I've been looking at the boot and shutdown timing of our boot scripts.

For boot, it seems that most of the time is taken with 'udevadm settle'. 
  When I instrumented the scripts, over half the boot time was waiting 
for settle to complete.

When I commented out the settle instruction, the speedup was evident:

Oct 05 03:01:15.899727477  Starting mountvirtfs
...
Oct 05 03:01:19.779770827  Starting SSH Server... OK

That's 3.9 seconds for all the bootscripts I run.  From dmesg, the 
scripts start running a about 4.5 seconds after the kernel messages 
start.  That compares to 9.1 (+4.5) seconds with the settle instruction 
in both udev and udev_retry.

I'm hesitant to remove the settle instructions, but I'm also not sure 
they do anything for us.  Even without settle, it takes about 2 seconds 
to check/mount the file systems (I mount 6) and I don't think udev 
affects that.  I don't really see anything after udev_retry that would 
be affected either.  It's possible there might be something though.

The question here is: should the 'udevadm settle' commands be removed 
from the udev and udev_retry scripts?

------

On shutdown, most of the time is in the killproc script.  We send a 
termination signal to each process and then wait for it to die.  There 
are a couple of sleep instructions there.

There are a couple of ways to shutdown the system.  The simplest is to 
just call reboot or poweroff as root.  These programs send init's 
programs (agetty, etc) a TERM signal, wait 3 seconds, and send anything 
left a KILL signal.  They then run the rc script which, in turn, runs 
the other scripts at runlevel 0 or 6.

The delays can be eliminated if the command '/sbin/telinit -t0 6' is 
used for reboot (or a 0 parameter for halt).  We also have the same 
logic in /etc/init.d/sendsignals script.  The delay time there can 
controlled by setting the KILLDELAY variable in /etc/sysconfig/rc.site.

With both settings at 0, the time for me to shut down is about 6.4 
seconds.  This could be improved by tweaking the delays in killproc.

kill "${signal}" "${pid}"

while [ "${delay}" -ne "0" ]; do
     kill -0 "${pid}" 2> /dev/null || piddead="1"
     if [ "${piddead}" = "1" ]; then break; fi
     sleep 0.1
     delay="$(( ${delay} - 1 ))"
done

The $delay is 30, so the wait here in each process can be up to 3 
seconds.  Instrumenting, the only process I have that waits at all 
appears to be klogd which takes about a second to die.

There is one instruction in killproc at the end that does:

if [ -n "${fallback}" -a "${piddead}" != "1" ]; then
    kill "${fallback}" "${pid}" 2> /dev/null
    sleep 1
    # Check again, and fail if still running
    kill -0 "${pid}" 2> /dev/null && return 1
else
    # just check one last time and if still alive, fail
    sleep 1
    kill -0 "${pid}" 2> /dev/null && return 1
fi

The second sleep does not seem to needed.  Usually $piddead will be set 
to 1 and $fallback to '-KILL'.  Removing the sleep in the else clause 
speeds up the shutdown a lot.  My best case for shutdown time is now 
about 1.4 seconds and 1 second of that is for klogd.

Perhaps the else clause should be removed completely.

Any thoughts?

--------

I think the startup and shutdown timing discussion should be in LFS. 
Perhaps a section named "Startup and shutdown timing" immediately after 
Section 7.12 - The rc.site File.

Does this seem useful?

   -- Bruce
-- 
http://linuxfromscratch.org/mailman/listinfo/lfs-dev
FAQ: http://www.linuxfromscratch.org/faq/
Unsubscribe: See the above information page

Reply via email to