GEEXBOX 无法加载USB的声卡驱动

znlive

在XP或WIN7下都是免驱的，要怎么在GEEXBOX下装驱动啊？

怎么办？

求助了。

znlive

怎么办啊。。。啊。。。

rockrock99

改输出就OK了，每个设置都测试下，总有一款适合你

znlive

在哪里设置啊。要怎么弄。有方法 吗？

我是神仙

自己研究一下启动时的搜索代码，也许能找到方法？

1. #!/bin/sh
   
2. 
   
3. dbg_echo () {
   
4.   [ "$QUIET" = yes ] || echo $*
   
5.   return
   
6. }
   
7. 
   
8. # install busybox symlinks
   
9. /bin/busybox --install -s
   
10. 
    
11. export PATH=/sbin:/bin
    
12. 
    
13. # mount required filesystems
    
14. busybox mount -t proc none /proc
    
15. busybox mount -t sysfs none /sys
    
16. 
    
17. # prepare /dev
    
18. mount -t devtmpfs devtmpfs /dev
    
19. echo '/bin/mdev' > /proc/sys/kernel/hotplug
    
20. mdev -s
    
21. 
    
22. # splash
    
23. /bin/ply-image /plymouth/splash.png
    
24. 
    
25. # parse kernel cmdline
    
26. for arg in $(cat /proc/cmdline); do
    
27.   case $arg in
    
28.     root=*)
    
29.       ROOT="${arg#root=}"
    
30.       ;;
    
31.     data=*)
    
32.       DATA="${arg#data=}"
    
33.       ;;
    
34.     init=*)
    
35.       INIT="${arg#init=}"
    
36.       ;;
    
37.     quiet)
    
38.       QUIET=yes
    
39.       ;;
    
40.     persistent)
    
41.       PERSISTENT=yes
    
42.       ;;
    
43.     initshell)
    
44.       echo "Dropping to shell as requested"
    
45.       exec sh
    
46.       ;;
    
47.   esac
    
48. done
    
49. 
    
50. # try to mount the rootfs specified in cmdline...
    
51. if [ -n "$ROOT" ]; then
    
52.   dbg_echo -n "Trying root=$ROOT as requested..."
    
53.   if mount -o ro $ROOT /mnt >/dev/null 2>&1; then
    
54.     if mount -t squashfs /mnt/rootfs /squashfs >/dev/null 2>&1; then
    
55.       dbg_echo "found."
    
56.     else
    
57.       dbg_echo "failed, cannot mount squashfs."
    
58.       umount /mnt
    
59.       unset ROOT
    
60.     fi
    
61.   else
    
62.     dbg_echo "failed, cannot mount device."
    
63.     unset ROOT
    
64.   fi
    
65. fi
    
66. 
    
67. # ...otherwise just scan the block devices for rootfs
    
68. if [ -z "$ROOT" ]; then
    
69.   dbg_echo "Scanning for root device:"
    
70.   cd /sys/block
    
71.   for i in 0 1 2 3 4 5 6 7 8 9; do
    
72.     for dev in *; do
    
73.       echo $dev | grep -q loop && continue
    
74.       echo $dev | grep -q ram && continue
    
75.       dbg_echo -n "[$i] Trying $dev..."
    
76.       if ! mount -o ro /dev/$dev /mnt >/dev/null 2>&1; then
    
77.         # check for removable devices not built with isohybrid support
    
78.         if [ $(cat /sys/block/$dev/removable) = 1 ]; then
    
79.           dbg_echo -n "[$i] Trying ${dev}1..."
    
80.           if ! mount -o rw /dev/${dev}1 /mnt >/dev/null 2>&1; then
    
81.             dbg_echo "failed, cannot mount device."
    
82.             continue
    
83.           fi
    
84.         else
    
85.           dbg_echo "failed, cannot mount device."
    
86.           continue
    
87.         fi
    
88.       fi
    
89.       if mount -t squashfs /mnt/rootfs /squashfs >/dev/null 2>&1; then
    
90.         dbg_echo "found."
    
91.         FOUND_ROOTFS=yes
    
92.         break
    
93.       else
    
94.         dbg_echo "failed, cannot mount squashfs."
    
95.         umount /mnt
    
96.       fi
    
97.     done
    
98.     [ -n "$FOUND_ROOTFS" ] && break
    
99.     sleep 1
    
100.   done
     
101.   cd /
     
102. fi
     
103. 
     
104. [ -z "$INIT" ] && INIT=/bin/systemd
     
105. 
     
106. if [ ! -x /squashfs/$INIT ]; then
     
107.     echo "Cannot find a valid root filesystem, dropping to shell"
     
108.     exec sh
     
109. fi
     
110. 
     
111. # setup aufs
     
112. if [ "$PERSISTENT" = yes ]; then
     
113.    DATA=/mnt/casper-rw
     
114.    PERSISTENT_OPT="-o loop -t ext2"
     
115.    [ ! -f "$DATA" ] && unset DATA && unset PERSISTENT_OPT
     
116. fi
     
117. if [ -n "$DATA" ]; then
     
118.   if ! mount $PERSISTENT_OPT -o rw,noatime $DATA /rw; then
     
119.     echo "Cannot mount data partition, using tmpfs instead"
     
120.     unset DATA
     
121.   fi
     
122. fi
     
123. [ -z "$DATA" ] && mount -t tmpfs none /rw
     
124. if ! mount -t aufs -o br=/rw:/squashfs none /newroot; then
     
125.   echo "Cannot mount aufs, dropping to shell"
     
126.   exec sh
     
127. fi
     
128. 
     
129. # move backed filesystems inside newroot otherwise aufs won't work properly
     
130. mkdir -p /newroot/run
     
131. mount -t tmpfs -o mode=0755,nosuid,nodev tmpfs /newroot/run
     
132. mkdir -p /newroot/.data /newroot/.squashfs /newroot/.root
     
133. mount --move /rw /newroot/.data
     
134. mount --move /squashfs /newroot/.squashfs
     
135. mount --move /mnt /newroot/.root
     
136. mkdir -p /newroot/run/initramfs/bin /newroot/run/initramfs/sbin
     
137. cp -P /bin/busybox /bin/sh /newroot/run/initramfs/bin/
     
138. cp -P /bin/shutdown /newroot/run/initramfs/
     
139. 
     
140. INIT_ARGS=`cat /proc/cmdline`
     
141. 
     
142. # Reset kernel hotplugging
     
143. echo "" > /proc/sys/kernel/hotplug
     
144. umount /sys
     
145. umount /dev
     
146. umount /proc
     
147. 
     
148. # Change to the new root partition and execute /sbin/init
     
149. if ! exec /bin/busybox switch_root /newroot $INIT $INIT_ARGS; then
     
150.   echo "Failed, dropping to shell"
     
151.   /bin/busybox mount -t proc none /proc
     
152.   /bin/busybox mount -t sysfs none /sys
     
153.   exec sh
     
154. fi

复制代码

znlive

看了半天没研究出来什么啊。郁闷。实力不够。

rockrock99

系统的设置里面，或在播放的时候也有地方可以更改设置

my9823

# prepare /dev
mount -t devtmpfs devtmpfs /dev
echo '/bin/mdev' > /proc/sys/kernel/hotplug
mdev -s

这个是创建设备？

我是神仙

# parse kernel cmdline
for arg in $(cat /proc/cmdline); do
  case $arg in
    root=*)
      ROOT="${arg#root=}"
      ;;
    data=*)
      DATA="${arg#data=}"
      ;;
    init=*)
      INIT="${arg#init=}"
      ;;
    quiet)
      QUIET=yes
      ;;
    persistent)
      PERSISTENT=yes
      ;;
    initshell)
      echo "Dropping to shell as requested"
      exec sh
      ;;
  esac
done

看来在启动时加参数 initshell 就可以直接进命令行模式？
PERSISTENT那个参数好像也检测得很简单，不能改位置。好像后面有个新的可以改casper-rw位置的initrd?

geexbox在initrd启动时没有NTFS驱动，访问不了NTFS的磁盘，所有不能放在ntfs盘。在后面加载了rootfs后才有了NTFS驱动，启动完了后倒是又可以访问NTFS盘上的资源了

那个CDLinux倒是把NTFS驱动也打包进initrd了，大得多。geexbox的initrd才500K，CDLinux的initrd是8M，一堆的驱动。
不知道能不能把CDLinux和GeexBox组合起来，用CDLinux的initrd 加上 GeexBox的 rootfs ? 这个完全搞不懂，只是猜想

我是神仙

转帖一个修改版的initrd,替换为这个脚本后
GeexBox2.0就支持中文或从NTFS启动，好强大的脚本（其实就是windows中的批处理）
自己能写出这个脚本说明这位大侠已经可以自己做一个GeexBox了

--------------

原创文章，转载请注明： 转载自下雨天
本文链接地址:
http://rain.orgfree.com/2011/11/23/geexbox2-0硬盘启动支持NTFS和ISO

1. #!/bin/sh
   
2. 
   
3. 
   
4. 
   
5. 
   
6. 
   
7. 
   
8. 
   
9. 
   
10. dbg_echo () {
    
11. 
    
12. 
    
13.   [ -z "$DEBUG_FLAG" ] || echo "$*" >>/${DEBUG_TXT}
    
14. 
    
15. 
    
16.   [ "$QUIET" = yes ] || echo $*
    
17. 
    
18. 
    
19.   return
    
20. 
    
21. 
    
22. }
    
23. 
    
24. 
    
25. 
    
26. 
    
27. 
    
28. prase_from() {
    
29. 
    
30. 
    
31.     [ -z "$FROM" ] && return
    
32. 
    
33. 
    
34.     FROM_TYPE=${FROM%%:*}
    
35. 
    
36. 
    
37.     FROM=${FROM#*:}
    
38. 
    
39. 
    
40.     FROM_DEV=${FROM%%:*}
    
41. 
    
42. 
    
43.     FROM_BASIC=${FROM##*:}
    
44. 
    
45. 
    
46. 
    
47. 
    
48. 
    
49.     if [ "$FROM_TYPE" != "ISO" -a "$FROM_TYPE" != "DIR" ];then
    
50. 
    
51. 
    
52.         dbg_echo "FROM_TYPE=$FROM_TYPE is unknown,Dropping to shell"
    
53. 
    
54. 
    
55.         exec sh
    
56. 
    
57. 
    
58.     fi
    
59. 
    
60. 
    
61. 
    
62. 
    
63. 
    
64.     if [ ! -b "${FROM_DEV}" ];then
    
65. 
    
66. 
    
67.         dbg_echo "dev=${FROM_DEV} no exsit,Dropping to shell"
    
68. 
    
69. 
    
70.         exec sh
    
71. 
    
72. 
    
73.     fi
    
74. 
    
75. 
    
76. }
    
77. 
    
78. 
    
79. 
    
80. 
    
81. 
    
82. #mount block dev
    
83. 
    
84. 
    
85. mount_dev() {
    
86. 
    
87. 
    
88.     device_mnt=$1
    
89. 
    
90. 
    
91.     dest=$2
    
92. 
    
93. 
    
94.     shift 2
    
95. 
    
96. 
    
97.     if [ ! -b "${device_mnt}" ]; then
    
98. 
    
99. 
    
100.         return 2
     
101. 
     
102. 
     
103.     fi
     
104. 
     
105. 
     
106.     #echo "string=mount_cmd  -o $* ${device_mnt} ${dest}"
     
107. 
     
108. 
     
109.     if mount  -o $* "${device_mnt}" "${dest}" >/dev/null 2>&1; then
     
110. 
     
111. 
     
112.         return 0
     
113. 
     
114. 
     
115.     else
     
116. 
     
117. 
     
118.         if ntfs-3g -o $* "${device_mnt}" "${dest}" >/dev/null 2>&1; then
     
119. 
     
120. 
     
121.             return 0
     
122. 
     
123. 
     
124.         fi
     
125. 
     
126. 
     
127.         return 1
     
128. 
     
129. 
     
130.     fi
     
131. 
     
132. 
     
133. }
     
134. 
     
135. 
     
136. 
     
137. 
     
138. 
     
139. 
     
140. 
     
141. 
     
142. # install busybox symlinks
     
143. 
     
144. 
     
145. /bin/busybox --install -s
     
146. 
     
147. 
     
148. 
     
149. 
     
150. 
     
151. export PATH=/sbin:/bin
     
152. 
     
153. 
     
154. 
     
155. 
     
156. 
     
157. # mount required filesystems
     
158. 
     
159. 
     
160. busybox mount -t proc none /proc
     
161. 
     
162. 
     
163. busybox mount -t sysfs none /sys
     
164. 
     
165. 
     
166. 
     
167. 
     
168. 
     
169. # prepare /dev
     
170. 
     
171. 
     
172. mount -t devtmpfs devtmpfs /dev
     
173. 
     
174. 
     
175. echo '/bin/mdev' > /proc/sys/kernel/hotplug
     
176. 
     
177. 
     
178. mdev -s
     
179. 
     
180. 
     
181. 
     
182. 
     
183. 
     
184. # splash
     
185. 
     
186. 
     
187. /bin/ply-image /plymouth/splash.png
     
188. 
     
189. 
     
190. 
     
191. 
     
192. 
     
193. # parse kernel cmdline
     
194. 
     
195. 
     
196. for arg in $(cat /proc/cmdline); do
     
197. 
     
198. 
     
199.   case $arg in
     
200. 
     
201. 
     
202.       from=*)
     
203. 
     
204. 
     
205.       FROM="${arg#from=}"
     
206. 
     
207. 
     
208.       FROM_FLAG="yes"
     
209. 
     
210. 
     
211.       ;;
     
212. 
     
213. 
     
214.     root=*)
     
215. 
     
216. 
     
217.       ROOT="${arg#root=}"
     
218. 
     
219. 
     
220.       ;;
     
221. 
     
222. 
     
223.     rootfs=*)
     
224. 
     
225. 
     
226.       ROOTFS="${arg#rootfs=}"
     
227. 
     
228. 
     
229.       ;;
     
230. 
     
231. 
     
232.     data=*)
     
233. 
     
234. 
     
235.       DATA="${arg#data=}"
     
236. 
     
237. 
     
238.       ;;
     
239. 
     
240. 
     
241.     init=*)
     
242. 
     
243. 
     
244.       INIT="${arg#init=}"
     
245. 
     
246. 
     
247.       ;;
     
248. 
     
249. 
     
250.     quiet)
     
251. 
     
252. 
     
253.       QUIET=yes
     
254. 
     
255. 
     
256.       ;;
     
257. 
     
258. 
     
259.     persistent*)
     
260. 
     
261. 
     
262.       PERSISTENT="${arg#persistent=}"
     
263. 
     
264. 
     
265.       [ -z "$PERSISTENT" ] && PERSISTENT=casper-rw
     
266. 
     
267. 
     
268.       [ "$PERSISTENT" = persistent ] && PERSISTENT="/casper-rw"
     
269. 
     
270. 
     
271.       ;;
     
272. 
     
273. 
     
274.     nocache)
     
275. 
     
276. 
     
277.       NOCACHE=yes
     
278. 
     
279. 
     
280.       ;;
     
281. 
     
282. 
     
283.     ro|rootro)
     
284. 
     
285. 
     
286.       ROOT_MODE=ro
     
287. 
     
288. 
     
289.       ROOT_MODE_PART=ro
     
290. 
     
291. 
     
292.       ;;
     
293. 
     
294. 
     
295.     rw|rootrw)
     
296. 
     
297. 
     
298.       ROOT_MODE=rw
     
299. 
     
300. 
     
301.       ROOT_MODE_PART=rw
     
302. 
     
303. 
     
304.       ;;
     
305. 
     
306. 
     
307.     nfsroot=*)
     
308. 
     
309. 
     
310.       NFSROOT="${arg#nfsroot=}"
     
311. 
     
312. 
     
313.       ;;
     
314. 
     
315. 
     
316.     ip=*)
     
317. 
     
318. 
     
319.     IP="${arg#ip=}"
     
320. 
     
321. 
     
322.       ;;
     
323. 
     
324. 
     
325.     initshell)
     
326. 
     
327. 
     
328.       echo "Dropping to shell as requested"
     
329. 
     
330. 
     
331.       exec sh
     
332. 
     
333. 
     
334.       ;;
     
335. 
     
336. 
     
337.     debug)
     
338. 
     
339. 
     
340.     DEBUG_FLAG="yes"
     
341. 
     
342. 
     
343.     DEBUG_TXT="initrd.log"
     
344. 
     
345. 
     
346.       ;;
     
347. 
     
348. 
     
349.   esac
     
350. 
     
351. 
     
352. done
     
353. 
     
354. 
     
355. 
     
356. 
     
357. 
     
358. # prase FROM parameter
     
359. 
     
360. 
     
361. prase_from
     
362. 
     
363. 
     
364. 
     
365. 
     
366. 
     
367. # if rootro, always mount root as r/o
     
368. 
     
369. 
     
370. # if rootrw, always mount root as r/w
     
371. 
     
372. 
     
373. # if neither, mount root as r/w only if persistent is enabled and we're
     
374. 
     
375. 
     
376. # mounting a partition (not a disk); otherwise, mount root as r/o
     
377. 
     
378. 
     
379. if [ -z "$ROOT_MODE" ]; then
     
380. 
     
381. 
     
382.   ROOT_MODE=ro
     
383. 
     
384. 
     
385.   if [ -n "$PERSISTENT" ]; then
     
386. 
     
387. 
     
388.     ROOT_MODE_PART=rw
     
389. 
     
390. 
     
391.   else
     
392. 
     
393. 
     
394.     ROOT_MODE_PART=ro
     
395. 
     
396. 
     
397.   fi
     
398. 
     
399. 
     
400. fi
     
401. 
     
402. 
     
403. 
     
404. 
     
405. 
     
406. #try to from iso or dir
     
407. 
     
408. 
     
409. if [ -n "$FROM_FLAG" ]; then
     
410. 
     
411. 
     
412.     mkdir -p /.partition
     
413. 
     
414. 
     
415.     mkdir -p /.cache
     
416. 
     
417. 
     
418. #        if mount -o ro "$FROM_DEV" /.partition >/dev/null 2>&1; then
     
419. 
     
420. 
     
421.     if mount_dev "$FROM_DEV" /.partition $ROOT_MODE_PART; then
     
422. 
     
423. 
     
424.         echo -e "\033[36;1mmount FROM_DEV=$FROM_DEV sucess\033[0m"
     
425. 
     
426. 
     
427.         dbg_echo "mount FROM_DEV=$FROM_DEV sucess"
     
428. 
     
429. 
     
430.         case $FROM_TYPE in
     
431. 
     
432. 
     
433.             ISO)   
     
434. 
     
435. 
     
436.             mkdir -p /.temp
     
437. 
     
438. 
     
439.             
     
440. 
     
441. 
     
442.             if mount -o loop,ro /.partition/$FROM_BASIC /.temp >/dev/null 2>&1; then
     
443. 
     
444. 
     
445.                 if ! mount -t tmpfs tmpfs /.cache >/dev/null 2>&1; then
     
446. 
     
447. 
     
448.                     dbg_echo "get tmpfs failed"
     
449. 
     
450. 
     
451.                     exec sh
     
452. 
     
453. 
     
454.                 fi
     
455. 
     
456. 
     
457.                 cp /.temp/rootfs /.cache/rootfs
     
458. 
     
459. 
     
460.                 if ! mount --move /.cache /mnt >/dev/null 2>&1; then
     
461. 
     
462. 
     
463.                     dbg_echo "ISO deal failed: mount --move"
     
464. 
     
465. 
     
466.                     exec sh
     
467. 
     
468. 
     
469.                 fi
     
470. 
     
471. 
     
472.                 umount /.temp
     
473. 
     
474. 
     
475.                 umount /.partition
     
476. 
     
477. 
     
478.                 echo -e "\033[36;1mmount FROM_BASIC=$FROM_BASIC sucess\033[0m"
     
479. 
     
480. 
     
481.                 dbg_echo "mount FROM_BASIC=$FROM_BASIC sucess"
     
482. 
     
483. 
     
484.                 if mount -t squashfs /mnt/rootfs /squashfs >/dev/null 2>&1; then
     
485. 
     
486. 
     
487.                         dbg_echo "found."
     
488. 
     
489. 
     
490.                         FOUND_ROOTFS=yes
     
491. 
     
492. 
     
493.                 else
     
494. 
     
495. 
     
496.                     dbg_echo "failed, cannot mount squashfs."
     
497. 
     
498. 
     
499.                         umount /mnt
     
500. 
     
501. 
     
502.                     umount /.partition
     
503. 
     
504. 
     
505.                    fi                    
     
506. 
     
507. 
     
508.             else
     
509. 
     
510. 
     
511.                 echo -e "\033[31;1mmount FROM_BASIC=$FROM_BASIC failed\033[0m"
     
512. 
     
513. 
     
514.                 dbg_echo "mount FROM_BASIC=$FROM_BASIC failed"
     
515. 
     
516. 
     
517.                 umount /.partition   
     
518. 
     
519. 
     
520.                 exec sh
     
521. 
     
522. 
     
523.             fi
     
524. 
     
525. 
     
526.             ;;
     
527. 
     
528. 
     
529.             DIR)
     
530. 
     
531. 
     
532.                 if [ -z "$PERSISTENT" ] ; then
     
533. 
     
534. 
     
535.                     mount -t tmpfs tmpfs /.cache                    
     
536. 
     
537. 
     
538.                     cp /.partition/${FROM_BASIC}/rootfs /.cache/rootfs
     
539. 
     
540. 
     
541.                     mount --move /.cache /mnt
     
542. 
     
543. 
     
544.                     ROOTFS=/mnt/rootfs
     
545. 
     
546. 
     
547.                     umount /.partition
     
548. 
     
549. 
     
550.                 else
     
551. 
     
552. 
     
553.                     ROOTFS=/.partition/${FROM_BASIC}/rootfs
     
554. 
     
555. 
     
556.                 fi
     
557. 
     
558. 
     
559.             
     
560. 
     
561. 
     
562.                 if mount -t squashfs $ROOTFS /squashfs >/dev/null 2>&1; then
     
563. 
     
564. 
     
565.                         dbg_echo "found."
     
566. 
     
567. 
     
568.                         FOUND_ROOTFS=yes
     
569. 
     
570. 
     
571.                 else
     
572. 
     
573. 
     
574.                     dbg_echo "failed, cannot mount squashfs."
     
575. 
     
576. 
     
577.                     umount /.partition
     
578. 
     
579. 
     
580.                    fi
     
581. 
     
582. 
     
583. 
     
584. 
     
585. 
     
586.                   
     
587. 
     
588. 
     
589. 
     
590. 
     
591. 
     
592.             ;;
     
593. 
     
594. 
     
595.         esac
     
596. 
     
597. 
     
598.     else
     
599. 
     
600. 
     
601.         echo -e "\033[31;1mmount FROM_DEV=$FROM_DEV failed\033[0m"
     
602. 
     
603. 
     
604.         deg_echo "mount FROM_DEV=$FROM_DEV failed"
     
605. 
     
606. 
     
607.         exec sh
     
608. 
     
609. 
     
610.     fi
     
611. 
     
612. 
     
613. fi
     
614. 
     
615. 
     
616. 
     
617. 
     
618. 
     
619. 
     
620. 
     
621. 
     
622. # try to mount the rootfs specified in cmdline ... and wait for slow device
     
623. 
     
624. 
     
625. [ -z "$ROOT" -a "$ROOTFS" = flat ] && ROOTFS="/rootfs"
     
626. 
     
627. 
     
628. [ -z "$ROOTFS" ] && ROOTFS="/rootfs"
     
629. 
     
630. 
     
631. if [ -z "$FROM_FLAG" -a -n "$ROOT" ]; then
     
632. 
     
633. 
     
634.   COUNT="0 1 2 3 4 5 6 7 8 9"
     
635. 
     
636. 
     
637.   for i in $COUNT; do
     
638. 
     
639. 
     
640.     dbg_echo -n "[$i] Trying root=$ROOT as requested..."
     
641. 
     
642. 
     
643. #    if mount -o $ROOT_MODE $ROOT /mnt >/dev/null 2>&1; then
     
644. 
     
645. 
     
646.     if mount_dev $ROOT /mnt $ROOT_MODE; then   
     
647. 
     
648. 
     
649.       if [ "$ROOTFS" = flat ]; then
     
650. 
     
651. 
     
652.         dbg_echo "found."
     
653. 
     
654. 
     
655.         FOUND_ROOTFS=yes
     
656. 
     
657. 
     
658.         break
     
659. 
     
660. 
     
661.       elif mount -t squashfs /mnt/$ROOTFS /squashfs >/dev/null 2>&1; then
     
662. 
     
663. 
     
664.         dbg_echo "found."
     
665. 
     
666. 
     
667.         FOUND_ROOTFS=yes
     
668. 
     
669. 
     
670.         break
     
671. 
     
672. 
     
673.       else
     
674. 
     
675. 
     
676.         dbg_echo "failed, cannot mount squashfs."
     
677. 
     
678. 
     
679.         umount /mnt
     
680. 
     
681. 
     
682.       fi
     
683. 
     
684. 
     
685.     else
     
686. 
     
687. 
     
688.       dbg_echo "failed, cannot mount device."
     
689. 
     
690. 
     
691.     fi
     
692. 
     
693. 
     
694.     sleep 1
     
695. 
     
696. 
     
697.   done
     
698. 
     
699. 
     
700.   [ -n "$FOUND_ROOTFS" ] || unset ROOT
     
701. 
     
702. 
     
703.   unset FOUND_ROOTFS
     
704. 
     
705. 
     
706. fi
     
707. 
     
708. 
     
709. 
     
710. 
     
711. 
     
712. if [ -z "$FROM_FLAG" -a -n "$NFSROOT" ] ; then
     
713. 
     
714. 
     
715.   dbg_echo -n "Trying nfsroot=$NFSROOT as requested..."
     
716. 
     
717. 
     
718.   ROOT=/mnt
     
719. 
     
720. 
     
721.   if [ -z "$IP" ] ; then
     
722. 
     
723. 
     
724.     ifconfig eth0 up >/dev/null 2>&1
     
725. 
     
726. 
     
727.     udhcpc -s /bin/assign-ip >/dev/null 2>&1
     
728. 
     
729. 
     
730.   fi
     
731. 
     
732. 
     
733.   if mount -o nolock,$ROOT_MODE_PART $NFSROOT /mnt >/dev/null 2>&1; then
     
734. 
     
735. 
     
736.     if mount -t squashfs /mnt/rootfs /squashfs >/dev/null 2>&1; then
     
737. 
     
738. 
     
739.       dbg_echo "found."
     
740. 
     
741. 
     
742.       FOUND_ROOTFS=yes
     
743. 
     
744. 
     
745.     else
     
746. 
     
747. 
     
748.       dbg_echo -n "failed, cannot mount squashfs."
     
749. 
     
750. 
     
751.       umount /mnt
     
752. 
     
753. 
     
754.     fi
     
755. 
     
756. 
     
757.   else
     
758. 
     
759. 
     
760.     dbg_echo -n "failed, cannot mount $NFSROOT."
     
761. 
     
762. 
     
763.   fi
     
764. 
     
765. 
     
766.   [ -n "$FOUND_ROOTFS" ] || unset ROOT
     
767. 
     
768. 
     
769.   unset FOUND_ROOTFS
     
770. 
     
771. 
     
772. fi
     
773. 
     
774. 
     
775. 
     
776. 
     
777. 
     
778. # ...otherwise just scan the block devices for rootfs
     
779. 
     
780. 
     
781. if [ -z "$FROM_FLAG" -a -z "$ROOT" ]; then
     
782. 
     
783. 
     
784.   dbg_echo "Scanning for root device:"
     
785. 
     
786. 
     
787.   cd /sys/block
     
788. 
     
789. 
     
790.   for i in 0 1 2 3 4 5 6 7 8 9; do
     
791. 
     
792. 
     
793.     for dev in *; do
     
794. 
     
795. 
     
796.       echo $dev | grep -q loop && continue
     
797. 
     
798. 
     
799.       echo $dev | grep -q ram && continue
     
800. 
     
801. 
     
802.       dbg_echo -n "[$i] Trying $dev..."
     
803. 
     
804. 
     
805. #      if mount -o $ROOT_MODE /dev/$dev /mnt >/dev/null 2>&1; then
     
806. 
     
807. 
     
808.       if mount_dev /dev/$dev /mnt $ROOT_MODE; then
     
809. 
     
810. 
     
811.         ROOT_DEV=$dev
     
812. 
     
813. 
     
814.         if [ `cat /sys/block/$ROOT_DEV/device/type` -eq 5 ]; then
     
815. 
     
816. 
     
817.           ROOT_TYPE=cdrom
     
818. 
     
819. 
     
820.         else
     
821. 
     
822. 
     
823.           ROOT_TYPE=disk
     
824. 
     
825. 
     
826.         fi
     
827. 
     
828. 
     
829.       else
     
830. 
     
831. 
     
832. ########################################
     
833. 
     
834. 
     
835.     for dev_part in `ls $dev | grep $dev`; do
     
836. 
     
837. 
     
838.         dbg_echo -n "[$i] Trying ${dev_part}..."
     
839. 
     
840. 
     
841. #        if ! mount -o $ROOT_MODE_PART /dev/${dev_part} /mnt >/dev/null 2>&1; then
     
842. 
     
843. 
     
844.         if ! mount_dev /dev/${dev_part} /mnt $ROOT_MODE_PART; then
     
845. 
     
846. 
     
847.             dbg_echo "failed, cannot mount device."
     
848. 
     
849. 
     
850.         else
     
851. 
     
852. 
     
853.             if mount -t squashfs /mnt/$ROOTFS /squashfs >/dev/null 2>&1; then
     
854. 
     
855. 
     
856.                     dbg_echo "found."
     
857. 
     
858. 
     
859.                     FOUND_ROOTFS=yes
     
860. 
     
861. 
     
862.                 ROOT_DEV=${dev_part}
     
863. 
     
864. 
     
865.                 ROOT_TYPE=disk
     
866. 
     
867. 
     
868.                     break 2
     
869. 
     
870. 
     
871.               else
     
872. 
     
873. 
     
874.                   dbg_echo "failed, cannot mount squashfs."
     
875. 
     
876. 
     
877.                   umount /mnt
     
878. 
     
879. 
     
880.             fi            
     
881. 
     
882. 
     
883.         fi
     
884. 
     
885. 
     
886.     done
     
887. 
     
888. 
     
889. 
     
890. 
     
891. 
     
892. #####################################
     
893. 
     
894. 
     
895.       fi
     
896. 
     
897. 
     
898.       if [ "$ROOT_TYPE" = cdrom -a -z "$NOCACHE" ]; then
     
899. 
     
900. 
     
901.         mkdir /cache
     
902. 
     
903. 
     
904.         mount -t tmpfs tmpfs /cache
     
905. 
     
906. 
     
907.         cp /mnt/$ROOTFS /cache/rootfs
     
908. 
     
909. 
     
910.         ROOTFS=/rootfs
     
911. 
     
912. 
     
913.         umount /mnt
     
914. 
     
915. 
     
916.         eject -s $ROOT_DEV >/dev/null 2>&1 || eject $ROOT_DEV >/dev/null 2>&1
     
917. 
     
918. 
     
919.         mount --move /cache /mnt
     
920. 
     
921. 
     
922.       fi
     
923. 
     
924. 
     
925.       if mount -t squashfs /mnt/$ROOTFS /squashfs >/dev/null 2>&1; then
     
926. 
     
927. 
     
928.         dbg_echo "found."
     
929. 
     
930. 
     
931.         FOUND_ROOTFS=yes
     
932. 
     
933. 
     
934.         break
     
935. 
     
936. 
     
937.       else
     
938. 
     
939. 
     
940.         dbg_echo "failed, cannot mount squashfs."
     
941. 
     
942. 
     
943.         umount /mnt
     
944. 
     
945. 
     
946.       fi
     
947. 
     
948. 
     
949.     done
     
950. 
     
951. 
     
952.     [ -n "$FOUND_ROOTFS" ] && break
     
953. 
     
954. 
     
955.     sleep 1
     
956. 
     
957. 
     
958.   done
     
959. 
     
960. 
     
961.   cd /
     
962. 
     
963. 
     
964. fi
     
965. 
     
966. 
     
967. 
     
968. 
     
969. 
     
970. [ -z "$INIT" ] && INIT=/bin/systemd
     
971. 
     
972. 
     
973. 
     
974. 
     
975. 
     
976. if [ "$ROOTFS" = flat ]; then
     
977. 
     
978. 
     
979.   if [ ! -x /mnt/$INIT ]; then
     
980. 
     
981. 
     
982.     echo "Cannot find a valid root filesystem, dropping to shell"
     
983. 
     
984. 
     
985.     exec sh
     
986. 
     
987. 
     
988.   fi
     
989. 
     
990. 
     
991.   mount --move /mnt /newroot
     
992. 
     
993. 
     
994. else
     
995. 
     
996. 
     
997.   if [ ! -x /squashfs/$INIT ]; then
     
998. 
     
999. 
     
1000.     echo "Cannot find a valid root filesystem, dropping to shell"
      
1001. 
      
1002. 
      
1003.     exec sh
      
1004. 
      
1005. 
      
1006.   fi
      
1007. 
      
1008. 
      
1009. 
      
1010. 
      
1011. 
      
1012.   # setup aufs
      
1013. 
      
1014. 
      
1015.   if [ -n "$PERSISTENT" ]; then   
      
1016. 
      
1017. 
      
1018.    DATA=/mnt/$PERSISTENT
      
1019. 
      
1020. 
      
1021.    PERSISTENT_OPT="-o loop -t ext2"
      
1022. 
      
1023. 
      
1024.    if [ -n "$FROM_FLAG" ];then
      
1025. 
      
1026. 
      
1027.     case $FROM_TYPE in
      
1028. 
      
1029. 
      
1030.         ISO)
      
1031. 
      
1032. 
      
1033.             unset DATA
      
1034. 
      
1035. 
      
1036.         ;;
      
1037. 
      
1038. 
      
1039.         DIR)
      
1040. 
      
1041. 
      
1042.             DATA=/.partition/$FROM_BASIC/casper-rw
      
1043. 
      
1044. 
      
1045.         ;;
      
1046. 
      
1047. 
      
1048.     esac
      
1049. 
      
1050. 
      
1051.    fi
      
1052. 
      
1053. 
      
1054.    [ ! -f "$DATA" ] && unset DATA && unset PERSISTENT_OPT
      
1055. 
      
1056. 
      
1057.   fi
      
1058. 
      
1059. 
      
1060.   
      
1061. 
      
1062. 
      
1063.   if [ -n "$DATA" ]; then
      
1064. 
      
1065. 
      
1066.     if ! mount $PERSISTENT_OPT -o rw,noatime $DATA /rw; then
      
1067. 
      
1068. 
      
1069.       dgb_echo "Cannot mount data partition, using tmpfs instead"
      
1070. 
      
1071. 
      
1072.       unset DATA
      
1073. 
      
1074. 
      
1075.       exec sh
      
1076. 
      
1077. 
      
1078.     fi
      
1079. 
      
1080. 
      
1081.   fi
      
1082. 
      
1083. 
      
1084.   [ -z "$DATA" ] && mount -t tmpfs none /rw
      
1085. 
      
1086. 
      
1087.   if ! mount -t aufs -o br=/rw:/squashfs none /newroot; then
      
1088. 
      
1089. 
      
1090.     dbg_echo "Cannot mount aufs, dropping to shell"
      
1091. 
      
1092. 
      
1093.     exec sh
      
1094. 
      
1095. 
      
1096.   fi
      
1097. 
      
1098. 
      
1099. 
      
1100. 
      
1101. 
      
1102.   # move backed filesystems inside newroot otherwise aufs won't work properly
      
1103. 
      
1104. 
      
1105.   mkdir -p /newroot/run
      
1106. 
      
1107. 
      
1108.   mount -t tmpfs -o mode=0755,nosuid,nodev tmpfs /newroot/run
      
1109. 
      
1110. 
      
1111.   mkdir -p /newroot/.data /newroot/.squashfs /newroot/.root
      
1112. 
      
1113. 
      
1114.   mount --move /rw /newroot/.data
      
1115. 
      
1116. 
      
1117.   mount --move /squashfs /newroot/.squashfs
      
1118. 
      
1119. 
      
1120.   mount --move /mnt /newroot/.root
      
1121. 
      
1122. 
      
1123.   mkdir -p /newroot/run/initramfs/bin /newroot/run/initramfs/sbin
      
1124. 
      
1125. 
      
1126.   cp -P /bin/busybox /bin/sh /newroot/run/initramfs/bin/
      
1127. 
      
1128. 
      
1129.   cp -P /bin/shutdown /newroot/run/initramfs/
      
1130. 
      
1131. 
      
1132. fi
      
1133. 
      
1134. 
      
1135. 
      
1136. 
      
1137. 
      
1138. INIT_ARGS=`cat /proc/cmdline`
      
1139. 
      
1140. 
      
1141. 
      
1142. 
      
1143. 
      
1144. # Reset kernel hotplugging
      
1145. 
      
1146. 
      
1147. echo "" > /proc/sys/kernel/hotplug
      
1148. 
      
1149. 
      
1150. umount /sys
      
1151. 
      
1152. 
      
1153. umount /dev
      
1154. 
      
1155. 
      
1156. umount /proc
      
1157. 
      
1158. 
      
1159. 
      
1160. 
      
1161. 
      
1162. # Change to the new root partition and execute /sbin/init
      
1163. 
      
1164. 
      
1165. if ! exec /bin/busybox switch_root /newroot $INIT $INIT_ARGS; then
      
1166. 
      
1167. 
      
1168.   echo "Failed, dropping to shell"
      
1169. 
      
1170. 
      
1171.   /bin/busybox mount -t proc none /proc
      
1172. 
      
1173. 
      
1174.   /bin/busybox mount -t sysfs none /sys
      
1175. 
      
1176. 
      
1177.   exec sh
      
1178. 
      
1179. 
      
1180. fi

复制代码

my9823

不知道能不能把CDLinux和GeexBox组合起来，用CDLinux的initrd 加上 GeexBox的 rootfs ？


应该不行，给你个链接,介绍initrd机制的，在ibm网站上找到的！

http://www.ibm.com/developerworks/cn/linux/l-k26initrd/

rockrock99

2.0.1的内测版本已经发布，大家不妨测试一下