Greg K-H: "การเขียนโค้ดใหม่ด้วย Rust เป็นประโยชน์ต่อทุกคน"
(lore.kernel.org)เหตุผลที่ควรนำ Rust เข้าสู่ลินุกซ์เคอร์เนล
- จากประสบการณ์ที่ได้ตรวจดูการแก้บั๊กและปัญหาความปลอดภัยของลินุกซ์เคอร์เนลเกือบทั้งหมดตลอด 15 ปีที่ผ่านมา จึงอยากอธิบายถึงความจำเป็นของการนำ Rust มาใช้
- ไม่ใช่ทุกการแก้บั๊กจะถูกนำเข้าไปยัง stable tree แต่โดยทั่วไปสิ่งที่สำคัญมักจะถูกนำเข้า และฉันอยู่ในบทบาทที่ต้องตรวจสอบ CVE ของเคอร์เนลทั้งหมด
ข้อจำกัดของ C และข้อดีของ Rust
- บั๊กส่วนใหญ่ที่เกิดขึ้นในลินุกซ์เคอร์เนลมีที่มาจาก ข้อจำกัดเชิงโครงสร้างของภาษา C
- โดยเฉพาะอย่างยิ่ง มีบั๊กจำนวนมากที่เกิดจาก ความผิดพลาดเล็กน้อยของมนุษย์ และปัญหาเหล่านี้แทบไม่เกิดขึ้นใน Rust
- การเขียนทับหน่วยความจำ (Rust ไม่ได้จับได้ทุกกรณี แต่ช่วยแก้ได้อย่างมาก)
- ปัญหาการจัดการเส้นทางข้อผิดพลาด
- การลืมตรวจสอบค่าข้อผิดพลาด
- บั๊ก use-after-free (ใช้งานหลังจากถูกคืนหน่วยความจำแล้ว)
- หากนำ Rust มาใช้ในเคอร์เนล นักพัฒนาและผู้ดูแลจะสามารถ หลุดพ้นจากความผิดพลาดพื้นฐานเหล่านี้ และไปโฟกัสกับปัญหาที่ยากจริง ๆ เช่น logical error, race condition เป็นต้น
ฐานโค้ด C เดิมยังคงต้องดูแลต่อไป
- ปัจจุบันลินุกซ์เคอร์เนลประกอบด้วย โค้ด C มากกว่า 30 ล้านบรรทัด และเป็นไปไม่ได้ที่จะเปลี่ยนทั้งหมดเป็น Rust ในระยะเวลาอันสั้น
- ดังนั้น งาน เสริมความปลอดภัยให้โค้ด C ที่นักพัฒนาอย่าง Kees และ Gustavo กำลังทำอยู่จึงเป็นสิ่งจำเป็นและต้องดำเนินต่อไป
- แนวทางที่เหมาะสมไม่ใช่การให้ Rust มาแทนที่โค้ดเดิมทั้งหมด แต่คือ การเขียนโค้ดใหม่ (โดยเฉพาะไดรเวอร์) ด้วย Rust เพื่อลดปัญหา
ความปลอดภัยของ API ที่ Rust มอบให้
- Rust ช่วยให้สามารถออกแบบ API ภายในเคอร์เนลให้ ปลอดภัยกว่าและใช้งานได้ง่ายกว่าเดิม
- ปัจจุบัน API ของเคอร์เนลที่อิงกับ C นั้น ซับซ้อน ผิดพลาดได้ง่าย และหลายครั้งผู้ดูแลต้องตรวจทานอย่างละเอียดมาก
- ตัวอย่างเช่น มีหลายวิธีในการใช้งานโครงสร้างอย่าง
struct cdevอย่างปลอดภัย และการใช้งานให้ถูกต้องต้องอาศัยประสบการณ์สูง - เมื่อใช้ Rust จะสามารถนิยาม API ให้ชัดเจนขึ้น ทำให้ ลดโอกาสที่นักพัฒนาจะทำผิดพลาดได้อย่างมาก
- นี่ไม่ได้เป็นประโยชน์เฉพาะกับผู้ใช้ Rust เท่านั้น แต่ยังเป็น การเปลี่ยนแปลงที่ช่วยผู้ใช้โค้ด C เดิมด้วย
ข้อโต้แย้งต่อความกังวลว่าการนำ Rust มาใช้จะเป็นเรื่องยาก
- Rust ไม่ใช่คำตอบสารพัดนึก → แต่สามารถแก้ปัญหาเดิมได้เป็นจำนวนมาก
- ภาระของผู้ดูแลจะเพิ่มขึ้น → แต่ นักพัฒนาที่ต้องการผลักดัน Rust ก็กำลังลงมือทำงานนี้ด้วยตัวเอง
- ความยากในการดูแลฐานโค้ดหลายภาษา → แต่ลินุกซ์เคอร์เนลก็ได้แก้ปัญหาที่ยากกว่านี้มาแล้วหลายครั้ง
บทสรุป
- ลินุกซ์คือ เครื่องมือที่นักพัฒนาจำนวนมหาศาลทั่วโลกใช้เพื่อแก้ปัญหา และ
- ตอนนี้ หากมี ความต้องการจากนักพัฒนาที่อยากเขียนโค้ดสำหรับฮาร์ดแวร์อย่างปลอดภัย ก็ไม่ควรมองข้ามสิ่งนั้น
- โมเดลการพัฒนาของลินุกซ์ได้ เติบโตสู่ขนาดที่ไม่มีใครคาดคิด และแสดงให้เห็นถึงศักยภาพด้านวิศวกรรมอันยอดเยี่ยม
- ถึงเวลาแล้วที่จะก้าวต่อไปเพื่อ การพัฒนาในอีกกว่า 20 ปีข้างหน้า ด้วยการนำ Rust มาใช้
เราต้องเปิดรับเทคโนโลยีและแนวคิดใหม่ ๆ และพยายามทำให้มันประสบความสำเร็จร่วมกับคอมมูนิตี้
24 ความคิดเห็น
การนำ Rust มาใช้น่าจะเป็นการเปลี่ยนแปลงที่หลีกเลี่ยงได้ยากเมื่อคำนึงถึง memory safety ครับ คิดว่าอาจจะพยายามประสานรอยร้าวกันใหม่ผ่านทางออกแบบประนีประนอมที่เหมาะสมสักอย่าง
แต่ส่วนตัวแล้ว ผมรู้สึกว่าคีย์เวิร์ดของ Rust มันไม่ค่อยเข้าตาเท่าไร แล้วพอกลับมาดูอีกทีหลังจากผ่านไปนาน ๆ ก็จำไม่ค่อยได้ เลยทำให้ไม่ค่อยอยากหยิบมันขึ้นมาใช้เท่าไร ;;;; ถึงจะรู้ว่าทุกอย่างล้วนจำเป็นก็เถอะ แต่มันให้ความรู้สึกเหมือนถูกบังคับให้ท่องกริยาอปกติของภาษาอังกฤษอยู่บ่อย ๆ
ถึงอย่างนั้น ก็เป็นความจริงอีกเหมือนกันว่าผลงานที่เขียนด้วย Rust มักก่อปัญหาในงานจริงน้อยกว่า.....
ผมไม่แน่ใจว่านี่เป็นเรื่องที่ควรถูกตำหนิหนักขนาดนี้หรือไม่ แค่บอกว่าไม่ควรนำภาษาที่ยังไม่สุกงอมพอเข้ามาใส่ในเคอร์เนล ตอนนี้ถ้าลองให้ไปหาคนรอบตัวที่ใช้ Rust ได้อย่างชำนาญ ก็คงแทบไม่มีเลยไม่ใช่หรือครับ? ผมคิดว่ารอให้ภาษานี้มีความสุกงอมมากขึ้น และมีผู้ใช้มากพอ แม้จะไม่ถึงระดับผู้ใช้ภาษาเลกาซี แต่ก็มีฐานผู้ใช้ที่เพียงพอแล้วค่อยนำเข้ามา ก็ยังไม่สายเกินไป
ผมเชื่อว่าความมีประโยชน์ของภาษา Rust สามารถพิสูจน์ได้อย่างเพียงพอ แม้จะไม่ได้ถูกนำไปใช้กับลินุกซ์เคอร์เนลก็ตาม
ก็น่าประหลาดใจอยู่เหมือนกันที่ Rust ในระดับปัจจุบันนี้ยังถูกพูดว่าเป็น "ภาษาที่ยังไม่สุกงอม" แต่แยกจากประเด็นนั้น ผมก็สงสัยว่าการพยายามลดสัดส่วนของภาษาไม่ปลอดภัยในเคอร์เนลยังเป็นเรื่องที่ต้องถูกตำหนิถึงขนาดนี้จริงหรือ เปลี่ยนมองรอบตัวตอนนี้ มีคนมากนักไหมที่เชี่ยวชาญ C จนสามารถเขียนโค้ดที่ปลอดภัยพอจะมีส่วนร่วมกับเคอร์เนลได้? แทนที่จะคาดหวังให้ C พัฒนาไปได้มากกว่านี้ ตอนนี้ที่ความต้องการของยุคใหม่ชัดเจนและพร้อมเพียงพอแล้ว ดูจะเป็นช่วงเวลาที่ไม่สายเกินไปพอดี
Rust มีประโยชน์อยู่แล้ว และการพยายามถูกรวมเข้าไปในเคอร์เนลก็คงไม่ใช่เพื่อพิสูจน์ว่ามันมีประโยชน์
ตอนที่ตัดสินใจจะเริ่มนำ rust มาใช้ครั้งแรก ก็น่าจะมีการถกเถียงกันอยู่บ้าง
ถ้าลองคิดดูว่าระหว่างคนที่ชำนาญ C กับคนที่ชำนาญ rust ฝั่งไหนมีจำนวนมากกว่ากัน ก็คงต้องบอกว่า C ทิ้งห่างแบบขาดลอย
แต่ถ้าเป็นโปรแกรมเมอร์ที่มีความรู้โดเมนพร้อมอยู่แล้ว การเรียนภาษาเพิ่มอีกสักภาษาหนึ่งจะเป็นเรื่องใหญ่อะไรไหม ก็อดคิดแบบนั้นไม่ได้
แต่ระดับความชำนาญที่คนทำเคอร์เนลต้องการ ก็คงเป็นอีกเรื่องหนึ่งอยู่ดี...
ความเห็นนี้ก็ดีนะ
ผมไม่เข้าใจเลยจริง ๆ ว่าทำไมถึงมีการเรียกร้องให้ฟอร์กแล้วออกไป แล้วทำไมกันล่ะที่จู่ ๆ ลินุสต้องฟอร์กออกจากลินุกซ์แล้วไป?
มีใครไล่ให้ Linus แยก fork ออกไปไหมครับ? เหมือนผมจะไม่เคยเห็นใครพูดแบบนั้นในการถกเถียงนี้เลย..
ผมเองก็เป็นผู้ใช้ Rust แต่ถ้าโค้ด Rust กับโค้ด C ปะปนกันอยู่ ในโอเพนซอร์สถ้าไม่มีข้อกำหนดที่เข้มงวดอย่างชัดเจนว่าอนุญาตให้มีโค้ด Rust ได้ถึงระดับไหน ก็ดูจะควบคุมไม่ได้ หรืออย่างน้อยที่สุดก็น่าจะทำให้ต้นทุนด้านการรีวิวและการบำรุงรักษาสูงขึ้นมาก ดังนั้นมองว่าไม่เพิ่มเข้าไปแล้ว fork ออกมาจะเป็นทางเลือกที่ฉลาดที่สุด
ผมไม่ค่อยรู้เรื่องเคอร์เนลเท่าไร แต่ถ้าสามารถแปลโค้ด C เป็น Rust แบบอัตโนมัติได้ก็น่าจะดีนะครับ แน่นอนว่านอกจากปัญหาเรื่องการแปลโค้ดแล้ว ก็คงมีปัญหาเรื่องคนด้วยเหมือนกันครับ
ถ้ามีคนจำนวนมากที่อยากนำ Rust เข้าไปใช้ในเคอร์เนลขนาดนี้ ก็แยกฟอร์กออกไปทำเป็นโปรเจ็กต์ใหม่ไม่ได้เหรอ? แล้วพอมันเติบโตจนมีความพร้อมมากพอ ดิสโทรหลัก ๆ ก็คงจะเปลี่ยนไปใช้เคอร์เนลที่พัฒนาด้วย Rust กันเอง
ผมไม่ค่อยเข้าใจว่าทำไมถึงต้องมาทะเลาะกันด้วย
ผมไม่แน่ใจว่าคุณมีประสบการณ์พัฒนาเคอร์เนลหรือไม่ เลยไม่รู้จะอธิบายอย่างไรดี
ก่อนอื่น การนำภาษา Rust มาใช้ไม่ได้หมายความว่าจะเปลี่ยนเคอร์เนลให้เป็น Rust ทั้งหมด คุณอาจถามว่าแยกออกไปแล้วสร้างเคอร์เนลอีกตัวต่างหากไม่ได้หรือ
แต่ประเด็นไม่ใช่การสร้างเคอร์เนลด้วยภาษา Rust หากแต่เป็นการทำ wrapper สำหรับอินเทอร์เฟซของไดรเวอร์อุปกรณ์ในเคอร์เนลด้วย Rust เพื่อให้สามารถพัฒนาเฉพาะไดรเวอร์อุปกรณ์ด้วย Rust ได้
ดังนั้นการบอกว่าจะไปทำเป็นโปรเจกต์ใหม่จึงไม่มีความหมาย
ไม่เคยพัฒนาฝั่งลินุกซ์มาก่อนครับ
ดูเหมือนว่า Rust wrapper ของไดรเวอร์อุปกรณ์จะเป็นโครงสร้างที่แยกออกจากเคอร์เนลไม่ได้สินะ...
น่าขันจริงๆ ที่ชุมชนลินุกซ์ซึ่งเคยใช้เหตุผลเรื่องเสถียรภาพของเคอร์เนลมาอ้างความชอบธรรมให้กับการใช้ถ้อยคำเป็นพิษ ตอนนี้กลับมองว่าคำตอบอย่าง 'ถ้าไม่ชอบก็ไปฟอร์กเองสิ' เป็นคำตอบที่สมเหตุสมผล
ผมไม่ใช่ชุมชนลินุกซ์ แต่...
ฉันไม่คิดว่าควรมองคนเหล่านั้นกับผู้เขียนคอมเมนต์นี้ว่าเป็นชุมชนเดียวกัน
ดูเหมือนว่าจะคาดเดาได้ยากว่าผลลัพธ์จากการ fork จะกลายเป็นการย้ายระบบหรือจะกลายเป็นยุคชุนชิวจ้านกั๋วกันแน่
แม้หลังจาก fork แล้ว การตามอัปเดตการเปลี่ยนแปลงจาก upstream ต่อก็คงไม่ใช่สถานการณ์ที่น่ารื่นรมย์นัก
https://th.news.hada.io/topic?id=16860
เมื่อเห็นว่าฟอร์กของ Realtime Linux ใช้เวลาถึง 20 ปีจึงถูกรวมกลับเข้าไป ก็น่าจะต้องตัดสินใจเรื่องการฟอร์กกันอย่างรอบคอบไม่ใช่หรือ
ผมพูดแบบนั้นหลังจากเห็นสิ่งนี้
เพราะเราสามารถแยกฟีเจอร์เรียลไทม์ออกจากเคอร์เนลและดูแลมันในรูปแบบโปรเจกต์มาได้เป็นเวลานาน และคนที่ต้องการก็แค่นำไปใช้แล้วปรับเข้ากับเคอร์เนลเพื่อใช้งานได้
แม้ฉันจะเป็นผู้ใช้ Rust แต่คอมเมนต์ของ hgwxx7_ ที่โพสต์ใน r/rust1 น่าประทับใจมาก
จำได้ว่าพอมีเรื่องที่ต้องแบ็กพอร์ตไปยังเวอร์ชัน stable หรือต้องติดต่อไป เขาก็ตอบกลับมาได้ดีแม้จะยุ่งมากก็ตาม
"Rust ไม่ใช่คำตอบที่ถูกต้องเสมอไป แต่ก็ใกล้เคียงกับคำตอบมากกว่า Java และ Python" -codemaster kimc-
ความคิดเห็นจาก Hacker News
คอมเมนต์ที่เต็มไปด้วยความเกลียดชังแบบนี้ รายงานไม่ได้เหรอ?
เห็นด้วยครับ