ผู้ปฏิบัติการต้องใช้เคอร์เนลระบบปฏิบัติการหรือไม่

ฉันรู้ว่าเมื่อซอร์สโค้ดกล่าวคือ C ++ รวบรวมผลลัพธ์จากคอมไพเลอร์คือรหัสเครื่อง (ปฏิบัติการ) ซึ่งฉันคิดว่าเป็นคำสั่งของ CPU โดยตรง เมื่อเร็ว ๆ นี้ฉันได้อ่านข้อมูลเกี่ยวกับเมล็ดและฉันพบว่าโปรแกรมไม่สามารถเข้าถึงฮาร์ดแวร์ได้โดยตรง แต่ต้องผ่านเคอร์เนล

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

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

ในฐานะคนที่เขียนโปรแกรมที่ทำงานโดยไม่มีระบบปฏิบัติการฉันขอเสนอคำตอบที่ชัดเจน

ผู้ปฏิบัติการต้องใช้เคอร์เนลระบบปฏิบัติการหรือไม่

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

อย่างไรก็ตามโปรแกรมทั่วไปที่เขียนและสร้างขึ้นในบางสภาพแวดล้อมระบบปฏิบัติการโฮสต์จะใช้ค่าเริ่มต้นในการดำเนินการในสภาพแวดล้อมระบบปฏิบัติการโฮสต์เดียวกันนั้น
จำเป็นต้องมีการตัดสินใจและการกระทำที่ชัดเจนในการเขียนและสร้างโปรแกรมแบบสแตนด์อโลน

... ผลลัพธ์จากคอมไพเลอร์คือรหัสเครื่อง (ปฏิบัติการ) ซึ่งฉันคิดว่าเป็นคำสั่งของ CPU โดยตรง

แก้ไข.

เมื่อเร็ว ๆ นี้ฉันได้อ่านข้อมูลเกี่ยวกับเมล็ดและฉันพบว่าโปรแกรมไม่สามารถเข้าถึงฮาร์ดแวร์ได้โดยตรง แต่ต้องผ่านเคอร์เนล

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

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

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

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

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

... จะเกิดอะไรขึ้นหลังจากโหลดรหัสเครื่องในหน่วยความจำ

ขึ้นอยู่กับสภาพแวดล้อม

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

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

มันจะผ่านเคอร์เนลหรือคุยกับโปรเซสเซอร์โดยตรงหรือไม่

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

บางทีหัวข้อถัดไปที่คุณควรตรวจสอบเป็นโหมด CPU

เคอร์เนลคือรหัสเพิ่มเติม "เพียง" เป็นเพียงแค่รหัสนั้นเป็นเลเยอร์ที่อยู่ระหว่างส่วนที่ต่ำที่สุดของระบบของคุณและฮาร์ดแวร์จริง

มันทำงานบนซีพียูโดยตรงคุณเพียงแค่เปลี่ยนผ่านเลเยอร์ของมันเพื่อทำอะไร

โปรแกรมของคุณ "ต้องการ" เคอร์เนลในแบบเดียวกับที่มันต้องการไลบรารี C มาตรฐานเพื่อใช้printfคำสั่งตั้งแต่แรก

รหัสที่แท้จริงของโปรแกรมของคุณทำงานบน CPU แต่สาขาที่รหัสทำให้การพิมพ์บางสิ่งบางอย่างบนหน้าจอไปผ่านรหัสสำหรับซีprintfฟังก์ชั่นผ่านระบบอื่น ๆ อีกมากมายและล่ามซึ่งแต่ละทำการประมวลผลของตัวเองที่จะทำงานออกเพียงวิธี hello world!จริง ๆ แล้วพิมพ์บนหน้าจอของคุณ

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

ยังมีอีกมากที่เกิดขึ้น แต่ช่วยให้ง่าย ...

1. ในโปรแกรมเทอร์มินัลคุณเรียกใช้โปรแกรมเพื่อพิมพ์ hello world!
2. เทอร์มินัลเห็นว่าโปรแกรมได้เขียน (ผ่านรูทีนเอาต์พุต C) hello world!ไปยังคอนโซล
3. โปรแกรมเทอร์มินัลขึ้นไปที่ตัวจัดการหน้าต่างเดสก์ท็อปโดยพูดว่า "ฉันhello world!เขียนมาให้ฉันคุณช่วยวางมันไว้ที่ตำแหน่งxได้yมั้ย"
4. ตัวจัดการหน้าต่างเดสก์ท็อปขึ้นไปที่เคอร์เนลด้วย "หนึ่งในโปรแกรมของฉันต้องการให้อุปกรณ์กราฟิกของคุณวางข้อความไว้ที่ตำแหน่งนี้
5. เคอร์เนลส่งคำร้องขอไปยังไดรเวอร์อุปกรณ์กราฟิกซึ่งฟอร์แมตในลักษณะที่การ์ดกราฟิกสามารถเข้าใจได้
6. ขึ้นอยู่กับวิธีการเชื่อมต่อกราฟิกการ์ดไดรเวอร์อุปกรณ์เคอร์เนลอื่น ๆ จะต้องเรียกให้ส่งข้อมูลบนบัสอุปกรณ์ทางกายภาพเช่น PCIe การจัดการสิ่งต่าง ๆ เช่นทำให้แน่ใจว่าเลือกอุปกรณ์ที่ถูกต้องและข้อมูลสามารถผ่านสะพานที่เกี่ยวข้องหรือ แปลง
7. ฮาร์ดแวร์แสดงเนื้อหา

_{นี่เป็นคำอธิบายที่มากเกินไปสำหรับคำอธิบายเท่านั้น นี่คือมังกร}

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

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

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

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

มันถูกจัดการโดยเลเยอร์ตามชั้นของโค้ด

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

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

นอกจากนี้คอมพิวเตอร์สมัยใหม่ (ต่างจากที่อื่นคือ 1401) รองรับการเชื่อมต่อของอุปกรณ์ I / O ที่หลากหลายมาก ๆ ไม่ใช่แค่เครื่อง IBM ที่ขายคุณในสมัยก่อน คอมไพเลอร์และลิงเกอร์ของคุณไม่สามารถรู้เกี่ยวกับความเป็นไปได้ทั้งหมด ตัวอย่างเช่นแป้นพิมพ์ของคุณอาจเชื่อมต่อผ่าน PS / 2 หรือ USB ระบบปฏิบัติการอนุญาตให้คุณติดตั้ง "ไดรเวอร์อุปกรณ์" เฉพาะสำหรับอุปกรณ์ที่รู้วิธีพูดคุยกับอุปกรณ์เหล่านั้น แต่นำเสนออินเตอร์เฟสทั่วไปสำหรับคลาสอุปกรณ์กับระบบปฏิบัติการ ดังนั้นโปรแกรมของคุณและแม้แต่ระบบปฏิบัติการไม่จำเป็นต้องทำอะไรที่แตกต่างไปสำหรับการกดแป้นจาก USB กับคีย์บอร์ด PS / 2 หรือสำหรับการเข้าถึงพูดดิสก์ SATA ในตัวเครื่องกับอุปกรณ์เก็บข้อมูล USB และที่เก็บข้อมูล บน NAS หรือ SAN รายละเอียดเหล่านั้นได้รับการจัดการโดยไดรเวอร์อุปกรณ์สำหรับอุปกรณ์ควบคุมต่างๆ

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

ดังนั้นในสภาพแวดล้อมทั่วไปที่ทันสมัยใช่ - คุณต้องการระบบปฏิบัติการจริงๆ แต่แม้กระทั่งทุกวันนี้ก็มีคอมพิวเตอร์เช่นคอนโทรลเลอร์แบบเรียลไทม์ที่ไม่ซับซ้อนพอที่จะใช้งานได้

ตัวอย่างเช่นในสภาพแวดล้อม Arduino ไม่มีระบบปฏิบัติการจริงๆ แน่นอนว่ามีรหัสห้องสมุดมากมายที่สภาพแวดล้อมการสร้างจะรวมอยู่ใน "ไบนารี" ทุกตัวที่สร้างขึ้น แต่เนื่องจากไม่มีการคงอยู่ของรหัสนั้นจากโปรแกรมหนึ่งไปยังอีกโปรแกรมหนึ่งจึงไม่ใช่ OS

ฉันคิดว่าคำตอบมากมายทำให้เข้าใจผิดคำถามซึ่งทำให้เกิดความเข้าใจผิด:

คอมไพเลอร์เอาท์พุทรหัสเครื่อง รหัสเครื่องนี้ทำงานโดยซีพียูโดยตรงหรือว่า "แปล" โดยเคอร์เนล?

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

1. เมื่อมีระบบปฏิบัติการอยู่โดยทั่วไปโปรแกรมแอปพลิเคชันจะถูก จำกัด ไม่ให้เรียกใช้คำสั่งบางอย่างหรือเข้าถึงทรัพยากรบางอย่าง ตัวอย่างเช่นหากแอปพลิเคชันดำเนินการคำสั่งซึ่งแก้ไขตารางระบบขัดจังหวะ CPU จะข้ามไปยังตัวจัดการข้อยกเว้นของระบบปฏิบัติการแทนเพื่อให้แอปพลิเคชันที่ละเมิดถูกยกเลิก นอกจากนี้แอปพลิเคชันมักไม่ได้รับอนุญาตให้อ่าน / เขียนไปยังหน่วยความจำอุปกรณ์ (เช่น "พูดคุยกับฮาร์ดแวร์") การเข้าถึงพื้นที่หน่วยความจำพิเศษเหล่านี้คือวิธีที่ระบบปฏิบัติการสื่อสารกับอุปกรณ์เช่นการ์ดกราฟิก, เครือข่ายอินเตอร์เฟส, นาฬิการะบบ ฯลฯ

2. ข้อ จำกัด ที่ OS วางไว้ในแอปพลิเคชันนั้นทำได้โดยคุณสมบัติพิเศษของ CPU เช่นโหมดสิทธิพิเศษการป้องกันหน่วยความจำและการขัดจังหวะ แม้ว่า CPU ใด ๆ ที่คุณจะพบในสมาร์ทโฟนหรือพีซีมีคุณสมบัติเหล่านี้ แต่ CPU บางตัวไม่มี ซีพียูเหล่านี้ต้องการเมล็ดพิเศษที่ "ตีความ" รหัสแอปพลิเคชันเพื่อให้ได้คุณสมบัติที่ต้องการ ตัวอย่างที่น่าสนใจมากคือGigatronซึ่งเป็นคอมพิวเตอร์ 8 คำสั่งที่คุณสามารถสร้างจากชิปซึ่งจำลองคอมพิวเตอร์ 34 คำสั่ง

3. บางภาษาเช่น Java "คอมไพล์" กับสิ่งที่เรียกว่า Bytecode ซึ่งไม่ใช่รหัสเครื่องจริงๆ แม้ว่าในอดีตจะมีการตีความเพื่อเรียกใช้โปรแกรม แต่บางครั้งสิ่งที่เรียกว่าการคอมไพล์แบบ Just-in-Timeมักจะถูกใช้เพื่อให้พวกเขาทำงานได้โดยตรงบน CPU เป็นรหัสเครื่อง

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

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

เมื่อเร็ว ๆ นี้ฉันได้อ่านข้อมูลเกี่ยวกับเมล็ดและฉันพบว่าโปรแกรมไม่สามารถเข้าถึงฮาร์ดแวร์ได้โดยตรง แต่ต้องผ่านเคอร์เนล

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

คำสั่งแต่ละคำสั่งในรหัสเครื่องนี้จะถูกเรียกใช้งานโดยตรงจากหน่วยความจำ (เมื่อโหลดรหัสลงในหน่วยความจำโดยระบบปฏิบัติการ) หรือแต่ละคำสั่งในรหัสเครื่องยังคงต้องผ่าน OS (เคอร์เนล) เพื่อดำเนินการ

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

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

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

จะเกิดอะไรขึ้นหลังจากโหลดรหัสเครื่องไปยังหน่วยความจำ มันจะผ่านเคอร์เนลหรือคุยกับโปรเซสเซอร์โดยตรง

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

ดีเพียงเพื่อป้องกันเปลวไฟในความคิดเห็น - มันเป็นแบบจำลองขนาดใหญ่จริง ๆ ที่ฉันหวังว่าจะช่วยให้ OP เข้าใจสิ่งต่าง ๆ พื้นฐาน แต่คำแนะนำที่ดีเพื่อปรับปรุงคำตอบนี้ยินดีต้อนรับ

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

โดยพื้นฐานแล้วการเรียกของระบบเท่านั้นไปที่เคอร์เนล โดยทั่วไปแล้วสิ่งใดที่ทำกับ I / O หรือการจัดสรร / การจัดสรรคืนหน่วยความจำจะส่งผลให้เกิดการเรียกระบบ บางคำสั่งสามารถเรียกใช้งานได้ในโหมดเคอร์เนลเท่านั้นและจะทำให้ CPU เรียกใช้ข้อยกเว้น ข้อยกเว้นทำให้เกิดการสลับไปยังโหมดเคอร์เนลและข้ามไปยังรหัสเคอร์เนล

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

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

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

ผู้ปฏิบัติการต้องใช้เคอร์เนลระบบปฏิบัติการหรือไม่

ขึ้นอยู่กับประเภทของไฟล์ปฏิบัติการ

เมล็ดนอกเหนือจากการไกล่เกลี่ยการเข้าถึง RAM และฮาร์ดแวร์ที่ใช้ร่วมกันแล้วยังทำหน้าที่โหลดเดอร์

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

ไฟล์สั่งการเหล่านี้ยังอ้างอิงไลบรารี (Windows .dllหรือ Linux .soไฟล์ออบเจ็กต์ที่ใช้ร่วมกัน) - จะต้องมีรหัสของพวกเขาด้วย

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

• คุณสามารถใส่รหัสที่ทำงานของตัวโหลดได้หรือไม่?

แน่ใจ คุณต้องโน้มน้าวให้ระบบปฏิบัติการเรียกใช้รหัสดิบโดยไม่ต้องประมวลผลข้อมูลเมตาใด ๆ หากรหัสของคุณเรียกใช้ API ของเคอร์เนลจะยังคงใช้งานไม่ได้

• เกิดอะไรขึ้นถ้ามันไม่ได้เรียก API ของเคอร์เนล

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

• ถ้าคุณเรียกใช้จากโหมดเคอร์เนล

จากนั้นมันจะทำงาน

TL; หมายเลข DR

การพัฒนา Arduino นั้นคำนึงถึงสภาพแวดล้อมปัจจุบันที่ไม่มีระบบปฏิบัติการ เชื่อใจฉันในหนึ่งในทารกเหล่านี้ที่คุณไม่มีที่ว่างสำหรับระบบปฏิบัติการ

ในทำนองเดียวกันเกมสำหรับ Sega Genesis ไม่มีระบบปฏิบัติการที่ Sega เตรียมไว้ให้เรียก คุณเพิ่งสร้างเกมของคุณในแอสเซมเบลอร์ 68K เขียนโดยตรงไปยังโลหะเปลือย

หรือที่ฉันตัดฟันของฉันทำงานฝังตัวกับ Intel 8051 อีกครั้งเมื่อคุณมี 2716 eprom ด้วย 2k * 8 footprint คุณไม่มีที่ว่างสำหรับระบบปฏิบัติการ

แน่นอนว่านี่ถือว่าเป็นการใช้งานคำที่กว้างมาก ในฐานะที่เป็นคำถามเชิงโวหารมันคุ้มค่าที่จะถามตัวเองว่าร่าง Arduino เป็นแอปพลิเคชั่นหรือไม่

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

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

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

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

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

กรณีพิเศษอื่น ๆ รวมถึงโปรแกรม bootstrap ที่โหลดเคอร์เนลและเคอร์เนลเอง กรณีพิเศษเหล่านี้โดยทั่วไปมีรหัสในภาษาอื่นที่ไม่ใช่ C ++

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

ที่ปลายอีกด้านของสเปกตรัมคือ Java ใน Java คอมไพเลอร์ไม่ได้แปลซอร์สโค้ดเป็นคำสั่งเครื่องเนื่องจากมักจะเข้าใจคำนี้ แต่รหัสต้นฉบับจะถูกแปลเป็น "คำสั่งเครื่อง" สำหรับเครื่องจินตภาพที่เรียกว่า Java Virtual Machine ก่อนที่โปรแกรม Java จะสามารถรันได้จะต้องรวมกับ Java runtime ซึ่งมีล่ามสำหรับ Java Virtual Machine

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

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

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

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

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

ฉันทดลองกับ Microkernel ที่สามารถใช้งาน Java Virtual Machine แต่พบในภายหลังว่าจุดที่ดีสำหรับ Docker

ในระบบปฏิบัติการเดสก์ท็อปทั่วไปเคอร์เนลเองนั้นสามารถเรียกใช้งานได้ (Windows มีntoskrnl.exe; Linux มีvmlinuxฯลฯ ) หากคุณต้องการเคอร์เนลเพื่อให้สามารถเรียกใช้งานได้แสดงว่า OS เหล่านั้นไม่สามารถใช้งานได้

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