| 10 ขั้นตอน สร้างลีนุกซ์อย่างที่ใจต้องการ |
 |
“เคอร์เนล ก็คือตัวที่ทำหน้าที่คอยประสานงานระหว่างซอฟต์แวร์และ ฮาร์ดแวร์ของคุณ โดยทำหน้าที่จัดการหน่วยความจำให้สำหรับทุกโปรแกรมที่ทำงานอยู่บนระบบ และจะบริหารในส่วนของการแบ่งให้เข้าใช้ซีพียูอย่างยุติธรรม รวมทั้งเตรียมการในส่วนของการให้โปรแกรมติดต่อกับฮาร์ดแวร์ นี่คืองานหลักที่อยากให้รู้จัก”
ส่วน Loadable Module ก็คือชิ้นส่วนของเคอร์เนลโค้ดที่ไม่ถูกรวมเข้าไปในเคอร์เนลตรงๆ เราสามารถคอมไพล์มันแยกออกมาต่างหาก และสามารถเพิ่มหรือลบมันออกจากเคอร์เนล ที่กำลังให้บริการอยู่ได้ตลอดเวลา ตัวอย่างพวกที่เป็น Loadable Module ก็คือไดร์ฟเวอร์ของ PCMCIA, Network Adapter และ Tape Backup
เมื่อก่อนตอนใช้งานลีนุกซ์ใหม่ๆ เคยติดตั้งแล้วปรากฏว่าระบบหาแลนการ์ดไม่เจอ ตกใจเลยให้เพื่อนๆ พี่ๆ ช่วยกันดู เขาบอกว่าอย่างนี้ต้องคอมไพล์เคอร์เนลใหม่ ได้ยินแล้วจะเป็นลมเพราะทำเองไม่เป็น แล้วยังบอกอีกว่าคอมไพล์เคอร์เนล ใช้เวลานานและอาจจะคอมไพล์ไม่ผ่านด้วย ถ้าคอมไพล์ไม่ผ่านก็ต้องลงเริ่มต้นลงกันใหม่หมดเลย ฟังดูแล้วนึกเสียดายไหนๆ ก็ลงอะไรไปตั้งมากมายแล้ว ทางออกที่ดีตอนนั้นไปเลือกซื้อแลนการ์ดตัวใหม่ที่ระบบรองรับดีกว่า เอาแบบเสียบปุ๊บใช้ได้เลย
ตอนนี้มานั่งนึกแล้วก็ขำ พอกันเลยทั้งคนหัดเล่นและก็คนที่เรียกได้ว่าเล่นมาก่อน เพราะสิ่งที่เล่าให้ฟังนั้นก็ใช่ว่าจะไม่จริงไปทุกเรื่อง อย่างน้อยที่บอกว่าต้องคอมไพล์เคอร์เนลใหม่นั้นก็ถูกหนึ่งอย่างละ ส่วนที่บอกว่าถ้าคอมไพล์แล้วไม่ผ่านต้องลงระบบใหม่อันนี้ขอค้าน อีกอย่างเรื่องของเวลาที่ใช้นั้นมันก็ขึ้นอยู่กับเครื่องที่ใช้แหละว่าแรงพอ หรือเปล่า
เพื่อไม่ให้เป็นการเสียเวลามาดูกันเลยดีกว่าว่าขั้นตอนคอมไพล์นั้นมีอะไรกัน บ้าง แล้วความจริงจะปรากฏว่าทำไม่ผ่านก็ไม่ต้องกลัวระบบยังใช้ได้อยู่ คอมไพล์เคอร์เนลไม่ใช่เรื่องยากอย่างที่คิด
Environment :
Before : เคอร์เนลเก่าของคุณคือ 2.2.14-5.0
After : เคอร์เนลใหม่ที่จะทำการคอมไพล์คือ linux-2.4.20.tar.gz
Step 1
เริ่มต้นด้วยการหาว่า Source ของเคอร์เนลตัวปัจจุบันของคุณเก็บไว้อยู่ที่ไหน โดยทั่วไปแล้วจะถูกเก็บอยู่ที่ /usr/src/ เมื่อทำการ List File จะเห็นว่ามี Link ไปยัง Source Code ของเคอร์เนลเวอร์ชันนั้นๆ อีกที
เพื่อไม่ให้เกิดความผิดพลาดในการคอมไพล์เคอร์เนล ที่ระบบใช้อยู่ก็ตรวจสอบกันก่อนว่าคุณกำลังใช้งานเคอร์เนลเวอร์ชันไหนอยู่ด้วยคำสั่ง
#uname -r
Step 2
ตามหาเคอร์เนลใหม่ที่เราต้องการ มาไว้ในครอบครอง หาเอาง่ายๆ จากอินเทอร์เน็ตเลยอยากได้ตัวไหนก็ดาวน์โหลดมาซะ อย่าลืมอ่านข้อมูลที่เขาแถมมาด้วยนะ ว่ามีอะไรมาให้บ้าง ไฟล์ที่ได้จะมีชื่อลักษณะคล้ายๆ linux-2.4.x-x.tar.gz
ก่อนจะติดตั้ง Source Code ของลีนุกซ์ ให้ทำการตรวจสอบก่อนว่าเวลาติดตั้งลงไป Code จะถูกเก็บไว้ที่ไหนด้วยคำสั่ง
#tar tzvpf source_filename
ในที่นี้ก็คือ
#tar tzvpf linux-2.4.20.tar.gz
สิ่งที่ได้ก็คือรายการของ Files และ Path ที่จะทำการติดตั้ง คำสั่งนี้เป็นการตรวจสอบและแสดงผลเท่านั้น ยังไม่มีการติดตั้งใดๆ เกิดขึ้น
การติดตั้งที่แท้จริงต้องแบบนี้
#mv linux-2.4.20.tar.gz /usr/src
เพื่อย้าย path ไปยัง /usr/src ตามด้วย
#tar xzvpf linux-2.4.20.tar.gz
แต่ถ้าคุณเห็นว่ามันจะถูกนำไปติดตั้งลงที่อื่น เช่น ไดเรคทอรี linux-2.4.20 แทนที่จะเป็นไดเรคทอรี linux แล้วละก็ให้คุณทำ Symbolic Link จาก Source Code ใหม่ที่คุณแตกแล้วไปยังไดเรคทอรี linux ด้วยคำสั่ง
#rm linux
#ln -s linux-2.4.20/ linux
อย่าพยายามลบ Source Code เก่าทิ้ง เพราะอย่างน้อยถ้าเคอร์เนลใหม่ที่คุณคอมไพล์ขึ้นมาไม่สามารถใช้งานได้จะได้ใช้ของเก่านั้น คอมไพล์ขึ้นมาใช้งานได้เหมือนเดิม
Step3
จัดการอ่านเอกสารเกี่ยวกับเคอร์เนลใหม่ที่คุณได้มา ทุกเวอร์ชันของ Source Code ที่ได้มาจะมีเอกสารมาด้วยอยู่แล้ว หากไม่รู้จะเริ่มตรงไหนแนะนำให้อ่านไฟล์ต่อไปนี้
/usr/src/linux/README เอกสารเกี่ยวกับการสอนวิธีการคอมไพล์เคอร์เนล
/usr/src/linux/MAINTAINERS เอกสารเกี่ยวกับนักพัฒนาเคอร์เนล
/usr/src/linux/Documentation/* เอกสารอธิบาย แต่ละส่วนของเคอร์เนล
แล้วก็ได้เวลาของการเริ่มลงมือกันเสียที โดยส่วนใหญ่การคอมไพล์เคอร์เนลจะเกี่ยวข้องกับการใช้คำสั่ง make เลยจะขออธิบายให้เข้าใจกันซักหน่อยว่า make เป็นโปรแกรมที่ใช้ในการแปลหรือคอมไพล์ Source ต่างๆ จากนั้นก็จะสร้างไฟล์ประเภท Object และทำการเชื่อมต่อ (Link) มันขึ้นมาเพื่อรองรับการเรียกใช้งานของระบบ โปรแกรม make ไม่เพียงแต่เรียกใช้งาน Compiler ให้ทำหน้าที่แปล Source เท่านั้น มันยังทำหน้าที่ดูแลในส่วนที่เรียกว่า dependencies ด้วย
dependencies ก็คือเงื่อนไขที่ว่าการกระทำบางส่วนจะสามารถเกิดขึ้นได้ก็ต่อเมื่อมีการกระทำส่วนหนึ่งเกิดขึ้นก่อนหน้านั้นแล้ว เช่น คุณจะคอมไพล์ Module ในส่วนของการ FTP ก็ต้องมีการคอมไพล์ Module ในส่วนของ Security ที่เตรียมไว้อยู่แล้วนั่นเอง
make จะทำงานคู่กับ Source ที่ชื่อว่า Makefile ซึ่ง อย่างไรก็ตาม โปรแกรม make ฉลาดพอที่จะคอย Link เฉพาะส่วนของโปรแกรมที่คุณเลือกคอมไพล์เท่านั้น เช่นเคอร์เนลนั้นไฟล์ Makefile จะเปรียบเสมือนเป็นโครงสร้างของเคอร์เนล โดยนอกจาก make คอยเรียกใช้ตัว Compiler และ Linker เพื่อประมวลผลตัว Makefile ของเคอร์เนลแล้ว make ยังใช้ในการ run โปรแกรมและเรียกโปรแกรมที่เป็น Initialisation Script มาช่วยประมวลผลเคอร์เนลอีกด้วย
Step4
การตั้งค่าเคอร์เนล คุณสามารถเลือกทำได้หลายวิธี ซึ่งทุกวิธีให้ผลเหมือนกัน เลือกเอาตามความพอใจไม่ว่าจะเป็นเท็กซ์โหมด กราฟิกบนเท็กซ์โหมด หรือแบบกราฟิกบน X ก็ยังไหว
make xconfig
แบบนี้เป็นการใช้งานผ่าน X Window ดังนั้นสิ่งที่คุณจะได้ก็คือการปรับแต่งค่าเคอร์เนลผ่านเครื่องมือที่เป็น GUI
วิธีใช้งาน
หลังจากเข้าสู่การทำงานของ X Window แล้วให้เปิดโปรแกรมเทอร์มินอล ย้ายการทำงานไปที่ไดเรคทอรี /usr/src/linux
#cd /usr/src/linux
จากนั้นก็เรียก make xconfig ขึ้นมาใช้งาน
#make xconfig
จากคำสั่งข้างต้นจะปรากฏหน้าจอ
ถ้าคุณต้องการให้เคอร์เนลใหม่ของคุณรองรับการ load แบบ module ให้เลือก Loadable module support จะ ปรากฏหน้าจอ
make menuconfig
เป็น GUI แบบเท็กซ์โหมด ความสวยงามอาจจะลดไปบ้างแต่ยังคงความสามารถไว้เหมือนเดิม
วิธีใช้งาน
| Note: ในกรณีการคอมไพล์เคอร์เนลใหม่แต่ใช้ Source Code ของเวอร์ชันเดิมคุณควรแก้ไขข้อมูลบางส่วนใน Makefile ก่อนใช้คำสั่ง make เพื่อไม่ให้เวอร์ชันของเคอร์เนลทับกัน คำสั่งที่ใช้ [root@portal src]# cd /usr/src/linux [root@portal linux]# vi Makefile  ทำการแก้ไขในส่วนของ EXTRAVERSION ในไฟล์ที่คุณ จะคอมไพล์ จาก -5.0 เป็น -5.0-compile สาเหตุที่ต้องทำก็เพื่อไม่ให้เกิดการคอมไพล์เคอร์เนลทับตัว Image ตัวเดิม (กรณีที่เกิดความผิดพลาดขณะคอมไพล์) |
ย้ายการทำงานไปที่ไดเรคทอรี /usr/src/linux
#cd /usr/src/linux
ตั้งค่าการทำงานของหน้าจอป้องกันการแสดงผล ผิดพลาด
#export TERM=vt100
แล้วก็อย่ารอช้าเรียกใช้งาน make menuconfig กันเลย
#make menuconfig
ทำการเลือกลักษณะของเคอร์เนลใหม่ที่คุณต้องการโดยแต่ละเมนูจะมีคำอธิบายอยู่ ในเอกสารแล้วว่าถ้าเลือกเสร็จแล้ว เคอร์เนลของคุณจะมีคุณสมบัติรองรับการทำงานในส่วนไหนเพิ่มขึ้นบ้าง
make config
สำหรับผู้นิยมการทำงานเท็กซ์โหมดแบบล้วนๆ ไม่สน GUI ตัวอย่างก็แบบนี้เลย
rm -f include/asm
( cd include ; ln -sf asm-i386 asm)
/bin/sh scripts/Configure arch/i386/config.in
#
# Using defaults found in .config
#
*
* Code maturity level options
*
Prompt for development and/or incomplete code/drivers (CONFIG_EXPERIMENTAL)[N/y?] n
*
* Loadable module support
*
Enable loadable module support (CONFIG_MODULES) [Y/n/?] Y
Set version information on all symbols for modules (CONFIG_MODVERSIONS)[N/y/?]
Kernel daemon support (e.g. autoload of modules) (CONFIG_KERNELD) [N/y/?] y
*
* General setup
*
Kernel math emulation (CONFIG_MATH_EMULATION) [Y/n/?]
| Note : 1. คำถามที่ปรากฏขึ้นมาจะมีคำตอบให้เป็นค่า Default อยู่ แล้วและคำตอบ Default เหล่านี้จะเปลี่ยนไปตามการเลือก ครั้งล่าสุดในคำถามต่อไป ถ้า Default ของคำตอบแรกเป็น “N” และคุณเลือกตอบ “Y” Default ของคำตอบของคำถาม ต่อไปจะเปลี่ยนเป็น “Y” ซึ่งหมายความว่าถ้าคุณต้องการ ตอบคำถามเหมือน ค่าคำตอบที่ขึ้นมาเป็น Default คุณก็เพียง แค่กด Enter ไปตลอดการตั้งค่าเคอร์เนลนั่นเอง 2. คำถามช่วงแรกจะเกี่ยวข้องกับการตั้งค่าพื้นฐานของเคอร์เนล เพราะฉะนั้นต้องระมัดระวังเป็นพิเศษในการตอบคำถาม เช่น ถ้าคุณต้องการให้เคอร์เนลใหม่ของคุณรองรับการ Load แบบ Module ละก็ ให้สังเกตตามตัวอย่างต่อไปนี้ |
*
* Additional Block Devices
*
Loopback device support (CONFIG_BLK_DEV_LOOP) [N/y/m/?]
Multiple devices driver support (CONFIG_BLK_DEV_MD) [N/y/?]
RAM disk support (CONFIG_BLK_DEV_RAM) [Y/m/n/?]
Initial RAM disk (initrd) support (CONFIG_BLK_DEV_INITRD) [N/y/?]
XT harddisk support (CONFIG_BLK_DEV_XD) [N/y/m/?]
จะเห็น Option ของคำตอบมีค่าที่แสดงเป็นตัว “m” ซึ่งหมายความว่าถ้าหากคุณเลือก “m” จะทำให้อุปกรณ์ชิ้นนั้นสามารถคอมไพล์เป็นแบบ Module ได้ นั่นก็คือไม่ต้องการทำการรวมเอาไดร์ฟเวอร์ตัวนั้นเข้าเป็นส่วนหนึ่งของเคอร์เนล แต่จะคอมไพล์เป็น Module แยกต่างหากเวลาจะใช้งานให้ Load ขึ้นมาเอง
สิ่งที่ควรเลือก
Enable the Loadable kernel modules support!
Option นี้จะทำให้คุณสามารถเลือกที่จะ Load หรือ Remove Module ของคุณขึ้นมาเมื่อไหร่ก็ได้ดังรูป (ตัวอย่างจากการเรียกใช้ make menuconfig)
เมื่อเลือก Select จะปรากฏหน้าจอให้ทำเครื่องหมาย “*” ที่หน้า Option ที่คุณต้องการเลือกโดยการกด Spacebar บน Keyboard นั่นเอง
เมื่อคุณจัดเก็บและออกจากเมนู “make menuconfig” ค่าของสิ่งที่คุณเลือกไปแล้วทั้งหมดจะถูกจัดเก็บลงในไฟล์ /usr /src/linux/.config (อ่านว่าไฟล์ด็อทคอนฟิก)
กรณีที่คุณออกจากเมนูแต่ไม่ได้ทำการบันทึก Config ที่เลือกไว้ระบบจะถามให้คุณบันทึกค่าดังกล่าว ซึ่งโดย Default แล้วระบบจะจัดเก็บให้คุณในชื่อ .config ที่อยู่ใน path /usr/src/linux นั่นเอง
คุณสามารถบันทึก Config ของเคอร์เนลเป็นชื่อใดๆ ก็ได้หากคุณต้องการ โดยเลือกไปที่ Save configuration to an Alternate file
ใส่ชื่อที่ต้องการให้บันทึกเป็น .config
ระบบจะจัดเก็บให้คุณในชื่อ kernel.config ที่อยู่ใน path/usr/src/linux
เมื่อต้องการ Load เคอร์เนลที่ config ไว้แล้วมาแก้ไขให้ทำการเรียกคำสั่ง make menuconfig ขึ้นมาอีกครั้งแล้วเลือก Load an Alternate Configuration File
สิ่งที่คุณเลือกจะปรากฏหน้าจอ
| เรื่องน่ารู้ของ .config : 1.สามารถจัดเก็บไว้และเรียกขึ้นมาแก้ไขต่อโดยยังไม่ต้องเรียกคำสั่งต่อไป หากยังทำการกำหนดค่าของเคอร์เนลนั้นๆ ไม่เสร็จ 2.กรณีที่แก้ไขค่าของเคอร์เนล แล้วได้ผลดีต้องการนำไปใช้กับเครื่องอื่นๆ ก็สามารถนำไฟล์นี้ไปใช้ได้เลย |
ค่าของเคอร์เนลที่เคยจัดเก็บไว้จะถูก Load ขึ้นมาให้คุณทำการแก้ไขต่อไป
อย่างที่เป็นที่รู้กันว่าเหตุผลหลักของการคอมไพล์ เคอร์เนล นั้นเพื่อให้เคอร์เนลของคุณสามารถรองรับการทำงานร่วมกับอุปกรณ์ใหม่ที่เคอร์ เนลเดิมไม่สามารถทำงานร่วมด้วยได้ แต่อย่างไรก็ตามในบางครั้งคุณอาจต้องการแก้ไขหลักการ ทำงานบางส่วนของเคอร์เนล
ในเคอร์เนลมีการกำหนดโครงสร้างจำนวนของ Array แบบคงที่ เพื่อใช้ในการเก็บรายการของ Process แต่ละตัวที่ ทำงานอยู่บนระบบทั้งหมด เมื่อโครงสร้างที่กำหนดไว้ถูกนำไปใช้งานทั้งหมด ระบบก็จะไม่สามารถเริ่มต้นการทำงานของ Process ใหม่ได้ ซึ่งการจำกัดจำนวน Array ดังกล่าวจะถูกกำหนดไว้ในไฟล์ task.h เก็บอยู่ที่ /usr/src/linux/include /linux ในรูป
/*
* This is the maximum nr of tasks - change it if you need to
*/
#define NR_TASKS 512
#define MAX_TASKS_PER_USER (NR_TASKS/2)
#define MIN_TASKS_LEFT_FOR_ROOT 4
ซึ่งจำนวน Array ที่รองรับ 512 งานนั้นดูเหมือนมาก แต่ในระบบปฏิบัติการที่เป็นมัลติยูสเซอร์ นั้น ในช่วงที่มีการใช้งานมากๆ ผู้ใช้แต่ละคนก็ใช้งาน Process คนละหลายๆ งาน เพราะฉะนั้นข้อจำกัดที่ 512 งานนั้นเป็นข้อจำกัดที่ระบบจะต้องการการปรับเปลี่ยนแน่นอน และเมื่อคุณปรับเปลี่ยนโดยการเพิ่มค่าของ NR_TASKS แล้วก็ต้องทำการคอมไพล์เคอร์เนลใหม่เช่นกัน
Step5
การทำ Dependencies
เริ่มต้นด้วยการใช้คำสั่ง
#make dep
ซึ่งคำสั่ง make dep จะนำผลลัพธ์ที่ได้จาก make config มาทำงานต่อโดยทำการตั้งค่าให้กับ Source Code ตามที่คุณเลือกมาแล้ว ซึ่งจะเลือกเฉพาะบางส่วนของเคอร์เนล (ที่เกี่ยวข้องกับที่คุณแก้ไข) มาคอมไพล์ และส่วนที่คุณไม่ได้เลือกก็จะไม่ถูกคอมไพล์ ขั้นตอนนี้จะใช้เวลาประมาณ 2-3 นาทีและไม่จำเป็นที่ผู้ใช้จะต้องคอยตอบคำถามกับระบบ
ตามด้วยคำสั่ง
#make clean
อันนี้ก็ไม่ต้องไปตอบโต้กับระบบเช่นกัน โดยคำสั่ง make clean นี้จะคอยตรวจ Source Tree และลบ Object เก่าๆ ที่ไม่เกี่ยวข้องทั้งหมดรวมทั้งลบ Temporary files ทั้งหมดทิ้งไป (เคลียร์ส่วนที่ไม่เกี่ยวข้องออกจากระบบ)
การสั่ง make clean นี้ห้ามลืมเด็ดขาดเพราะอาจมีส่วนทำให้เกิดปัญหาขณะคอมไพล์เคอร์เนลได้
Step6
คอมไพล์เคอร์เนลของคุณ ให้ระบบเข้าใจ
6.1 ติดตั้งเคอร์เนลใหม่ ลงบนแผ่นดิสก์เก็ตก่อนและทดสอบว่ามันทำงานได้ แล้วจึงติดตั้งลงบนฮาร์ดดิสก์อีกทีให้ใช้คำสั่ง
#make zdisk
คำสั่งนี้จะทำการติดตั้งเคอร์เนลที่คุณคอมไพล์ และคาดว่าสามารถ Boot ได้ (Bootable Kernel) ลงแผ่นดิสก์ หลังจากที่คำสั่งนี้ทำงานเสร็จ ให้ทำการ Reboot เครื่อง
เคอร์เนลที่อยู่บนแผ่นดิสก์จะถูก Load เข้าสู่หน่วยความจำ ส่วนของ Root Partition จะถูก mount ขึ้นมาจากนั้นระบบจะถูก Boot ขึ้นมาตามปรกติ เมื่อถึงขั้นตอนนี้ก็ดีใจได้เลยว่าเคอร์เนลที่คุณอุตส่าห์คอมไพล์มาใช้งานได้ คุณไม่ควรปล่อยให้ระบบทำการ Boot จากแผ่นเรื่อยไป แต่ควรทำการสำเนาไฟล์ของเคอร์เนลที่เป็น Image File จากแผ่นลงสู่ฮาร์ดดิสก์ในส่วนของ /boot และทำตามขั้นตอนเดียวกันกับการติดตั้งบนฮาร์ดดิสก์ต่อไป
แต่ถ้าทำการเริ่มต้นจากแผ่นไม่สำเร็จ ก็แค่เอาแผ่นออกหรือไม่ก็พยายามทำใหม่อีกรอบ หากต้องการใช้เครื่องก็ใช้แบบเดิมไปก่อนได้
6.2 ติดตั้งเคอร์เนลใหม่ ฮาร์ดดิสก์ของระบบด้วยความมั่นใจ และหวังว่ามันจะทำงานได้โดยที่ไม่มีปัญหา มีให้เลือกใช้ 2 แบบ
make bzImage จะเป็นคำสั่งที่ดีกว่าในกรณีที่เคอร์เนลใหม่ของคุณอาจมีขนาดใหญ่มาก เนื่องจากคำสั่ง make bzImage มีโครงสร้างที่ดีกว่าในการบีบอัดข้อมูล
make zImage จะเป็นคำสั่งที่น่าใช้ก็ต่อเมื่อคุณแน่ใจว่าเคอร์เนลใหม่ของคุณมีขนาดไม่ใหญ่มาก ซึ่งคำสั่งนี้จะใช้เวลาไม่มาก ประมาณ 15 นาที
Step7
Optional ถ้าตอนที่คุณใช้คำสั่ง make menuconfig เพื่อตั้งค่า configuration ของระบบมีการกำหนดให้สามารถเพิ่มหรือลบ modules ได้ภายหลัง ก็ยังมีอีก 2 คำสั่งที่คุณจะต้องสั่งงาน
#make modules เพื่อแปลค่าลักษณะบางอย่างที่คุณเลือกจะให้เป็น modules นั่นเอง
#make modules_install เพื่อติดตั้ง modules ที่แปลค่านั้นๆ ไปยัง Path ที่ถูกต้องและพร้อมให้ระบบเลือก Load ขึ้นมาใช้งาน
Step8
ติดตั้งเคอร์เนล
ไปยังส่วนต่างๆ ที่เกี่ยวข้องกับการ Boot ระบบ ซึ่งเป็นขั้นตอนที่สำคัญไม่แพ้กันกับขั้นตอนของการคอมไพล์เคอร์เนล และจะต้องใช้ความระมัดระวังกันพอสมควรเลยทีเดียว
8.1 การย้ายเคอร์เนล ที่คุณคอมไพล์เสร็จไปยัง /boot โดยคำสั่งนี้
#cp /usr/src/linux-2.4.20/arch/i386/boot/bzImage /boot/vmlinuz-2.4.20
vmlinuz-2.4.20 คือเคอร์เนลใหม่ที่คุณคอมไพล์ (แบบถูกบีบอัดไว้) นั่นเอง ซึ่งเรื่องนี้เกี่ยวข้องกับการอ้างถึงไฟล์ /etc/lilo.conf ที่จะกล่าวถึงต่อไป
8.2 ย้ายไฟล์ System.map ไปยัง /boot โดยใช้คำสั่ง
#cp /usr/src/linux-2.4.20/System.map /boot/System.map-2.4.20
8.3 ทำการลบและแก้ไข Symbolic Link ที่เกี่ยวข้องใน /boot โดยย้ายการทำงานไปที่ /boot และพิมพ์คำสั่ง
#rm /boot/vmlinuz rm /boot/System.map
สร้าง Symbolic Link ใหม่โดยใช้คำสั่ง
#ln -s /boot/System.map-2.4.20 /boot/System.map
#ln -s /boot/vmlinuz-2.4.20 /boot/vmlinuz
เนื่องจาก /boot/System.map และ/boot/vmlinuz เดิมจะ Symbolic Link ไปยัง System.map และ vmlinuz ของเคอร์เนลเก่า จึงต้องมีการแก้ไขให้ Link ไปยัง System. map และ vmlinuz ของเคอร์เนลใหม่ที่คุณเพิ่งคอมไพล์มาใหม่นั่นเอง
Step9
แก้ไข LILO
โดยการเข้าไปแก้ไขไฟล์ /etc/lilo.conf ด้วยคำสั่ง vi หรือ pico แล้วแต่คุณถนัด
# pico /etc/lilo.conf หรือ
# vi /etc/lilo.conf
จากคำสั่งในหัวข้อที่ 8 ในเรื่องของการทำ symbolic link จาก
System.map ไปยัง System.map-2.4.20
vmlinuz ไปยัง vmlinuz-2.4.20
ทำให้คุณสามารถแก้ไข
ไฟล์ /etc/lilo.conf ต้นแบบจะมีเนื้อหา
boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
linear
default=linux
image=/boot/vmlinuz-2.2.14-5.0
label=linux
read-only
root=/dev/hda1
แก้ไขแล้วจะมีหน้าตาแบบนี้
boot=/dev/hda
map=/boot/map
install=/boot/boot.b
prompt
timeout=50
linear
default=linux
image=/boot/vmlinuz # สามารถระบุเป็น vmlinuz ได้เลยเพราะทำ symbolic link ไว้แล้ว แต่หากไม่ต้องการทำ symbolic link ก็สามารถ ระบุเป็น /boot/vmlinuz-2.4.20 ได้เลย
label=linux
read-only
root=/dev/hda1
image=/boot/vmlinuz-2.2.14-5.0
label=linux-old
read-only
root=/dev/hda1
ถ้าบรรทัดสุดท้าย root=/dev/hda1 ของคุณไม่ใช่ 1 ก็ไม่เป็นไร ให้ดูว่า root=/dev/hdax ของตัวเดิมเป็นแบบไหน และพิมพ์ตามแล้วเพิ่มส่วนของเคอร์เนลใหม่ก็พอ แล้วทำการจัดเก็บ
สั่งให้ lilo รับเอาไฟล์ใหม่ไปทำงานด้วย
#/sbin/lilo
[ warunee@server boot ]# /sbin/lilo
Added linux *
Added linux-old
[ warunee@server boot ]#
ป้องกันความผิดพลาดครั้งสุดท้ายให้คุณใส่ แผ่นดิสก์เข้าสู่ไดร์ฟ A แล้วสั่งทำแผ่นฉุกเฉินด้วย
#mkbootdisk —device/dev/fd0 2.2.14-5.0 # หมายเลขของเคอร์เนล version เก่าของคุณ
Step10
ทดสอบเคอร์เนลใหม่
เช่นเดียวกันกับการคอมไพล์เคอร์เนลลงบนแผ่นดิสก์ คือเมื่อคุณแน่ใจว่าได้ทำตามขั้นตอนทั้งหมดที่กล่าวมาแล้ว ข้างต้น ให้ทำการ Reboot เครื่องหากไม่สำเร็จหรือเกิดความ ผิดพลาด คุณสามารถ Boot จากเคอร์เนลเก่าได้โดย เมื่อเปิดเครื่องขึ้นมาที่ Prompt LILO ให้กด tab จะมีข้อความปรากฏเป็น
linux linux-old
พิมพ์ linux-old ลงไปแล้วกด Enter คุณก็จะสามารถ Boot เป็นเคอร์เนลตัวเก่าขึ้นมาได้นั่นเอง แต่ถ้าไม่สามารถใช้งานได้ ให้งัดเอาไม้ตายสุดท้ายคือแผ่น Boot ที่คุณทำไว้แล้วในข้อ 9 มาใช้ นอกเสียจากว่าคุณไม่ได้ทำ ก็คงต้องนับหนึ่ง กันใหม่
Thanks : www.opensource.co.th
Thanks : www.opensource.co.th
ไม่มีความคิดเห็น:
แสดงความคิดเห็น