ฉันจะสร้างระบบปฏิบัติการขนาดเล็กบนคอมพิวเตอร์เดสก์ท็อปรุ่นเก่าได้อย่างไร [ปิด]

สิ่งนี้อาจไร้ผลเนื่องจากฉันรู้ว่าการเขียนระบบปฏิบัติการนั้นซับซ้อนเหลือทน (โดยเฉพาะด้วยตัวเอง)

• ฉันไม่คาดหวังว่าจะสร้าง linux หรือ windows ตัวถัดไป

• ฉันรู้ว่ามันจะแย่และเป็นรถที่ใช้งานไม่ได้ แต่ก็ไม่เป็นไร

ผมอยากจะเขียนทุกอย่างเองในสภา , Cและ (พอใช้) C ++

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

ฉันต้องการตั้งค่าเดสก์ท็อปรุ่นเก่าด้วยจอภาพแป้นพิมพ์และเมาส์และเริ่มทำงานกับฮาร์ดไดรฟ์เปล่า

ฉันต้องการเรียนรู้วิธีเขียนโปรแกรมโหลดบูตของตัวเอง (ฉันพบแหล่งข้อมูลมากมายเกี่ยวกับเรื่องนี้ แต่เพื่อความสมบูรณ์โปรดยังคงเพิ่มสิ่งที่ดี) ไดรเวอร์ USB ของฉันเอง (ถ้าจำเป็น) ไดรเวอร์ซีดี (หากจำเป็น ) ฯลฯ ทุกอย่างตั้งแต่ต้นจนจบ

• ฉันจะใส่รหัสลงในคอมพิวเตอร์ได้อย่างไร? จะดีที่สุดถ้าทำด้วยฟล็อปปี้ดิสก์? คอมพิวเตอร์ส่วนใหญ่สามารถทำได้จากแท่ง USB หรือไม่?

• ฉันต้องการไดรเวอร์อะไรและคุณสามารถแนะนำข้อมูลอ้างอิงเพื่อสร้างสิ่งเหล่านี้ได้หรือไม่?

• หลังจากลำดับการบูต - แล้วอะไรล่ะ? ฉันจะเข้าสู่โหมดป้องกันได้อย่างไร ฯลฯ

• ฉันจะจัดการหน่วยความจำโดยไม่ต้องใช้ระบบปฏิบัติการได้อย่างไร? ฉันแค่ใช้ที่อยู่ที่ฉันต้องการหรือไม่? ไม่จำเป็นต้องเริ่มต้น?

• สิ่งที่ฉันต้องเผชิญอย่างไม่ต้องสงสัยที่จะทำให้ฉันสับสน?

• ฉันจะทำให้เป็นบรรทัดคำสั่ง O / S และแบบกราฟิกได้อย่างไร

• O / S แบบกราฟิกสร้างขึ้นบนอะไร? เช่นฉันจะทำอะไรเช่นบรรทัดคำสั่งพร้อมแบบอักษรและรูปภาพที่ด้านบน

• ฉันจะอ่านเกี่ยวกับการตั้งค่าสภาพแวดล้อมมัลติทาสก์ได้ที่ไหน (กล่าวคือมีบรรทัดคำสั่งเหมือนกราฟิกสองบรรทัดทำงานเคียงข้างกัน)

• ฉันจะตั้งค่าระบบหน้าต่างได้อย่างไร? ฉันจะแสดงกราฟิกบนหน้าจอได้อย่างไรเมื่อตั้งค่ามัลติทาสก์อย่างง่าย

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

มีชิ้นส่วนอื่น ๆ อีกมากมายในเรื่องนี้ที่ฉันไม่ได้กล่าวถึงหากคุณคิดว่ามีก็อย่าลังเลที่จะเพิ่มสิ่งเหล่านั้นด้วย

โปรดใส่ "หัวข้อ" 1 หัวข้อต่อคำตอบตัวอย่างเช่นไดรเวอร์ USB จากนั้นอาจเป็นรายการทรัพยากรสิ่งที่ต้องระวัง ฯลฯ

นอกจากนี้โปรดอย่าแนะนำให้สร้าง O / S อื่นหรือรหัสที่มีอยู่แล้ว ฉันรู้ว่าฉันจะอ่านโค้ดที่มีอยู่แล้วจำนวนมาก (เช่นเคอร์เนลลินุกซ์หรือทรัพยากรตัวอย่างไดรเวอร์ที่มีอยู่ ฯลฯ ) แต่ท้ายที่สุดฉันต้องการเขียนทั้งหมดด้วยตัวเอง ฉันรู้ว่าฉันควรสร้างจากอย่างอื่นและมีคำถามอื่น ๆ อีกมากมายเกี่ยวกับ SO เกี่ยวกับเรื่องนี้ที่ฉันสามารถอ่านได้หากฉันเปลี่ยนใจและไปเส้นทางนั้น แต่อันนี้เกี่ยวกับการทำทั้งหมดตั้งแต่เริ่มต้น

ข้อเสนอแนะใด ๆ เกี่ยวกับวิธีทำให้เป็นกราฟิก? โหมดวิดีโอที่แตกต่างกันและวิธีการใช้งาน ฯลฯ ?

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

หยิบหนังสือเกี่ยวกับระบบปฏิบัติการของ Andrew Tanenbaum มาหนึ่งเล่ม นี่คือสิ่งที่เราใช้ในคลาส OS ของฉันในวิทยาลัย:

PDF ระบบปฏิบัติการที่ทันสมัย

ระบบปฏิบัติการที่ทันสมัยใน Amazon

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

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

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

หากคุณมีความรู้ด้านอิเล็กทรอนิกส์อาจจะง่ายกว่าที่จะเริ่มต้นด้วยการเขียนระบบปฏิบัติการสำหรับอุปกรณ์ฝังตัวที่มีเอกสารเพียงพอเพราะโดยทั่วไปแล้วจะง่ายกว่าพีซี x86 ฉันอยากเขียนระบบปฏิบัติการของตัวเองมาโดยตลอดและฉันเริ่มต้นด้วยการเขียนระบบปฏิบัติการฝังไมโครเคอร์เนลสำหรับบอร์ดพัฒนานี้จาก Digilent สามารถเรียกใช้โปรเซสเซอร์ MicroBlaze แบบซอฟต์คอร์จาก Xilinx ซึ่งมีเอกสารที่ละเอียดมาก นอกจากนี้ยังมี RAM ที่เก็บข้อมูลแฟลช LED สวิตช์ปุ่มเอาต์พุต VGA และอื่น ๆ อีกมากมายให้เล่นกับการเขียนไดรเวอร์ง่ายๆสำหรับ

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

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

http://www.osdev.org/ และ http://www.osdever.net/

ยินดีต้อนรับสู่โลกแห่งการพัฒนาระบบปฏิบัติการ

ดูลิงก์เอกสาร x86 อื่น ๆ ใน SO's x86 tag wiki : คู่มือ Intel และ AMD เอกสารคอมไพเลอร์ / แอสเซมเบลอร์และคำแนะนำต่างๆ

นอกจากนี้ยังแนะนำให้ใช้ BOCHS หรือสภาพแวดล้อมเสมือนอื่น ๆ สำหรับการดีบักเนื่องจากคุณสามารถทำขั้นตอนเดียว bootloader และตรวจสอบการลงทะเบียน

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

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

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

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

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

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

จากตรงนั้นคุณควรจะสามารถใช้งานฟีเจอร์ที่ซับซ้อนกว่านี้ได้ จากฐานนี้คุณสามารถเขียนและรวบรวม "เคอร์เนล" ใหม่ ... รีบูตเครื่องทดสอบของคุณและนำเคอร์เนลใหม่ไปใช้งาน

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

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

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

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

หากคุณไม่สนใจที่จะใช้การจำลองเสมือนของฮาร์ดแวร์มีหลักสูตร (หนังสือ + การบรรยาย + ซอฟต์แวร์) ที่จะพาคุณ 'From Nand to Tetris' คุณสร้างระบบคอมพิวเตอร์เต็มรูปแบบด้วยตัวคุณเองจากประตู NAND ไฟฟ้า (เพื่อวัตถุประสงค์เหล่านี้และกำหนดให้) ไปจนถึงการสร้างระบบปฏิบัติการภาษาและในที่สุดก็เข้ารหัสเกมง่ายๆบนเครื่องส่วนตัวของคุณ

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

ลิงค์: http://www1.idc.ac.il/tecs/

ฉันจะเริ่มต้นเล็ก ๆ และซื้อชุดพัฒนาฝังตัว 8086 และพัฒนาระบบปฏิบัติการมัลติทาสก์ เมื่อคุณมีเคอร์เนลและคุ้นเคยกับการทำงานในระดับฮาร์ดแวร์แล้วคุณก็พร้อมที่จะทำสิ่งที่ท้าทายมากขึ้น

การสร้างแม้แต่โคลน DOS ที่แสดงผล VGA ก็เป็นสิ่งที่ท้าทายพอสมควร รายละเอียดมีมากมายมหาศาล :-)

หัวข้อเฉพาะ

ฉันจะใส่รหัสลงในคอมพิวเตอร์ได้อย่างไร? จะดีที่สุดถ้าทำด้วยฟล็อปปี้ดิสก์? คอมพิวเตอร์ส่วนใหญ่สามารถทำได้จากแท่ง USB หรือไม่?

BIOS จะทำการบูตเบื้องต้น

ฉันต้องการไดรเวอร์อะไรและคุณสามารถแนะนำข้อมูลอ้างอิงเพื่อสร้างสิ่งเหล่านี้ได้หรือไม่?

อะไรก็ตามที่ไม่ใช่การทำงานของ cpu / หน่วยความจำโดยตรง สิ่งที่ไม่ได้อยู่ในคู่มืออ้างอิง CPU โดยตรง

หลังจากลำดับการบูต - แล้วอะไรล่ะ? ฉันจะเข้าสู่โหมดป้องกันได้อย่างไร ฯลฯ

โหมดป้องกันจะเป็นส่วนหนึ่งของลำดับการบูต

จากนั้นคุณจะเริ่มทำงานหลายอย่างพร้อมกันและหาวิธีเริ่มกระบวนการต่างๆ

ฉันจะจัดการหน่วยความจำโดยไม่ต้องใช้ระบบปฏิบัติการได้อย่างไร? ฉันแค่ใช้ที่อยู่ที่ฉันต้องการหรือไม่? ไม่จำเป็นต้องเริ่มต้น?

แก้ไข. คุณอาจต้องการแยกระบบหน่วยความจำเสมือนในที่สุด

สิ่งที่ฉันต้องเผชิญอย่างไม่ต้องสงสัยที่จะทำให้ฉันสับสน?

ไม่มีเครื่องมือดีบักไม่มี IO

ฉันจะทำให้เป็นบรรทัดคำสั่ง O / S และแบบกราฟิกได้อย่างไร

ด้วยความเศร้าโศก. ค้นหา Windows 3.1 และ Linux โดยเฉพาะ X windows

O / S แบบกราฟิกสร้างขึ้นบนอะไร? เช่นฉันจะทำอะไรเช่นบรรทัดคำสั่งพร้อมแบบอักษรและรูปภาพที่ด้านบน

ค้นหาหน้าต่าง X

คำแนะนำสุดท้าย: ศึกษา linux / x windows มันไม่ได้สมบูรณ์แบบ แต่ก็มีความเข้าใจในหนึ่งวิธี ศึกษาระบบฝังตัวด้วย

ฉันเห็นการอ้างอิงที่ดีมากมายเกี่ยวกับไซต์การพัฒนาระบบปฏิบัติการดังนั้นฉันจะอธิบายวิธีการอื่น:

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

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

ดูการบูตเครื่อง ARM หรือชิป "ฝังตัว" แบบ 32 บิตอื่น ๆ มีบอร์ดพัฒนาราคาไม่แพงหรือคุณสามารถบัดกรีเองก็ได้! บางรุ่นมีอีเธอร์เน็ตและยูเอสบีในตัว ฉันคิดว่าคุณจะสนุกมากขึ้นในการทำงานกับสถาปัตยกรรมที่มีสติและไม่ดื้อรั้นและอาจจบลงด้วยทักษะที่สามารถใช้ซ้ำได้

ยิ่งกว่าสิ่งอื่นใดหากคุณต้องการให้สิ่งนี้ทำงานบนฮาร์ดแวร์จริงคุณจำเป็นต้องมีสำเนาคู่มือโปรเซสเซอร์ของคุณ คู่มือ Intel ( http://www.intel.com/products/processor/manuals/ ) เป็นสิ่งล้ำค่า พวกเขาทำทุกอย่างตั้งแต่โหมดการสลับ (จริง / ป้องกัน) ไปจนถึงการจัดการหน่วยความจำเสมือน (ถ้าคุณเลือกที่จะไปไกลขนาดนั้น) ไปจนถึงการสร้าง syscalls (ถ้าคุณเคยทำโหมดผู้ใช้) สิ่งสำคัญที่สุดคือพวกเขาอธิบายรายละเอียดอย่างละเอียดเกี่ยวกับสิ่งต่างๆที่ต้องตั้งค่าเพื่อให้ทำงานได้เช่น TSS และการลงทะเบียนเซ็กเมนต์ที่ข้อความระบบปฏิบัติการส่วนใหญ่ไม่ได้พูดถึงเพราะพวกเขาเกี่ยวข้องกับแนวคิดระดับสูงกว่าโปรเซสเซอร์ - รายละเอียดเฉพาะ

ชุดพัฒนา OS @ BrokenThorn คุณอาจสนใจ

พยายามอ่านโค้ดของ OS โอเพ่นซอร์สพื้นฐานขนาดเล็กเช่น MikeOS

หรือฉันขอแนะนำขั้นตอนต่อไปนี้ (ควรจะสนุก!):

1. เขียนเครื่องเสมือน กำหนดคำแนะนำโปรเซสเซอร์ทั้งหมดของคุณเพื่อให้คุณรู้จักระบบของคุณทั้งภายในและภายนอก เชื่อมต่อกับ SDL สำหรับแป้นพิมพ์เมาส์หน้าจอการเข้าถึงเสียง ทำให้เรียบง่ายเพื่อให้คุณสามารถจัดวางทุกสิ่งในหัวได้ในคราวเดียว ไม่จำเป็นต้องเป็นเครื่องเสมือนที่ทันสมัยเพียงเครื่องเดียวที่สามารถเลียนแบบการทำงานของคอมพิวเตอร์ 'ของจริง' ได้
2. เขียนแอสเซมเบลอร์สำหรับโปรเซสเซอร์ของเครื่องเสมือนของคุณ โปรดจำไว้ว่าแอสเซมเบลอร์นี้ไม่จำเป็นต้องเป็นโปรแกรมที่เขียนด้วยภาษาของเครื่องเสมือน แต่เป็นสิ่งที่สามารถแปลงภาษาแอสเซมบลีของคุณเป็นรหัสเครื่องได้
3. กำหนดรูปแบบที่เรียกใช้งานได้และเขียนตัวเชื่อมโยงอย่างง่าย
4. คุณมีทุกส่วนในการเขียนระบบปฏิบัติการของคุณแล้ว! เขียนเป็นภาษาแอสเซมบลีประกอบเข้าด้วยกัน ... ฯลฯ คุณไม่จำเป็นต้องมีขั้นตอนการบูตที่ยุ่งยากเพียงแค่ให้เครื่องของคุณรันระบบปฏิบัติการของคุณก่อน

ขั้นตอนข้างต้นอาจดูโง่ไปหน่อยสำหรับการเขียน OS ธรรมดา ๆ แต่เดี๋ยวก่อนมันสนุกมาก

ตรวจสอบMikeOS มันเป็นระบบปฏิบัติการที่ค่อนข้างง่ายที่เขียนขึ้นสามารถอ่านได้ (ตามที่แสดงความคิดเห็น) แม้ว่าจะค่อนข้างเรียบง่าย แต่ก็มี GUI และรองรับเครือข่ายและมัลติมีเดียบางอย่าง

แก้ไข : MenuetOSเป็นแบบกราฟิก มันเขียนตรง asm แต่ซับซ้อนกว่า MikeOS

คุณมีเป้าหมายที่ทะเยอทะยาน แต่การดำเนินการเป็นสิ่งสำคัญ

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

คำแนะนำของฉันคือ: ลดความคาดหวังของคุณและเริ่มต้นด้วยคำถามพื้นฐาน

ระบบปฏิบัติการคืออะไร?

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

ระบบปฏิบัติการไม่ได้เป็นอะไรมากไปกว่าโปรแกรมที่จัดการทรัพยากรฮาร์ดแวร์ของคอมพิวเตอร์: หน่วยความจำ CPU และอุปกรณ์ต่อพ่วง

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

ทำสิ่งนี้บนสถาปัตยกรรมที่ "สะอาด" เช่นโปรเซสเซอร์ ARM แบบฝังที่มีหน่วยความจำ 64K หรือมากกว่านั้น คุณสามารถเขียนโค้ดนี้ในแอสเซมบลีหลังจากไม่กี่วันของการเรียนรู้รายละเอียดของ ARM และvoila! คุณมีระบบปฏิบัติการด้วยตัวเอง

มันทำทุกอย่างที่ระบบปฏิบัติการควรทำ:

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

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

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

ทางเลือกของคุณมีไม่ จำกัด แต่แต่ละอย่างเป็นเพียงก้าวแรกจากที่คุณเคยมีมาก่อน

มันสนุกมากถ้าคุณไม่ตั้งค่าสถานที่ท่องเที่ยวให้สูงเกินไป!

ฉันจะรักษารายการของทรัพยากรใน StackOverflow A: วิธีการเริ่มต้นในการพัฒนาระบบปฏิบัติการ โปรดเพิ่มแหล่งข้อมูลใหม่เมื่อคุณเริ่มต้นการผจญภัย (ฉันกำลังจะเริ่ม :))

โรงเรียนหลายแห่งมีชั้นเรียน OS ที่ทำสิ่งที่คุณอธิบายได้มาก โรงเรียนของฉัน (CMU) สอน OS ในภาษา C และเราเขียนเคอร์เนลระบบไฟล์และเชลล์และได้รับโค้ดสำหรับบูตโหลดเดอร์

น่าเสียดายที่ฉันไม่พบแหล่งข้อมูลที่ชัดเจนสำหรับหลักสูตรนี้ (15-412) บนเว็บและมีการพัฒนาอยู่ตลอดเวลา แต่บางทีผู้คนอาจโพสต์ลิงก์ไปยังแหล่งข้อมูลและการมอบหมายงานสำหรับโรงเรียนที่มีแหล่งข้อมูลที่ดีบนเว็บ

คุณอาจสนุกกับบทช่วยสอนนี้ที่ชื่อว่า "Roll your own toy UNIX-clone OS" ซึ่งมีข้อมูลเชิงลึกมากและน่าจะช่วยคุณได้

โชคดี.

ศึกษาระบบ A2 (เดิมเรียกว่าระบบ Oberon ) เพื่อหาไอเดียที่คุณขโมยได้ เป็นระบบปฏิบัติการแบบกราฟิกที่สร้างขึ้นโดยคนเพียงสองคนแม้ว่าหนึ่งคนจะเป็น Niklaus Wirth ก็ตาม เปิดตัวครั้งแรกเมื่อประมาณปี 1990 และความเร็วก็ดีอย่างน่าอัศจรรย์ มีหนังสือเล่มหนึ่งของ Gutknecht

เกี่ยวกับการเขียนโปรแกรมกราฟิกระดับต่ำนี้จะให้ข้อมูลจำนวนมาก: http://www.osdever.net/FreeVGA/home.htm (มันน่าสนใจมากสำหรับโหมดข้อความเช่นกัน)

สิ่งที่ฉันต้องเผชิญอย่างไม่ต้องสงสัยที่จะทำให้ฉันสับสน?

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

อย่ากังวลกับฟล็อปปี้ดิสก์และส่วนใหญ่แล้วคุณจะใช้โปรแกรมจำลองเช่น Bochs หรือ QEmu

คุณอาจต้องการพิจารณาดูแนวคิดระบบปฏิบัติการโดย Abraham Silberschatz - การทำความเข้าใจแนวคิดการเขียนโปรแกรมระบบเป็นข้อกำหนดพื้นฐานลองดูภายในเคอร์เนล F / OSS ของ OSes linux * BSD และGNU / Linuxโดยเฉพาะเวอร์ชันก่อนหน้าซึ่ง น่าจะเป็นเอกสารอีกเล็กน้อย

ลองดูที่มินิกซ์ ศึกษาซอร์สโค้ดพร้อมกับ " การออกแบบและการใช้งานระบบปฏิบัติการ " พิจารณาให้การสนับสนุนโครงการ ฉันคิดว่า Minix เป็นระบบปฏิบัติการที่ดีและมีแนวโน้มในการสร้าง เป็นโครงการที่ได้รับการสนับสนุนอย่างดี นั่นหมายความว่าคุณอาจได้รับเงินจากการมีส่วนร่วมของคุณด้วยซ้ำ!

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

BIOS จะโหลดเซกเตอร์แรกบนฮาร์ดไดรฟ์และเริ่มรันโค้ดจากที่นั่นดังนั้นระบบปฏิบัติการของคุณจะต้องวางคำสั่งแรกไว้ในเซ็กเตอร์แรกบนฮาร์ดไดรฟ์

บทความ Wikipedia นี้ควรช่วยให้คุณเริ่มต้นใช้งาน BIOS ขัดจังหวะสำหรับการเขียนข้อความไปยังหน้าจอรับปุ่มจากแป้นพิมพ์และสิ่งอื่น ๆ https://en.wikipedia.org/wiki/BIOS_interrupt_call

แม้ว่าคุณวางแผนที่จะใช้ c ++ ฉันขอแนะนำอย่างยิ่งให้อ่านเกี่ยวกับการเขียนโปรแกรมแอสเซมบลีเนื่องจากเป็นสิ่งสำคัญในการทำความเข้าใจว่าฮาร์ดแวร์ทำงานอย่างไร