บทที่ 12: I/O เกือบทุกแอปพลิเคชันต้องการการอ่านหรือเขียนไฟล์หรือดำเนินการ I/O อื่นๆ Qt ให้การสนับสนุน I/O ที่ยอดเยี่ยมด้วย QIODevice ซึ่งเป็นนามธรรมอันทรงพลังของ "อุปกรณ์" ที่สามารถอ่านและเขียนได้

อินพุตและเอาท์พุต ฉันยังพบว่าสิ่งสำคัญมากคือผลลัพธ์ของฉันจะต้องขับเคลื่อนด้วย "อินพุต" ที่เหมาะสม การเขียน รหัสโปรแกรม- งานสร้างสรรค์ ความคิดสร้างสรรค์ของฉันมักจะดีที่สุดเมื่อฉันเผชิญกับความท้าทายที่สร้างสรรค์

งานที่ออกคำขอสำหรับการดำเนินการ I/O จะถูกวางไว้โดยหัวหน้างานในสถานะรอการดำเนินการที่ได้รับคำสั่งให้เสร็จสิ้น เมื่อหัวหน้างานได้รับข้อความจากส่วนที่เสร็จสมบูรณ์ว่าการดำเนินการเสร็จสิ้นแล้ว จะทำให้งานอยู่ในสถานะพร้อมและทำงานต่อไป สถานการณ์นี้สอดคล้องกับ I/O แบบซิงโครนัส Synchronous I/O เป็นมาตรฐานในระบบปฏิบัติการส่วนใหญ่ เพื่อเพิ่มความเร็วในการดำเนินการแอปพลิเคชัน จึงเสนอให้ใช้ I/O แบบอะซิงโครนัสเมื่อจำเป็น

เวอร์ชันที่ง่ายที่สุดของเอาต์พุตแบบอะซิงโครนัสคือสิ่งที่เรียกว่าบัฟเฟอร์เอาต์พุตไปยังอุปกรณ์ภายนอก ซึ่งข้อมูลจากแอปพลิเคชันจะไม่ถูกถ่ายโอนโดยตรงไปยังอุปกรณ์ I/O แต่ไปยังบัฟเฟอร์ระบบพิเศษ ในกรณีนี้ ตามตรรกะแล้ว การดำเนินการเอาท์พุตสำหรับแอปพลิเคชันจะถือว่าเสร็จสิ้นทันที และงานอาจไม่รอให้กระบวนการโอนข้อมูลจริงไปยังอุปกรณ์เสร็จสิ้น กระบวนการ ผลผลิตที่แท้จริงข้อมูลจากบัฟเฟอร์ระบบได้รับการจัดการโดยผู้ดูแล I/O โดยปกติแล้ว กระบวนการของระบบพิเศษตามทิศทางของผู้ดูแล I/O มีหน้าที่รับผิดชอบในการจัดสรรบัฟเฟอร์จากพื้นที่หน่วยความจำระบบ ดังนั้น สำหรับกรณีที่พิจารณา เอาต์พุตจะเป็นแบบอะซิงโครนัสหากประการแรก คำขอ I/O ระบุความจำเป็นในการบัฟเฟอร์ข้อมูล และประการที่สอง หากอุปกรณ์ I/O อนุญาตการดำเนินการแบบอะซิงโครนัสดังกล่าว และสิ่งนี้จะถูกบันทึกไว้ใน UCB คุณยังสามารถจัดระเบียบการป้อนข้อมูลแบบอะซิงโครนัสได้ อย่างไรก็ตาม ในการดำเนินการนี้ ไม่เพียงแต่จำเป็นจะต้องจัดสรรพื้นที่หน่วยความจำสำหรับการจัดเก็บข้อมูลชั่วคราวที่อ่านจากอุปกรณ์ และเพื่อเชื่อมโยงบัฟเฟอร์ที่จัดสรรกับงานที่สั่งการดำเนินการ แต่ยังต้องแบ่งคำขอสำหรับ I/O ด้วย การดำเนินการเป็นสองส่วน (เป็นสองคำขอ) คำขอแรกระบุการดำเนินการในการอ่านข้อมูล คล้ายกับการดำเนินการกับ I/O แบบซิงโครนัส อย่างไรก็ตาม ประเภท (รหัส) ของคำขอนั้นแตกต่างกัน และคำขอระบุพารามิเตอร์เพิ่มเติมอย่างน้อยหนึ่งรายการ - ชื่อ (รหัส) ของออบเจ็กต์ระบบที่งานได้รับเพื่อตอบสนองต่อคำขอและระบุบัฟเฟอร์ที่จัดสรร หลังจากได้รับชื่อของบัฟเฟอร์ (ตามอัตภาพเราจะเรียกวัตถุระบบนี้ด้วยวิธีนี้แม้ว่าระบบปฏิบัติการที่แตกต่างกันจะใช้คำอื่นเพื่อกำหนดเช่นคลาส) งานยังคงทำงานต่อไป สิ่งสำคัญมากที่ต้องเน้น ณ ที่นี้ว่าเป็นผลมาจากคำขอป้อนข้อมูลแบบอะซิงโครนัส งานจะไม่อยู่ในสถานะโดยผู้ดูแล I/O เพื่อรอให้การดำเนินการ I/O เสร็จสิ้น แต่ยังคงอยู่ในการทำงานหรือ สถานะพร้อมที่จะดำเนินการ หลังจากผ่านไประยะหนึ่ง เมื่อรันโค้ดที่จำเป็นซึ่งกำหนดโดยโปรแกรมเมอร์แล้ว งานจะออกคำขอครั้งที่สองเพื่อให้การดำเนินการ I/O เสร็จสมบูรณ์ ในคำขอครั้งที่สองนี้ไปยังอุปกรณ์เดียวกัน ซึ่งแน่นอนว่ามีรหัสที่แตกต่างกัน (หรือชื่อคำขอ) งานจะระบุชื่อของอ็อบเจ็กต์ระบบ (บัฟเฟอร์สำหรับการป้อนข้อมูลแบบอะซิงโครนัส) และหากการดำเนินการอ่านข้อมูลสำเร็จ รับมันจากบัฟเฟอร์ระบบทันที หากข้อมูลจากอุปกรณ์ภายนอกไปยังบัฟเฟอร์ระบบยังไม่ได้รับการถ่ายโอนอย่างสมบูรณ์ ผู้ดูแล I/O จะสลับงานเป็นสถานะรอการดำเนินการ I/O เสร็จสิ้น จากนั้นทุกอย่างจะคล้ายกับอินพุตข้อมูลซิงโครนัสปกติ

โดยทั่วไปแล้ว I/O แบบอะซิงโครนัสจะมีให้ในระบบปฏิบัติการที่มีการเขียนโปรแกรมหลายโปรแกรมส่วนใหญ่ โดยเฉพาะอย่างยิ่งหากระบบปฏิบัติการรองรับการทำงานหลายอย่างพร้อมกันโดยใช้กลไกเธรด อย่างไรก็ตาม หากไม่มีอินพุต/เอาท์พุตแบบอะซิงโครนัสที่ชัดเจน คุณสามารถนำแนวคิดของมันไปปฏิบัติได้ด้วยตัวเองโดยจัดระเบียบเธรดอิสระสำหรับเอาต์พุตข้อมูล

ฮาร์ดแวร์ I/O ถือได้ว่าเป็นคอลเลกชัน โปรเซสเซอร์ฮาร์ดแวร์ซึ่งสามารถทำงานแบบขนานโดยสัมพันธ์กันรวมถึงสัมพันธ์กับโปรเซสเซอร์กลาง (โปรเซสเซอร์) บน "โปรเซสเซอร์" ดังกล่าวเรียกว่า กระบวนการภายนอกตัวอย่างเช่น สำหรับอุปกรณ์ภายนอก (อุปกรณ์อินพุต/เอาท์พุต) กระบวนการภายนอกอาจเป็นชุดของการดำเนินการที่แปลหัวพิมพ์ เลื่อนกระดาษไปหนึ่งตำแหน่ง เปลี่ยนสีหมึก หรือพิมพ์อักขระบางตัว กระบวนการภายนอกโดยใช้ฮาร์ดแวร์อินพุต/เอาท์พุต โต้ตอบระหว่างกันและกับกระบวนการ "ซอฟต์แวร์" ทั่วไปที่ทำงานบนโปรเซสเซอร์กลาง ข้อเท็จจริงที่สำคัญคือความเร็วของการดำเนินการของกระบวนการภายนอกจะแตกต่างกันอย่างมีนัยสำคัญ (บางครั้งตามลำดับความสำคัญหรือมากกว่า) จากความเร็วของการดำเนินการของกระบวนการทั่วไป (“ ภายใน") กระบวนการ สำหรับการทำงานปกติ กระบวนการภายนอกและภายในจะต้องซิงโครไนซ์ เพื่อให้ผลกระทบของความเร็วที่ไม่ตรงกันอย่างมากระหว่างกระบวนการภายในและภายนอกราบรื่นขึ้น จึงมีการใช้การบัฟเฟอร์ที่กล่าวถึงข้างต้น ดังนั้น เราสามารถพูดคุยเกี่ยวกับระบบของกระบวนการโต้ตอบแบบขนานได้ (ดูบทที่ 6)

บัฟเฟอร์เป็นทรัพยากรที่สำคัญที่เกี่ยวข้องกับกระบวนการภายใน (ซอฟต์แวร์) และภายนอก ซึ่งในระหว่างการพัฒนาแบบขนานนั้นจะมีการโต้ตอบข้อมูล ผ่านบัฟเฟอร์ ข้อมูลจะถูกส่งจากกระบวนการบางอย่างไปยังกระบวนการภายนอกที่สามารถระบุแอดเดรสได้ (การดำเนินการส่งออกข้อมูลไปยังอุปกรณ์ภายนอก) หรือจากกระบวนการภายนอกจะถูกถ่ายโอนไปยังกระบวนการซอฟต์แวร์บางอย่าง (การดำเนินการอ่านข้อมูล) การแนะนำการบัฟเฟอร์เป็นวิธีโต้ตอบข้อมูลทำให้เกิดปัญหาในการจัดการบัฟเฟอร์ระบบเหล่านี้ ซึ่งแก้ไขได้โดยใช้ส่วนกำกับดูแลของระบบปฏิบัติการ ในกรณีนี้ ผู้บังคับบัญชาไม่เพียงแต่มอบหมายให้จัดสรรและปล่อยบัฟเฟอร์ในพื้นที่หน่วยความจำระบบเท่านั้น แต่ยังรวมถึงกระบวนการซิงโครไนซ์ตามสถานะการดำเนินการเพื่อเติมหรือปล่อยบัฟเฟอร์ให้ว่าง ตลอดจนรอหากไม่มีการว่าง มีบัฟเฟอร์อยู่และคำขออินพุต/เอาต์พุตจำเป็นต้องมีการบัฟเฟอร์ โดยทั่วไปแล้ว ผู้ดูแล I/O จะใช้เครื่องมือการซิงโครไนซ์มาตรฐานที่ใช้ในระบบปฏิบัติการที่กำหนดเพื่อแก้ไขงานที่แสดงไว้ ดังนั้นหากระบบปฏิบัติการได้พัฒนาเครื่องมือสำหรับการแก้ปัญหาการดำเนินการแบบขนานของแอปพลิเคชันและงานที่มีการโต้ตอบ ตามกฎแล้วระบบปฏิบัติการก็จะใช้อินพุต/เอาท์พุตแบบอะซิงโครนัสด้วย

บันทึก

ในความเป็นจริงมันไม่ง่ายขนาดนั้น read(2) ต้องรอให้ข้อมูลถูกอ่านทางกายภาพจากอุปกรณ์ แต่ write(2) ทำงานในโหมด write-lazy ตามค่าเริ่มต้น โดยจะส่งกลับหลังจากข้อมูลถูกถ่ายโอนไปยังบัฟเฟอร์ระบบ แต่โดยทั่วไปก่อน ข้อมูลถูกถ่ายโอนทางกายภาพไปยังอุปกรณ์ ซึ่งมักจะช่วยปรับปรุงประสิทธิภาพที่สังเกตได้ของโปรแกรมอย่างมีนัยสำคัญ และช่วยให้หน่วยความจำจากข้อมูลสามารถนำไปใช้เพื่อวัตถุประสงค์อื่นได้ทันทีหลังจากส่งคืน write(2) แต่การบันทึกล่าช้าก็มีข้อเสียอย่างมากเช่นกัน สิ่งสำคัญคือคุณจะได้เรียนรู้เกี่ยวกับผลลัพธ์ของการดำเนินการทางกายภาพ ไม่ใช่ในทันทีด้วยโค้ดส่งคืนของ write(2) แต่เพียงบางครั้งหลังจากการส่งคืน โดยปกติแล้วจะเป็นโค้ดส่งคืนของการเรียก write(2) ครั้งถัดไป สำหรับบางแอปพลิเคชัน - การตรวจสอบธุรกรรม โปรแกรมเรียลไทม์จำนวนมาก ฯลฯ - สิ่งนี้เป็นสิ่งที่ยอมรับไม่ได้และถูกบังคับให้ปิดการบันทึกแบบ Lazy ซึ่งทำได้โดยการตั้งค่าสถานะ O_SYNC ซึ่งสามารถตั้งค่าได้เมื่อเปิดและเปลี่ยนแปลงไฟล์ที่ เปิดไฟล์โดยเรียก fcntl(2)

การซิงโครไนซ์การเขียนแต่ละรายการสามารถมั่นใจได้โดยการเรียก fsync(2) สำหรับแอพพลิเคชั่นจำนวนมากที่เกี่ยวข้องกับอุปกรณ์หลายตัวและ/หรือการเชื่อมต่อเครือข่าย โมเดลซิงโครนัสไม่สะดวก การทำงานในโหมดโพลก็ไม่เป็นที่ยอมรับเสมอไป ความจริงก็คือว่า select(3C) และ poll(2) พิจารณา file descriptor ที่พร้อมสำหรับการอ่านหลังจากที่ข้อมูลปรากฏในบัฟเฟอร์แล้วเท่านั้น แต่อุปกรณ์บางชนิดจะเริ่มส่งข้อมูลหลังจากได้รับการร้องขออย่างชัดเจนเท่านั้น

นอกจากนี้ สำหรับบางแอปพลิเคชัน โดยเฉพาะแอปพลิเคชันแบบเรียลไทม์ สิ่งสำคัญคือต้องทราบเวลาที่แน่ชัดว่าข้อมูลเริ่มมาถึงเมื่อใด สำหรับแอปพลิเคชันดังกล่าว การเลือก (3C) และการสำรวจความคิดเห็น (2) อาจเป็นที่ยอมรับไม่ได้ ไฟล์ปกติพร้อมเสมอที่จะอ่านและเขียน จริงหรือ, ระบบไฟล์อ่านจากดิสก์และถึงแม้ว่ามันจะทำงานได้เร็วกว่าส่วนใหญ่มากก็ตาม เชื่อมต่อเครือข่ายแต่การเข้าถึงยังคงเกี่ยวข้องกับความล่าช้าบางประการ สำหรับแอปพลิเคชันแบบเรียลไทม์แบบฮาร์ด ความล่าช้าเหล่านี้อาจยอมรับไม่ได้ - แต่ไม่มีคำขออ่านที่ชัดเจน ระบบไฟล์ไม่ให้ข้อมูล!

สำหรับแอปพลิเคชันเรียลไทม์แบบฮาร์ด ปัญหา I/O อีกแง่มุมหนึ่งอาจมีนัยสำคัญ ความจริงก็คือว่าแอปพลิเคชัน RT แบบฮาร์ดมีลำดับความสำคัญสูงกว่าเคอร์เนล ดังนั้นจึงดำเนินการเรียกของระบบ - แม้ว่าจะไม่ได้บล็อกก็ตาม! - สามารถนำไปสู่ การผกผันลำดับความสำคัญ.

วิธีแก้ปัญหาเหล่านี้ทราบกันมานานแล้ว และเรียกว่าอินพุต/เอาท์พุตแบบอะซิงโครนัส ในโหมดนี้ การเรียกระบบ I/O จะส่งคืนการควบคุมทันทีหลังจากการร้องขอไปยังไดรเวอร์อุปกรณ์ โดยทั่วไปก่อนที่ข้อมูลจะถูกคัดลอกไปยังบัฟเฟอร์ของระบบด้วยซ้ำ การสร้างคำขอประกอบด้วยการวางรายการ (IRP, แพ็กเก็ตคำขออินพุต/เอาต์พุต, แพ็กเก็ตคำขออินพุต/เอาต์พุต) ลงในคิว ในการดำเนินการนี้ คุณจะต้องจับภาพ mutex ที่ปกป้อง "ส่วนท้าย" ของคิวเพียงสั้นๆ เท่านั้น จึงสามารถเอาชนะปัญหาการกลับลำดับความสำคัญได้อย่างง่ายดาย เพื่อดูว่าการโทรสิ้นสุดลงแล้วหรือไม่และสิ้นสุดแล้วอย่างไรและสามารถใช้หน่วยความจำที่จัดเก็บข้อมูลไว้ได้หรือไม่มีการจัดเตรียม API พิเศษไว้ (ดูรูปที่ 8.1)

ข้าว. 8.1.

โมเดลอะซิงโครนัสเป็นโมเดล I/O หลักในระบบปฏิบัติการ เช่น DEC RT-11, DEC RSX-11, VAX/VMS, OpenVMS เกือบทุกคนสนับสนุนโมเดลนี้ในรูปแบบใดรูปแบบหนึ่ง ระบบปฏิบัติการแบบเรียลไทม์. ระบบ Unix ใช้ API ที่เข้ากันไม่ได้หลายอย่างสำหรับ I/O แบบอะซิงโครนัสตั้งแต่ปลายทศวรรษ 1980 ในปี 1993 ANSI/IEEE นำ POSIX 1003.1b มาใช้ ซึ่งอธิบาย API ที่เป็นมาตรฐานซึ่งเราจะสำรวจในภายหลังในส่วนนี้

ใน Solaris 10 ฟังก์ชัน I/O แบบอะซิงโครนัสจะรวมอยู่ในไลบรารี libaio.so เมื่อต้องการสร้างโปรแกรมที่ใช้ฟังก์ชันเหล่านี้ คุณต้องใช้สวิตช์ -laio ในการสร้างคำขอสำหรับ I/O แบบอะซิงโครนัส จะใช้ฟังก์ชัน aio_read(3AIO), aio_write(3AIO) และ lio_listio(3AIO)

ฟังก์ชัน aio_read(3AIO) และ aio_write(3AIO) มีพารามิเตอร์ตัวเดียว คือ structaiocb *aiocbp โครงสร้าง aiocb ถูกกำหนดไว้ในไฟล์< aio.h>และประกอบด้วยฟิลด์ต่อไปนี้:

• int aio_fildes - ตัวอธิบายไฟล์
• off_t aio_offset - ออฟเซ็ตในไฟล์โดยเริ่มจากการเขียนหรือการอ่านที่จะเริ่มต้น
• volatile void* aio_buf - บัฟเฟอร์ที่ควรอ่านข้อมูลหรือข้อมูลที่จะเขียนอยู่
• size_t aio_nbytes - ขนาดบัฟเฟอร์ เช่นเดียวกับ read(2) แบบดั้งเดิม aio_read(3AIO) สามารถอ่านข้อมูลน้อยกว่าที่ร้องขอ แต่จะไม่อ่านเพิ่มเติมอีก
• int aio_reqprio - ขอลำดับความสำคัญ
• struct sigevent aio_sigevent - วิธีการแจ้งว่าคำขอเสร็จสมบูรณ์ (จะกล่าวถึงในภายหลังในส่วนนี้)
• int aio_lio_opcode - ไม่ใช้สำหรับ aio_read(3AIO) และ aio_write(3AIO) ใช้โดยฟังก์ชัน lio_listio เท่านั้น

ฟังก์ชัน lio_listio(3AIO) ช่วยให้คุณสร้างคำขอ I/O หลายคำขอด้วยการเรียกระบบเพียงครั้งเดียว ฟังก์ชันนี้มีพารามิเตอร์สี่ตัว:

• โหมด int - สามารถรับค่า LIO_WAIT (ฟังก์ชันรอให้คำขอทั้งหมดเสร็จสมบูรณ์) และ LIO_NOWAIT (ฟังก์ชันส่งคืนการควบคุมทันทีหลังจากสร้างคำขอทั้งหมด)
• struct aiocb *list - รายการพอยน์เตอร์ไปยังโครงสร้าง aiocb พร้อมคำอธิบายคำขอ

  คำร้องขอสามารถอ่านหรือเขียนได้ ซึ่งจะถูกกำหนดโดยฟิลด์ aio_lio_opcode การร้องขอไปยัง descriptor ตัวเดียวจะถูกดำเนินการตามลำดับที่ระบุไว้ในอาร์เรย์รายการ

• int net - จำนวนรายการในอาร์เรย์รายการ
• struct sigevent *sig - วิธีแจ้งว่าคำขอทั้งหมดเสร็จสมบูรณ์แล้ว หาก mode==LIO_WAIT พารามิเตอร์นี้จะถูกละเว้น

ไลบรารี POSIX AIO มีสองวิธีในการแจ้งโปรแกรมว่าคำขอเสร็จสมบูรณ์ แบบซิงโครนัสและแบบอะซิงโครนัส ลองดูวิธีการซิงโครนัสก่อน ฟังก์ชัน aio_return(3AIO) ส่งคืนสถานะคำขอ หากคำขอเสร็จสมบูรณ์และดำเนินการเรียบร้อยแล้ว จะส่งคืนขนาดของข้อมูลที่อ่านหรือเขียนเป็นไบต์ เช่นเดียวกับการอ่านแบบดั้งเดิม (2) aio_return(3AIO) จะส่งคืน 0 ไบต์ในกรณีที่สิ้นสุดไฟล์ หากคำขอล้มเหลวหรือยังไม่เสร็จสิ้น ระบบจะส่งคืน -1 และตั้งค่า errno หากคำขอยังไม่เสร็จสิ้น รหัสข้อผิดพลาดคือ EINPROGRESS

ฟังก์ชัน aio_return(3AIO) เป็นอันตราย หากเรียกใช้คำขอที่เสร็จสมบูรณ์ มันจะทำลายออบเจ็กต์ระบบที่เก็บข้อมูลเกี่ยวกับสถานะของคำขอ การโทร aio_return(3AIO) หลายครั้งในคำขอเดียวกันจึงไม่สามารถทำได้

ฟังก์ชัน aio_error(3AIO) ส่งคืนรหัสข้อผิดพลาดที่เกี่ยวข้องกับคำขอ หากคำขอเสร็จสมบูรณ์ 0 จะถูกส่งกลับ หากเกิดข้อผิดพลาด - รหัสข้อผิดพลาดสำหรับคำขอที่ไม่สมบูรณ์ - EINPROGRESS

ฟังก์ชัน aio_suspend(3AIO) จะบล็อกเธรดจนกว่าหนึ่งในคำขอ I/O แบบอะซิงโครนัสที่ระบุจะเสร็จสมบูรณ์หรือตามระยะเวลาที่ระบุ ฟังก์ชันนี้มีพารามิเตอร์สามตัว:

• const struct aiocb *รายการ const- อาร์เรย์ของพอยน์เตอร์เพื่อสอบถามคำอธิบาย
• int net - จำนวนองค์ประกอบในอาร์เรย์รายการ
• const struct timespec *หมดเวลา- หมดเวลาแม่นยำถึงระดับนาโนวินาที (อันที่จริงแม่นยำในความละเอียด ตัวจับเวลาของระบบ).

ฟังก์ชันจะส่งคืนค่า 0 หากการดำเนินการอย่างน้อยหนึ่งรายการในรายการเสร็จสมบูรณ์ หากฟังก์ชันล้มเหลว จะส่งกลับ -1 และตั้งค่า errno หากฟังก์ชันหมดเวลา ก็จะส่งคืน -1 และ errno==EINPROGRESS ด้วย

ตัวอย่างของการใช้ I/O แบบอะซิงโครนัสกับการตรวจสอบสถานะคำขอแบบซิงโครนัสมีให้ไว้ในตัวอย่างที่ 8.3

ถ่าน req = "GET / HTTP/1.0\r\n\r\n"; int main() ( int s; static struct aiocb readrq; static const struct aiocb *readrqv=(&readrq, NULL); /* เปิดซ็อกเก็ต […] */ memset (&readrq, 0, ขนาดของ readrq); readrq.aio_fildes=s ; readrq.aio_buf=buf; readrq.aio_nbytes=sizeof buf; if (aio_read(&readrq)) ( /* ... */ ) เขียน (s, req, (ขนาดของ req)-1); while(1) ( aio_suspend (readrqv , 1, NULL); size=aio_return(&readrq); if (ขนาด>0) ( เขียน(1, buf, ขนาด); aio_read(&readrq); ) else if (size==0) ( break; ) else if ( errno!=EINPROGRESS) ( perror("อ่านจากซ็อกเก็ต"); ) ) ) 8.3. I/O แบบอะซิงโครนัสพร้อมการตรวจสอบสถานะคำขอแบบซิงโครนัส รหัสสั้นลง การเปิดซ็อกเก็ตและการจัดการข้อผิดพลาดไม่ได้รับการยกเว้น

การแจ้งเตือนแบบอะซิงโครนัสของแอปพลิเคชันเกี่ยวกับความสมบูรณ์ของการดำเนินการประกอบด้วย การสร้างสัญญาณเมื่อการดำเนินการเสร็จสิ้น เมื่อต้องการทำเช่นนี้ คุณต้องทำการตั้งค่าที่เหมาะสมในฟิลด์ aio_sigevent ของตัวอธิบายคำขอ ฟิลด์ aio_sigevent เป็นประเภท struct sigevent โครงสร้างนี้ถูกกำหนดไว้ใน และประกอบด้วยฟิลด์ต่อไปนี้:

• int sigev_notify - โหมดการแจ้งเตือน ค่าที่ถูกต้องคือ SIGEV_NONE (อย่าส่งการตอบรับ), SIGEV_SIGNAL (สร้างสัญญาณเมื่อคำขอเสร็จสมบูรณ์) และ SIGEV_THREAD (เรียกใช้ฟังก์ชันที่ระบุในเธรดแยกต่างหากเมื่อคำขอเสร็จสมบูรณ์) Solaris 10 ยังรองรับประเภทการแจ้งเตือน SIGEV_PORT ซึ่งจะกล่าวถึงในภาคผนวกของบทนี้
• int sigev_signo - จำนวนสัญญาณที่จะถูกสร้างขึ้นเมื่อใช้ SIGEV_SIGNAL
• union sigval sigev_value - พารามิเตอร์ที่จะถูกส่งไปยังตัวจัดการสัญญาณหรือฟังก์ชันการประมวลผล เมื่อใช้สำหรับ I/O แบบอะซิงโครนัส โดยปกติจะเป็นตัวชี้ไปยังคำขอ

  เมื่อใช้ SIGEV_PORT นี่ควรเป็นโครงสร้างตัวชี้ port_event_t ที่มีหมายเลขพอร์ตและอาจเป็นข้อมูลเพิ่มเติม

• เป็นโมฆะ (*sigev_notify_function)(สหภาพ sigval)เป็นฟังก์ชันที่จะถูกเรียกใช้เมื่อใช้ SIGEV_THREAD
• pthread_attr_t *sigev_notify_attributes- คุณสมบัติของเธรดที่จะเปิดตัว
• sigev_notify_function เมื่อใช้ SIGEV_THREAD

การใช้งาน libaio ไม่ใช่ทั้งหมดที่รองรับการแจ้งเตือน SIGEV_THREAD ระบบ Unix บางระบบใช้การแจ้งเตือน SIGEV_CALLBACK ที่ไม่เป็นไปตามมาตรฐานแทน ต่อไปในการบรรยายนี้ เราจะพูดถึงเฉพาะการแจ้งเตือนสัญญาณเท่านั้น

แอปพลิเคชันบางตัวใช้ SIGIO หรือ SIGPOLL เป็นหมายเลขสัญญาณ (ใน Unix SVR4 ซึ่งเป็นสัญญาณเดียวกัน) SIGUSR1 หรือ SIGUSR2 ก็มักใช้เช่นกัน สะดวกเพราะช่วยให้แน่ใจว่าสัญญาณที่คล้ายกันจะไม่เกิดขึ้นด้วยเหตุผลอื่น

แอปพลิเคชันแบบเรียลไทม์ยังใช้หมายเลขสัญญาณตั้งแต่ SIGRTMIN ถึง SIGRTMAX การใช้งานบางอย่างจัดสรรหมายเลขสัญญาณพิเศษ SIGAIO หรือ SIGASYNCIO เพื่อจุดประสงค์นี้ แต่ไม่มีสัญญาณดังกล่าวใน Solaris 10

แน่นอน ก่อนที่จะดำเนินการคำขอแบบอะซิงโครนัสที่ได้รับแจ้งจากสัญญาณ คุณควรติดตั้งตัวจัดการสำหรับสัญญาณนี้ สำหรับการแจ้งเตือน คุณต้องใช้สัญญาณที่ประมวลผลในโหมด SA_SIGINFO ไม่สามารถติดตั้งตัวจัดการดังกล่าวโดยใช้การเรียกระบบ signal(2) และ sigset(2) คุณต้องใช้ sigaction(2) การติดตั้งตัวจัดการโดยใช้ sigaction

การควบคุมอินพุต/โอ

เน้นบล็อกอุปกรณ์และ เน้นไบต์

แนวคิดหลัก

สำคัญหลักการก็คือ ความเป็นอิสระของอุปกรณ์

·การจัดการขัดจังหวะ

· ไดรเวอร์อุปกรณ์,

ดูเหมือนชัดเจนว่าการหยุดชะงักเกิดขึ้นได้หลากหลายด้วยเหตุผลหลายประการ ดังนั้นตัวเลขจึงสัมพันธ์กับการหยุดชะงัก - สิ่งที่เรียกว่าหมายเลขการขัดจังหวะ

หมายเลขนี้สอดคล้องกับเหตุการณ์ใดเหตุการณ์หนึ่งโดยเฉพาะ ระบบสามารถรับรู้การขัดจังหวะ และเมื่อเกิดขึ้น ระบบจะเรียกใช้ขั้นตอนที่สอดคล้องกับหมายเลขการขัดจังหวะ

การขัดจังหวะบางอย่าง (ห้ารายการแรกตามลำดับตัวเลข) สงวนไว้สำหรับการใช้งาน โปรเซสเซอร์กลางในกรณีของเหตุการณ์พิเศษใดๆ เช่น ความพยายามที่จะหารด้วยศูนย์, โอเวอร์โฟลว์ ฯลฯ (นี่คือการขัดจังหวะภายในที่แท้จริง J)

การขัดจังหวะด้วยฮาร์ดแวร์จะเกิดขึ้นแบบอะซิงโครนัสเสมอโดยคำนึงถึงโปรแกรมที่รันอยู่ นอกจากนี้ อาจมีการหยุดชะงักหลายครั้งพร้อมกันได้!

เพื่อให้แน่ใจว่าระบบจะไม่สับสนเมื่อตัดสินใจว่าจะขัดจังหวะการบริการใดก่อน จึงมีแผนลำดับความสำคัญพิเศษ การขัดจังหวะแต่ละครั้งจะได้รับการกำหนดลำดับความสำคัญของตัวเอง หากมีการขัดจังหวะหลายครั้งเกิดขึ้นพร้อมกัน ระบบจะจัดลำดับความสำคัญให้กับการขัดจังหวะที่มีลำดับความสำคัญสูงสุด โดยเลื่อนการประมวลผลการขัดจังหวะที่เหลือไประยะหนึ่ง

ระบบจัดลำดับความสำคัญถูกนำไปใช้กับชิป Intel 8259 (หรือที่คล้ายกัน) สองตัว ชิปแต่ละตัวเป็นตัวควบคุมการขัดจังหวะและทำหน้าที่ลำดับความสำคัญสูงสุดแปดประการ สามารถรวมชิป (เรียงซ้อน) เพื่อเพิ่มจำนวนระดับความสำคัญในระบบ

ลำดับความสำคัญจะมีตัวย่อ IRQ0 - IRQ15

24. การควบคุมอินพุต/โอ I/O แบบซิงโครนัสและอะซิงโครนัส

หน้าที่หลักประการหนึ่งของระบบปฏิบัติการคือการจัดการอุปกรณ์อินพุต/เอาท์พุตของคอมพิวเตอร์ทั้งหมด ระบบปฏิบัติการจะต้องส่งคำสั่งไปยังอุปกรณ์ สกัดกั้นการขัดจังหวะ และจัดการกับข้อผิดพลาด แต่ยังต้องมีอินเทอร์เฟซระหว่างอุปกรณ์กับส่วนที่เหลือของระบบด้วย เพื่อวัตถุประสงค์ในการพัฒนา อินเทอร์เฟซควรเหมือนกันสำหรับอุปกรณ์ทุกประเภท (ความเป็นอิสระของอุปกรณ์) ข้อมูลเพิ่มเติมเกี่ยวกับการควบคุม IV คำถามที่ 23

หลักการป้องกัน

เนื่องจาก UNIX OS ตั้งแต่เริ่มแรกถูกมองว่าเป็นระบบปฏิบัติการที่มีผู้ใช้หลายคน ปัญหาในการอนุญาตการเข้าถึงไฟล์ในระบบไฟล์ของผู้ใช้ที่แตกต่างกันจึงมีความเกี่ยวข้องอยู่เสมอ โดยการอนุญาตการเข้าถึง เราหมายถึงการกระทำของระบบที่อนุญาตหรือปฏิเสธการเข้าถึง ผู้ใช้ที่กำหนดถึง ไฟล์นี้ขึ้นอยู่กับสิทธิ์การเข้าถึงของผู้ใช้และข้อจำกัดการเข้าถึงที่กำหนดไว้สำหรับไฟล์ รูปแบบการอนุญาตการเข้าถึงที่ใช้ใน UNIX OS นั้นง่ายและสะดวกมาก และในขณะเดียวกันก็ทรงพลังมากจนกลายเป็นมาตรฐานของระบบปฏิบัติการสมัยใหม่โดยพฤตินัย (ซึ่งไม่ได้เสแสร้งว่าเป็นระบบที่มีการรักษาความปลอดภัยหลายระดับ)

การป้องกันไฟล์

ตามธรรมเนียมในระบบปฏิบัติการที่มีผู้ใช้หลายราย UNIX จะรักษากลไกการควบคุมการเข้าถึงที่เหมือนกันสำหรับไฟล์และไดเร็กทอรีระบบไฟล์ กระบวนการใดๆ สามารถเข้าถึงไฟล์ได้ก็ต่อเมื่อสิทธิ์การเข้าถึงที่ระบุสำหรับไฟล์นั้นตรงกับความสามารถของกระบวนการเท่านั้น

การปกป้องไฟล์จากการเข้าถึงโดยไม่ได้รับอนุญาตใน UNIX ขึ้นอยู่กับข้อเท็จจริงสามประการ ประการแรก กระบวนการใด ๆ ที่สร้างไฟล์ (หรือไดเร็กทอรี) จะเชื่อมโยงกับตัวระบุผู้ใช้บางตัวที่ไม่ซ้ำใครในระบบ (UID - ตัวระบุผู้ใช้) ซึ่งสามารถตีความเพิ่มเติมได้ว่าเป็นตัวระบุของเจ้าของไฟล์ที่สร้างขึ้นใหม่ ประการที่สอง แต่ละกระบวนการที่พยายามเข้าถึงไฟล์จะมีตัวระบุคู่หนึ่งที่เกี่ยวข้องกัน - ตัวระบุผู้ใช้และกลุ่มปัจจุบัน ประการที่สาม แต่ละไฟล์จะเชื่อมโยงเฉพาะกับ descriptor - i-node

ข้อเท็จจริงสุดท้ายควรค่าแก่การดูรายละเอียดเพิ่มเติม สิ่งสำคัญคือต้องเข้าใจว่าชื่อไฟล์และไฟล์นั้นไม่เหมือนกัน โดยเฉพาะอย่างยิ่ง เมื่อมีหลายฮาร์ดลิงก์ไปยังไฟล์เดียวกัน ชื่อไฟล์หลายชื่อจะแสดงถึงไฟล์เดียวกันจริง ๆ และเชื่อมโยงกับ i-node เดียวกัน i-node ใดๆ ที่ใช้ในระบบไฟล์จะสอดคล้องกับไฟล์เดียวเท่านั้นเสมอ I-node มีข้อมูลที่แตกต่างกันมากมาย (ส่วนใหญ่พร้อมใช้งานสำหรับผู้ใช้ผ่านการเรียกระบบ stat และ fstat) และในบรรดาข้อมูลนี้มีส่วนที่อนุญาตให้ระบบไฟล์ประเมินสิทธิ์ของกระบวนการที่กำหนดในการเข้าถึง ไฟล์ที่กำหนดในโหมดที่ต้องการ

หลักการทั่วไปการป้องกันจะเหมือนกันสำหรับเวอร์ชันที่มีอยู่ทั้งหมดของระบบ: ข้อมูล i-node รวมถึง UID และ GID ของเจ้าของไฟล์ปัจจุบัน (ทันทีหลังจากสร้างไฟล์ ตัวระบุของเจ้าของปัจจุบันจะถูกตั้งค่าเป็นตัวระบุที่ถูกต้องที่สอดคล้องกัน ของกระบวนการสร้าง แต่สามารถเปลี่ยนแปลงได้ในภายหลังโดยการเรียกระบบ chown และ chgrp) นอกจากนี้ i-node ของไฟล์จะจัดเก็บสเกลที่ระบุว่าผู้ใช้ - เจ้าของ - สามารถทำอะไรกับไฟล์ได้ สิ่งที่ผู้ใช้ที่อยู่ในกลุ่มผู้ใช้เดียวกันกับเจ้าของสามารถทำอะไรกับไฟล์ได้ และสิ่งที่ผู้อื่นสามารถทำได้ ด้วยไฟล์. users. รายละเอียดการใช้งานขนาดเล็กใน ตัวเลือกที่แตกต่างกันระบบแตกต่างกันไป

28. การจัดการการเข้าถึงไฟล์ใน Windows NT รายการสิทธิ์การเข้าถึง

ระบบควบคุมการเข้าใช้งานใน Windows NT มีลักษณะพิเศษคือมีความยืดหยุ่นในระดับสูง ซึ่งทำได้เนื่องจากหัวข้อและอ็อบเจ็กต์ในการเข้าถึงที่หลากหลาย รวมถึงการดำเนินการในการเข้าถึงอย่างละเอียด

การควบคุมการเข้าถึงไฟล์

สำหรับทรัพยากรที่ใช้ร่วมกันใน Windows NT จะใช้โมเดลวัตถุทั่วไปซึ่งมีลักษณะความปลอดภัยเช่นชุดของการดำเนินการที่อนุญาต ตัวระบุเจ้าของ และรายการควบคุมการเข้าถึง

ออบเจ็กต์ใน Windows NT ถูกสร้างขึ้นสำหรับทรัพยากรใด ๆ เมื่อมีการแชร์หรือแชร์ - ไฟล์ ไดเร็กทอรี อุปกรณ์ ส่วนหน่วยความจำ กระบวนการ ลักษณะของวัตถุใน Windows NT แบ่งออกเป็นสองส่วน - ส่วนทั่วไป องค์ประกอบที่ไม่ขึ้นอยู่กับประเภทของวัตถุ และแต่ละส่วนที่กำหนดโดยประเภทของวัตถุ
วัตถุทั้งหมดจะถูกเก็บไว้ในโครงสร้างต้นไม้ โครงสร้างลำดับชั้นองค์ประกอบที่เป็นวัตถุสาขา (ไดเรกทอรี) และวัตถุใบไม้ (ไฟล์) สำหรับอ็อบเจ็กต์ระบบไฟล์ รูปแบบความสัมพันธ์นี้เป็นการสะท้อนโดยตรงของลำดับชั้นของไดเร็กทอรีและไฟล์ สำหรับออบเจ็กต์ประเภทอื่น แผนภาพความสัมพันธ์แบบลำดับชั้นจะมีเนื้อหาของตัวเอง ตัวอย่างเช่น สำหรับกระบวนการจะสะท้อนถึงความสัมพันธ์ระหว่างพ่อแม่และลูก และสำหรับอุปกรณ์จะสะท้อนถึงความเป็นสมาชิกในอุปกรณ์บางประเภทและการเชื่อมต่อของอุปกรณ์กับอุปกรณ์อื่น สำหรับ เช่น คอนโทรลเลอร์ SCSI พร้อมดิสก์

การตรวจสอบสิทธิ์การเข้าถึงสำหรับออบเจ็กต์ประเภทใดๆ จะดำเนินการจากส่วนกลางโดยใช้ Security Reference Monitor ที่ทำงานในโหมดสิทธิพิเศษ

สำหรับระบบ ความปลอดภัยของวินโดวส์ NT โดดเด่นด้วยการมีอยู่ของหัวข้อการเข้าถึงที่กำหนดไว้ล่วงหน้า (ในตัว) ที่แตกต่างกันจำนวนมาก - ทั้งผู้ใช้รายบุคคลและกลุ่ม ดังนั้น ระบบมักจะมีผู้ใช้เช่น Adininistrator, System และ Guest รวมถึงกลุ่มผู้ใช้, Adiniiiistrator, ผู้ดำเนินการบัญชี, ผู้ดำเนินการเซิร์ฟเวอร์, ทุกคน และอื่นๆ ประเด็นของผู้ใช้และกลุ่มในตัวเหล่านี้คือพวกเขามีสิทธิ์บางประการ ทำให้ผู้ดูแลระบบสามารถสร้างระบบควบคุมการเข้าถึงที่มีประสิทธิภาพได้ง่ายขึ้น เมื่อเพิ่มผู้ใช้ใหม่ ผู้ดูแลระบบสามารถเลือกได้เฉพาะกลุ่มหรือกลุ่มที่จะมอบหมายผู้ใช้นี้ให้ แน่นอนว่าผู้ดูแลระบบสามารถสร้างกลุ่มใหม่รวมทั้งเพิ่มสิทธิ์ให้กับกลุ่มในตัวเพื่อใช้นโยบายความปลอดภัยของตนเองได้ แต่ในหลายกรณี กลุ่มในตัวก็เพียงพอแล้ว

Windows NT สนับสนุนการดำเนินการเข้าถึงสามคลาส ซึ่งแตกต่างกันในประเภทของหัวเรื่องและวัตถุที่เกี่ยวข้องกับการดำเนินการเหล่านี้

□ สิทธิ์คือชุดของการดำเนินการที่สามารถกำหนดได้สำหรับหัวข้อทุกประเภทที่เกี่ยวข้องกับวัตถุประเภทใดๆ: ไฟล์ ไดเร็กทอรี เครื่องพิมพ์ ส่วนหน่วยความจำ ฯลฯ สิทธิ์ในวัตถุประสงค์สอดคล้องกับสิทธิ์ในการเข้าถึงไฟล์และไดเร็กทอรีใน QC UNIX .

□ สิทธิ์ (สิทธิ์ผู้ใช้) - ถูกกำหนดไว้สำหรับหัวข้อประเภทกลุ่มเพื่อดำเนินการบางอย่างของระบบ: การตั้งเวลาของระบบ การเก็บถาวรไฟล์ การปิดคอมพิวเตอร์ ฯลฯ การดำเนินการเหล่านี้เกี่ยวข้องกับวัตถุการเข้าถึงพิเศษ - ระบบปฏิบัติการโดยรวม .

สิทธิหลักๆ ไม่ใช่การอนุญาต ที่ทำให้กลุ่มผู้ใช้ภายในกลุ่มหนึ่งแตกต่างจากกลุ่มอื่น สิทธิ์บางอย่างสำหรับกลุ่มที่มีอยู่แล้วภายในก็มีอยู่แล้วภายใน - ไม่สามารถลบออกจากกลุ่มนี้ได้ สิทธิ์อื่นๆ ของกลุ่มบิวท์อินสามารถลบได้ (หรือเพิ่มจากรายการสิทธิ์ทั่วไป)

□ ความสามารถของผู้ใช้ถูกกำหนดให้ผู้ใช้แต่ละรายดำเนินการที่เกี่ยวข้องกับการก่อตัวของสภาพแวดล้อมการทำงาน เช่น การเปลี่ยนองค์ประกอบของเมนูโปรแกรมหลัก ความสามารถในการใช้รายการเมนู Run เป็นต้น โดยการลดชุดความสามารถ ( ซึ่งผู้ใช้สามารถใช้งานได้ตามค่าเริ่มต้น) ผู้ดูแลระบบสามารถบังคับให้ผู้ใช้ทำงานกับสภาพแวดล้อมการทำงานที่ผู้ดูแลระบบเห็นว่าเหมาะสมที่สุดและปกป้องผู้ใช้จากข้อผิดพลาดที่อาจเกิดขึ้น

สิทธิ์และการอนุญาตที่มอบให้กับกลุ่มนั้นมอบให้กับสมาชิกโดยอัตโนมัติ ช่วยให้ผู้ดูแลระบบสามารถปฏิบัติต่อผู้ใช้จำนวนมากเสมือนเป็นหน่วยข้อมูลทางบัญชีและลดการดำเนินการของพวกเขา

เมื่อผู้ใช้เข้าสู่ระบบ โทเค็นการเข้าถึงที่เรียกว่าจะถูกสร้างขึ้นสำหรับเขา ซึ่งรวมถึง ID ผู้ใช้และ ID ของกลุ่มทั้งหมดที่ผู้ใช้อยู่ โทเค็นยังประกอบด้วย: รายการควบคุมการเข้าถึงเริ่มต้น (ACL) ซึ่งประกอบด้วยสิทธิ์และใช้กับอ็อบเจ็กต์ที่สร้างโดยกระบวนการ รายการสิทธิ์ผู้ใช้ในการดำเนินการของระบบ

ออบเจ็กต์ทั้งหมด รวมถึงไฟล์ เธรด เหตุการณ์ แม้แต่โทเค็นการเข้าถึง จะได้รับคำอธิบายด้านความปลอดภัยเมื่อสร้างขึ้น ตัวบอกเกี่ยวกับความปลอดภัยประกอบด้วยรายการควบคุมการเข้าถึง - ACL

ตัวอธิบายไฟล์- จำนวนเต็มที่ไม่ใช่ลบที่กำหนดโดยระบบปฏิบัติการให้กับไฟล์ที่เปิดโดยกระบวนการ

เอซีแอล(ภาษาอังกฤษ) รายการควบคุมการเข้าถึง- รายการควบคุมการเข้าถึง ออกเสียงว่า "ekl" ในภาษาอังกฤษ) - กำหนดว่าใครหรือสิ่งใดที่สามารถเข้าถึงวัตถุเฉพาะได้ และการดำเนินการใดที่หัวข้อนี้ได้รับอนุญาตหรือห้ามไม่ให้ดำเนินการกับวัตถุนั้น

รายการควบคุมการเข้าถึงเป็นพื้นฐานของระบบควบคุมการเข้าออกแบบเลือก ( วิกิ)

เจ้าของออบเจ็กต์ ซึ่งโดยทั่วไปคือผู้ใช้ที่สร้างออบเจ็กต์นั้น มีสิทธิ์ควบคุมการเข้าถึงออบเจ็กต์แบบเลือกได้ และสามารถเปลี่ยน ACL ของออบเจ็กต์เพื่ออนุญาตหรือป้องกันไม่ให้ผู้อื่นเข้าถึงออบเจ็กต์ได้ บิวท์อิน ผู้ดูแลระบบวินโดวส์ NT อาจไม่เหมือนกับผู้ใช้ระดับสูงของ UNIX ตรงที่อาจไม่มีสิทธิ์ในการเข้าถึงวัตถุ หากต้องการใช้คุณลักษณะนี้ สามารถรวม ID ของผู้ดูแลระบบและกลุ่มผู้ดูแลระบบไว้ใน ACL ได้ เช่นเดียวกับ ID ผู้ใช้ทั่วไป อย่างไรก็ตาม ผู้ดูแลระบบยังคงมีความสามารถในการดำเนินการใดๆ กับออบเจ็กต์ใดๆ เนื่องจากเขาสามารถเป็นเจ้าของออบเจ็กต์ได้ตลอดเวลา จากนั้นในฐานะเจ้าของ จะได้รับสิทธิ์เต็มรูปแบบ อย่างไรก็ตาม ผู้ดูแลระบบไม่สามารถคืนความเป็นเจ้าของให้กับเจ้าของออบเจ็กต์คนก่อนได้ ดังนั้นผู้ใช้สามารถทราบได้ตลอดเวลาว่าผู้ดูแลระบบได้ทำงานกับไฟล์หรือเครื่องพิมพ์ของเขา

เมื่อกระบวนการร้องขอการดำเนินการเพื่อเข้าถึงวัตถุใน Windows NT การควบคุมจะส่งผ่านไปยังการตรวจสอบความปลอดภัยเสมอ ซึ่งจะเปรียบเทียบตัวระบุผู้ใช้และกลุ่มผู้ใช้จากโทเค็นการเข้าถึงกับตัวระบุที่จัดเก็บไว้ในองค์ประกอบ ACL ของวัตถุ ต่างจาก UNIX องค์ประกอบ Windows NT ACL สามารถมีทั้งรายการอนุญาตและรายการการดำเนินการที่ห้ามสำหรับผู้ใช้

Windows NT กำหนดกฎที่กำหนด ACL ให้กับวัตถุที่สร้างขึ้นใหม่อย่างชัดเจน หากรหัสการเรียกเมื่อสร้างอ็อบเจ็กต์ ระบุสิทธิ์การเข้าถึงทั้งหมดไปยังอ็อบเจ็กต์ที่สร้างขึ้นใหม่อย่างชัดเจน ระบบรักษาความปลอดภัยจะกำหนด ACL นี้ให้กับอ็อบเจ็กต์

หากรหัสการเรียกไม่ได้ระบุ ACL ให้กับอ็อบเจ็กต์ และอ็อบเจ็กต์มีชื่อ หลักการของการสืบทอดสิทธิ์ก็จะนำไปใช้ ระบบรักษาความปลอดภัยจะดู ACL ของไดเร็กทอรีอ็อบเจ็กต์ซึ่งชื่อของอ็อบเจ็กต์ใหม่ถูกเก็บไว้ รายการ ACL ไดเร็กทอรีอ็อบเจ็กต์บางรายการสามารถทำเครื่องหมายว่าสามารถสืบทอดได้ ซึ่งหมายความว่าสามารถกำหนดให้กับออบเจ็กต์ใหม่ที่สร้างขึ้นในไดเร็กทอรีนี้ได้

ในกรณีที่กระบวนการไม่ได้ระบุ ACL อย่างชัดเจนสำหรับออบเจ็กต์ที่กำลังสร้าง และออบเจ็กต์ไดเร็กทอรีไม่มีรายการ ACL ที่สืบทอดได้ ระบบจะใช้ ACL เริ่มต้นจากโทเค็นการเข้าถึงของกระบวนการ

29. ภาษาโปรแกรมจาวา เครื่องเสมือนจาวา เทคโนโลยีจาวา

ชวาเป็นภาษาโปรแกรมเชิงวัตถุที่พัฒนาโดย Sun Microsystems โดยทั่วไปแอปพลิเคชัน Java จะถูกคอมไพล์เป็นโค้ดไบต์แบบกำหนดเอง เพื่อให้สามารถทำงานบน Java virtual machine (JVM) ใดก็ได้ โดยไม่คำนึงถึงสถาปัตยกรรมคอมพิวเตอร์ โปรแกรม Java ได้รับการแปลเป็น bytecode ที่ถูกเรียกใช้งาน เครื่องเสมือนชวา ( เจวีเอ็ม) - โปรแกรมที่ประมวลผลรหัสไบต์และส่งคำสั่งไปยังอุปกรณ์ในฐานะล่าม แต่ด้วยความแตกต่างที่รหัสไบต์ซึ่งต่างจากข้อความจะถูกประมวลผลเร็วกว่ามาก

ข้อดีของวิธีการรันโปรแกรมนี้คือความเป็นอิสระที่สมบูรณ์ของโค้ดไบต์ ระบบปฏิบัติการและฮาร์ดแวร์ ช่วยให้คุณสามารถเรียกใช้แอปพลิเคชัน Java บนอุปกรณ์ใดๆ ที่มีเครื่องเสมือนที่เกี่ยวข้องได้ คุณสมบัติที่สำคัญอีกประการหนึ่งของเทคโนโลยี Java คือระบบรักษาความปลอดภัยที่ยืดหยุ่นเนื่องจากข้อเท็จจริงดังกล่าว การทำงานของโปรแกรมถูกควบคุมโดยเครื่องเสมือนอย่างสมบูรณ์. การดำเนินการใดๆ ที่เกินสิทธิ์ที่กำหนดไว้ของโปรแกรม (เช่น ความพยายามในการเข้าถึงข้อมูลโดยไม่ได้รับอนุญาต หรือเชื่อมต่อกับคอมพิวเตอร์เครื่องอื่น) ทำให้เกิดการหยุดชะงักในทันที

บ่อยครั้ง ข้อเสียของแนวคิดเครื่องเสมือนรวมถึงความจริงที่ว่าการดำเนินการของ bytecode โดยเครื่องเสมือนสามารถลดประสิทธิภาพของโปรแกรมและอัลกอริธึมที่ใช้งานในภาษา Java

เครื่องเสมือนจาวา(เรียกย่อว่า Java VM, เจวีเอ็ม) - Java virtual machine เป็นส่วนหลักของระบบ Java runtime หรือที่เรียกว่า Java Runtime Environment (JRE) Java Virtual Machine ตีความและรันโค้ดไบต์ Java ที่สร้างไว้ล่วงหน้าจากซอร์สโค้ดของโปรแกรม Java โดยคอมไพเลอร์ Java (javac) JVM ยังสามารถใช้เพื่อรันโปรแกรมที่เขียนในภาษาการเขียนโปรแกรมอื่นได้ ตัวอย่างเช่น ซอร์สโค้ด Ada สามารถคอมไพล์เป็น Java bytecode ซึ่ง JVM จะสามารถดำเนินการได้

JVM เป็นองค์ประกอบสำคัญของแพลตฟอร์ม Java เนื่องจากเครื่องเสมือน Java พร้อมใช้งานสำหรับฮาร์ดแวร์จำนวนมากและ แพลตฟอร์มซอฟต์แวร์, Java ถือได้ว่าเป็นทั้งมิดเดิลแวร์และเป็นแพลตฟอร์มในตัวของมันเอง ดังนั้นหลักการ “เขียนครั้งเดียวทำงานได้ทุกที่” การใช้โค้ดไบต์เดียวในหลายแพลตฟอร์มทำให้ Java สามารถอธิบายได้ว่า “คอมไพล์ครั้งเดียว ทำงานได้ทุกที่”

สภาพแวดล้อมรันไทม์

โปรแกรมที่ตั้งใจจะรันบน JVM จะต้องคอมไพล์ในรูปแบบไบนารีแบบพกพามาตรฐาน ซึ่งโดยปกติจะแสดงเป็นไฟล์ .class โปรแกรมสามารถประกอบด้วยหลายคลาสที่อยู่ในไฟล์ต่างๆ เพื่อให้ง่ายต่อการโฮสต์โปรแกรมขนาดใหญ่ ไฟล์ .class บางไฟล์สามารถรวมเข้าด้วยกันเป็นไฟล์ที่เรียกว่า .jar (ย่อมาจาก Java Archive)

JVM รันไฟล์ .class หรือ .jar โดยจำลองคำสั่งที่เขียนสำหรับ JVM โดยการตีความหรือใช้คอมไพเลอร์ just-in-time (JIT) เช่น HotSpot จากระบบไมโคร Sun ทุกวันนี้ การคอมไพล์ JIT ถูกใช้ใน JVM ส่วนใหญ่เพื่อให้ได้ความเร็วที่มากขึ้น

เช่นเดียวกับเครื่องเสมือนส่วนใหญ่ Java Virtual Machine มีสถาปัตยกรรมแบบสแต็กที่คล้ายคลึงกับไมโครคอนโทรลเลอร์และไมโครโปรเซสเซอร์

JVM ซึ่งเป็นอินสแตนซ์ของ JRE (Java Runtime Environment) จะเข้ามามีบทบาทเมื่อมีการเรียกใช้งานโปรแกรม Java หลังจากดำเนินการเสร็จสิ้น อินสแตนซ์นี้จะถูกลบโดยตัวรวบรวมขยะ JIT เป็นส่วนหนึ่งของ Java Virtual Machine ที่ใช้ในการเร่งเวลาดำเนินการของแอปพลิเคชัน JIT จะรวบรวมส่วนของโค้ดไบต์ที่มีฟังก์ชันการทำงานคล้ายกันไปพร้อมๆ กัน ดังนั้นจึงลดระยะเวลาที่ใช้ในการคอมไพล์ลง

j2se (java 2 Standard Edition) – ไลบรารี่มาตรฐานประกอบด้วย:

GUI, NET, ฐานข้อมูล...

30. แพลตฟอร์ม .NET แนวคิดหลักและบทบัญญัติ ภาษาโปรแกรม .NET

.NET Framework - เทคโนโลยีซอฟต์แวร์จาก Microsoft ออกแบบมาเพื่อสร้างโปรแกรมและเว็บแอปพลิเคชันทั่วไป

แนวคิดหลักประการหนึ่งของ Microsoft .NET คือความสามารถในการทำงานร่วมกันของบริการต่างๆ ที่เขียนในภาษาต่างๆ ตัวอย่างเช่น บริการที่เขียนด้วยภาษา C++ สำหรับ Microsoft .NET อาจเรียกวิธีการเรียนจากไลบรารีที่เขียนด้วย Delphi ใน C# คุณสามารถเขียนคลาสที่สืบทอดมาจากคลาสที่เขียนได้ วิชวลเบสิก.NET และข้อยกเว้นที่เกิดจากวิธีที่เขียนด้วย C# สามารถตรวจจับและจัดการได้ใน Delphi แต่ละไลบรารี (แอสเซมบลี) ใน .NET มีข้อมูลเกี่ยวกับเวอร์ชัน ซึ่งช่วยให้คุณกำจัดข้อขัดแย้งที่อาจเกิดขึ้นระหว่างกันได้ รุ่นที่แตกต่างกันแอสเซมบลี

แอปพลิเคชันสามารถพัฒนาได้ในโปรแกรมแก้ไขข้อความและใช้คอนโซลคอมไพเลอร์

เช่นเดียวกับเทคโนโลยี Java สภาพแวดล้อมการพัฒนา .NET จะสร้างโค้ดไบต์สำหรับการดำเนินการโดยเครื่องเสมือน ภาษาอินพุตของเครื่องนี้ใน .NET เรียกว่า MSIL (Microsoft Intermediate Language) หรือ CIL (Common Intermediate Language เวอร์ชันใหม่กว่า) หรือเรียกง่ายๆ ว่า IL

การใช้ bytecode ช่วยให้คุณบรรลุฟังก์ชันการทำงานข้ามแพลตฟอร์มในระดับโปรเจ็กต์ที่คอมไพล์แล้ว (ในแง่ .NET: การประกอบ) และไม่เพียงแต่ในระดับข้อความต้นฉบับ เช่น ใน C ก่อนที่จะเริ่มแอสเซมบลีในรันไทม์ CLR รหัสไบต์จะถูกแปลงโดยคอมไพเลอร์ JIT ที่สร้างในสภาพแวดล้อม (ทันเวลา ทันทีทันใด) การคอมไพล์) ลงในรหัสเครื่องของโปรเซสเซอร์เป้าหมาย นอกจากนี้ยังสามารถคอมไพล์แอสเซมบลีเป็นโค้ดเนทิฟสำหรับแพลตฟอร์มที่เลือกได้โดยใช้ยูทิลิตี้ NGen.exe ที่มาพร้อมกับ .NET Framework

ในระหว่างขั้นตอนการแปล ซอร์สโค้ดของโปรแกรม (เขียนด้วย SML, C#, Visual Basic, C++ หรือภาษาการเขียนโปรแกรมอื่น ๆ ที่สนับสนุนโดย .NET) จะถูกแปลงโดยคอมไพเลอร์ให้กลายเป็นแอสเซมบลีที่เรียกว่าแอสเซมบลีและบันทึกเป็นไดนามิก ไฟล์ไลบรารีที่เชื่อมโยง (ลิงก์แบบไดนามิก) ไลบรารี, DLL) หรือ ไฟล์ปฏิบัติการ(ปฏิบัติการได้, EXE)

โดยปกติแล้ว สำหรับคอมไพเลอร์แต่ละตัว (ไม่ว่าจะเป็นคอมไพเลอร์ภาษา C#, csc.exe หรือ Visual Basic, vbc.exe) สภาพแวดล้อมรันไทม์จะดำเนินการแมปที่จำเป็นของประเภทที่ใช้ในประเภท CTS และโค้ดโปรแกรมลงในโค้ดของ " เครื่องนามธรรม” .NET - MSIL (ภาษา Microsoft Intermediate)

ในท้ายที่สุด โครงการซอฟต์แวร์ถูกสร้างขึ้นในรูปแบบของแอสเซมบลี - ส่วนประกอบแบบพอเพียงสำหรับการปรับใช้ การจำลองแบบ และการนำกลับมาใช้ใหม่ มีการระบุการชุมนุม ลายเซ็นดิจิทัลผู้เขียนและหมายเลขเวอร์ชันเฉพาะ

ภาษาการเขียนโปรแกรมในตัว (รวมอยู่ใน .NET Framework):

ค#; เจ#; วีบี.เน็ต; เจสคริปต์ .NET; C++/CLI - เวอร์ชันใหม่ C++ (จัดการ)

31. ส่วนประกอบการทำงานของระบบปฏิบัติการ การจัดการไฟล์

ส่วนประกอบระบบปฏิบัติการที่ใช้งานได้:

โดยทั่วไปฟังก์ชันของระบบปฏิบัติการของคอมพิวเตอร์แบบสแตนด์อโลนจะถูกจัดกลุ่มตามประเภทของทรัพยากรภายในเครื่องที่ระบบปฏิบัติการจัดการหรือตามงานเฉพาะที่ใช้กับทรัพยากรทั้งหมด บางครั้งกลุ่มของฟังก์ชันดังกล่าวเรียกว่าระบบย่อย ระบบย่อยการจัดการทรัพยากรที่สำคัญที่สุดคือกระบวนการ หน่วยความจำ ไฟล์ และระบบย่อยการจัดการอุปกรณ์ภายนอก และระบบย่อยที่ใช้ร่วมกันกับทรัพยากรทั้งหมดคือระบบย่อย หน้าจอผู้ใช้การปกป้องข้อมูลและการบริหารจัดการ

การจัดการไฟล์:

ความสามารถของระบบปฏิบัติการในการ "ป้องกัน" ความซับซ้อนของฮาร์ดแวร์จริงนั้นแสดงให้เห็นอย่างชัดเจนในระบบย่อยระบบปฏิบัติการหลักระบบใดระบบหนึ่ง - ระบบไฟล์

ระบบไฟล์จะเชื่อมโยงสื่อจัดเก็บข้อมูลที่ด้านหนึ่งและ API (Application Programming Interface) สำหรับการเข้าถึงไฟล์ที่อีกด้านหนึ่ง เมื่อแอปพลิเคชันโปรแกรมเข้าถึงไฟล์ จะไม่ทราบว่าข้อมูลในไฟล์นั้นอยู่อย่างไร หรือสื่อทางกายภาพประเภทใด (ซีดี ฮาร์ดดิสก์ เทปแม่เหล็ก หรือหน่วยหน่วยความจำแฟลช) ที่ถูกบันทึกไว้ สิ่งที่โปรแกรมรู้คือชื่อไฟล์ ขนาด และคุณลักษณะ ได้รับข้อมูลนี้จากไดรเวอร์ระบบไฟล์ เป็นระบบไฟล์ที่กำหนดตำแหน่งและวิธีที่ไฟล์จะถูกเขียนบนสื่อทางกายภาพ (เช่น ฮาร์ดไดรฟ์)

จากมุมมองของระบบปฏิบัติการ ดิสก์ทั้งหมดคือชุดของคลัสเตอร์ที่มีขนาดตั้งแต่ 512 ไบต์ขึ้นไป ไดรเวอร์ระบบไฟล์จัดระเบียบคลัสเตอร์เป็นไฟล์และไดเร็กทอรี (ซึ่งจริงๆ แล้วเป็นไฟล์ที่มีรายการไฟล์ในไดเร็กทอรีนั้น) ไดรเวอร์เดียวกันนี้จะติดตามว่าคลัสเตอร์ใดที่ใช้งานอยู่ในปัจจุบัน คลัสเตอร์ใดว่าง และคลัสเตอร์ใดถูกทำเครื่องหมายว่าชำรุด

อย่างไรก็ตาม ระบบไฟล์ไม่จำเป็นต้องเกี่ยวข้องโดยตรงกับสื่อบันทึกข้อมูลจริง มีระบบไฟล์เสมือน เช่นเดียวกับระบบไฟล์เครือข่าย ซึ่งเป็นเพียงวิธีในการเข้าถึงไฟล์ที่อยู่บนคอมพิวเตอร์ระยะไกล

ในกรณีที่ง่ายที่สุด ไฟล์ทั้งหมดบนดิสก์ที่กำหนดจะถูกจัดเก็บไว้ในไดเร็กทอรีเดียว โครงการระดับเดียวนี้ใช้ใน CP/M และ MS-DOS 1.0 เวอร์ชันแรก ระบบไฟล์แบบลำดับชั้นที่มีไดเร็กทอรีแบบซ้อนปรากฏขึ้นครั้งแรกใน Multics จากนั้นใน UNIX

แคตตาล็อกสำหรับ ไดรฟ์ที่แตกต่างกันสามารถสร้างแผนผังแยกกันหลายรายการได้ เช่นใน DOS/Windows หรือรวมเป็นแผนผังเดียวทั่วไปสำหรับดิสก์ทั้งหมด เช่นใน ระบบเหมือน UNIXโอ้.

ในความเป็นจริง ในระบบ DOS/Windows เช่นเดียวกับในระบบที่คล้าย UNIX มีไดเร็กทอรีรากหนึ่งไดเร็กทอรีที่มีไดเร็กทอรีย่อยชื่อ "c:", "d:" ฯลฯ พาร์ติชั่นฮาร์ดดิสก์จะถูกเมาท์ในไดเร็กทอรีเหล่านี้ นั่นคือ c:\ เป็นเพียงลิงก์ไปยังไฟล์:///c:/ อย่างไรก็ตาม ใน Windows นั้นต่างจากระบบไฟล์ที่คล้ายกับ UNIX ตรงที่ห้ามเขียนลงในไดเร็กทอรีราก เช่นเดียวกับการดูเนื้อหาในไดเร็กทอรีนั้น

ใน UNIX จะมีไดเร็กทอรีรากเพียงไดเร็กทอรีเดียว และไฟล์และไดเร็กทอรีอื่นๆ ทั้งหมดจะซ้อนกันอยู่ข้างใต้ ในการเข้าถึงไฟล์และไดเร็กทอรีบนดิสก์ คุณต้องเมาต์ดิสก์โดยใช้คำสั่ง mount ตัวอย่างเช่น หากต้องการเปิดไฟล์ในซีดี คุณต้องบอกระบบปฏิบัติการว่า “นำระบบไฟล์ในซีดีนี้ไปแสดงในไดเร็กทอรี /mnt/cdrom” ไฟล์และไดเร็กทอรีทั้งหมดที่อยู่ในซีดีจะปรากฏในไดเร็กทอรี /mnt/cdrom นี้ ซึ่งเรียกว่าจุดเมานท์ บนระบบที่เหมือน UNIX ส่วนใหญ่ ดิสก์แบบถอดได้(ฟล็อปปี้ดิสก์และซีดี) แฟลชไดรฟ์ และอุปกรณ์จัดเก็บข้อมูลภายนอกอื่น ๆ จะถูกเมาท์ในไดเร็กทอรี /mnt, /mount หรือ /media ระบบปฏิบัติการที่คล้าย Unix และ UNIX ยังอนุญาตให้ติดตั้งดิสก์โดยอัตโนมัติเมื่อระบบปฏิบัติการบู๊ต

โปรดทราบการใช้เครื่องหมายทับในไฟล์ ระบบวินโดวส์, ระบบปฏิบัติการที่คล้าย UNIX และ UNIX (ใน Windows จะใช้เครื่องหมายแบ็กสแลช “\” และในระบบปฏิบัติการที่คล้าย UNIX และ UNIX จะใช้เครื่องหมายทับ “/”)

นอกจากนี้ ควรสังเกตว่าระบบข้างต้นอนุญาตให้คุณเมานต์ไม่เพียงแต่ระบบไฟล์ของอุปกรณ์ฟิสิคัลเท่านั้น แต่ยังรวมถึงไดเร็กทอรีแต่ละรายการด้วย (พารามิเตอร์ --bind) หรือตัวอย่างเช่น ภาพไอเอสโอ(ตัวเลือกวนซ้ำ) ส่วนเสริมเช่น FUSE ยังช่วยให้คุณสามารถเมานต์ได้ เช่น ไดเร็กทอรีทั้งหมดบน FTP และทรัพยากรต่างๆ จำนวนมาก

โครงสร้างที่ซับซ้อนยิ่งขึ้นนั้นถูกใช้ใน NTFS และ HFS ในสิ่งเหล่านี้ ระบบไฟล์แต่ละไฟล์คือชุดของคุณสมบัติ คุณสมบัติไม่เพียงแต่รวมถึงระบบอ่านอย่างเดียวแบบดั้งเดิมเท่านั้น แต่ยังรวมถึงชื่อไฟล์ ขนาด และแม้แต่เนื้อหาด้วย ดังนั้นสำหรับ NTFS และ HFS สิ่งที่จัดเก็บไว้ในไฟล์จึงเป็นเพียงคุณลักษณะอย่างหนึ่งเท่านั้น

ตามตรรกะนี้ ไฟล์เดียวสามารถมีเนื้อหาได้หลายรูปแบบ ดังนั้นจึงสามารถจัดเก็บเอกสารเดียวกันหลายเวอร์ชันไว้ในไฟล์เดียวได้ตลอดจนข้อมูลเพิ่มเติม (ไอคอนไฟล์ โปรแกรมที่เกี่ยวข้องกับไฟล์) องค์กรนี้เป็นเรื่องปกติสำหรับ HFS ​​บน Macintosh

32. ส่วนประกอบการทำงานของระบบปฏิบัติการ การจัดการกระบวนการ

การจัดการกระบวนการ:

ส่วนที่สำคัญที่สุดของระบบปฏิบัติการซึ่งส่งผลโดยตรงต่อการทำงานของคอมพิวเตอร์คือระบบย่อยการควบคุมกระบวนการ กระบวนการ (หรืออีกนัยหนึ่ง งาน) คือสิ่งที่เป็นนามธรรมที่อธิบายโปรแกรมที่กำลังรันอยู่ สำหรับระบบปฏิบัติการ กระบวนการคือหน่วยของงาน ซึ่งเป็นคำขอใช้ทรัพยากรระบบ

ในระบบมัลติทาสกิ้ง (หลายกระบวนการ) กระบวนการสามารถอยู่ในสถานะหลักหนึ่งในสามสถานะ:

RUNNING - สถานะแอ็คทีฟของกระบวนการในระหว่างที่กระบวนการมีทรัพยากรที่จำเป็นทั้งหมดและดำเนินการโดยตรงโดยโปรเซสเซอร์

กำลังรอ - สถานะแฝงของกระบวนการ กระบวนการถูกบล็อก ไม่สามารถดำเนินการได้ด้วยเหตุผลภายในของตัวเอง กำลังรอให้เหตุการณ์บางอย่างเกิดขึ้น เช่น เสร็จสิ้นการดำเนินการ I/O ได้รับข้อความจากที่อื่น กระบวนการหรือการปลดปล่อยทรัพยากรบางอย่างที่ต้องการ

READY ยังเป็นสถานะพาสซีฟของกระบวนการ แต่ในกรณีนี้ กระบวนการถูกบล็อกเนื่องจากสถานการณ์ภายนอก: กระบวนการมีทรัพยากรทั้งหมดที่จำเป็นสำหรับกระบวนการ พร้อมที่จะดำเนินการ แต่โปรเซสเซอร์กำลังยุ่งอยู่กับการดำเนินการกระบวนการอื่น

ในระหว่าง วงจรชีวิตแต่ละกระบวนการจะย้ายจากสถานะหนึ่งไปยังอีกสถานะหนึ่งตามอัลกอริธึมการกำหนดเวลากระบวนการที่ใช้ในระบบปฏิบัติการที่กำหนด

มาตรฐานซีพี/เอ็ม

การสร้างระบบปฏิบัติการสำหรับไมโครคอมพิวเตอร์เริ่มต้นจาก OS SR/M ได้รับการพัฒนาในปี 1974 หลังจากนั้นถูกติดตั้งบนเครื่อง 8 บิตหลายเครื่อง ภายในกรอบของระบบปฏิบัติการนี้ มีการสร้างซอฟต์แวร์จำนวนมาก รวมถึงนักแปลจากภาษา BASIC, Pascal, C, Fortran, Cobol, Lisp, Ada และอื่นๆ อีกมากมายในภาษาข้อความ ช่วยให้คุณเตรียมเอกสารได้เร็วและสะดวกกว่าการใช้เครื่องพิมพ์ดีด

มาตรฐานเอ็มเอสเอ็กซ์

มาตรฐานนี้ไม่เพียงแต่กำหนดระบบปฏิบัติการเท่านั้น แต่ยังกำหนดคุณลักษณะของฮาร์ดแวร์สำหรับพีซีในโรงเรียนด้วย ตามมาตรฐาน MSX รถต้องมีครับ แกะปริมาณอย่างน้อย 16 K, หน่วยความจำถาวร 32 K พร้อมล่ามภาษา BASIC ในตัว, จอแสดงผลกราฟิกสีความละเอียด 256x192 พิกเซลและ 16 สี, เครื่องกำเนิดเสียง 8 อ็อกเทฟสามช่องสัญญาณ, พอร์ตขนาน สำหรับเชื่อมต่อเครื่องพิมพ์และคอนโทรลเลอร์สำหรับควบคุมไดรฟ์ภายนอกที่เชื่อมต่อภายนอก

ระบบปฏิบัติการของเครื่องดังกล่าวต้องมีคุณสมบัติดังต่อไปนี้: หน่วยความจำที่ต้องการ - ไม่เกิน 16 K, ความเข้ากันได้กับ CP/M ที่ระดับการเรียกของระบบ, ความเข้ากันได้กับ DOS ในรูปแบบไฟล์บน ไดรฟ์ภายนอกขึ้นอยู่กับฟล็อปปี้ดิสก์แม่เหล็ก รองรับนักแปลภาษา BASIC, C, Fortran และ Lisp

พาย - ระบบ

ในช่วงเริ่มต้นของการพัฒนา คอมพิวเตอร์ส่วนบุคคลระบบปฏิบัติการ p-system USCD ถูกสร้างขึ้น พื้นฐานของระบบนี้คือสิ่งที่เรียกว่า P-machine ซึ่งเป็นโปรแกรมที่เลียนแบบสากลเชิงสมมุติ คอมพิวเตอร์. เครื่อง P จำลองการทำงานของโปรเซสเซอร์ หน่วยความจำ และอุปกรณ์ภายนอกโดยดำเนินการคำสั่งพิเศษที่เรียกว่า P-code ส่วนประกอบซอฟต์แวร์ระบบ Pi (รวมถึงคอมไพเลอร์) ได้รับการคอมไพล์ด้วยรหัส P ส่วนโปรแกรมแอปพลิเคชันก็ถูกคอมไพล์เป็นรหัส P เช่นกัน ดังนั้นหลักๆ คุณสมบัติที่โดดเด่นระบบมีการพึ่งพาคุณสมบัติของอุปกรณ์พีซีเพียงเล็กน้อย นี่คือสิ่งที่รับประกันความสามารถในการพกพาของระบบ Pi หลากหลายชนิดรถ ความกะทัดรัดของรหัส P และกลไกการเพจที่ใช้งานสะดวกทำให้สามารถรันโปรแกรมที่มีขนาดค่อนข้างใหญ่บนพีซีที่มี RAM ขนาดเล็กได้

การควบคุมอินพุต/โอ

อุปกรณ์ I/O แบ่งออกเป็น 2 ประเภท: เน้นบล็อกอุปกรณ์และ เน้นไบต์อุปกรณ์ อุปกรณ์ที่เน้นบล็อกจะจัดเก็บข้อมูลเป็นบล็อกขนาดคงที่ ซึ่งแต่ละบล็อกมีที่อยู่ของตัวเอง อุปกรณ์เชิงบล็อกที่พบบ่อยที่สุดคือดิสก์ อุปกรณ์เชิงไบต์ไม่สามารถระบุที่อยู่ได้และไม่อนุญาตให้ดำเนินการค้นหา แต่จะสร้างหรือใช้ลำดับไบต์ ตัวอย่างได้แก่ เทอร์มินัล เครื่องพิมพ์แบบเส้น อะแดปเตอร์เครือข่าย. ชิ้นส่วนอิเล็กทรอนิกส์เรียกว่าตัวควบคุมอุปกรณ์หรืออะแดปเตอร์ ระบบปฏิบัติการเกี่ยวข้องกับคอนโทรลเลอร์ คอนโทรลเลอร์ทำหน้าที่ง่าย ๆ ตรวจสอบและแก้ไขข้อผิดพลาด คอนโทรลเลอร์แต่ละตัวมีรีจิสเตอร์หลายตัวที่ใช้สื่อสารกับโปรเซสเซอร์กลาง ระบบปฏิบัติการดำเนินการ I/O โดยการเขียนคำสั่งไปยังรีจิสเตอร์คอนโทรลเลอร์ คอนโทรลเลอร์ฟล็อปปี้ดิสก์ IBM PC ยอมรับคำสั่ง 15 คำสั่ง เช่น READ, WRITE, SEEK, FORMAT เป็นต้น เมื่อยอมรับคำสั่งแล้ว โปรเซสเซอร์จะออกจากคอนโทรลเลอร์และทำงานอื่น เมื่อคำสั่งเสร็จสิ้น คอนโทรลเลอร์จะส่งสัญญาณขัดจังหวะเพื่อถ่ายโอนการควบคุมโปรเซสเซอร์ไปยังระบบปฏิบัติการ ซึ่งจะต้องตรวจสอบผลลัพธ์ของการดำเนินการ โปรเซสเซอร์รับผลลัพธ์และสถานะของอุปกรณ์โดยการอ่านข้อมูลจากรีจิสเตอร์คอนโทรลเลอร์

แนวคิดหลัก การจัดระเบียบซอฟต์แวร์ I/Oประกอบด้วยการแบ่งระดับออกเป็นหลายระดับ โดยระดับล่างจะทำหน้าที่ป้องกันคุณสมบัติของอุปกรณ์จากด้านบน และส่วนที่ให้ ส่วนต่อประสานที่ใช้งานง่ายสำหรับผู้ใช้

สำคัญหลักการก็คือ ความเป็นอิสระของอุปกรณ์. ประเภทของโปรแกรมไม่ควรขึ้นอยู่กับว่าอ่านข้อมูลจากฟล็อปปี้ดิสก์หรือจาก ฮาร์ดไดรฟ์. ปัญหาที่สำคัญอีกประการหนึ่งสำหรับซอฟต์แวร์ I/O คือการจัดการข้อผิดพลาด โดยทั่วไปแล้ว ข้อผิดพลาดควรได้รับการจัดการให้ใกล้เคียงกับฮาร์ดแวร์มากที่สุด หากคอนโทรลเลอร์ตรวจพบข้อผิดพลาดในการอ่าน จะต้องพยายามแก้ไข หากล้มเหลว ไดรเวอร์อุปกรณ์จะต้องแก้ไขข้อผิดพลาด และเฉพาะในกรณีที่ระดับล่างไม่สามารถรับมือกับข้อผิดพลาดได้ ก็จะรายงานข้อผิดพลาดไปยังระดับบนเท่านั้น

ปัญหาสำคัญอีกประการหนึ่งคือการใช้การถ่ายโอนแบบบล็อก (ซิงโครนัส) และไม่มีการบล็อก (อะซิงโครนัส) การดำเนินการ I/O ทางกายภาพส่วนใหญ่จะดำเนินการแบบอะซิงโครนัส - โปรเซสเซอร์เริ่มการถ่ายโอนและย้ายไปยังงานอื่นจนกว่าจะเกิดการขัดจังหวะ จำเป็นต้องบล็อกการดำเนินการ I/O - หลังจากคำสั่ง READ โปรแกรมจะหยุดชั่วคราวโดยอัตโนมัติจนกว่าข้อมูลจะถึงบัฟเฟอร์ของโปรแกรม

ปัญหาสุดท้ายคืออุปกรณ์บางตัวถูกแชร์ (ดิสก์: ผู้ใช้หลายคนที่เข้าถึงดิสก์ในเวลาเดียวกันไม่ใช่ปัญหา) ในขณะที่อุปกรณ์อื่นๆ เป็นแบบเฉพาะ (เครื่องพิมพ์: บรรทัดที่พิมพ์โดยผู้ใช้ต่างกันไม่สามารถผสมกันได้)

เพื่อแก้ไขปัญหาเหล่านี้ ขอแนะนำให้แบ่งซอฟต์แวร์ I/O ออกเป็นสี่ชั้น (รูปที่ 2.30):

·การจัดการขัดจังหวะ

·ไดรเวอร์อุปกรณ์

· เลเยอร์ระบบปฏิบัติการที่ไม่ขึ้นกับอุปกรณ์

· เลเยอร์ซอฟต์แวร์ที่กำหนดเอง

แนวคิดเรื่องการขัดจังหวะฮาร์ดแวร์และการประมวลผล

การขัดจังหวะแบบอะซิงโครนัสหรือภายนอก (ฮาร์ดแวร์) คือเหตุการณ์ที่มาจากแหล่งภายนอก (เช่น อุปกรณ์ต่อพ่วง) และสามารถเกิดขึ้นได้ตลอดเวลา: สัญญาณจากตัวจับเวลา การ์ดเครือข่ายหรือดิสก์ไดรฟ์ การกดแป้นคีย์บอร์ด การเลื่อนเมาส์ พวกเขาต้องการปฏิกิริยาทันที (การประมวลผล)

ระบบอินพุต/เอาท์พุตเกือบทั้งหมดในคอมพิวเตอร์ทำงานโดยใช้การขัดจังหวะ โดยเฉพาะเมื่อคุณกดปุ่มหรือคลิกเมาส์ ฮาร์ดแวร์จะสร้างการขัดจังหวะ เพื่อตอบสนองต่อสิ่งเหล่านั้นระบบจะอ่านรหัสของปุ่มที่กดหรือจดจำพิกัดของเคอร์เซอร์ของเมาส์ การขัดจังหวะจะถูกสร้างขึ้นโดยตัวควบคุมดิสก์ อะแดปเตอร์ เครือข่ายท้องถิ่น, พอร์ตอนุกรม, อะแดปเตอร์เสียง และอุปกรณ์อื่นๆ