ข้อมูลเชิงลึกของระบบ "Ubuntu Linux" - เราเห็นสิ่งนี้หรือไม่?

Ubuntu เวอร์ชันก่อนหน้าก่อน 6.10 มี sysvinit รูปแบบเก่าที่ใช้ในการเรียกใช้สคริปต์ใน “/etc/rcx.d ” ทุกครั้งที่เริ่มและปิดระบบ แต่หลังจากนั้นระบบ upstart ก็เข้ามาแทนที่ระบบ sysvinit แบบเก่า แต่ยังคงให้ความเข้ากันได้แบบย้อนหลัง

Ubuntu เวอร์ชันล่าสุดมีระบบพุ่งพรวดนี้ แต่เนื่องจากวิวัฒนาการมาจาก Ubuntu 6.10 จึงได้มีการแก้ไขหลายครั้งในเวอร์ชันปัจจุบันคือ 1.13.2 ณ วันที่ 4 กันยายน 2014 ระบบพุ่งพรวดล่าสุด มีกระบวนการ 2 init หนึ่งกระบวนการสำหรับกระบวนการของระบบและอื่น ๆ ที่จัดการเซสชันผู้ใช้ที่เข้าสู่ระบบปัจจุบันและมีอยู่จนกว่าผู้ใช้จะเข้าสู่ระบบเท่านั้น หรือที่เรียกว่า x-session init .

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

ตัวอย่าง: ความสัมพันธ์แบบลำดับชั้นเล็กๆ ระหว่างกระบวนการ init ทั้งสองคือ: system init(1) -> display manager(kernel space) -> ตัวจัดการการแสดงผล (พื้นที่ผู้ใช้) -> ผู้ใช้ init (หรือ x-session init)

ไฟล์การกำหนดค่าสำหรับกระบวนการที่จัดการโดย system init จะอยู่ใน “/etc/init ” และสำหรับกระบวนการที่จัดการโดย session init จะอยู่ใน “/usr/share/upstart ” (ตาม ตามเวอร์ชันพุ่งพรวดปัจจุบันที่สูงกว่า 1.12) และไฟล์การกำหนดค่าเหล่านี้เป็นกุญแจสำคัญในความลับมากมายเกี่ยวกับกระบวนการตามที่อธิบายไว้ในบทความนี้

เจาะลึกเข้าไปในลำดับชั้นมากขึ้น

Ubuntu รู้จักกระบวนการสองประเภท:

1. งานอายุสั้น (หรืองานแล้วตาย)
2. งานที่มีอายุยืนยาว (หรืองานที่อยู่และทำงาน)

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

ลำดับชั้นการบูต

Init เป็นกระบวนการแรกที่จะเริ่มเปิดเครื่องและจัดอยู่ในงาน work-and-stay เนื่องจากไม่เคยถูกฆ่า และเฉพาะเวลาที่ init ถูกฆ่าเท่านั้นที่เปิดอยู่ การปิดเครื่องเช่น init จะตายเท่านั้นและนั่นก็เช่นกันหนึ่งครั้งต่อเซสชันและนั่นคือการปิดเครื่อง เมื่อเปิดเครื่อง init จะสร้างเหตุการณ์แรกสุดบนระบบ เช่น เหตุการณ์การเริ่มต้น ไฟล์การกำหนดค่าแต่ละไฟล์ใน “/etc/init ” มีสองบรรทัดที่กำหนดเหตุการณ์ที่ทำให้กระบวนการเริ่มต้นและหยุด เส้นเหล่านั้นถูกเน้นไว้ในภาพด้านล่าง:

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

กระบวนการที่เริ่มต้นเมื่อเริ่มต้นระบบจะแสดงรายการไว้ด้านล่าง และงานเหล่านี้ล้วนเป็นงานที่ต้องทำงานแล้วตาย:

1. ชื่อโฮสต์ – นี่เป็นกระบวนการที่บอกระบบถึงชื่อโฮสต์ที่กำหนดไว้ในไฟล์ /etc/hostname

2. kmod – โหลดโมดูลเคอร์เนล เช่น ไดรเวอร์ทั้งหมดจากไฟล์ /etc/modules

3. mountall – กระบวนการนี้สร้างเหตุการณ์จำนวนมาก และมีหน้าที่หลักในการติดตั้งระบบไฟล์ทั้งหมดในขณะบูต รวมถึงระบบไฟล์ในเครื่องและระบบไฟล์ระยะไกล

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

4. พลีมัธ – กระบวนการนี้ดำเนินการบนการเริ่มต้น mountall และมีหน้าที่รับผิดชอบในการแสดงหน้าจอสีดำที่เห็นเมื่อเริ่มต้นระบบโดยแสดงบางอย่างดังนี้:

5. พร้อมพลีมัธ – แสดงว่าพลีมัธพร้อมแล้ว

ต่อไปนี้เป็นกระบวนการหลัก ส่วนกระบวนการอื่นๆ ที่ดำเนินการเมื่อเริ่มต้นระบบก็เช่น udev-fallback-graphics ฯลฯ การกลับมาที่ลำดับชั้นการบูต โดยสรุปเหตุการณ์และกระบวนการที่ตามมาจะเป็นตามลำดับ:

1. init พร้อมกับการสร้างเหตุการณ์การเริ่มต้น

2. การติดตั้งระบบไฟล์ mountall พลีมัธ (พร้อมกับการเริ่มต้น mountall) ที่แสดงหน้าจอสแปลช และโมดูลเคอร์เนลการโหลด kmod

3. เหตุการณ์ local-filesystem ที่สร้างโดย mountall ทำให้ dbus ทำงาน (Dbus คือบัสข้อความทั้งระบบซึ่งสร้างซ็อกเก็ตเพื่อให้กระบวนการอื่นสื่อสารถึงกันผ่านการส่งข้อความไปยังซ็อกเก็ตนี้ และผู้รับจะฟังข้อความบนซ็อกเก็ตนี้และกรองข้อความที่มีความหมายสำหรับมัน)

4. local-filesystem พร้อมด้วย dbus ที่เริ่มต้นและเหตุการณ์ static-network-up ที่เกิดจากเครือข่ายกระบวนการที่ทำงานบนเหตุการณ์ local-filesystem ทำให้ตัวจัดการเครือข่ายทำงาน

5. เหตุการณ์ ระบบไฟล์เสมือน ที่สร้างโดย mountall ทำให้ udev ทำงาน (udev เป็นตัวจัดการอุปกรณ์สำหรับ linux ที่จัดการ hot-plugging ของอุปกรณ์และรับผิดชอบในการสร้างไฟล์ในไดเร็กทอรี /dev และจัดการไฟล์เหล่านั้นด้วย) udev สร้างไฟล์สำหรับ ram, rom ฯลฯ ในไดเร็กทอรี /dev ที่ mountall ติดตั้งเสมือนเสร็จแล้ว -filesystems และได้สร้างเหตุการณ์ virtual-filesystem ซึ่งแสดงถึงการติดตั้งไดเร็กทอรี /dev

6. udev ทำให้ upstart-udev-bridge ทำงานโดยแสดงว่าเครือข่ายท้องถิ่นพร้อมใช้งาน จากนั้นหลังจากที่ mountall ติดตั้งระบบไฟล์ล่าสุดเสร็จแล้วและสร้างเหตุการณ์ระบบไฟล์

7. เหตุการณ์ ระบบไฟล์ พร้อมกับเหตุการณ์ static-network-up ทำให้งาน rc-sysinit ทำงาน ความเข้ากันได้แบบย้อนหลังระหว่าง sysvinit รุ่นเก่ากับ upstart...

9. rc-sysinit รันคำสั่ง telinit ที่บอกระดับรันระบบ

10. หลังจากได้รับระดับรันแล้ว init จะดำเนินการสคริปต์ที่ขึ้นต้นด้วย 'S' หรือ 'K' (การเริ่มงานที่มี 'S' อยู่ใน นำหน้าชื่อและฆ่าผู้ที่มี 'K' ขึ้นต้นชื่อ) ในไดเร็กทอรี /etc/rcX.d (โดยที่ 'X' คือระดับรันปัจจุบัน) .

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

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

ด้านบนคือส่วนของไฟล์คอนฟิกูเรชันของกระบวนการ mountall นี่จะแสดงเหตุการณ์ที่มันส่งเสียงออกมา ชื่อของกิจกรรมคือชื่อที่ตามหลังคำว่า "กิจกรรม" เหตุการณ์อาจเป็นเหตุการณ์ที่กำหนดไว้ในไฟล์การกำหนดค่าข้างต้นหรืออาจเป็นชื่อของกระบวนการพร้อมกับคำนำหน้า 'starting' , 'started', 'stopping' หรือ 'stopped'

ดังนั้นเราจึงให้คำนิยามไว้สองคำ:

1. เครื่องมือสร้างเหตุการณ์: รายการที่มีบรรทัด 'emits xxx' ในไฟล์การกำหนดค่า โดยที่ xxx คือชื่อของเหตุการณ์ที่เป็นเจ้าของหรือสร้างขึ้น
2. ตัวจับเหตุการณ์: ตัวจับเหตุการณ์ที่มีเงื่อนไขเริ่มต้นหรือหยุดเป็น xxx หรือที่เริ่มต้นหรือหยุดในเหตุการณ์ที่สร้างหนึ่งในตัวสร้างเหตุการณ์

ดังนั้นลำดับชั้นจึงเป็นไปตามและการพึ่งพาระหว่างกระบวนการ:

Event generator (parent) -> Event catcher (child)

การเพิ่มความซับซ้อนให้กับลำดับชั้น

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

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

บรรทัดเหล่านี้นำมาจากกระบวนการ - เครือข่ายและที่นี่การเริ่มต้นในเงื่อนไขดูเหมือนจะซับซ้อนเกินไปเล็กน้อยซึ่งประกอบด้วยเหตุการณ์มากมาย ได้แก่ - local-filesystems, udevtrigger, container, ระดับการทำงาน, ระบบเครือข่าย

ระบบไฟล์ในเครื่องถูกปล่อยออกมาโดย mountall, udevtrigger เป็นชื่อของงาน, เหตุการณ์คอนเทนเนอร์ถูกปล่อยออกมาโดยการตรวจจับคอนเทนเนอร์, เหตุการณ์ runlevel ที่ปล่อยออกมาโดย rc-sysinit และเครือข่ายก็เป็นงานอีกครั้ง

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

แยกแยะประเภทงาน

ตามที่กำหนดไว้ก่อนหน้านี้ เราสามารถมีงานอายุสั้น (หรืองาน งานแล้วตาย) หรืองานอายุยืน (หรือ งานประจำ) แต่จะแยกแยะได้อย่างไรระหว่าง พวกเขา??

งานที่มีเงื่อนไข 'start on' และ 'stop on' ระบุไว้ในไฟล์การกำหนดค่าและมีคำว่า 'task' อยู่ในงาน ไฟล์การกำหนดค่าคืองาน work-and-die ที่เริ่มต้นในเหตุการณ์ที่สร้างขึ้น รันสคริปต์หรือส่วน exec (ในขณะที่ดำเนินการ งานจะบล็อกเหตุการณ์ที่ทำให้เกิดเหตุการณ์เหล่านั้น) และตายหลังจากนั้นปล่อยเหตุการณ์เหล่านั้นที่พวกเขาบล็อก .

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

1. ผู้ที่ไม่มีเงื่อนไขการเกิดใหม่และผู้ใช้รูทสามารถฆ่าได้
2. ผู้ที่มีเงื่อนไขการเกิดใหม่ในไฟล์กำหนดค่า และรีสตาร์ทหลังจากถูกฆ่า เว้นแต่งานจะเสร็จสิ้น

บทสรุป

ดังนั้น แต่ละกระบวนการใน LINUX จึงขึ้นอยู่กับบางกระบวนการและมีบางกระบวนการขึ้นอยู่กับมัน และความสัมพันธ์นี้มีหลายต่อหลายรายการ และระบุด้วยระบบพุ่งพรวดพร้อมกับรายละเอียดอื่น ๆ ของกระบวนการ