Kernel (เคอร์เนล) คืออะไร และ VPS ของคุณใช้ตัวไหนอยู่

Kernel คืออะไร

Kernel (เคอร์เนล) คือโปรแกรมที่อยู่ระหว่างฮาร์ดแวร์กับโปรแกรมอื่นทุกตัวในเครื่อง หน้าที่หลักของมันคือแบ่งทรัพยากรให้โปรแกรมต่าง ๆ ใช้ร่วมกัน ได้แก่ เวลาของ CPU หน่วยความจำ อุปกรณ์ และไฟล์ โปรแกรมทั่วไปไม่ได้แตะฮาร์ดแวร์เอง แต่ร้องขอผ่านช่องทางที่เรียกว่า system call (การเรียกใช้บริการของระบบ)

ตัวอย่างง่าย ๆ คือเว็บเซิร์ฟเวอร์อย่าง nginx เมื่อต้องส่งไฟล์ HTML ให้ผู้ใช้ nginx ไม่ได้สั่งดิสก์หรือสั่งการ์ดเครือข่ายให้ส่งแพ็กเก็ตเอง มันเรียก system call อย่าง openat read และ sendfile แล้วเคอร์เนลเป็นผู้ไปคุยกับฮาร์ดแวร์แทน ผลลัพธ์จึงเหมือนกันไม่ว่าเซิร์ฟเวอร์จะใช้ดิสก์ NVMe หรือดิสก์เสมือนของผู้ให้บริการ VPS เพราะเคอร์เนลซ่อนความต่างนั้นไว้ให้

คำว่า Linux ในความหมายที่แคบที่สุดคือชื่อของเคอร์เนลตัวนี้ ส่วน Ubuntu, Debian และ Rocky Linux คือ distribution (ดิสโทร) ซึ่งเอาเคอร์เนล Linux มารวมกับเครื่องมือพื้นฐาน ตัวจัดการแพ็กเกจ และการตั้งค่าเริ่มต้นของแต่ละค่าย บทความนี้อธิบายว่าเคอร์เนลทำงานอย่างไร ออกแบบได้กี่แบบ เขียนด้วยภาษาอะไร และที่สำคัญที่สุดสำหรับคนเช่าเซิร์ฟเวอร์ คือ VPS ของคุณมีเคอร์เนลเป็นของตัวเองหรือใช้ร่วมกับเครื่องอื่น

เคอร์เนลทำหน้าที่อะไรบ้าง

งานของเคอร์เนลแบ่งได้เป็นสี่กลุ่มใหญ่ ทุกกลุ่มคือการตัดสินว่าใครได้ใช้อะไร เมื่อไร และเท่าไร

• จัดเวลา CPU (process scheduling): เซิร์ฟเวอร์ที่มี 2 vCPU อาจมีโปรเซสหลายร้อยตัว เคอร์เนลสลับให้แต่ละตัวได้ทำงานทีละช่วงสั้น ๆ จนดูเหมือนทุกตัวทำงานพร้อมกัน
• จัดการหน่วยความจำ (memory management): ทุกโปรเซสเห็นหน่วยความจำเสมือน (virtual memory) ของตัวเอง เคอร์เนลเป็นผู้จับคู่ไปยัง RAM จริง เมื่อ RAM หมด เคอร์เนลจะเลือกฆ่าโปรเซสหนึ่งตัว และเขียนบรรทัด Out of memory: Killed process ลงใน dmesg
• ควบคุมอุปกรณ์ (device drivers): ไดรเวอร์ของดิสก์ การ์ดเครือข่าย และอุปกรณ์เสมือนของ VPS เช่น virtio_net และ virtio_blk ล้วนทำงานอยู่ในเคอร์เนล
• ระบบไฟล์และเครือข่าย (filesystems และ network stack): ext4, XFS, TCP/IP, ไฟร์วอลล์ nftables และ VPN อย่าง WireGuard เป็นโค้ดของเคอร์เนลทั้งหมด

ข้อสุดท้ายนี้คือเหตุผลที่คนเช่า VPS ต้องสนใจเคอร์เนล ฟีเจอร์เครือข่ายหลายอย่างที่ดูเหมือนเป็นโปรแกรมธรรมดา ที่จริงแล้วอยู่ในเคอร์เนล ถ้าเคอร์เนลไม่มีฟีเจอร์นั้น การติดตั้งแพ็กเกจด้วย apt ก็ช่วยไม่ได้

Kernel space กับ user space ต่างกันอย่างไร

CPU สมัยใหม่มีโหมดการทำงานอย่างน้อยสองระดับ บน x86 เรียกว่า ring 0 กับ ring 3 โค้ดที่รันใน ring 0 ทำได้ทุกอย่าง เช่น เขียนหน่วยความจำของโปรเซสอื่น หรือสั่งงานฮาร์ดแวร์โดยตรง โค้ดที่รันใน ring 3 ทำแบบนั้นไม่ได้ ถ้าพยายาม CPU จะหยุดคำสั่งนั้นและส่งเรื่องให้เคอร์เนลจัดการ

พื้นที่ที่เคอร์เนลรันเรียกว่า kernel space ส่วนพื้นที่ที่โปรแกรมทั่วไปรัน เช่น nginx, PostgreSQL และ shell ของคุณ เรียกว่า user space การแยกนี้มีผลที่เห็นได้ชัด ถ้าโปรแกรมใน user space ทำงานผิดพลาด โปรแกรมนั้นตายตัวเดียว และคุณเห็นข้อความ Segmentation fault แต่ถ้าโค้ดใน kernel space ผิดพลาดร้ายแรง ทั้งเครื่องจะหยุด ซึ่งเรียกว่า kernel panic เพราะไม่มีชั้นไหนอยู่เหนือเคอร์เนลที่จะคอยรับความผิดพลาดนั้นไว้

ประตูเดียวที่ข้ามจาก user space ไป kernel space ได้คือ system call คุณดู system call ของโปรแกรมได้จริงด้วย strace ซึ่งเป็นเครื่องมือที่ดักการเรียกเหล่านี้แล้วพิมพ์ออกมา

sudo apt install -y strace
strace -e trace=openat,read,write cat /etc/hostname

บรรทัดแรก ๆ จะเป็น openat ที่เปิดไลบรารีอย่าง libc.so.6 เพราะ cat ต้องโหลดไลบรารีก่อนเริ่มทำงาน จากนั้นคุณจะเห็นบรรทัดที่ขึ้นต้นด้วย openat(AT_FDCWD, "/etc/hostname", O_RDONLY) และลงท้ายด้วย = 3 เลข 3 คือ file descriptor (หมายเลขอ้างอิงไฟล์) ที่เคอร์เนลส่งกลับมา บรรทัด read(3, ...) ที่ตามมาคือการขอเนื้อหาไฟล์ และ write(1, ...) คือการขอให้เคอร์เนลพิมพ์ข้อความออกหน้าจอ ซึ่ง file descriptor 1 หมายถึง standard output คำสั่งสั้น ๆ คำสั่งเดียวจึงต้องขอให้เคอร์เนลช่วยหลายครั้ง

เคอร์เนลแบบโมโนลิธิก ไมโครเคอร์เนล และไฮบริด

คำถามสำคัญของการออกแบบเคอร์เนลคือ ควรเอาโค้ดส่วนไหนไว้ใน kernel space คำตอบที่ต่างกันทำให้เกิดแนวทางหลักที่คนพูดถึงกันบ่อย

Monolithic kernel (เคอร์เนลแบบโมโนลิธิก) เอาเกือบทุกอย่างไว้ใน kernel space ทั้งไดรเวอร์ ระบบไฟล์ และเครือข่าย ทุกส่วนเรียกหากันได้ด้วยการเรียกฟังก์ชันธรรมดา จึงเร็ว Linux ใช้แนวทางนี้ ข้อเสียคือไดรเวอร์ที่มีบั๊กเพียงตัวเดียวทำให้ทั้งเครื่องล่มได้ เพราะมันรันด้วยสิทธิ์เดียวกับส่วนอื่นของเคอร์เนล

Microkernel (ไมโครเคอร์เนล) เก็บไว้ใน kernel space เฉพาะส่วนที่จำเป็นจริง ๆ คือการจัดเวลา การจัดการหน่วยความจำ และ IPC (inter-process communication หรือการสื่อสารระหว่างโปรเซส) ไดรเวอร์และระบบไฟล์ย้ายไปเป็นโปรแกรมใน user space แล้วคุยกันด้วยการส่งข้อความ ตัวอย่างคือ MINIX 3, QNX, seL4 และ GNU Hurd ข้อดีคือไดรเวอร์ที่ล่มจะถูกรีสตาร์ตได้โดยระบบไม่ล่มตาม ข้อเสียคือการส่งข้อความข้ามโปรเซสมีต้นทุนมากกว่าการเรียกฟังก์ชัน

Hybrid kernel (เคอร์เนลแบบไฮบริด) มีโครงสร้างภายในแบบไมโครเคอร์เนล แต่รันส่วนใหญ่ใน kernel space เพื่อความเร็ว Windows NT เป็นตัวอย่างที่ชัด ตัวเคอร์เนลแยกเป็นชั้น ๆ แต่ระบบไฟล์และไดรเวอร์ทำงานใน kernel mode และตั้งแต่ Windows NT 4.0 ส่วนของระบบกราฟิกก็ย้ายเข้าไปด้วย ส่วน XNU ของ macOS เอา Mach ซึ่งเป็นไมโครเคอร์เนล มารวมกับชั้น BSD และ I/O Kit ให้อยู่ใน address space (พื้นที่หน่วยความจำ) เดียวกัน ในทางปฏิบัติ คำว่าไฮบริดจึงหมายถึงการออกแบบแบบไมโครเคอร์เนล แต่รันแบบโมโนลิธิก

ข้อถกเถียงนี้เก่าพอ ๆ กับ Linux เอง ในปี 1992 Andrew Tanenbaum ผู้สร้าง MINIX โพสต์ในกลุ่มข่าว comp.os.minix ว่า Linux ล้าสมัยเพราะเป็นโมโนลิธิก และ Linus Torvalds ตอบโต้ยาวหลายรอบ ถ้าอยากรู้ว่าแนวคิดเหล่านี้สืบทอดมาจาก Unix อย่างไร อ่านต่อได้ที่ ประวัติจาก Unix มาถึง Linux

Loadable kernel module: ทำไม Linux ถึงไม่ใหญ่ตายตัว

Linux เป็นโมโนลิธิกก็จริง แต่ไม่ได้บังคับให้โหลดไดรเวอร์ทุกตัวตั้งแต่บูต โค้ดจำนวนมากถูกคอมไพล์แยกเป็น loadable kernel module (โมดูลที่โหลดเพิ่มได้) เป็นไฟล์นามสกุล .ko เคอร์เนลโหลดโมดูลเข้ามาเมื่อจำเป็น และเมื่อโหลดแล้ว โมดูลก็รันใน kernel space ด้วยสิทธิ์เต็มเหมือนส่วนอื่นของเคอร์เนล

lsmod | head -n 15
modinfo wireguard
ls /lib/modules/$(uname -r)/kernel/

lsmod อ่านข้อมูลจาก /proc/modules แล้วแสดงเป็นสามคอลัมน์ Module คือชื่อโมดูล Size คือขนาดในหน่วยความจำเป็นไบต์ และ Used by คือจำนวนส่วนที่ใช้งานโมดูลนั้นอยู่ ตามด้วยชื่อโมดูลอื่นที่พึ่งพามัน ถ้าตัวเลข Used by ไม่ใช่ 0 คุณถอดโมดูลนั้นออกด้วย modprobe -r ไม่ได้ เพราะยังมีส่วนอื่นใช้มันอยู่ และคุณจะเห็นข้อความว่าโมดูล is in use

modinfo wireguard แสดงตำแหน่งไฟล์ของโมดูล ใบอนุญาต และบรรทัด vermagic ซึ่งบอกว่าโมดูลนี้สร้างมาเพื่อเคอร์เนลรุ่นไหน ค่านี้ต้องตรงกับเคอร์เนลที่รันอยู่ เพราะโมดูลถูกคอมไพล์ให้เข้ากับโครงสร้างภายในของเคอร์เนลรุ่นนั้นพอดี นี่คือเหตุผลที่ไดเรกทอรีใต้ /lib/modules/ ถูกตั้งชื่อตามผลของ uname -r ทุกครั้งที่ติดตั้งเคอร์เนลใหม่ จะได้ไดเรกทอรีโมดูลชุดใหม่ตามมาด้วย

โมดูลที่ไม่ได้มากับเคอร์เนล เช่น ไดรเวอร์ NVIDIA ต้องถูกคอมไพล์ใหม่ทุกครั้งที่เปลี่ยนเคอร์เนล งานนี้ทำโดย DKMS (Dynamic Kernel Module Support) และเมื่อมันล้มเหลว อาการจะเป็นแบบที่อธิบายไว้ใน DKMS คอมไพล์ไดรเวอร์ NVIDIA ไม่ผ่านหลังเปลี่ยนเคอร์เนล

Linux ใช้ภาษาอะไรเขียน

เคอร์เนล Linux เขียนด้วยภาษา C เป็นหลัก โดยใช้ส่วนขยายของ GNU C จึงคอมไพล์ด้วย GCC หรือ Clang ส่วนที่ต้องคุยกับ CPU โดยตรง เช่น โค้ดช่วงบูตและการสลับโปรเซส เขียนด้วยภาษา assembly ของแต่ละสถาปัตยกรรม

ภาษา Rust ได้รับการรองรับอย่างเป็นทางการครั้งแรกใน Linux 6.1 ซึ่งออกเมื่อเดือนธันวาคม 2022 รุ่นนั้นใส่เพียงโครงสร้างพื้นฐานสำหรับเขียนโค้ด Rust ในเคอร์เนล ยังไม่มีไดรเวอร์จริงที่ใช้งานกันทั่วไป หลังจากนั้นไดรเวอร์ที่เขียนด้วย Rust ค่อย ๆ เพิ่มเข้ามา เหตุผลหลักคือ Rust ตรวจจับบั๊กประเภทใช้หน่วยความจำผิดได้ตั้งแต่ตอนคอมไพล์ ซึ่งเป็นบั๊กที่พบบ่อยในโค้ด C แต่โค้ดส่วนใหญ่ของเคอร์เนลยังเป็น C และจะเป็นแบบนั้นไปอีกนาน

คุณเห็นได้ด้วยตัวเองว่าเคอร์เนลที่รันอยู่ถูกคอมไพล์ด้วยอะไร ไฟล์ /proc/version บอกชื่อและรุ่นของคอมไพเลอร์ไว้ในบรรทัดเดียวกับเวอร์ชันเคอร์เนล วิธีอ่านอยู่ในหัวข้อถัดไป

วิธีเช็กว่า VPS ของคุณใช้เคอร์เนลตัวไหน

สามคำสั่งนี้ใช้ได้บนทุกดิสโทร และไม่ต้องใช้ sudo

uname -r
uname -a
cat /proc/version

uname -r พิมพ์ kernel release (เวอร์ชันของเคอร์เนล) อย่างเดียว บน Ubuntu ผลจะมีรูปแบบ <major>.<minor>.<patch>-<ABI>-<flavour> ตัวเลขสามชุดแรกคือเวอร์ชันของ Linux ต้นทางที่ Ubuntu ใช้เป็นฐาน ตัวเลข ABI (application binary interface) ขยับขึ้นเมื่อ Ubuntu ออกเคอร์เนลแก้ไขชุดใหม่ ส่วนท้าย เช่น generic หรือ kvm คือ flavour หรือชุดการตั้งค่าที่ Ubuntu คอมไพล์มา ผลที่คุณเห็นจะเปลี่ยนไปทุกครั้งที่มีอัปเดตเคอร์เนล บทความนี้จึงไม่พิมพ์ค่าตัวอย่างไว้ให้เทียบ ให้อ่านตามโครงสร้างแทน

uname -a พิมพ์ข้อมูลทั้งหมดในบรรทัดเดียว เรียงตามลำดับนี้

1. ชื่อเคอร์เนล ซึ่งจะเป็น Linux
2. hostname ของเครื่อง
3. kernel release เหมือนผลของ uname -r
4. kernel version ซึ่งขึ้นต้นด้วย # ตามด้วยหมายเลขการคอมไพล์ มักมีคำว่า SMP (รองรับหลาย CPU) และปิดท้ายด้วยวันที่คอมไพล์
5. สถาปัตยกรรมของเครื่อง เช่น x86_64 หรือ aarch64 บางดิสโทรพิมพ์คำนี้ซ้ำสองหรือสามครั้ง เพราะ uname แยกรายงานชนิดเครื่องกับชนิดโปรเซสเซอร์
6. ชื่อระบบปฏิบัติการ ซึ่งจะเป็น GNU/Linux

จุดที่คนอ่านผิดบ่อยคือวันที่ในข้อ 4 วันที่นั้นคือวันที่ผู้ดูแลดิสโทรคอมไพล์เคอร์เนล ไม่ใช่วันที่เครื่องบูต ถ้าอยากรู้ว่าเครื่องบูตเมื่อไร ใช้ uptime -s

cat /proc/version ให้ข้อมูลใกล้เคียงกับ uname -a แต่เพิ่มรุ่นของคอมไพเลอร์และ linker ที่ใช้สร้างเคอร์เนล เช่น gcc และ GNU ld บน Ubuntu มีไฟล์ /proc/version_signature เพิ่มมาอีกหนึ่งไฟล์ ซึ่งบอกว่าเคอร์เนลของ Ubuntu รุ่นนี้ตรงกับ Linux ต้นทางรุ่นไหน

ถ้าคุณใช้ Ubuntu Server และเห็นเลขเวอร์ชันไม่ตรงกับที่คาด อาจเป็นเพราะเครื่องใช้เคอร์เนลสาย HWE แทนสาย GA ความต่างของสองสายนี้อธิบายไว้ใน เคอร์เนล HWE กับ GA บน Ubuntu Server

VPS แบบ KVM กับแบบ container: ใครเป็นเจ้าของเคอร์เนล

ส่วนนี้สำคัญที่สุดสำหรับคนเช่า VPS เพราะคำว่า VPS ครอบคลุมเทคโนโลยีสองแบบที่ต่างกันมากในเรื่องเคอร์เนล

VPS แบบ KVM (Kernel-based Virtual Machine) คือเครื่องเสมือนเต็มรูปแบบ VPS ของคุณบูตเคอร์เนลของตัวเองจากไดเรกทอรี /boot ของตัวเอง คุณอัปเดตเคอร์เนลเองได้ โหลดโมดูลเองได้ และเลือกได้ว่าจะบูตเคอร์เนลรุ่นไหน ผลของ uname -r คือเคอร์เนลที่ดิสโทรของคุณติดตั้งไว้

VPS แบบ container เช่น LXC และ OpenVZ ไม่มีเคอร์เนลเป็นของตัวเอง ทุก VPS บนเครื่องจริงเครื่องเดียวกันใช้เคอร์เนลตัวเดียวกับเครื่องโฮสต์ ผลที่ตามมามีหลายข้อ ข้อแรก uname -r แสดงเคอร์เนลของโฮสต์ ไม่ใช่ของดิสโทรที่คุณเลือก ข้อสอง คุณโหลดโมดูลเองไม่ได้ เพราะการโหลดโมดูลคือการเพิ่มโค้ดเข้าไปในเคอร์เนลที่ลูกค้ารายอื่นใช้ร่วมอยู่ ผู้ให้บริการจึงปิดสิทธิ์นี้ไว้ ข้อสาม การอัปเดตเคอร์เนลเป็นงานของผู้ให้บริการ การสั่ง reboot ใน container เป็นแค่การรีสตาร์ต container และหลังรีบูต uname -r จะยังแสดงค่าเดิม

Docker ทำงานแบบเดียวกัน container ของ Docker ไม่มีเคอร์เนลของตัวเอง คุณพิสูจน์ได้บนเครื่องที่ติดตั้ง Docker ไว้

uname -r
docker run --rm ubuntu:24.04 uname -r
docker run --rm alpine uname -r

ทุกบรรทัดจะพิมพ์ค่าเดียวกัน แม้ image จะเป็น Ubuntu หรือ Alpine ก็ตาม เพราะทุกอย่างรันบนเคอร์เนลของเครื่องโฮสต์ ไฟล์ใน image เป็นแค่ user space ดังนั้นการติดตั้งแพ็กเกจ linux-image ใน Dockerfile จึงไม่ได้เปลี่ยนเคอร์เนลที่ container ใช้เลย

ถ้าไม่แน่ใจว่ากำลังอยู่ในเครื่องแบบไหน บนดิสโทรที่ใช้ systemd ให้รันคำสั่งนี้

systemd-detect-virt

ผล kvm หรือ qemu หมายถึงเครื่องเสมือนที่มีเคอร์เนลเป็นของตัวเอง ผล lxc หรือ openvz หมายถึง container ที่ใช้เคอร์เนลร่วมกับโฮสต์ ผล none หมายถึงเครื่องจริง ส่วนความต่างของเทคโนโลยีแต่ละแบบอย่างละเอียด อ่านได้ที่ KVM, Xen และ LXC ต่างกันอย่างไรบน VPS และถ้าคุณกำลังเลือกแพ็กเกจราคาถูก ให้อ่าน วิธีอ่านโปรโมชัน VPS ราคาถูกให้รู้ว่าได้อะไรจริง ก่อน เพราะหน้าขายมักไม่บอกตรง ๆ ว่าเป็น container

WireGuard: ปัญหาแรกที่คนเช่า container VPS มักเจอ

WireGuard อยู่ในเคอร์เนล Linux ต้นทางตั้งแต่รุ่น 5.6 บน VPS แบบ KVM ที่ใช้ดิสโทรปัจจุบัน มันจึงพร้อมใช้ทันที เช็กได้ด้วยคำสั่งนี้

sudo modprobe wireguard && echo ok
lsmod | grep wireguard

ถ้าเห็น ok แปลว่าโหลดโมดูลได้ และ lsmod | grep wireguard จะแสดงบรรทัดของโมดูลนั้น

บน container VPS คำสั่งเดียวกันมักล้มเหลวด้วยข้อความ modprobe: FATAL: Module wireguard not found in directory /lib/modules/... สาเหตุคือ modprobe ไปหาโมดูลในไดเรกทอรีที่ตั้งชื่อตามเคอร์เนลของโฮสต์ แต่ในไฟล์ระบบของ container ไม่มีไดเรกทอรีนั้น และต่อให้มี container ก็ไม่มีสิทธิ์โหลดโมดูลอยู่ดี ถ้าลองสร้าง interface ตรง ๆ ด้วย sudo ip link add dev wg0 type wireguard แล้วเห็น RTNETLINK answers: Operation not supported แปลว่าเคอร์เนลของโฮสต์ยังไม่ได้โหลด WireGuard ไว้ให้ คุณแก้จากในเครื่องไม่ได้

ทางออกมีสองทาง ทางแรกคือขอให้ผู้ให้บริการโหลดโมดูลบนโฮสต์ ทางที่สองคือใช้ wireguard-go ซึ่งเป็น WireGuard ที่รันใน user space แต่วิธีนี้ต้องใช้อุปกรณ์ /dev/net/tun ซึ่งผู้ให้บริการต้องเปิดให้ container ของคุณก่อนเช่นกัน หลักเดียวกันนี้ใช้กับทุกฟีเจอร์ที่อยู่ในเคอร์เนล ถ้าซอฟต์แวร์ที่คุณจะใช้ต้องการโมดูลเคอร์เนล VPS แบบ KVM คือทางเลือกที่ไม่ต้องรอใคร

ถ้าคุณต้องการแยกแอปเป็น container แต่ยังอยากคุมเคอร์เนลเอง วิธีที่ได้ทั้งสองอย่างคือเช่า KVM แล้วรัน container บนนั้นเอง ดูตัวอย่างได้ใน การรัน system container ด้วย Incus บน VPS

ทำไมอัปเดตเคอร์เนลบน Ubuntu แล้วต้องรีบูต

เคอร์เนลถูกโหลดเข้า RAM ครั้งเดียวตอนบูต และอยู่ที่นั่นจนกว่าเครื่องจะปิด เมื่อ apt upgrade ติดตั้งเคอร์เนลใหม่ apt แค่วางไฟล์ vmlinuz ตัวใหม่ไว้ใน /boot และวางโมดูลชุดใหม่ไว้ใน /lib/modules/ เคอร์เนลที่รันอยู่ไม่ได้เปลี่ยน ดังนั้นแพตช์ความปลอดภัยของเคอร์เนลจะยังไม่มีผลจนกว่าคุณจะรีบูต

คุณเช็กได้ว่าเครื่องรอการรีบูตอยู่หรือไม่

uname -r
ls /boot/vmlinuz-*
cat /var/run/reboot-required

ถ้าใน /boot มีไฟล์ vmlinuz ที่เวอร์ชันใหม่กว่าผลของ uname -r แปลว่าเคอร์เนลใหม่ติดตั้งแล้วแต่ยังไม่ได้ใช้ ไฟล์ /var/run/reboot-required ถูกสร้างโดยแพ็กเกจที่ต้องการให้รีบูต ถ้าไฟล์นี้มีอยู่ คุณจะเห็นข้อความ *** System restart required *** และไฟล์ /var/run/reboot-required.pkgs จะบอกว่าแพ็กเกจไหนเป็นต้นเหตุ ถ้าไม่มีอะไรรออยู่ cat จะแจ้งว่า No such file or directory หลังรีบูต ให้รัน uname -r อีกครั้ง ผลควรตรงกับเคอร์เนลตัวใหม่สุดใน /boot

Ubuntu ออกเคอร์เนลแก้ไขเป็นรอบที่ค่อนข้างแน่นอน การรู้รอบนี้ช่วยให้วางเวลารีบูตล่วงหน้าได้ อ่านรายละเอียดได้ที่ รอบ SRU ของเคอร์เนล Ubuntu และการวางแผนรีบูต ถ้ารีบูตบ่อยไม่ได้ live patching บน VPS ช่วยปิดช่องโหว่บางประเภทได้โดยไม่ต้องรีบูต แต่ไม่ได้แทนการรีบูตทั้งหมด และเมื่อเคอร์เนลเก่าสะสมจน /boot เต็ม ให้ดู วิธีลบเคอร์เนลเก่าบน Ubuntu อย่างปลอดภัย

ทั้งหมดนี้ใช้กับ VPS แบบ KVM เท่านั้น บน container VPS การรีบูตไม่ทำให้เคอร์เนลเปลี่ยน และไฟล์ใน /boot (ถ้ามี) ไม่ได้ถูกใช้บูตอะไรเลย

อยากรู้ว่าเคอร์เนล Linux มาจากไหน

Linux เริ่มจากโปรเจกต์ส่วนตัวของ Linus Torvalds ในปี 1991 และเติบโตจนรันอยู่บนเซิร์ฟเวอร์ส่วนใหญ่ของอินเทอร์เน็ต ถ้าอยากรู้ว่าฟีเจอร์ที่พูดถึงในบทความนี้ เช่น loadable module, KVM และ WireGuard เข้ามาในรุ่นไหน อ่านต่อได้ที่ ไทม์ไลน์ประวัติเคอร์เนล Linux

FAQ

Kernel คืออะไร อธิบายให้สั้นที่สุด

Kernel หรือเคอร์เนล คือโปรแกรมที่อยู่ระหว่างฮาร์ดแวร์กับโปรแกรมอื่นทุกตัว มันแบ่งเวลา CPU หน่วยความจำ อุปกรณ์ และไฟล์ให้โปรแกรมต่าง ๆ ใช้ โปรแกรมทั่วไปขอใช้ทรัพยากรเหล่านี้ผ่าน system call และไม่ได้คุยกับฮาร์ดแวร์เอง Linux คือชื่อของเคอร์เนล ส่วน Ubuntu และ Debian คือดิสโทรที่สร้างขึ้นบนเคอร์เนลนั้น

Linux ใช้ภาษาอะไรเขียน

เคอร์เนล Linux เขียนด้วยภาษา C เป็นหลัก โดยมี assembly ในส่วนที่ต้องคุยกับ CPU โดยตรง ภาษา Rust ได้รับการรองรับครั้งแรกใน Linux 6.1 ซึ่งออกเมื่อเดือนธันวาคม 2022 และไดรเวอร์ที่เขียนด้วย Rust ค่อย ๆ เพิ่มขึ้นหลังจากนั้น แต่โค้ดส่วนใหญ่ยังเป็น C คุณดูรุ่นของคอมไพเลอร์ที่ใช้สร้างเคอร์เนลบนเครื่องได้ด้วย cat /proc/version

Linux เป็นเคอร์เนลแบบโมโนลิธิกหรือไมโครเคอร์เนล

Linux เป็นแบบโมโนลิธิก ไดรเวอร์ ระบบไฟล์ และเครือข่ายรันใน kernel space ทั้งหมด แต่ Linux รองรับ loadable kernel module จึงโหลดไดรเวอร์เพิ่มหรือถอดออกได้ขณะเครื่องทำงาน ใช้ lsmod ดูโมดูลที่โหลดอยู่ ส่วน Windows NT และ XNU ของ macOS ถูกจัดเป็นแบบไฮบริด

ทำไม uname -r ใน Docker container ไม่ตรงกับ distro ใน image

container ของ Docker ไม่มีเคอร์เนลของตัวเอง ทุก container ใช้เคอร์เนลของเครื่องโฮสต์ร่วมกัน image ของ Ubuntu หรือ Alpine มีแค่ไฟล์ใน user space ดังนั้น uname -r ใน container จึงพิมพ์เวอร์ชันเคอร์เนลของโฮสต์เสมอ VPS แบบ LXC และ OpenVZ ก็เป็นแบบเดียวกัน

ทำไม WireGuard ใช้ไม่ได้บน VPS แบบ LXC หรือ OpenVZ

WireGuard เป็นโมดูลของเคอร์เนล และ container VPS ใช้เคอร์เนลร่วมกับโฮสต์ ซึ่งคุณไม่มีสิทธิ์โหลดโมดูลเข้าไป sudo modprobe wireguard จึงล้มเหลว และถ้าโฮสต์ไม่ได้โหลดโมดูลไว้ ip link add dev wg0 type wireguard จะตอบ RTNETLINK answers: Operation not supported ทางออกคือขอผู้ให้บริการโหลดโมดูล ใช้ wireguard-go ถ้ามี /dev/net/tun หรือย้ายไปใช้ VPS แบบ KVM รัน systemd-detect-virt เพื่อดูว่าคุณใช้แบบไหนอยู่