ข้อผิดพลาดที่กู้คืนไม่ได้ด้วย panic!
ในบางครั้ง ข้อผิดพลาดร้ายแรงอาจเกิดขึ้นในโค้ดของคุณโดยที่โปรแกรมไม่สามารถจัดการอะไรต่อไปได้ ในสถานการณ์เช่นนี้ Rust มีแมโคร panic! ไว้รองรับ ในทางปฏิบัติ มีสองวิธีที่จะทำให้เกิดการแพนิก (panic): วิธีแรกคือการกระทำบางอย่างที่ทำให้โค้ดเกิด panic (เช่น การเข้าถึงข้อมูลในอาร์เรย์เกินตำแหน่งสิ้นสุด) หรือวิธีที่สองคือการเรียกใช้แมโคร panic! อย่างโจ่งแจ้งด้วยตัวเอง ไม่ว่าจะเป็นกรณีใด ทั้งคู่ล้วนส่งผลให้โปรแกรมของเราเกิด panic ขึ้น โดยตามค่าเริ่มต้นแล้ว เมื่อเกิด panic โปรแกรมจะพิมพ์ข้อความแสดงความผิดพลาด ทำการคลี่คลายสแตก (unwind) เคลียร์ข้อมูลออกจากสแตก แล้วปิดโปรแกรม นอกจากนี้ คุณยังสามารถตั้งค่าตัวแปรสภาพแวดล้อมเพื่อให้ Rust แสดงคอลสแตก (call stack) ในขณะที่เกิด panic ได้ ซึ่งจะช่วยให้คุณติดตามหาต้นตอของปัญหาได้ง่ายขึ้น
การคลี่คลายสแตกหรือการยกเลิกทันทีเมื่อเกิดการแพนิก
โดยค่าเริ่มต้น เมื่อเกิด panic โปรแกรมจะเริ่มทำการ คลี่คลายสแตก (unwinding) ซึ่งหมายความว่า Rust จะเดินย้อนกลับขึ้นไปตามสแตกและทำความสะอาด (clean up) ข้อมูลของแต่ละฟังก์ชันที่พบ ทว่ากระบวนการเดินย้อนและทำความสะอาดนี้ต้องใช้ทรัพยากรและการทำงานค่อนข้างมาก Rust จึงเปิดโอกาสให้คุณเลือกอีกทางเลือกหนึ่งได้ นั่นคือการ ยกเลิกทันที (aborting) ซึ่งจะยุติการทำงานของโปรแกรมลงทันทีโดยไม่ต้องเสียเวลาทำความสะอาดสแตก
ส่วนหน่วยความจำที่โปรแกรมเคยใช้งานอยู่นั้นจะถูกปล่อยให้เป็นหน้าที่ของระบบปฏิบัติการในการกวาดล้างคืนเอง หากในโปรเจกต์ของคุณต้องการให้ไฟล์ไบนารีผลลัพธ์มีขนาดเล็กที่สุดเท่าที่จะทำได้ คุณสามารถเปลี่ยนพฤติกรรมจาก unwinding เป็น aborting ได้เมื่อเกิด panic โดยการเพิ่ม
panic = 'abort'เข้าไปในส่วน[profile]ที่เกี่ยวข้องภายในไฟล์ Cargo.toml ตัวอย่างเช่น หากคุณต้องการให้ยกเลิกทันทีเมื่อเกิด panic ในโหมด release ให้กำหนดค่าดังนี้:[profile.release] panic = 'abort'
มาลองเรียกใช้ panic! ในโปรแกรมง่ายๆ กันดู:
fn main() {
panic!("crash and burn");
}
เมื่อคุณรันโปรแกรม คุณจะเห็นผลลัพธ์ประมาณนี้:
$ cargo run
Compiling panic v0.1.0 (file:///projects/panic)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.25s
Running `target/debug/panic`
thread 'main' (6018279) panicked at src/main.rs:2:5:
crash and burn
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
การเรียกใช้ panic! ส่งผลให้เกิดข้อความแสดงข้อผิดพลาดในสองบรรทัดสุดท้าย โดยบรรทัดแรกจะแสดงข้อความ panic ของเราพร้อมกับตำแหน่งในซอร์สโค้ดที่เกิด panic ขึ้น: ตัวเลข src/main.rs:2:5 บ่งบอกว่ามันคือบรรทัดที่ 2 ตัวอักษรที่ 5 ในไฟล์ src/main.rs ของเรา
ในกรณีนี้ บรรทัดที่ถูกระบุเป็นโค้ดที่เราเขียนขึ้นเอง และหากเราเปิดไปดูที่บรรทัดนั้น เราจะเห็นคำสั่งเรียกแมโคร panic! พอดี แต่ในกรณีอื่นๆ การเรียกใช้ panic! อาจเกิดขึ้นภายในโค้ดภายนอกที่โค้ดเราเรียกใช้อีกทอดหนึ่ง ซึ่งในกรณีนั้น ชื่อไฟล์และหมายเลขบรรทัดที่แสดงในข้อความแจ้งข้อผิดพลาดจะชี้ไปยังโค้ดของผู้อื่นที่มีการเรียกแมโคร panic! ไม่ใช่บรรทัดในโค้ดของเราที่ส่งผลให้เกิดการเรียก panic! ดังกล่าว
เราสามารถใช้แบ็กเทรซ (backtrace) ของฟังก์ชันที่ส่งผลให้เกิดการเรียก panic! เพื่อสืบหาว่าส่วนใดในโค้ดของเราที่เป็นต้นเหตุของปัญหา และเพื่อทำความเข้าใจวิธีการใช้งานแบ็กเทรซของ panic! มาดูอีกตัวอย่างหนึ่งว่าจะเป็นอย่างไรเมื่อคำสั่ง panic! ถูกเรียกขึ้นจากภายในไลบรารีอันเนื่องมาจากบั๊กในโค้ดของเรา แทนที่จะมาจากการที่เราเรียกใช้แมโครโดยตรง ลิสติ้ง 9-1 แสดงโค้ดที่พยายามเข้าถึงดัชนีในเวกเตอร์ที่เกินขอบเขตของดัชนีที่มีอยู่จริง
fn main() {
let v = vec![1, 2, 3];
v[99];
}
ในตัวอย่างนี้ เราพยายามเข้าถึงสมาชิกตัวที่ 100 ของเวกเตอร์ (ซึ่งอยู่ที่ดัชนี 99 เพราะการระบุดัชนีเริ่มต้นจากศูนย์) แต่เวกเตอร์กลับมีสมาชิกเพียงแค่สามตัวเท่านั้น ในสถานการณ์นี้ Rust จะเกิด panic ขึ้นมา การใช้วงเล็บ [] นั้นควรจะต้องคืนค่าสมาชิกออกมาหนึ่งตัว แต่เมื่อคุณระบุดัชนีที่ไม่ถูกต้อง ย่อมไม่มีสมาชิกใดที่ Rust จะสามารถส่งคืนกลับมาได้อย่างถูกต้อง
ในภาษา C การพยายามอ่านข้อมูลเกินขอบเขตของโครงสร้างข้อมูลถือเป็นพฤติกรรมที่ไม่พึงประสงค์และไม่ได้นิยามไว้ (undefined behavior) คุณอาจได้ค่าอะไรก็ตามที่อยู่ในตำแหน่งหน่วยความจำถัดไป แม้ว่าหน่วยความจำนั้นจะไม่ได้เป็นของโครงสร้างข้อมูลดังกล่าวเลยก็ตาม ปัญหานี้เรียกว่า การอ่านเกินบัฟเฟอร์ (buffer overread) ซึ่งอาจนำไปสู่ช่องโหว่ด้านความปลอดภัยร้ายแรงได้ หากผู้โจมตีสามารถควบคุมค่าดัชนีเพื่อแอบอ่านข้อมูลสำคัญอื่นๆ ที่เก็บอยู่ถัดจากโครงสร้างข้อมูลนั้น
เพื่อปกป้องโปรแกรมของคุณจากช่องโหว่ประเภทนี้ หากคุณพยายามอ่านสมาชิกที่ดัชนีที่ไม่มีอยู่จริง Rust จะสั่งหยุดการทำงานทันทีและปฏิเสธที่จะทำงานต่อ มาลองรันดูผลลัพธ์กัน:
$ cargo run
Compiling panic v0.1.0 (file:///projects/panic)
Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.27s
Running `target/debug/panic`
thread 'main' (6017887) panicked at src/main.rs:4:6:
index out of bounds: the len is 3 but the index is 99
note: run with `RUST_BACKTRACE=1` environment variable to display a backtrace
ข้อผิดพลาดนี้ชี้ไปที่บรรทัดที่ 4 ของไฟล์ main.rs ซึ่งเป็นจุดที่เราพยายามเข้าถึงดัชนี 99 ของเวกเตอร์ในตัวแปร v
บรรทัด note: แนะนำให้เราทราบว่า เราสามารถตั้งค่าตัวแปรสภาพแวดล้อม RUST_BACKTRACE เพื่อดูแบ็กเทรซของลำดับเหตุการณ์ทั้งหมดที่ทำให้เกิดข้อผิดพลาดได้ โดย แบ็กเทรซ (backtrace) คือรายการของฟังก์ชันทั้งหมดที่ถูกเรียกใช้ไล่มาจนถึงจุดนี้ แบ็กเทรซใน Rust ทำงานในลักษณะเดียวกับภาษาอื่นๆ: หัวใจสำคัญในการอ่านแบ็กเทรซคือ ให้เริ่มดูจากด้านบนสุดแล้วไล่อ่านลงมาจนกระทั่งเจอบรรทัดที่เป็นไฟล์ที่คุณเขียนขึ้นเอง นั่นคือจุดเริ่มต้นที่เป็นต้นตอของปัญหา บรรทัดที่อยู่เหนือจุดนั้นขึ้นไปคือโค้ดภายในที่โค้ดของคุณเรียกใช้ ส่วนบรรทัดที่อยู่ต่ำลงมาคือโค้ดที่เป็นตัวเรียกโค้ดของคุณ ซึ่งบรรทัดก่อนหน้าและหลังจากนั้นอาจประกอบไปด้วยโค้ดแกนหลักของ Rust โค้ดของไลบรารีมาตรฐาน หรือเครตภายนอกที่คุณดึงมาใช้งาน มาลองดูแบ็กเทรซโดยการตั้งค่าตัวแปรสภาพแวดล้อม RUST_BACKTRACE ให้เป็นค่าใดก็ได้ที่ไม่ใช่ 0 กันดู ซึ่งลิสติ้ง 9-2 แสดงผลลัพธ์คล้ายกับสิ่งที่คุณจะได้เห็น
$ RUST_BACKTRACE=1 cargo run
thread 'main' panicked at src/main.rs:4:6:
index out of bounds: the len is 3 but the index is 99
stack backtrace:
0: rust_begin_unwind
at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/std/src/panicking.rs:692:5
1: core::panicking::panic_fmt
at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/core/src/panicking.rs:75:14
2: core::panicking::panic_bounds_check
at /rustc/4d91de4e48198da2e33413efdcd9cd2cc0c46688/library/core/src/panicking.rs:273:5
3: <usize as core::slice::index::SliceIndex<[T]>>::index
at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/slice/index.rs:274:10
4: core::slice::index::<impl core::ops::index::Index<I> for [T]>::index
at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/slice/index.rs:16:9
5: <alloc::vec::Vec<T,A> as core::ops::index::Index<I>>::index
at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/alloc/src/vec/mod.rs:3361:9
6: panic::main
at ./src/main.rs:4:6
7: core::ops::function::FnOnce::call_once
at file:///home/.rustup/toolchains/1.85/lib/rustlib/src/rust/library/core/src/ops/function.rs:250:5
note: Some details are omitted, run with `RUST_BACKTRACE=full` for a verbose backtrace.
ผลลัพธ์ที่แสดงออกมานั้นมีรายละเอียดเยอะมาก! ซึ่งสิ่งที่คุณเห็นจริงอาจมีความแตกต่างกันไปบ้าง ขึ้นอยู่กับระบบปฏิบัติการและเวอร์ชันของ Rust ที่คุณใช้งาน และเพื่อให้ได้แบ็กเทรซที่มีข้อมูลครบถ้วนเช่นนี้ ตัวโปรแกรมจะต้องเปิดใช้งานสัญลักษณ์ดีบัก (debug symbols) ไว้ด้วย ซึ่งโดยค่าเริ่มต้นแล้ว debug symbols จะถูกเปิดใช้งานเสมอเมื่อเรารันคำสั่ง cargo build หรือ cargo run โดยไม่ได้ระบุแฟล็ก --release ดังเช่นในตัวอย่างนี้
ในผลลัพธ์ของลิสติ้ง 9-2 บรรทัดที่ 6 ของแบ็กเทรซจะชี้ไปยังบรรทัดในโปรเจกต์ของเราที่เป็นต้นตอของปัญหา นั่นคือบรรทัดที่ 4 ของไฟล์ src/main.rs หากเราไม่ต้องการให้โปรแกรมเกิด panic เราก็ควรเริ่มตรวจสอบจากตำแหน่งที่บรรทัดแรกซึ่งกล่าวถึงไฟล์ที่เราเขียนขึ้นชี้ไป ในลิสติ้ง 9-1 ซึ่งเป็นโค้ดที่เราตั้งใจเขียนให้เกิด panic นั้น วิธีแก้ไขก็คือการไม่ขอเข้าถึงสมาชิกที่อยู่นอกเหนือช่วงดัชนีของเวกเตอร์ และเมื่อใดก็ตามที่โค้ดของคุณเกิด panic ขึ้นในอนาคต คุณก็จะต้องสืบหาว่าโค้ดกำลังทำงานอะไรและใช้ค่าอะไรที่ทำให้เกิด panic รวมถึงพิจารณาว่าโค้ดควรจะทำงานอย่างไรแทนจึงจะถูกต้อง
เราจะกลับมาพูดถึง panic! รวมถึงประเด็นที่ว่าเมื่อใดที่เราควรหรือไม่ควรใช้ panic! เพื่อจัดการกับเงื่อนไขข้อผิดพลาดในหัวข้อ “จะ panic! หรือไม่ panic!” ในช่วงท้ายของบทนี้ ส่วนต่อไปเราจะไปดูวิธีจัดการและกู้คืนจากข้อผิดพลาดโดยใช้ Result กัน