Всё, что вы хотели знать о Singularity, но боялись спросить

Автор оригинала: Mike Hearn
  • Перевод


Мне бы хотелось написать что-нибудь про Microsoft Singularity. Это очень клёвая штука, и в IT сегодня все говорят про это. Вот обзор Singularity для тех, кто не хочет читать официальные публикации.






Что это такое


Singularity — это исследовательский проект по разработке операционной системы. Это команда умных людей, которым сказали: «Как бы вы сделали операционную систему, изначально ориентированную на надёжность?».



Люди на популярных форумах вроде Slashdot или OSNews уже годами мечтают о том, чтобы Microsoft отказалась от Windows и начала всё с чистого листа — чтобы побороть проблемы ненадёжности или вредоносного кода (malware). Обычно мечтания всех этих людей крутятся вокруг идеи переноса Windows на какой-нибудь UNIX — но это говенная идея, это не решило бы основных проблем. Если вы хотите решить проблемы, вызванные фундаментальными особенностями дизайна, вам следует начать с дизайна. Что и делается в Singularity.



Надёжность — это довольно обширный вопрос. Как минимум, это означает, что приложения не падают и что они безопасны. Но несмотря на то, что разработка Singularity затрагивает множество областей, у разработчиков нет задачи сделать полноценную ОС — к примеру, они не занимаются разработками GUI.





В чём разница?


Собственно, это то, о чём я буду говорить здесь.



Singularity — это микроядерный дизайн, а также высокая производительность, единое адресное пространство, статическая верификация типов и гибкое управление правами доступа.



О да, в предыдущем предложении была целая куча пугающих академических терминов. Давайте попробуем разобраться в них. Это будет непросто, потому что Singularity довольно далека от стандартных дизайнов OS из учебников.



Singularity — высокопроизводительна. Вообще-то, производительность не была целью проекта, но разработчики оказались достаточно умны для осознания того, что без этого их разработка «улетит в облака» и станет совершенно некоммерциализируемой. Это косвенно указывает на то, что Microsoft планирует когда-нибудь использовать эту разработку в реальных продуктах, так что ей необходимо быть быстрой (об этом немного попозже).



А еще Singularity — это микроядро. Давайте сейчас сфокусируемся на том, что это такое. Мы поговорим об остальных вещах позже. Прокрутите вниз, если вы уже в курсе всего этого — в таком случае будем считать, что вы совершенно точно знаете, что такое микроядро и почему оно считается медленным.





Э-э-э… микро-что?


Исторически сложились два способа спроектировать операционную систему, два способа сделать одно и то же, используя разные соотношения затрат и результатов: микроядро или монолитное ядро. Заметьте, мы сейчас говорим о низкоуровневом дизайне… это не влияет на то, используете ли вы taskbar или dock в своём UI.



В микроядерном дизайне подсистемы вроде файловой системы или сетевых драйверов работают как более-менее обычные программы вне самого ядра (которое отличается от других программ тем, что работает в специальном режиме процессора). Ядро отвечает лишь за создание процессов/потоков, пересылку сообщений между ними и за некоторые другие мелкие вещи, типа распределения ресурсов CPU. Истинных микроядер на сегодняшний день практически нигде не встретишь. Скорее всего, вы использовали его, даже не подозревая об этом. К примеру, QNX — операционная система, разработанная для встроенных приложений, вроде роутеров Cisco. QNX — это чистое микроядро.



Хозяйке на заметку


Вот краткий обзор виртуальной памяти. Когда ваш код читает что-то из памяти, CPU внутри преобразовывает ваш адрес из виртуального адреса в физический адрес, который он может скормить контроллерам памяти. На 32-х битном CPU они оба являются 32-х битными указателями, и вы, скорее всего, никогда не увидите непосредственный физический адрес, если только вы не ядерный разработчик. Это преобразование делается компонентом процессора, который называется MMU (memory management unit) — он также реализует контроль доступа. Память разбивается на «страницы» по 4 килобайта (в чипах Intel/AMD) и для каждой страницы заводится своё отображение (mapping). У страницы отображения есть биты доступа — read/write/execute — прямо как у файлов в UNIX.



Такое отображение памяти является основой безопасности во всех операционных системах. Оно не даёт глючащей программе гадить в память других программ, и — поскольку лишь ядро может обновлять таблицы страниц памяти, плюс весь доступ к железу происходит через ядро — такая программа, работающая в пользовательском режиме процессора, ничего «интересного» сделать не сможет, пока ядро не позволяет это делать. А поскольку MMU не позволяет вам читать память ядра, вы не можете получить доступ к ней. Это также означает, что мы можем использовать своп-файлы для использования диска, как чипа RAM — просто выгрузите отображение части адресного пространства процесса, поймайте ошибку чтения из него — и загрузите отображение вновь.



Виртуальная память — отличная штука, одно из самых больших улучшений надежности компьютеров за последние 13 лет. Windows 3.1 не использовала её, в отличие о Windows 95 — и вот почему так много людей обновили свою OС. Преимущества микроядра здесь очевидны — глючные компоненты ядра не могут отправить компьютер в BSOD aka «blue screen of death» — как они делают это сегодня. Если ваша файловая система обрушилась — просто перезапустите её!



В монолитном дизайне файловые системы, драйверы и даже веб-серверы загружаются прямо в ядро и работают в привилегированном режиме процессора. Ядро всё еще предоставляет систему обмена сообщениями (message-passing) для процессов пользовательского режима — но это нигде особо не используется. Сегодня монолитной является любая популярная серверная или десктопная ОС — Windows, Linux и MacOS. Заметьте, что Linux всегда был монолитным, Windows NT изначально была микроядерной, а MacOS — будучи основанной на Mach — теоретически микроядерна. Впрочем, я не знаю никого, кто бы в это верил.



Вероятно, трудно сказать, действительно ли какая-либо операционная система микроядерна или монолитна, потому что это не бинарная логика «да/нет» — к примеру, в Linux графическая подсистема работает в отдельном процессе (X Server), тогда как в Windows когда-то было так — но не сегодня. Так или иначе, никто не спорит, что Linux — это не микроядро. Хороший критерий оценки это то, работает ли файловая система в режиме ядра или нет — может, графические системы и находятся в серой области, но не файловые системы.



В любом случае, то, что в Singularity применяется микроядерный дизайн, выглядит довольно странно, потому что исторически в академической среде побеждало микроядро, а вот на рынке всегда побеждало монолитное ядро — в основном из-за проблем с производительностью. Эти споры разгорались в 80-х — вот здесь вы можете прочитать знаменитый спор Торвальдса и Таненбаума. Итак, на первый взгляд может показаться, что Singularity это очередное академическая разработка теоретически чистой, но практически неюзабельной вещи… но это не так.





Почему микроядро медленнее?


Микроядра типично медленнее, чем монолитные ядра — из-за накладных расходов на переключения между режимами процессора (user-mode в kernel-mode и обратно). Кроме того, существуют еще и расходы на переключение процессора между двумя процессами пользовательского режима (переключение контекста).



Эти расходы малы, но реальны, и когда вы делаете стопятьсот таких переключений в секунду — приводит к тому, что вся работа процессора сводится к переключениям туда-сюда-обратно, а на реальную работу времени не остаётся. И измерить эти расходы довольно трудно, хотя команда Singularity сделала это.



Причина, по которой эти переключения отнимают драгоценное время заключается в том, что CPU приходится делать необычную для него работу, а поскольку большую часть времени процессор проводит не делая эту работу — она не очень хорошо оптимизирована. Это изменилось в последних поколениях чипов x86, но в целом, всё остаётся так же.



К примеру, делая syscall чтобы заставить ядро сделать что-то, вы используете специальную инструкцию процессора. Обычно это «int 80» на Linux, но сегодня вы можете использовать опкод «sysenter» на ядрах и процессорах, поддерживающих его (практически все умеют). При этом управление переходит в ядро. Это довольно быстро на современных компьютерах, но это не всегда было так — к примеру, ранние версии Windows применяли некорректную инструкцию процессора, так как разработчики обнаружили, что выброс исключения CPU оказался более быстрым способом попасть в режим ядра, чем использование прерывания («официальный» способ). В Intel исправили это :)



Переключение контекста более затратно; во-первых, потому что это очевидно вызывает переход в режим ядра, а еще потому что переконфигурирование таблиц отображения памяти — штука небыстрая.



Небыстрая она из-за того, что это, опять же, необычная операция (для этого нужно использовать специальные регистры в x86 чипах), но в основном из-за того что это требует сброса так называемых «translation lookaside буферов» (TLB). Эти буферы хранят результат запросов MMU. Ведь даже если MMU и являются специализированным для своей задачи железом, его использование не бесплатно — а трансляцию адресов памяти надо делать каждый раз при обращении кода к памяти (что происходит постоянно) — и здесь кэширование просто необходимо.



Из-за этого трудно измерить, насколько дорого обходится переключение контекста. Мы знаем, что это чего-то там стоит — из-за фундаментальных особенностей дизайна CPU. Но реальная стоимость размазывается по коду запущенного процесса. Сразу после переключения контекста ваш компьютер работает немного медленнее и набирает ход по мере заполнения TLB.



Итак, мы имеем два конфликтующих приоритета. С одной стороны, использование виртуальной памяти для разделения адресных пространств может улучшить надёжность отделением программ друг от друга (что хорошо), но, с другой стороны, это обходится нам сложноизмеримой потерей производительности — что плохо. Еще хуже то, что хоть процессоры и становятся быстрее время от времени — они становятся быстрее в исполнении кода, но не в манипуляциях с адресным пространством, так что мы не можем положиться на помощь закона Мура в этот раз.





Обмен сообщениями


Микро-ядра основаны на идее пересылки сообщений между процессами в разных адресных пространствах. Так, чтобы прочитать файл, вам нужно послать сообщение из вашей программы в сервер файловой системы. Вы формируете сообщение в вашей памяти (это быстро), делаете syscall «послать сообщение» (уже не так быстро), потом ядро копирует сообщение в своё собственное адресное пространство (довольно медленно), переключает контекст на сервер файловой системы (медленно), и потом копирует сообщение в память сервера файловой системы перед тем, как покинуть режим ядра.



Когда файловая система прочитает искомый файл, вам нужно повторить всю эту жесть в обратном порядке, в этот раз копируя данные в обратное сообщение… и поскольку стоимость пересылки сообщения растет вместе с его размером — это еще медленнее чем начальный запрос!



Совсем иначе это выглядит в монолитном дизайне: вы формируете ваш запрос (это быстро), делаете syscall (не так быстро), ждёте, пока файловая система не получит ваши данные, потом ядро копирует данные прямо в ваше адресное пространство (или это сделает железо, если вы используете DMA), возвращая управление в пользовательский режим… wow, это проще и быстрее! Недостаток здесь в том, что если файловая система заглючит, то вся ОС порушится в BSOD и вы потеряете всё.



Около 80% крэшей в Windows вызвано кривыми драйверами. Итак, если бы мы смогли предотвратить крэши системы из-за драйверов таким же образом, как мы предотвратили крэши из-за глючных программ — мы предотвратили бы 80% всех BSOD'ов в мире! Это довольно круто! Это также означает, что с драйверами могут работать механизмы безопасности. Если вы сегодня установите стороннюю файловую систему, кто знает, что вы на самом деле получите? Пока вы не просмотрите и не скомпилируете код сами — вам приходится доверять тому, кто дал вам его. Даже если с этим всё в порядке, баг в новом драйвере может открыть дыру для руткита, нагибая всю систему безопасности :(



Наверное, это не удивительно, что академики предпочли медленное, но надёжное решение — а разработчики десктопных ОС предпочли быстрое, но нестабильное. Но не надо думать, что они не пытались сделать иначе! Windows NT разрабатывалась как чисто микроядерное решение, но даже с супер-оптимизированным межпроцессовым взаимодействием они однажды сдались и «переехали» в ядро вместе с GUI — за что получили массу критики, но это сделало Windows отзывчивой, а юзеров счастливыми.





Singularity


Singularity умудряется «и сесть и съесть» — получить все преимущества микроядра и даже более высокую производительность, чем монолитное ядро. Круто!





Как это работает?


Singularity впечатляет тем, что, обладая чистым микроядерным дизайном, на ~30% быстрее традиционного подхода и на 10% быстрее монолитного (в бенчмарке тяжёлого файлового I/O). Как же она это делает?



Трюк очень прост — они просто отказались от аппаратной защиты памяти, полностью. В Singularity всё работает в режиме ядра и всё работает в едином адресном пространстве. Иными словами, MMU ничего не делает. И тут нет «процессов» в традиционном понимании.



Разумеется, если бы это было единственной вещью, которую они сделали, это не было бы так интересно. Восемьдесят процентов крэшей Windows вызвано глюкавыми драйверами, а не ошибками в ядре (подозреваю, что остальные 20% вызваны сбоями в железе). Бессчётные уязвимости, позволяющие эскалировать привилегии вызваны глюками в драйверах. Каждая такая уязвимость — подарок «плохим ребятам». Защита от программных ошибок — вот, что делает микроядра полезными.



Программы в Singularity изолированы друг от друга — но изоляция делается целиком и полностью программно, с помощью теории типов, а не кремния. Это возможно благодаря тому, что в Singularity программы написаны на потомке C#, названном Sing# (теоретически, вы можете использовать любой язык для .NET — Singularity использует совсем немного фич, добавленных в C#, так что любой другой язык потребует лишь этих немногих изменений).



Вы наверняка уже знаете, что в большинстве современных языков — вроде Java или C# — у вас нет прямого доступа к памяти. Грубо говоря, нельзя написать подобный C-код на Java:



*((char *)0x1234) = ‘X’; // записать байт по адресу 1234



И дело не в том, что синтаксиса для этого нет. Просто компиляторы Java/C# производят байт-код, который может быть проверен математическими методами, чтобы удостовериться, что код не делает этого. И, будучи проверенными, эти опкоды JVM/MSIL транслируются в «настоящий код», который скармливается процессору, и мы уверены в том, что передав в этот код ссылку на объект, код не будет читать/писать в него. И это не только обеспечивает надёжность — мы можем построить целую систему безопасности поверх этого!





Но не всё так просто


Окей, это было в теории. А на практике это не совсем так. Точно так же, как теоретически изолированные программы на C могут нарушить изоляцию, используя уязвимости в ядре — так же и программы на Java/.NET могут использовать уязвимости в среде исполнения или нативных библиотеках классов (написанных на C++) и таким образом обойти систему безопасности.



А еще хуже то, что в некоторых случаях, механизмы вроде reflection (интроспекция) могут быть использованы для доступа к объектам тогда, когда такое поведение не ожидается.



Обе этих проблемы служили причиной для эксплойтов в JVM-апплетах в прошлом. Учитывая то, насколько огромны современные JRE — это совсем не удивительно.





Решение


Подход Singularity снова очень прост — вся система написана целиком на C#, лишь малая часть написана на C++ и ассемблере. Это автоматически делает ядро устойчивым к распространенным видам атак. Но Microsoft на этом не останавливается — они работают над исследованиями, которые помогут доказать безопасность и того оставшегося небольшого объема небезопасного кода.



Основной строительный блок Singularity — это SIP, software isolated process или «программно изолированный процесс». Singularity придерживается идеи процесса, как чего-то, что обладает собственными ресурсами, своим адресным пространством и независимо шедулится на исполнение — но это всё обеспечивается исключительно математикой.



SIP обладает собственной кучей (heap), собственным сборщиком мусора (вы можете выбрать из нескольких разных предоставляемых системой GC, принимая во внимание тот факт, что ни один GC не подходит для всех ситуаций) и своими собственными страницами памяти. Так что SIP более изолирован, чем в некоторых других решениях (типа KaffeOS), в которых весь код загружается в единую среду исполнения и объекты могут быть разделены между разными программами. Недостаток в том, что вы не можете с легкостью обмениваться объектами между двумя SIP. А объективное преимущество в том, что SIP могут сильно отличаться друг от друга — используя не только разные сборщики мусора, но и разные языковые среды исполнения и разные модели данных. Это также означает, что они могут быть быстро уничтожены, без прогонки GC по всему хипу, что может быть невероятно медленно.



Мы больше не используем различные режимы CPU — и теперь неясно, как определить, что является «ядром». В Singularity «ядро» это программный компонент, который связывает SIP'ы вместе, управляет памятью, загружает новые SIP'ы и делает некоторые другие задачи. Логически, оно также включает в себя доверенные/небезопасные части системы, написанные на C++ или ассемблере. Некоторые из них привязываются к SIP (сборщики мусора), но, поскольку они считаются безопасными, они могут считаться частью ядра.



SIP'ы обращаются к ядру, просто делая обычный вызов функции. Вам нужно пометить стек, чтобы GC ядра не пересекался с собственным сборщиком SIP'а — но это просто и быстро. Поэтому обычных для syscall накладных расходов здесь просто нет.



SIP'ы общаются через так называемые «каналы». Каналы — это основанные на сообщениях пайпы, вроде UNIX'овых сокетов, но строго типизированных и быстрых. Канал это, по сути, математическая абстракция — пересылка сообщения через такой пайп не вызывает копирования чего-либо или использования всяких железячных трюков. Пересылка сводится к обновлению пары указателей в памяти. И поэтому пересылка даже больших объемов данных между SIP'ами (к примеру, между сетевым драйвером и веб-сервером) очень быстра.





Обеспечение безопасности


Может показаться диким то, что обращение к ядру сводится к простому вызову функции. Это ведь невозможно? Что мешает SIP'у просто вызвать функции для управления жестким диском?



Ответ в том, что SIP поставляется (скажем, на CD), как набор MSIL-инструкций. Эти файлы не компилируются при исполнении (just-in-time, JIT) так же, как в обычной среде Java или .NET. Вместо этого, при установке программы она компилируется и статически проверяется различными анализаторами. Установка программ это привилегированная операция в Singularity — она производится самим ядром. Лишь программы установленные ядром допускаются к исполнению.



Поскольку вы не можете определить в безопасном MSIL такие специфичные для CPU инструкции, как «записать в этот I/O порт» или «вызвать это прерывание», единственный способ сделать это — слинковаться с какой-нибудь доверенной нативной библиотекой, которая сделает это для вас. Поскольку ядро управляет установкой программ, оно может удостовериться, что лишь определенные программы связаны с такими библиотеками, и что связаны они лишь определенным образом. Так ядро может управлять доступом к ресурсам железа, не полагаясь на аппаратные проверки — контролируя доступ к CPU еще при установке приложения.





Манифесты


В обычной OS процесс более-менее соответствует программе. Лишь некоторые программы заводят несколько процессов: к примеру, iTunes устанавливает процесс, который ждет, пока вы не вставите iPod. Но, в общем-то, практически всегда на одну программу приходится лишь один процесс, и довольно часто процесс содержит несколько программ — например, веб-браузер, запускающий внутри себя плагины.



Поскольку SIP'ы такие дешёвые, имеет смысл (и даже нужно) разбивать программы на несколько сообщающихся SIP'ов. И тут мы сталкиваемся с проблемой — как запустить программу? Что вообще такое программа, в таком случае?



Программа в Singularity описывается манифестом. Манифест это, как в .NET, XML-файл, описывающий SIP'ы из которых состоит программа, и их соединения. Манифест практически полностью генерируется автоматически из метаданных в коде. Запуская программу вы, фактически, вызываете манифест.





Драйверы в Singularity


Драйверы это важная тема для нас, поскольку:

  1. Около 80% всех крэшей в Windows вызваны глюками в драйверах.
     
  2. Анализ кода Linux показал, что код драйверов в 7 раз более подвержен ошибкам, чем остальные части ядра.
     
  3. Когда драйвер падает, он забирает «на тот свет» всю систему, при этом теряются данные пользователя и — как следствие — его доверие.
     
  4. Если драйвер содержит ошибку, это может быть использовано для эскалации привилегий. А это на руку лишь «плохим ребятам».


Поскольку Singularity это микро-ядерный дизайн, основанный на системе типов, драйвер — это просто набор Sing#-классов (Sing# это слегка «прокачанный» C#), распространяемый в виде верифицируемого MSIL-байткода. Он работает в SIP, как и любая другая программа. Очевидно, что использование C# разом решает огромный класс распространённых ошибок — любой эксплойт, содержащий слово «overflow» в своём названии неприменим при использовании таких языков.



В чистом MSIL мы не можем записать специализированные инструкции, необходимые для управления железом, поэтому нам нужно какое-то другое решение. И оно выглядит, как что-то вроде небезопасной DLL, предоставляющее объекты, абстрагирующие инструкции, управляющие железом. Эта DLL (Singularity.DriverRuntime) является частью того, что Microsoft называет «trusted computing base», что делает это похожим на слух на какую-то систему DRM, чем оно не является. Проще представить эту DLL, как логическую часть ядра, даже если оно и не работает непосредственно в контексте основного ядра. Эти классы называются IoPortRange, IoIrqRange (и т.п.) и предоставляют простой объектно-ориентированный интерфейс для программирования железа.



Singularity не даст вам создать объекты этих типов самому, поэтому вам нужно использовать специальные статические вызовы методов. И вы даже не можете вызвать их напрямую. Похоже, мы влипли — как мы получим ссылку на такой объект, если мы не можем создать их сами? И в чём смысл этой странности?



Singularity требует аннотаций вашего кода метаданными, описывая железо, для которого предназначен ваш драйвер и какие ресурсы он использует. Это делается традиционным для .NET способом — атрибутами, которыми вы помечаете ваши классы и поля. При установке приложения эти метаданные используются для построения XML-манифеста (описывающего ресурсы, необходимые вашему коду) и входных данных для статического преобразования (compile-time transform), заполняющего пустой метод, который вы предоставляете. Это преобразование само является частью ядра и применяется при установке драйвера — оно и добавляет защищенный вызов библиотеки HAL (hardware abstraction layer).



Таким образом, Singularity получает точное декларативное описание того, что именно нужно драйверу. Поскольку система гарантирует, что вы не можете получить доступ к необходимым объектам (и работать с железом) без точного указания метаданных — метаданные всегда будут указаны с предельной точностью. Это, в свою очередь, позволяет легко решать проблемы вроде конфликта драйверов и построения порядка загрузки драйверов при старте системы.





В чём подвох?


Это всё было бы очень круто, если бы кое-что (и почему всегда есть подвох?). Подвох в том, что любой драйвер, работающий с DMA-железом может обойти систему типов, перезаписывая любые адреса физической памяти.



DMA — Direct Memory Access (или прямой доступ к памяти) — оптимизация, позволяющая устройствам писать напрямую в RAM, в обход CPU. Это очень полезная штука и она реально ускоряет работу, особенно при пересылке больших объемов данных между графическими ускорителями, жесткими дисками, сетевыми картами и так далее. К сожалению, DMA идёт не только в обход CPU, но и в обход MMU, так что драйвер, контролирующий DMA-железку может контролировать и содержимое физической памяти. В обычной операционной системе это неважно, поскольку драйверы работают в режиме ядра и им полностью доверяют. Но в Singularity это проблема.



К счастью для нас, на помощь приходит DRM! Да, я не шучу! Новейшие архитектуры CPU, разрабатываемые в Intel и AMD, обладают кое-чем, называющимся (довольно удачно) IOMMU. Эта штуковина делает для железа то, что обычный MMU делает для процессора — регулирует доступ к памяти, проецируя чтение/запись по DMA через таблицы страниц. Работая с IOMMU, вы можете предотвратить несанкционированный доступ к памяти по DMA. Эта фича изначально разрабатывалась для предотвращения доступа к адресному пространству ядра через подключение железок (что является головной болью для лоббистов DRM-защиты). Ну и, разумеется, это защищает систему от глючного железа, что не такая уж и редкость.



Это также огромное подспорье для нас, потому что это закрывает дыру, через которую DMA-драйверы могли бы выбраться из своей типо-безопасной «тюрьмы».





Как это укрепляет безопасность?


В 2001-м году идея Microsoft об ограничениях на установку драйверов казалась нелепой. К тому моменту война браузеров подходила к концу, широкополосный Интернет только начинал распространяться и проблемы ботнетов еще не существовало. Слишком велика была вероятность неприятия а преимущества были совсем неочевидны — но, несмотря на всё это, проблема глючных драйверов была столь велика, что инициатива подписывания драйверов не могла не появиться. Microsoft предоставила бы вам пакет unit-тестов, и после успешного прохождения, этот пакет подписал бы вам драйвер. Пакет проверял множество распространенных проблем и не требовал передачи кода в Microsoft. Выглядит неплохо?



Ну, разумеется, это было спорно. Хуже, это не работало. Вместо того, чтобы проходить все тесты, некоторые разработчики сжульчинали. Чтобы не сорвать сроки или не платить $250 за верификацию, некоторые из них программно нажимали на кнопку «OK» в окошке предупреждения о неподписанном драйвере. Упс.



Мы могли бы поступить жёстче и требовать обязательного подписывания для некоторых вещей. Это привело бы к тому, что каждый драйвер должен быть подписан — но во многих случаях этого можно избежать.



К примеру, благодаря декларативным метаданным, мы можем статически исследовать драйвер и сказать: «Ну, да, этот драйвер применим лишь для устройств класса “звуковая карта”, не использует DMA, не обращается к файлам (мы знаем это, поскольку можем статически проверить, что драйвер устанавливает соединения с файловой системой)». Что может такой драйвер сделать, кроме как накосячить со звуковой картой? Да ничего. Хоть он и может подвесить систему, неправильно программируя железо, такие баги очень редки. Он не может отправить нас в BSOD, потому что он не работает в ядре. Если он обрушится, то худшее, что может случиться — звук пропадёт до тех пор, пока драйвер не перезапустится и программы не возобновят свои соединения с драйвером.



В целом, мы можем определить некий набор привилегий (в Singularity это набор соединений, доступных SIP'у), которые могут быть опасны — и требовать подписывания только таких драйверов. Что это может быть? Доступ к системным или конфигурационным файлам, очевидно. Еще один случай это сетевые драйверы (как заDoS'ить что-то в обход файрвола? стать сетевым драйвером). К счастью, это редкость, когда драйверам требуется доступ к чему-то еще кроме железа и собственных конфигурационных данных, а сетевые драйверы неинтересны, поскольку стандартных драйверов достаточно большинству людей. Поэтому основная масса драйверов может быть безопасно написана, распространена и установлена без участия Microsoft, сохраняя при этом безопасность всей системы.

Поделиться публикацией

Похожие публикации

Комментарии 197

    +2
    круто! спасибо за статью.
      +20
      Читать замучился, но мне понравилось =)
        +4
        Это точно, привыкли мы к картинкам: "Скоро будут одни сплошиные картинки! Ни кино, ни журналов, ни книг - одни картинки" ))
          +3
          Я вообще чипсы жрал во время чтения.
          0
          Отлично. Давно гуглил почитать чтото пережеванное о синугларитиос
            +10
            Спасибо за перевод. Наконец-то я понял, что такое эта Singularity. :)
              +4
              Грамотно написать ОС можно при помощи обработчиков, с копированием блока памяти и возвратом статуса. Простой пример:
              Базовый обработчик работы с диском представляет собой блочное устройство, назовем его blrw.
              На blrw делаем обработчик, который предоставляет файловую систему - fs.

              При записи fs выделяет область памяти, через blrw копирует в нее содержимое диска, выполняет операции и контролирует целостность fs. Если все успешно - ставится флаг, если нет - то код ошибки.

              blrw, в который прошел вызов обрабатывает флаг и копирует (или не копирует) область памяти на диск. Если и тут произошел сбой - идет флаг в микроядро, которое делает шатдаун/паник

              Такой подход полностью соответствует парадигме ООП, и работу файловой системы можно представить в виде объекта blrw.fs, где функции низкого уровня приватны и доступны только для обхекта fs.

              В свою очередь, объект fs может предоставить тип файловой системы - fs.vfat, fs.ext3 и каждый будет со своими свойствами и методами

              Обработка ошибок будет многоступенчатая, что снижает риск.

              Драйверы, от глюков которых падает система, тоже могут быть оформлены в виде объектов.

              Например vid - объект работающий с видеоподсистемой, а vid.ati - с картами фирмы ati.
              Если карта не может выполнить операцию, то экран переключается в режим vid (vesa/vga), который работает по умолчанию на большинстве карт и работа продолжается
                +2
                Ты можешь выразить простым языком, что ты все-таки хотел сказать?
                  +2
                  Постараюсь, я пишу отдельную статью, как кармы набежит - отправлю
                  • НЛО прилетело и опубликовало эту надпись здесь
                      0
                      Думаю, теперь достаточно — и надеюсь на интересную статью =)
                  0
                  Насколько я знаю Singularity не единственная система написаная на C#. Про другие системы можете что-нибудь написать?
                    0
                    есть еще CosmOS

                    правда, мне с ходу не удалось найти у них на сайте подробностей о том, какую модель изоляции они там используют

                    забавно еще видеть у них в FAQ это:


                    Developers of Cosmos should not look at Singularity source to avoid contaminating Cosmos and violating the Singularity license.
                      0
                      If you want to check out real Open Source OSes written in c# go to http://www.sharpos.org, http://www.ensemble-os.org/ or http://www.gocosmos.org/
                        0
                        У нас ещё среда исполнения не доделана. О процессах и речи пока нет.
                        Хотя судя по mail-list'у народ уже обсуждает архитектуру драйверов.
                        0
                        Еще есть Cosmos.
                        +4
                        хороший перевод, спасибо. но Mike Hearn, видимо, периодами впадает в черную депрессию и начинает писать ужоснахи вроде
                        >>К примеру, QNX — операционная система, разработанная для встроенных приложений, вроде роутеров Cisco
                        или
                        >>Windows NT разрабатывалась как чисто микроядерное решение, но ... они однажды сдались и «переехали» в ядро вместе с GUI — за что получили массу критики, но это сделало Windows отзывчивой, а юзеров счастливыми.

                        впихнуть полную реализацию сетевых протоколов (особенно SMB :) ) в kernel-space было, конечно, отличным способом осчастливить юзеров.

                        к переводу претензий никаких, еще раз огромное спасибо.
                          +1
                          ну, насчет ужоснахов — из песни слов не вырежешь :)

                          а осчастливливание юзеров — это он про GUI, которое стало заметно резвее
                            0
                            QNX есть в одном из Cisco роутеров. А еще не давно уних появилась железка с линухом. Только она там делает унылую вещь. Отслеживает падение IOS и быстро подсовывает другой.
                            0
                            заманчиво..
                              +3
                              Давно пора переходить на новую систему, которая не будет нести кучи
                              проблем и болячек старых ОС. Грамотно спроектированная и написанная с нуля ОС будет иметь все шансы на огромный успех, даже с учетом того что она будет абсолютно несовместима со старым ПО.
                              И как бы вы не любили Microsoft, это единственная фирма которая имеет достаточный опыт в разработке ОС и имеет финансовые возможности для осуществления переворота на рынке ОС.
                                0
                                еще IBM способна на это.
                                  0
                                  Вообще, давно пора переходить на новую платформу, чтобы не тащить за собой вагон проблем архитектуры x86
                                    0
                                    А причем тут x86? :]
                                      0
                                      Microsoft делает операционку под x86, так? Сингулярити, фигулярити — нет никакой разницы, потому что платформа x86 сама по себе изначально ущербна.
                                        0
                                        Нуу... вообще Windows NT была и под PowerPC и под Alpha. Только вот Alpha уже не жива (хотя технологически решение было существенно более лучшее чем x86), а PowerPC не сильно майнстрим. Вообще виживают не самые технологически правильные вещи, а те что становятся массовыми и дешевыми. Хороший пример это как раз x86 платформа.
                                          0
                                          Хорошо тебе, сказал что "Альфа уже не жива" и забыл про нее, а мне завтра на работу из отпуска выходить, опять с альфами маяться :)))
                                    0

                                    Грамотно спроектированная и написанная с нуля ОС будет иметь все шансы на огромный успех

                                    Хорошие технические решения без должной поддержки и раскрутки полный пшик. К тому же под платформу Windows и *nix написано огромное количество ПО. Так что новая ОС должна предоставлять легкие методики портирования на нее иначе софта на ней не появится и юзать ее никто не будет. ОС это не самоцель это просто окружение для запуска нужных вам программ.
                                      0
                                      >> И как бы вы не любили Microsoft
                                      если сингулярити будет распространяться под GPL то я с радостью поставлю ее себе.

                                      >> это единственная фирма которая имеет достаточный опыт в разработке ОС
                                      ого!
                                      +1
                                      Нереально круто, хотя и знакомо много.

                                      Пошел распечатывать, хочу перечитать более вдумчиво.

                                      Спасибо!
                                        0
                                        Я так понял, что отсутствие виртуальной памяти в Singularity ограничивает суммарную потребляемую память размером RAM? Или я где-то невнимательно прочитал?
                                          0
                                          угу, невнимательно

                                          paging памяти там есть, разумеется — для свопинга

                                          просто таблица страниц одна на всю систему и хардверная защита не используется
                                            0
                                            Спасибо, понятно. И за перевод тоже спасибо :)
                                            0
                                            т.е. говоря "single address space" — имеем ввиду "single virtual address space"
                                            +1
                                            Вобщем, все в контексте винды написано. Возникает вопрос, а нафига тогда упоминать линух и никсы вообще? Да и вообще зачем говорить про новую ОСь, опираясь на винду?
                                            Вот кусок, например:
                                            1. Около 80% всех крэшей в Windows вызваны глюками в драйверах.
                                            2. Анализ кода Linux показал, что код драйверов в 7 раз более подвержен ошибкам, чем остальные части ядра.
                                            3. Когда драйвер падает, он забирает «на тот свет» всю систему, при этом теряются данные пользователя и — как следствие — его доверие.

                                            Ну что за бред? :) Когда это линух падал от ошибки в модуле? Спокойно выгрузит лишний глючный модуль и продолжит работу, ни на какой "тот" и "этот" свет не пойдет. И кто это код линуха анализировал? девелоперы мелкософта?
                                            Собсно я к тому, что в тексте про мелкософт упоминать вскользь линух, а потом писать в этом контексте про ошибки опять же винды как-то неуместно, получается впечатление, что это "везде так", а это ошибка.

                                            А дальше вообще интересно. Например, вот: "Каналы — это основанные на сообщениях пайпы, вроде UNIX'овых сокетов, но строго типизированных и быстрых"
                                            Как может быть пересылка куска памяти void* медленнее, чем "строго типизированный" канал? А как же проверки? А как же накладные расходы?

                                            Ну и сама суть - C#. Это ж за собой тянуть всю платформу для того, что бы "ядро" запустить? А кто же тогда запустит платформу? Вот тот кусок, который "немного на С++ и ассемблере" ? Это что же получается, лоадер грузит .NET, который далее грузит "ядро". Стоп. А куда и как лоадер грузит этот .NET?
                                            Ну и накладные расходы байт-кода.

                                            Вобщем, одни вопросы и никаких ответов. Где, хотя бы, замеры скорости, которые, как говориться в статье, провели участники проекта? Где цифры то?

                                            За труды по переводу - спасибо, но, имхо, по сути это все похоже на воспевание непонятно чего.
                                              +1
                                              у меня убунта падала из-за ошибки в видеодрайвере!

                                              >> Как может быть пересылка куска памяти void* медленнее, чем "строго типизированный" канал?

                                              а в каналах Singularity ничего не пересылается — это просто абстракция — поэтому они и быстрее

                                              там напрямую пишется/читается память, без копирования

                                              >> Ну и сама суть - C#. Это ж за собой тянуть всю платформу для того, что бы "ядро" запустить?

                                              эта "платформа" очень маленькая — если хотите живых примеров, смотрите на — ха-ха — Silverlight, там минимальный рантайм, достаточный для выполнения C# впихнут в полтора мегабайта вместе с остальным функционалом Silverlight.

                                              >> Где, хотя бы, замеры скорости, которые, как говориться в статье, провели участники проекта? Где цифры то?

                                              цифры есть в официальных публикациях, которые нетрудно найти
                                                –2
                                                >> у меня убунта падала из-за ошибки в видеодрайвере!
                                                холивар -> там :)

                                                как это абстракция? а как же типизация? и что они тогда шлют по этой абстракции? если написано "типизировано" - значит должны быть проверки типов.

                                                платформа маленькая? да ну бросьте :) вы мне лучше скажите, как эта плафторма стартует _до_ ядра.

                                                цифры погляжу ;)
                                                  0
                                                  проверки типов происходят еще во время установки приложения

                                                  а в run-time код тупо "фигачит"

                                                  >> вы мне лучше скажите, как эта плафторма стартует _до_ ядра

                                                  она не стартует "до ядра"

                                                  там пара тысяч строк кода на C, который и "стартует" эту платформу
                                                    0
                                                    а нафиг такой канал? :) я думал несколько иначе о них, типа для передачи данных между процессами, как-то так.

                                                    Дык не все так просто со стартом, имхо. Интересно будет поглядеть, что дальше будет.
                                                      0
                                                      >> а нафиг такой канал? :) я думал несколько иначе о них, типа для передачи данных между процессами, как-то так.

                                                      он и нужен для передачи данных между процессами

                                                      просто к данным быстрее обращаться напрямую, чем копировать их туда-сюда ;)

                                                      Singularity гарантирует безопасность такого доступа, поэтому там так можно делать, а в Unix нельзя :)
                                                        +1
                                                        воот! Дык если между процессами, то в шарпе я могу динамически создать разные типы и кидать их в канал, совсем не в compile-time, а именно в рантайме. И если канал мне гарантирует типизацию, то "проверки типов происходят еще во время установки приложения" бессмысленно.
                                                          0
                                                          к слову сказать, в Singularity "динамизм" приложений сильно ограничен — в частности, там нет Reflection и нельзя генерировать код в run-time — опять же, из-за соображений безопасности (из-за того, что такой код невозможно верифицировать статически)
                                                            0
                                                            Почитал я еще раз, подумал, и никак не возьму в толк. Вот взяли они .NET, обрезали его хорошенько, запихнули на уровень ядра и... И что, собсно, получили? Особых фишек .NET-а уже нет, если GC оставили - провал производительности, имхо таки убрали, что там остается? Reflection нет тоже, дык вроде бы и получился тот же С++, тольк объектный. А, забыл вроде проверки границ массивов и подобные фишечки платформы, но это же накладные все те же расходы, ведь так?
                                                            Вобщем то, я почему то не вижу смысла в этом деянии, обрезать шарп до уровня плюсов, запихнуть его в ядро, внести кучу абстракций, которые вносят дополнительные расходы, и что же получаем? "Быстродействие" ? Вот уж вряд ли, что-то моя сомневаться сильно-сильно :( Не верю я в жизнь байт-кода в ядре.
                                                              0
                                                              Крики линуксоида. Вот скажите что вам просто не нравятся мелкомягкие и все...
                                                                0
                                                                я хоть слово сказал о линуксе?
                                                                не ищите черную кошку... (с)
                                                                это паранойей попахивает
                                                                  0
                                                                  Кто ж вас, анти-MS невежд, разберёт...
                                                                +1
                                                                Про байт-код в ядре (и не в ядре) вы сами выдумали. Весь исполняемый код нативный.
                                                                  0
                                                                  А Сан джаву в кернел запихивает.
                                                                  Для драйверов :)
                                                                  может и выживет
                                                                  0
                                                                  >> там нет Reflection и нельзя генерировать код в run-time
                                                                  Кошмар, нет reflection? А какже тогда всякие Linq там работать будут? Или их на уровень доверенных библиотек вынесут? Да и вообще reflection иногда просто незаменим!
                                                                    +1
                                                                    Задачей проекта было создание дизайна (в смысле «design») операционной системы, а не поддержка Reflections и λ-выражений.
                                                                      0
                                                                      Reflection нужен очень редко. Разве что для плагинов.
                                                                      LINQ и лямбды, насколько я понимаю, работают без Reflection.
                                                                0
                                                                собственно, абстракция канала это часть формальной модели, которая используется для гарантии свойств безопасности

                                                                эта абстракция сильнее, чем абстракция "вот у нас есть кусок памяти и мы можем в него писать по рандомным адресам" — с ней легче доказать интересующие нас свойства
                                                                  0
                                                                  правильно, собсно это и накладывает дополнительные накладные расходы. Поэтому я и усомнился в скорости таких каналов.
                                                                    +2
                                                                    накладные расходы не в run-time.
                                                            +1
                                                            Ну кхмм, сильверлайт не очень хороший пример=) во первых под виндовс он занимает 4 мегабайта, а не полтора, но у меня подозрение что его удалось уменьшить за счет использования библиотек из самого виндовса(директикс какой нибудь там и прочее).

                                                            А под линукс для него нужен mono (.net для линукса) который весит 40 метров=) + сам moonlight 3 метра.
                                                              0
                                                              то линукс

                                                              в Windows-версии используется независимая от десктопного .NET среда исполнения — как раз и впихнутая в дистрибутив

                                                              про библиотеки речь не идёт — интересует именно минимальный размер run-time, необходимый для работы C#-кода
                                                                +1
                                                                .NET Micro Framework, ограниченное подмножество .NET, в самом сокращенном виде может занимать всего 390 Kb.
                                                                0
                                                                в 4 мегабайта помимо среды исполнения C# впихнуты еще и библиотеки, и плагин для браузера, и рендеринг графики и чёрт знает что еще
                                                                  0
                                                                  >но у меня подозрение что его удалось уменьшить за счет использования библиотек из самого виндовса
                                                                  Давайте засудим Apple за "использования библиотек из самого виндовса" =)
                                                                  0
                                                                  Убунта вся падала, или только X не стартовал?
                                                                    0
                                                                    просто подвисло всё, даже в терминал переключиться не мог
                                                                      0
                                                                      Скорее всего система работала, а вот иксы зависли.

                                                                      X это не только отображение, но и обработка устройств ввода. А вот acpi с иксы не связаны, потому при из смерти (глючный драйвер GMA 500 зависал, а не падал) система корректно выключалась по нажатию на кнопку питания.
                                                                  0
                                                                  >> Когда это линух падал от ошибки в модуле? Спокойно выгрузит лишний глючный модуль и продолжит работу

                                                                  вызывающе неверная информация, модуль обладает всеми правами ядра (и вообще это код ядра, просто загружается по-другому), и посылает систему в crash одной левой пяткой

                                                                  накладные расходы на UNIX пайпы связаны с переключением контекста, потому как это системные вызовы
                                                                    0
                                                                    ммм? я занимался писательством модулей ядра и знаю, о чем говорю. при ошибке модуль выгружается.

                                                                    а пайпы в сингулярити не будут ядерными и не будет переключений контекста?
                                                                      0
                                                                      При какой "ошибке" ? Модуль, к примеру, может "по ошибке" повредить любую внутреннюю структуру данных ядра. Как ядро об этом узнает ? Память-то у них общая, никакого разграничения доступа нет.
                                                                        0
                                                                        вы имеете в виду что модуль может выгрузить себя если нашел аппаратную ошибку? ну так и немодульный драйвер может себя отключить. Проблема в том, что ошибку обнаружить можно наверное только в нескольких процентах случаев, если же идет банальный сбой по памяти, то ядру можно только стреляться.

                                                                        в сингулярити нет переключений контекста, вы статью не читали?
                                                                          –1
                                                                          нет, я хотел сказать, что в большинстве случаев, когда винда валится в бсод, в линухе драйвер просто выгружается, например при работе с памятью по несуществующему адресу или при проваливании стека.
                                                                            0
                                                                            нет, такое сделать, увы, нереально в ядре, при достуре по NULL или несуществующему адресу просто вылетает Oops, да и способов поломать ядро на порядок больше - испортить структуры или подсунуть испорченные, испоганить таблицу сегментов, самое замечательное это залочить перерывания навечно или просто нагадить в своем обработчике прерываний, и т.п.
                                                                      +1

                                                                      Вот тот кусок, который "немного на С++ и ассемблере" ? Это что же получается, лоадер грузит .NET, который далее грузит "ядро". Стоп. А куда и как лоадер грузит этот .NET?
                                                                      Ну и накладные расходы байт-кода.

                                                                      Тут вот подробнее написано http://www.rsdn.ru/article/singularity/s…
                                                                      Реально там не используется VM, а используется компиляция в бинарный код. Для того чтобы в коде небыло ошибок, компилятор осуществляет валидацию на уровне компиляции кода.
                                                                        0
                                                                        >Ну и сама суть - C#. Это ж за собой тянуть всю платформу для того, что бы "ядро" запустить?
                                                                        Лол, ты не понимаешь разницу между C# (на самом деле Sing#) и .Net?
                                                                        Взял бы и проверил, чем позориться. Нету в Singularity .Net Framework. Да и runtime особо нет.
                                                                        0
                                                                        ндя... перевести всю систему на байт-код MSIL... может оно и хорошо с точки зрения безопасности, но с точки зрения быстродействия самого кода - вряд ли. Не достигли еще JIT-компиляторы байт-кода такого же совершенства, как оптимизирующие компиляторы C++.
                                                                          +5
                                                                          Вычислительные мощности дешевле, чем труд программистов, пишущих быстрый и безопасный код.
                                                                            0
                                                                            Да... и к большому сожалению у Майкрософта так всегда и получается. Им дешевле сделать быстро, чем качественно.
                                                                              +3
                                                                              К большому сожалению это не только у Майкрософта. ПО стало слишком сложным для того, чтобы его можно было написать без ошибок. Кроме того, качество зависит от денежных и временных вложений нелинейно, компании выбирают разумный компромисс между ценой и качеством.
                                                                            +2
                                                                            там не JIT-компилятор, трансляция в машинный код производится в deploy-time, при установке приложения

                                                                            вообще-то и сегодня в .NET приложениях это практикуется - google "ngen"
                                                                              0
                                                                              кстати, это чем-то похоже на линуксы, где зачастую компиляция приложения в нативный код происходит при установке
                                                                                0
                                                                                че-то вы хорошенько так перепутали:)
                                                                                  +2
                                                                                  я ничего не путаю

                                                                                  sudo make install :)
                                                                                    0
                                                                                    см. команду 'rpmbuild' (по крайней мере для openSuSE)
                                                                                0
                                                                                Насколько я понял там не MSIL, а свой компайлер который делает бинарный файлы.
                                                                                  0
                                                                                  да, мне тоже показалось это сомнительно как то
                                                                                  0
                                                                                  Еще пара вопросов:
                                                                                  а) код будет открытым?
                                                                                  б) есть какие-нибудь сроки выхода?
                                                                                  в) как оно например в сравнении с каким-нибудь Minix?
                                                                                    0
                                                                                    a) код недавно был открыт (валяется на CodePlex)
                                                                                    б) говорить о сроках выхода неуместно, т.к. это исследовательский проект, а не full-blown OS
                                                                                    в) Minix это совсем другое — различны модели изоляции, в Singularity код формально верифицируем
                                                                                    0
                                                                                    Сейчас сырцы можете скачать.
                                                                                    под вистой установить не удалось. по причине оцуцтвия .net 1.1 (2.0 дифолтовый и есть разница - читал в конференции на кодеплексе)
                                                                                      +1
                                                                                      .net 1.1 можно установить side-by-side, это не помешает работе .net 2.0
                                                                                        0
                                                                                        спасибо, уже)
                                                                                        :)
                                                                                    0
                                                                                    интересно, но сложно читать такую большую статься с экрана. хотел распечатать, но не нашел на хабре print view :(
                                                                                    +1
                                                                                    при установке программы она компилируется и статически проверяется различными анализаторами.


                                                                                    прям Gentoo какая-то :-)
                                                                                      –14
                                                                                      Если на картинке интерфейс этой системы то это ппц конечно полный, виндовс фореве!!!
                                                                                        0
                                                                                        Запустите пожалуйста в "виндовс форева" cmd.exe - ужаснетесь убогости интерфейса. Нет, правда.
                                                                                          –10
                                                                                          А нахер мне её запускать, мне вполне хватает графического интерфейса великого виндовса ХП
                                                                                            +1
                                                                                            Действительно, вам ее не нужно запускать. Главное чтобы вам права выше Users в виндах случайно не дали. Power users для вас слишком много.
                                                                                              –4
                                                                                              а кто мне может права какие-то давать я сам себе хозяин на своем компутере
                                                                                                0
                                                                                                Свой гробьте сколько хотите. А в любой конторе с админом - только users, поскольку даже элементарных основ вы не знаете.
                                                                                                  0
                                                                                                  бугага, чего это я не знаю основ? За компутером уже как никак 10 лет отматал
                                                                                                    +2
                                                                                                    Да ты что? За 10 лет не получить минимального представления об архитектуре оси, с которой работаешь? Мой бедный и воспаленный мозг!

                                                                                                    p.s. Лучше бы эти 10 лет провести за учебником русского языка.
                                                                                                      –2
                                                                                                      Уважаемый, все то, что мне нужно в повседневной работе я прекрасно знаю. Архитектура ОС меня абсолютно не волнует, так как я не являюсь системным программистом.
                                                                                                        +1
                                                                                                        Да-да-да, я руль крутить умею, а вот как антифриз залить - меня абсолютно не волнует, так как я не являюсь автомехаником.
                                                                                                  +9
                                                                                                  ...и твой компутер уже не твой, а часть ботнета :P
                                                                                            +1
                                                                                            Увидел картинку и сразу в каменты срать, ай-яй-яй
                                                                                              –6
                                                                                              А почему-бы и не посрать, коли предоставлена такая возможность на этом чудо-сайте
                                                                                              0
                                                                                              У этой системы еще нет пользовательского интерфейса. И, может быть, никогда не будет. Не для того ее делают, что всякие своими грязными ручищами... :)
                                                                                              0
                                                                                              http://www.habrahabr.ru/blog/os_inferno/ - Оч похожая идея, только оно может работтать внутри другой ОС, те не требует драйверов для железа, и имеет ещё много полезных фич.
                                                                                                0
                                                                                                Оооо, великий план9 :) Это ИМХО вообще тяжелейшая форма наркомании. Чего стоит только cat /dev/net/http/ru/wikipedia/org :)
                                                                                                Хотя на домашнем "кластере" из 4-х виртуалок оно прожило 2 месяца :)
                                                                                                  0
                                                                                                  Логичность организации и простота реализации не даються просто так, чем-то надо жертвовать.
                                                                                                    0
                                                                                                    Ну я ж не спорю. Просто очень тяжело поначалу "въехать" в понятие "ВСЕ сущности = файлы".
                                                                                                      0
                                                                                                      Кому как. После того как я узнал что в линуксе жёский диск - это /dev/hda, я был просто поражён, и надеялся что все остальные устройства будут выглядеться также, те /dev/eth0, /dev/img ... В этом плане Plan9 или Inferno кажуться мне более логичными.
                                                                                                0
                                                                                                Отличная статья, прочитал, несмотря на объём, на одном дыхании)
                                                                                                Спасибо автору и переводчику!
                                                                                                  +1
                                                                                                  Singularity — это микроядерный дизайн, особенностями которого являются высокая производительность, единое адресное пространство, статическая верификация типов и гибкое управление правами доступа.

                                                                                                  Всё-таки, высокая производительность никогда не была особенностью микроядерного дизайна. Собственно, в оригинале всё правильно написано:

                                                                                                  Singularity is a high performance, single address space microkernel design, which uses static type verification to enforce reliability properties and flexible pattern based ACLs.
                                                                                                    0
                                                                                                    у меня написано, что высокая производительность — это особенность микроядерного дизайна Singularity, а не микроядерного дизайна вообще

                                                                                                    просто не подумал, что кто-то может прочитать иначе

                                                                                                    сейчас исправлю
                                                                                                      0
                                                                                                      Да. Действительно, можно прочитать двумя способами.
                                                                                                      Спасибо.
                                                                                                      0
                                                                                                      собственно, и оригинал можно точно так же misunderstand — "high performance, single address space microkernel design", прочитав это, можно подумать, что эти эпитеты относятся к любому microkernel design
                                                                                                      0
                                                                                                      Спасибо большое, очень интересно было почитать.

                                                                                                      Самый главный вопрос: можно ли будет мегатонны уже существующего софта заставить работать хотя бы через какой-нибудь полупрозрачный эмулятор. Иначе сложно представить, как может быть осуществлён переход на такую новую платформу.
                                                                                                        0
                                                                                                        можете быть уверены, что мы не доживём до окончания этого перехода :)

                                                                                                        а если серьёзно — то это, как минимум, 20 лет
                                                                                                          0
                                                                                                          Нет, исключено, не будет работать. более того, я даже близко не представляю себе, как туда можно что-либо портировать. Это вещь в себе.
                                                                                                          0
                                                                                                          "Я ничего не понял из того что ты сказал, но ты достучался до моего сердца!".

                                                                                                          Спасибо вам за статью. Очень далек от темы, но было очень интересно и написано вполне популярно. Great job!
                                                                                                            0
                                                                                                            я нихера не понял из того что ты сказал, но ты мне близок... ты... ты... достучался до моего сердца!

                                                                                                            (с) Джей и молчаливый Боб наносят ответный удар
                                                                                                              +1
                                                                                                              Забыли тесты скорости создания процессов в линкс, винде сингулярити, пин-понг между ядрами и кажется выделение памяти.
                                                                                                                0
                                                                                                                Отличнейшая статься, узнал для себя много нового. Спасибо.
                                                                                                                  0
                                                                                                                  С огромным интересом прочёл, спасибо!
                                                                                                                    +2
                                                                                                                    Есть кое-какие странности:

                                                                                                                    "Виртуальная память — отличная штука, одно из самых больших улучшений надежности компьютеров за последние 13 лет. Windows 3.1 не использовала её, в отличие о Windows 95"

                                                                                                                    Т.е. своп в Win 3.x мне приснился?

                                                                                                                    "В чистом MSIL мы не можем записать специализированные инструкции, необходимые для управления железом, поэтому нам нужно какое-то другое решение. И оно выглядит, как что-то вроде небезопасной DLL, предоставляющее объекты, абстрагирующие инструкции, управляющие железом."

                                                                                                                    И чем это принципиально отличается от драйверов в традиционных ОС? Что тут, что там - нативный код, работающий напрямую с железом.

                                                                                                                    "К счастью для нас, на помощь приходит DRM! Да, я не шучу! Новейшие архитектуры CPU, разрабатываемые в Intel и AMD, обладают кое-чем, называющимся (довольно удачно) IOMMU. Эта штуковина делает для железа то, что обычный MMU делает для процессора — регулирует доступ к памяти, проецируя чтение/запись по DMA через таблицы страниц. Работая с IOMMU, вы можете предотвратить несанкционированный доступ к памяти по DMA."

                                                                                                                    Замечательно, но зачем тогда вообще использовать MSIL и среду исполнения .net? Чтоб софт тормозил? Достаточно добавить поддержку такого железа в существующие ОС (если ее там еще нет).

                                                                                                                    В общем, МС опять развлекаются созданием bloatware путем заметания мусора под ковер и нагромождения лишних сущностей.
                                                                                                                      0
                                                                                                                      >> Т.е. своп в Win 3.x мне приснился?

                                                                                                                      думаю, автор просто перепутал версии windows, в Win 3.x действительно впервые появилась виртуальная память

                                                                                                                      >> И чем это принципиально отличается от драйверов в традиционных ОС? Что тут, что там - нативный код, работающий напрямую с железом.

                                                                                                                      мы работаем не напрямую с железом, а через HAL, который является SIP — это значит, что мы еще при установке драйвера знаем всё про этот драйвер и про то, как он взаимодействует с железом

                                                                                                                      это значит, что драйвер не будет делать то, чего от него не ожидают

                                                                                                                      >> Замечательно, но зачем тогда вообще использовать MSIL и среду исполнения .net? Чтоб софт тормозил?

                                                                                                                      а кто сказал, что там софт тормозит? и почему он должен тормозить? MSIL используется для развёртывания приложения (deployment), а не для непосредственного исполнения

                                                                                                                      зачем это нужно — очень подробно описано в статье

                                                                                                                      >> В общем, МС опять развлекаются созданием bloatware путем заметания мусора под ковер и нагромождения лишних сущностей.

                                                                                                                      к сожалению, лишние сущности необходимы для гарантий безопасности

                                                                                                                      вы же сами видите, что творится в Windows сегодня ;)
                                                                                                                        0
                                                                                                                        "к сожалению, лишние сущности необходимы для гарантий безопасности
                                                                                                                        вы же сами видите, что творится в Windows сегодня"

                                                                                                                        IOMMU спасет отца русской демократии, стуча по щупальцам некошерных DMAшных транзакций. Нельзя (да и незачем) доверять софту то, с чем лучше справится специально обученная железка.
                                                                                                                        0
                                                                                                                        еще раз насчёт "тормозов"

                                                                                                                        вы не подумали о том, что в Singularity — благодаря свойствам её рантайма — возможно, к примеру, заинлайнить вызовы драйвера при компиляции? это возможно лишь managed-среде исполнения

                                                                                                                        у таких систем потенциал в производительности намного выше, чем у традиционных
                                                                                                                          0
                                                                                                                          Своп под 3.1 был только на 80386. Была еще Windows 286, это какая-то обточенная то ли 3.0 то ли 3.1 под 286 онли, но умела ли она vm - не помню, а в википедию лезть за этой пылью лень:)
                                                                                                                            0
                                                                                                                            3.0
                                                                                                                            3.1 уже не ставлась на 286.
                                                                                                                            Подозреваю и Virtual Memory где-то тут появилась.
                                                                                                                              0
                                                                                                                              В 3.x после установки флажка «386 enhanced mode».
                                                                                                                                0
                                                                                                                                3.1 ставилась, сам лично юзал. И даже 3.11 ставилась с небольшим хаком.
                                                                                                                            +1
                                                                                                                            Спасибо за перевод. Сам не знаю как я его дочитал до конца ;)
                                                                                                                              +1
                                                                                                                              Огромное спасибо за пост, очень интересно было почитать.
                                                                                                                                –2
                                                                                                                                а зачем она нужна то вообще? это десктопная или серверная ось предполагается? или просто как лабораторный эксперимент? если она выйдет из лаборатории, то откуда под нее софт появится? микрософт опять нечем заняться, вот и дурят.
                                                                                                                                  +6
                                                                                                                                  разумеется, разработчикам OS нечем заниматься

                                                                                                                                  лучС?Рµ Р±С‹ С?ли новый таскбар Рє Windows 7 прикручивать, ага ;)
                                                                                                                                  • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                      +3
                                                                                                                                      если вдруг, кто-то не владеет языком республики, я переведу

                                                                                                                                      разумеется, разработчикам OS нечем заниматься
                                                                                                                                      лучше бы шли новый таскбар к Windows 7 прикручивать, ага ;)
                                                                                                                                      0
                                                                                                                                      чем минусовать и в карму гадить лучше бы ответили.
                                                                                                                                      –1
                                                                                                                                      лучше чем Виндовс ХП никогда уже не придумают
                                                                                                                                        0
                                                                                                                                        Откручу-ка я тебе карму назад...
                                                                                                                                          –2
                                                                                                                                          та пох, срал я на карму
                                                                                                                                            0
                                                                                                                                            Накручу-ка я тебе карму вперед... упс, а уже нечем =(
                                                                                                                                        0
                                                                                                                                        По сути ядро singularity - это одна виртуальная машина, выполняющая инъектируемые куски кода. Круто.

                                                                                                                                        Насчет Java хочется поправить, что untrusted code через reflection не может (и никогда не мог) получить доступ к системным ресурсам, поскольку выполнение кода контролируется SecurityManager-ом. Проблемы с эксплоитами возникали в имплементации Java 1.1 от Microsoft, где были обойдены некоторые основные принципы спецификации в угоду более native интеграции с платформой Windows (например, любой объект автоматически имплементировал COM).
                                                                                                                                          0
                                                                                                                                          Хорошая статья по теме, была на RSDN на великом и могучем.
                                                                                                                                          По теме:
                                                                                                                                          1. В теории выглядит конечно хорошо и ново, но пока дело до практического применения не дошло, то говорить об эффективности и надежности - сложно, разве что только в теории. А тем временем, l4 уже себя отлично зарекомендовало в embedded устройствая.

                                                                                                                                          2. "К счастью для нас, на помощь приходит DRM! Да, я не шучу! Новейшие архитектуры CPU, разрабатываемые в Intel и AMD, обладают кое-чем, называющимся (довольно удачно) IOMMU. Эта штуковина делает для железа то, что обычный MMU делает для процессора — регулирует доступ к памяти, проецируя чтение/запись по DMA через таблицы страниц."

                                                                                                                                          Туманно и непонятно, что тут за архитектуры такие. Тем не менее, вот это предложение как раз и означает лишь то, что на данный момент (пока такие "новейшие архитектуры CPU" не используються) драйвер легко может закрашить систему, через DMA контроллер (что собственно я и писал в соседней теме о Windows Se7en и надежности ОС), т.е. все прелести Singularity по защите памяти и ресурсов, для драйверов - пустой звук. Кстати, у PPC давно уже есть аппаратный IOMMU.

                                                                                                                                          3. "Что может такой драйвер сделать, кроме как накосячить со звуковой картой? Да ничего. Хоть он и может подвесить систему, неправильно программируя железо, такие баги очень редки."

                                                                                                                                          Ой как опрометчиво. Такая вещь, как Interrupt lookup как раз таки очень часто возникает (я в Linux не разу не видел kernel panic, а вот interrupt lookup от своей звуковой карты - неоднократно), и завешивают систему намертво.

                                                                                                                                          А вообще, конечно Microsoft применила интересный подход, эдакая микроядерность в новом стиле.
                                                                                                                                            0
                                                                                                                                            Хороший перевод. Хорошая статья. Прям разработка будущего.
                                                                                                                                              0
                                                                                                                                              Микроядро в 17 метров? Подождем, что дальше из этого будет.
                                                                                                                                                –1
                                                                                                                                                Вестимо что, наноядро на 150 метров, пикоядро на 0,5 гига и так далее. В мелкософте курят нечто особенное индусское, у них исчисление вспять пошло ;)
                                                                                                                                                0
                                                                                                                                                > Восемьдесят процентов крэшей Windows вызвано глюкавыми драйверами,
                                                                                                                                                > а не ошибками в ядре (подозреваю, что остальные 20% вызваны сбоями в железе).

                                                                                                                                                Повесилило, особенно то что в скобках :)
                                                                                                                                                  0
                                                                                                                                                  17 метров - многовато для микроядра..
                                                                                                                                                    0
                                                                                                                                                    согласен,у меня монолитный линукс - 2 метра + алса модулем
                                                                                                                                                      –1
                                                                                                                                                      гордись до пенсии и пойди получи медаль в ЖЭКе резиновую
                                                                                                                                                    –1
                                                                                                                                                    Тем временем, разработчикам QNX удалось добится практически мгновенной загрузки (миллисикунды) на Intel Atom.
                                                                                                                                                    http://onqpl.blogspot.com/2008/06/do-fas…
                                                                                                                                                      0
                                                                                                                                                      Ссылка битая. Как вариант:
                                                                                                                                                      http://www.qnx.com/news/pr_2870_1.html
                                                                                                                                                      –1
                                                                                                                                                      Круто, все переходим на Singularity, предварительно выбросив в помойку - Игрушки, офисы, вообщем-то весь GUI soft и весь win32 софт. Хорошая новость - кое-что можно будет поднять из написаного на Java, C#, ocaml, Haskell.

                                                                                                                                                      Серьезно, я когда читал это года 2 назад - сильно проперся, а потом решил узнать как они собираются прицепить ко всей этой красоте хотя бы win32 - ответ был - не собираемся. Надеюсь передумают - поднимут в этом объектно-ориентированном пространстве - LegacyWin32Process, который по старой памяти будет использовать MMU и context switching.
                                                                                                                                                      • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                        • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                            +1
                                                                                                                                                            а зачем его переписывать

                                                                                                                                                            в эмуляторе будет работать

                                                                                                                                                            вот где сейчас Win16 софт? ;)
                                                                                                                                                              0
                                                                                                                                                              К тому времени все переедут на дотнет. :)
                                                                                                                                                          –1
                                                                                                                                                          Сдается мне, для чего этот проект задуман - так это чтобы похерить такие проги, как Daemon Tools. Дескать, DRM - это наше всё. В смысле - всё, песец.
                                                                                                                                                            +2
                                                                                                                                                            Нет, песец - это когда в интеренете гуляют люди с интеллектом ниже плинтуса.
                                                                                                                                                              –1
                                                                                                                                                              Судя по информативности коммента - это самокритика?
                                                                                                                                                                +1
                                                                                                                                                                Вы - отличное опровержение вашего же предположения.
                                                                                                                                                                Люди с интеллектом ниже плинтуса самокритикой не занимаются.
                                                                                                                                                            0
                                                                                                                                                            Не совсем так... чет статья не совсем про Сингулярити, это не виртуалка, и не "как выше было написано" первая операционка на С#,и ни как в статье написано что основная цель это микроядро и упор на безопасность.. все это да...
                                                                                                                                                            но идея другая...
                                                                                                                                                            Сингурярити - это первая объекто-ориентировнная операционная система! =)
                                                                                                                                                            Кто хочет знать подробнее читайте арзивы rsdn magazine =)
                                                                                                                                                              0
                                                                                                                                                              при всей своей нелюбви к ms вынужден все же счесть, что тут они копают в правильном направлении.
                                                                                                                                                                0
                                                                                                                                                                Странно, но идеи эти давно витали в воздухе. Фриман много высказывался по поводу проектирования систем будущего (хотябы ЕС его вспомнить, надеюсь, что она развивается). Только там за идею проектирования системы брался объектный подход. Одним из вариантов реализации было построение виртуальной машины, поддерживающей объекты на своем "машинном" уровне (в ЕС это по-моему называется крэкером). Такая ВМ могла быть написана как для голого железа, так и для существующей ОС в качестве простого приложения. Защита тоже планировалась, как я понял, чисто математическая — в основе объекты. В качестве средств разработки выбраны 2 языка реализующие различные парадигмы программирования, спроектированные специально для ЕС. Да, это ограничения, но они позволяют добиться защиты адресных пространств процессов (ой, прошу прощения, там понятия процесса нет, как и программы). Вообще много новшеств планировалось, но все уперлось в реализацию. А новшеств было множество: отказ от файловой системы в пользу постреляционной БД, новый подход к безопасному проектированию ПО, использование последний разработок в области UI (Zoom world, аналоги интерфейса на canon cat)...

                                                                                                                                                                Есть вики проекта, но там помоему все уехало совсем в иные края...

                                                                                                                                                                http://unienv.org/

                                                                                                                                                                Люди знают мало альтернатив, совсем мало... А их на самом деле куча, идей много новых, куд больше неплохих реализаций старых. HelenOS, например, очень себе приятна внутри =) FOS от Олега — наиболее понятное микроядро (код очень хороший)...

                                                                                                                                                                Спасибо за статью. Отличная)
                                                                                                                                                                  0
                                                                                                                                                                  Кто-нибудь может привести сравнение Singularity с JNode?
                                                                                                                                                                    0
                                                                                                                                                                    Ну, в общем, довольно свежие и элегантные идеи присутствуют. Однако есть и спорные места, а именно:
                                                                                                                                                                    - Многопользовательская работа: невозможность поставить программу локально без проверки админом.
                                                                                                                                                                    - Закрытость кода: 100% стабильность невозможна без 100%-ой осведомленности.
                                                                                                                                                                      0
                                                                                                                                                                      насчет закрытости кода — всё равно в будущем распространено будет software-as-a-service, когда закрытый код физически находится "где-то там", на удаленном сервере, а не на машине пользователя
                                                                                                                                                                        0
                                                                                                                                                                        Это только предположение, с которым я, кстати, не согласен. Не всё можно упрятать за завесу компьютерной сети, есть данные, которые пользователь в принципе не захочет кому-то доверить.
                                                                                                                                                                      0
                                                                                                                                                                      Просто спасибо, огромное спасибо за перевод. Узнал немало нового про эту OS.
                                                                                                                                                                        0
                                                                                                                                                                        "Микроядра типично медленнее, чем монолитные ядра — из-за накладных расходов на переключения между режимами процессора (user-mode в kernel-mode и обратно). Кроме того, существуют еще и расходы на переключение процессора между двумя процессами пользовательского режима (переключение контекста)" — это вроде бы имеет смысл только для x86 и прочей CISC, или я не прав?
                                                                                                                                                                          0
                                                                                                                                                                          Идея связки "единое адресное пространство + типобезопасный язык" заимствована из Oberon OS Вирта.
                                                                                                                                                                            0
                                                                                                                                                                            Что-то мне кажется что оно не доживет до полноценной ОС, хотя концепции безусловно интересные
                                                                                                                                                                              0
                                                                                                                                                                              тачскрин в командной строке?
                                                                                                                                                                              это однозначно круто! )))
                                                                                                                                                                                0
                                                                                                                                                                                просто человек пальцем в монитор показывает: "Оно работает!"
                                                                                                                                                                                Интересно, действительно работает? А на железе, не в эмуляторе?
                                                                                                                                                                                0
                                                                                                                                                                                спасибо. Очень понравилось. Красивый концепт.
                                                                                                                                                                                  0
                                                                                                                                                                                  "ядерный разработчик" - улыбнуло
                                                                                                                                                                                    0
                                                                                                                                                                                    Что-то где-то как-то не так... Что мешает криворукому драйверописателю написать драйвер под некое своё устройство, который будет через DMA гробить систему? Некий плумифический IOMMU? А как он работает на системах, где контроллер шины и памяти находится не в CPU, а в чипсете? Он же 100% аппаратно зависымый от чипсета. У AMD он реализован в гипертранспорте, у Интела - через их чудо-виртуализацию. Я если процессор не Intel и не AMD? А если архитектура не x86?
                                                                                                                                                                                    Второй момент - если все исполняется в одном коце защты, то любая минимальаня уязвимость даёт полный и абсолютный контроль над системой и никакие антивирусы не помогут, т.к. они тоже работают на более высоком уровне. А уязвимостей будет вагон - сделать 100% надёжный анализатор это нынче из области фантастики - нужно менять всю филисофию программирования. Плюс, уязвимость в любом компоненте автоматически распространяет её на всю систему - с таким механизмом защиты достатончо пропустить однин модуль и все кто нипопадя смогут им воспорльзоваться, ведь он страсть какой доверенный.
                                                                                                                                                                                    Третий момент - все эти танцы с динамической компиляцией и уборкой мусора на данный момент работают весьма сомнительно. Уборка мусора в частности приводит к крайне неравномерной производительности системы - скорость исполнения может меняться в стотни раз в зависимости от объёма доступной памяти. Не говоря о том, что это большой тормоз на многих алгоритмах.
                                                                                                                                                                                    Короче, идея забавная, но на нынешнем этапе развития науки и техники слабореализуемая. Хотя кто знает, куда этот путь выведет...
                                                                                                                                                                                      0
                                                                                                                                                                                      >> Уборка мусора в частности приводит к крайне неравномерной производительности системы

                                                                                                                                                                                      это только если руки растут из задницы

                                                                                                                                                                                      во-первых, ядро Singularity предоставляет на выбор несколько различных GC

                                                                                                                                                                                      во-вторых, ничто не мешает просто выделить через GC большой плоский шматок памяти и строить свой собственный аллокатор поверх него — разве это не очевидно?
                                                                                                                                                                                        0
                                                                                                                                                                                        Ээээ... а ваш аллокатор не соврешенно не будет использовать никаких объектных типов, включая встроенные? Если да, то он всё равно будет засирать свою память. Во-вторых, строить свой аллокатор это бред, а кучу расширять тоже самому? Может ещё и аналог MMU для простоты написать и поверх него свою ось? :))))
                                                                                                                                                                                          0
                                                                                                                                                                                          >> строить свой аллокатор это бред

                                                                                                                                                                                          вообще, да, мне тоже кажется, что это бред

                                                                                                                                                                                          мне просто непонятны задачи, которые вы собираетесь решать, где GC не подходит и нельзя построить workaround поверх объектной модели Singularity для специфического алгоритма

                                                                                                                                                                                          >> Не говоря о том, что это большой тормоз на многих алгоритмах.

                                                                                                                                                                                          вот мне и интересно, каких
                                                                                                                                                                                            0
                                                                                                                                                                                            Про аллокаторы - берём какой-нибудь более-менее сложную программу на языке уборкой мусора - что-то вроде Netbean или eclipse и с ужасом види что они засирают >500 МБ памяти за две секунды работы. Плюс до трети процессорного времни уходит на уборку мусора.
                                                                                                                                                                                            Так чтобы с ходу - архиваторы, медипроигрыватели, медиакодеки, работа с графикой.
                                                                                                                                                                                              0
                                                                                                                                                                                              ну нет, у меня Eclipse не засирает больше 100-200 мб обычно, и уж тем более не через 2 секунды работы

                                                                                                                                                                                              там внизу, кстати, есть кнопочка "collect garbage" и счётчик used/allocated memory, вот вы попробуйте туда нажать

                                                                                                                                                                                              если GC запросил у системы 500 мб памяти, это не означает, что он использует все 500 мб

                                                                                                                                                                                              медиакодекам, насколько мне известно, не нужны сложные структуры данных, использующие объектную модель вроде .NET, всё что нужно алгоритмам кодеков описывается POD (plain old data) структурами, которые ещё с первого CLR поддерживаются в .NET (называется value-тип, хранится в хипе, как сишная структура, as is)

                                                                                                                                                                                              вообще вы попробуйте для CLR какое-нибудь приложение построить, вот тогда и будем говорить, а то у вас, похоже, такое впечатление, что там на каждую временную переменную в счетчике цикла выделяется объект на куче :D

                                                                                                                                                                                              семантика MSIL-программ намного яснее для компилятора, чем семантика C (из-за отсутствия random access memory), это позволяет легко делать оптимизации, вроде region inference (когда время жизни объектов выводится ещё на этапе компиляции, и выделение памяти на куче заменятся на стек)

                                                                                                                                                                                              медиапроигрыватели это вообще GUI над медиакодеками, там тормозить-то нечему

                                                                                                                                                                                              а насчёт работы с графикой.. ну вот я сейчас работаю с 3D-графикой на работе, и почему-то прекрасно всё работает из C# :) дело в том, что современные приложения для работы с графикой используют ресурсы GPU для этого, и вся "работа с графикой" сводится к дерганью вызовов драйвера (через DirectX), а с этим хоть тормознейший Ruby справится и не подавится

                                                                                                                                                                                              посмотрите, к примеру, на WPF (современный GPU-ускоренный фреймворк для построения GUI для .NET) — вот уж что там тормозит, так это точно не рендеринг
                                                                                                                                                                                        0
                                                                                                                                                                                        >> А уязвимостей будет вагон - сделать 100% надёжный анализатор это нынче из области фантастики

                                                                                                                                                                                        сделать анализатор для unmanaged C кода это и правда из области фантастики

                                                                                                                                                                                        вот только вы забываете о том, что в Singularity используется как раз-таки другая "философия программирования" (как вы выразились) — формально верифицируемый language framework

                                                                                                                                                                                        формально — это значит, математическими методами

                                                                                                                                                                                        единственный неверифицируемый на сегодня код находится в ядре Singularity, но там совсем немного кода, и его безопасность тоже можно доказать формально (собственно, разработчики этой OS сегодня именно этим и занимаются)
                                                                                                                                                                                          0
                                                                                                                                                                                          т.е. чтобы найти уязвимость в такой системе, надо найти уязвимость в самих математических методах доказательства теорем

                                                                                                                                                                                          и если это случится, то это будет проблема не только Singularity...
                                                                                                                                                                                            0
                                                                                                                                                                                            Пока что вся философия сводится к тому, что каждая проверенная библиотека и программа считается 100% безопасной. Для яэра и это может быть справедливо - можно вылизать ядро так, чтобы оно было безопасно, но что будете делать, например, с HD-video компрессором/декомпрессором? В ядро встривать? Для каждого кодека? Не реально. Писать на .NET? Нихватит никакой просизводительности производительности. Придётся допустить использовать библиотеки, написанные сторонними авторами. В реальной жизни есть миллион задач, в том числе повседневных, где просто необходимо использовать очень сложные библиотеки написанные на нативном коде или имеющие доступ непосредственно к ядру - это антивирусы, архиваторы, кодеки и прочее, включая видеодрайверы. И уязвимость в любом из них будет глобальной уязвимостью системы.
                                                                                                                                                                                            Пока что это попытка натянуть новый подход к написанию ОС к старому подходу в написании программ и драйверов. А нужно что-то гораздо более масштабное.
                                                                                                                                                                                              0
                                                                                                                                                                                              >> например, с HD-video компрессором/декомпрессором? В ядро встривать? Для каждого кодека? Не реально.

                                                                                                                                                                                              Singularity это микроядро, вы туда ничего не "встроите"

                                                                                                                                                                                              все драйверы и кодеки — это обычные процессы, и, кстати, преимуществ в производительности у ядра Singularity перед процессами нет

                                                                                                                                                                                              >> это антивирусы

                                                                                                                                                                                              в Singularity не нужны антивирусы, потому что априори система считается безопасной, это доказано математически

                                                                                                                                                                                              >> Писать на .NET? Нихватит никакой просизводительности производительности.

                                                                                                                                                                                              объясните, почему?

                                                                                                                                                                                              сдаётся мне, вы оперируете ложными предубеждениями

                                                                                                                                                                                              в Singularity нельзя использовать нативный код, вообще, в принципе

                                                                                                                                                                                              неужели вы это ещё не поняли? ни драйвер, ни кодек, ни даже большая часть ядра не обладают такими привилегиями там

                                                                                                                                                                                              да-да, большая часть ядра Singularity определена через т.н.з. "unsafe C#", который, несмотря на приставку "unsafe" прекрасно верифицируется

                                                                                                                                                                                              >> Пока что это попытка натянуть новый подход к написанию ОС к старому подходу в написании программ и драйверов.

                                                                                                                                                                                              если бы вы читали статью, то вы бы такого не написали

                                                                                                                                                                                              в Singularity нельзя писать ни программы, ни драйверы "по-старому"
                                                                                                                                                                                                0
                                                                                                                                                                                                Ответьте на следующзие вопросы. Выберите наиболее подохдящий вам вариант:
                                                                                                                                                                                                1) При прогирывании и редактриовании аудио-видео на этой чудо ОС я буду:
                                                                                                                                                                                                a) Пользоваться только встроенными кодеками от Microsoft. Никогда не смотреть и не копировать пиратское видео. После появление новых кодеков ходить по друзьям и смотрть видео на их компьюетрах под алтернативными ОС.
                                                                                                                                                                                                б) Тоже что и (а), но видео с новыми кодеками буду смотреть по одному кадру в пять секунд при помощи кодеков на .NET
                                                                                                                                                                                                в) Поставлю вагон кодеков исполняющихся в нативном коде, и буду обновлять их вместе с обновлением стандартов кодеков.

                                                                                                                                                                                                2) Для архивирования я буду:
                                                                                                                                                                                                a) использовать только формат CAB от микрософт, а для остальных форматов мириться с 50-100 кратной потерей производительности.
                                                                                                                                                                                                б) Поставлю архиватор работающий в нативном коде.

                                                                                                                                                                                                3) При редактированаии фото и видео, кроме перечисленного в п.1 я буду:
                                                                                                                                                                                                а) мириться с минимум трёхкратной потерей производительности и закупать память гигабайтами.
                                                                                                                                                                                                б) буду использовать редакторы имеющие библиотеки работающие в нативном коде.

                                                                                                                                                                                                4) После того, как в результате уязвимостей в системе, анализаторе когда или программах использующий нативный код в мою систему поселится троян, который будет работать на уровне ядра и не будет удалться ничем кроме переустановки системы, я буду:
                                                                                                                                                                                                а) Упорно сносить всё к чертям три-шесть раз в год после обнаружения каждой критичной уязвимости.
                                                                                                                                                                                                б) В будущем уязвимостей не будет, код будет писаться безглючным, в ОС будут находит не больше одной ошибки в за два-три года, безногие будут ходить, гулхие петь, слепые прозреют, а с небес будет сыпаться манна небесная.
                                                                                                                                                                                                в) В ОС уже будет встроен нативный антивирус и я буду использовать его. Никто и никогда не напишщет антивируса лучше. Микрсофт - лучший писатель антивирусов, а компьюетры защищать нужно MS Malicious Software Removal Tool и встроенным в Windows firewall'ом.
                                                                                                                                                                                                в) Поставлю себе антивирус имеющий доступ к нативному коду.

                                                                                                                                                                                                Другие варианты ответов искренне приветствуются.
                                                                                                                                                                                                  0
                                                                                                                                                                                                  >> а для остальных форматов мириться с 50-100 кратной потерей производительности.

                                                                                                                                                                                                  да это бред, какая там 50-100 кратная потеря производительности? своими глазами видел худший случай это 2-х кратное падение и то из-за того что то был JIT-компилятор (у него не так много времени на оптимизации, как у оффлайнового)

                                                                                                                                                                                                  в лучшем случае будет прирост производительности из-за hotspot-оптимизации и знания компилятором (который работает либо в deploy time, либо в run time) особенностей железа пользователя

                                                                                                                                                                                                  >> а) мириться с минимум трёхкратной потерей производительности

                                                                                                                                                                                                  это туда же

                                                                                                                                                                                                  >> a) Пользоваться только встроенными кодеками от Microsoft.

                                                                                                                                                                                                  ну так никто не запрещает написать свой кодек или портировать уже существующий

                                                                                                                                                                                                  >> ) После того, как в результате уязвимостей

                                                                                                                                                                                                  их не будет, и вирусов тоже не будет :)
                                                                                                                                                                                                    0
                                                                                                                                                                                                    Гхм... Для архиваторов потеря производительности будет 50..100 раз. В два раза падение может быть на сетевый/офисных задач. Полагать, что hotspot может соптимизировать лучше чем авторы соврмсенных архиваторо - по карйней мере наивно.
                                                                                                                                                                                                    Свой кодек тоже будете на .NET писать? :) SSE2,SEE3 тоже из-под него использовать? :) Это, мягко-говоря, невозможно. КОдеки нынче затачиваются под архитектуру конкретного процессора и, как-правило, содерат несколько вариантов под различные CPU.
                                                                                                                                                                                                    Про уфзвимости, это я готов согласиться, но только после изобретения нуль-траспортировки. Пока что уменьшения количества ошибок и уязвимостей в программах не наблюдается. Более того, имеется скорее тенденция к увеличению количества ошибок.
                                                                                                                                                                                                      0
                                                                                                                                                                                                      во, первых, "на .NET" я его не буду писать, т.к. это библиотека классов для Windows

                                                                                                                                                                                                      >> SSE2,SEE3 тоже из-под него использовать? :) Это, мягко-говоря, невозможно.

                                                                                                                                                                                                      интересно, как же это я использовал супер-пупер-распараллеленный GPU через C++?

                                                                                                                                                                                                      я сделал простую шаблонную библиотеку для имитации шейдерного DSL (вроде boost::spirit, который имитирует язык BNF) — это при запуске компилировалось в шейдер

                                                                                                                                                                                                      и это в древнем убогом C++

                                                                                                                                                                                                      а у IL-компилятора Singularity просто развязаны руки, т.к. он обладает знанием семантики программы на уровне использования ей библиотеки классов

                                                                                                                                                                                                      компиляция для SSE делается тривиальным введением классов типа Float4 и операторов над ними (умножить-сложить-etc) и модификации компилятора, чтобы он оператор "сложить два float4" компилировал в соответствующую SSE-инструкцию

                                                                                                                                                                                                      /* хуяк, волшебный SSE! */
                                                                                                                                                                                                      Math.Float4 a = b + c;

                                                                                                                                                                                                      причём это уже сегодня есть, к примеру, в (кто бы мог подумать) Microsoft Visual C++

                                                                                                                                                                                                      начиная с дремучей версии 7.0 там появились "intrinsics" (интринсики) — это как раз такие специальные "встроенные" функции и типы данных (int128, к примеру), которые компилятор преобразует в SSE-код

                                                                                                                                                                                                      и это интринсики там есть для MMX, SSE, SSE2 и SSE3

                                                                                                                                                                                                      и это в древнем C++!

                                                                                                                                                                                                      компилятор Singularity технологически несравненно совершенней, и там можно даже сделать хоть компилятор в GPU-код — это на порядки проще, чем прикрутить аналогичное к C++

                                                                                                                                                                                                      кстати, аналог транслятора в GPU этого есть и для C сегодня, называется NVidia CUDA
                                                                                                                                                                                        • НЛО прилетело и опубликовало эту надпись здесь
                                                                                                                                                                                            –1
                                                                                                                                                                                            Если у них хватит терпения/денег/мативации сделать реально нормальную ОС я буду их уважать!
                                                                                                                                                                                              0
                                                                                                                                                                                              Эх, жалко закрыли проект. Причины?
                                                                                                                                                                                                0
                                                                                                                                                                                                Вроде как исследовательский проект, поэтому живет в продолжателях своего дела — Drawbridge, Midori и пр.
                                                                                                                                                                                                  0
                                                                                                                                                                                                  Спасибо за информацию. Тоже думал, что у них что-то не получилось
                                                                                                                                                                                              0
                                                                                                                                                                                              Получилась слишком хорошей, чтобы быть правдой

                                                                                                                                                                                              Только полноправные пользователи могут оставлять комментарии. Войдите, пожалуйста.