Unsafe Rust
โค้ดทั้งหมดที่เราพูดถึงกันมาจนถึงตอนนี้ ล้วนได้รับการบังคับใช้การรับประกันความปลอดภัยของหน่วยความจำ (memory safety) ของ Rust ในขณะคอมไพล์ อย่างไรก็ตาม Rust มีภาษาที่สองซ่อนอยู่ภายใน ซึ่งไม่ได้บังคับใช้การรับประกันความปลอดภัยของหน่วยความจำเหล่านี้ ภาษาดังกล่าวเรียกว่า unsafe Rust ซึ่งทำงานเหมือนกับ Rust ปกติทุกประการ แต่เปิดโอกาสให้เราใช้พลังพิเศษเพิ่มเติมได้
Unsafe Rust มีอยู่เพราะโดยธรรมชาติแล้ว การวิเคราะห์แบบสแตติก (static analysis) จะมีความระมัดระวังรอบคอบ (conservative) เสมอ เมื่อคอมไพเลอร์พยายามตัดสินว่าโค้ดเป็นไปตามการรับประกันความปลอดภัยหรือไม่ คอมไพเลอร์ยอมที่จะปฏิเสธโปรแกรมที่ถูกต้องบางโปรแกรม ดีกว่ายอมรับโปรแกรมที่มีข้อผิดพลาด แม้ว่าโค้ดนั้น_อาจจะ_ทำงานได้ถูกต้อง แต่หากคอมไพเลอร์ Rust มีข้อมูลไม่เพียงพอที่จะมั่นใจ ก็จะปฏิเสธโค้ดนั้น ในกรณีเหล่านี้ คุณสามารถใช้โค้ด unsafe เพื่อบอกคอมไพเลอร์ว่า “เชื่อใจฉันเถอะ ฉันรู้ว่ากำลังทำอะไรอยู่” แต่ขอเตือนไว้ก่อนว่า คุณใช้ unsafe Rust ด้วยความเสี่ยงของคุณเอง หากคุณใช้โค้ด unsafe อย่างไม่ถูกต้อง ปัญหาความไม่ปลอดภัยของหน่วยความจำย่อมเกิดขึ้นได้ เช่น การดีเรเฟอเรนซ์พอยน์เตอร์ที่เป็น null
อีกเหตุผลหนึ่งที่ Rust มีตัวตนอีกด้านที่เป็น unsafe ก็เพราะฮาร์ดแวร์คอมพิวเตอร์ระดับล่างนั้นไม่ได้ปลอดภัยโดยธรรมชาติ หาก Rust ไม่อนุญาตให้คุณทำงานที่ไม่ปลอดภัย คุณก็จะไม่สามารถทำภารกิจบางอย่างได้ Rust จึงจำเป็นต้องเปิดทางให้คุณเขียนโปรแกรมเชิงระบบระดับต่ำ (low-level systems programming) เช่น การโต้ตอบกับระบบปฏิบัติการโดยตรง หรือแม้กระทั่งการเขียนระบบปฏิบัติการขึ้นมาเอง การรองรับการเขียนโปรแกรมเชิงระบบระดับต่ำถือเป็นเป้าหมายหลักประการหนึ่งของภาษา Rust มาสำรวจกันว่าเราสามารถทำอะไรได้บ้างใน unsafe Rust และมีวิธีใช้งานอย่างไร
การใช้พลังพิเศษของ unsafe
หากต้องการสลับไปใช้ unsafe Rust ให้ใช้คำสงวน unsafe แล้วเริ่มต้นบล็อกใหม่เพื่อบรรจุโค้ด unsafe คุณสามารถดำเนินการ 5 สิ่งใน unsafe Rust ที่ไม่สามารถทำได้ใน safe Rust ซึ่งเราเรียกว่า_พลังพิเศษของ unsafe (unsafe superpowers)_ พลังพิเศษเหล่านั้นได้แก่:
- ดีเรเฟอเรนซ์พอยน์เตอร์ดิบ (raw pointer)
- เรียกใช้ฟังก์ชันหรือเมธอดที่เป็น unsafe
- เข้าถึงหรือแก้ไขตัวแปร static แบบเปลี่ยนแปลงค่าได้ (mutable static variable)
- อิมพลีเมนต์เทรต (trait) ที่เป็น unsafe
- เข้าถึงฟิลด์ต่าง ๆ ของ
union
สิ่งสำคัญที่ต้องทำความเข้าใจคือ unsafe ไม่ได้ปิดการทำงานของตัวตรวจการยืม (borrow checker) หรือปิดระบบตรวจสอบความปลอดภัยอื่น ๆ ของ Rust หากคุณใช้การอ้างอิง (reference) ภายในโค้ด unsafe การอ้างอิงนั้นก็ยังคงได้รับการตรวจสอบตามปกติ คำสงวน unsafe เพียงแค่เปิดโอกาสให้คุณเข้าถึงฟีเจอร์ทั้งห้านี้ ซึ่งคอมไพเลอร์จะไม่ตรวจสอบความปลอดภัยของหน่วยความจำให้อีกต่อไป คุณจึงยังคงได้รับการปกป้องในระดับหนึ่งภายในบล็อก unsafe
นอกจากนี้ unsafe ไม่ได้หมายความว่าโค้ดภายในบล็อกนั้นจะต้องเป็นอันตราย หรือต้องเกิดปัญหาความปลอดภัยของหน่วยความจำอย่างแน่นอน จุดมุ่งหมายคือ ในฐานะโปรแกรมเมอร์ คุณจะต้องเป็นผู้รับประกันเองว่าโค้ดภายในบล็อก unsafe จะเข้าถึงหน่วยความจำได้อย่างถูกต้องและปลอดภัย
มนุษย์ย่อมมีข้อผิดพลาดได้ และข้อผิดพลาดย่อมเกิดขึ้นได้เสมอ แต่การกำหนดให้การดำเนินการ unsafe ทั้ง 5 อย่างนี้ต้องอยู่ภายในบล็อกที่กำกับด้วย unsafe ทำให้คุณมั่นใจได้ว่า ข้อผิดพลาดใด ๆ ที่เกี่ยวข้องกับความปลอดภัยของหน่วยความจำจะต้องอยู่ภายในบล็อก unsafe อย่างแน่นอน จงรักษาบล็อก unsafe ให้มีขนาดเล็กที่สุดเท่าที่จะทำได้ แล้วคุณจะขอบคุณตัวเองในภายหลังเมื่อต้องค้นหาและแก้ไขบั๊กเกี่ยวกับหน่วยความจำ
เพื่อแยกโค้ด unsafe ออกมาให้เป็นสัดส่วนมากที่สุด ทางที่ดีที่สุดคือการห่อหุ้มโค้ดดังกล่าวไว้ภายในแอบสแตรกชันที่ปลอดภัย (safe abstraction) และเตรียม API ที่ปลอดภัยไว้ให้เรียกใช้งาน ซึ่งเราจะพูดถึงในบทนี้เมื่อเราศึกษาฟังก์ชันและเมธอดที่เป็น unsafe บางส่วนของไลบรารีมาตรฐานได้รับการอิมพลีเมนต์เป็นแอบสแตรกชันที่ปลอดภัยครอบโค้ด unsafe ที่ผ่านการตรวจสอบอย่างละเอียดแล้ว การห่อหุ้มโค้ด unsafe ไว้ในแอบสแตรกชันที่ปลอดภัยช่วยป้องกันไม่ให้การใช้งาน unsafe รั่วไหลไปยังทุกจุดที่คุณหรือผู้ใช้งานต้องการเรียกใช้ฟังก์ชันการทำงานที่สร้างขึ้นด้วยโค้ด unsafe เพราะการเรียกใช้งานแอบสแตรกชันที่ปลอดภัยนั้นปลอดภัยอยู่แล้ว
มาดูพลังพิเศษของ unsafe แต่ละอย่างจากทั้ง 5 ข้อตามลำดับกัน รวมถึงดูแอบสแตรกชันบางส่วนที่เตรียมอินเทอร์เฟซที่ปลอดภัยครอบโค้ด unsafe เอาไว้ด้วย
การดีเรเฟอเรนซ์พอยน์เตอร์ดิบ
ในบทที่ 4 ในหัวข้อ“เรเฟอเรนซ์ที่ชี้ไปยังหน่วยความจำที่ถูกคืนแล้ว” เราได้กล่าวถึงการที่คอมไพเลอร์คอยรับประกันว่าการอ้างอิงจะถูกต้องสมบูรณ์เสมอ ส่วน Unsafe Rust มีชนิดข้อมูลใหม่ 2 ชนิดที่เรียกว่า_พอยน์เตอร์ดิบ (raw pointer)_ ซึ่งมีลักษณะคล้ายกับการอ้างอิง เช่นเดียวกับการอ้างอิง พอยน์เตอร์ดิบสามารถเป็นแบบเปลี่ยนแปลงค่าไม่ได้หรือเปลี่ยนแปลงค่าได้ โดยเขียนเป็น *const T และ *mut T ตามลำดับ เครื่องหมายดอกจันไม่ใช่ตัวดำเนินการดีเรเฟอเรนซ์ (dereference operator) แต่เป็นส่วนหนึ่งของชื่อชนิดข้อมูล ในบริบทของพอยน์เตอร์ดิบ คำว่า เปลี่ยนแปลงค่าไม่ได้ (immutable) หมายความว่าเราไม่สามารถกำหนดค่าลงไปยังพอยน์เตอร์ได้โดยตรงหลังจากที่ดีเรเฟอเรนซ์แล้ว
สิ่งที่พอยน์เตอร์ดิบแตกต่างไปจากการอ้างอิงและสมาร์ตพอยน์เตอร์ (smart pointer) คือ:
- ได้รับอนุญาตให้ละเว้นกฎการยืมได้ โดยสามารถมีทั้งพอยน์เตอร์แบบเปลี่ยนแปลงค่าไม่ได้และแบบเปลี่ยนแปลงค่าได้ หรือมีพอยน์เตอร์แบบเปลี่ยนแปลงค่าได้หลายตัวชี้ไปยังตำแหน่งเดียวกัน
- ไม่มีการรับประกันว่าจะชี้ไปยังหน่วยความจำที่ถูกต้องสมบูรณ์
- อนุญาตให้เป็น null ได้
- ไม่มีการทำความสะอาดหน่วยความจำโดยอัตโนมัติ (automatic cleanup)
การเลือกไม่ให้ Rust บังคับใช้การรับประกันเหล่านี้ ทำให้คุณสามารถแลกความปลอดภัยที่รับประกันไว้ กับประสิทธิภาพที่สูงขึ้น หรือความสามารถในการเชื่อมต่อกับภาษาอื่นหรือฮาร์ดแวร์ที่การรับประกันของ Rust ไม่สามารถครอบคลุมได้
ลิสติ้ง 20-1 แสดงวิธีสร้างพอยน์เตอร์ดิบทั้งแบบเปลี่ยนแปลงค่าไม่ได้และแบบเปลี่ยนแปลงค่าได้
fn main() {
let mut num = 5;
let r1 = &raw const num;
let r2 = &raw mut num;
}
โปรดสังเกตว่าเราไม่ได้ใส่คำสงวน unsafe ในโค้ดนี้ เพราะเราสามารถสร้างพอยน์เตอร์ดิบในโค้ด safe ได้ เพียงแต่เราไม่สามารถดีเรเฟอเรนซ์พอยน์เตอร์ดิบภายนอกบล็อก unsafe ได้ ดังที่คุณจะได้เห็นในอีกสักครู่
เราสร้างพอยน์เตอร์ดิบขึ้นมาโดยใช้ตัวดำเนินการยืมแบบ raw: &raw const num สร้างพอยน์เตอร์ดิบแบบเปลี่ยนแปลงค่าไม่ได้ชนิด *const i32 และ &raw mut num สร้างพอยน์เตอร์ดิบแบบเปลี่ยนแปลงค่าได้ชนิด *mut i32 เนื่องจากเราสร้างพอยน์เตอร์เหล่านี้ขึ้นมาจากตัวแปรโลคัลโดยตรง เราจึงรู้ว่าพอยน์เตอร์ดิบชุดนี้ชี้ไปยังตำแหน่งที่ถูกต้องแน่นอน แต่เราไม่สามารถสรุปเช่นนั้นกับพอยน์เตอร์ดิบทั่วไปได้เสมอไป
เพื่อสาธิตให้เห็นชัดเจน ต่อไปเราจะสร้างพอยน์เตอร์ดิบที่เราไม่สามารถมั่นใจในความถูกต้องของตำแหน่งปลายทางได้ โดยใช้คำสงวน as เพื่อแปลงชนิดค่า (cast) แทนการใช้ตัวดำเนินการยืมแบบ raw ลิสติ้ง 20-2 แสดงวิธีสร้างพอยน์เตอร์ดิบที่ชี้ไปยังตำแหน่งหน่วยความจำใด ๆ ก็ตาม การพยายามเข้าถึงหน่วยความจำตามใจชอบเช่นนี้ถือเป็นพฤติกรรมที่ไม่พึงประสงค์หรือไม่ถูกกำหนดไว้ (undefined behavior): แอดเดรสดังกล่าวอาจมีข้อมูลอยู่จริงหรือไม่ก็ได้ คอมไพเลอร์อาจปรับแต่งโค้ดจนไม่มีการเข้าถึงหน่วยความจำเลย หรือโปรแกรมอาจหยุดทำงานกะทันหันด้วยข้อผิดพลาด segmentation fault โดยปกติแล้ว ไม่มีเหตุผลอันสมควรที่จะเขียนโค้ดแบบนี้ โดยเฉพาะเมื่อคุณสามารถใช้ตัวดำเนินการยืมแบบ raw แทนได้ แต่วิธีนี้ก็สามารถทำได้ในเชิงเทคนิค
fn main() {
let address = 0x012345usize;
let r = address as *const i32;
}
โปรดจำไว้ว่าเราสามารถสร้างพอยน์เตอร์ดิบในโค้ด safe ได้ แต่ไม่สามารถดีเรเฟอเรนซ์พอยน์เตอร์ดิบเพื่ออ่านข้อมูลที่ตำแหน่งปลายทางได้ ในลิสติ้ง 20-3 เราใช้ตัวดำเนินการดีเรเฟอเรนซ์ * กับพอยน์เตอร์ดิบ ซึ่งจำเป็นต้องทำภายในบล็อก unsafe
fn main() {
let mut num = 5;
let r1 = &raw const num;
let r2 = &raw mut num;
unsafe {
println!("r1 is: {}", *r1);
println!("r2 is: {}", *r2);
}
}
การสร้างพอยน์เตอร์ไม่ได้ก่อให้เกิดอันตรายใด ๆ จะมีก็เฉพาะตอนที่เราพยายามเข้าถึงค่าที่พอยน์เตอร์ชี้ไปเท่านั้นที่เราอาจต้องเผชิญกับค่าที่ไม่ถูกต้องสมบูรณ์
โปรดสังเกตด้วยว่าในลิสติ้ง 20-1 และ 20-3 เราสร้างพอยน์เตอร์ดิบชนิด *const i32 และ *mut i32 ซึ่งต่างก็ชี้ไปยังตำแหน่งหน่วยความจำเดียวกันที่เก็บค่า num เอาไว้ หากเราเปลี่ยนไปพยายามสร้างการอ้างอิงแบบเปลี่ยนแปลงค่าไม่ได้และการอ้างอิงแบบเปลี่ยนแปลงค่าได้ไปยัง num โค้ดจะไม่สามารถคอมไพล์ผ่านได้ เพราะกฎความเป็นเจ้าของ (ownership) ของ Rust ไม่อนุญาตให้มีการอ้างอิงแบบเปลี่ยนแปลงค่าได้พร้อมกับการอ้างอิงแบบเปลี่ยนแปลงค่าไม่ได้ แต่สำหรับพอยน์เตอร์ดิบ เราสามารถสร้างทั้งพอยน์เตอร์แบบเปลี่ยนแปลงค่าได้และเปลี่ยนแปลงค่าไม่ได้ชี้ไปยังตำแหน่งเดียวกัน พร้อมทั้งแก้ไขข้อมูลผ่านพอยน์เตอร์แบบเปลี่ยนแปลงค่าได้ ซึ่งอาจก่อให้เกิดภาวะแย่งชิงข้อมูล (data race) ได้ จึงต้องใช้ความระมัดระวังอย่างยิ่ง!
เมื่อมีความเสี่ยงมากมายขนาดนี้ ทำไมเราถึงยังต้องใช้พอยน์เตอร์ดิบอยู่อีก? กรณีการใช้งานหลักข้อหนึ่งคือการเชื่อมต่อกับโค้ดภาษา C ดังที่คุณจะได้เห็นในหัวข้อถัดไป อีกกรณีหนึ่งคือการสร้างแอบสแตรกชันที่ปลอดภัยซึ่งตัวตรวจการยืมไม่สามารถเข้าใจได้ เราจะแนะนำฟังก์ชัน unsafe ให้รู้จักกันก่อน แล้วจึงไปดูตัวอย่างการสร้างแอบสแตรกชันที่ปลอดภัยซึ่งอาศัยโค้ด unsafe ในการทำงาน
การเรียกฟังก์ชันหรือเมธอด unsafe
การทำงานประเภทที่ 2 ที่คุณสามารถทำได้ในบล็อก unsafe คือการเรียกใช้ฟังก์ชันที่เป็น unsafe โดยฟังก์ชันและเมธอด unsafe มีหน้าตาเหมือนกับฟังก์ชันและเมธอดปกติทุกประการ เพียงแต่มีคำสงวน unsafe เพิ่มเข้ามาด้านหน้านิยามส่วนที่เหลือ คำสงวน unsafe ในบริบทนี้บ่งชี้ว่าฟังก์ชันดังกล่าวมีข้อกำหนดและเงื่อนไขที่เราต้องดูแลรักษาให้ถูกต้องเมื่อเรียกใช้งาน เนื่องจาก Rust ไม่สามารถตรวจสอบและรับประกันได้ว่าเราปฏิบัติตามข้อกำหนดเหล่านั้นครบถ้วน การเรียกใช้ฟังก์ชัน unsafe ภายในบล็อก unsafe จึงเป็นการยืนยันว่าเราได้อ่านเอกสารประกอบของฟังก์ชันนี้แล้ว และเราขอรับผิดชอบในการปฏิบัติตามข้อตกลง (contract) ของฟังก์ชันด้วยตนเอง
นี่คือตัวอย่างฟังก์ชัน unsafe ชื่อ dangerous ซึ่งไม่ได้ทำอะไรเลยในบอดี้ของมัน:
fn main() {
unsafe fn dangerous() {}
unsafe {
dangerous();
}
}
เราจำเป็นต้องเรียกใช้ฟังก์ชัน dangerous ภายในบล็อก unsafe แยกต่างหาก หากเราพยายามเรียก dangerous โดยไม่มีบล็อก unsafe เราจะพบกับข้อผิดพลาด:
$ cargo run
Compiling unsafe-example v0.1.0 (file:///projects/unsafe-example)
error[E0133]: call to unsafe function `dangerous` is unsafe and requires unsafe block
--> src/main.rs:4:5
|
4 | dangerous();
| ^^^^^^^^^^^ call to unsafe function
|
= note: consult the function's documentation for information on how to avoid undefined behavior
For more information about this error, try `rustc --explain E0133`.
error: could not compile `unsafe-example` (bin "unsafe-example") due to 1 previous error
การครอบด้วยบล็อก unsafe เป็นการยืนยันกับ Rust ว่าเราได้ศึกษาเอกสารของฟังก์ชัน เข้าใจวิธีใช้งานอย่างถูกต้อง และตรวจสอบแล้วว่าเราได้ปฏิบัติตามข้อตกลงของฟังก์ชันครบถ้วน
สำหรับการดำเนินการ unsafe ภายในบอดี้ของฟังก์ชัน unsafe คุณยังคงต้องใช้บล็อก unsafe เช่นเดียวกับในฟังก์ชันปกติ และคอมไพเลอร์จะแจ้งเตือนหากคุณลืมใส่ สิ่งนี้ช่วยให้เรารักษาบล็อก unsafe ให้มีขนาดเล็กที่สุดเท่าที่จะทำได้ เนื่องจากการดำเนินการ unsafe อาจไม่จำเป็นต้องครอบคลุมตลอดทั้งบอดี้ของฟังก์ชัน
การสร้างแอบสแตรกชันที่ปลอดภัยครอบโค้ด unsafe
เพียงเพราะฟังก์ชันหนึ่งมีโค้ด unsafe อยู่ข้างใน ไม่ได้หมายความว่าเราจำเป็นต้องทำเครื่องหมายฟังก์ชันนั้นทั้งฟังก์ชันว่าเป็น unsafe ในความเป็นจริง การห่อหุ้มโค้ด unsafe ไว้ในฟังก์ชันที่ปลอดภัยถือเป็นแอบสแตรกชันที่พบได้เป็นปกติ ตัวอย่างเช่น ลองมาศึกษาฟังก์ชัน split_at_mut จากไลบรารีมาตรฐาน ซึ่งต้องอาศัยโค้ด unsafe ในบางจุด เราจะมาดูวิธีอิมพลีเมนต์ฟังก์ชันนี้กัน โดยเมธอดที่ปลอดภัยนี้ถูกนิยามไว้บนสไลซ์แบบเปลี่ยนแปลงค่าได้ (mutable slice) ซึ่งรับสไลซ์เข้ามาหนึ่งตัว แล้วแยกออกเป็นสองตัวตามตำแหน่งดัชนีที่ส่งเข้ามาเป็นอาร์กิวเมนต์ ลิสติ้ง 20-4 แสดงวิธีเรียกใช้งาน split_at_mut
fn main() {
let mut v = vec![1, 2, 3, 4, 5, 6];
let r = &mut v[..];
let (a, b) = r.split_at_mut(3);
assert_eq!(a, &mut [1, 2, 3]);
assert_eq!(b, &mut [4, 5, 6]);
}
เราไม่สามารถอิมพลีเมนต์ฟังก์ชันนี้โดยอาศัยเพียง safe Rust ได้ ตัวอย่างความพยายามอาจมีลักษณะดังลิสติ้ง 20-5 ซึ่งจะไม่สามารถคอมไพล์ผ่านได้ เพื่อความเข้าใจง่าย เราจะอิมพลีเมนต์ split_at_mut เป็นฟังก์ชันแทนที่จะเป็นเมธอด และรองรับเฉพาะสไลซ์ของค่า i32 แทนที่จะเป็นชนิดข้อมูลเจเนอริก T
fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
let len = values.len();
assert!(mid <= len);
(&mut values[..mid], &mut values[mid..])
}
fn main() {
let mut vector = vec![1, 2, 3, 4, 5, 6];
let (left, right) = split_at_mut(&mut vector, 3);
}
ฟังก์ชันนี้เริ่มต้นด้วยการหาความยาวทั้งหมดของสไลซ์ จากนั้นตรวจสอบยืนยัน (assert) ว่าดัชนีที่ส่งเข้ามาเป็นพารามิเตอร์นั้นอยู่ภายในขอบเขตของสไลซ์ โดยตรวจดูว่าค่าน้อยกว่าหรือเท่ากับความยาวหรือไม่ การยืนยันนี้หมายความว่า หากเราส่งดัชนีที่มีค่ามากกว่าความยาวเพื่อใช้ตัดแบ่งสไลซ์ ฟังก์ชันจะเกิดอาการแพนิก (panic) ก่อนที่จะพยายามนำดัชนีนั้นไปใช้งานจริง
จากนั้น เราคืนค่าทูเพิล (tuple) ที่บรรจุสไลซ์แบบเปลี่ยนแปลงค่าได้สองตัว: ตัวหนึ่งเริ่มตั้งแต่จุดเริ่มต้นของสไลซ์เดิมไปจนถึงดัชนี mid และอีกตัวเริ่มตั้งแต่ mid ไปจนถึงจุดสิ้นสุดของสไลซ์
เมื่อเราพยายามคอมไพล์โค้ดในลิสติ้ง 20-5 เราจะได้รับข้อผิดพลาดดังนี้:
$ cargo run
Compiling unsafe-example v0.1.0 (file:///projects/unsafe-example)
error[E0499]: cannot borrow `*values` as mutable more than once at a time
--> src/main.rs:6:31
|
1 | fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
| - let's call the lifetime of this reference `'1`
...
6 | (&mut values[..mid], &mut values[mid..])
| --------------------------^^^^^^--------
| | | |
| | | second mutable borrow occurs here
| | first mutable borrow occurs here
| returning this value requires that `*values` is borrowed for `'1`
|
= help: use `.split_at_mut(position)` to obtain two mutable non-overlapping sub-slices
For more information about this error, try `rustc --explain E0499`.
error: could not compile `unsafe-example` (bin "unsafe-example") due to 1 previous error
ตัวตรวจการยืมของ Rust ไม่เข้าใจว่าเรากำลังขอยืมส่วนต่าง ๆ ของสไลซ์ที่ไม่ทับซ้อนกัน มันรู้เพียงว่าเรากำลังขอยืมจากสไลซ์เดียวกันถึงสองครั้ง ในความเป็นจริง การขอยืมส่วนต่าง ๆ ของสไลซ์ย่อมทำได้อย่างปลอดภัยเพราะสไลซ์ทั้งสองไม่มีส่วนใดทับซ้อนกัน แต่ Rust ไม่ฉลาดพอที่จะรับรู้ข้อเท็จจริงนี้ เมื่อเรารู้แน่ชัดว่าโค้ดทำงานได้ถูกต้อง แต่ตัว Rust ไม่รู้ นั่นคือจังหวะเวลาที่เราต้องหยิบโค้ด unsafe เข้ามาช่วย
ลิสติ้ง 20-6 แสดงวิธีนำบล็อก unsafe, พอยน์เตอร์ดิบ และการเรียกใช้ฟังก์ชัน unsafe มาช่วยให้การอิมพลีเมนต์ split_at_mut ทำงานได้สำเร็จ
use std::slice;
fn split_at_mut(values: &mut [i32], mid: usize) -> (&mut [i32], &mut [i32]) {
let len = values.len();
let ptr = values.as_mut_ptr();
assert!(mid <= len);
unsafe {
(
slice::from_raw_parts_mut(ptr, mid),
slice::from_raw_parts_mut(ptr.add(mid), len - mid),
)
}
}
fn main() {
let mut vector = vec![1, 2, 3, 4, 5, 6];
let (left, right) = split_at_mut(&mut vector, 3);
}
ย้อนนึกถึงหัวข้อ“ชนิดสไลซ์” ในบทที่ 4 ซึ่งระบุว่าสไลซ์ประกอบด้วยพอยน์เตอร์ที่ชี้ไปยังข้อมูลส่วนหนึ่งและค่าความยาวของสไลซ์ เราใช้เมธอด len เพื่อหาความยาวของสไลซ์ และใช้เมธอด as_mut_ptr เพื่อเข้าถึงพอยน์เตอร์ดิบของสไลซ์ ในกรณีนี้ เนื่องจากเรามีสไลซ์แบบเปลี่ยนแปลงค่าได้ไปยังค่า i32 เมธอด as_mut_ptr จึงคืนค่าพอยน์เตอร์ดิบชนิด *mut i32 ซึ่งเรานำมาเก็บไว้ในตัวแปร ptr
เรายังคงการยืนยันว่าดัชนี mid อยู่ในขอบเขตของสไลซ์ไว้ จากนั้นก็เข้าสู่ส่วนของโค้ด unsafe: ฟังก์ชัน slice::from_raw_parts_mut รับพอยน์เตอร์ดิบและความยาว แล้วสร้างสไลซ์ขึ้นมา เราใช้ฟังก์ชันนี้สร้างสไลซ์ที่เริ่มต้นจาก ptr และมีความยาวเท่ากับ mid รายการ จากนั้น เราเรียกเมธอด add บน ptr โดยส่ง mid เป็นอาร์กิวเมนต์ เพื่อให้ได้พอยน์เตอร์ดิบที่เริ่มต้นที่ตำแหน่ง mid แล้วจึงสร้างสไลซ์โดยใช้พอยน์เตอร์นั้นร่วมกับจำนวนรายการที่เหลืออยู่หลัง mid เป็นความยาว
ฟังก์ชัน slice::from_raw_parts_mut ถือเป็น unsafe เพราะรับพอยน์เตอร์ดิบเข้ามาและต้องไว้วางใจว่าพอยน์เตอร์นี้ชี้ไปยังตำแหน่งที่ถูกต้อง ส่วนเมธอด add บนพอยน์เตอร์ดิบก็เป็น unsafe เช่นกัน เนื่องจากต้องเชื่อใจว่าตำแหน่งที่บวกเยื้องเพิ่มไป (offset) นั้นยังคงเป็นพอยน์เตอร์ที่ถูกต้องสมบูรณ์ ด้วยเหตุนี้ เราจึงต้องครอบการเรียกใช้ slice::from_raw_parts_mut และ add ไว้ด้วยบล็อก unsafe เพื่อให้สามารถเรียกใช้งานได้ เมื่อพิจารณาจากตรรกะของโค้ดและข้อกำหนดที่เราใส่เพิ่มไว้ว่า mid ต้องน้อยกว่าหรือเท่ากับ len เราจึงสามารถบอกได้ว่าพอยน์เตอร์ดิบทั้งหมดที่ใช้ภายในบล็อก unsafe จะเป็นพอยน์เตอร์ที่ถูกต้องและชี้ไปยังข้อมูลภายในสไลซ์อย่างแน่นอน นี่คือตัวอย่างการใช้งาน unsafe ที่เหมาะสมและยอมรับได้
โปรดสังเกตว่าเราไม่จำเป็นต้องทำเครื่องหมายฟังก์ชัน split_at_mut ที่ได้ว่าเป็น unsafe และเราสามารถเรียกใช้ฟังก์ชันนี้จากโค้ดที่เป็น safe Rust ได้ตามปกติ เราได้สร้างแอบสแตรกชันที่ปลอดภัยครอบโค้ด unsafe เอาไว้ ด้วยการอิมพลีเมนต์ฟังก์ชันที่ใช้โค้ด unsafe อย่างปลอดภัย เพราะตัวฟังก์ชันสร้างเฉพาะพอยน์เตอร์ที่ถูกต้องสมบูรณ์จากข้อมูลที่ฟังก์ชันเข้าถึงได้เท่านั้น
ในทางตรงกันข้าม การเรียกใช้ slice::from_raw_parts_mut ในลิสติ้ง 20-7 มีแนวโน้มสูงที่จะทำให้โปรแกรมหยุดทำงานกะทันหัน (crash) เมื่อนำสไลซ์นั้นไปใช้งาน โค้ดนี้หยิบตำแหน่งหน่วยความจำใด ๆ ขึ้นมา แล้วสร้างสไลซ์ที่มีความยาวถึง 10,000 รายการ
fn main() {
use std::slice;
let address = 0x01234usize;
let r = address as *mut i32;
let values: &[i32] = unsafe { slice::from_raw_parts_mut(r, 10000) };
}
เราไม่ได้เป็นเจ้าของหน่วยความจำ ณ ตำแหน่งที่ระบุขึ้นมาลอย ๆ นี้ และไม่มีสิ่งใดรับประกันได้เลยว่าสไลซ์ที่โค้ดนี้สร้างขึ้นจะมีค่า i32 ที่ถูกต้องสมบูรณ์อยู่จริง การพยายามนำ values ไปใช้งานเสมือนว่าเป็นสไลซ์ที่สมบูรณ์ จะนำไปสู่พฤติกรรมที่ไม่พึงประสงค์หรือไม่ถูกกำหนดไว้ (undefined behavior)
การใช้ฟังก์ชัน extern เพื่อเรียกโค้ดภายนอก
ในบางครั้งโค้ด Rust ของคุณอาจจำเป็นต้องสื่อสารหรือทำงานร่วมกับโค้ดที่เขียนด้วยภาษาอื่น สำหรับกรณีนี้ Rust มีคำสงวน extern ที่ช่วยอำนวยความสะดวกในการสร้างและใช้งาน Foreign Function Interface (FFI) ซึ่งเป็นกลไกที่เปิดให้ภาษาโปรแกรมหนึ่งสามารถนิยามฟังก์ชัน และอนุญาตให้ภาษาโปรแกรมอื่น (ภาษาภายนอก) สามารถเรียกใช้ฟังก์ชันเหล่านั้นได้
ลิสติ้ง 20-8 สาธิตวิธีเชื่อมต่อกับฟังก์ชัน abs จากไลบรารีมาตรฐานของภาษา C โดยทั่วไปแล้ว ฟังก์ชันที่ประกาศไว้ภายในบล็อก extern จะถือเป็น unsafe เมื่อเรียกใช้จากโค้ด Rust ดังนั้นบล็อก extern จึงต้องกำกับด้วย unsafe เช่นกัน เหตุผลคือภาษาอื่นไม่ได้บังคับใช้กฎและการรับประกันความปลอดภัยของ Rust และ Rust เองก็ไม่สามารถตรวจสอบความปลอดภัยของภาษาเหล่านั้นได้ ความรับผิดชอบจึงตกอยู่กับโปรแกรมเมอร์ที่จะต้องดูแลความปลอดภัยด้วยตนเอง
unsafe extern "C" {
fn abs(input: i32) -> i32;
}
fn main() {
unsafe {
println!("Absolute value of -3 according to C: {}", abs(-3));
}
}
ภายในบล็อก unsafe extern "C" เราระบุชื่อและซิกเนเจอร์ของฟังก์ชันภายนอกจากภาษาอื่นที่เราต้องการเรียกใช้ ส่วนคำว่า "C" กำหนดว่าฟังก์ชันภายนอกนั้นใช้ ส่วนต่อประสานไบนารีของแอปพลิเคชัน (application binary interface หรือ ABI) แบบใด: ABI เป็นตัวกำหนดวิธีการเรียกใช้ฟังก์ชันในระดับภาษาแอสเซมบลี ABI แบบ "C" เป็นรูปแบบที่พบได้บ่อยที่สุดและเป็นไปตาม ABI ของภาษาโปรแกรม C คุณสามารถดูข้อมูลเกี่ยวกับ ABI ทั้งหมดที่ Rust รองรับได้ในคู่มืออ้างอิงของ Rust (Rust Reference)
ทุกรายการที่ประกาศภายในบล็อก unsafe extern จะถือเป็น unsafe โดยปริยาย อย่างไรก็ตาม ฟังก์ชัน FFI บางฟังก์ชันก็ปลอดภัยที่จะเรียกใช้งาน ตัวอย่างเช่น ฟังก์ชัน abs จากไลบรารีมาตรฐานของ C ไม่มีประเด็นความเสี่ยงด้านความปลอดภัยของหน่วยความจำใด ๆ และเรารู้ว่าสามารถส่งค่า i32 ใด ๆ ให้ทำงานได้เสมอ ในกรณีเช่นนี้ เราสามารถใช้คำสงวน safe เพื่อระบุเจาะจงว่าฟังก์ชันนี้ปลอดภัยที่จะเรียกใช้งาน แม้ว่าจะอยู่ภายในบล็อก unsafe extern ก็ตาม เมื่อปรับเปลี่ยนเช่นนี้แล้ว การเรียกใช้งานฟังก์ชันดังกล่าวก็ไม่จำเป็นต้องครอบด้วยบล็อก unsafe อีกต่อไป ดังที่แสดงในลิสติ้ง 20-9
unsafe extern "C" {
safe fn abs(input: i32) -> i32;
}
fn main() {
println!("Absolute value of -3 according to C: {}", abs(-3));
}
การทำเครื่องหมายฟังก์ชันว่าเป็น safe ไม่ได้ทำให้ฟังก์ชันปลอดภัยขึ้นมาได้ด้วยตัวเองโดยอัตโนมัติ! แต่มันเปรียบเสมือนสัญญาที่คุณให้ไว้กับ Rust ว่าฟังก์ชันนี้ปลอดภัย และยังคงเป็นหน้าที่ของคุณที่จะต้องดูแลให้สัญญานั้นเป็นจริงอยู่เสมอ!
การเรียกฟังก์ชัน Rust จากภาษาอื่น
เรายังสามารถใช้ extern เพื่อสร้างอินเทอร์เฟซที่เปิดให้ภาษาอื่นสามารถเรียกใช้ฟังก์ชันของ Rust ได้ด้วยเช่นกัน โดยแทนที่จะสร้างบล็อก extern ทั้งบล็อก เราจะใส่คำสงวน extern พร้อมระบุ ABI ที่จะใช้ไว้หน้าคำสงวน fn ของฟังก์ชันนั้น ๆ โดยตรง นอกจากนี้เรายังต้องระบุแอตทริบิวต์ #[unsafe(no_mangle)] เพื่อบอกคอมไพเลอร์ Rust ไม่ให้ดัดแปลงชื่อ (mangle) ฟังก์ชันนี้ การดัดแปลงชื่อหรือ mangling คือกระบวนการที่คอมไพเลอร์เปลี่ยนชื่อฟังก์ชันที่เราตั้งไว้ให้เป็นชื่อใหม่ที่บรรจุข้อมูลเพิ่มเติมสำหรับใช้ในขั้นตอนการคอมไพล์ส่วนอื่น ๆ ซึ่งทำให้อ่านเข้าใจได้ยากขึ้นสำหรับมนุษย์ คอมไพเลอร์ของแต่ละภาษาโปรแกรมจะดัดแปลงชื่อแตกต่างกันไป ดังนั้น เพื่อให้ภาษาอื่นสามารถอ้างอิงชื่อฟังก์ชันของ Rust ได้อย่างถูกต้อง เราจึงต้องปิดระบบ name mangling ของคอมไพเลอร์ Rust สิ่งนี้ถือเป็น unsafe เพราะหากไม่มีระบบดัดแปลงชื่อของคอมไพเลอร์ ก็อาจเสี่ยงต่อการเกิดชื่อฟังก์ชันชนกันข้ามไลบรารีได้ เราจึงมีหน้าที่ต้องตรวจสอบให้แน่ใจว่าชื่อที่เราเลือกนั้นปลอดภัยที่จะส่งออก (export) โดยไม่ผ่านการดัดแปลงชื่อ
ในตัวอย่างต่อไปนี้ เราทำให้ฟังก์ชัน call_from_c สามารถเรียกใช้ได้จากโค้ดภาษา C หลังจากคอมไพล์เป็นแชร์ไลบรารี (shared library) และเชื่อมโยง (link) จากฝั่ง C แล้ว:
#[unsafe(no_mangle)]
pub extern "C" fn call_from_c() {
println!("Just called a Rust function from C!");
}
การใช้งาน extern ในลักษณะนี้จำเป็นต้องมี unsafe เฉพาะในแอตทริบิวต์เท่านั้น ไม่ใช่บนบล็อก extern
การเข้าถึงหรือแก้ไขตัวแปร static ที่เปลี่ยนแปลงได้
ในหนังสือเล่มนี้ เรายังไม่ได้พูดถึงตัวแปรแบบโกลบอล (global variable) ซึ่ง Rust ก็รองรับการใช้งานเช่นกัน แต่อาจเกิดปัญหาขัดแย้งกับกฎความเป็นเจ้าของของ Rust ได้ หากมีสองเธรดพยายามเข้าถึงตัวแปรโกลบอลแบบเปลี่ยนแปลงค่าได้ตัวเดียวกัน ก็อาจนำไปสู่ภาวะแย่งชิงข้อมูล (data race) ได้
ในภาษา Rust ตัวแปรโกลบอลจะเรียกว่า ตัวแปร static ลิสติ้ง 20-10 แสดงตัวอย่างการประกาศและใช้งานตัวแปร static ที่เก็บค่าเป็นสตริงสไลซ์
static HELLO_WORLD: &str = "Hello, world!";
fn main() {
println!("value is: {HELLO_WORLD}");
}
ตัวแปร static มีความคล้ายคลึงกับค่าคงที่ (constant) ซึ่งเราได้พูดคุยกันไปในหัวข้อ“การประกาศค่าคงที่” ในบทที่ 3 ตามธรรมเนียมปฏิบัตินิยมตั้งชื่อตัวแปร static ด้วยรูปแบบ SCREAMING_SNAKE_CASE ตัวแปร static สามารถจัดเก็บได้เฉพาะการอ้างอิงที่มีไลฟ์ไทม์เป็น 'static เท่านั้น ซึ่งหมายความว่าคอมไพเลอร์ Rust สามารถอนุมานไลฟ์ไทม์ได้เองโดยที่เราไม่จำเป็นต้องระบุไว้อย่างชัดแจ้ง การเข้าถึงตัวแปร static แบบเปลี่ยนแปลงค่าไม่ได้นั้นถือว่าปลอดภัย
จุดแตกต่างอันละเอียดอ่อนระหว่างค่าคงที่กับตัวแปร static แบบเปลี่ยนแปลงค่าไม่ได้ คือ ค่าในตัวแปร static จะมีตำแหน่งแอดเดรสในหน่วยความจำที่แน่นอนตายตัว การเรียกใช้ค่าดังกล่าวจะเข้าถึงข้อมูลตำแหน่งเดิมเสมอ ในทางกลับกัน ค่าคงที่สามารถคัดลอกข้อมูลซ้ำใหม่ได้ทุกครั้งที่มีการหยิบไปใช้งาน จุดแตกต่างอีกประการหนึ่งคือตัวแปร static สามารถกำหนดให้เปลี่ยนแปลงค่าได้ ซึ่งการเข้าถึงและแก้ไขตัวแปร static แบบเปลี่ยนแปลงค่าได้นั้น_เป็น unsafe_ ลิสติ้ง 20-11 แสดงวิธีประกาศ เข้าถึง และแก้ไขตัวแปร static แบบเปลี่ยนแปลงค่าได้ที่มีชื่อว่า COUNTER
static mut COUNTER: u32 = 0;
/// SAFETY: Calling this from more than a single thread at a time is undefined
/// behavior, so you *must* guarantee you only call it from a single thread at
/// a time.
unsafe fn add_to_count(inc: u32) {
unsafe {
COUNTER += inc;
}
}
fn main() {
unsafe {
// SAFETY: This is only called from a single thread in `main`.
add_to_count(3);
println!("COUNTER: {}", *(&raw const COUNTER));
}
}
เช่นเดียวกับตัวแปรทั่วไป เรากำหนดให้เปลี่ยนแปลงค่าได้โดยใช้คำสงวน mut โดยโค้ดใดก็ตามที่อ่านหรือเขียนค่าไปยัง COUNTER จะต้องอยู่ภายในบล็อก unsafe โค้ดในลิสติ้ง 20-11 สามารถคอมไพล์ผ่านและพิมพ์ผลลัพธ์ COUNTER: 3 ออกมาได้ตามที่คาดหมายไว้ เนื่องจากโปรแกรมทำงานอยู่บนเธรดเดียว แต่หากมีหลายเธรดเข้าถึง COUNTER พร้อมกัน ก็มีโอกาสสูงมากที่จะเกิด data race ขึ้น จึงถือเป็นพฤติกรรมที่ไม่พึงประสงค์หรือไม่ถูกกำหนดไว้ ดังนั้น เราจึงต้องทำเครื่องหมายทั้งฟังก์ชันว่าเป็น unsafe พร้อมทั้งบันทึกเอกสารกำกับข้อจำกัดด้านความปลอดภัยไว้ เพื่อให้ทุกคนที่เรียกใช้ฟังก์ชันนี้ทราบว่าตนเองสามารถทำอะไรได้อย่างปลอดภัยและมีสิ่งใดที่ห้ามทำบ้าง
เมื่อใดก็ตามที่เราเขียนฟังก์ชัน unsafe ถือเป็นแนวทางปฏิบัติที่ดี (idiomatic) ในการเขียนคอมเมนต์ขึ้นต้นด้วย SAFETY เพื่ออธิบายว่าผู้เรียกใช้ฟังก์ชันจำเป็นต้องทำสิ่งใดบ้างเพื่อให้สามารถเรียกใช้งานฟังก์ชันได้อย่างปลอดภัย ในทำนองเดียวกัน เมื่อใดก็ตามที่เราทำการดำเนินการ unsafe ก็ถือเป็นแนวทางปฏิบัติที่ดีในการเขียนคอมเมนต์ขึ้นต้นด้วย SAFETY เพื่ออธิบายว่ากฎเกณฑ์ด้านความปลอดภัยต่าง ๆ ได้รับการปฏิบัติตามอย่างไร
นอกจากนี้ คอมไพเลอร์จะปฏิเสธความพยายามสร้างการอ้างอิงไปยังตัวแปร static แบบเปลี่ยนแปลงค่าได้เป็นค่าเริ่มต้นผ่าน lint ของคอมไพเลอร์ คุณต้องเลือกระงับการป้องกันของ lint ดังกล่าวอย่างชัดแจ้งด้วยแอตทริบิวต์ #[allow(static_mut_refs)] หรือไม่ก็เข้าถึงตัวแปร static แบบเปลี่ยนแปลงค่าได้ผ่านทางพอยน์เตอร์ดิบที่สร้างขึ้นด้วยตัวดำเนินการยืมแบบ raw ซึ่งรวมถึงกรณีที่การอ้างอิงถูกสร้างขึ้นโดยไม่รู้ตัว เช่น เมื่อนำไปใช้งานใน println! ในลิสติ้งโค้ดนี้ การกำหนดให้การอ้างอิงไปยังตัวแปร static แบบเปลี่ยนแปลงค่าได้ต้องสร้างผ่านพอยน์เตอร์ดิบ ช่วยทำให้ข้อกำหนดด้านความปลอดภัยในการใช้งานตัวแปรเหล่านี้ชัดเจนยิ่งขึ้น
เมื่อข้อมูลที่เปลี่ยนแปลงค่าได้สามารถเข้าถึงได้จากทั่วทั้งโปรแกรม ย่อมเป็นการยากที่จะรับประกันว่าจะไม่เกิด data race ขึ้น นี่จึงเป็นเหตุผลที่ Rust ถือว่าตัวแปร static แบบเปลี่ยนแปลงค่าได้เป็น unsafe เมื่อเป็นไปได้ จึงแนะนำให้เลือกใช้เทคนิคการทำงานพร้อมกัน (concurrency) และสมาร์ตพอยน์เตอร์ที่ปลอดภัยต่อการใช้งานข้ามเธรด (thread-safe smart pointer) ดังที่เราได้พูดคุยกันในบทที่ 16 แทน เพื่อให้คอมไพเลอร์ช่วยตรวจสอบว่าการเข้าถึงข้อมูลจากเธรดต่าง ๆ กระทำได้อย่างปลอดภัย
การอิมพลีเมนต์เทรต unsafe
เราสามารถใช้ unsafe เพื่ออิมพลีเมนต์เทรตที่เป็น unsafe ได้ โดยเทรตจะถือว่าเป็น unsafe ก็ต่อเมื่อมีเมธอดอย่างน้อยหนึ่งตัวที่มีเงื่อนไขคงที่ (invariant) บางประการที่คอมไพเลอร์ไม่สามารถตรวจสอบได้ เราประกาศว่าเทรตใดเป็น unsafe ได้โดยใส่คำสงวน unsafe ไว้หน้าคำว่า trait และทำเครื่องหมายการอิมพลีเมนต์เทรตนั้นว่าเป็น unsafe ด้วยเช่นกัน ดังที่แสดงในลิสติ้ง 20-12
unsafe trait Foo {
// methods go here
}
unsafe impl Foo for i32 {
// method implementations go here
}
fn main() {}
การใช้ unsafe impl เป็นการให้คำสัญญาว่าเราจะดูแลรักษาเงื่อนไขคงที่ที่คอมไพเลอร์ไม่สามารถตรวจสอบให้ได้นั้นด้วยตนเอง
ตัวอย่างเช่น ย้อนนึกถึงเทรตบ่งชี้ (marker trait) อย่าง Send และ Sync ที่เราได้พูดคุยกันในหัวข้อ“การทำงานพร้อมกันแบบขยายได้ด้วย Send และ Sync” ในบทที่ 16: คอมไพเลอร์จะอิมพลีเมนต์เทรตเหล่านี้ให้โดยอัตโนมัติหากชนิดข้อมูลของเราประกอบขึ้นมาจากชนิดข้อมูลอื่นที่ต่างก็อิมพลีเมนต์ Send และ Sync ครบทั้งหมด แต่หากเราอิมพลีเมนต์ชนิดข้อมูลที่มีสมาชิกเป็นชนิดข้อมูลที่ไม่ได้อิมพลีเมนต์ Send หรือ Sync (เช่น พอยน์เตอร์ดิบ) แล้วเราต้องการทำเครื่องหมายให้ชนิดข้อมูลนั้นเป็น Send หรือ Sync เราจำเป็นต้องใช้ unsafe เนื่องจาก Rust ไม่สามารถตรวจสอบได้ว่าชนิดข้อมูลของเรารักษาการรับประกันว่าจะสามารถส่งต่อข้ามเธรด หรือเข้าถึงพร้อมกันจากหลายเธรดได้อย่างปลอดภัยหรือไม่ เราจึงต้องดำเนินการตรวจสอบเหล่านั้นด้วยตนเอง และยืนยันความปลอดภัยด้วยคำสงวน unsafe
การเข้าถึงฟิลด์ของ union
การทำงานประการสุดท้ายที่ใช้ได้เฉพาะใน unsafe คือการเข้าถึงฟิลด์ต่าง ๆ ของ union โดย union มีลักษณะคล้ายกับ struct แต่จะมีฟิลด์ที่ประกาศไว้เพียงฟิลด์เดียวเท่านั้นที่ถูกใช้งานในอินสแตนซ์หนึ่ง ๆ ณ ช่วงเวลาใดเวลาหนึ่ง การใช้งาน union มีวัตถุประสงค์หลักเพื่อเชื่อมต่อกับ union ในโค้ดภาษา C การเข้าถึงฟิลด์ของ union ถือเป็น unsafe เนื่องจาก Rust ไม่สามารถรับประกันชนิดข้อมูลของข้อมูลที่กำลังจัดเก็บอยู่ในอินสแตนซ์ของ union นั้นได้ คุณสามารถศึกษาเพิ่มเติมเกี่ยวกับ union ได้ในคู่มืออ้างอิงของ Rust (Rust Reference)
การใช้ Miri เพื่อตรวจสอบโค้ด unsafe
เมื่อเขียนโค้ด unsafe คุณอาจต้องการตรวจสอบให้แน่ใจว่าสิ่งที่คุณเขียนนั้นปลอดภัยและถูกต้องจริง ๆ หรือไม่ หนึ่งในวิธีที่ดีที่สุดคือการใช้ Miri ซึ่งเป็นเครื่องมืออย่างเป็นทางการของ Rust สำหรับตรวจจับพฤติกรรมที่ไม่พึงประสงค์หรือไม่ถูกกำหนดไว้ (undefined behavior) ในขณะที่ตัวตรวจการยืมเป็นเครื่องมือแบบ_สแตติก (static)_ ที่ทำงานในตอนคอมไพล์ Miri จะเป็นเครื่องมือแบบ_ไดนามิก (dynamic)_ ที่ทำงานในตอนรันไทม์ โดยจะตรวจสอบโค้ดของคุณด้วยการรันโปรแกรมจริงหรือรันชุดการทดสอบ แล้วตรวจจับเมื่อมีการละเมิดกฎเกณฑ์การทำงานของ Rust ตามที่มันเข้าใจ
การใช้งาน Miri จำเป็นต้องใช้ Rust รุ่น nightly (ซึ่งเราจะอธิบายเพิ่มเติมในภาคผนวก G: กระบวนการพัฒนา Rust และ “Nightly Rust”) คุณสามารถติดตั้ง Rust เวอร์ชัน nightly และเครื่องมือ Miri ได้โดยพิมพ์คำสั่ง rustup +nightly component add miri การทำเช่นนี้ไม่ได้เปลี่ยนเวอร์ชันของ Rust ที่โปรเจกต์ของคุณใช้งานอยู่ แต่เป็นเพียงการเพิ่มเครื่องมือลงในระบบเพื่อให้คุณสามารถเรียกใช้เมื่อต้องการได้ คุณสามารถรัน Miri บนโปรเจกต์ได้โดยสั่ง cargo +nightly miri run หรือ cargo +nightly miri test
เพื่อแสดงให้เห็นว่าเครื่องมือนี้มีประโยชน์เพียงใด ลองมาดูสิ่งที่จะเกิดขึ้นเมื่อเรารัน Miri กับโค้ดในลิสติ้ง 20-7:
$ cargo +nightly miri run
Compiling unsafe-example v0.1.0 (file:///projects/unsafe-example)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.17s
Running `file:///home/.rustup/toolchains/nightly/bin/cargo-miri runner target/miri/debug/unsafe-example`
warning: integer-to-pointer cast
--> src/main.rs:5:13
|
5 | let r = address as *mut i32;
| ^^^^^^^^^^^^^^^^^^^ integer-to-pointer cast
|
= help: this program is using integer-to-pointer casts or (equivalently) `ptr::with_exposed_provenance`, which means that Miri might miss pointer bugs in this program
= help: see https://doc.rust-lang.org/nightly/std/ptr/fn.with_exposed_provenance.html for more details on that operation
= help: to ensure that Miri does not miss bugs in your program, use Strict Provenance APIs (https://doc.rust-lang.org/nightly/std/ptr/index.html#strict-provenance, https://crates.io/crates/sptr) instead
= help: you can then set `MIRIFLAGS=-Zmiri-strict-provenance` to ensure you are not relying on `with_exposed_provenance` semantics
= help: alternatively, `MIRIFLAGS=-Zmiri-permissive-provenance` disables this warning
error: Undefined Behavior: constructing invalid value of type &mut [i32]: encountered a dangling reference (0x1234[noalloc] has no provenance)
--> src/main.rs:7:35
|
7 | let values: &[i32] = unsafe { slice::from_raw_parts_mut(r, 10000) };
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Undefined Behavior occurred here
|
= help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
= help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
error: aborting due to 1 previous error; 1 warning emitted
Miri แจ้งเตือนอย่างถูกต้องว่าเรากำลังแปลงเลขจำนวนเต็มไปเป็นพอยน์เตอร์ ซึ่งอาจก่อให้เกิดปัญหาได้ แต่ Miri ยังไม่สามารถฟันธงได้ว่ามีปัญหาจริงหรือไม่ เนื่องจากมันไม่ทราบที่มาที่ไปของพอยน์เตอร์นั้น จากนั้น Miri จะส่งข้อผิดพลาดออกมาตรงจุดที่ลิสติ้ง 20-7 มีพฤติกรรมที่ไม่พึงประสงค์ เนื่องจากเรามีพอยน์เตอร์ค้าง (dangling pointer) ที่ชี้ไปยังตำแหน่งที่ไม่ถูกต้อง ด้วยความช่วยเหลือของ Miri ทำให้ตอนนี้เราทราบถึงความเสี่ยงของการเกิด undefined behavior และสามารถหาวิธีปรับปรุงโค้ดให้ปลอดภัยได้ ในบางกรณี Miri ยังสามารถให้คำแนะนำเกี่ยวกับวิธีแก้ไขข้อผิดพลาดได้อีกด้วย
อย่างไรก็ตาม Miri ไม่ได้ตรวจจับทุกข้อผิดพลาดที่คุณอาจทำพลาดในการเขียนโค้ด unsafe เนื่องจาก Miri เป็นเครื่องมือวิเคราะห์แบบไดนามิก จึงตรวจจับปัญหาได้เฉพาะกับโค้ดส่วนที่ถูกรันจริงเท่านั้น นั่นหมายความว่าคุณจำเป็นต้องใช้งานมันควบคู่ไปกับเทคนิคการทดสอบที่ดีเพื่อเพิ่มความมั่นใจในโค้ด unsafe ที่คุณเขียนขึ้น นอกจากนี้ Miri ยังไม่ได้ครอบคลุมทุกแง่มุมที่โค้ดของคุณอาจไม่ปลอดภัยสมบูรณ์ (unsound)
กล่าวอีกนัยหนึ่งคือ: หาก Miri ตรวจพบปัญหา คุณก็มั่นใจได้เลยว่ามีบั๊กอยู่แน่นอน แต่การที่ Miri ตรวจไม่พบบั๊ก ก็ไม่ได้แปลว่าจะไม่มีปัญหาใด ๆ ซ่อนอยู่ ถึงกระนั้น Miri ก็สามารถตรวจจับข้อผิดพลาดได้เป็นจำนวนมาก ลองนำไปรันกับตัวอย่างโค้ด unsafe อื่น ๆ ในบทนี้ดู แล้วสังเกตผลลัพธ์ที่ได้รับ!
คุณสามารถเรียนรู้เพิ่มเติมเกี่ยวกับ Miri ได้ที่ GitHub repository ของ Miri
การใช้โค้ด unsafe อย่างถูกต้อง
การใช้คำสงวน unsafe เพื่อใช้งานพลังพิเศษอย่างใดอย่างหนึ่งใน 5 ข้อที่เพิ่งกล่าวถึงไปนั้นไม่ใช่เรื่องผิด และไม่ใช่เรื่องที่น่าตำหนิแต่อย่างใด เพียงแต่การเขียนโค้ด unsafe ให้ถูกต้องสมบูรณ์นั้นทำได้ยากกว่า เพราะคอมไพเลอร์ไม่สามารถช่วยดูแลความปลอดภัยของหน่วยความจำให้ได้ เมื่อคุณมีเหตุผลจำเป็นต้องใช้โค้ด unsafe คุณก็สามารถใช้งานได้ และการกำกับด้วย unsafe ไว้อย่างชัดเจนจะช่วยให้ค้นหาต้นตอของปัญหาได้ง่ายยิ่งขึ้นเมื่อเกิดข้อผิดพลาดขึ้น และเมื่อใดก็ตามที่คุณเขียนโค้ด unsafe คุณสามารถนำ Miri มาช่วยเพิ่มความมั่นใจว่าโค้ดที่คุณเขียนนั้นยังคงปฏิบัติตามกฎเกณฑ์ของ Rust ได้
สำหรับการศึกษาเชิงลึกเพิ่มเติมเกี่ยวกับวิธีการทำงานกับ unsafe Rust อย่างมีประสิทธิภาพ สามารถอ่านเพิ่มเติมได้จากคู่มืออย่างเป็นทางการของ Rust สำหรับ unsafe นั่นคือ “The Rustonomicon”