เคอร์เนล (ระบบปฏิบัติการ)

จากวิกิพีเดีย สารานุกรมเสรี
ข้ามไปที่การนำทาง ข้ามไปที่การค้นหา
เคอร์เนลเชื่อมต่อแอพพลิเคชั่นซอฟต์แวร์กับฮาร์ดแวร์ของคอมพิวเตอร์

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

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

เคอร์เนลของอินเตอร์เฟซที่เป็นระดับต่ำ ชั้น abstractionเมื่อขั้นตอนการขอบริการจากเมล็ดนั้นจะต้องเรียกใช้เรียกระบบมักจะผ่านฟังก์ชั่นเสื้อคลุม

มีการออกแบบสถาปัตยกรรมเคอร์เนลที่แตกต่างกันเมล็ดแบบเสาหินทำงานทั้งหมดในพื้นที่ที่อยู่เดียวโดยที่ CPU ทำงานในโหมดผู้ควบคุมส่วนใหญ่เพื่อความเร็วMicrokernelsทำงานส่วนใหญ่แต่ไม่ใช่ทุกบริการในพื้นที่ผู้ใช้[3]เช่นเดียวกับกระบวนการของผู้ใช้ ซึ่งส่วนใหญ่ใช้สำหรับความยืดหยุ่นและโมดูลาร์[4] MINIX 3เป็นตัวอย่างที่โดดเด่นของการออกแบบไมโครเคอร์เนล แทนเคอร์เนล Linuxเป็นแบบเสาหิน แม้ว่าจะเป็นแบบโมดูลาร์เช่นกัน เพราะมันสามารถแทรกและลบโมดูลเคอร์เนลที่โหลดได้ในขณะรันไทม์

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

หน่วยความจำเข้าถึงโดยสุ่ม

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

อุปกรณ์อินพุต/เอาต์พุต

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

การจัดการทรัพยากร

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

การจัดการหน่วยความจำ

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

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

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

การจัดการอุปกรณ์

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

ในระดับฮาร์ดแวร์ สิ่งที่เป็นนามธรรมทั่วไปของไดรเวอร์อุปกรณ์ ได้แก่:

  • เชื่อมต่อโดยตรง
  • การใช้อินเทอร์เฟซระดับสูง (Video BIOS )
  • การใช้ไดรเวอร์อุปกรณ์ระดับล่าง (ไดรเวอร์ไฟล์ที่ใช้ไดรเวอร์ดิสก์)
  • จำลองการทำงานกับฮาร์ดแวร์ ในขณะที่ทำสิ่งที่แตกต่างไปจากเดิมอย่างสิ้นเชิง

และในระดับซอฟต์แวร์ สิ่งที่เป็นนามธรรมของไดรเวอร์อุปกรณ์ประกอบด้วย:

  • อนุญาตให้ระบบปฏิบัติการเข้าถึงทรัพยากรฮาร์ดแวร์ได้โดยตรง
  • นำเฉพาะเบื้องต้นเท่านั้น
  • การใช้อินเทอร์เฟซสำหรับซอฟต์แวร์ที่ไม่ใช่ไดรเวอร์ เช่นTWAIN
  • การใช้ภาษา (มักจะเป็นภาษาระดับสูงเช่นPostScript )

ตัวอย่างเช่น เพื่อแสดงบางสิ่งให้ผู้ใช้เห็นบนหน้าจอ แอปพลิเคชันจะส่งคำขอไปยังเคอร์เนล ซึ่งจะส่งต่อคำขอไปยังไดรเวอร์การแสดงผล ซึ่งมีหน้าที่ในการวางแผนอักขระ/พิกเซลจริง[6]

เคอร์เนลต้องรักษารายการอุปกรณ์ที่มีอยู่ รายการนี้อาจทราบล่วงหน้า (เช่น บนระบบฝังตัวซึ่งเคอร์เนลจะถูกเขียนใหม่หากฮาร์ดแวร์ที่พร้อมใช้งานเปลี่ยนแปลง) กำหนดค่าโดยผู้ใช้ (โดยทั่วไปบนพีซีรุ่นเก่าและบนระบบที่ไม่ได้ออกแบบมาสำหรับการใช้งานส่วนตัว) หรือตรวจพบโดย ระบบปฏิบัติการในขณะใช้งาน (ปกติเรียกว่าplug and play ) ในระบบ plug-and-play อันดับแรก ตัวจัดการอุปกรณ์จะทำการสแกนอุปกรณ์ต่อพ่วงต่างๆ เช่นPeripheral Component Interconnect (PCI) หรือUniversal Serial Bus (USB) เพื่อตรวจหาอุปกรณ์ที่ติดตั้ง จากนั้นจึงค้นหาไดรเวอร์ที่เหมาะสม

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

ระบบเรียก

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

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

เพื่อทำงานที่มีประโยชน์จริง ๆ กระบวนการต้องสามารถเข้าถึงบริการที่เคอร์เนลจัดหาให้ สิ่งนี้มีการใช้งานที่แตกต่างกันโดยแต่ละเคอร์เนล แต่ส่วนใหญ่มีไลบรารี CหรือAPIซึ่งจะเรียกใช้ฟังก์ชันเคอร์เนลที่เกี่ยวข้อง [7]

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

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

การตัดสินใจออกแบบเคอร์เนล

การป้องกัน

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

กลไกหรือนโยบายที่มีให้โดยเคอร์เนลสามารถจำแนกได้ตามเกณฑ์หลายประการ ได้แก่ แบบคงที่ (บังคับใช้ ณเวลาคอมไพล์ ) หรือไดนามิก (บังคับใช้ ณรันไทม์ ); การตรวจจับล่วงหน้าหรือหลังการตรวจจับ ตามหลักการป้องกันที่พวกเขาพอใจ (เช่นDenning [8] [9] ); ไม่ว่าจะเป็นฮาร์ดแวร์ที่รองรับหรือตามภาษา ไม่ว่าจะเป็นกลไกแบบเปิดหรือนโยบายที่มีผลผูกพัน และอื่น ๆ อีกมากมาย.

การสนับสนุนสำหรับโดเมนป้องกันลำดับชั้น[10]โดยปกติจะดำเนินการโดยใช้โหมด CPU

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

วิธีที่มีประสิทธิภาพและง่ายต่อการให้การสนับสนุนฮาร์ดแวร์ของความสามารถคือการมอบหมายให้กับหน่วยจัดการหน่วยความจำ (MMU) รับผิดชอบในการตรวจสอบการเข้าถึงสิทธิสำหรับการเข้าถึงหน่วยความจำทุกกลไกที่เรียกว่าความสามารถตามที่อยู่ [11]สถาปัตยกรรมคอมพิวเตอร์เชิงพาณิชย์ส่วนใหญ่ขาดการสนับสนุน MMU สำหรับความสามารถดังกล่าว

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

หากเฟิร์มแวร์ไม่สนับสนุนกลไกการป้องกัน ก็สามารถจำลองการป้องกันในระดับที่สูงขึ้นได้ เช่น โดยการจำลองความสามารถโดยจัดการตารางเพจแต่มีนัยเกี่ยวกับประสิทธิภาพ [14]การขาดการสนับสนุนฮาร์ดแวร์อาจไม่เป็นปัญหาสำหรับระบบที่เลือกใช้การป้องกันตามภาษา [15]

การตัดสินใจในการออกแบบเคอร์เนลที่สำคัญคือการเลือกระดับที่เป็นนามธรรมซึ่งควรนำกลไกและนโยบายด้านความปลอดภัยไปใช้ กลไกการรักษาความปลอดภัยเคอร์เนลมีบทบาทสำคัญในการสนับสนุนความปลอดภัยในระดับที่สูงขึ้น [11] [16] [17] [18] [19]

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

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

การป้องกันด้วยฮาร์ดแวร์หรือภาษา

ระบบคอมพิวเตอร์ทั่วไปในปัจจุบันใช้กฎที่บังคับใช้กับฮาร์ดแวร์เกี่ยวกับโปรแกรมที่ได้รับอนุญาตให้เข้าถึงข้อมูลใด ตัวประมวลผลจะตรวจสอบการดำเนินการและหยุดโปรแกรมที่ละเมิดกฎ เช่น กระบวนการของผู้ใช้ที่พยายามเขียนไปยังหน่วยความจำเคอร์เนล ในระบบที่ไม่รองรับความสามารถ กระบวนการจะถูกแยกออกจากกันโดยใช้ช่องว่างที่อยู่แยกต่างหาก[20] การเรียกจากกระบวนการของผู้ใช้เข้าสู่เคอร์เนลถูกควบคุมโดยกำหนดให้ใช้วิธีเรียกระบบอย่างใดอย่างหนึ่งที่อธิบายข้างต้น

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

ข้อดีของวิธีนี้ ได้แก่ :

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

ข้อเสีย ได้แก่ :

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

ตัวอย่างของระบบที่มีการป้องกันตามภาษา ได้แก่JXและไมโครซอฟท์ 's เอกพจน์

กระบวนการความร่วมมือ

Edsger Dijkstraพิสูจน์ให้เห็นว่าจากจุดตรรกะในมุมมองของอะตอม ล็อคและปลดล็อคการดำเนินงานการดำเนินงานในไบนารีsemaphoresมีพื้นฐานเพียงพอที่จะแสดงการทำงานของความร่วมมือกระบวนการใด ๆ [21]อย่างไรก็ตาม แนวทางนี้โดยทั่วไปถือว่ายังขาดในแง่ของความปลอดภัยและประสิทธิภาพ ในขณะที่วิธีการส่งข้อความจะมีความยืดหยุ่นมากกว่า [22] จำนวนของวิธีการอื่น ๆ (ทั้งล่างหรือระดับที่สูงขึ้น) ให้บริการเป็นอย่างดีกับเมล็ดที่ทันสมัยมากให้การสนับสนุนสำหรับระบบดังกล่าวเป็นหน่วยความจำที่ใช้ร่วมกันและโทรขั้นตอนระยะไกล

การจัดการอุปกรณ์ I/O

ความคิดของเคอร์เนลที่อุปกรณ์ I / O ได้รับการจัดการอย่างสม่ำเสมอกับกระบวนการอื่น ๆ เช่นกระบวนการปฏิบัติการร่วมขนานที่ได้รับการเสนอครั้งแรกและดำเนินการโดยBrinch แฮนเซน (แม้ว่าความคิดที่คล้ายกันถูกแนะนำในปี 1967 [23] [24] ) ในรายละเอียดของแฮนเซนของนี้ "คนธรรมดา" กระบวนการที่เรียกว่ากระบวนการภายในในขณะที่อุปกรณ์ I / O จะเรียกว่ากระบวนการภายนอก [22]

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

แนวทางการออกแบบทั่วทั้งเคอร์เนล

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

หลักการแยกกลไกและนโยบายเป็นความแตกต่างที่สำคัญระหว่างปรัชญาของเมล็ดไมโครและเมล็ดเสาหิน [25] [26] ในที่นี้กลไกคือการสนับสนุนที่ช่วยให้สามารถดำเนินการตามนโยบายต่างๆ ได้มากมาย ในขณะที่นโยบายคือ "โหมดการทำงาน" โดยเฉพาะ ตัวอย่าง:

  • กลไก: การพยายามเข้าสู่ระบบของผู้ใช้จะถูกส่งไปยังเซิร์ฟเวอร์การอนุญาต
  • นโยบาย:เซิร์ฟเวอร์การอนุญาตต้องใช้รหัสผ่านที่ตรวจสอบกับรหัสผ่านที่จัดเก็บไว้ในฐานข้อมูล

เพราะกลไกและนโยบายจะถูกแยกออกนโยบายที่สามารถเปลี่ยนแปลงได้อย่างง่ายดายไปเช่นต้องใช้การรักษาความปลอดภัย token

ใน microkernel ขั้นต่ำ มีเพียงนโยบายพื้นฐานบางอย่างเท่านั้นที่รวมไว้[26]และกลไกของมันช่วยให้สิ่งที่ทำงานอยู่บนเคอร์เนล (ส่วนที่เหลือของระบบปฏิบัติการและแอปพลิเคชันอื่นๆ) เพื่อตัดสินใจว่าจะใช้นโยบายใด (ในฐานะการจัดการหน่วยความจำ การจัดตารางกระบวนการระดับสูง การจัดการระบบไฟล์ ฯลฯ) [5] [22]เคอร์เนลเสาหินแทนมีแนวโน้มที่จะรวมนโยบายหลายอย่าง ดังนั้นจึงจำกัดส่วนที่เหลือของระบบให้พึ่งพานโยบายเหล่านั้น

Per Brinch Hansenเสนอข้อโต้แย้งเพื่อสนับสนุนการแยกกลไกและนโยบาย[5] [22]ความล้มเหลวในการปฏิบัติตามการแยกนี้อย่างถูกต้องเป็นหนึ่งในสาเหตุหลักของการขาดนวัตกรรมที่สำคัญในระบบปฏิบัติการที่มีอยู่[5]ปัญหาทั่วไปในสถาปัตยกรรมคอมพิวเตอร์[27] [28] [29]การออกแบบเสาหินที่เกิดจาก "โหมดเคอร์เนล"/"โหมดผู้ใช้" แนวทางสถาปัตยกรรมเพื่อป้องกัน (เทคนิคเรียกว่าโดเมนการป้องกันตามลำดับชั้น ) ซึ่งเป็นเรื่องปกติในระบบการค้าทั่วไป; [30]อันที่จริง ทุกโมดูลที่ต้องการการป้องกันจึงควรรวมไว้ในเคอร์เนล[30]ความเชื่อมโยงระหว่างการออกแบบเสาหินและ "โหมดสิทธิพิเศษ" สามารถนำมาพิจารณาใหม่ได้ในประเด็นสำคัญของการแยกกลไก-นโยบาย[5]อันที่จริง วิธีการทางสถาปัตยกรรม "โหมดพิเศษ" ผสมผสานกลไกการป้องกันเข้ากับนโยบายความปลอดภัย ในขณะที่แนวทางสถาปัตยกรรมทางเลือกที่สำคัญ การกำหนดที่อยู่ตามความสามารถแยกความแตกต่างอย่างชัดเจนระหว่างสองสิ่งนี้ นำไปสู่การออกแบบไมโครเคอร์เนลอย่างเป็นธรรมชาติ[5] ( ดูการแยกการป้องกันและการรักษาความปลอดภัย )

ในขณะที่เคอร์เนลแบบเสาหินรันโค้ดทั้งหมดในพื้นที่ที่อยู่เดียวกัน (พื้นที่เคอร์เนล ) microkernelsพยายามเรียกใช้บริการส่วนใหญ่ในพื้นที่ผู้ใช้ โดยมีเป้าหมายเพื่อปรับปรุงความสามารถในการบำรุงรักษาและความเป็นโมดูลของโค้ดเบส [4]เมล็ดพืชส่วนใหญ่ไม่ตรงกับประเภทใดประเภทหนึ่ง แต่พบได้ระหว่างการออกแบบทั้งสองนี้ เหล่านี้เรียกว่าเมล็ดไฮบริด มีการออกแบบที่แปลกใหม่มากขึ้น เช่นนาโนเคอร์เนลและเอ็กโซเคอร์เนลแต่มักไม่ค่อยใช้สำหรับระบบการผลิต Xen hypervisor ตัวอย่างเช่นเป็นเอ็กโซ

เมล็ดเสาหิน

แผนภาพของเคอร์เนลเสาหิน

ในเคอร์เนลเสาหิน บริการ OS ทั้งหมดจะทำงานพร้อมกับเธรดเคอร์เนลหลัก ดังนั้นจึงอยู่ในพื้นที่หน่วยความจำเดียวกันด้วย แนวทางนี้ให้การเข้าถึงฮาร์ดแวร์ที่สมบูรณ์และทรงพลัง นักพัฒนาบางคน เช่นKen Thompson ผู้พัฒนาUNIXยืนยันว่า "ง่ายต่อการใช้งานเคอร์เนลเสาหิน" [31]กว่า microkernels ข้อเสียเปรียบหลักของเมล็ดเสาหินคือการขึ้นต่อกันระหว่างส่วนประกอบของระบบ - ข้อบกพร่องในไดรเวอร์อุปกรณ์อาจทำให้ระบบทั้งหมดขัดข้อง - และความจริงที่ว่าเมล็ดขนาดใหญ่สามารถรักษาได้ยากมาก

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

  • เนื่องจากมีซอฟต์แวร์ที่เกี่ยวข้องน้อยกว่าจึงเร็วกว่า
  • เนื่องจากเป็นซอฟต์แวร์ชิ้นเดียว จึงควรมีขนาดเล็กกว่าทั้งในแบบต้นฉบับและแบบคอมไพล์
  • โดยทั่วไปแล้วโค้ดที่น้อยลงหมายถึงบั๊กที่น้อยลง ซึ่งสามารถแปลเป็นปัญหาด้านความปลอดภัยที่น้อยลงได้

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

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

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

ตัวอย่างของเคอร์เนลแบบเสาหิน ได้แก่เคอร์เนลAIX , เคอร์เนล HP-UX และเคอร์เนล Solaris

ไมโครเคอร์เนล

Microkernel (เรียกย่อว่า μK หรือ uK) เป็นคำที่อธิบายแนวทางการออกแบบระบบปฏิบัติการโดยที่การทำงานของระบบถูกย้ายออกจาก "เคอร์เนล" แบบเดิมๆ ไปเป็นชุดของ "เซิร์ฟเวอร์" ที่สื่อสารผ่านเคอร์เนลที่ "น้อยที่สุด" ให้เหลือน้อยที่สุดใน "พื้นที่ระบบ" และให้มากที่สุดใน "พื้นที่ผู้ใช้" ไมโครเคอร์เนลที่ออกแบบมาสำหรับแพลตฟอร์มหรืออุปกรณ์เฉพาะจะมีสิ่งที่จำเป็นในการใช้งานเท่านั้น วิธี microkernel ประกอบด้วยการกำหนดสิ่งที่เป็นนามธรรมที่เรียบง่ายมากกว่าฮาร์ดแวร์กับชุดของพื้นฐานหรือระบบโทรศัพท์ที่จะใช้บริการ OS น้อยที่สุดเช่นการจัดการหน่วยความจำ , มัลติทาสกิ้งและการสื่อสารระหว่างกระบวนการ. บริการอื่น ๆ รวมทั้งผู้ที่ให้ตามปกติโดย kernel เช่นระบบเครือข่ายจะถูกนำมาใช้ในโปรแกรมผู้ใช้พื้นที่เรียกว่าเซิร์ฟเวอร์ไมโครเคอร์เนลดูแลรักษาง่ายกว่าเคอร์เนลเสาหิน แต่การเรียกระบบและการสลับบริบทจำนวนมากอาจทำให้ระบบช้าลง เนื่องจากโดยทั่วไปแล้วจะสร้างโอเวอร์เฮดมากกว่าการเรียกใช้ฟังก์ชันธรรมดา

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

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

microkernels ส่วนใหญ่ใช้ระบบส่งข้อความเพื่อจัดการคำขอจากเซิร์ฟเวอร์หนึ่งไปยังอีกเซิร์ฟเวอร์หนึ่ง ระบบส่งข้อความโดยทั่วไปทำงานบนพื้นฐานพอร์ตกับไมโครเคอร์เนล ตัวอย่างเช่น หากมีการส่งคำขอเพิ่มหน่วยความจำ พอร์ตจะถูกเปิดด้วย microkernel และคำขอที่ส่งผ่าน เมื่ออยู่ในไมโครเคอร์เนลแล้ว ขั้นตอนจะคล้ายกับการเรียกของระบบ เหตุผลก็คือมันจะทำให้เกิดโมดูลในสถาปัตยกรรมระบบ ซึ่งจะทำให้ระบบสะอาดขึ้น ง่ายต่อการแก้ไขจุดบกพร่องหรือปรับเปลี่ยนแบบไดนามิก ปรับแต่งได้ตามความต้องการของผู้ใช้ และมีประสิทธิภาพมากขึ้น เป็นส่วนหนึ่งของระบบปฏิบัติการเช่นGNU Hurd , MINIX , MkLinux , QNXและRedox OS. แม้ว่าไมโครเคอร์เนลจะมีขนาดเล็กมากในตัวเอง แต่เมื่อรวมกับรหัสเสริมที่จำเป็นทั้งหมดแล้ว ในความเป็นจริงแล้ว ไมโครเคอร์เนลมักจะใหญ่กว่าเมล็ดแบบเสาหิน ผู้สนับสนุนของเมล็ดเสาหินยังชี้ให้เห็นว่าโครงสร้างสองระดับของระบบไมโครเคอร์เนล ซึ่งระบบปฏิบัติการส่วนใหญ่ไม่ได้โต้ตอบโดยตรงกับฮาร์ดแวร์ ทำให้เกิดต้นทุนที่ไม่มีนัยสำคัญในแง่ของประสิทธิภาพของระบบ โดยปกติแล้ว เคอร์เนลประเภทนี้จะให้บริการเพียงเล็กน้อย เช่น การกำหนดพื้นที่ที่อยู่หน่วยความจำ การสื่อสารระหว่างกระบวนการ (IPC) และการจัดการกระบวนการ ฟังก์ชันอื่นๆ เช่น การรันกระบวนการฮาร์ดแวร์ไม่ได้รับการจัดการโดย microkernels โดยตรง ผู้เสนอเมล็ดขนาดเล็กชี้ให้เห็นว่าเมล็ดเสาหินเหล่านั้นมีข้อเสียที่ข้อผิดพลาดในเคอร์เนลอาจทำให้ทั้งระบบหยุดทำงาน อย่างไรก็ตาม,ด้วย microkernel หากกระบวนการเคอร์เนลขัดข้อง ยังคงสามารถป้องกันการหยุดทำงานของระบบโดยรวมได้เพียงแค่เริ่มบริการใหม่ที่ทำให้เกิดข้อผิดพลาด

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

อย่างไรก็ตาม ข้อเสียในไมโครเคอร์เนลยังคงมีอยู่ บางสิ่งเป็น:

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

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

microkernel อนุญาตให้ใช้งานส่วนที่เหลือของระบบปฏิบัติการเป็นโปรแกรมแอปพลิเคชันปกติที่เขียนด้วยภาษาระดับสูงและใช้ระบบปฏิบัติการที่แตกต่างกันบนเคอร์เนลเดียวกันที่ไม่เปลี่ยนแปลง นอกจากนี้ยังสามารถสลับไปมาระหว่างระบบปฏิบัติการแบบไดนามิกและเปิดใช้งานพร้อมกันได้มากกว่าหนึ่งระบบ [22]

เมล็ดเสาหินเทียบกับ microkernels

เมื่อเคอร์เนลของคอมพิวเตอร์เติบโตขึ้น ขนาดและช่องโหว่ของฐานการคำนวณที่เชื่อถือได้ก็เพิ่มขึ้นเช่นกัน และนอกจากจะลดความปลอดภัยแล้ว ยังมีปัญหาในการขยายขนาดหน่วยความจำอีกด้วย สิ่งนี้ลดลงในระดับหนึ่งโดยการปรับปรุงระบบหน่วยความจำเสมือนให้สมบูรณ์แบบแต่ไม่ใช่สถาปัตยกรรมคอมพิวเตอร์ทั้งหมดที่รองรับหน่วยความจำเสมือน [32]เพื่อลดรอยเท้าของเคอร์เนล จะต้องดำเนินการแก้ไขอย่างละเอียดเพื่อลบโค้ดที่ไม่จำเป็นออกอย่างระมัดระวัง ซึ่งอาจเป็นเรื่องยากมากด้วยการพึ่งพาอาศัยกันที่ไม่ชัดเจนระหว่างส่วนต่างๆ ของเคอร์เนลที่มีโค้ดหลายล้านบรรทัด

ในช่วงต้นทศวรรษ 1990 เนื่องจากข้อบกพร่องหลายประการของเมล็ด monolithic กับ microkernels นักวิจัยระบบปฏิบัติการแทบทุกคนจึงถือว่า monolithic kernels ล้าสมัย [ ต้องการอ้างอิง ]เป็นผลให้การออกแบบของลินุกซ์เป็นเคอร์เนลเสาหินมากกว่า microkernel เป็นหัวข้อของการอภิปรายที่มีชื่อเสียงระหว่างLinus Torvaldsและแอนดรู Tanenbaum [33]มีบุญทั้งสองด้านของการโต้แย้งที่นำเสนอในการอภิปราย Tanenbaum-Torvalds

ประสิทธิภาพ

เมล็ดพืชเสาหินได้รับการออกแบบให้มีรหัสทั้งหมดในพื้นที่ที่อยู่เดียวกัน ( พื้นที่เคอร์เนล ) ซึ่งนักพัฒนาบางคนโต้แย้งว่าจำเป็นต้องเพิ่มประสิทธิภาพของระบบ[34]นักพัฒนาบางคนยังยืนยันว่าระบบเสาหินนั้นมีประสิทธิภาพอย่างยิ่งหากเขียนได้ดี[34]รุ่นเสาหินมีแนวโน้มที่จะมีประสิทธิภาพมากขึ้น[35]ผ่านการใช้หน่วยความจำเคอร์เนลที่ใช้ร่วมกันมากกว่าระบบ IPC ช้าของการออกแบบ microkernel ซึ่งมักจะขึ้นอยู่กับการส่งผ่านข้อความ [ ต้องการการอ้างอิง ]

ประสิทธิภาพของ microkernels นั้นแย่ทั้งในช่วงปี 1980 และต้นทศวรรษ 1990 [36] [37]อย่างไรก็ตาม การศึกษาที่วัดประสิทธิภาพของ microkernels เหล่านี้ไม่ได้วิเคราะห์สาเหตุของความไร้ประสิทธิภาพดังกล่าว[36]คำอธิบายของข้อมูลนี้ปล่อยให้เป็น "คติชนวิทยา" โดยสันนิษฐานว่าเป็นเพราะความถี่ที่เพิ่มขึ้นของสวิตช์จาก "โหมดเคอร์เนล" เป็น "โหมดผู้ใช้" ไปจนถึงความถี่ที่เพิ่มขึ้นของการสื่อสารระหว่างกระบวนการและความถี่ที่เพิ่มขึ้นของสวิทช์บริบท (36)

ที่จริงแล้ว ตามที่คาดเดาไว้ในปี 1995 สาเหตุของประสิทธิภาพที่ต่ำของ microkernels อาจเป็นดังนี้: (1) ความไร้ประสิทธิภาพที่แท้จริงของวิธีการ microkernel ทั้งหมด(2) แนวคิดเฉพาะที่นำไปใช้ใน microkernels เหล่านั้น และ (3) การนำแนวคิดเหล่านั้นไปปฏิบัติโดยเฉพาะดังนั้นจึงยังคงต้องศึกษาว่าวิธีการแก้ปัญหาในการสร้างไมโครเคอร์เนลที่มีประสิทธิภาพนั้นแตกต่างจากความพยายามครั้งก่อนหรือไม่ในการใช้เทคนิคการก่อสร้างที่ถูกต้อง(36)

อีกด้านหนึ่งสถาปัตยกรรมโดเมนการป้องกันแบบลำดับชั้นที่นำไปสู่การออกแบบเคอร์เนลเสาหิน[30]มีข้อเสียด้านประสิทธิภาพที่สำคัญในแต่ละครั้งที่มีปฏิสัมพันธ์ระหว่างระดับการป้องกันที่แตกต่างกัน (เช่น เมื่อกระบวนการต้องจัดการโครงสร้างข้อมูลทั้ง ในโหมด "ผู้ใช้" และ "โหมดผู้บังคับบัญชา") ตั้งแต่นี้ต้องมีการคัดลอกข้อความด้วยค่า [38]

แนวทางไฮบริดเคอร์เนลผสมผสานความเร็วและการออกแบบที่เรียบง่ายของเคอร์เนลเสาหินเข้ากับโมดูลาร์และความปลอดภัยในการดำเนินการของไมโครเคอร์เนล

เมล็ดลูกผสม (หรือโมดูลาร์)

เคอร์เนลไฮบริดใช้ในระบบปฏิบัติการเชิงพาณิชย์ส่วนใหญ่ เช่นMicrosoft Windows NT 3.1, NT 3.5, NT 3.51, NT 4.0, 2000, XP, Vista, 7, 8, 8.1 และ 10 macOSของApple Incใช้เคอร์เนลไฮบริดที่เรียกว่าXNUซึ่งจะขึ้นอยู่กับโค้ดจากOSF / 1 's Mach เคอร์เนล (OSFMK 7.3) [39]และFreeBSD ' s เสาหินเคอร์เนล. พวกมันคล้ายกับไมโครเคอร์เนล ยกเว้นว่ามีโค้ดเพิ่มเติมบางส่วนในเคอร์เนลสเปซเพื่อเพิ่มประสิทธิภาพ เมล็ดเหล่านี้แสดงถึงการประนีประนอมที่ดำเนินการโดยนักพัฒนาบางคนเพื่อรองรับข้อได้เปรียบที่สำคัญของทั้งเมล็ดเสาหินและไมโคร เมล็ดเหล่านี้เป็นส่วนขยายของเมล็ดขนาดเล็กที่มีคุณสมบัติบางอย่างของเมล็ดเสาหิน ไม่เหมือนกับเมล็ดแบบเสาหิน เมล็ดประเภทนี้ไม่สามารถโหลดโมดูลในขณะรันไทม์ได้ด้วยตัวเอง Hybrid kernels เป็นไมโครเคอร์เนลที่มีโค้ด "ไม่จำเป็น" บางส่วนในเคอร์เนลสเปซเพื่อให้โค้ดทำงานเร็วกว่าที่ควรจะเป็นในพื้นที่ผู้ใช้ เมล็ดลูกผสมเป็นการประนีประนอมระหว่างการออกแบบเสาหินและไมโครเคอร์เนล นี่หมายถึงการเรียกใช้บริการบางอย่าง (เช่นเครือข่ายสแต็กหรือระบบไฟล์) ในพื้นที่เคอร์เนลเพื่อลดโอเวอร์เฮดด้านประสิทธิภาพของไมโครเคอร์เนลแบบเดิม แต่ยังคงรันโค้ดเคอร์เนล (เช่น ไดรเวอร์อุปกรณ์) เป็นเซิร์ฟเวอร์ในพื้นที่ผู้ใช้

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

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

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

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

นาโนเคอร์เนล

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

เอ็กโซเคอร์เนล

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

Exokernels ในตัวเองมีขนาดเล็กมาก อย่างไรก็ตาม มันมาพร้อมกับระบบปฏิบัติการห้องสมุด (ดูเพิ่มเติมที่unikernel ) ให้นักพัฒนาแอปพลิเคชันมีฟังก์ชันการทำงานของระบบปฏิบัติการทั่วไป สิ่งนี้เกิดขึ้นกับผู้ใช้ทุกคนที่เขียนเคอร์เนลที่เหลือของตัวเองตั้งแต่ต้น ซึ่งเป็นงานที่มีความเสี่ยงสูง ซับซ้อนและค่อนข้างน่ากลัว โดยเฉพาะอย่างยิ่งในสภาพแวดล้อมที่มุ่งเน้นการผลิตที่มีเวลาจำกัด ซึ่งเป็นสาเหตุที่ exokernels ไม่เคย ติดอยู่บน. [ ต้องการการอ้างอิง ]ข้อได้เปรียบที่สำคัญของระบบที่ใช้ exokernel คือสามารถรวมระบบปฏิบัติการไลบรารีหลายระบบ โดยแต่ละระบบจะส่งออกAPI ที่แตกต่างกันตัวอย่างเช่น ระบบหนึ่งสำหรับการพัฒนาUIระดับสูงและอีกระบบสำหรับการควบคุม แบบเรียลไทม์

ประวัติการพัฒนาเคอร์เนล

เคอร์เนลระบบปฏิบัติการก่อนหน้า

พูดอย่างเคร่งครัด ระบบปฏิบัติการ (และดังนั้น เคอร์เนล) ไม่จำเป็นต้องใช้คอมพิวเตอร์ สามารถโหลดและดำเนินการโปรแกรมได้โดยตรงบนเครื่อง "โลหะเปลือย" โดยที่ผู้เขียนโปรแกรมเหล่านั้นเต็มใจที่จะทำงานโดยไม่ต้องมีฮาร์ดแวร์ที่เป็นนามธรรมหรือการสนับสนุนระบบปฏิบัติการ คอมพิวเตอร์ยุคแรกๆ ส่วนใหญ่ใช้วิธีนี้ในช่วงปี 1950 และต้นทศวรรษ 1960 ซึ่งถูกรีเซ็ตและโหลดซ้ำระหว่างการเรียกใช้โปรแกรมต่างๆ ในที่สุดโปรแกรมเสริมขนาดเล็กเช่นรถตักโปรแกรมและแก้จุดบกพร่องที่ถูกทิ้งไว้ในความทรงจำระหว่างวิ่งหรือโหลดจากรอมเมื่อสิ่งเหล่านี้ได้รับการพัฒนา พวกเขาสร้างพื้นฐานของสิ่งที่กลายเป็นเคอร์เนลของระบบปฏิบัติการในยุคแรก"โลหะเปลือย"วิธีการที่จะยังคงใช้มาจนถึงปัจจุบันในบางวิดีโอเกมคอนโซลและระบบฝังตัว , [41]แต่โดยทั่วไปคอมพิวเตอร์รุ่นใหม่ใช้ระบบปฏิบัติการที่ทันสมัยและเมล็ด

ในปี 1969 RC 4000 Multiprogramming System ได้แนะนำปรัชญาการออกแบบระบบของนิวเคลียสขนาดเล็ก "ซึ่งระบบปฏิบัติการสำหรับวัตถุประสงค์ที่แตกต่างกันสามารถสร้างขึ้นได้อย่างเป็นระเบียบ" [42]สิ่งที่จะเรียกว่าแนวทางไมโครเคอร์เนล

ระบบปฏิบัติการแบ่งเวลา

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

การพัฒนาระบบการแบ่งปันเวลาทำให้เกิดปัญหาหลายประการ หนึ่งคือผู้ใช้ โดยเฉพาะอย่างยิ่งในมหาวิทยาลัยที่มีการพัฒนาระบบ ดูเหมือนจะต้องการแฮ็คระบบเพื่อให้ได้เวลาCPUมากขึ้นด้วยเหตุผลนี้ การรักษาความปลอดภัยและการควบคุมการเข้าถึงจึงกลายเป็นจุดสนใจหลักของโครงการMulticsในปี 1965 [44]ปัญหาต่อเนื่องอีกประการหนึ่งคือการจัดการทรัพยากรการประมวลผลอย่างเหมาะสม: ผู้ใช้ใช้เวลาส่วนใหญ่จ้องมองที่เทอร์มินัลและคิดว่าจะป้อนข้อมูลอะไรแทน โดยใช้ทรัพยากรของคอมพิวเตอร์ และระบบแบ่งเวลาควรให้เวลา CPU แก่ผู้ใช้ที่ใช้งานอยู่ในช่วงเวลาเหล่านี้ ในที่สุด ระบบมักจะเสนอลำดับชั้นของหน่วยความจำลึกหลายชั้น และการแบ่งพาร์ติชั่นทรัพยากรราคาแพงนี้นำไปสู่การพัฒนาที่สำคัญในระบบ หน่วยความจำเสมือน

เอมิกา

พลเรือจัตวา เอมิได้รับการปล่อยตัวในปี 1985 และเป็นหนึ่งในคนแรก - และแน่นอนที่ประสบความสำเร็จมากที่สุด - เครื่องคอมพิวเตอร์ที่บ้านจะมีสถาปัตยกรรมเคอร์เนลขั้นสูง exec.libraryคอมโพเนนต์สำหรับผู้บริหารของเคอร์เนล AmigaOS ใช้การออกแบบการส่งข้อความผ่านไมโครเคอร์เนล แต่มีส่วนประกอบเคอร์เนลอื่นๆ เช่นgraphics.libraryที่เข้าถึงฮาร์ดแวร์ได้โดยตรง ไม่มีการป้องกันหน่วยความจำ และเคอร์เนลทำงานในโหมดผู้ใช้เกือบตลอดเวลา การดำเนินการพิเศษเท่านั้นที่จะดำเนินการในโหมดเคอร์เนล และแอปพลิเคชันโหมดผู้ใช้สามารถขอให้ระบบปฏิบัติการรันโค้ดในโหมดเคอร์เนลได้

ยูนิกซ์

แผนภาพของความสัมพันธ์ในครอบครัวบรรพบุรุษ / ทายาทสำหรับUnix เหมือนระบบ

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

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

ในรุ่น Unix ระบบปฏิบัติการประกอบด้วยสองส่วน: อันดับแรก ชุดโปรแกรมอรรถประโยชน์ขนาดใหญ่ที่ขับเคลื่อนการทำงานส่วนใหญ่ ประการที่สอง เคอร์เนลที่รันโปรแกรม[45]ภายใต้ Unix จากมุมมองของการเขียนโปรแกรม ความแตกต่างระหว่างทั้งสองนั้นค่อนข้างบาง เคอร์เนลเป็นโปรแกรมที่ทำงานในโหมดผู้ดูแล[46]ซึ่งทำหน้าที่เป็นตัวโหลดโปรแกรมและตัวควบคุมสำหรับโปรแกรมยูทิลิตี้ขนาดเล็กที่ประกอบขึ้นเป็นส่วนที่เหลือของระบบ และเพื่อให้บริการล็อคและI/Oสำหรับโปรแกรมเหล่านี้ ยิ่งไปกว่านั้น เคอร์เนลไม่ได้เข้าไปแทรกแซงในuser spaceเลย

ตลอดหลายปีที่ผ่านมา โมเดลการคำนวณของ Unix เปลี่ยนไป และการปฏิบัติต่อทุกอย่างของ Unix เป็นไฟล์หรือไบต์สตรีมนั้นไม่สามารถใช้งานได้ในระดับสากลอย่างที่เคยเป็นมา แม้ว่าเทอร์มินัลจะถือว่าเป็นไฟล์หรือไบต์สตรีม ซึ่งพิมพ์หรืออ่านจากส่วนต่อประสานกราฟิกกับผู้ใช้ก็ตามระบบเครือข่ายมีปัญหาอื่น แม้ว่าการสื่อสารในเครือข่ายสามารถเปรียบเทียบได้กับการเข้าถึงไฟล์ แต่สถาปัตยกรรมระดับต่ำที่เน้นแพ็กเก็ตจะจัดการกับกลุ่มข้อมูลที่ไม่ต่อเนื่องและไม่ใช่กับไฟล์ทั้งหมด เมื่อความสามารถของคอมพิวเตอร์เติบโตขึ้น Unix ก็มีความยุ่งเหยิงมากขึ้นด้วยโค้ด นอกจากนี้ยังเป็นเพราะโมดูลของเคอร์เนล Unix สามารถปรับขนาดได้อย่างกว้างขวาง[47]ในขณะที่เมล็ดอาจมีรหัส 100,000 บรรทัดในอายุเจ็ดสิบและแปดสิบ แต่เมล็ดเช่นLinuxของผู้สืบทอด Unix ที่ทันสมัยเช่นGNUมีมากกว่า 13 ล้านบรรทัด[48]

อนุพันธ์ Unix สมัยใหม่โดยทั่วไปจะขึ้นอยู่กับโมดูลที่โหลดเมล็ดเสาหิน ตัวอย่างของเรื่องนี้เป็นเคอร์เนลในหลายกระจายของGNU , IBM AIX , เช่นเดียวกับการจัดจำหน่ายซอฟแวร์เบิร์กลีย์ตัวแปรเมล็ดเช่นFreeBSD , DragonflyBSD , OpenBSD , NetBSDและMacOS นอกเหนือจากทางเลือกเหล่านี้ นักพัฒนามือสมัครเล่นยังคงรักษาชุมชนการพัฒนาระบบปฏิบัติการที่ใช้งานอยู่สร้างขึ้นโดยเมล็ดงานอดิเรกที่เขียนเองซึ่งส่วนใหญ่จบลงด้วยการแบ่งปันคุณสมบัติมากมายกับเคอร์เนล Linux, FreeBSD, DragonflyBSD, OpenBSD หรือ NetBSD และ/หรือเข้ากันได้กับพวกเขา [49]

Mac OS

แอปเปิ้ลเปิดตัวครั้งแรกของมันคลาสสิก Mac OSในปี 1984 พร้อมกับของMacintosh เครื่องคอมพิวเตอร์ส่วนบุคคล Apple ย้ายไปใช้การออกแบบนาโนเคอร์เนลใน Mac OS 8.6 ต่อนี้ทันสมัยMacOS (เดิมชื่อ Mac OS X) จะขึ้นอยู่กับดาร์วินซึ่งใช้เคอร์เนลไฮบริดที่เรียกว่าXNUซึ่งถูกสร้างขึ้นโดยการรวม4.3BSDเคอร์เนลและเคอร์เนล Mach [50]

ไมโครซอฟต์วินโดวส์

Microsoft Windowsได้รับการเปิดตัวครั้งแรกในปี 1985 ในฐานะที่เป็น add-on MS-DOSเนื่องจากต้องอาศัยระบบปฏิบัติการอื่น Windows รุ่นแรกก่อน Windows 95 จึงถูกพิจารณาว่าเป็นสภาพแวดล้อมการทำงาน (เพื่อไม่ให้สับสนกับระบบปฏิบัติการ ) กลุ่มผลิตภัณฑ์นี้ยังคงพัฒนาอย่างต่อเนื่องตลอดช่วงทศวรรษ 1980 และ 1990 โดยซีรีส์Windows 9x ได้เพิ่มแอดเดรส 32 บิตและมัลติทาสกิ้งล่วงหน้า แต่จบลงด้วยการเปิดตัวWindows Meในปี 2000

Microsoft ยังพัฒนาWindows NTซึ่งเป็นระบบปฏิบัติการที่มีอินเทอร์เฟซคล้ายกันมาก แต่มีไว้สำหรับผู้ใช้ระดับไฮเอนด์และระดับธุรกิจ บรรทัดนี้เริ่มต้นด้วยการเปิดตัวWindows NT 3.1ในปี 1993 และได้รับการแนะนำให้รู้จักกับผู้ใช้ทั่วไปด้วยการเปิดตัวWindows XPในเดือนตุลาคม 2544 โดยแทนที่Windows 9xด้วยระบบปฏิบัติการที่แตกต่างอย่างสิ้นเชิงและซับซ้อนกว่ามาก นี่คือเส้นที่ยังคงมีการใช้ Windows 11

สถาปัตยกรรมของ Windows NTเคอร์เนล 's ถือว่าเป็นไฮบริดเพราะเคอร์เนลเคอร์เนลตัวเองมีงานดังกล่าวในฐานะผู้จัดการหน้าต่างและผู้จัดการ IPC กับลูกค้า / เซิร์ฟเวอร์ชั้นรูปแบบระบบย่อย [51]ได้รับการออกแบบให้เป็นmicrokernel ที่ดัดแปลงเนื่องจากเคอร์เนล Windows NT ได้รับอิทธิพลจากMach microkernelแต่ไม่ตรงตามเกณฑ์ทั้งหมดของ microkernel บริสุทธิ์

หัวหน้างาน IBM

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

ประวัติศาสตร์ในระยะนี้เป็นหลักที่เกี่ยวข้องกับIBMเส้น 'ของเมนเฟรมระบบปฏิบัติการที่เริ่มต้นด้วยOS / 360 ในระบบปฏิบัติการอื่น ๆ หัวหน้างานจะเรียกว่าเคอร์เนล

ในปี 1970 IBM ได้แยกสถานะหัวหน้างานออกจากฮาร์ดแวร์ ส่งผลให้เกิดไฮเปอร์ไวเซอร์ที่เปิดใช้งานการจำลองเสมือนเต็มรูปแบบกล่าวคือ ความสามารถในการเรียกใช้ระบบปฏิบัติการหลายระบบบนเครื่องเดียวกันโดยอิสระจากกันโดยสิ้นเชิง ดังนั้นครั้งแรกที่ระบบดังกล่าวถูกเรียกว่าเครื่องเสมือนหรือVM

การพัฒนาไมโครเคอร์เนล

แม้ว่าMach ที่พัฒนาโดยRichard RashidจากCarnegie Mellon Universityจะเป็น microkernel อเนกประสงค์ที่รู้จักกันดีที่สุด แต่ microkernels อื่นๆ ได้รับการพัฒนาโดยมีเป้าหมายเฉพาะเจาะจงมากขึ้น ตระกูลL4 microkernel (ส่วนใหญ่เป็น L3 และ L4 kernel) ถูกสร้างขึ้นเพื่อแสดงให้เห็นว่า microkernels ไม่จำเป็นต้องช้า[52]การใช้งานที่ใหม่กว่า เช่นFiascoและPistachioสามารถเรียกใช้Linuxถัดจากกระบวนการ L4 อื่นๆ ในพื้นที่ที่อยู่แยกต่างหาก[53] [54]

นอกจากนี้QNXเป็น microkernel ที่ใช้หลักในระบบฝังตัว , [55]และซอฟต์แวร์โอเพ่นซอร์ส มินิกซ์ในขณะที่สร้างขึ้นมาเพื่อการศึกษาจะเน้นในขณะนี้เมื่อเป็นความน่าเชื่อถือสูงและรักษาตนเอง microkernel OS

ดูเพิ่มเติม

หมายเหตุ

  1. ^ อาจขึ้นอยู่กับสถาปัตยกรรมคอมพิวเตอร์
  1. ^ a b "เคอร์เนล" . Linfo กลุ่มผู้ใช้แบลลินุกซ์ สืบค้นเมื่อ15 กันยายน 2559 .
  2. ^ Randal อีไบรอันท์; เดวิด อาร์. โอฮาลลารอน (2016). ระบบคอมพิวเตอร์: มุมมองของโปรแกรมเมอร์ (Third ed.). เพียร์สัน NS. 17. ISBN 978-0134092669.
  3. ^ cf เลย ภูต (คอมพิวเตอร์)
  4. ^ a b Roch 2004
  5. ^ กรัม Wulf 1974 pp.337-345
  6. ^ Silberschatz 1991
  7. ^ Tanenbaum, แอนดรูว์ เอส. (2008) ระบบปฏิบัติการสมัยใหม่ (ฉบับที่ 3) ศิษย์ฮอลล์. น. 50–51. ISBN 978-0-13-600663-3. . . . การเรียกระบบเกือบทั้งหมด [ถูก] เรียกใช้จากโปรแกรม C โดยการเรียกโพรซีเดอร์ไลบรารี . . ขั้นตอนของห้องสมุด . . ดำเนินการคำสั่ง TRAP เพื่อเปลี่ยนจากโหมดผู้ใช้เป็นโหมดเคอร์เนล และเริ่มดำเนินการ . .
  8. ^ เดนนิ่ง 1976
  9. ^ Swift 2005, p.29 quote: "การแยกตัว การควบคุมทรัพยากร การตรวจสอบการตัดสินใจ (การตรวจสอบ) และการกู้คืนข้อผิดพลาด"
  10. ^ ชโรเดอร์ 72
  11. ^ a b ลินเดน 76
  12. ^ Stephane Eranian และ David Mosberger, Virtual Memory ใน IA-64 Linux Kernel , Prentice Hall PTR, 2002
  13. ^ Silberschatz & Galvin, แนวคิดระบบปฏิบัติการ, ฉบับที่ 4, หน้า 445 & 446
  14. ^ Hoch ชาร์ลส์; เจซี บราวน์ (กรกฎาคม 2523) "การดำเนินการตามความสามารถของ PDP-11/45" ACM SIGOPS รีวิวระบบปฏิบัติการ 14 (3): 22–32. ดอย : 10.1145/850697.850701 . S2CID 17487360 . 
  15. a b A Language-Based Approach to Security , Schneider F., Morrissett G. (Cornell University) และ Harper R. (Carnegie Mellon University)
  16. ^ พีเอ Loscocco, SD สมอ, PA Muckelbauer, RC เทย์เลอร์, SJ อร์เนอร์และเจเอฟแฟร์เรลล์หลีกเลี่ยงไม่ได้ของความล้มเหลวที่: อัสสัมชัข้อบกพร่องของการรักษาความปลอดภัยในโมเดิร์นคอมพิวเตอร์สภาพแวดล้อม ที่จัดเก็บ 2007/06/21 ที่เครื่อง Waybackในการดำเนินการของ 21 การประชุมระบบสารสนเทศความมั่นคงแห่งชาติ, หน้า 303-314 ตุลาคม 1998 [1]
  17. ^ ภูตผีปีศาจ เจ; ฟอร์ด, ไบรอัน; ฮิบเลอร์, ไมค์ (1996). "ความเกี่ยวข้องอย่างต่อเนื่องของระบบปฏิบัติการในพื้นที่กับแอปพลิเคชันทั่วโลก" การดำเนินการของการประชุมเชิงปฏิบัติการครั้งที่ 7 ในการสนับสนุน ACM SIGOPS ระบบการประชุมเชิงปฏิบัติการในยุโรปสำหรับการใช้งานทั่วโลก - EW 7 NS. 133. ดอย : 10.1145/504450.504477 . S2CID 10027108 . 
  18. J. Anderson, Computer Security Technology Planning Study Archived 2011-07-21 at the Wayback Machine , Air Force Elect. แผนกระบบ ESD-TR-73-51 ตุลาคม 2515
  19. ^ *เจอร์รี่ เอช. ซอลท์เซอร์; ไมค์ ดี. ชโรเดอร์ (กันยายน 2518) "การปกป้องข้อมูลในระบบคอมพิวเตอร์" . การดำเนินการของ IEEE 63 (9): 1278–1308. CiteSeerX 10.1.1.126.9257 . ดอย : 10.1109/PROC.1975.9939 . S2CID 269166 .  
  20. โจนาธาน เอส. ชาปิโร; โจนาธาน เอ็ม. สมิธ; เดวิด เจ. ฟาร์เบอร์ (1999). "EROS: ระบบความสามารถที่รวดเร็ว" การดำเนินการของสิบเจ็ด ACM ประชุมวิชาการเกี่ยวกับระบบปฏิบัติการหลักการ 33 (5): 170–185. ดอย : 10.1145/319344.319163 .
  21. ^ Dijkstra, EWกระบวนการให้ความร่วมมือต่อเนื่อง คณิตศาสตร์. Dep., Technological U., Eindhoven, กันยายน 1965.
  22. ^ Brinch แฮนเซน 70 pp.238-241
  23. ^ แฮร์ริสัน เอ็มซี; ชวาร์ตษ์, เจที (1967). "SHARER เป็นระบบที่ใช้ร่วมกันเวลาสำหรับ CDC 6600" การติดต่อสื่อสารของพลอากาศเอก 10 (10): 659–665 ดอย : 10.1145/363717.363778 . S2CID 14550794 . ที่ดึง 2007/01/07 
  24. ^ Huxtable, DHR; วอริก, มอนแทนา (1967). แบบไดนามิกผู้บังคับบัญชา - การออกแบบและก่อสร้างของพวกเขา หน้า 11.1–11.17. ดอย : 10.1145/800001.811675 . ISBN 9781450373708. S2CID  17709902 . ที่ดึง 2007/01/07
  25. ^ Baiardi 1988
  26. ^ เลวิน 75
  27. ^ เดนนิ่ง 1980
  28. ^ Jürgen Nehmer " ? อมตะของระบบปฏิบัติการหรือการวิจัยอยู่ในระบบปฏิบัติการยังคงธรรม "บรรยายในวิทยาการคอมพิวเตอร์ ; ฉบับที่ 563. การดำเนินการของการประชุมเชิงปฏิบัติการระหว่างประเทศว่าด้วยระบบปฏิบัติการในยุค 90 และหลังจากนั้น หน้า 77–83 (1991) ISBN 3-540-54987-0 [2]อ้าง: " 25 ปีที่ผ่านมาแสดงให้เห็นว่าการวิจัยเกี่ยวกับสถาปัตยกรรมระบบปฏิบัติการมีผลกระทบเล็กน้อยต่อระบบกระแสหลักที่มีอยู่ [ sic ] " 
  29. ^ Levy 84, p.1 quote: "แม้ว่าความซับซ้อนของแอปพลิเคชันคอมพิวเตอร์จะเพิ่มขึ้นทุกปี แต่สถาปัตยกรรมฮาร์ดแวร์พื้นฐานสำหรับแอปพลิเคชันยังคงไม่เปลี่ยนแปลงมานานหลายทศวรรษ"
  30. ^ a b c Levy 84, p.1 quote: "สถาปัตยกรรมทั่วไปสนับสนุนโหมดการทำงานที่มีสิทธิพิเศษเดียว โครงสร้างนี้นำไปสู่การออกแบบแบบเสาหิน โมดูลใด ๆ ที่ต้องการการป้องกันจะต้องเป็นส่วนหนึ่งของเคอร์เนลระบบปฏิบัติการเดี่ยว แทน โมดูลใด ๆ สามารถดำเนินการภายในโดเมนที่ได้รับการป้องกัน ระบบสามารถสร้างเป็นชุดของโมดูลอิสระที่ผู้ใช้ทุกคนสามารถขยายได้"
  31. ^ "โอเพ่นซอร์ส: เสียงจากการปฏิวัติโอเพ่นซอร์ส" . 1-56592-582-3 . 29 มีนาคม 2542
  32. ^ การระบุที่อยู่เสมือนทำได้โดยทั่วไปผ่านหน่วยจัดการหน่วยความจำในตัว
  33. ^ บันทึกการอภิปรายระหว่าง Torvalds และ Tanenbaum สามารถพบได้ที่ dina.dk Archived 2012-10-03 ที่ Wayback Machine , groups.google.com , oreilly.comและเว็บไซต์ของ Andrew Tanenbaum
  34. ^ แมทธิว รัสเซลล์. "ดาร์วินคืออะไร (และขับเคลื่อน Mac OS X อย่างไร)" . โอเรลลี่ มีเดีย . อ้าง: "ลักษณะที่แน่นแฟ้นของเคอร์เนลเสาหินช่วยให้สามารถใช้ฮาร์ดแวร์พื้นฐานได้อย่างมีประสิทธิภาพ [... ] ในทางกลับกัน Microkernels เรียกใช้กระบวนการหลักใน userland มากขึ้น [... ] น่าเสียดาย ประโยชน์เหล่านี้ทำให้ microkernel เสียค่าใช้จ่ายในการส่งข้อมูลจำนวนมากเข้าและออกจากพื้นที่เคอร์เนลผ่านกระบวนการที่เรียกว่า Context Switch การสลับบริบททำให้เกิดโอเวอร์เฮดมาก ดังนั้นจึงส่งผลให้ประสิทธิภาพลดลง"
  35. ^ "ระบบปฏิบัติการ/โมเดลเคอร์เนล - Wikiversity" . th.wikiversity.org .
  36. อรรถเป็น c d Liedtke 95
  37. ^ Härtig 97
  38. ^ Hansen 73 มาตรา 7.3 p.233 "การโต้ตอบระหว่างระดับการป้องกันต่างๆ จำเป็นต้องมีการส่งข้อความตามค่า "
  39. ^ มากี, จิม. WWDC 2000 เซสชัน 106 – Mac OS X: เคอร์เนล . เข้า 14 นาที
  40. ^ KeyKOS Nanokernel Architecture Archived 2011-06-21 ที่ Wayback Machine
  41. ^ Ball: การออกแบบไมโครโปรเซสเซอร์แบบฝัง, พี. 129
  42. ^ Hansen 2001 (os), pp.17–18
  43. ^ "รุ่น BSTJ กระดาษ C.ACM ยูนิกซ์" bell-labs.com
  44. ^ บทนำและภาพรวมของระบบ Multicsโดย FJ Corbató และ VA Vissotsky
  45. ^ a b "The Single Unix Specification" . กลุ่มเปิด . เก็บถาวรจากต้นฉบับเมื่อ 2016-10-04 . สืบค้นเมื่อ 2016-09-29 .
  46. ^ ระดับสิทธิพิเศษสูงสุดมีชื่อต่าง ๆ ตลอดทั้งสถาปัตยกรรมที่แตกต่างกันเช่นโหมดผู้บังคับบัญชาโหมดเคอร์เนล, CPL0, DPL0 แหวน 0, ฯลฯ ดูแหวน (รักษาความปลอดภัยคอมพิวเตอร์)สำหรับข้อมูลเพิ่มเติม
  47. ^ "การแก้แค้นของ Unix" . asymco.com . 29 กันยายน 2553
  48. ^ Linux Kernel 2.6: คุ้มยิ่งกว่าคุ้ม! , โดย David A. Wheeler, 12 ตุลาคม 2547
  49. ^ ชุมชนนี้ส่วนใหญ่รวมตัวกันที่ Bona Fide OS Development , The Mega-Tokyo Message Boardและเว็บไซต์ผู้ที่ชื่นชอบระบบปฏิบัติการอื่นๆ
  50. ^ XNU: The Kernel Archived 2011-08-12 ที่ Wayback Machine
  51. ^ "Windows - เว็บไซต์อย่างเป็นทางการสำหรับระบบปฏิบัติการ Microsoft Windows 10 Home & Pro, แล็ปท็อป, พีซี, แท็บเล็ต และอื่นๆ" . windows.com .
  52. ^ "ตระกูล L4 microkernel - ภาพรวม" . os.inf.tu-เดรสเดน . de
  53. ^ "ไมโครเคอร์เนล Fiasco - ภาพรวม" . os.inf.tu-เดรสเดน . de
  54. ^ Zoller (inaktiv), ไฮนซ์ (7 ธันวาคม 2013) "โครงการ L4Ka - L4Ka" . www.l4ka.org .
  55. ^ "ระบบปฏิบัติการ QNX" . blackberry.qnx.comครับ

อ้างอิง

อ่านเพิ่มเติม

ลิงค์ภายนอก