In today’s Linux distributions, mounting is usually done automatically. I never had to mount anything manually on my personal computer. However, sometimes you will have to mount something (or a tutorial will ask you to do so), so here is how it is done:
mount -t type device mountpoint
As we can see, it is done with the mount where type is the filesystem type (ex4, FAT, NTFS, …), device is the device file (remember the /dev folder discussion) and the mountpoint is the point in our Linux directory structure where we want to place the device (the device’s storage). (Ward, 2014)
Now you know how to mount a device. Again, you will rarely ever do this, but when you do, you know what you’re doing and what each of those arguments to the mount command mean. Sounds like you had a great Linux teacher!
Thank you for reading!
Ward, B. (2014). How Linux Works: What Every Superuser Should Know (2nd ed.). No Starch Press. Page 76
Today we will talk about something more conceptual yet again. I know that you might be thinking: “Why this conceptual stuff again? It’s been a lot of that lately and I’m tired of that…”. I get it. But be patient – this knowledge will pay off. I am trimming the fat – the things you don’t need to know – but it pays to know these particular concepts. Especially mounting and unmounting because even though you’ll probably never do those manually, there will be some situations where you will have to mount or unmount (an example – “burning” an operating system on an USB) and you have to know what is going on.
Still with me? Good. So what is mounting? Mounting is the process of attaching your device(your device’s storage)in the Linux directory structure. As we know, everything in Linux starts from the root folder (/). Every other directory is accessible from the root folder by navigating from the root folder to the other folders hierarchically below it. When you insert a new device (say, a USB drive) you have to place it in a directory so that it is accessible from the root directory. The directory in which the new device resides is called its mount point. That process (when you assign a directory accessible from the root folder to a new device) is called mounting. Unmounting is the reverse process from mounting – removing the association between a directory in the directory hierarchy and the device (device’s storage).
So basically, when you mount, you make your device’s storage accessible to your Linux computer and when you unmount, you make your device’s storage inaccessible. Not all devices that are mounted need to have storage, but that doesn’t matter for our practical applications. (“What is meant by mounting a device in Linux?,” n.d.)
I modeled my explanation after (“understanding ‘mount’ as a concept in the OS [duplicate],” n.d.) , which you can read as well for a second perspective.
Device files are files that are actually device I/O (input/output) interfaces. (Ward, 2014) If you take the trip back down the memory lane, when I was explaining what each Linux directory is for, I said that /dev contains files which represent devices. They are located in the /dev folder. They can also be called device nodes.
Let’s see what I get with ls -l when I go to /dev:
mislav@mislavovo-racunalo:/dev$ ls -l
crw-r--r-- 1 root root 10, 235 Jan 2 18:11 autofs
drwxr-xr-x 2 root root 280 Feb 12 07:48 block
drwxr-xr-x 2 root root 60 Feb 12 07:48 bsg
crw-rw---- 1 root disk 10, 234 Feb 11 16:19 btrfs-control
drwxr-xr-x 3 root root 60 Nov 9 17:37 bus
drwxr-xr-x 2 root root 3520 Feb 12 07:48 char
crw------- 1 root root 5, 1 Jan 2 18:11 console
A bunch of files representing devices.
There is a special “device” called /dev/null, which doesn’t represent any device, but rather, it represents “void”. If you send any data to it, as in:
mislav@mislavovo-racunalo:/dev$ ls -l > /dev/null
nothing happens. More specifically, the kernel ignores the information sent to /dev/null.
One important thing to note is that not all devices are represented with device files.
Hope you learned something new!
Ward, B. (2014). How Linux Works: What Every Superuser Should Know (2nd ed.). No Starch Press. Page 46
Look at the second column. It now says that link count for ab.txt is 2, while link count for a.txt is 1. How can this be? Shouldn’t link count for both ab.txt and a.txt be 2?
No, because hard links point to the underlying data and symbolic links are like shortcuts (shortcuts you may have used in Windows). So hard links point to the underlying data (which is an inode), while symbolic links point to the file.
I think that the difference is best explained with this figure, modeled after (“What is the difference between a hard link and a symbolic link?,” n.d.).
Here’s what happens when we rename ab.txt (the one with the hard link):
Since symbolic links just point to the filename, our a-symbolic link is not working anymore. We now call it a broken link.
That’s it for today. Hope you learned something useful! Maybe you don’t see it yet, but when you will be dealing with broken links, it will pay greatly that you understand what is going on under the hood.
Link is a pointer to a file or a directory. If you are not a programmer, a pointer is exactly what its name says it is – it is used for pointing to something. Let’s look at the following situation:
mislav@mislavovo-racunalo:~/Linux_folder$ ls -l
-rw-r--r-- 1 mislav mislav 8 Feb 5 23:09 1264.txt
-rw-r--r-- 1 mislav mislav 8 Feb 5 23:06 1-4.txt~
-rw-r--r-- 1 mislav mislav 8 Feb 5 23:06 2345.txt
The number in the second column (after file permissions) is the link count. Why is this link count number equal to 1 for these files? Because the only link that exists at this time is the link which is pointing from Linux_folder to the file.
You can increase the number of links to a file and there are two types of links – only one type of link increases the link count. But that’s a topic for another article.
Thank you for reading and hope you learned something useful!
Let’s clear out one more conceptual thing before we jump into other things – how are files and directories represented internally.
See, a usual filesystem you will find on Linux consists of a pool of data blocks where you can store data and a database system that manages the data pool. The database contains entries which describe the file type, file permissions and where the file is stored in the data pool. (Ward, 2014) These database entries are called inodes. Interestingly, the inodes don’t store the file name. (“Where are filenames stored on a filesystem?,” n.d.)
Files and directories are represented as inodes. This is imporant to keep in mind as we progress, although in my explanations I try to review some key concepts before explaining new ones.
Hope you learned something new!
Ward, B. (2014). How Linux Works: What Every Superuser Should Know (2nd ed.). No Starch Press. Page 87
Today let’s talk about the thing that bothered me for some time. What is a partition exactly? What is a filesystem, exactly? How do they relate to each other?
Let’s go top-down, from the biggest to the smallest. First, the hardware – the permanent storage devices. There are many permanent storage devices, but let’s focus on the ones most people use in their computer for permanent storage. They can be either hard drives or solid state drives. Permanent storage device is the physical device your data is stored on. Again, the term also includes USB drives, CDs and DVDs, but let’s focus on hard drives and solid state drives. Let’s call them disks.
Partitions are subdivisions of the whole disk. A disk can, thus, be divided into multiple partitions. Partitions are defined on a small area of the disk called a partition table. (Ward, 2014)
Every partition has a filesystem. A filesystem is a hierarchy of files and directories you are accustomed to interacting with. A filesystem resembles a database. A great illustration of this is in the figure below, modeled after (Ward, 2014), page 66.
If we want to access a file, we first consult the partition table to see which partition we need to access. Then after we access that partition, we consult the filesystem database to find the data we are looking for.
I think this is important to understand conceptually, as there is a lot of confusion between what is a partition and what is a filesystem. I hope this cleared it up.
Thank you for reading!
Ward, B. (2014). How Linux Works: What Every Superuser Should Know (2nd ed.). No Starch Press. Pages 66-67
Next up, we will talk about devices at a low-level. More specifically, we will talk about how are devices represented in your Linux system, what are links, what is mounting, what is unmounting and some other things related to devices which are not as important, but warrant a quick read.
This is not really important for your everyday use, but you will almost guaranteed encounter some device-related things (especially if you are a software developer), so it pays to know these things in those moments. And yes, even if you are a regular user, it pays to know these things. So read on. Don’t lose your enthusiasm – you are still learning the fundamental things.