How does Linux, the kernel, mount filesystems? What actually does this

A filesystem is both a reference to a tree structure of directories and files as well as a overarching structure that can be placed on a physical medium such as a hard drive or other similar types of medium.

At the end of of the day they're both layers of abstraction that people create so that things are standardized.

The directories + files analogy used is to mimic how people think, with respect to the physical world for storing items (files) inside of something (folders).

So too is a filesystem such as ext4 of fat32. Here it might not be so obvious, but the structure that this type of filesystem provides serves the same purpose, just at a lower level.

For example, a raw disk is just a sequence of bits. By creating a structure on top of it using inodes, we're able to access sections of the disk in an organized methodical fashion.

Notice the image of the inode structure (from wikipedia article titled: inode pointer structure

The structure of a filesystem representing files + directories

computer architectures

One thing you'll notice as you continue to study computer architectures is that the same concepts are used over and over again. The notion of hostnames is nested too.

                                   .---> <-----.
                                   |           |
                               .------.    .------.
                 ^------------>| .com |    | .net |
                 |             '------'    '------'
                 |                 ^
                 |                 |
             .--------.    .---------------.
             | google |    | stackexchange |
             '--------'    '---------------'
                  ^                ^
                  |                |
               .-----.          .------.
               | www |          | unix |
               '-----'          '------'

Or in programming, class inheritance (Ruby):

class Mammal  
  def breathe  
    puts "inhale and exhale"  
  end  
end  


class Cat < Mammal  
  def speak  
    puts "Meow"  
  end  
end  

jake = Cat.new  
jake.breathe  
jake.speak  

All three data journaling modes should leave the filesystem itself fully intact after a power failure. So it should always mount without errors. The difference is only in the data in your files; data=writeback mode may leave stale data (i.e., what was stored in the disk sectors before the writes your app did). data=ordered and data=journaled should not do this.

Most likely what you're seeing is that I/O barriers aren't working on your setup. First, make sure you're not mounting with barrier=0/nobarrier. That boosts performance, but will cause corruption on power failure.

If I/O barriers are on, it's also possible you're passing through a storage layer that doesn't support them. On older releases, LVM didn't and various mdraid levels didn't. (This was fixed in Linux 2.6.33; so only if you're running Lucid still.)

Finally, it's possible your disks are telling lies. Disks have write caches. Especially with NCQ, they're supposed to only tell the OS they've written data when they've actually done so, but they've been known to tell the OS its written when its only in the disk's write cache. Increases performance. At least as long as the power stays on. You can try disabling the write cache on the disks, though you'll take a performance hit for this.

Note also that flash-memory disks have a lot of work to do under the hood, and many of them don't handle power failure well. (For example, wear leveling sometimes requires that a full flash block of data be moved. If the power fails in the middle, bad things happen on some flash disks.)

Finally... have you considered an UPS?