Day 3 - Disk, LVM, and Permission Task Questions: Solving Scenarios in Command Order

📌 Key Points

• In task-style questions, a wrong order ruins everything. Memorize the whole sequence, not a single command.
• Four steps to add a disk: partition (fdisk) → format (mkfs) → mount (mount) → register in fstab. If the requirement says "persists after reboot", fstab is mandatory.
• LVM is built in the order pvcreate → vgcreate → lvcreate, and removed in the reverse order.
• Capacity expansion is vgextend (grow the pool) → lvextend (grow the LV) → resize2fs/xfs_growfs (grow the filesystem). If you skip the last step, the capacity does not increase.
• umask is a mask subtracted from the defaults - from 666 for files and 777 for directories. 022 → 644 / 755.
• Special permissions: SetUID 4000 (run with the owner's privileges), SetGID 2000 (group inheritance), Sticky 1000 (delete only your own files). /tmp=1777, passwd=4755.

General Disk Work: Partition → Filesystem → Mount → fstab

• This is the standard four-step flow for adding a new disk /dev/sdb and mounting it on /data.

# [Step 0] Confirm the disk is recognized
fdisk -l                 # list all disks and partitions
lsblk                    # view block devices as a tree
 
# [Step 1] Create a partition (fdisk or parted)
fdisk /dev/sdb
# Interactive: n (new partition) → p (primary) → number → size → w (write)
 
# [Step 2] Create a filesystem (format)
mkfs -t ext4 /dev/sdb1   # format as ext4
mkfs.ext4 /dev/sdb1      # same as above
mkfs -t xfs /dev/sdb1    # format as xfs
mkfs.xfs /dev/sdb1       # same as above
 
# [Step 3] Create a mount point and mount
mkdir /data
mount /dev/sdb1 /data    # temporary mount (lost on reboot)
mount -t ext4 /dev/sdb1 /data   # specify the type
 
# [Step 4] Register in fstab (persistent mount)
# Add to /etc/fstab:
# /dev/sdb1   /data   ext4   defaults   0 2
mount -a                 # re-mount everything in fstab (also validates syntax)
df -h                    # check the mount result

The "add a disk and mount it" task always follows the order partition → format (mkfs) → mount (mount) → register in fstab. If any one of these four steps is missing, the task is incomplete. In particular, if the requirement says "persists after reboot", you must go all the way to the fstab registration.

⚠️ Trap: You format the partition (/dev/sdb1), not the whole disk (/dev/sdb). Also, mount alone is lost on reboot - a persistent mount requires registration in /etc/fstab. mount -a re-mounts every entry in fstab, so use it to verify after writing fstab.

# Create a swap partition/file
mkswap /dev/sdb2         # create the swap area
swapon /dev/sdb2         # activate swap
swapon -s                # list active swap
free -h                  # memory and swap usage
# fstab: /dev/sdb2  none  swap  sw  0 0

To check mount information, use mount (current mount list), df -h (capacity and usage), lsblk (device tree), and blkid (UUID and type). To mount by UUID, find the UUID with blkid and write it in fstab in the form UUID=.... Device names (/dev/sdb1) can change when disks are added, so UUIDs are safer.

LVM Work: PV → VG → LV → Expansion

• LVM is a layered structure for flexibly combining and dividing disks.
• You stack it in the order physical volume (PV) → volume group (VG) → logical volume (LV).

# [Step 1] Create physical volumes (PV) - initialize disks/partitions for LVM
pvcreate /dev/sdb /dev/sdc
pvscan                   # PV list
pvdisplay                # PV details
 
# [Step 2] Create a volume group (VG) - combine the PVs into one
vgcreate vg_data /dev/sdb /dev/sdc
vgscan
vgdisplay                # VG details (check free space)
 
# [Step 3] Create a logical volume (LV) - carve it out of the VG
lvcreate -L 10G -n lv_app vg_data    # create a 10GB lv_app
lvcreate -l 100%FREE -n lv_all vg_data  # all remaining space
lvscan
lvdisplay                # LV details, path is /dev/vg_data/lv_app
 
# [Step 4] Create a filesystem + mount
mkfs -t ext4 /dev/vg_data/lv_app
mkdir /app
mount /dev/vg_data/lv_app /app
# fstab: /dev/vg_data/lv_app  /app  ext4  defaults  0 2

The LVM creation order is pvcreate → vgcreate → lvcreate. The command prefixes pv, vg, and lv indicate the layer. Create from top to bottom (PV→VG→LV), and remove in reverse (LV→VG→PV).

• LVM's strength is online expansion without downtime.

# Add a new disk (PV) to the VG
pvcreate /dev/sdd
vgextend vg_data /dev/sdd    # add the PV to the VG (expand capacity)
 
# Grow the LV
lvextend -L +5G /dev/vg_data/lv_app      # add 5GB
lvextend -L 20G /dev/vg_data/lv_app      # make it 20GB total
lvextend -l +100%FREE /dev/vg_data/lv_app  # all remaining space
 
# ★ After growing the LV, you must also grow the filesystem for the capacity to actually increase
resize2fs /dev/vg_data/lv_app    # for ext2/3/4
xfs_growfs /app                  # for xfs (specify the mount point)
 
# In one step: the lvextend -r option (automatic resize)
lvextend -L +5G -r /dev/vg_data/lv_app

The command to extend an LV is lvextend. However, growing only the LV leaves the filesystem unchanged, so you must also grow the filesystem - resize2fs for ext family, xfs_growfs for xfs - for the capacity to actually show up. Missing this "two-step" process is the classic mistake. Using lvextend -r handles the resize automatically.

⚠️ Trap: Extending a VG is vgextend (adding a PV), and extending an LV is lvextend. The names are similar, which causes confusion. vgextend grows the pool, and lvextend grows the logical disk. Another trap is that xfs cannot be shrunk (no shrinking) and can only be grown.

Permission Task Questions: umask / Special Permissions

umask: Controlling Default Permissions of New Files and Directories

• umask specifies the bits to remove from the permissions of newly created files and directories.

umask              # print the current umask (e.g. 0022)
umask 022          # set umask
umask 027          # stricter
 
# Calculation: subtract umask from the file default 666 and directory default 777
# umask 022 → file 644 (rw-r--r--), directory 755 (rwxr-xr-x)
# umask 077 → file 600 (rw-------), directory 700 (rwx------)

umask is a "mask that is subtracted from the default permissions". For files, subtract the umask from 666; for directories, from 777. With umask 022, a file becomes 666-022=644 and a directory 777-022=755. The reason files don't get the execute bit (x) by default is that the starting value is 666.

Special Permissions: SetUID / SetGID / Sticky bit

• Three special permissions added on top of regular rwx are tested in the practical exam.

# SetUID (4000) - runs with the file owner's privileges when executed
chmod 4755 /path/program     # rwsr-xr-x
chmod u+s /path/program      # symbolic form
# e.g. /usr/bin/passwd (lets regular users modify shadow)
 
# SetGID (2000) - runs with group privileges / on a directory, inherits the group
chmod 2755 /path/program     # rwxr-sr-x
chmod g+s /shared_dir        # directory: new files inherit the group
# e.g. keep the team group in a shared directory
 
# Sticky bit (1000) - directory: only the owner can delete their own files
chmod 1777 /tmp              # rwxrwxrwt
chmod +t /shared_dir         # symbolic form
# e.g. /tmp (anyone can write, but cannot delete others' files)

• In ls -l, you tell them apart by the permission characters.
• -rwsr-xr-x → SetUID (s in the owner x position)
• -rwxr-sr-x → SetGID (s in the group x position)
• drwxrwxrwt → Sticky bit (t in the others x position)

The special-permission octal adds one more digit in front of the regular permissions. In chmod 4755, the leading 4 is SetUID, 2 is SetGID, and 1 is the Sticky bit. /tmp is 1777 (Sticky), and /usr/bin/passwd is 4755 (SetUID).

If you see an uppercase S/T (e.g. rwSr--r--), it means the special bit is set at that position without the execute permission (x), which is usually an unintended setting. A lowercase s/t is the normal state where the execute permission is also present.

Try It Yourself

# Check disk status (safe query commands)
lsblk
df -h
blkid
mount | column -t
 
# Check LVM status (on an environment with LVM installed)
pvscan; vgscan; lvscan
vgdisplay 2>/dev/null
 
# umask experiment
umask                    # check the current value
mkdir testdir && touch testfile
ls -ld testdir testfile  # check permissions
umask 077
mkdir testdir2 && touch testfile2
ls -ld testdir2 testfile2  # check the stricter permissions
 
# Check special permissions
ls -l /usr/bin/passwd    # rwsr-xr-x (SetUID)
ls -ld /tmp              # rwxrwxrwt (Sticky)

Task Order Memorization Cards

Don't skip the command prefixes (pv/vg/lv) or the finishing steps (fstab, resize2fs) of each stage. Tomorrow we fill in the other half of system administration with process, scheduling, and systemd task questions.

📖 Glossary

• fdisk : An interactive tool that divides a disk into partitions. Use n (create) → w (write) in that order.
• mkfs : The command that creates (formats) a filesystem on a partition. Run it on a partition, not the whole disk.
• fstab registration : The last step that makes a filesystem mount automatically at boot. Without it, the mount disappears on reboot.
• mount -a : Re-mounts every entry in /etc/fstab. Use it to validate syntax after editing fstab.
• blkid : The command that shows a device's UUID and filesystem type. Needed when writing fstab with UUIDs instead of device names.
• PV (physical volume) : A disk or partition initialized so LVM can use it. Created with pvcreate.
• VG (volume group) : A storage pool combining several PVs. Created with vgcreate and grown with vgextend.
• LV (logical volume) : A logical disk carved out of a VG. Created with lvcreate and grown with lvextend.
• resize2fs / xfs_growfs : Commands that grow the filesystem on top after growing the LV (ext family / xfs).
• umask : The bits removed from the default permissions of newly created files and directories. The starting values are 666 for files and 777 for directories.
• SetUID : A bit (4000) that makes a program run with the privileges of the file owner rather than the executor. The passwd command is the classic example.
• SetGID : A bit (2000) that uses group privileges at execution, or, when set on a directory, makes new files inherit that directory's group.
• Sticky bit : A bit (1000) set on a directory so that only your own files can be deleted. /tmp is the classic example.