大家一起来分析这个initrd.gz里面的启动iso镜像的脚本

econy

大家一起来分析这个initrd.gz里面的启动iso镜像的脚本suddy，解压开initrd.gz后，是在scripts目录下

1. 
   
2. 
   
3. #!/bin/sh
   
4. 
   
5. # set -e
   
6. 
   
7. export PATH=/usr/bin:/usr/sbin:/bin:/sbin
   
8. 
   
9. mountpoint=/cdrom
   
10. 
    
11. root_persistence="casper-rw"
    
12. home_persistence="home-rw"
    
13. root_snapshot_label="casper-sn"
    
14. home_snapshot_label="home-sn"
    
15. 
    
16. USERNAME=casper
    
17. USERFULLNAME="Live session user"
    
18. HOST=live
    
19. BUILD_SYSTEM=Custom
    
20. 
    
21. mkdir -p $mountpoint
    
22. 
    
23. [ -f /etc/casper.conf ] && . /etc/casper.conf
    
24. export USERNAME USERFULLNAME HOST BUILD_SYSTEM
    
25. 
    
26. . /scripts/casper-helpers
    
27. 
    
28. if [ ! -f /casper.vars ]; then
    
29.     touch /casper.vars
    
30. fi
    
31. 
    
32. parse_cmdline() {
    
33.     for x in $(cat /proc/cmdline); do
    
34.         case $x in
    
35.        casperroot=*)
    
36.       export CASPERROOT="${x#casperroot=}";;
    
37.             persistent)
    
38.                 export PERSISTENT="Yes" ;;
    
39.             nopersistent)
    
40.                 export PERSISTENT="" ;;
    
41.             union=*)
    
42.                 export UNIONFS="${x#union=}";;
    
43.             ip*)
    
44.                 STATICIP=${x#ip=}
    
45.                 if [ "${STATICIP}" = "" ]; then
    
46.                     STATICIP="frommedia"
    
47.                 fi
    
48.                 export STATICIP ;;
    
49.             ignore_uuid)
    
50.                 IGNORE_UUID="Yes" ;;
    
51.         esac
    
52.     done
    
53.     if [ "${UNIONFS}" = "" ]; then
    
54.         export UNIONFS="aufs"
    
55.     fi
    
56. }
    
57. 
    
58. is_casper_path() {
    
59.     if [ "${CASPERROOT}" = "" ]; then
    
60.         path=$1
    
61.     else
    
62.    path="$1/${CASPERROOT}"
    
63.     fi
    
64.     # modify the path to $1 if it's a iso file
    
65.     if [ "$ISISO" != "" ]; then
    
66.         path=$1
    
67.     fi
    
68.     if [ -d "$path/casper" ]; then
    
69.         if [ "$(echo $path/casper/*.squashfs)" != "$path/casper/*.squashfs" ] ||
    
70.             [ "$(echo $path/casper/*.ext2)" != "$path/casper/*.ext2" ] ||
    
71.             [ "$(echo $path/casper/*.dir)" != "$path/casper/*.dir" ]; then
    
72.             return 0
    
73.         fi
    
74.     fi
    
75.     return 1
    
76. }
    
77. 
    
78. matches_uuid() {
    
79.     if [ "$IGNORE_UUID" ] || [ ! -e /conf/uuid.conf ]; then
    
80.         return 0
    
81.     fi
    
82.     path="$1"
    
83.     uuid="$(cat /conf/uuid.conf)"
    
84.     for try_uuid_file in "$path/.disk/casper-uuid"*; do
    
85.         [ -e "$try_uuid_file" ] || continue
    
86.         try_uuid="$(cat "$try_uuid_file")"
    
87.         if [ "$uuid" = "$try_uuid" ]; then
    
88.             return 0
    
89.         fi
    
90.     done
    
91.     return 1
    
92. }
    
93. 
    
94. get_backing_device() {
    
95.     case "$1" in
    
96.    # add the ext of *.fs to doing with storefilesystem sth like Backtrack.fs
    
97.         *.squashfs|*.ext2|*.fs)
    
98.             echo $(setup_loop "$1" "loop" "/sys/block/loop*")
    
99.             ;;
    
100.         *.dir)
     
101.             echo "directory"
     
102.             ;;
     
103.         *)
     
104.             panic "Unrecognized casper filesystem: $1"
     
105.             ;;
     
106.     esac
     
107. }
     
108. 
     
109. match_files_in_dir() {
     
110.     # Does any files match pattern $1 ?
     
111. 
     
112.     local pattern="$1"
     
113.     if [ "$(echo $pattern)" != "$pattern" ]; then
     
114.         return 0
     
115.     fi
     
116.     return 1
     
117. }
     
118. 
     
119. mount_images_in_directory() {
     
120.     if [ "${CASPERROOT}" = "" ]; then
     
121.         directory="$1"
     
122.     else
     
123.    directory="$1/${CASPERROOT}"
     
124.     fi
     
125.     if [ "$1" = "/iso9660" ]; then
     
126.         directory="$1"
     
127.     fi
     
128.     rootmnt="$2"
     
129.     if match_files_in_dir "$directory/casper/*.squashfs" ||
     
130.         match_files_in_dir "$directory/casper/*.ext2" ||
     
131.         match_files_in_dir "$directory/casper/*.dir"; then
     
132.         setup_unionfs "$directory/casper" "$rootmnt"
     
133.     else
     
134.         :
     
135.     fi
     
136. }
     
137. 
     
138. is_nice_device() {
     
139.     sysfs_path="${1#/sys}"
     
140.     if /lib/udev/path_id "${sysfs_path}" | grep -E -q "ID_PATH=(usb|pci-[^-]*-(ide|scsi|usb))"; then
     
141.         return 0
     
142.     fi
     
143.     return 1
     
144. }
     
145. 
     
146. copy_live_to() {
     
147.     copyfrom="${1}"
     
148.     copytodev="${2}"
     
149.     copyto="${copyfrom}_swap"
     
150. 
     
151.     size=$(fs_size "" ${copyfrom} "used")
     
152. 
     
153.     if [ "${copytodev}" = "ram" ]; then
     
154.         # copying to ram:
     
155.         freespace=$( expr $(awk '/MemFree/{print $2}' /proc/meminfo) + $( cat /proc/meminfo | grep Cached | head -n 1 | awk '/Cached/{print $2}' - ) )
     
156.         mount_options="-o size=${size}k"
     
157.         free_string="memory"
     
158.         fstype="tmpfs"
     
159.         dev="/dev/shm"
     
160.     else
     
161.         # it should be a writable block device
     
162.         if [ -b "${copytodev}" ]; then
     
163.             dev="${copytodev}"
     
164.             free_string="space"
     
165.             fstype=$(get_fstype "${dev}")
     
166.             freespace=$(fs_size "${dev}")
     
167.         else
     
168.             [ "$quiet" != "y" ] && log_warning_msg "${copytodev} is not a block device."
     
169.             return 1
     
170.         fi
     
171.     fi
     
172.     if [ "${freespace}" -lt "${size}" ] ; then
     
173.         [ "$quiet" != "y" ] && log_warning_msg "Not enough free ${free_string} (${freespace}k > ${size}k) to copy live media in ${copytodev}."
     
174.         return 1
     
175.     fi
     
176. 
     
177.     # begin copying..
     
178.     mkdir "${copyto}"
     
179.     echo "mount -t ${fstype} ${mount_options} ${dev} ${copyto}"
     
180.     mount -t "${fstype}" ${mount_options} "${dev}" "${copyto}"
     
181.     cp -a ${copyfrom}/* ${copyto} # "cp -a" from busybox also copies hidden files
     
182.     umount ${copyfrom}
     
183.     mount -r -o move ${copyto} ${copyfrom}
     
184.     rmdir ${copyto}
     
185.     return 0
     
186. }
     
187. 
     
188. do_netmount() {
     
189.     rc=1
     
190. 
     
191.     modprobe "${MP_QUIET}" af_packet # For DHCP
     
192. 
     
193.     /sbin/udevadm trigger
     
194.     /sbin/udevadm settle
     
195. 
     
196.     ipconfig ${DEVICE} /tmp/net-${DEVICE}.conf | tee /netboot.config
     
197. 
     
198.     if [ "${NFSROOT}" = "auto" ]; then
     
199.         NFSROOT=${ROOTSERVER}:${ROOTPATH}
     
200.     fi
     
201. 
     
202.     [ "$quiet" != "y" ] && log_begin_msg "Trying netboot from ${NFSROOT}"
     
203. 
     
204.     if [ "${NETBOOT}" != "nfs" ] && do_cifsmount ; then
     
205.         rc=0
     
206.     elif do_nfsmount ; then
     
207.         NETBOOT="nfs"
     
208.         export NETBOOT
     
209.         rc=0
     
210.     fi
     
211. 
     
212.     [ "$quiet" != "y" ] && log_end_msg
     
213.     return ${rc}
     
214. }
     
215. 
     
216. do_nfsmount() {
     
217.     rc=1
     
218.     modprobe "${MP_QUIET}" nfs
     
219.     if [ -z "${NFSOPTS}" ]; then
     
220.         NFSOPTS=""
     
221.     fi
     
222. 
     
223.     [ "$quiet" != "y" ] && log_begin_msg "Trying nfsmount -o nolock -o ro ${NFSOPTS} ${NFSROOT} ${mountpoint}"
     
224.     # FIXME: This while loop is an ugly HACK round an nfs bug
     
225.     i=0
     
226.     while [ "$i" -lt 60 ]; do
     
227.         nfsmount -o nolock -o ro ${NFSOPTS} "${NFSROOT}" "${mountpoint}" && rc=0 && break
     
228.         sleep 1
     
229.         i="$(($i + 1))"
     
230.     done
     
231.     return ${rc}
     
232. }
     
233. 
     
234. do_cifsmount() {
     
235.     rc=1
     
236.     if [ -x "/sbin/mount.cifs" ]; then
     
237.         if [ -z "${NFSOPTS}" ]; then
     
238.             CIFSOPTS="-ouser=root,password="
     
239.         else
     
240.             CIFSOPTS="${NFSOPTS}"
     
241.         fi
     
242. 
     
243.         [ "$quiet" != "y" ] && log_begin_msg "Trying mount.cifs ${NFSROOT} ${mountpoint} ${CIFSOPTS}"
     
244.         modprobe "${MP_QUIET}" cifs
     
245. 
     
246.         if mount.cifs "${NFSROOT}" "${mountpoint}" "${CIFSOPTS}" ; then
     
247.             rc=0
     
248.         fi
     
249.     fi
     
250.     return ${rc}
     
251. }
     
252. 
     
253. do_snap_copy ()
     
254. {
     
255.     fromdev="${1}"
     
256.     todir="${2}"
     
257.     snap_type="${3}"
     
258. 
     
259.     size=$(fs_size "${fromdev}" "" "used")
     
260. 
     
261.     if [ -b "${fromdev}" ]; then
     
262.         # look for free mem
     
263.         if [ -n "${HOMEMOUNTED}" -a "${snap_type}" = "HOME" ]; then
     
264.             todev=$(cat /proc/mounts | grep -s " $(base_path ${todir}) " | awk '{print $1}' )
     
265.             freespace=$(df -k  | grep -s ${todev} | awk '{print $4}')
     
266.         else
     
267.             freespace=$( expr $(awk '/MemFree/{print $2}' /proc/meminfo) + $( cat /proc/meminfo | grep Cached | head -n 1 | awk '/Cached/{print $2}' - ))
     
268.         fi
     
269. 
     
270.         tomount="/mnt/tmpsnap"
     
271.         if [ ! -d "${tomount}" ] ; then
     
272.             mkdir -p "${tomount}"
     
273.         fi
     
274. 
     
275.         fstype=$(get_fstype "${fromdev}")
     
276.         if [ -n "${fstype}" ]; then
     
277.             # Copying stuff...
     
278.             mount -t "${fstype}" -o ro,noatime "${fromdev}" "${tomount}"
     
279.             cp -a "${tomount}"/* ${todir}
     
280.             umount "${tomount}"
     
281.         else
     
282.             log_warning_msg "Unrecognized fstype: ${fstype} on ${fromdev}:${snap_type}"
     
283.         fi
     
284. 
     
285.         rmdir "${tomount}"
     
286.         if echo ${fromdev} | grep -qs loop; then
     
287.            losetup -d "${fromdev}"
     
288.         fi
     
289.         return 0
     
290.     else
     
291.         return 1
     
292.         [ "$quiet" != "y" ] && log_warning_msg "Unable to find the snapshot ${snap_type} medium"
     
293.     fi
     
294. }
     
295. 
     
296. try_snap ()
     
297. {
     
298.     # Look for $snap_label.* in block devices and copy the contents to $snap_mount
     
299.     #   and remember the device and filename for resync on exit in casper.init
     
300. 
     
301.     snap_label="${1}"
     
302.     snap_mount="${2}"
     
303.     snap_type="${3}"
     
304. 
     
305.     snapdata=$(find_files "${snap_label}.squashfs ${snap_label}.cpio.gz ${snap_label}.ext2")
     
306.     if [ ! -z "${snapdata}" ]; then
     
307.         snapdev="$(echo ${snapdata} | cut -f1 -d ' ')"
     
308.         snapback="$(echo ${snapdata} | cut -f2 -d ' ')"
     
309.         snapfile="$(echo ${snapdata} | cut -f3 -d ' ')"
     
310.         if echo "${snapfile}" | grep -qs '\(squashfs\|ext2\)'; then
     
311.             # squashfs or ext2 snapshot
     
312.             dev=$(get_backing_device "${snapback}/${snapfile}")
     
313.             if ! do_snap_copy "${dev}" "${snap_mount}" "${snap_type}"; then
     
314.                  log_warning_msg "Impossible to include the ${snapfile} Snapshot"
     
315.                  return 1
     
316.             fi
     
317.         else
     
318.             # cpio.gz snapshot
     
319.             if ! (cd "${snap_mount}" && zcat "${snapback}/${snapfile}" | cpio -i -u -d 2>/dev/null) ; then
     
320.                 log_warning_msg "Impossible to include the ${snapfile} Snapshot"
     
321.                 return 1
     
322.             fi
     
323.         fi
     
324.         umount "${snapback}"
     
325.     else
     
326.         dev=$(find_cow_device "${snap_label}")
     
327.         if [ -b ${dev} ]; then
     
328.             if echo "${dev}" | grep -qs loop; then
     
329.                 # strange things happens, user confused?
     
330.                 snaploop=$( losetup ${dev} | awk '{print $3}' | tr -d '()' )
     
331.                 snapfile=$(basename ${snaploop})
     
332.                 snapdev=$(cat /proc/mounts | awk '{print $2,$1}' | grep -es "^$( dirname ${snaploop} )" | cut -f2 -d ' ')
     
333.             else
     
334.                 snapdev="${dev}"
     
335.             fi
     
336.             if ! do_snap_copy "${dev}" "${snap_mount}" "${snap_type}" ; then
     
337.                 log_warning_msg "Impossible to include the ${snap_label} Snapshot"
     
338.                 return 1
     
339.             else
     
340.                 if [ -n "${snapfile}" ]; then
     
341.                      # it was a loop device, user confused
     
342.                      umount ${snapdev}
     
343.                 fi
     
344.             fi
     
345.         else
     
346.             log_warning_msg "Impossible to include the ${snap_label} Snapshot"
     
347.             return 1
     
348.         fi
     
349.     fi
     
350.     echo "export ${snap_type}SNAP="${snap_mount}":${snapdev}:${snapfile}" >> /etc/casper.conf # for resync on reboot/halt
     
351.     return 0
     
352. }
     
353. 
     
354. setup_unionfs() {
     
355.     image_directory="$1"
     
356.     rootmnt="$2"
     
357. 
     
358.     modprobe "${MP_QUIET}" -b ${UNIONFS}
     
359. 
     
360.     # run-init can't deal with images in a subdir, but we're going to
     
361.     # move all of these away before it runs anyway.  No, we're not,
     
362.     # put them in / since move-mounting them into / breaks mono and
     
363.     # some other apps.
     
364. 
     
365.     croot="/"
     
366. 
     
367.     # Let's just mount the read-only file systems first
     
368.     rofsstring=""
     
369.     rofslist=""
     
370.     if [ "${NETBOOT}" = "nfs" ] ; then
     
371.         roopt="nfsro" # go aroung a bug in nfs-unionfs locking
     
372.     elif [ "${UNIONFS}" = "aufs" ]; then
     
373.         roopt="rr"
     
374.     else
     
375.         roopt="ro"
     
376.     fi
     
377. 
     
378.     mkdir -p "${croot}"
     
379.     for image_type in "ext2" "squashfs" "dir" ; do
     
380.         for image in "${image_directory}"/*."${image_type}"; do
     
381.             imagename=$(basename "${image}")
     
382.             if [ -d "${image}" ]; then
     
383.                 # it is a plain directory: do nothing
     
384.                 rofsstring="${image}=${roopt}:${rofsstring}"
     
385.                 rofslist="${image} ${rofslist}"
     
386.             elif [ -f "${image}" ]; then
     
387.                 backdev=$(get_backing_device "$image")
     
388.                 fstype=$(get_fstype "${backdev}")
     
389.                 if [ "${fstype}" = "unknown" ]; then
     
390.                     panic "Unknown file system type on ${backdev} (${image})"
     
391.                 fi
     
392.                 mkdir -p "${croot}/${imagename}"
     
393.                 mount -t "${fstype}" -o ro,noatime "${backdev}" "${croot}/${imagename}" || panic "Can not mount $backdev ($image) on ${croot}/${imagename}" && rofsstring="${croot}/${imagename}=${roopt}:${rofsstring}" && rofslist="${croot}/${imagename} ${rofslist}"
     
394.             fi
     
395.         done
     
396.     done
     
397.     rofsstring=${rofsstring%:}
     
398. 
     
399.     mkdir -p /cow
     
400.     cowdevice="tmpfs"
     
401.     cow_fstype="tmpfs"
     
402.     cow_mountopt="rw,noatime,mode=755"
     
403. 
     
404.     # Looking for "${root_persistence}" device or file
     
405.     if [ -n "${PERSISTENT}" ]; then
     
406.         cowprobe=$(find_cow_device "${root_persistence}")
     
407.         if [ -b "${cowprobe}" ]; then
     
408.             cowdevice=${cowprobe}
     
409.             cow_fstype=$(get_fstype "${cowprobe}")
     
410.        cow_mountopt="rw,noatime"
     
411.         else
     
412.             [ "$quiet" != "y" ] && log_warning_msg "Unable to find the persistent medium"
     
413.         fi
     
414.     fi
     
415. 
     
416.     mount -t ${cow_fstype} -o ${cow_mountopt} ${cowdevice} /cow || panic "Can not mount $cowdevice on /cow"
     
417. 
     
418.     # mkdir a filesystem to mount the *.fs
     
419.     if [ "${CASPERROOT}" = "" ]; then
     
420.         storefs="$mountpoint"
     
421.     else
     
422.    storefs="$mountpoint/${CASPERROOT}"
     
423.     fi
     
424.     # if a *.fs in the patch of the boot directory, use unionfs to mount to /
     
425.     if [ "$(echo $storefs/*.fs)" != "$storefs/*.fs" ] ; then
     
426.    rwfs="$(echo $storefs/*.fs)"
     
427.    #mkdir -p /storefs
     
428.    #storefs_fstype=$(get_fstype $rwfs)
     
429.    #storefs_mountopt="rw,noatime"
     
430.    #mount -t  $storefs_fstype -o $storefs_mountopt $rwfs /storefs
     
431. 
     
432.    storefs_backdev=$(get_backing_device "$rwfs")
     
433.         storefs_fstype=$(get_fstype "${storefs_backdev}")
     
434.         if [ "${storefs_fstype}" = "unknown" ]; then
     
435.       panic "Unknown file system type on ${storefs_backdev} ($rwfs)"
     
436.    fi
     
437.         mkdir -p "/storefs"
     
438.         mount -t "${storefs_fstype}" -o rw,noatime "${storefs_backdev}" "/storefs" || panic "Can not mount $storefs_backdev ($rwfs) on /storefs"
     
439.            
     
440.    #mkdir -p "/root1"
     
441.    # mount with storefs to store the change
     
442.    mount -t ${UNIONFS} -o noatime,dirs=//storefs=rw:$rofsstring ${UNIONFS} "$rootmnt" || panic "${UNIONFS} mount failed"
     
443.    #mount -t ${UNIONFS} -o noatime,dirs=//storefs=rw:/cow=rw:$rofsstring ${UNIONFS} "$rootmnt" || panic "${UNIONFS} mount failed"
     
444.    #mount -t ${UNIONFS} -o noatime,dirs=//storefs=rw:/cow=rw:$rofsstring ${UNIONFS} "/root1" || panic "${UNIONFS} mount failed"
     
445.     else
     
446.    mount -t ${UNIONFS} -o noatime,dirs=/cow=rw:$rofsstring ${UNIONFS} "$rootmnt" || panic "${UNIONFS} mount failed"
     
447.     fi
     
448. 
     
449.     # if a *.swap in the patch of the boot directory, use it like a swap file
     
450.     if [ "$(echo $storefs/*.swap)" != "$storefs/*.swap" ] ; then
     
451.    swapfs="$(echo $storefs/*.swap)"
     
452.    swapon $swapfs
     
453.    echo "$swapfs swap  swap  defaults  0  0">> "$rootmnt"/etc/swap_fstab
     
454.     fi
     
455. 
     
456.     # Adding other custom mounts
     
457.     if [ -n "${PERSISTENT}" ]; then
     
458.         # directly mount /home
     
459.         # FIXME: add a custom mounts configurable system
     
460.         homecow=$(find_cow_device "${home_persistence}" )
     
461.         if [ -b "${homecow}" ]; then
     
462.             mount -t $(get_fstype "${homecow}") -o rw,noatime "${homecow}" "${rootmnt}/home"
     
463.             export HOMEMOUNTED=1 # used to proper calculate free space in do_snap_copy()
     
464.         else
     
465.             [ "$quiet" != "y" ] && log_warning_msg "Unable to find the persistent home medium"
     
466.         fi
     
467.         # Look for other snapshots to copy in
     
468.         try_snap "${root_snapshot_label}" "${rootmnt}" "ROOT"
     
469.         try_snap "${home_snapshot_label}" "${rootmnt}/home" "HOME"
     
470.     fi
     
471. 
     
472.     if [ -n "${SHOWMOUNTS}" ]; then
     
473.         for d in ${rofslist}; do
     
474.             mkdir -p "${rootmnt}/casper/${d##*/}"
     
475.             case d in
     
476.                 *.dir) # do nothing # mount -o bind "${d}" "${rootmnt}/casper/${d##*/}"
     
477.                     ;;
     
478.                 *) mount -o move "${d}" "${rootmnt}/casper/${d##*/}"
     
479.                     ;;
     
480.             esac
     
481.         done
     
482.         # shows cow fs on /cow for use by casper-snapshot
     
483.         mkdir -p "${rootmnt}/cow"
     
484.         mount -o bind /cow "${rootmnt}/cow"
     
485.     fi
     
486. 
     
487.     # move the stofs ; no head in busybox-initramfs
     
488.     if [ "${storefs_fstype}" != "" ]; then
     
489.    mkdir -p "${rootmnt}/rwfs"
     
490.    mount -o move "/storefs" "${rootmnt}/rwfs"
     
491.     fi
     
492. 
     
493.     for d in $(mount -t iso9660 | cut -d\  -f 3); do
     
494.        mkdir -p "$rootmnt/iso9660"
     
495.        mount -o move "${d}" "$rootmnt/iso9660"
     
496.     done
     
497. 
     
498.     # move the first mount; no head in busybox-initramfs
     
499.     for d in $(mount -t squashfs | cut -d\  -f 3); do
     
500.         mkdir -p "${rootmnt}/rofs"
     
501.         mount -o move "${d}" "${rootmnt}/rofs"
     
502.         break
     
503.     done
     
504. }
     
505. 
     
506. find_iso()
     
507. {
     
508.    local isoroot="/iso9660"
     
509.    local tmproot=$1
     
510.    if [ "${CASPERROOT}" = "" ]; then
     
511.         isos=`ls ${tmproot}/*.iso 2>/dev/null` || return 1
     
512.    else
     
513.    isos=`ls ${tmproot}/${CASPERROOT}/*.iso 2>/dev/null` || return 1
     
514.    fi
     
515.    modprobe loop
     
516.    mkdir -p "$isoroot"
     
517.    for iso in ${isos}
     
518.    do
     
519.        mount -t iso9660 -o loop $iso $isoroot 2>/dev/null || continue
     
520.        #if casper_path "$isoroot"; then
     
521.        #send a sign to the function that is a iso file
     
522.        ISISO="YES";
     
523.        if is_casper_path "$isoroot" ; then
     
524.            #echo "$isoroot"/casper/filesystem.squashfs
     
525.            #in_iso_squashfs="$isoroot"/casper/filesystem.squashfs
     
526.       in_iso_squashfs="$isoroot"
     
527.            return 0        
     
528.    else
     
529.       ISISO=""
     
530.            umount "$isoroot"
     
531.        fi
     
532.    done
     
533.    unset isos
     
534.    unset iso
     
535.    return 1
     
536. }
     
537. 
     
538. check_dev ()
     
539. {
     
540.     sysdev="${1}"
     
541.     devname="${2}"
     
542.     skip_uuid_check="${3}"
     
543.     if [ -z "${devname}" ]; then
     
544.         devname=$(sys2dev "${sysdev}")
     
545.     fi
     
546. 
     
547.     if [ -d "${devname}" ]; then
     
548.         mount -o bind "${devname}" $mountpoint || continue
     
549.         if is_casper_path $mountpoint; then
     
550.             echo $mountpoint
     
551.             return 0
     
552.         else
     
553.             umount $mountpoint
     
554.         fi
     
555.     fi
     
556. 
     
557.     if [ -n "${LIVEMEDIA_OFFSET}" ]; then
     
558.         loopdevname=$(setup_loop "${devname}" "loop" "/sys/block/loop*" "${LIVEMEDIA_OFFSET}")
     
559.         devname="${loopdevname}"
     
560.     fi
     
561. 
     
562.     fstype=$(get_fstype "${devname}")
     
563.     if is_supported_fs ${fstype}; then
     
564.    if [ ${fstype}="ntfs" ]; then
     
565.       mount -t ntfs-3g -o rw,noatime "${devname}" $mountpoint || continue
     
566.    else
     
567.       mount -t ${fstype} -o rw,noatime "${devname}" $mountpoint || continue
     
568.    fi
     
569.    if find_iso $mountpoint ; then
     
570.       echo $in_iso_squashfs
     
571.       return 0
     
572.    fi
     
573.         if is_casper_path $mountpoint && \
     
574.            ([ "$skip_uuid_check" ] || matches_uuid $mountpoint); then
     
575.             echo $mountpoint
     
576.             return 0
     
577.         else
     
578.             umount $mountpoint
     
579.         fi
     
580.     fi
     
581. 
     
582.     if [ -n "${LIVEMEDIA_OFFSET}" ]; then
     
583.         losetup -d "${loopdevname}"
     
584.     fi
     
585.     return 1
     
586. }
     
587. 
     
588. find_livefs() {
     
589.     timeout="${1}"
     
590.     # first look at the one specified in the command line
     
591.     if [ ! -z "${LIVEMEDIA}" ]; then
     
592.         if check_dev "null" "${LIVEMEDIA}" "skip_uuid_check"; then
     
593.             return 0
     
594.         fi
     
595.     fi
     
596.     # don't start autodetection before timeout has expired
     
597.     if [ -n "${LIVEMEDIA_TIMEOUT}" ]; then
     
598.         if [ "${timeout}" -lt "${LIVEMEDIA_TIMEOUT}" ]; then
     
599.             return 1
     
600.         fi
     
601.     fi
     
602.     # or do the scan of block devices
     
603.     for sysblock in $(echo /sys/block/* | tr ' ' '\n' | grep -vE "/(loop|ram|fd)"); do
     
604.         devname=$(sys2dev "${sysblock}")
     
605.         fstype=$(get_fstype "${devname}")
     
606.         if /lib/udev/cdrom_id ${devname} > /dev/null; then
     
607.             if check_dev "null" "${devname}" ; then
     
608.                 return 0
     
609.             fi
     
610.         elif is_nice_device "${sysblock}" ; then
     
611.             for dev in $(subdevices "${sysblock}"); do
     
612.                 if check_dev "${dev}" ; then
     
613.                     return 0
     
614.                 fi
     
615.             done
     
616.         elif [ "${fstype}" = "squashfs" -o \
     
617.                 "${fstype}" = "ext3" -o \
     
618.                 "${fstype}" = "ext2" ]; then
     
619.             # This is an ugly hack situation, the block device has
     
620.             # an image directly on it.  It's hopefully
     
621.             # casper, so take it and run with it.
     
622.             ln -s "${devname}" "${devname}.${fstype}"
     
623.             echo "${devname}.${fstype}"
     
624.             return 0
     
625.         fi
     
626.     done
     
627.     return 1
     
628. }
     
629. 
     
630. set_usplash_timeout() {
     
631.     if [ -x /sbin/usplash_write ]; then
     
632.         /sbin/usplash_write "TIMEOUT 120"
     
633.     fi
     
634. }
     
635. 
     
636. mountroot() {
     
637.     exec 6>&1
     
638.     exec 7>&2
     
639.     exec > casper.log
     
640.     exec 2>&1
     
641. 
     
642.     parse_cmdline
     
643. 
     
644.     set_usplash_timeout
     
645.     [ "$quiet" != "y" ] && log_begin_msg "Running /scripts/casper-premount"
     
646.     run_scripts /scripts/casper-premount
     
647.     [ "$quiet" != "y" ] && log_end_msg
     
648. 
     
649.     # Needed here too because some things (*cough* udev *cough*)
     
650.     # changes the timeout
     
651. 
     
652.     set_usplash_timeout
     
653. 
     
654.     if [ ! -z "${NETBOOT}" ]; then
     
655.         if do_netmount ; then
     
656.             livefs_root="${mountpoint}"
     
657.         else
     
658.             panic "Unable to find a live file system on the network"
     
659.         fi
     
660.     else
     
661.         # Scan local devices for the image
     
662.         i=0
     
663.         while [ "$i" -lt 60 ]; do
     
664.             livefs_root=$(find_livefs $i)
     
665.             if [ "${livefs_root}" ]; then
     
666.                 break
     
667.             fi
     
668.             sleep 1
     
669.             i="$(($i + 1))"
     
670.         done
     
671.     fi
     
672. 
     
673.     if [ -z "${livefs_root}" ]; then
     
674.         panic "Unable to find a medium containing a live file system"
     
675.     fi
     
676. 
     
677.     if [ "${TORAM}" ]; then
     
678.         live_dest="ram"
     
679.     elif [ "${TODISK}" ]; then
     
680.         live_dest="${TODISK}"
     
681.     fi
     
682.     if [ "${live_dest}" ]; then
     
683.         log_begin_msg "Copying live_media to ${live_dest}"
     
684.         copy_live_to "${livefs_root}" "${live_dest}"
     
685.         log_end_msg
     
686.     fi
     
687.     mount_images_in_directory "${livefs_root}" "${rootmnt}"
     
688. 
     
689.     log_end_msg
     
690. 
     
691.     maybe_break casper-bottom
     
692.     [ "$quiet" != "y" ] && log_begin_msg "Running /scripts/casper-bottom"
     
693. 
     
694.     run_scripts /scripts/casper-bottom
     
695.     [ "$quiet" != "y" ] && log_end_msg
     
696. 
     
697.     exec 1>&6 6>&-
     
698.     exec 2>&7 7>&-
     
699.     cp casper.log "${rootmnt}/var/log/"
     
700. }
     

复制代码

carbonjiao

查找root   启动root。。。

关键要看楼主实现什么功能。。。

这里面些函数还是可以利用起来的