Slight Insights

An interesting article on lwn.net : Why filesystem are hard.

I saw these messages during boot up on one of the linux servers that I was working on:

Scanning for LVM volume groups...
  Reading all physical volumes.  This may take a while...
  Couldn't find device with uuid 'flRhH7-5l8N
        -LWGG-2mUB-DeDZ-w4y0-Q0a6ib'.
  Couldn't find all physical volumes for volume group 
         VolGroup00.
  Couldn't find device with uuid 'flRhH7-5l8N
         -LWGG-2mUB-DeDZ-w4y0-Q0a6ib'.
  Couldn't find all physical volumes for volume group 
         VolGroup00.
  Volume group "VolGroup00" not found

Puzzled I checked out the "VolGroup00" volume group:

 #vgdisplay
  Couldn't find device with uuid 'flRhH7-5l8N
         -LWGG-2mUB-DeDZ-w4y0-Q0a6ib'.
  Couldn't find all physical volumes for volume group 
          VolGroup00.
  Couldn't find device with uuid 'flRhH7-5l8N
         -LWGG-2mUB-DeDZ-w4y0-Q0a6ib'.
  Couldn't find all physical volumes for volume group 
         VolGroup00.
  Volume group "VolGroup00" not found

Was the volume group corrupted? Then I figured it out. It wasn't. This volume group had a number of phyiscal volumes removed that was removed a few days ago but its metadata were still pointing to the removed PVs. This fixed the problem:

# vgreduce  --removemissing VolGroup00

Ever since Mandelbrot sets (http://en.wikipedia.org/wiki/Mandelbrot_set) were discovered, people have been fascinated by the fractal imageries that they give birth to. Well, now with the advent of newer and more powerful computers, someone has finally rendered 3D Mandelbrot sets:

You can see more here.

Saw this interesting tech tip (from Rich Lundeen) in the September edition of Linux Journal:
You can test if a process ID is valid with kill -0:

# kill -0 517 ----- where PID 517 is the udevd process on my PC now
# echo $?
0

Signal 0 is special so kill -0 does not terminate the process. The return status can be used to determine
whether a process is running. If the process is still running, the status is 0.
This method is much easier than parsing the ps command.
Also many processes save their PID at /var/run in a file. So you can use those to test them:

# kill -0 $(cat /var/run/cupsd.pid)

Had a look at grub-install today. It's the script that installs GRUB (GRand Unified Bootloader) which
is used by just about every open source OS during boot up. Here's what I found:

- It's a 650+ line shell script

- Well written. Some useful gems in there.

- Essentially a wrapper around the GRUB shell program (/sbin/grub). Adds error checking and
gives a more user-friendly way to install GRUB.

- The main function is install_boot_block() which installs GRUB:


install_boot_block () {
# Before all invocations of the grub shell, call sync to make sure
# the raw device is in sync with any bufferring in filesystems.
sync

# Now perform the installation.
$grub_shell --batch $no_floppy --device-map=$device_map <>$log_file
root $1
setup $force_lba --stage2=$grubdir/stage2 --prefix=$grub_prefix $2
quit
EOF
}

- On my Fedora box, the images are actually stored at /usr/share/grub and grub-install will copy the images from
there to the /boot/grub directory

- These images are very likely the binary files that contain executable code for the bootloading functionalities.
I am quite certain the 512byte /boot/grub/stage1 is the part of the bootloader that lives in the Master Boot Record (MBR)
The main purpose of this stage1 bootloader is to load the the stage 2 bootloader (/boot/grub/stage2) which is the
GRUB bootloader proper.

Came across this interesting blog post of about a high performance chat server implemented with Java:

http://mailinator.blogspot.com/2008/08/benchmarking-talkinator.html

Also interesting is this post:

http://mailinator.blogspot.com/2007/01/architecture-of-mailinator.html

"How many POSIX ACL can you set on a file in Linux?" a manager once asked me that at work. Someone wanted to implement Linux ACLs for their IT systems and he needed to know the limits of ACL. I had to admit I didn't know and apparently no one knew either. At time the time I could not give a good answer because I had no time and had no access to a test system. But the question intrigued me and so I am attempting to find a better answer here.

Actually there's no fixed answer. That's because the limit on the number of ACL entries is determined by the blocksize of your filesystem and the types of ACLs being stored. On the ext2/3 filesystem, ACLs are implemented using extended attributes. The kernel code for extended attributes is here. The leading comments gives hints  on how ACLs are stored. But even knowing how ACLs are stored, it is still not possible to give an exact answer. It's probably possible to come up with a formula but a more practical way would be to estimate with a simple script like this one:

#!/usr/bin/python  
    import os      
    i=1  
    status=0  
    while status == 0:  
         username = "u" + str(i)  
         print username  
         os.system("useradd " + username);  
         status = os.system("setfacl -m user:"+ username + ":rw- testacl.txt");  
         i+=1

This script attempts to set as many user acl on the file called testacl.txt as possible. On my Fedora Core system
using a Ext3 filesystem with 4KB block size, I could set up to 496 individual ACLs. The same for group ACLs.
This is way more than would ever be needed. A rule of thumb is around 20 max. Beyond that things will get complicated.