ระบบ Inferno แต่ละระบบนำเสนอสภาพแวดล้อมที่เหมือนกันสำหรับแอปพลิเคชัน โดยไม่คำนึงถึงระบบปฏิบัติการโฮสต์หรือสถาปัตยกรรมพื้นฐาน ช่วยให้นักพัฒนาสามารถทำงานกับสภาพแวดล้อมที่เป็นเนื้อเดียวกันอย่างแท้จริงบนแพลตฟอร์มที่แตกต่างกันหลายแห่ง
แอปพลิเคชั่นแบบพกพา
แอปพลิเคชัน Inferno เขียนด้วย Limbo® ซึ่งเป็นภาษาการเขียนโปรแกรมที่ทันสมัย ปลอดภัย แบบแยกส่วน และทำงานพร้อมกันพร้อมไวยากรณ์คล้าย C มีประสิทธิภาพมากกว่า C แต่เข้าใจและแก้ไขจุดบกพร่องได้ง่ายกว่า C++ หรือ Java มาก เป็นเรื่องง่ายที่จะแสดงความเห็นพร้อมกันในโลกทางกายภาพโดยตรงในรูปแบบไวยากรณ์ของ Limbo แอปพลิเคชัน Inferno ใดๆ ก็ตามจะทำงานเหมือนกันบนแพลตฟอร์ม Inferno ทั้งหมด
รหัสแบบพกพา
โค้ด Limbo ได้รับการคอมไพล์เป็นโค้ดอิสระทางสถาปัตยกรรมสำหรับ Dis® Virtual Machine พร้อมด้วยการแสดงแบบกะทัดรัด สามารถตีความ Dis ได้โดยตรง (ประหยัดพื้นที่) หรือคอมไพล์ได้ทันทีสำหรับโปรเซสเซอร์เป้าหมายที่กำหนด (ประหยัดเวลา) สามารถเลือกได้ในขณะรันไทม์ต่อโมดูล สถาปัตยกรรม Dis ได้รับการออกแบบมาอย่างพิถีพิถันเพื่อให้การสร้างโค้ดได้ทันทีตรงไปตรงมา คำแนะนำนั้นง่ายต่อการปฏิบัติ
ทรัพยากรที่โปร่งใส
Inferno นำเสนอความโปร่งใสของทรัพยากรและข้อมูลโดยใช้ระบบ "เนมสเปซ" ที่เรียบง่ายแต่ทรงพลัง ด้วยทรัพยากรที่แสดงเป็นไฟล์และมีโปรโตคอลการสื่อสารมาตรฐานเดียว - 9P (Styx®) - ทรัพยากร เช่น ที่เก็บข้อมูล บริการ และอุปกรณ์ภายนอกสามารถแบ่งปันระหว่างระบบ Inferno ได้อย่างง่ายดาย อินเทอร์เฟซทรัพยากรอาจถูกนำเข้าไปยังระบบโลคัลและใช้งานโดยแอปพลิเคชันโดยที่พวกเขาไม่รู้หรือจำเป็นต้องรู้ ไม่ว่าจะเป็นภายในเครื่องหรือระยะไกล
ความปลอดภัย
การรักษาความปลอดภัยระดับสูงเป็นส่วนสำคัญของระบบ Inferno ด้วยการใช้โปรโตคอลมาตรฐานเดียวสำหรับการสื่อสารเครือข่ายทั้งหมด การรักษาความปลอดภัยสามารถมุ่งเน้นไปที่จุดเดียวและจัดให้มีในระดับระบบ Inferno ให้การสนับสนุนอย่างเต็มที่สำหรับการเชื่อมต่อที่ได้รับการรับรองความถูกต้องและเข้ารหัสโดยใช้รูปแบบการระบุผู้ใช้ตามใบรับรองและอัลกอริธึมที่หลากหลาย รวมถึง:
- IDEA, 56 บิต DES, 40, 128 และ 256 บิต RC4 อัลกอริธึมการเข้ารหัส
- อัลกอริธึมแฮชที่ปลอดภัยของ MD4, MD5 และ SHA
โซลูชั่นที่สมบูรณ์
นรกไม่ได้เป็นเพียง ระบบปฏิบัติการอีกทั้งยังเป็นสภาพแวดล้อมการพัฒนาที่สมบูรณ์ โดยมีเครื่องมือทั้งหมดที่จำเป็นสำหรับการสร้าง ทดสอบ และแก้ไขข้อบกพร่องแอปพลิเคชันที่ทำงานภายในนั้น
- Acme IDE: รวมโปรแกรมแก้ไข เชลล์ เครื่องมือจับคู่รูปแบบขั้นสูง และอื่นๆ
- Fast Compiler: พร้อมไวยากรณ์แบบเต็มและการตรวจสอบประเภทเวลาคอมไพล์
- ดีบักเกอร์กราฟิก: พร้อมการติดตามสแต็กแบบเต็มสำหรับเธรดที่กำลังดำเนินการอยู่
- เชลล์อันทรงพลัง: พร้อมความสามารถในการเขียนสคริปต์ที่ซับซ้อน
- คำสั่งเช่น UNIX: รวมถึง bind, grep, gzip, mount, ps, tar, yacc...
การแนะนำ Inferno OS
เป็นเวลานานแล้วที่เราบอกคุณเกี่ยวกับระบบปฏิบัติการใหม่ แต่โลกไม่หยุดนิ่งและตลาดระบบปฏิบัติการไม่ได้ จำกัด อยู่ที่ Linux, Windows และ *BSD เลยซึ่งข้อมูลทั้งใน CP และในสิ่งพิมพ์และสิ่งพิมพ์อิเล็กทรอนิกส์อื่น ๆ ปรากฏขึ้นด้วยความสม่ำเสมอที่น่าอิจฉา
และทันใดนั้น เหตุผลที่ดีก็ปรากฏขึ้น: มีข้อความปรากฏขึ้นในฟีดข่าวเกี่ยวกับการเปิดตัว (และความพร้อมสำหรับ ดาวน์โหลดฟรี) ระบบปฏิบัติการเวอร์ชันที่ 4 ที่มีความชั่วร้าย (ในบริบทนี้พวกเขามักจะพูดว่า "นรก" แต่ในกรณีของเรามันเป็นเรื่องซ้ำซาก :) ชื่อ Inferno แต่เนื่องจากเราแน่ใจว่าผู้อ่านของเราอย่างน้อยครึ่งหนึ่งไม่เคยได้ยินเกี่ยวกับระบบปฏิบัติการนี้มาก่อน และด้วยเหตุนี้จึงไม่รู้ว่าจะยินดีกับข่าวดังกล่าวหรือไม่ เราจึงตัดสินใจอุทิศเนื้อหา "ฉบับเต็ม" ทั้งหมดให้กับ Inferno โดยอิงจาก บทความโดยผู้พัฒนาระบบนี้ อย่างไรก็ตาม ดูรายชื่อผู้เขียนในตอนท้ายของบทความ เรามั่นใจว่าคุณจะต้องประหลาดใจอย่างแน่นอน ;)
การแนะนำ
ระบบปฏิบัติการ Inferno ได้รับการพัฒนาโดย Bell Labs Computer Research Center ซึ่งเป็นแผนกวิจัยและพัฒนาของ Lucent Technologies ต่อมาการพัฒนายังคงดำเนินต่อไปโดยแผนกอื่น ๆ ของ Lucent และในปัจจุบันสิทธิ์แต่เพียงผู้เดียวในระบบนี้เป็นของ บริษัท ซอฟต์แวร์สัญชาติอังกฤษ Vita Nuova
วัตถุประสงค์หลักของระบบคือการสร้างระบบคอมพิวเตอร์แบบกระจายที่ไม่ขึ้นกับฮาร์ดแวร์และใช้ในอุปกรณ์ฝังตัว
Inferno ได้รับการออกแบบมาเพื่อใช้ในสภาพแวดล้อมเครือข่ายที่หลากหลาย เช่น สมาร์ทโฟน, PDA แบบพกพา, ระบบโทรทัศน์เคเบิลและดาวเทียม, เทอร์มินอลอินเทอร์เน็ตราคาประหยัด และแน่นอนว่ารวมถึงระบบคอมพิวเตอร์แบบดั้งเดิม
สามารถใช้ Inferno ได้สำเร็จที่ไหน? บนเครือข่ายเคเบิลทีวีโดยตรง การออกอากาศผ่านดาวเทียม, อินเทอร์เน็ตและเครือข่ายข้อมูลอื่น ๆ (และแน่นอนว่าบริการหลากหลาย)
ไม่เหมือน ระบบโทรศัพท์ด้วยเทอร์มินัลและสัญญาณมาตรฐาน เครือข่ายคอมพิวเตอร์ได้รับการพัฒนาในโลกที่มีเทอร์มินัล อุปกรณ์เครือข่าย และโปรโตคอลที่แตกต่างกัน ออกแบบมาอย่างดีเท่านั้น ประหยัด ระบบปฏิบัติการสามารถรวบรวมผู้ให้บริการเนื้อหาและบริการต่างๆ บนแพลตฟอร์มการขนส่งและการนำเสนอที่แตกต่างกัน อย่างที่คุณอาจเดาได้ Inferno เป็นเพียงระบบปฏิบัติการดังกล่าว;)
ข้อดีของ Inferno ขึ้นอยู่กับความสามารถในการพกพาและความยืดหยุ่นในด้านต่อไปนี้:
- รองรับโปรเซสเซอร์:ปัจจุบันรองรับ Intel, Sparc, MIPS, ARM, HP PA, PowerPC กำลังเตรียมการรองรับโปรเซสเซอร์อื่น ๆ
- รองรับสภาพแวดล้อมต่างๆ: Inferno ทำงานเหมือน ระบบแยกบนเทอร์มินัลขนาดเล็ก ยังทำงานเป็นกระบวนการผู้ใช้บน Windows NT, Windows 95, Unix (Irix, Solaris, FreeBSD, Linux, AIX, HP/UX) และ Plan 9 ในทุกกรณีเหล่านี้ แอปพลิเคชัน Inferno มีอินเทอร์เฟซเดียวกัน
- โครงสร้างแบบกระจาย:มีการติดตั้งสภาพแวดล้อมที่เหมือนกันบนเทอร์มินัลผู้ใช้และบนเซิร์ฟเวอร์ โดยแต่ละสภาพแวดล้อมสามารถนำเข้าทรัพยากร (เช่น อุปกรณ์ I/O หรือเครือข่ายที่มีอยู่) ของอีกเครื่องหนึ่งได้ ด้วยความสามารถในการสื่อสารของระบบ ทำให้สามารถแชร์แอปพลิเคชันระหว่างไคลเอนต์และเซิร์ฟเวอร์ได้อย่างง่ายดาย (แม้จะเป็นแบบไดนามิก)
- ข้อกำหนดอุปกรณ์ขั้นต่ำ:แอปพลิเคชันแบบสแตนด์อโลนทำงานบนคอมพิวเตอร์ที่มีหน่วยความจำ 1 MB และไม่ต้องใช้ตัวควบคุมหน่วยความจำ
- ความสะดวกในการพกพาแอปพลิเคชัน:แอปพลิเคชัน Inferno เขียนด้วยภาษาพิมพ์ Limbo และการแทนค่าไบนารี่ที่สร้างโดยคอมไพเลอร์จะเหมือนกันสำหรับทุกแพลตฟอร์ม
- การปรับตัวแบบไดนามิก:แอปพลิเคชันอาจใช้แตกต่างกันออกไป ขึ้นอยู่กับฮาร์ดแวร์หรือทรัพยากรอื่นๆ ที่มีอยู่ โมดูลซอฟต์แวร์เพื่อทำหน้าที่เฉพาะ ตัวอย่างเช่น โปรแกรมเล่นวิดีโออาจใช้ โมดูลต่างๆตัวถอดรหัส
การออกแบบ Inferno มีพื้นฐานมาจากโมเดลที่รองรับการใช้งานที่หลากหลาย ผู้ให้บริการหลายรายสนใจที่จะให้บริการสื่อและบริการอื่นๆ: บริการโทรศัพท์,www-service, เคเบิลทีวี, ค้าขาย, บริการข้อมูลต่างๆ นอกจากนี้ยังมีเทคโนโลยีการสื่อสารมากมาย: แบบธรรมดา โมเด็มโทรศัพท์, ISDN, ATM, อินเทอร์เน็ต, โทรทัศน์ภาคพื้นดินแบบอะนาล็อกหรือเคเบิลทีวี, เคเบิลโมเด็ม, วิดีโอดิจิทัล และโทรทัศน์แบบโต้ตอบ
แอปพลิเคชันที่ตอบสนองความต้องการในปัจจุบันและอนาคตของ Lucent ได้แก่ การจัดการสวิตช์และเราเตอร์ โปรดทราบว่าเครือข่ายและเซิร์ฟเวอร์ภายในของ Bell Labs ได้รับการปกป้องโดยไฟร์วอลล์ที่ใช้ Inferno
Inferno เป็นทรัพยากรที่มีประสิทธิภาพมาก ทำให้สามารถรองรับแอปพลิเคชันที่ค่อนข้างซับซ้อนบนฮาร์ดแวร์ในปัจจุบันได้ โดยเฉพาะระบบจะช่วยให้นักพัฒนาสามารถสร้าง แอปพลิเคชั่นที่ทำงานบนอุปกรณ์ต่างๆ ตัวอย่างเช่น แคตตาล็อกการซื้อแบบโต้ตอบ: ความสามารถในการทำงานในโหมดข้อความผ่านโมเด็มแอนะล็อก, แสดงรูปภาพ (อาจมีเสียงด้วย) ของผลิตภัณฑ์ผ่าน ISDN และแสดงคลิปวิดีโอผ่านช่องทางดิจิทัล
แน่นอนว่าไม่มีใครบังคับให้คุณในฐานะนักพัฒนาใช้คุณสมบัติและฟังก์ชันทั้งหมดของ Inferno แต่คุณควรจำไว้ว่าสถาปัตยกรรมระบบนั้นถูกจำกัดด้วยข้อกำหนดและจินตนาการของลูกค้า ช่องทางเครือข่ายและเทคโนโลยีเซิร์ฟเวอร์ที่มีอยู่เท่านั้น แต่ ไม่ใช่โดยซอฟต์แวร์
อินเทอร์เฟซนรก
บทบาทของระบบ Inferno คือการสร้างหลายอย่าง อินเทอร์เฟซมาตรฐานสำหรับแอปพลิเคชันของคุณ:
1. แอปพลิเคชันใช้ทรัพยากรระบบภายในที่หลากหลาย เช่น เครื่องเสมือน ซึ่งรันโปรแกรมและโมดูลไลบรารีเพื่อดำเนินการต่างๆ ตั้งแต่การดำเนินการง่ายๆ เช่น การจัดการสตริงไปจนถึงการดำเนินการที่ซับซ้อนมากขึ้น (การทำงานกับข้อความ รูปภาพ ไลบรารีระดับสูง หรือวิดีโอ ).
2. แอปพลิเคชันมีอยู่ในสภาพแวดล้อมภายนอกที่มีทรัพยากร เช่น ไฟล์ที่มีข้อมูลที่สามารถจัดการได้ และตั้งชื่ออ็อบเจ็กต์ที่สามารถจัดการได้เหมือนกับไฟล์ แต่มีความเข้มข้นมากกว่า อุปกรณ์ (ระยะไกล การควบคุมระยะไกล, ตัวถอดรหัส MPEG หรือ อินเตอร์เฟซเครือข่าย) จะถูกนำเสนอต่อแอปพลิเคชันในรูปแบบไฟล์
3. มีโปรโตคอลการสื่อสารมาตรฐานสำหรับการโต้ตอบของแอปพลิเคชันทั้งภายในโฮสต์เดียวกันและระหว่างโฮสต์ที่แตกต่างกันที่ใช้ Inferno ด้วยวิธีนี้ แอปพลิเคชัน Inferno จึงสามารถทำงานร่วมกันได้อย่างมีประสิทธิภาพ
ในเวลาเดียวกัน Inferno ใช้อินเทอร์เฟซที่มาจากสภาพแวดล้อมที่มีอยู่ เช่น ฮาร์ดแวร์หรือโปรโตคอลที่มีอยู่ และ การโทรของระบบระบบปฏิบัติการ
บริการที่ใช้ Inferno ทั่วไปประกอบด้วยเทอร์มินัลราคาถูกจำนวนมากที่ใช้ Inferno เป็นระบบปฏิบัติการเนทิฟ และเครื่องจักร (เซิร์ฟเวอร์) ขนาดใหญ่จำนวนน้อยกว่าที่ใช้ Inferno เป็นระบบแขก บนเครื่องเซิร์ฟเวอร์ดังกล่าว Inferno สามารถให้การเข้าถึงฐานข้อมูล ระบบธุรกรรม หรือทรัพยากรอื่นๆ ที่ระบบปฏิบัติการดั้งเดิมมอบให้ แอปพลิเคชัน Inferno สามารถทำงานบนระบบไคลเอนต์ หรือบนเซิร์ฟเวอร์ หรือทั้งสองอย่าง
สภาพแวดล้อมภายนอกของแอปพลิเคชัน Inferno
วัตถุประสงค์ของแอปพลิเคชัน Inferno ส่วนใหญ่คือการให้ข้อมูลหรือสื่อแก่ผู้ใช้ แอปพลิเคชันดังกล่าวจะต้องค้นหาตำแหน่งของทรัพยากรบนเครือข่ายและสร้างการแสดงข้อมูลนี้ในเครื่องบนอุปกรณ์ของผู้ใช้ อย่างไรก็ตาม การไหลของข้อมูลส่วนใหญ่ไม่ใช่ทางเดียว: เทอร์มินัลผู้ใช้ (ไม่ว่าจะเป็นคอมพิวเตอร์เครือข่าย ทีวี คอมพิวเตอร์ส่วนบุคคลหรือวิดีโอโฟน) ก็เป็นแหล่งข้อมูลบางอย่างและต้องให้ข้อมูลนี้แก่แอปพลิเคชันด้วย Inferno ติดตามการออกแบบ Plan9 เป็นอย่างมาก (ระบบปฏิบัติการที่เกี่ยวข้องซึ่งพัฒนาโดย Bell Labs ด้วย) ในลักษณะการนำเสนอทรัพยากรให้กับแอปพลิเคชัน โครงสร้างนี้เป็นไปตามหลักการสามประการ:
1. ทรัพยากรทั้งหมดได้รับการตั้งชื่อและพร้อมใช้งานเป็นไฟล์ในแผนผังของระบบไฟล์แบบลำดับชั้น
2. แยกลำดับชั้นทรัพยากรให้ บริการต่างๆถูกรวมเข้าเป็นช่องว่างที่มีชื่อเฉพาะที่เดียว
3. โปรโตคอลการสื่อสาร Styx ใช้เพื่อรวมการเข้าถึงทรัพยากรทั้งในพื้นที่หรือระยะไกล
ในทางปฏิบัติ แอปพลิเคชันส่วนใหญ่จะเห็นชุดของไฟล์ที่จัดอยู่ในแผนผังไดเร็กทอรี ไฟล์บางไฟล์มีข้อมูลปกติ ส่วนบางไฟล์เป็นทรัพยากรที่มีการใช้งานมากกว่า อุปกรณ์จะแสดงเป็นไฟล์ ไดรเวอร์อุปกรณ์ (เช่น โมเด็ม ตัวถอดรหัส MPEG อินเทอร์เฟซเครือข่าย หรือหน้าจอทีวี) ที่แนบกับระบบจะแสดงเป็นไดเร็กทอรีขนาดเล็ก โดยทั่วไปไดเร็กทอรีเหล่านี้ประกอบด้วยสองไฟล์: data และ ctl ซึ่งกำหนดการดำเนินการ I/O และการควบคุมอุปกรณ์ตามลำดับ บริการระบบยังสามารถเข้าถึงได้ผ่านไฟล์ที่มีชื่อ ตัวอย่างเช่น คุณสามารถเข้าถึงเนมเซิร์ฟเวอร์โดยใช้ชื่อเฉพาะ เช่น /net/dns; หลังจากเขียนชื่อโดเมนของโฮสต์ลงในไฟล์นี้ การอ่านครั้งต่อไปจะส่งคืนที่อยู่ IP ที่เกี่ยวข้องในรูปแบบตัวเลข
กาวที่ยึดส่วนที่แยกของเนมสเปซที่มีชื่อไว้ด้วยกันคือโปรโตคอล Styx ใน Inferno ไดรเวอร์อุปกรณ์ทั้งหมดและทรัพยากรภายในอื่นๆ จะสอดคล้องกับเวอร์ชันขั้นตอนของ Styx
เคอร์เนล Inferno มีสิ่งที่เรียกว่า "ไดรเวอร์เมาท์" ซึ่งแปลการทำงานของระบบไฟล์เป็นการเรียกขั้นตอนระยะไกลสำหรับการส่งสัญญาณผ่านเครือข่าย ที่ปลายอีกด้านของการเชื่อมต่อ เซิร์ฟเวอร์จะอ่านข้อความโปรโตคอล Styx และใช้การโทรที่เกี่ยวข้องโดยใช้ ทรัพยากรในท้องถิ่น- ด้วยวิธีนี้ ทำให้สามารถนำเข้าส่วนหนึ่งของพื้นที่ที่มีชื่อ (นั่นคือ ทรัพยากรที่มีอยู่) จากเครื่องอื่นได้
จากตัวอย่างข้างต้น ไม่น่าเป็นไปได้ที่อุปกรณ์ปลายทางจะจัดเก็บโค้ดเนมเซิร์ฟเวอร์ด้วยตัวเอง แต่อินเทอร์เน็ตเบราว์เซอร์จะนำเข้าทรัพยากร /net/dns ลงในเนมสเปซของตนเองโดยตรงจากเครื่องเซิร์ฟเวอร์บนเครือข่ายแทน
โปรโตคอล Styx เป็นเลเยอร์ที่สูงกว่าและไม่ขึ้นอยู่กับโปรโตคอลการขนส่ง มันทำงานบน TCP, PPP, ATM หรือโปรโตคอลโมเด็มต่างๆ
สภาพแวดล้อมภายในของแอปพลิเคชัน Inferno
โปรแกรม Inferno เขียนด้วยภาษา Limbo ใหม่ ซึ่งสร้างขึ้นเพื่อการทำงานใน Inferno โดยเฉพาะ ไวยากรณ์ของมันคือแรงบันดาลใจจาก C และ Pascal และรองรับเรื่องทั่วไป ประเภทมาตรฐานข้อมูลและข้อมูลระดับสูงหลายประเภท เช่น รายการ สิ่งอันดับ สตริง อาร์เรย์แบบไดนามิกและประเภทข้อมูลนามธรรมอย่างง่าย
นอกจากนี้ Limbo ยังรองรับโครงสร้างที่ซับซ้อนหลายอย่างที่ฝังอยู่ในเครื่องเสมือน Inferno โดยเฉพาะกลไกการสื่อสาร ช่องทาง ที่ใช้ในการสื่อสาร งานต่างๆ Limbo บนเครื่องของคุณหรือผ่านเครือข่าย ช่องสัญญาณจะส่งข้อมูลในลักษณะที่ไม่ขึ้นอยู่กับเครื่อง โครงสร้างที่ซับซ้อนข้อมูล รวมถึงช่องทางต่างๆ สามารถส่งผ่านระหว่างงาน Limbo หรือแนบไปกับไฟล์เนมสเปซเพื่อการทำงานร่วมกันระหว่างเครื่องกับเครื่องในระดับภาษา
การทำงานหลายอย่างพร้อมกันได้รับการสนับสนุนโดยตรงโดยภาษา Limbo: สามารถวางเธรดอิสระได้ และนิพจน์ alt ใช้เพื่อประสานการเชื่อมต่อช่องสัญญาณระหว่างงานต่างๆ (นั่นคือ alt ใช้เพื่อเลือกหนึ่งในหลายช่องสัญญาณที่พร้อมจะสื่อสาร) ด้วยการฝังช่องทางและงานต่างๆ ลงในภาษาและเครื่องเสมือน Inferno ทำให้ใช้งานง่ายและ วิธีที่ปลอดภัยการโต้ตอบ
โปรแกรม Limbo ประกอบด้วยโมดูลซึ่งเป็นคอนเทนเนอร์แพ็กเกจที่มีอินเทอร์เฟซที่กำหนดไว้ในรูปแบบของฟังก์ชัน/วิธีการ ประเภทข้อมูลนามธรรม และค่าคงที่ที่กำหนดไว้ภายในโมดูลและสามารถเข้าถึงได้จากภายนอก โมดูลถูกเข้าถึงแบบไดนามิก นั่นคือหากโมดูลหนึ่งต้องการใช้อีกโมดูลหนึ่ง โหลดจะถูกเรียกแบบไดนามิกพร้อมกับชื่อของโมดูลที่ถูกเรียกและตัวชี้จะถูกส่งกลับ โมดูลใหม่- เมื่อโมดูลใหม่ไม่ได้ใช้งานอีกต่อไป สภาพแวดล้อมและโค้ดของโมดูลจะถูกยกเลิกการโหลด
ความยืดหยุ่นของโครงสร้างโมดูลาร์นั้นเนื่องมาจากขนาดที่เล็กของการใช้งาน Inferno ทั่วไป ตัวอย่างเช่น ในแค็ตตาล็อกการช็อปปิ้งที่อธิบายไว้ข้างต้น โมดูลแอปพลิเคชันหลักจะตรวจสอบความพร้อมใช้งานของทรัพยากรวิดีโอแบบไดนามิก และหากไม่มีทรัพยากรก็จะไม่โหลดตัวถอดรหัสวิดีโอ
Limbo ตรวจสอบความถูกต้องของประเภทข้อมูลอย่างสมบูรณ์ในระหว่างการรวบรวมและดำเนินการ ตัวอย่างเช่น มีการตรวจสอบพอยน์เตอร์ (โดยวิธีการที่เข้มงวดมากกว่าใน C) ก่อนใช้งาน มีการตรวจสอบความสอดคล้องประเภทของโมดูลที่โหลดแบบไดนามิกระหว่างการโหลด แอปพลิเคชัน Limbo ทำงานได้อย่างเสถียรบนเครื่องโดยไม่มีการป้องกันหน่วยความจำฮาร์ดแวร์
นอกจากนี้ ออบเจ็กต์ข้อมูลระบบและออบเจ็กต์โปรแกรมทั้งหมดจะถูกควบคุมโดย "ตัวรวบรวมขยะ" ที่ต่อสายเข้ากับ Limbo ออบเจ็กต์ดังกล่าวทั้งหมดจะถูกติดตามโดยเครื่องเสมือนและยกเลิกการโหลดหลังการใช้งาน ตัวอย่างเช่น หากแอปพลิเคชันสร้างหน้าต่างกราฟิกและทำงานเสร็จสิ้น หน้าต่างนั้นจะถูกปิดโดยอัตโนมัติหลังจากที่การอ้างอิงทั้งหมดไปยังวัตถุนั้นถูกลบออก
โปรแกรม Limbo ถูกคอมไพล์เป็น bytecode ซึ่งมีคำแนะนำสำหรับเครื่องเสมือน Dis สถาปัตยกรรมของส่วนเลขคณิตของ Dis เป็นเครื่องจักร 3 ที่อยู่อย่างง่าย ซึ่งมาพร้อมกับการดำเนินการพิเศษหลายอย่างสำหรับการทำงานกับบางรายการ ประเภทระดับสูงข้อมูลเช่นอาร์เรย์และสตริง ehjdytv ด้านล่างเป็นผู้ดำเนินการรวบรวมขยะ และการกำหนดเวลางานก็ถูกซ่อนไว้เช่นเดียวกัน เมื่อโหลดโค้ดไบต์ลงในหน่วยความจำ รหัสดังกล่าวจะถูกขยายเป็นรูปแบบที่มีประสิทธิภาพมากขึ้นสำหรับการดำเนินการ คอมไพเลอร์ที่มีอยู่จะแปลงสตรีมคำสั่ง Dis ให้เป็นคำสั่งเครื่องสำหรับฮาร์ดแวร์ได้ทันที การแปลงนี้มีประสิทธิภาพเนื่องจากคำสั่ง Dis ตรงกับชุดคำสั่งที่ดีมาก สถาปัตยกรรมสมัยใหม่- โค้ดผลลัพธ์จะทำงานด้วยความเร็วเทียบเท่ากับโปรแกรม C ที่คอมไพล์แล้ว
ด้านล่าง Dis คือเคอร์เนล Inferno ซึ่งมีล่ามและคอมไพเลอร์แบบเรียลไทม์ รวมถึงตัวจัดการหน่วยความจำ ตัวกำหนดเวลา ไดรเวอร์อุปกรณ์ สแต็กโปรโตคอล และอื่นๆ ที่คล้ายคลึงกัน เคอร์เนลยังประกอบด้วยแกนหลักของระบบไฟล์ (ตัวจัดการชื่อและโค้ดที่แปลการทำงานของระบบไฟล์เป็นการเรียกโพรซีเดอร์ระยะไกลผ่านช่องทางการสื่อสารที่มีอยู่)
สุดท้ายนี้ เครื่องเสมือน Inferno จะใช้โมดูลมาตรฐานหลายโมดูลภายใน โมดูล Sys ซึ่งจัดเตรียมการเรียกระบบและไลบรารีรูทีนขนาดเล็ก (การสร้างการเชื่อมต่อเครือข่าย การดำเนินการสตริง) โมดูล Draw เป็นไลบรารีกราฟิกหลักที่ทำงานร่วมกับกราฟิกแรสเตอร์ แบบอักษร และหน้าต่าง โมดูล Prefab สร้างขึ้นบน Draw เพื่อรองรับโครงสร้างเชิงซ้อนที่มีรูปภาพและข้อความภายในหน้าต่าง วัตถุเหล่านี้สามารถเลื่อน เลือก แก้ไขได้โดยใช้วิธี Prefab โมดูล Tk คือ การใช้งานใหม่ไลบรารีกราฟิก Tk และอินเทอร์เฟซ Limbo โมดูลคณิตศาสตร์ประกอบด้วยขั้นตอนสำหรับการเขียนโปรแกรมการดำเนินการทางคณิตศาสตร์
สภาพแวดล้อมนรก
Inferno สร้างสภาพแวดล้อมมาตรฐานสำหรับแอปพลิเคชัน แอปพลิเคชันเดียวกันสามารถเปิดใช้งานได้ในสภาพแวดล้อมประเภทต่างๆ รวมถึงสภาพแวดล้อมแบบกระจาย และดูทรัพยากรที่เหมือนกัน ขึ้นอยู่กับสภาพแวดล้อมที่ Inferno กำลังทำงานอยู่ มีเคอร์เนลหลายเวอร์ชัน ตัวแปล Dis/Limbo และชุดไดรเวอร์อุปกรณ์
เมื่อ Inferno ทำงานเป็นระบบปฏิบัติการเดียว เคอร์เนลจะรวมส่วนระดับต่ำที่จำเป็นทั้งหมด (ตัวจัดการขัดจังหวะ กราฟิก และไดรเวอร์อื่นๆ) ที่จำเป็นในการใช้งานนามธรรมระดับสูงสำหรับแอปพลิเคชัน
ในฐานะระบบเกสต์ เช่น บน Unix หรือ Windows Inferno ทำงานเหมือนกับชุดของกระบวนการปกติ แทนที่จะใช้ ความสามารถของตัวเองในการจัดการฮาร์ดแวร์ Inferno ใช้ทรัพยากรที่ได้รับจากระบบปฏิบัติการที่รันอยู่ ตัวอย่างเช่น ภายใต้ Unix ไลบรารีกราฟิกสามารถใช้งานได้โดยใช้ XWindow และรองรับเครือข่ายโดยใช้ไลบรารีซ็อกเก็ต บน Windows Inferno จะใช้เนทิฟ ระบบกราฟิกและวินซ็อคก็โทรมา
Inferno เขียนด้วยมาตรฐาน C และส่วนประกอบส่วนใหญ่ไม่ขึ้นอยู่กับระบบปฏิบัติการที่สามารถโฮสต์ Inferno ได้
การรักษาความปลอดภัยในนรก
Inferno รับประกันการสื่อสารที่ปลอดภัย การใช้ทรัพยากร และความสมบูรณ์ของระบบ
ผ่านช่องทางภายนอกแต่ละช่อง ข้อมูลจะถูกส่งในรูปแบบที่ชัดเจนพร้อมกับการย่อยแบบดิจิทัลเพื่อป้องกันความเสียหาย หรือเข้ารหัสเพื่อป้องกันความเสียหายและการสกัดกั้นข้อมูล คีย์มีการแลกเปลี่ยนผ่านกลไกคีย์สาธารณะมาตรฐาน หลังจากการแลกเปลี่ยนคีย์ การเข้ารหัสและลายเซ็นดิจิทัลจะใช้กลไกแบบสมมาตรมาตรฐาน
Inferno ให้การป้องกันแอปพลิเคชันที่เขียนไม่ดี (มีจุดบกพร่องหรือ "การเบี่ยงเบน") ที่เป็นอันตราย และเปิดใช้งานการสื่อสารที่ปลอดภัยระหว่างผู้ให้บริการและลูกค้าที่ "น่าสงสัย" ทรัพยากร, ที่จำเป็นสำหรับโปรแกรมมีให้เฉพาะในเนมสเปซของโปรแกรมเท่านั้น สิ่งนี้ใช้กับข้อมูล ช่องทางการสื่อสาร รวมถึงไฟล์และไลบรารีที่ปฏิบัติการได้จริง ทรัพยากรระบบที่สำคัญสามารถเข้าถึงได้ผ่านการเรียกไปยังโมดูลที่จัดเตรียมไว้เท่านั้น โดยเฉพาะอย่างยิ่ง การเพิ่มไฟล์และบริการใหม่ลงในพื้นที่ที่กำหนดชื่อจะถูกควบคุมและทำได้หลังจากการรับรองความถูกต้องเท่านั้น ตัวอย่างเช่น ถ้า ทรัพยากรเครือข่ายลบออกจากเนมสเปซของแอปพลิเคชัน จะทำให้ไม่สามารถสร้างการเชื่อมต่อเครือข่ายได้
โมดูลออบเจ็กต์สามารถลงนามเพื่อยืนยันความถูกต้องและความถูกต้องได้ และระบบสามารถตรวจสอบลายเซ็นเหล่านี้ได้เมื่อเข้าถึงโมดูลดังกล่าว
แม้ว่า Inferno จะมีกลไกการตรวจสอบสิทธิ์และการรักษาความปลอดภัยจำนวนมาก ตามรายละเอียดด้านล่าง มีแอปพลิเคชันเพียงไม่กี่รายการที่จำเป็นต้องมีการติดตั้งกลไกเหล่านี้ หรืออย่างน้อยต้องมีการเขียนโปรแกรมบางประเภทเพื่อใช้งาน
บ่อยครั้งที่การเข้าถึงทรัพยากรที่จำกัดผ่านช่องทางที่ปลอดภัยจะถูกจัดเตรียมไว้ล่วงหน้าโดยระบบที่แอปพลิเคชันทำงานอยู่ ตัวอย่างเช่น เมื่อระบบไคลเอนต์ใช้ระบบเซิร์ฟเวอร์และมีการตรวจสอบการเข้าถึงและการเข้ารหัส ทรัพยากรเซิร์ฟเวอร์จะถูกจัดเตรียมให้เป็นส่วนหนึ่งของเนมสเปซของแอปพลิเคชัน ช่องทางการสื่อสารซึ่งมีโปรโตคอล Styx สามารถตั้งค่าสำหรับการตรวจสอบสิทธิ์หรือการเข้ารหัสได้ ด้วยวิธีนี้ การใช้ทรัพยากรทั้งหมดจึงได้รับการปกป้องโดยอัตโนมัติ
กลไกการรักษาความปลอดภัย
การรับรองความถูกต้องและลายเซ็นดิจิทัลจะแสดงโดยการใช้การเข้ารหัส กุญแจสาธารณะ- กุญแจสาธารณะได้รับการรับรองและลงนามโดยกุญแจส่วนตัวขององค์กรที่ออกใบรับรอง
Inferno ใช้การเข้ารหัสเพื่อ:
- การรับรองความถูกต้องของฝ่ายต่างๆอย่างต่อเนื่อง
- การตรวจสอบข้อความระหว่างฝ่าย;
- การเข้ารหัสข้อความ
อัลกอริธึมการเข้ารหัสที่จัดทำโดย Inferno ประกอบด้วยแฮช SHA, MD4 และ MD5 ลายเซ็นสาธารณะและการยืนยันลายเซ็น Elgamal การเข้ารหัส RC4 และ DES การแลกเปลี่ยนคีย์ส่วนตัวสาธารณะจะขึ้นอยู่กับโครงการ Diffie Hellman ลายเซ็นคีย์สาธารณะสามารถมีความยาวได้สูงสุด 4096 บิต โดยมีค่าเริ่มต้นที่ 512 บิต
ไม่มีองค์กรระดับชาติหรือระดับนานาชาติทั่วไปในการจัดเก็บหรือสร้างคีย์การเข้ารหัสสาธารณะหรือส่วนตัว ดังนั้น Inferno จึงรวมเครื่องมือสำหรับการใช้หรือสร้างองค์กรที่เชื่อถือได้ แต่ไม่ได้จัดเตรียมองค์กรดังกล่าวไว้เนื่องจากเป็นคุณลักษณะด้านการดูแลระบบ ดังนั้น องค์กรที่ใช้ Inferno (หรือระบบความปลอดภัยและการแลกเปลี่ยนคีย์อื่น) จึงต้องสร้างขึ้น ระบบของตัวเองตามความต้องการของคุณและโดยเฉพาะอย่างยิ่งการตัดสินใจว่าจะมอบใบรับรองให้กับใคร อย่างไรก็ตาม การออกแบบของ Inferno มีความยืดหยุ่นและเป็นโมดูลาร์เพียงพอที่จะรองรับโปรโตคอลที่ใช้ในทางปฏิบัติ
ผู้ออกใบรับรองที่ลงนามคีย์สาธารณะของผู้ใช้จะกำหนดขนาดคีย์และอัลกอริทึม เครื่องมือที่ Inferno มอบให้ใช้ลายเซ็นเหล่านี้ในการตรวจสอบสิทธิ์ สำหรับการลงนามและการตรวจสอบ แอปพลิเคชัน Limbo จะได้รับไลบรารีอินเทอร์เฟซ
เมื่อฝ่ายต่างๆ แลกเปลี่ยนข้อมูล พวกเขาจะใช้โปรโตคอล Station to Station เพื่อระบุฝ่ายต่างๆ และสร้างรหัสลับ โปรโตคอล Station to Station ใช้อัลกอริธึม Diffie-Hellman เพื่อสร้างรหัสลับที่ใช้ร่วมกัน โปรโตคอลได้รับการปกป้องจากการโจมตีซ้ำโดยการเลือกค่าใหม่สำหรับการโต้ตอบแต่ละครั้ง โปรโตคอลมีความปลอดภัยจากการโจมตีแบบแทรกกลางโดยการแลกเปลี่ยนใบรับรองระหว่างฝ่ายต่างๆ จากนั้นลงนามส่วนสำคัญของโปรโตคอล หากต้องการปลอมตัวเป็นอีกฝ่าย ผู้โจมตีจะต้องเลียนแบบลายเซ็นของฝ่ายนั้น
การรักษาความปลอดภัยสาย
การสื่อสารผ่านเครือข่ายสามารถป้องกันการดัดแปลงหรือดัดแปลงและการดักฟังได้ เพื่อป้องกันการดัดแปลง Inferno สามารถใช้แฮช MD5 หรือ SHA (เรียกว่าไดเจสต์) -
แฮช (ความลับ ข้อความ รหัสข้อความ)
สำหรับแต่ละข้อความ Messageid คือตัวเลขลำดับที่ 32 ซึ่งเริ่มต้นที่ 0 และเพิ่มขึ้น 1 สำหรับแต่ละข้อความที่ตามมา นั่นคือไม่สามารถเปลี่ยนแปลงหรือลบข้อความได้ ลำดับของข้อความในสตรีมไม่สามารถเปลี่ยนได้เฉพาะในกรณีที่มีคีย์หรืออัลกอริธึมแฮชถูกแคร็ก
เพื่อป้องกันการดักฟัง Inferno ใช้การเข้ารหัสของเซสชันทั้งหมดโดยใช้ RC4 หรือ DES (DESCBC, DESECB)
Inferno ใช้รูปแบบการห่อหุ้มแบบเดียวกับ Secure Sockets Layer ของ Netscape การห่อหุ้มสตรีมข้อความหลายรายการสามารถทำได้เพื่อให้การป้องกันในระดับที่แตกต่างกัน
ตัวเลขสุ่ม
ความแรงของอัลกอริธึมการเข้ารหัสนั้นขึ้นอยู่กับโดยเฉพาะ ตัวเลขสุ่มใช้เพื่อเลือกคีย์ พารามิเตอร์ Diffie Hellman เวกเตอร์การเริ่มต้น ฯลฯ Inferno บรรลุเป้าหมายนี้ในสองขั้นตอน: ได้รับสตรีมบิตแบบสุ่มที่ช้า (100 ถึง 200 bps) โดยการสุ่มตัวอย่างบิตต่ำของตัวนับที่ทำงานอย่างอิสระในแต่ละรอบสัญญาณนาฬิกา ชั่วโมง. นาฬิกาจะต้องไม่ซิงโครไนซ์ หรือซิงโครไนซ์กับตัวนับได้ไม่ดี เครื่องกำเนิดตัวเลขสุ่มนี้ใช้เพื่อเปลี่ยนสถานะ เครื่องกำเนิดไฟฟ้าที่รวดเร็วตัวเลขสุ่มเทียม เครื่องกำเนิดไฟฟ้าทั้งสองได้รับการทดสอบบนสถาปัตยกรรมที่หลากหลายโดยใช้ความสัมพันธ์ในตัวเอง การเคลื่อนไหวแบบสุ่ม และการทดสอบซ้ำๆ
คำอธิบายของนรก
เขียนบทวิจารณ์ในบทความ "Inferno (ระบบปฏิบัติการ)"
หมายเหตุ
ดูเพิ่มเติม
ลิงค์
- (ภาษาอังกฤษ)
- พร้อมแหล่งข้อมูลอย่างเป็นทางการ (อังกฤษ)
- (รัสเซีย)
- (รัสเซีย)
- (รัสเซีย)
- (รัสเซีย)
- - บทความที่มีรายการลิงก์ไปยังแหล่งข้อมูลอื่นใน Inferno (รัสเซีย)
- (ภาษาอังกฤษ)
- (รัสเซีย)
- (รัสเซีย)
|
||||||||||||||||||||
ข้อความที่ตัดตอนมาจากลักษณะ Inferno (ระบบปฏิบัติการ)
“ นี่คือ Metampsic” Sonya ผู้เรียนดีมาโดยตลอดและจดจำทุกสิ่งกล่าว – ชาวอียิปต์เชื่อว่าจิตวิญญาณของเราอยู่ในสัตว์และจะกลับไปเป็นสัตว์“ไม่ เธอก็รู้ ฉันไม่เชื่อว่าเราเป็นสัตว์” นาตาชาพูดด้วยเสียงกระซิบเดียวกัน แม้ว่าดนตรีจะจบลงแล้ว “แต่ฉันรู้แน่ว่าเราเป็นนางฟ้าที่นี่และที่นั่นที่ไหนสักแห่ง และนั่นคือเหตุผลว่าทำไม เราจำทุกอย่างได้” ...
- ฉันสามารถเข้าร่วมกับคุณได้ไหม? - Dimmler ซึ่งเดินเข้ามาหาอย่างเงียบ ๆ และนั่งลงข้างพวกเขากล่าว
- ถ้าเราเป็นนางฟ้าแล้วทำไมเราถึงตกต่ำลงล่ะ? - นิโคไลกล่าว - ไม่ เป็นไปไม่ได้!
“ไม่ต่ำกว่าใครบอกคุณว่าต่ำกว่านั้น?... ทำไมฉันถึงรู้ว่าฉันเคยเป็นอะไรมาก่อน” นาตาชาคัดค้านด้วยความมั่นใจ - ท้ายที่สุดแล้ว จิตวิญญาณนั้นเป็นอมตะ... ดังนั้น ถ้าฉันมีชีวิตอยู่ตลอดไป ฉันก็ใช้ชีวิตแบบเมื่อก่อนนั่นแหละ มีชีวิตอยู่ชั่วนิรันดร์
“ใช่ แต่มันยากสำหรับเราที่จะจินตนาการถึงความเป็นนิรันดร์” ดิมเลอร์กล่าว ซึ่งเข้าหาคนหนุ่มสาวด้วยรอยยิ้มที่ดูถูกเหยียดหยาม แต่ตอนนี้พูดอย่างเงียบๆ และจริงจังเหมือนที่พวกเขาทำ
– เหตุใดจึงยากที่จะจินตนาการถึงความเป็นนิรันดร์? - นาตาชากล่าว - วันนี้ก็จะเป็น พรุ่งนี้ก็จะเป็น จะเป็นตลอดไป เมื่อวานก็เป็น และเมื่อวานก็เป็น...
- นาตาชา! ตอนนี้ถึงตาคุณแล้ว “ ร้องเพลงให้ฉันหน่อยสิ” ได้ยินเสียงของคุณหญิง - ที่คุณนั่งลงเหมือนผู้สมรู้ร่วมคิด
- แม่! “ฉันไม่อยากทำแบบนั้น” นาตาชาพูด แต่ในขณะเดียวกันเธอก็ลุกขึ้นยืน
พวกเขาทั้งหมดแม้แต่ Dimmler วัยกลางคนก็ไม่ต้องการขัดจังหวะการสนทนาและลุกจากมุมโซฟา แต่นาตาชาลุกขึ้นยืนและนิโคไลก็นั่งลงที่กระดูกไหปลาร้า เช่นเคยยืนอยู่กลางห้องโถงและเลือก ทำเลที่ตั้งดีเยี่ยมนาตาชาเริ่มร้องเพลงโปรดของแม่ของเธอเพื่อให้เกิดเสียงสะท้อน
เธอบอกว่าเธอไม่อยากร้องเพลง แต่เธอไม่ได้ร้องเพลงมานานแล้ว และตั้งแต่นั้นเป็นต้นมา วิธีการร้องเพลงของเธอในเย็นวันนั้นก็นานมาแล้ว Count Ilya Andreich จากออฟฟิศที่เขาคุยกับ Mitinka ได้ยินเธอร้องเพลงและเหมือนนักเรียนรีบไปเล่นจบบทเรียนเขาสับสนในคำพูดของเขาออกคำสั่งกับผู้จัดการและในที่สุดก็เงียบไป และมิทินกาก็ฟังอย่างเงียบ ๆ ด้วยรอยยิ้มยืนอยู่หน้านับ นิโคไลไม่ได้ละสายตาจากน้องสาวของเขาและสูดลมหายใจร่วมกับเธอ Sonya กำลังฟังอยู่และคิดว่าเธอกับเพื่อนของเธอมีความแตกต่างกันมากเพียงใด และเป็นไปไม่ได้เลยที่เธอจะมีเสน่ห์เหมือนลูกพี่ลูกน้องของเธอจากระยะไกล เคาน์เตสเฒ่านั่งด้วยรอยยิ้มเศร้าและน้ำตาในดวงตาของเธอและส่ายหัวเป็นครั้งคราว เธอคิดถึงนาตาชาและวัยเยาว์ของเธอและว่ามีบางสิ่งที่ผิดธรรมชาติและน่ากลัวในการแต่งงานของนาตาชากับเจ้าชายอังเดรที่กำลังจะเกิดขึ้นนี้
ดิมม์เลอร์นั่งลงข้างคุณหญิงและหลับตาฟัง
“ไม่ เคาน์เตส” ในที่สุดเขาก็พูด “นี่คือพรสวรรค์ของชาวยุโรป เธอไม่มีอะไรจะเรียนรู้ ความนุ่มนวล ความอ่อนโยน ความแข็งแกร่งนี้…”
- อ่า! “ ฉันกลัวเธอแค่ไหนฉันกลัวแค่ไหน” เคาน์เตสกล่าวโดยจำไม่ได้ว่าเธอกำลังคุยกับใคร สัญชาตญาณของความเป็นแม่บอกเธอว่านาตาชามีบางอย่างมากเกินไป และสิ่งนี้จะไม่ทำให้เธอมีความสุข นาตาชายังร้องเพลงไม่จบเมื่อ Petya วัย 14 ปีผู้กระตือรือร้นวิ่งเข้าไปในห้องพร้อมข่าวว่ามัมมี่มาถึงแล้ว
นาตาชาหยุดกะทันหัน
- คนโง่! - เธอตะโกนใส่น้องชาย วิ่งขึ้นไปบนเก้าอี้ ล้มลงบนเก้าอี้ ร้องไห้หนักมากจนหยุดไม่ได้นาน
“ไม่มีอะไรค่ะแม่ ไม่มีอะไรจริงๆ แบบนี้ Petya ทำให้ฉันกลัว” เธอพูดและพยายามยิ้ม แต่น้ำตายังคงไหลและเสียงสะอื้นก็สำลักคอของเธอ
แต่งตัวคนรับใช้ หมี เติร์ก เจ้าของโรงแรม สุภาพสตรี น่ากลัวและตลก นำความเย็นชาและความสนุกสนานมาด้วย ในตอนแรกรวมตัวกันอย่างขี้อายในโถงทางเดิน จากนั้นพวกเขาก็ถูกบังคับให้เข้าไปในห้องโถงโดยซ่อนตัวหนึ่งไว้ข้างหลัง และในตอนแรกอย่างเขินอาย จากนั้นเพลง การเต้นรำ การร้องเพลงประสานเสียง และเกมคริสต์มาสก็เริ่มขึ้นอย่างร่าเริงและเป็นกันเองมากขึ้นเรื่อยๆ เคาน์เตสจำใบหน้าได้และหัวเราะเยาะคนที่แต่งตัวประหลาดจึงเข้าไปในห้องนั่งเล่น นับ Ilya Andreich นั่งอยู่ในห้องโถงด้วยรอยยิ้มอันสดใสซึ่งเห็นชอบจากผู้เล่น เยาวชนหายไปที่ไหนสักแห่ง
ข้อมูลในโพสต์ที่แล้วล้าสมัยไปเกือบ 4 ปีแล้ว เลยถูกขอให้อัปเดต พวกเขายังขอไม่ให้รวมการติดตั้งเข้ากับการปรับแต่งในโพสต์เดียว ดังนั้นจะมีการติดตั้งที่นี่เท่านั้น และการตั้งค่า Inferno อธิบายไว้ในโพสต์แยกต่างหาก อัปเดต:คำอธิบายการติดตั้งสำหรับ Windows อัปเดตเมื่อเดือนมิถุนายน 2014
ดังนั้นเราจะติดตั้ง Inferno OS แบบกระจาย เว็บไซต์อย่างเป็นทางการมีคำแนะนำในการติดตั้ง แต่คำแนะนำเหล่านี้ไม่ถูกต้องทั้งหมดและล้าสมัยไปเล็กน้อยด้วย Inferno สามารถทำงานในสองโหมด - พื้นเมือง(บน Bare Metal หรือใน qemu/etc เช่นเดียวกับ OS ทั่วไปทั้งหมด) และ เป็นเจ้าภาพ(ยังไง แอปพลิเคชันปกติภายใต้ *NIX/Win) คำแนะนำในการติดตั้ง Native Inferno สามารถพบได้ในวิกิภาษารัสเซีย นอกจากนี้ยังมีตัวเลือกอื่นๆ เช่น การติดตั้ง Inferno บน Android (ภาษาอังกฤษ) โดยส่วนตัวแล้ว ฉันไม่เห็นจุดใดในการใช้ Inferno แบบเนทีฟบนคอมพิวเตอร์ทั่วไป ดังนั้นฉันจะอธิบายการติดตั้ง Inferno ที่โฮสต์ไว้ภายใต้ Gentoo, Ubuntu, FreeBSD, MacOSX และ Windows
คุณสมบัติการติดตั้ง
ระบบปฏิบัติการ Inferno เวอร์ชัน
ตามทฤษฎีแล้ว "ฉบับที่สี่" อย่างเป็นทางการครั้งสุดท้ายออกประมาณปี 2547 เวอร์ชันปัจจุบันอยู่ในที่เก็บ Mercurial บน Google Code และเรียกตัวเองว่า "New Edition" ในทางปฏิบัติ ไม่มีประโยชน์ที่จะใช้สิ่งอื่นนอกเหนือจากเวอร์ชันปัจจุบันจากพื้นที่เก็บข้อมูล - มันมีความเสถียรอย่างแน่นอนและมีเสถียรภาพอยู่เสมอ เราจะติดตั้งมันรูปแบบการติดตั้งแบบผู้ใช้คนเดียวหรือหลายคน
สามารถติดตั้ง Inferno ได้ทั้งระบบ (เช่น ใน /usr/inferno/) เพื่อให้ผู้ใช้ทุกคนสามารถใช้งานได้ Inferno รองรับทุกสิ่งที่จำเป็นสำหรับสิ่งนี้ - ทำงานกับสิทธิ์ผู้ใช้ แยกโฮมไดเร็กตอรี่ ฯลฯ ในทางกลับกัน คุณสามารถใส่ inferno ลงในโฮมไดเร็กตอรี่ของคุณ (เช่น ใน ~/inferno/) ซึ่งจะสะดวกกว่า ฉันทำให้บทความที่แล้วซับซ้อนขึ้นเล็กน้อยโดยการอธิบายทั้งสองวิธีในเวลาเดียวกัน แต่ตอนนี้ฉันตัดสินใจว่าจะง่ายกว่าที่จะอธิบายเฉพาะตัวเลือกการติดตั้งแบบผู้ใช้คนเดียว หากผู้อ่านบทความนี้คนใดมีเซิร์ฟเวอร์ที่มีผู้ใช้ Inferno มากกว่าหนึ่งคน พวกเขาก็คงไม่ต้องใช้คำแนะนำของฉันในการติดตั้ง Inferno ;-) ดังนั้นเราจะติดตั้งมันใน ~/inferno/ บนระบบ *NIX และใน C:\inferno\ บน Windows32/64 บิต
ระบบปฏิบัติการ Inferno 32 บิต ดังนั้น ในการติดตั้งและรันบนระบบปฏิบัติการ 64 บิต จำเป็นต้องมีการรองรับแอปพลิเคชัน 32 บิตบนระบบปฏิบัติการเหล่านี้ น่าเสียดายที่ฉันไม่สามารถรัน Inferno ภายใต้ FreeBSD-9.0 64 บิตได้แข็งตัว/PaX/SeLinux/ฯลฯ
Inferno รันโค้ดใน เครื่องเสมือนแถมยังรองรับ JIT จึงมีปัญหาเดียวกันกับการป้องกันต่าง ๆ เช่น Java เป็นต้น ในบทความก่อนหน้านี้ ฉันให้ความสำคัญกับหัวข้อนี้มากขึ้น หากคุณมีคำถามใดๆ โปรดดูที่นั่นเวลาและสถานที่
นรกที่ติดตั้งจะใช้เวลาประมาณ 200MB แต่การติดตั้งคอมไพเลอร์อาจต้องใช้พื้นที่มากถึง 3 กิกะไบต์ (เช่น บน Xcode หรือ วิชวลสตูดิโอ- Inferno รวบรวมในระบบโดยเฉลี่ยภายในไม่กี่นาทีที่ตั้ง
เมื่อติดตั้ง inferno ลงในโฮมไดเร็กตอรี่ของคุณ คุณควรจำไว้ว่า inferno ไม่ชอบความพิเศษ อักขระในชื่อไฟล์/ไดเร็กทอรี ดังนั้น หากเส้นทางไปยัง โฮมไดเร็กทอรีตัวอย่างเช่นมีช่องว่าง - อาจเกิดปัญหาที่ฉันไม่ได้คำนึงถึงการติดตั้ง
ใน (แข็งตัว) Gentoo Linux 32/64-บิต ทุกอย่างไม่สำคัญ - มีแพ็คเกจที่ติดตั้ง inferno ทั้งระบบใน /usr/inferno/ :คนธรรมดา -ผู้มีอำนาจโผล่ออกมาจากนรก
และตอนนี้เราจะจัดการกับระบบปฏิบัติการที่เหลือ
Mercurial, คอมไพเลอร์ และทุกสิ่ง ทุกอย่าง
... อูบุนตู 12.04 32 บิต
sudo apt-get ติดตั้ง -y mercurial sudo apt-get ติดตั้ง -y libxext-dev... อูบุนตู 12.04 64 บิต
sudo apt-get ติดตั้ง -y mercurial sudo apt-get ติดตั้ง -y libc6-dev-i386 sudo apt-get ติดตั้ง -y libxext-dev:i386... FreeBSD 8.0 32 บิต
pkg_add -r ปรอท...แมคโอเอสเอ็กซ์ 10.6.8 เสือดาวหิมะ 32 บิต
ฉันติดตั้ง Xcode (3.2.2) และ Mercurial (1.7.1) แล้ว...Mac OS X 10.7.4 ไลออน 64 บิต
ติดตั้ง Xcode (4.3.2) ผ่านทาง App Storeเปิด Xcode ไปที่เมนู Xcode - การตั้งค่า - ดาวน์โหลด และคลิกติดตั้งสำหรับเครื่องมือบรรทัดคำสั่ง
ไปที่ mercurial.berkwood.com และดาวน์โหลด/ติดตั้งเวอร์ชันปัจจุบัน (Mercurial 2.2.2 สำหรับ OS X 10.7)
... Windows (XP 32 บิต, เซเว่น 32 บิต, เซเว่น 64 บิต)
ไปที่ mercurial.selenic.com/downloads และดาวน์โหลด/ติดตั้งเวอร์ชันปัจจุบัน (3.0.1)แต่ด้วยคอมไพเลอร์มีตัวเลือกมากมาย ตัวเลือกที่ชัดเจนในการติดตั้ง Visual Studio Express จะมีราคามากกว่า 3 กิกะไบต์ต่อสกรู ทางเลือกอื่น- ติดตั้ง WinSDK - จะมีราคาประมาณ 800 เมกะไบต์ ฉันจะอธิบายทั้งสองตัวเลือก เลือกด้วยตัวคุณเอง
ตัวเลือกแรก ไปที่ www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-cpp-express และดาวน์โหลด/ติดตั้ง/อัปเดต (ตามธรรมเนียมของรัสเซีย - สามครั้ง :) มิฉะนั้นจะไม่ได้ติดตั้งการอัปเดตทั้งหมด) “ วิชวลซี++ 2010 เอ็กซ์เพรส”
ตัวเลือกที่สอง ขั้นแรก ไปที่ go.microsoft.com/fwlink/?LinkId=187668 และดาวน์โหลด/ติดตั้งไฟล์ ". NET Framework 4" จากนั้นไปที่ www.microsoft.com/en-us/download/details.aspx?id=8279 และดาวน์โหลด/ติดตั้ง “Windows SDK 7.1” เมื่อทำการติดตั้ง เพียงจำกัดตัวเองอยู่เพียงจุดเหล่านี้:
# การพัฒนาโค้ด Windows Native: # ส่วนหัวและไลบรารีของ Windows: # [X] ส่วนหัวของ Windows # [X] ไลบรารี x86 # [X] คอมไพเลอร์ Visual C++ # แพ็คเกจที่แจกจ่ายต่อได้: # [X] Microsoft Visual C++ 2010 (ในปี 2014 SDK ของฉันปฏิเสธที่จะติดตั้งจนกว่าฉันจะถอนการติดตั้ง Visual C++ 2010 Redistributable ทั้งหมด - มันกลายเป็นเวอร์ชันใหม่เกินไปสำหรับมัน)จากนั้นเราก็อัปเดตด้วย จริงๆ แล้วอาจไม่จำเป็นต้องอัปเดต มันแค่กลายเป็นนิสัยไปแล้ว
ดาวน์โหลดและอัปเดตแหล่งที่มาของนรก
แม้ว่าเว็บไซต์อย่างเป็นทางการจะเสนอไฟล์เก็บถาวรแยกต่างหากสำหรับ Windows และไบนารีแยกต่างหากสำหรับ Mac แต่เราไม่ต้องการทั้งหมดนี้และมันก็เป็นอันตรายด้วยซ้ำ (ไฟล์เก็บถาวรสำหรับ Windows ไม่ได้รับการอัปเดตตามปกติจากพื้นที่เก็บข้อมูล - มีข้อขัดแย้งเกิดขึ้น) ดังนั้นภายใต้ระบบปฏิบัติการทั้งหมด เราจะติดตั้งจาก inferno-20100120.tgz ประเด็นคือการใช้ไฟล์เก็บถาวรนี้แทน การโคลนนิ่งแบบง่ายๆพื้นที่เก็บข้อมูลคือไฟล์เก็บถาวรมีไฟล์บางไฟล์ (ส่วนใหญ่เป็นแบบอักษร) ที่ใบอนุญาตห้ามมิให้โพสต์บน Google Code ดังนั้นจึงไม่อยู่ในพื้นที่เก็บข้อมูล… *นิกซ์
wget http://www.vitanuova.com/dist/4e/inferno-20100120.tgz tar xzf inferno-20100120.tgz ซีดีนรก/ hg ดึง -uv...ชนะ
ดาวน์โหลด www.vitanuova.com/dist/4e/inferno.zip (แนะนำบนเว็บไซต์ แต่คุณสามารถใช้ .tgz ได้เช่นกัน - ฉันสามารถประกอบทั้งสองอย่างได้โดยไม่มีปัญหา)แตกไฟล์ไปที่ C:\inferno\ ฉันไม่รู้ว่าต้องใช้อะไรบ้างในการแตกไฟล์ .tgz ใน Windows - ฉันติดตั้ง Far และ 7Zip ไว้ และฉันก็แตกมันด้วย Far
เปิดตัว cmd
cd \inferno hg pull -uv # หากเราได้รับข้อขัดแย้งเช่น: การผสาน libinterp/keyring.h คำเตือน: ข้อขัดแย้งระหว่างการผสาน การรวม libinterp/keyring.h ไม่สมบูรณ์! (แก้ไขข้อขัดแย้ง จากนั้นใช้ "hg solve --mark") การรวมคำเตือน libinterp/runt.h: ข้อขัดแย้งระหว่างการผสาน การรวม libinterp/runt.h ไม่สมบูรณ์! (แก้ไขข้อขัดแย้ง จากนั้นใช้ "hg solve --mark") อัปเดตไฟล์ 3038 ไฟล์ รวม 0 ไฟล์ ลบ 106 ไฟล์ 2 ไฟล์ไม่ได้รับการแก้ไข ใช้ "hg แก้ไข" เพื่อลองรวมไฟล์ที่ยังไม่ได้แก้ไขอีกครั้ง # จากนั้นเพียงคืนค่าเวอร์ชันล่าสุด: hg revert - r tip libinterp\keyring.h hg revert -r tip libinterp\runt.h Exit cmd
การตั้งค่าตัวแปรสภาพแวดล้อม
ตัวแปรเดียวที่จำเป็นจริงๆคือ PATH EMU ตั้งค่าพารามิเตอร์เริ่มต้นสำหรับการเปิดตัว Inferno เพื่อความสะดวกเท่านั้น สำหรับ INFERNO_ROOT นั้น Inferno ไม่รู้เรื่องนี้เลย เราต้องการตัวแปรนี้เพื่อความสะดวกเท่านั้น นอกจากการตั้งค่าตัวแปรในเซสชันปัจจุบันแล้ว เรายังเขียนตัวแปรเหล่านั้นลงในสคริปต์เริ่มต้นอีกด้วย... อูบุนตู
ส่งออก INFERNO_ROOT=$(pwd) ส่งออก PATH=$INFERNO_ROOT/Linux/386/bin:$PATH ส่งออก EMU=-r$INFERNO_ROOT echo "ส่งออก INFERNO_ROOT=$INFERNO_ROOT" >> ~/.bashrc echo "ส่งออก PATH=\$INFERNO_ROOT /Linux/386/bin:\$PATH" >> ~/.bashrc echo "ส่งออก EMU=-r\$INFERNO_ROOT" >> ~/.bashrc... ฟรีบีเอสดี
ส่งออก INFERNO_ROOT=$(pwd) ส่งออก PATH=$INFERNO_ROOT/FreeBSD/386/bin:$PATH ส่งออก EMU=-r$INFERNO_ROOT echo "ส่งออก INFERNO_ROOT=$INFERNO_ROOT" >> ~/.bash_profile echo "ส่งออก PATH=\$INFERNO_ROOT /FreeBSD/386/bin:\$PATH" >> ~/.bash_profile echo "ส่งออก EMU=-r\$INFERNO_ROOT" >> ~/.bash_profile...แมค โอเอส เอ็กซ์
ส่งออก INFERNO_ROOT=$(pwd) ส่งออก PATH=$INFERNO_ROOT/MacOSX/386/bin:$PATH ส่งออก EMU=-r$INFERNO_ROOT echo "ส่งออก INFERNO_ROOT=$INFERNO_ROOT" >> ~/.bash_profile echo "ส่งออก PATH=\$INFERNO_ROOT /MacOSX/386/bin:\$PATH" >> ~/.bash_profile echo "ส่งออก EMU=-r\$INFERNO_ROOT" >> ~/.bash_profile...ชนะ
ไปที่: แผงควบคุม -> ระบบ -> พารามิเตอร์ระบบเพิ่มเติม (ใน XP เรียกง่ายๆ ว่า "ขั้นสูง") -> ตัวแปรสภาพแวดล้อมเพิ่มที่ส่วนท้ายของ Path: ;C:\inferno\Nt\386\bin
สร้างตัวแปรใหม่: INFERNO_ROOT: C:\inferno
สร้างตัวแปรใหม่: อีมู: -rC:\inferno
การกำหนดค่าพารามิเตอร์บิลด์
คุณสามารถแก้ไขไฟล์ mkconfig ได้ด้วยตนเองในทุกระบบปฏิบัติการ แต่เพื่อความง่าย หากเป็นไปได้ ฉันจะจัดเตรียมคำสั่งที่เปลี่ยนการกำหนดค่าโดยอัตโนมัติ... อูบุนตู
perl -i -pe "s/^ROOT=.*/ROOT=$ENV(INFERNO_ROOT)/m" mkconfig perl -i -pe "s/^SYSHOST=.*/SYSHOST=Linux/m" mkconfig perl -i - pe "s/^OBJTYPE=.*/OBJTYPE=386/m" mkconfig.peใน Linux Inferno รองรับ IPv6 นอกจากนี้ IPv6 ยังถูกใช้เป็นค่าเริ่มต้นอีกด้วย ไม่ว่าจะเหมาะกับคุณหรือไม่ - ตัดสินใจด้วยตัวเอง โดยส่วนตัวแล้วฉันปิดมัน:
perl -i -pe "s/ipif6/ipif/g" อีมู/Linux/อีมู อีมู/Linux/emu-g
... ฟรีบีเอสดี
perl -i -pe "s/^ROOT=.*/ROOT=$ENV(INFERNO_ROOT)/m" mkconfig perl -i -pe "s/^SYSHOST=.*/SYSHOST=FreeBSD/m" mkconfig perl -i - pe "s/^OBJTYPE=.*/OBJTYPE=386/m" mkconfig.pe...แมค โอเอส เอ็กซ์
perl -i -pe "s/^ROOT=.*/ROOT=$ENV(INFERNO_ROOT)/m" mkconfig perl -i -pe "s/^SYSHOST=.*/SYSHOST=MacOSX/m" mkconfig perl -i - pe "s/^OBJTYPE=.*/OBJTYPE=386/m" mkconfig.pe...ชนะ
แก้ไข mkconfig:ROOT=c:/นรก SYSHOST=Nt OBJTYPE=386
การประกอบ
… *นิกซ์
sh makemk.sh mk nuke mk install # ข้ามคำสั่งนี้บนเซิร์ฟเวอร์ที่ไม่มี X และ GUI mk CONF=emu-g ติดตั้ง...วินเซเว่น 64 บิต
หากคุณติดตั้ง WinSDK คุณต้องทำ ทางลัดใหม่บน “พรอมต์คำสั่ง Windows SDK 7.1” ไปที่คุณสมบัติและเพิ่มพารามิเตอร์ /x86 - ดังนั้นจึงมีลักษณะดังนี้:C:\Windows\System32\cmd.exe /E:ON /V:ON /T:0E /K "C:\Program Files\Microsoft SDKs\Windows\v7.1\Bin\SetEnv.cmd" /x86
หากคุณติดตั้ง Visual C++ 2010 ฉันไม่รู้วิธีเรียกใช้คอมไพเลอร์ 32 บิต (แต่บางทีก็สามารถทำได้ในลักษณะเดียวกัน)
สิ่งที่ต้องทำถัดไปจะอธิบายไว้ในย่อหน้าถัดไปสำหรับ Windows ทุกรุ่น
...ชนะ
เปิด “พรอมต์คำสั่ง Windows SDK 7.1” (หรือ “พรอมต์คำสั่ง Visual Studio (2010)” - ขึ้นอยู่กับสิ่งที่คุณติดตั้ง)cd\inferno mk nuke mk ติดตั้ง
ปล่อย
จริงๆแล้วนั่นคือทั้งหมดที่ ตอนนี้คุณสามารถเรียกใช้ inferno ด้วยคำสั่ง emu หรือ emu-g (อย่างที่สองแตกต่างตรงที่ไม่รองรับ โหมดกราฟิกแต่จะทำงานบนเซิร์ฟเวอร์ที่ไม่มี X และสะดวกมากสำหรับการใช้บริการเครือข่ายต่างๆ) สภาพแวดล้อมแบบกราฟิกสามารถมองเห็นได้โดยการรันคำสั่ง wm/wm ภายในนกอีมู:$ นกอีมู ; wm/wm
