4.1.1. The MAKEDEV Script

Most device files will already be created and will be there ready to use after you install your Linux system. If by some chance you need to create one which is not provided then you should first try to use the MAKEDEV script. This script is usually located in /dev/MAKEDEV but might also have a copy (or a symbolic link) in /sbin/MAKEDEV. If it turns out not to be in your path then you will need to specify the path to it explicitly.

In general the command is used as:

	# /dev/MAKEDEV -v ttyS0  	create ttyS0   c 4 64 root:dialout 0660 	

ttyS0 is a serial port. The major and minor node numbers are numbers understood by the kernel. The kernel refers to hardware devices as numbers, this would be very difficult for us to remember, so we use filenames. Access permissions of 0660 means read and write permission for the owner (root in this case) and read and write permission for members of the group (dialout in this case) with no access for anyone else.

4.1.2. The mknod command

MAKEDEV is the preferred way of creating device files which are not present. However sometimes the MAKEDEV script will not know about the device file you wish to create. This is where the mknod command comes in. In order to use mknod you need to know the major and minor node numbers for the device you wish to create. The devices.txt file in the kernel source documentation is the canonical source of this information.

To take an example, let us suppose that our version of the MAKEDEV script does not know how to create the /dev/ttyS0 device file. We need to use mknod to create it. We know from looking at the devices.txt that it should be a character device with major number 4 and minor number 64. So we now know all we need to create the file.

	# mknod /dev/ttyS0 c 4 64  	# chown root.dialout /dev/ttyS0 	# chmod 0644 /dev/ttyS0 	# ls -l /dev/ttyS0 		crw-rw----   1 root dialout    4,   64 Oct 23 18:23 /dev/ttyS0 	  	

4.1.3. The lspci command

lspci

TO BE ADDED

4.1.4. The lsdev command

lsdev

TO BE ADDED

4.1.5. The lsusb command

lsusb

TO BE ADDED

4.1.6. The lsraid command

lsraid

TO BE ADDED

4.1.7. The hdparm command

hdparm

TO BE ADDED

4.1.8. More Hardware Resources

More information on what hardware resources the kernel is using can be found in the /proc directory. Refer to http://www.winehq.com for more information.

There is also VMWare, a commercial product, which emulates an entire x86 machine in software. See the VMWare website, http://www.vmware.com for more information.

A CD-ROM drive is accessed via the corresponding device file. There are several ways to connect a CD-ROM drive to the computer: via SCSI, via a sound card, or via EIDE. The hardware hacking needed to do this is outside the scope of this book, but the type of connection decides the device file.

Figure 5-2. The disk is divided into three primary partitions, the second of which is divided into two logical partitions. Part of the disk is not partitioned at all. The disk as a whole and each primary partition has a boot sector.

Figure 5-2. A sample hard disk partitioning.

5.9.3. Partition types

The partition tables (the one in the MBR, and the ones for extended partitions) contain one byte per partition that identifies the type of that partition. This attempts to identify the operating system that uses the partition, or what it uses it for. The purpose is to make it possible to avoid having two operating systems accidentally using the same partition. However, in reality, operating systems do not really care about the partition type byte; e.g., Linux doesn't care at all what it is. Worse, some of them use it incorrectly; e.g., at least some versions of DR-DOS ignore the most significant bit of the byte, while others don't.

There is no standardization agency to specify what each byte value means, but as far as Linux is concerned, here is a list of partition types as per the fdisk program.

 0  Empty           1c  Hidden Win95 FA 70  DiskSecure Mult bb  Boot Wizard hid  1  FAT12           1e  Hidden Win95 FA 75  PC/IX           be  Solaris boot  2  XENIX root      24  NEC DOS         80  Old Minix       c1  DRDOS/sec (FAT-  3  XENIX usr       39  Plan 9          81  Minix / old Lin c4  DRDOS/sec (FAT-  4  FAT16 <32M      3c  PartitionMagic  82  Linux swap      c6  DRDOS/sec (FAT-  5  Extended        40  Venix 80286     83  Linux           c7  Syrinx  6  FAT16           41  PPC PReP Boot   84  OS/2 hidden C:  da  Non-FS data  7  HPFS/NTFS       42  SFS             85  Linux extended  db  CP/M / CTOS / .  8  AIX             4d  QNX4.x          86  NTFS volume set de  Dell Utility  9  AIX bootable    4e  QNX4.x 2nd part 87  NTFS volume set df  BootIt  a  OS/2 Boot Manag 4f  QNX4.x 3rd part 8e  Linux LVM       e1  DOS access  b  Win95 FAT32     50  OnTrack DM      93  Amoeba          e3  DOS R/O  c  Win95 FAT32 (LB 51  OnTrack DM6 Aux 94  Amoeba BBT      e4  SpeedStor  e  Win95 FAT16 (LB 52  CP/M            9f  BSD/OS          eb  BeOS fs  f  Win95 Ext'd (LB 53  OnTrack DM6 Aux a0  IBM Thinkpad hi ee  EFI GPT 10  OPUS            54  OnTrackDM6      a5  FreeBSD         ef  EFI (FAT-12/16/ 11  Hidden FAT12    55  EZ-Drive        a6  OpenBSD         f0  Linux/PA-RISC b 12  Compaq diagnost 56  Golden Bow      a7  NeXTSTEP        f1  SpeedStor 14  Hidden FAT16 <3 5c  Priam Edisk     a8  Darwin UFS      f4  SpeedStor 16  Hidden FAT16    61  SpeedStor       a9  NetBSD          f2  DOS secondary 17  Hidden HPFS/NTF 63  GNU HURD or Sys ab  Darwin boot     fd  Linux raid auto 18  AST SmartSleep  64  Novell Netware  b7  BSDI fs         fe  LANstep 1b  Hidden Win95 FA 65  Novell Netware  b8  BSDI swap       ff  BBT

5.9.4. Partitioning a hard disk

There are many programs for creating and removing partitions. Most operating systems have their own, and it can be a good idea to use each operating system's own, just in case it does something unusual that the others can't. Many of the programs are called fdisk, including the Linux one, or variations thereof. Details on using the Linux fdisk given on its man page. The cfdisk command is similar to fdisk, but has a nicer (full screen) user interface.

When using IDE disks, the boot partition (the partition with the bootable kernel image files) must be completely within the first 1024 cylinders. This is because the disk is used via the BIOS during boot (before the system goes into protected mode), and BIOS can't handle more than 1024 cylinders. It is sometimes possible to use a boot partition that is only partly within the first 1024 cylinders. This works as long as all the files that are read with the BIOS are within the first 1024 cylinders. Since this is difficult to arrange, it is a very bad idea to do it; you never know when a kernel update or disk defragmentation will result in an unbootable system. Therefore, make sure your boot partition is completely within the first 1024 cylinders.

However, this may no longer be true with newer versions of LILO that support LBA (Logical Block Addressing). Consult the documentation for your distribution to see if it has a version of LILO where LBA is supported.

Some newer versions of the BIOS and IDE disks can, in fact, handle disks with more than 1024 cylinders. If you have such a system, you can forget about the problem; if you aren't quite sure of it, put it within the first 1024 cylinders.

Each partition should have an even number of sectors, since the Linux filesystems use a 1 kilobyte block size, i.e., two sectors. An odd number of sectors will result in the last sector being unused. This won't result in any problems, but it is ugly, and some versions of fdisk will warn about it.

Changing a partition's size usually requires first backing up everything you want to save from that partition (preferably the whole disk, just in case), deleting the partition, creating new partition, then restoring everything to the new partition. If the partition is growing, you may need to adjust the sizes (and backup and restore) of the adjoining partitions as well.

Since changing partition sizes is painful, it is preferable to get the partitions right the first time, or have an effective and easy to use backup system. If you're installing from a media that does not require much human intervention (say, from CD-ROM, as opposed to floppies), it is often easy to play with different configuration at first. Since you don't already have data to back up, it is not so painful to modify partition sizes several times.

There is a program for MS-DOS, called fips , which resizes an MS-DOS partition without requiring the backup and restore, but for other filesystems it is still necessary.

The fips program is included in most Linux distributions. The commercial partition manager ``Partition Magic'' also has a similar facility but with a nicer interface. Please do remember that partitioning is dangerous. Make sure you have a recent backup of any important data before you try changing partition sizes ``on the fly''. The program parted can resize other types of partitions as well as MS-DOS, but sometimes in a limited manner. Consult the parted documentation before using it, better safe than sorry.

5.9.5. Device files and partitions

Each partition and extended partition has its own device file. The naming convention for these files is that a partition's number is appended after the name of the whole disk, with the convention that 1-4 are primary partitions (regardless of how many primary partitions there are) and number greater than 5 are logical partitions (regardless of within which primary partition they reside). For example, /dev/hda1 is the first primary partition on the first IDE hard disk, and /dev/sdb7 is the third extended partition on the second SCSI hard disk.

5.10.1. What are filesystems?

A filesystem is the methods and data structures that an operating system uses to keep track of files on a disk or partition; that is, the way the files are organized on the disk. The word is also used to refer to a partition or disk that is used to store the files or the type of the filesystem. Thus, one might say ``I have two filesystems'' meaning one has two partitions on which one stores files, or that one is using the ``extended filesystem'', meaning the type of the filesystem.

The difference between a disk or partition and the filesystem it contains is important. A few programs (including, reasonably enough, programs that create filesystems) operate directly on the raw sectors of a disk or partition; if there is an existing file system there it will be destroyed or seriously corrupted. Most programs operate on a filesystem, and therefore won't work on a partition that doesn't contain one (or that contains one of the wrong type).

Before a partition or disk can be used as a filesystem, it needs to be initialized, and the bookkeeping data structures need to be written to the disk. This process is called making a filesystem.

Most UNIX filesystem types have a similar general structure, although the exact details vary quite a bit. The central concepts are superblock, inode , data block, directory block , and indirection block. The superblock contains information about the filesystem as a whole, such as its size (the exact information here depends on the filesystem). An inode contains all information about a file, except its name. The name is stored in the directory, together with the number of the inode. A directory entry consists of a filename and the number of the inode which represents the file. The inode contains the numbers of several data blocks, which are used to store the data in the file. There is space only for a few data block numbers in the inode, however, and if more are needed, more space for pointers to the data blocks is allocated dynamically. These dynamically allocated blocks are indirect blocks; the name indicates that in order to find the data block, one has to find its number in the indirect block first.

UNIX filesystems usually allow one to create a hole in a file (this is done with the lseek() system call; check the manual page), which means that the filesystem just pretends that at a particular place in the file there is just zero bytes, but no actual disk sectors are reserved for that place in the file (this means that the file will use a bit less disk space). This happens especially often for small binaries, Linux shared libraries, some databases, and a few other special cases. (Holes are implemented by storing a special value as the address of the data block in the indirect block or inode. This special address means that no data block is allocated for that part of the file, ergo, there is a hole in the file.)

5.10.2. Filesystems galore

Linux supports several types of filesystems. As of this writing the most important ones are:

In addition, support for several foreign filesystems exists, to make it easier to exchange files with other operating systems. These foreign filesystems work just like native ones, except that they may be lacking in some usual UNIX features, or have curious limitations, or other oddities.

The choice of filesystem to use depends on the situation. If compatibility or other reasons make one of the non-native filesystems necessary, then that one must be used. If one can choose freely, then it is probably wisest to use ext3, since it has all the features of ext2, and is a journaled filesystem. For more information on filesystems, see Section 5.10.6. You can also read the Filesystems HOWTO located at 5.7. Tapes

A tape drive uses a tape, similar to cassettes used for music. A tape is serial in nature, which means that in order to get to any given part of it, you first have to go through all the parts in between. A disk can be accessed randomly, i.e., you can jump directly to any place on the disk. The serial access of tapes makes them slow.

On the other hand, tapes are relatively cheap to make, since they do not need to be fast. They can also easily be made quite long, and can therefore contain a large amount of data. This makes tapes very suitable for things like archiving and backups, which do not require large speeds, but benefit from low costs and large storage capacities.

5.8. Formatting

Formatting is the process of writing marks on the magnetic media that are used to mark tracks and sectors. Before a disk is formatted, its magnetic surface is a complete mess of magnetic signals. When it is formatted, some order is brought into the chaos by essentially drawing lines where the tracks go, and where they are divided into sectors. The actual details are not quite exactly like this, but that is irrelevant. What is important is that a disk cannot be used unless it has been formatted.

The terminology is a bit confusing here: in MS-DOS and MS Windows, the word formatting is used to cover also the process of creating a filesystem (which will be discussed below). There, the two processes are often combined, especially for floppies. When the distinction needs to be made, the real formatting is called low-level formatting, while making the filesystem is called high-level formatting . In UNIX circles, the two are called formatting and making a filesystem, so that's what is used in this book as well.

For IDE and some SCSI disks the formatting is actually done at the factory and doesn't need to be repeated; hence most people rarely need to worry about it. In fact, formatting a hard disk can cause it to work less well, for example because a disk might need to be formatted in some very special way to allow automatic bad sector replacement to work.

Disks that need to be or can be formatted often require a special program anyway, because the interface to the formatting logic inside the drive is different from drive to drive. The formatting program is often either on the controller BIOS, or is supplied as an MS-DOS program; neither of these can easily be used from within Linux.

During formatting one might encounter bad spots on the disk, called bad blocks or bad sectors. These are sometimes handled by the drive itself, but even then, if more of them develop, something needs to be done to avoid using those parts of the disk. The logic to do this is built into the filesystem; how to add the information into the filesystem is described below. Alternatively, one might create a small partition that covers just the bad part of the disk; this approach might be a good idea if the bad spot is very large, since filesystems can sometimes have trouble with very large bad areas.

Floppies are formatted with fdformat . The floppy device file to use is given as the parameter. For example, the following command would format a high density, 3.5 inch floppy in the first floppy drive:

	$ fdformat /dev/fd0H1440  	Double-sided, 80 tracks, 18 sec/track. Total capacity  	1440 kB. 	Formatting ... done 	Verifying ... done 	$ 	

	$ setfdprm /dev/fd0 1440/1440 	$ fdformat /dev/fd0 	Double-sided, 80 tracks, 18 sec/track. Total capacity  	1440 KB. 	Formatting ... done  	Verifying ... done 	$ 	

fdformatalso validate the floppy, i.e., check it for bad blocks. It will try a bad block several times (you can usually hear this, the drive noise changes dramatically). If the floppy is only marginally bad (due to dirt on the read/write head, some errors are false signals), fdformat won't complain, but a real error will abort the validation process. The kernel will print log messages for each I/O error it finds; these will go to the console or, if syslog is being used, to the file /var/log/messages. fdformat itself won't tell where the error is (one usually doesn't care, floppies are cheap enough that a bad one is automatically thrown away).

	$ fdformat /dev/fd0H1440 	Double-sided, 80 tracks, 18 sec/track. Total capacity  	1440 KB. 	Formatting ... done 	Verifying ... read: Unknown error 	$  	

	$ badblocks /dev/fd0H1440 1440 	718 	719  	$ 	

Many modern disks automatically notice bad blocks, and attempt to fix them by using a special, reserved good block instead. This is invisible to the operating system. This feature should be documented in the disk's manual, if you're curious if it is happening. Even such disks can fail, if the number of bad blocks grows too large, although chances are that by then the disk will be so rotten as to be unusable.

5.9. Partitions

A hard disk can be divided into several partitions. Each partition functions as if it were a separate hard disk. The idea is that if you have one hard disk, and want to have, say, two operating systems on it, you can divide the disk into two partitions. Each operating system uses its partition as it wishes and doesn't touch the other ones. This way the two operating systems can co-exist peacefully on the same hard disk. Without partitions one would have to buy a hard disk for each operating system.

Floppies are not usually partitioned. There is no technical reason against this, but since they're so small, partitions would be useful only very rarely. CD-ROMs are usually also not partitioned, since it's easier to use them as one big disk, and there is seldom a need to have several operating systems on one.

	$ fdisk -l /dev/hda  	 	Disk /dev/hda: 15 heads, 57 sectors, 790 cylinders 	Units = cylinders of 855 * 512 bytes 	 	   Device Boot  Begin   Start     End  Blocks   Id  System 	/dev/hda1           1       1      24   10231+  82  Linux swap  	/dev/hda2          25      25      48   10260   83  Linux native 	/dev/hda3          49      49     408  153900   83  Linux native 	/dev/hda4         409     409     790  163305    5  Extended 	/dev/hda5         409     409     744  143611+  83  Linux native 	/dev/hda6         745     745     790   19636+  83  Linux native 	$  	

$ ls -l /proc total 0 dr-xr-xr-x   4 root     root            0 Jan 31 20:37 1 dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 63 dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 94 dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 95 dr-xr-xr-x   4 root     users           0 Jan 31 20:37 98 dr-xr-xr-x   4 liw      users           0 Jan 31 20:37 99 -r--r--r--   1 root     root            0 Jan 31 20:37 devices -r--r--r--   1 root     root            0 Jan 31 20:37 dma -r--r--r--   1 root     root            0 Jan 31 20:37 filesystems -r--r--r--   1 root     root            0 Jan 31 20:37 interrupts -r--------   1 root     root      8654848 Jan 31 20:37 kcore -r--r--r--   1 root     root            0 Jan 31 11:50 kmsg -r--r--r--   1 root     root            0 Jan 31 20:37 ksyms -r--r--r--   1 root     root            0 Jan 31 11:51 loadavg -r--r--r--   1 root     root            0 Jan 31 20:37 meminfo -r--r--r--   1 root     root            0 Jan 31 20:37 modules dr-xr-xr-x   2 root     root            0 Jan 31 20:37 net dr-xr-xr-x   4 root     root            0 Jan 31 20:37 self -r--r--r--   1 root     root            0 Jan 31 20:37 stat -r--r--r--   1 root     root            0 Jan 31 20:37 uptime -r--r--r--   1 root     root            0 Jan 31 20:37  version $

$ fdformat -n /dev/fd0H1440 Double-sided, 80 tracks, 18 sec/track. Total capacity  1440 KB. Formatting ... done  $ badblocks /dev/fd0H1440 1440 $>$  bad-blocks $ mkfs.ext2 -l bad-blocks  /dev/fd0H1440 mke2fs 0.5a, 5-Apr-94 for EXT2 FS 0.5, 94/03/10 360 inodes, 1440 blocks 72 blocks (5.00%) reserved for the super user First data block=1 Block size=1024 (log=0) Fragment size=1024 (log=0) 1 block group 8192 blocks per group, 8192 fragments per group 360 inodes per group  Writing inode tables: done Writing superblocks and filesystem accounting information:  done $

$ mkfs.ext2 -c  /dev/fd0H1440 mke2fs 0.5a, 5-Apr-94 for EXT2 FS 0.5, 94/03/10 360 inodes, 1440 blocks 72 blocks (5.00%) reserved for the super user First data block=1 Block size=1024 (log=0) Fragment size=1024 (log=0) 1 block group 8192 blocks per group, 8192 fragments per group 360 inodes per group  Checking for bad blocks (read-only test): done Writing inode tables: done Writing superblocks and filesystem accounting information:  done $