#This file was created by <hans> Tue Mar 30 12:25:23 1999
#LyX 1.0 (C) 1995-1999 Matthias Ettrich and the LyX Team
\lyxformat 2.15
\textclass linuxdoc
\language default
\inputencoding default
\fontscheme default
\graphics default
\paperfontsize 10
\spacing single 
\papersize Default
\paperpackage a4
\use_geometry 0
\use_amsmath 0
\paperorientation portrait
\secnumdepth 3
\tocdepth 3
\paragraph_separation indent
\defskip medskip
\quotes_language english
\quotes_times 2
\papercolumns 1
\papersides 1
\paperpagestyle default

\layout Title
\added_space_top vfill \added_space_bottom vfill 
Root over nfs clients & server Howto.
 
\layout Author

Hans de Goede
\layout Date

30 March 1999
\layout Abstract

Howto setup a server and configure clients for diskless operation from a
 network.
\layout Standard


\begin_inset LatexCommand \tableofcontents{}

\end_inset 


\layout Section

Introduction
\layout Standard

This document describes a setup for nfs over root.
 This document differs from the other root over nfs howto's in 2 ways: 
\layout Enumerate

It describes both the server and the client side offering a complete solution,
 it doesn't desribe the generic principles off root over nfs although they
 will become clear.
 Instead it offers a working setup for root over nfs.
 One of the many possible setup's I might add.
\layout Enumerate

This solution is unique in that it shares the root of the server with the
 workstations (ws).
 Instead of having a mini-root per ws.
 This has a number of advantages: 
\begin_deeper 
\layout Itemize

low diskspace usage
\layout Itemize

any changes on the serverside are also automagicly made at the client side,
 all configuration has only to be done once!
\layout Itemize

Very easy adding of new clients
\layout Itemize

only one system to maintain
\end_deeper 
\layout Standard

This document is heavily based on a RedHat-5.2 system.
 Quite a bit of prior linux sysadmin experience is assumed in this howto,
 if you have that it shouldn't be a problem to addept this solutions to
 other distributions.
\layout Subsection

Copyright
\layout Standard

Well here's the standard howto legal stuff:
\layout Standard

This manual may be reproduced and distributed in whole or in part, without
 fee, subject to the following conditions: 
\layout Itemize

The copyright notice above and this permission notice must be preserved
 complete on all complete or partial copies.
\layout Itemize

Any translation or derived work must be approved by the author in writing
 before distribution.
\layout Itemize

If you distribute this work in part, instructions for obtaining the complete
 version of this manual must be included, and a means for obtaining a complete
 version provided.
\layout Itemize

Small portions may be reproduced as illustrations for reviews or quotes
 in other works without this permission notice if proper citation is given.
 
\layout Standard

Exceptions to these rules may be granted for academic purposes: Write to
 the author and ask.
 These restrictions are here to protect us as authors, not to restrict you
 as learners and educators.
\layout Subsection

Changelog
\layout Itemize

v0.1, 20 January 1999: First draft written at the HHS, where the setup was
 originally developed.
\layout Itemize

v1.0, 30 March 1999: First released version partially written in time of
 ISM
\layout Section

Basic principle
\layout Standard

As already said with this setup the clients share basicly the entire root-fs
 with the server.
 But the clients ofcourse only get read access to it.
 This is basicly how things work.
 
\layout Subsection

Things can't be that simple
\layout Standard

Unfortunatly things aren't that simple, there are a couple of problems the
 overcome with this simple setup.
\layout Subsubsection

Each ws needs its own writable copy of a number of dirs
\layout Standard

A normal linux setup needs to have write access to the following dirs:
\layout Enumerate

/dev
\layout Enumerate

/var
\layout Enumerate

/tmp
\layout Standard

There are 3 solutions for this, of which one will only work for /dev:
\layout Enumerate

mount a ramdisk and populate it by untarring a tarball, or by copying a
 template dir.
\begin_deeper 
\layout Itemize

Advantages:
\begin_deeper 
\begin_deeper 
\layout Enumerate

It's cleaned up every reboot, which removes tmp files and logs.
 Thus it needs no maintaince unlike server sided dirs.
\layout Enumerate

It doesn't take up any space on the server, and that it doesn't generate
 any network traffic.
 A ramdisk takes less server and network resources, and is faster.
\end_deeper 
\end_deeper 
\layout Itemize

Disadvantages:
\begin_deeper 
\begin_deeper 
\layout Enumerate

It takes memory.
\layout Enumerate

The logs aren't kept after a reboot, if you really want logging of all your
 clients tell syslog to redirect the logging to your server.
\end_deeper 
\end_deeper 
\end_deeper 
\layout Enumerate

create a dir for each ws on the server and mount it rw over nfs.
\begin_deeper 
\layout Itemize

Advantages & disadvantages:
\begin_deeper 
\layout Enumerate

The above arguments work in reverse for serversided dirs.
\end_deeper 
\end_deeper 
\layout Enumerate

With kernel 2.2 devfs can be used for /dev, this is a virtual filesystem
 ala /proc for /dev.
\begin_deeper 
\layout Itemize

Advantages:
\begin_deeper 
\begin_deeper 
\layout Enumerate

Devfs takes very little memory when compared to a ramdisk / no diskspace
 on the server and is very fast.
 A normal /dev takes at least 1.5 mb since the minimal size for a file (and
 thus for a device) is 1k, and there are somewhere around 1200 devices.
 You can offcourse use a template of a stripped /dev with only the entries
 you need to save some space.
 1.5 Mb is a lott for a ramdisk and also isn't nice on a server.
\layout Enumerate

Devfs automagicly creates entries for newly added & detected devices, so
 no maintainance is needed.
\end_deeper 
\end_deeper 
\layout Itemize

Disadvantages:
\begin_deeper 
\begin_deeper 
\layout Enumerate

Any changes to /dev like creating symlinks for the mouse and cdrom are lost.
 Devfs comes with a script called rc.devfs to save these chances.
 The script's provided in this howto will automagicly restore these symlinks
 settings by calling rc.devfs If you make any changes to /dev you need to
 call the rc.devfs yourself to save them by typing:
\layout Quote

/etc/rc.d/rc.devfs save /etc/sysconfig
\end_deeper 
\end_deeper 
\end_deeper 
\layout Standard

As you can see, there are a number of ways to solve this problem.
 For the rest of this Howto the following choices are assumed:
\layout Itemize

For /dev we'll use Devfs
\layout Itemize

For /var and /tmp we'll use a shared ramdisk of 1mb.
 It's shared to use the space as effeciently as possible.
 /tmp is replaced by a symlink to /var/tmp to make the sharing possible.
\layout Itemize

Populating the ramdisk with tarballs or template dirs, works equally well.
 But with template dirs it's much easier to make changes, thus we'll use
 template dirs.
\layout Subsubsection

Write access to /home might be needed
\layout Standard

Not really a problem in every unix client/server setup /home is mounted
 rw from the server so we'll just do that ;) 
\layout Subsubsection

How does a ws find out it's ip so that it can communicate with the server?
\layout Standard

Luckily for us, this problem has already been solved and the linux kernel
 has support for 2 ways of autoconfiguration of the ip-address:
\layout Enumerate

RARP
\layout Enumerate

Bootp
\layout Standard

Rarp is the easiest to setup, bootp is the most flexible.
 Since most bootroms only support bootp that's what we'll use.
\layout Subsubsection

What about ws sepecific configuration
\layout Standard

On redhat most system dependent config files are already in /etc/sysconfig
 We'll just move those which aren't there and add symlinks.
 Then we mount a seperate /etc/sysconfig on a per ws basis.
 This is really the only distribution dependent part on other distributions
 you can just create a sysconfig dir, move all config files which can't
 be shared there and create symlinks.
 Also /etc/rc.d/rc3.d, or symilar on other dists, might need to be different
 for the server resp the workstations.
 Assuming that all ws run the same services in runlevel 3, we'll just create
 a seperate 3th runlevel for the workstations and the server:
\layout Enumerate

Create both a /etc/rc.d/rc3.ws and a /etc/rc.d/rc3.server
\layout Enumerate

make /etc/rc.d/rc3.d a symlink to /etc/sysconfig/rc3.d
\layout Enumerate

make /etc/sysconfig/rc3.d a symlink to the apropiate /etc/rc.d/rc3.xxx
\layout Enumerate

replace S99local in rc3.ws by a link to /etc/sysconfig/rc.local so that each
 ws can have it's own rc.local
\layout Subsubsection

Miscelancious problems
\layout Standard

There are a few problems left:
\layout Enumerate

/etc/rc.d/rc.sysinit needs /var, so /var needs to be mounted or created before
 /etc/rc.d/rc.sysinit is run.
 It would also be nice if the ws-specific /etc/sysconfig is mounted before
 any initscripts are run.
\begin_deeper 
\layout Itemize

We'll just source a bootup script for the ws in the very top of /etc/rc.d/rc.sysin
it.
 Note this script will then ofcourse also be sourced by the server itself
 on boot, so the script has to detect this and do nothing on the server.
\end_deeper 
\layout Enumerate

/etc/mtab needs to be writable:
\begin_deeper 
\layout Itemize

This is a tricky one, just create a link to /proc/mounts and create an empty
 file mounts in /proc so that fsck and mount don't complain during the initscrip
ts when /proc isn't mounted yet.
 One note smb(u)mount doesn't respect mtab being a link and overwrites it.
 Thus if you want to use smb(u)mount create wrapper scripts that restore
 the symlink.
\end_deeper 
\layout Section

Preparing the server
\layout Standard

Now it's time to prepare the server to serve diskless clients.
\layout Subsection

Building a kernel
\layout Standard

The first thing todo is build a kernel with the nescesarry stuff in to support
 root over nfs.
 Take the following steps to build your kernel:
\layout Enumerate

Since we'll be using redhat-5.2 with kernel-2.2 you should asure yourself
 that your redhat-5.2 is kernel-2.2 ready.
 RedHat has got an excellent howto on this.
\layout Enumerate

I use the same kernel for both server and ws, to avoid module conflicts
 since they share the same /lib/modules.
 If this is not possible in your situation, fake different kernel versions
 by editing the version number in the kernel's top makefile.
 These different versionsnumbers will avoid any conflicts.
 
\layout Enumerate

Besides the usual stuff the kernel should have the following:
\begin_deeper 
\layout Itemize

ext2 compiled in (if used on server, or for both)
\layout Itemize

nfs and root-over-nfs compiled in (if used on client or both), to get the
 nfs over root option in 2.2 enable ip-autoconfig in the network options.
 We'll use bootp as configuration method.
\layout Itemize

ws networkcard support compiled in (if used on client or both)
\layout Itemize

compile devfs in (required for client, also nice for server)
\layout Itemize

anything else you normally use, modules for all other devices used on either
 the server or all / some ws etc.
\end_deeper 
\layout Enumerate

The kernel-src needs to be edited to make the default root-over-nfs mount:
 /tftpboot/<ip>/root instead of just /tftpboot/<ip>.
 This is to get a clean tree in /tftpboot with one dir per ws containing
 both the root for it (a link to the actual server root) and any ws specific
 dirs.
\begin_deeper 
\layout Itemize

For 2.0 This is a define in: "include/linux/nfs_fs.h" called "NFS_ROOT"
\layout Itemize

For 2.2 This is a define in: "fs/nfs/nfsroot.c"
\end_deeper 
\layout Enumerate

Now just compile the kernel as usual, see the kernel-howto.
 
\layout Enumerate

If you don't have /dev/nfsroot yet, create it by typing: 
\begin_deeper 
\layout Quote

mknod /dev/nfsroot b 0 255.
\end_deeper 
\layout Enumerate

After compiling the kernel set the root to nfsroot by typing:
\begin_deeper 
\layout Quote

rdev <path-to-zImage>/zImage /dev/nfsroot
\end_deeper 
\layout Enumerate

Before booting with devfs you need to make a few changes to /etc/conf.modules,
 append the contents of the conf.modules in the devfs documentation to it.
 
\layout Enumerate

Since this new kernel is compiled for autoconfig of ip's it will try to
 autoconf the ip of the server during bootup.
 Which ofcourse will fail since it gives out the ip's.
 To avoid a long timeout add: append="ip=off" To the linux section of /etc/lilo.c
onf.
 
\layout Enumerate

Run lilo and boot the new kernel.
\layout Enumerate

Due to devfs you'll have lost all symlinks on the server.
 With redhat this is usually /dev/mouse and /dev/cdrom.
 Recreate these.
 If you also used to use special ownerships, chown to appropiate files in
 /dev.
 Now save the /dev settings (in /etc/sysconfig, since they might be ws specific)
:
\begin_deeper 
\layout Itemize

Copy rc.devfs from the devfs documentation in the kernel source to /etc/rc.d/rc.dev
fs and make it executable
\layout Itemize

Save the settings by typing:
\begin_deeper 
\layout Quote

/etc/rc.d/rc.devfs save /etc/sysconfig
\end_deeper 
\end_deeper 
\layout Subsection

Creating and populating /tftpboot, making symlinks for /tmp etc.
\layout Standard

The next step is to create and populate /tftpboot
\layout Subsubsection

The automagic part
\layout Standard

This is all handled by a big script since putting a long list of commands
 into this howto seemed pretty useless to me.
 If you want todo this manual just read the script and type it in as you
 go ;)
\layout Standard


\emph on 
This setup script thus some nasty things like nuke /tmp, temporary kill
 syslog, umount /proc.
 So make sure that noone is using the machine during this, and that X isn't
 running.
 Just making sure your the only one logged in on a text-console is enough,
 no need to change runlevels.
\layout Standard


\emph on 
DISCLAIMER: this script has been tested but nevertheless if it messes up
 your server your on your own.
 I can take no responsibility what so ever.
 Lett me repeat this howto is only for experienced linux sysadmins.
 Also this is script is designed to be run once and I really mean once.
 Running it twice will nuke: /etc/fstab, /etc/X11/XF86Config, /etc/X11/X
 and /etc/conf.modules.
\layout Standard

Now with that said, just cut and paste the script make it executable, execute
 it and pray to the holy penguin that it works ;)
\layout Code

#!/bin/sh
\newline 

\newline 
SERVER_NAME=`hostname -s`
\newline 

\newline 
###
\newline 
echo creating /etc/rc.d/rc.ws
\newline 
#this basicly just echos the entire script ;)
\newline 
echo "#root on nfs stuff
\newline 

\newline 
SERVER=$SERVER_NAME
\newline 

\newline 
#we need proc for mtab, route etc
\newline 
mount -t proc /proc /proc
\newline 

\newline 
IP=
\backslash 
`ifconfig eth0|grep inet|cut --field 2 -d ':'|cut --field 1 -d ' '
\backslash 
`
\newline 

\newline 
#if the first mount fails we're probably the server, or atleast something
 is
\newline 
#pretty wrong, so only do the other stuff if the first mount succeeds
\newline 
mount 
\backslash 
$SERVER:/tftpboot/
\backslash 
$IP/sysconfig /etc/sysconfig -o nolock &&
\newline 
{
\newline 

\protected_separator 

\protected_separator 
 #other mounts
\newline 

\protected_separator 

\protected_separator 
 mount 
\backslash 
$SERVER:/home /home -o nolock
\newline 

\protected_separator 

\protected_separator 
 mount 
\backslash 
$SERVER:/ /
\backslash 
$SERVER -o ro,nolock
\newline 

\newline 

\protected_separator 

\protected_separator 
 #/var
\newline 

\protected_separator 

\protected_separator 
 echo Creating /var ...
\newline 

\protected_separator 

\protected_separator 
 mke2fs -q -i 1024 /dev/ram1 1024
\newline 

\protected_separator 

\protected_separator 
 mount /dev/ram1 /var -o defaults,rw
\newline 

\protected_separator 

\protected_separator 
 cp -a /tftpboot/var /
\newline 

\newline 

\protected_separator 

\protected_separator 
 #network stuff
\newline 

\protected_separator 

\protected_separator 
 .
 /etc/sysconfig/network
\newline 

\protected_separator 

\protected_separator 
 HOSTNAME=
\backslash 
`cat /etc/hosts|grep 
\backslash 
$IP|cut --field 2
\backslash 
`
\newline 

\protected_separator 

\protected_separator 
 route add default gw 
\backslash 
$GATEWAY
\newline 

\protected_separator 

\protected_separator 
 ifup lo
\newline 
}
\newline 

\newline 
#restore devfs settings
\newline 
/etc/rc.d/rc.devfs restore /etc/sysconfig
\newline 

\newline 
umount /proc" > /etc/rc.d/rc.ws
\newline 

\newline 
###
\newline 
echo splitting runlevel 3 for the client and server
\newline 
mv /etc/rc.d/rc3.d /etc/rc.d/rc3.server
\newline 
cp -a /etc/rc.d/rc3.server /etc/rc.d/rc3.ws
\newline 
rm /etc/rc.d/rc3.ws/*network
\newline 
rm /etc/rc.d/rc3.ws/*nfs
\newline 
rm /etc/rc.d/rc3.ws/*nfsfs
\newline 
rm /etc/rc.d/rc3.ws/S99local
\newline 
ln -s /etc/sysconfig/rc.local /etc/rc.d/rc3.ws/S99local
\newline 
ln -s /etc/rc.d/rc3.server /etc/sysconfig/rc3.d
\newline 
ln -s /etc/sysconfig/rc3.d /etc/rc.d/rc3.d
\newline 

\newline 
###
\newline 
echo making tmp a link to /var/tmp
\newline 
rm -fR /tmp
\newline 
ln -s var/tmp /tmp
\newline 

\newline 
###
\newline 
echo moving various files around and create symlinks for them
\newline 
echo mtab
\newline 
/etc/rc.d/init.d/syslog stop
\newline 
umount /proc
\newline 
touch /proc/mounts
\newline 
mount /proc
\newline 
/etc/rc.d/init.d/syslog start
\newline 
rm /etc/mtab
\newline 
ln -s /proc/mounts /etc/mtab
\newline 
echo fstab
\newline 
mv /etc/fstab /etc/sysconfig
\newline 
ln -s sysconfig/fstab /etc/fstab
\newline 
echo X-config files
\newline 
mkdir /etc/sysconfig/X11
\newline 
mv /etc/X11/X /etc/sysconfig/X11
\newline 
ln -s ../sysconfig/X11/X /etc/X11/X
\newline 
mv /etc/X11/XF86Config /etc/sysconfig/X11
\newline 
ln -s ../sysconfig/X11/XF86Config /etc/X11/XF86Config
\newline 
echo conf.modules
\newline 
mv /etc/conf.modules /etc/sysconfig
\newline 
ln -s sysconfig/conf.modules /etc/conf.modules
\newline 
echo isapnp.conf
\newline 
mv /etc/isapnp.conf /etc/sysconfig
\newline 
ln -s sysconfig/isapnp.conf /etc/isapnp.conf
\newline 

\newline 
###
\newline 
echo creating a template dir for the ws directories
\newline 
echo /tftpboot/template
\newline 
mkdir /home/tftpboot
\newline 
ln -s home/tftpboot /tftpboot
\newline 
mkdir /tftpboot/template
\newline 
mkdir /$SERVER_NAME
\newline 
echo root
\newline 
ln -s / /tftpboot/template/root
\newline 
echo sysconfig
\newline 
cp -a /etc/sysconfig /tftpboot/template/sysconfig
\newline 
rm -fR /tftpboot/template/sysconfig/network-scripts
\newline 
ln -s /$SERVER_NAME/etc/sysconfig/network-scripts 
\backslash 

\newline 

\protected_separator 
/tftpboot/template/sysconfig/network-scripts
\newline 
echo NETWORKING=yes > /tftpboot/template/sysconfig/network
\newline 
echo `grep "GATEWAY=" /etc/sysconfig/network` >> /tftpboot/template/sysconfig/ne
twork
\newline 
echo "/dev/nfsroot / nfs defaults 1 1" > /tftpboot/template/sysconfig/fstab
\newline 
echo "none /proc proc defaults 0 0" >> /tftpboot/template/sysconfig/fstab
\newline 
echo "#!/bin/sh" > /tftpboot/template/sysconfig/rc.local
\newline 
chmod 755 /tftpboot/template/sysconfig/rc.local
\newline 
rm /tftpboot/template/sysconfig/rc3.d
\newline 
ln -s /etc/rc.d/rc3.ws /tftpboot/template/sysconfig/rc3.d
\newline 
rm /tftpboot/template/sysconfig/isapnp.conf
\newline 
echo var
\newline 
cp -a /var /tftpboot/var
\newline 
rm -fR /tftpboot/var/lib
\newline 
ln -s /$SERVER_NAME/var/lib /tftpboot/var/lib
\newline 
rm -fR /tftpboot/var/catman
\newline 
ln -s /$SERVER_NAME/var/catman /tftpboot/var/catman
\newline 
rm -fR /tftpboot/var/log/httpd
\newline 
rm -f /tftpboot/var/log/samba/*
\newline 
for i in `find /tftpboot/var/log -type f`; do cat /dev/null > $i; done
\newline 
rm `find /tftpboot/var/lock -type f`
\newline 
rm `find /tftpboot/var/run -type f`
\newline 
echo /sbin/fsck.nfs
\newline 
echo "#!/bin/sh
\newline 
exit 0" > /sbin/fsck.nfs
\newline 
chmod 755 /sbin/fsck.nfs
\newline 

\newline 
echo all done
\layout Subsubsection

Manual adjustments to some files 
\layout Standard

Now we need to make a few manual adjustments to the server:
\layout Enumerate

The ws setup script has to be sourced at the very beginning of rc.sysinit,
 so add the following lines directly after setting the PATH:
\begin_deeper 
\layout Code

#for root over nfs workstations.
\newline 
/etc/rc.d/rc.ws
\end_deeper 
\layout Enumerate

Strip /etc/rc.d/rc3.ws to a bare minimum.
 It might be useful to create something like rc.local.ws but I'll leave that
 up to you.
 Network and nfsfs are already setup.The following have been already removed
 / updated by the automagic script:
\begin_deeper 
\layout Itemize

network
\layout Itemize

nfsfs
\layout Itemize

nfs
\layout Itemize

rc.local
\end_deeper 
\layout Subsection

Exporting the appropriate file systems and setting up bootp
\layout Standard

The server must ofcourse export the appropriate filesystems and asign the
 ip addresses to the clients.
\layout Subsubsection

Exporting the appropriate file systems
\layout Standard

We need to export some dir's for the workstations so for the situation here
 at the university I would add the following to /etc/exports:
\layout Code

/ *.st.hhs.nl(ro,no_root_squash)
\newline 
/home *.st.hhs.nl(rw,no_root_squash)
\layout Standard

Ofcourse use the apropriate domain ;) and restart nfs by typing:
\layout Quote

/etc/rc.d/init.d/nfs restart
\layout Standard

Note for knfsd users: knfsd doesn't allow you to have multiple exports on
 one partition with different permissions.
 Also knfsd doesn't allow clients to go past partition boundaries for example
 if a client mounts / and /usr is a different partition it won't have access
 to /usr.
 Thus if you use knfsd, at least /home should be on a different partition,
 the server prepare script already puts /tftpboot in /home so that doesn't
 need a seperate partition.
 If you've got any other partitions your clients should have access to export
 them seperatly and add mount commands for them to /etc/rc.d/rc.ws.
\layout Subsubsection

Setting up bootp
\layout Enumerate

If bootp isn't installed yet install it.
 It comes with RedHat.
\layout Enumerate

Edit /etc/inetd.conf and uncomment the line beginning with bootps, if you
 want to use a bootprom uncomment tftp while your at it.
 
\layout Enumerate

Restart inetd by typing:
\begin_deeper 
\layout Quote

/etc/rc.d/init.d/inetd restart
\end_deeper 
\layout Section

Adding workstations
\layout Standard

Now that the server is all done, we can start adding workstations.
\layout Subsection

Creating a boot disk or bootrom
\layout Standard

You'll need ot create a bootrom and / or a bootdisk to boot your workstation.
\layout Subsubsection

Creating a bootdisk
\layout Standard

Even if you wish to use a bootrom its wise to first test with a bootdisk,
 to create a boot disk just type:
\layout Quote

dd if=/<path-to-zImage>/zImage of=/dev/fd0
\layout Subsubsection

Creating a bootrom
\layout Standard

There are a few free package's out there to create bootroms:
\layout Enumerate

netboot, this is IMHO the most complete free package out there.
 It uses standard dos packet drivers so allmost all cards are supported.
 One very usefull hint I got on there mailing list was to pklite the packetdrive
rs since some commercial drivers are to big to fit into the bootrom.
 Netboot's documentation is complete enough, so I won't waste any time reproduci
ng it here, it should be more then sufficient to create a bootrom and boot
 a ws with it.
 Netboot's webpage is: http://www.han.de/~gero/netboot/
\layout Enumerate

etherboot, this is the other free package out there it has got a few nice
 features like dhcp support, but has limited driver support as it uses its
 own driver format.
 I haven't used this so I really can't give anymore usefull info.
 Etherboot's webpage is: http://www.slug.org.au/etherboot/
\layout Standard

About the roms themselves.
 Most cards take ordinary eproms with an 28 pins dip housing.
 These eproms come in size upto 64kB.
 For most cards you'll need 32kB eproms with netboot.
 Some cards drivers will fit into 16kB but the price difference of the eproms
 is minimal.
 These eproms can be burned with any ordinairy eprom burner.
\layout Subsection

Creating a ws dir
\layout Standard

Just copy over the template by typing:
\layout Quote

cd /tftpboot
\layout Quote

cp -a template <ip>
\layout Standard

You could of course also copy over the dir of a workstation with identical
 mouse, graphicscard and monitor and ommit the configuration in step 5.4.
\layout Subsection

Add entries to /etc/bootptab and /etc/hosts
\layout Standard

Edit /etc/bootptab and add an entry for your test ws, an example entry is:
\layout Code

nfsroot1:hd=/tftpboot:vm=auto:ip=10.0.0.237:
\backslash 
 
\newline 
:ht=ethernet:ha=00201889EE78:
\backslash 

\newline 
:bf=bootImage:rp=/tftpboot/10.0.0.237/root
\layout Standard

Replace nfsroot1 by the hostname you want your ws to have.
 Replace 10.0.0.237 by the ip you want your ws to have (do this twice) and
 replace 00201889EE78 by the MAC-ADDRESS of your ws.
 If you don't know the MAC-ADDRESS of the ws, just boot it with the just
 created boot disk and look for the MAC-ADDRESS in the boot messages.
 There's a chance bootpd is already running so just to make sure try to
 restart it by typing:
\layout Quote

killall -HUP bootpd
\layout Standard

Don't worry if it fails, that just means it wasn't running, inetd will start
 it when asked too.
\layout Subsection

Booting the ws for the first time
\layout Standard

Just boot the ws from the bootdisk.
 This should get you a working ws in textmode, with the exact same setup
 as your server except for the ip-nr and the running services.
 Even if you want to use a bootprom it's wise to first test with the bootdisk,
 if that works you can try to boot with the bootrom see the bootroms documentati
on for more info.
\layout Subsection

Set the ws specific configuration.
\layout Standard

Now it's time to configure any ws specific settings:
\layout Enumerate

First off all to get the mouse working, just run mouseconfig.
 To apply the changes, and check that the mouse works type:
\begin_deeper 
\layout Quote

/etc/rc.d/init.d restart
\end_deeper 
\layout Enumerate

Run Xconfigurator, when Xconfigurator has probed the card and you can press
 ok don't! Since we have moved the symlink for the Xserver from /etc/X11/X
 to /etc/sysconfig/X11/X Xconfigurator will fail to create the proper link.
 Thus to make sure the rest of Xconfigurator goes well, switch to another
 console and create the link in /etc/sysconfig/X11 to the advised server.
 Now just finish Xconfigurator and test X.
\layout Enumerate

Configure anything else which is different then the server / template:
\begin_deeper 
\layout Itemize

sound: You probaly need to modify isapnp.conf and conf.modules, both are already
 made links to /etc/sysconfig by the server setup script.
\layout Itemize

cdrom: Link in /dev, entry in /etc/fstab? etc.
\layout Itemize

rc.local: Make any nescesarry changes.
\end_deeper 
\layout Enumerate

Save the links and any other changes to /dev type:
\begin_deeper 
\layout Quote

/etc/rc.d/rc.devfs save /etc/sysconfig
\end_deeper 
\layout Enumerate

All done.
\layout Section

Added bonus: booting from cdrom
\layout Standard

Much of the above also goes for booting from cdrom.
 Since I wanted to document howto boot from cdrom anyway, I document it
 in here to avoid typing a lott of the same twice.
\layout Standard

Why would one want to boot a machine from cd-rom? Booting from cdrom is
 interesting everywhere where one wants to run a very specific application,
 like a kiosk, a library database program or an intenet cafe, and one doesn't
 have a network or a server to use a root over nfs setup.
\layout Subsection

Basic Principle
\layout Standard

The basic principle is wants again simple, boot with a cdrom as root.
 To make this possible we'll use the rockridge extension to put a unix like
 filesystem on a cd and the Eltorito extension to make cd's bootable.
\layout Subsubsection

Things can't be that simple
\layout Standard

Ofcourse this setup also has a few problems.
 most are the same as above:
\layout Enumerate

We'll need write access to: /dev, /var & /tmp.
\begin_deeper 
\layout Itemize

We'll just use the same solutions as with root over nfs (see above):
\begin_deeper 
\layout Itemize

For /dev we'll use Devfs
\layout Itemize

For /var and /tmp we'll use a shared ramdisk of 1mb.
 It's shared to use the space as effeciently as possible.
 /tmp is replaced by a symlink to /var/tmp to make the sharing possible.
\layout Itemize

Populating the ramdisk with tarballs or template dirs, works equally well.
 But with template dirs it's much easier to make changes, thus we'll use
 template dirs.
\end_deeper 
\end_deeper 
\layout Enumerate

Some apps need write access to /home.
\begin_deeper 
\layout Itemize

Put the homedir of the user's who will be running the application in /var,
 and populate it wiht the rest of /var every boot.
\end_deeper 
\layout Enumerate

/etc/mtab needs to be writable:
\begin_deeper 
\layout Itemize

Create a link to /proc/mounts and create an empty file mounts in /proc,
 see above.
\end_deeper 
\layout Subsection

Creating a test setup.
\layout Standard

Now that we know what we want todo and how, it's time to create a test setup:
\layout Enumerate

For starters just take one of the machines which you want to use and put
 in a big disk and a cd-burner.
\layout Enumerate

Install your linux of choice on this machine, and leave a 650mb partition
 free for the test setup.
 This install will be used to make the iso-image and to burn the cd's from,
 so install the nescesarry tools.
 It will also be used to restore any booboo's which leave the test setup
 unbootable.
\layout Enumerate

On the 650 mb partition install your linux of choice with the setup you
 want to have on the cd, this will be the test setup
\layout Enumerate

Boot the test setup.
\layout Enumerate

Compile a kernel as described in Section 3.1, follow all the steps, the changes
 need for devfs are still needed! At step 3 of Section 3.1 put in the following:
\begin_deeper 
\layout Itemize

isofs compiled in 
\layout Itemize

devfs compiled in
\layout Itemize

cdrom support compiled in
\layout Itemize

everything else you need either compiled in or as module.
\end_deeper 
\layout Enumerate

Configure the test setup:
\begin_deeper 
\layout Itemize

Create the user which we'll be running the application.
\layout Itemize

Put it's homedir in /var.
 
\layout Itemize

Install the application if needed.
\layout Itemize

Configure the application if needed.
\layout Itemize

Configure the user so that the application is automagicly run after login.
\layout Itemize

Configure linux so that it automaigcly logs in the user.
\layout Itemize

Configure anything else which needs configuring.
\end_deeper 
\layout Enumerate

Test that the test setup automagicly boots into the apllication and everything
 works.
\layout Enumerate

Boot the main install and mount the 650 mb partition on /test of the main
 install.
\layout Enumerate

Put the following in a file called /test/etc/rc.d/rc.iso, this file we'll
 be sourced at the begining of rc.sysinit to create /var
\begin_deeper 
\layout Code

#/var
\newline 
echo Creating /var ...
\newline 
mke2fs -q -i 1024 /dev/ram1 1024
\newline 
mount /dev/ram1 /var -o defaults,rw
\newline 
cp -a /lib/var /
\newline 

\newline 
#restore devfs settings, needs proc
\newline 
mount -t proc /proc /proc
\newline 
/etc/rc.d/rc.devfs restore /etc/sysconfig
\newline 
umount /proc
\end_deeper 
\layout Enumerate

Edit /test/etc/rc.sysinit comment the lines we're the root is remounted rw
 and add the following 2 lines directly afer setting the PATH:
\begin_deeper 
\layout Code

#to boot from cdrom
\newline 
.
 /etc/rc.d/rc.iso
\end_deeper 
\layout Enumerate

Copying the following to a script and executing it, this wil create a template
 for /var and make /tmp and /etc/mtab links.
\begin_deeper 
\layout Code

#!/bin/sh
\newline 
echo tmp
\newline 
rm -fR /test/tmp
\newline 
ln -s var/tmp /test/tmp
\newline 

\newline 
###
\newline 
echo mtab
\newline 
touch /test/proc/mounts
\newline 
rm /test/etc/mtab
\newline 
ln -s /proc/mounts /test/etc/mtab
\newline 

\newline 
###
\newline 
echo var
\newline 
mv /test/var/lib /test/lib/var-lib
\newline 
mv /test/var /test/lib
\newline 
mkdir /test/var
\newline 
ln -s /lib/var-lib /test/lib/var/lib
\newline 
rm -fR /test/lib/var/catman
\newline 
rm -fR /test/lib/var/log/httpd
\newline 
rm -f /test/lib/var/log/samba/*
\newline 
for i in `find /test/lib/var/log -type f`; do cat /dev/null > $i; done
\newline 
rm `find /test/lib/var/lock -type f`
\newline 
rm `find /test/lib/var/run -type f`
\newline 

\end_deeper 
\layout Enumerate

Remove the creation of /etc/issue* from /test/etc/rc.local it will only fail.
\layout Enumerate

Now boot the test partition again, it will be read only just like a cdrom.
 If something doesn't work reboot to the working partition fix it, try again
 etc.
 Or you could remount / rw ,fix it then reboot straight into to test partition
 again.
 To remount / rw type:
\begin_deeper 
\layout Quote

mount -o remount,rw /
\end_deeper 
\layout Subsection

Creating the cd
\layout Subsubsection

Creating a boot image
\layout Standard

First of all boot into the workign partition.
 To create a bootable cd we'll need an image of a bootable floppy.
 Just dd-ing a zimage doesn't work since the loader at the beginning of
 the zimage doesn't seem to like the fake floppydrive a bootable cd creates.
 So we'll use syslinux instead.
\layout Enumerate

Get boot.img from a redhat cd
\layout Enumerate

Mount boot.img somewhere through loopback by typing:
\begin_deeper 
\layout Quote

mount boot.img somewhere -o loop -t vfat
\end_deeper 
\layout Enumerate

Remove everything from boot.img except for:
\begin_deeper 
\layout Itemize

ldlinux.sys
\layout Itemize

syslinux.cfg
\end_deeper 
\layout Enumerate

Cp the kernel-image from the test partition to boot.img.
\layout Enumerate

Edit syslinux.cfg so that it contains the following, ofcourse replace zImage
 by the appropiote image name:
\begin_deeper 
\layout Code

default linux 
\newline 

\newline 
label linux
\newline 
kernel zImage
\newline 
append root=/dev/<insert your cdrom device here>
\end_deeper 
\layout Enumerate

Umount boot.img:
\begin_deeper 
\layout Quote

umount somewhere
\end_deeper 
\layout Enumerate

If your /etc/mtab is a link to /proc/mounts umount won't automagicly free
 /dev/loop0 so free it by typing:
\begin_deeper 
\layout Quote

losetup -d /dev/loop0
\end_deeper 
\layout Subsubsection

Creating the iso image
\layout Standard

Now that we have the boot image and an install that can boot from a readonly
 mount it's time to create an iso image of the cd: 
\layout Enumerate

Copy boot.img to /test
\layout Enumerate

Cd to the directory where you want to store the image make sure it's on
 a partition with enough free space.
\layout Enumerate

Now generate the image by typing:
\begin_deeper 
\layout Quote

mkisofs -R -b boot.img -c boot.catalog -o boot.iso /test
\end_deeper 
\layout Subsubsection

Verifying the iso image
\layout Enumerate

Mounting the image throug the loopbackdevice by typing:
\begin_deeper 
\layout Quote

mount boot.iso somewhere -o loop -t iso9660
\end_deeper 
\layout Enumerate

Now verify that the contents is ok.
\layout Enumerate

Umount boot.iso:
\begin_deeper 
\layout Quote

umount somewhere
\end_deeper 
\layout Enumerate

If your /etc/mtab is a link to /proc/mounts umount won't automagicly free
 /dev/loop0 so free it by typing:
\begin_deeper 
\layout Quote

losetup -d /dev/loop0
\end_deeper 
\layout Subsubsection

Writing the actual cd
\layout Standard

Assuming that you've got cdrecord installed and configured for your cd-writer
 type:
\layout Quote

cdrecord -v speed=<desired writing speed> dev=<path to your writers generic
 scsi device> boot.iso
\layout Subsection

Boot the cd and test it
\layout Standard

Well the title of this paragraph says it all ;)
\layout Section

Thanks
\layout Itemize

The HHS (Haagse Hoge School) a dutch college where I first developed and
 tested this setup for use in a couple of labs.
 And where the initial version of this HOWTO was written.
\layout Itemize

ISM a dutch company where I'm doing my final project.
 Part of the project involves diskless machines, so I got to develop this
 setup further and had the time to update this HOWTO.
\layout Itemize

All the users who will give me usefull input once this first version is
 out ;)
\layout Section

Comments
\layout Standard

Comments suggestions and such are welcome.
 They can be send to Hans de Goede at: j.w.r.degoede@et.tudelft.nl
\the_end