Skip to main content

a silhouette of a person's head and shoulders, used as a default avatar

Размышления Марка Шаттлворта об Ubuntu, Canonical и внедрении свободного программного обеспечения


Те, кто регулярно читает opennet.ru, наверняка обратили внимание на горячее обсуждение письма Марка Шаттлворта о вкладе Canonical и Ubuntu в свободное ПО в целом. Почитав это письмо, я нашел в нем достаточно интересных мыслей, что сподвигло меня на перевод этого текста. Думаю, что мой перевод позволит словам Марка достичь гораздо большей аудитории.
Краткое резюме для тех, кто не хочет читать:

1. Свободное ПО - это огромная область, работы на которой хватит всем. Поэтому и надо заниматься работой, а не считать кто и сколько сделал.
2. Свободное ПО, как алмаз, который нуждается в правильной огранке, чтоб достичть своего пользователя. В истории IT есть много случаев, когда становились популярными не самые лучшие с точки зрения качества и надежности работы продукты. Поэтому, для популяризации свободного ПО нужно учитывать реальные потребности пользователей и подстраиваться под них.

Критика в адрес Canonical по поводу ее вклада в разработку ядра Linux и GNOME заставила меня задуматься: доволен ли я тем, чем занимаюсь каждый день моей жизни. Насколько для меня важно чувствовать, что результаты моей работы служат другим людям и делают мир лучше. Явлется ли мое участие в проекте Ubuntu тем делом, возможность заниматься которым можно посчитать за счастье.


За последний месяц у меня было два случая, позволяющих положительно ответить на данный вопрос. Первый - письмо с благодарностью из Новой Зеландии, от человека, который отметил, что Ubuntu 10.04 внесла реальные изменения в жизнь его семьи. Для них этот проект, предоставляющий целостное, интегрированное окружение для работы и существующий благодаря труду тысяч людей, похож на маленькое чудо человеческой щедрости. Второй случай - контракт на поддержку десятков тысяч рабочих станций, работающих на Ubuntu 10.04. Общее между этими двумя случаями - два столпа, на которых зиждутся проекты Ubuntu и Canonical: предоставлять всему миру результаты труда огромного сообщества свободного программного обеспечения как подарок, бесплатно, свободно, без ограничений и делать это на постоянной основе.

Первая история из Новой Зеландии о тех, кто учит детей пользоваться компьютером с раннего возраста и наблюдает насколько больше они могут получить знаний от Ubuntu, чем от Windows, и насколько доступнее делать это с Ubuntu. Для них то, что Ubuntu приносит им весь мир свободного программного обеспечения как единое целое - это здорово, это - прорыв, и они очень благодарны за это.

Это история, повторение которой я надеюсь увидеть 100 миллионов раз. И она делает честь и приносит удовольствие не только мне, не только тем, кто отдает Ubuntu свою любовь и энергию, но и всем тем, кто участвует в разработке свободного ПО в целом. Ubuntu в отдельности не заслуживает всеобщего признания, это часть большой и сложной экосистемы, но без Ubuntu продвижение свободного программного обеспечения просто не достигло бы таких масштабов.

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

Ubuntu и то, что она делает, не могло бы произойти без усилий прекрасного Linux-сообщества, которое, в свою очередь, не могло бы существовать без сообщества GNU, которое также не смогло бы подняться на сколь-нибудь значимое место без усилий таких компаний, как IBM и Red Hat. И может быть все пошло бы совсем не так, если бы не участники проектов Mozilla и Netscape, GNOME, KDE, Google и всех остальных, кто использовал свободное ПО для разных задач, что делало его только лучше. Есть десятки тысяч людей, которые никак не связаны с Ubuntu и которые сделали эту историю - реальностью. Многие из них работали более десятка лет - и прошло много времени прежде, чем пришел неожиданный успех, в то время как Ubuntu на сцене только лишь 6 лет. Именно поэтому Ubuntu не может признаваться единственной и неповторимой лишь только для красного словца и чтобы порадовать своих поклонников :).

Тем не менее проект Ubuntu делает кое-что уникальное, специфичное и важное для свободного ПО: создает у конечных пользователей устойчивый образ того, что со свободным ПО могут работать все, как с экономической точки зрения, так по легкости использования и готовности решать проблемы, возникающие то там, то здесь. И я считаю, что это подарок тем людям, которые собирают каждый из пакетов Ubuntu. Если мы сможем предложить свободное ПО аудитории в 10 раз большей чем сейчас, мы десятикратно усиливаем вашу щедрость, что делает каждый час нашей с вами жизни (который мы проводим исправляя ошибки или улучшая что-либо) в 10 раз ценнее. Я очень горжусь тем, что трачу время и силы на Ubuntu. Да, я мог бы делать множество других вещей, но я не могу себе представить что-то еще, что имело бы аналогичное влияние на мир.

Я готов признать, что не каждый может видеть картину моими глазами. Передача результатов своей работы аудитории в 10 раз большей без учета усилий, затрачиваемых на двустороннюю связь с конечными пользователями и работу над новыми возможностями, может выглядеть со стороны просто как рост скачиваний или увеличение потока отчетов об ошибках в 10 раз. Другими словами, если upstream не видит ничего кроме «кода», то он и не сможет увидеть ничего кроме кода. Я действительно не знаю, что с этим делать: Ubuntu - не средство для доставки конечным пользователями всего многообразия написанного кода, мне кажется это не то, в чем нуждается мир. А нуждается он в средстве, которое позволяло бы брать этот код и следило за тем, чтобы тот код, который уже есть, оставался в состоянии высокого качества и надежности. Все, что нужно для рабочих станций уже есть и даже код соответствует ожиданиям, не было только возможности вынести область его использования за пределы серверов, чтобы представить широкой публике уже готовое решение.

Второе письмо я не могу процитировать. Оно предполагает контракт на оказание услуг Canonical в оказании помощи по миграции более чем 20 000 настольных компьютеров с Windows на Ubuntu. В последнее время в этой области много предложений, их темп ускоряется по мере укрепления доверия к Ubuntu. Хоть Linux уже давно зарекомендовал себя прекрасным рабочим столом для вдохновленного и целеустремленного разработчика, существует разрыв между его потребностями и потребностям крупных организаций. Другой такой компании, которая была бы настолько же привержена идее свободного ПО для настольных систем в том же масштабе, как Canonical, нет и поэтому я очень горд тем, какую роль мы играем в этой экосистеме. Для меня было бы очень печально, если б все усилия, которые сообщество свободного ПО затрачивает на разработку приложений для рабочих станций, были потрачены впустую.

В настольных компьютерах, которые Canonical поддерживает в крупных организациях, нет чего-то секретного или закрытого. Подлинным чудом для меня является то, что и в истории из Новой Зеландии, и в истории с миграцией компьютеров фигурирует один и тот же код. Для меня это истинное назначение свободного ПО. Когда я сам участвовал в проектах с открытым кодом, я всегда был рад, когда результаты моей работы могли служить не только моим потребностям, но и оказаться полезными многим другим.

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

Canonical использует различные подходы для взаимодействия с другими компаниями, которые работают с Linux, и не занимается скрытой критикой конкурентов просто потому, что у нас есть свои принципы. Сила свободного ПО именно в наличии огромного количества разных компаний, совместно работающих над различными целями.

В последние несколько недель неоднократно заявлялось, что Canonical преследует какие-то свои собственные интересы и действует отнюдь не в интересах сообщества, занимающегося открытыми исходными кодами. Это все лживые заявления, потому что большинство из нас наоборот мотивировано делать все, что мы только сможем, чтобы способствовать делу свободного ПО как в интересах конечных пользователей, так и сообщества, которое его делает, и мы убеждены, что существование Ubuntu и Canonical это лучший способ для достижения этой цели. И этот пост показывает результаты размышлений над этими вопросами: это моя собственная позиция показывающая, что именно я делаю и почему я испытываю чувство гордости от тех усилий, которые затрачиваю каждый день.

Что мы вместе делаем для свободного ПО? И что же я сам могу сделать для него?
Во-первых, мы занимаемся доставкой его конечным пользователям. Мы снижаем влияние потребительской инерции и тех факторов, которые мешают людям попробовать бесплатное ПО и решить для себя, нравится ли оно им в той мере, чтобы начать им пользоваться. Сотни из тех, кто сейчас участвует в свободном ПО (разработчиков, переводчиков, дизайнеров, пропагандистов) получили возможность стать частью нашего движения, поскольку для них не стало проблемой слегка намочить ноги в воде. И это совсем не легко. Просто посмотрите на результаты нашей многолетней работы над упрощением инсталлятора Linux, что стало возможно только благодаря труду многих групп людей и было бы просто невозможно без участия Canonical и Ubuntu.

Есть тысячи людей, которые довольствуются сборкой свободного ПО для себя, и это не преступление. Но желание облечь его в такую форму, чтобы другие могли его попробовать, изучить и затем удобно использовать, нужно тоже приветствовать. И именно этому в сообществе Ubuntu придается огромное значение: если вы почитаете planet.ubuntu.com, вы станете свидетелем радости многих людей, использующих свободное ПО. Как сообщество мы глубоко удовлетворены тем, чтобы люди использовали его для решения каких-то задач в своей жизни. Это радует гораздо больше, чем истории о том, как мы «сделали это быстрее» или «добавили новую функцию». Мы, конечно, работаем и над тем и над другим, но сообщество больше ценит влияние на мир, а не на код. Люди очень ценят свое время и опыт. Я горжусь тем, что Ubuntu привлекает людей, вносящих свой щедрый вклад в общее дело. Поэтому мы благодарим и Kubuntu, и Xubuntu, и Puppy, и Linux Mint. Они не висят у нас на хвосте, они стоят на наших плечах, так же, как мы стоим на плечах гигантов. И это здорово. Наша работа будет более значимой и ценной, потому что их работа достигает тех пользователей, которых не достигли мы.

Что еще?
Посмотрите на проект Papercut, основанный на том положении, что все невероятные технологии и усилия, направленные на какой-то сложный проект (например, такой как ядро Linux) имеют нулевую ценность, если средний пользователь не может с ним работать. И, наоборот, проект ценен тогда, когда он просто работает. Сотни пожеланий пользователей были учтены во многих различных приложениях, пользу от чего получает не только Ubuntu, но и любые другие дистрибутивы, их использующие. Если вы думаете, что это легко, попробуйте оценить усилия, затрачиваемые на сортировку и рассмотрение каждого из тысяч предложений, координацию исправлений и их дальнейшее распространение. Результаты неустанного труда большой команды видны невооруженным взглядом.

Другой пример: сохранить миллионам пользователей 1 час в неделю - это экономия энергии, которую можно получить, используя свободное ПО. Хоть команда дизайнеров Canonical играет ведущую роль в создании проекта Papercuts, настоящие звезды представлены здесь - http://www.omgubuntu.co.uk/2010/06/maverick-papercut-hunting-season-opens.html . Каждый может внести предложение, как для версии Desktop http://ubuntuserver.wordpress.com/2010/01/20/ubuntu-server-papercuts-project/, так и для Server.

Лично я положил много на руководство и управление проектом и создание структуры сообщества. Когда мы только начинали Ubuntu, я потратил много времени на анализ существующих сообществ, на то как в них разрешаются неизбежные трения и разногласия, возникающие, когда у вас есть много умных и талантливых людей, взаимодействующих между собой. Для решения этого вопроса мы составили кодекс поведения, который будет гарантировать, что наша страсть к технологии и/или работе не подавит основную цель - собрать разных людей вместе, чтобы совместно работать над общей платформой. Я очень рад, что эта идея распространилась и на другие проекты: у нас нет цели тайно вынашивать идеи, проекты и мысли, которые шли бы вразрез с нашим назначением.

Мы создали простейшую структуру: технический совет (technical board) и совет сообщества (community council). Такой подход в настоящее время широко распространена и во многих других проектах. Поскольку проект Ubuntu вырос, управление претерпело изменения, в настоящее время есть несколько управляющих команд для таких групп, как Kubuntu, форумы и IRC, которые дают советы и руководят такими группами, как LoCo, модераторы, оперативный отдел, разработчики, которые, в свою очередь, стремяться к техническому совершенству и умению работать с людьми, как часть огромного мирового сообщества. Это удивительно и прекрасно. Когда люди начинают участвовать в Ubuntu, как правило, они мотивированы не только желанием быть частью замечательного сообщества, но и исправлением конкретной проблемы или внесением какой-либо идеи по улучшению. С течением времени некоторые из этих людей сознают, что они могут помочь людям быть более креативными, разрешать разногласия, организовывать работу группы так, чтобы результат был гораздо лучше, чем сможет сделать один человек. Наша структура управления проектом создает все возможности для таких людей: они составляют основу и структуру, которая делает это сообщество легко масштабируемым, производительным и довольным.

Такой проект, как Ubuntu, нуждается в постоянном уходе, чтобы защищать свои ценности. Когда вы малы и поднимаете плакат с надписью «мы делаем вот это» вы, как правило, привлекаете только тех людей, которых это интересует. Когда проект перерастает в нечто мощное и заметное, вы, как правило, начинаете привлекать ВСЕХ, потому что люди хотят быть там, где что-то происходит. И значимость проекта может легко пойти вниз. Так, я по-прежнему трачу много энергии на работу с советом сообщества Ubuntu и командой Canonical по взаимодействию с сообществом, и они оба являются талантливыми и трудолюбивыми, потому что эта часть моей работы приносит мне огромное удовольствие. Совет сообщества Ubuntu относится к своим обязанностям хранителя ценностей проектов сообщества очень серьезно. Он в основном состоит из людей, которые не связаны с Canonical, но которые тем не менее считают, что проект Ubuntu важен для свободного программного обеспечения в целом. И бесподобный Jono Bacon, восхитительный Daniel Holbach, и невозмутимый Jorge Castro - профессионалы, которые понимают, как сделать работу сообщества продуктивной и успешной.

Нечто столь же большое как сообщество Ubuntu не может быть только моей или чьей-то еше заслугой, но я горжусь той ролью, которую сыграл и буду продолжать играть по возможности.

В последние годы я стараюсь обращать больше внимания на соревнование за наилучшее оформление в свободном ПО. Я считаю, что свободное ПО обладает лучшим качеством, но думаю, нам нужно точно знать, что мы хотим создать для наших пользователей, будь то рабочая станция, нетбук или сервер. Поэтому я трачу так много моего времени на вдохновление различных сообществ - и Ubuntu, и upstream - чтобы приглашать в них тех, кто видит ПО глазами обычного пользователя, а не опытного хакера. Это фундаментально изменит ценность открытого ПО, и я не могу надеяться, что такую задачу можно осилить в одиночку, но я тем не менее горжусь тем, что являюсь чемпионом этого подхода и рад, что все предложенное неуклонно принимается.

В свободном ПО уже были дизайнеры и до того, как мы это предложили. Я надеюсь, они чувствуют, что внимание Canonical в области концепции лидирующей роли дизайна сделало их жизнь легче, и сообщество в целом больше ценит их усилия и восприимчиво к их идеям. И все-таки, если вы действительно заботитесь о внешнем виде свободного ПО, команда по дизайну Canonical (Canonical design team) ждет вас.

Я делаю некоторую часть работы по оформлению сам и участвую в разработке дизайна Unity - интерфейса для Ubuntu Netbook Edition 10.10. Это следующее поколение старого интерфейса UNR. Самое главное в нем - это утверждение, что рабочие станции Linux не должны быть застревать в 90-х, мы можем и будем пытаться построить новые и эффективные способы взаимодействия с компьютерами. Я был в восторге от скорости, с которой некоторые объекты Unity были приняты сотнями проектов, их цель сделать использование Linux гораздо более простым и прекрасным для всех, так как скорость этой адаптации является мерой того, насколько быстро пользователи смогут лучше адаптироваться к новым способам использования своих компьютеров.

Дизайн сам по себе ставит нас в положение, удобное для обвинения в желании свалить работу по его внедрению на других, так что я горжусь нашей замечательной командой, которая занята реализацией некоторых из этих основных компонентов. В частности, dbusmenu оказалось полезным для организации согласованности внешнего вида приложений GNOME и KDE, работающих под Unity, и я очень надеюсь, что оно будет принято в другие проекты, которые нуждаются в тех интерфейсах, которые оно предоставляет. Я полностью доверяю нашей инженерной команде, нацеленной на качество готового продукта, которая предоставит разработчикам простой и ясный API и руководство о том, как его использовать. Если вы использовали полный набор индикаторов в 10.10, то вы в курсе той работы, которая была сделана без лишнего шума и вобрала в себя результаты многих различных проектов и превратившей панель в нечто прекрасное и эффективное. Utouch также приближается к своему первому релизу и будет продолжать развиваться, так что и Ubuntu, и GNOME, и KDE получат простой способ реализации поддержки жестов Multi-Touch.

Помимо этого, я также занимаюсь финансовой поддержкой различных проектов. Целесообразность вклада денег в свободное ПО должна определяться ответом на следующий вопрос: может ли результат вложения денег в другой проект, помочь большему количеству людей? Есть много способов помогать людям: на $100 000 можно отправить многих в школу, одеть и накормить их. Поэтому я действительно должен быть уверен, что этими деньгами я привношу реальное воздействие на жизнь людей. Благодарственные письма, которые я получаю каждую неделю, помогают мне сохранить уверенность в этом. Более того, мои собственные наблюдения того каталитического эффекта, который Ubuntu дает всей экосистеме ПО с открытым исходным кодом, с точки зрения привлечения новых разработчиков, создания новых платформ, создания нового бизнеса, признания новых участников, придают мне уверенность, что обеспечиваемое мной финансирование оказывает значимые последствия.

Когда мы только задумывали Ubuntu, экосистема Linux была в некотором смысле полностью сформирована. У нас уже было ядро. У нас уже были GNOME и KDE. У нас были X, libc и GCC и все остальные хорошо знакомые инструменты. Естественно, что в них были ошибки, недостатки, были планы по их устранению. Но кое-чего не хватало: иногда это «кое-что» формулируется как «маркетинг», а иногда как «все для конечного пользователя». Я помню, как подумал «вот то, что я могу сделать». Именно поэтому Ubuntu и Canonical не прикладывают усилия к тому, что и так хорошо работает, вместо этого мы сосредотачиваем свое внимание на новых идеях, новых инструментах и новых компонентах. Я считаю это живительным взаимодействием со всей экостистемой открытого ПО, и я слышу от многих людей, что они воспринимают его точно так же. Те, кто говорят «Canonical не участвует в разработке X», правы, но упускают из вида все, что мы делаем с нуля. Конечно, есть мало того, что мы делаем в одиночку, и мало чего из того, что мы делаем, не смог бы сделать кто-то другой, но я думаю, что энергия сообщества Ubuntu и энтузиазм ее пользователей отражает тот факт, что в проекте есть кое-что отличное от других. Это «кое-что» заставляет нас торжествовать, гордиться своим трудом, и мотивирует нас продолжать.

Свободное ПО больше, чем любой из проектов. Оно больше, чем ядро Linux, чем GNU, чем GNOME и KDE, чем Ubuntu, Fedora и Debian. Каждый из этих проектов играет свою собственную роль, но это все в целом реально меняет мир. Поэтому, когда мы начинаем спорить друг с другом о том, какая часть свободного ПО перспективнее, мы рискуем упустить картину в целом. Это немного похоже на аутоиммунные заболевания, когда организм начинает атаковать сам себя. Тот, кто напряженно работает в течение всего дня, чтобы донести свободное ПО до более широкой аудитории, играет на той же стороне, что и я, если уж мы применяем такую терминологию. Я восхищаюсь и уважаю всех тех, кто вкладывает свою энергию в продвижение свободного программного обеспечения, даже если он делает это по-другому.

the avatar of Iterativo e Incremental

De vuelta por wordpress.com

Después de mi pase por 000webhost, vuelvo por acá. Mi sitio en ese host fue suspendido por «envió masivo de e-mails», y la única forma de recuperarlo sería actualizando la cuenta (es decir, pagando). Creo que el culpable del envió masivo de e-mails fue el plugin de «Suscribirte por e-mail a los nuevos comentarios de este post»…Más

the avatar of Thomas Thym

Strategy is mighty!

Following the openSUSE strategy discussion I read some reasonable questions and comments like:  Why do we invest time into that useless strategy discussion? What is the benefit of a strategy? Strategy is only for companies!
This is a follow up to my friend Jos' post about strategy.

I love strategy! (Strategy was one of my major subjects at university and a research focus of the chair I worked and taught over four years.) So I might be biased. Nevertheless I want to convince you share some of my thoughts.  


Why do we invest time into that valuable strategy discussion?

There are several studies about the success of organizations. The strategy is in most cases playing an important part. I explain why:


What is the benefit of a strategy?

A good strategy should
1. show your major future challenges and provide an answer to those challenges,
2. point into a direction where the team wants to move and
3. unite the team.

Challenges
"Prediction is very difficult, especially about the future. " (Niels Bohr) But you have to try to anticipate the challenges. Otherwise you have no chance to act. You could only re-act and that is not an advantage. It is always easier to change things when you are in the driving seat. These challenges include the development of customer needs as well as of the competitors. Business tools (like them or not) can help to see some things clearer.

Direction
A good strategy gives a direction where the herd is aiming at. In an environment with no strong top down control (like in communities), having the same targets and values are essential. This direction - called the vision or mission -  summarizes the common goals in one sentence. This goal is far enough away that you have to move yourself and close enough that it is possible to reach.

Uniting
A strategy can help a community to glue together, to find the things they have in common and to define (together) the way they want to go (together). In business many strategies are defined by the top management and fail because they are not wholeheartedly supported by the employees. The best strategy is worth nothing if it is not filled with life. Therefore, the perhaps most important part of a good strategy is the process how this strategy was created. Who was involved? How were the opinions collected and summarized? Is the process open enough? Is the communication and the flow of information transparent? How many people outside of the organization were involved? Etc. [This would fill a whole blogpost of it's own.]

Strategy is for communities!

Most strategy projects at university I did with NPO (non profit organization). We worked with kindergartens, with schools, with the youth welfare office etc. I can assure you: those projects were a blast. I am convinced that it works for communities as well!

Strategy is mighty!

A brilliant strategy, developed in an open environment by the community and external persons can take your open source project to the next level of success. Focus on the processes not (only) the content. Don't write down a strategy just to have one. Make it move your world!
a silhouette of a person's head and shoulders, used as a default avatar

Another openSUSE kernel git repo

The mirror of the openSUSE kernel-source repository has been around for several months already, now there is something new: A repository that is actually usable :-). The current kernel-source repository is a series of patches managed in git, which has some upsides, like the ability to easily cherry-pick a patch and port it to a different branch or send it upstream. But it is quite painful if you want to work with the code itself and not with patch files. A task as simple as determining if drivers/…/foo.c in openSUSE-11.3 has or does not have a certain change requires checking out the branch and running the sequence-patch script to be able to look at the file. If you need to know when was the file changed, you have to run ‘quilt patches <file>’ to find out what patches touched the file and then ask git about the history of these patches. Neither convenient nor efficient. That’s why we have a second repository, that contains the mainline tree with all the suse patches applied. It’s located at http://gitorious.org/opensuse/kernel, the clone url is git://gitorious.org/opensuse/kernel.git. If you already have a clone of the mainline tree, then you can download just the differences with

git remote add suse git://gitorious.org/opensuse/kernel.git
git remote update suse
git checkout suse/master

The above task is then solved by opening the required file in an editor or typing ‘git show branch:file’. And you don’t even need to clone the tree to quickly check something in the source, just use the web viewer. Also, bisecting is much easier, because you avoid the sequence-patch step now. There are some gotchas though:

  • Not every commit to the kernel-source repository results in a change in the kernel repository. For instance updating config files in the kernel-source repository results in a commit that has no text changes. The gitorious viewer is confused by this and tells you that you are viewing the initial commit. In a local clone, you can exclude such commits with ‘git log .’ (note the dot).
  • When the patch series does not apply, there isn’t much to show in the kernel repository. In such case, the commit only adds a ‘BROKEN’ file to the toplevel directory and uses the tree from the previous commit. When using a bisect script, you can skip such commits with e.g. ‘test -e BROKEN && exit 125’.
  • When patches such as xen are temporarily disabled while updating to newer upstream versions and later enabled, it generates huge diffs back and forth. That’s usually not a problem unless you are bisecting something xen-related.

Anyway, I’m sure this will be useful for anyone who needs to debug something in the openSUSE kernel.

a silhouette of a person's head and shoulders, used as a default avatar

Introduction

Just to get this blog started, a quick introduction.

I have been running GNU/Linux distributions for almost 8 years now. My first experience was with Mandrake (today Mandriva) Linux - downloading 6 CD's on dialup was fun - and after some distro hopping I soon found a home with SuSE 9.2. Since then I've stuck with openSUSE as my main distro while also running the *buntu's and others on testing machines. My preference has always been for KDE - which is why I've never been a fan of Ubuntu - but every so often I'll fire up Gnome, Xfce, LXDE to see what progress has been made. I'm just as happy hacking away from a console.

Over the years I've picked up a fair few scripting and coding skills. Given a bit of time to remember the syntax, I can generally get what I want done in most common languages - bash, awk, sed, perl, C/C++.

My main contributions to the FOSS software environment are RPM packaging/maintenance (made super easy by the OpenSUSE Build Service), and C++/Qt/KDE application maintenance and patching. One of the first projects I became directly involved in is the SynCE project, where I ported some simple KDE3 applications to KDE4. Since then I've been active on the openSUSE mailing lists and occasionally on the forums.

My openSUSE Build Service home project is accessible here.

the avatar of Andrés G. Aragoneses

Version Tolerant Serialization with Mono


(Zoot Woman - Lonely By Your Syde)

During the last months I've kept working {with|on} Mono, but not working for Novell anymore.

Today I'm proud to blog about a bit of work I've done on Mono towards a better Binary Serialization experience:
  • mono-api-info command now can output ABI instead of API if you append the flag --abi. It has been useful for us in LindenLab while working on binary serialization compatibility between versions (already upstream!, so will be available in Mono v2.8, even with a new man page).

    If you ever wondered why your .NET code is no longer capable of deserializing some old binary object you had in your servers, instead of fixing the problem in a case-by-case basis, you can now see the whole picture by just diffing the output of mono-api-info --abi from your current and old codebase! A small TODO that I haven't completed yet is to deal with automatic properties (because we still don't use them) so that would be an exercise for the reader!

  • Fix for upstream Mono to act as .NET in regards to Version Tolerant Serialization, a patch to which I have just added a lot more unit tests (soon to be pushed hopefully).

    You can see the patch of this quite old mono bug here. Disclaimer: to be honest you will only need the previous --abi tool if you use a Mono version prior this fix, because from my testing VTS in MS.NET works as if every new field had an [OptionalField] attached! (At least the BinaryFormatter, the TODO here for the reader is to test the SoapFormatter ;) )


On a totally unrelated note: kudos to the MonoDevelop team for making such a great releases lately (and fixing the bugs I report so promptly). I've been testing it the last months on Windows and I can say it's a great experience to see your favorite IDE working cross-platform and making you not depend on VS anymore if you need to work on Windows from time to time (I know the Express versions are free, and are great! but they do not support plugins :( ). BTW, I've been lately experimenting with the C language support in this IDE, and have had some problems, but the real culprit seems to lay behind some wierd behaviour of my gdb in opensuse. Taking advantage that I'm in opensuse planet, can I do a couple of lazyweb requests?:

a) If you're quite familiar with gdb, can you take a look at these 2 bugs in case it rings any bell for you? BNC#588175, BNC#459274

b) Can you try to reproduce those bugs in openSUSE 11.3? (I haven't migrated yet from 11.2 because I fear about the HALlessness of it :) )

PS: Wondered why the video on the top? Well, I like the trend that some people have about posting random photos in their blog posts even when they may be completely unrelated, but in my case I love music so I figured this would suit better. Of course I would rather embed a WebM video or, even better, something that can preview a song (without video) in a "normally-lower-quality-than-what-you-can-buy" way, so if you have any hints, those are welcome! I especially mention the latter in this case because the Album version of the song above is much much better (synth pop FTW!).

UPDATE 28-AUG-2012: Found a video-less alternative to youtube for embedding songs! It is GoEar.

the avatar of Thomas Thym

Hello Planet SUSE

Since many years I am an (open)SUSE user and spread openSUSE wherever I could in my private environment.
The openSUSE strategy discussion has scratched my itch and I started to contribute more to openSUSE.

What could you expect?
Don't expect much code from me. My experiences are more in the area of strategy, marketing and promotion. Perhaps I could also share some results from my researches during the last years about open source communities.

So be curios and stay tuned.
I am happy to join the openSUSE community and I am looking forward to know more of you.

Let's have a lot of fun!

Cheers,
Thomas

a silhouette of a person's head and shoulders, used as a default avatar

Recompiling wxRuby

Who uses Ruby might be interested to try this interesting multiplatform library that allows the development of GUI (Graphic User Interface) with a considerable visual impact and compatible with the three most popular Operating Systems: Linux (via GTK) Windows (with Native controls) and OSX (via Aqua). (This article is also available for italian users)

Usually need install the wxGTK libraries and the gem wxruby (or wxruby-ruby19 if using ruby 1.9) and start creating your own scripts.

$ sudo zypper in wxGTK wxGTK-gl
$ sudo gem install wxruby

But sometimes we could find an Error for a wrong compatibilty between the installed version of the wxGTK libraries and the wrapper library included in the gem.

/usr/lib/ruby/gems/1.8/gems/wxruby-2.0.1-x86-linux/lib/wxruby2.so:
symbol _ZN13wxAuiNotebook14ShowWindowMenuEv, version WXU_2.8.5 not defined in file libwx_gtk2u_aui-2.8.so.0 with link time reference -
/usr/lib/ruby/gems/1.8/gems/wxruby-2.0.1-x86-linux/lib/wxruby2.so

When an error like this appear, the unique solution is recompile the gem.

What we need:

  • rubygems: Tool for manage the ruby’s gems;
  • rake: the Ruby’s version of the popular make, will help us to compile wxRuby;
  • wxGTK, wxGTK-gl, wxGTK-devel: Library and headers needed for run our scripts and produce the object’s file;
  • SWIG: Build the wrapper classes in Ruby from the C++ sources, wxRuby 2.0.1 need the version 1.3.8;
  • gcc-c++: The C++ compiler used for build the wrapper library;
  • wxRuby: We have to download the source’s package directly from Rubyforge.

Added the repository which contains the Ruby extensions (warning to the portion of the address that refers the version of openSUSE), we can proceed with the installation confirming the request of the dependent packages:

$ sudo zypper ar http://download.opensuse.org/repositories/devel:/languages:/ruby:/extensions/openSUSE_11.3/ RubyExtensions
$ sudo zypper ref
$ sudo zypper install rubygems rubygem-rake gcc-c++ wxGTK-devel rubygem-ffi-swig-generator make

It’s time to download the sources of SWIG version 1.3.38 from sourceforge, then uncompress and install it:

tar -xvf swig-1.3.38.tar.gz
cd swig-1.3.38
./configure && make
sudo make install

All the packages are ready, we have to set some environment variables before continue:

export SWIG_CMD=/usr/local/bin/swig
export WXRUBY_EXCLUDED=GLCanvas
export WXRUBY_VERSION=2.0.1

The second instruction is important for ignore all the references to the openGL library, which are not availables in unicode version.

The next step is download the wxRuby’s source from Rubyforge and start to compile

tar -xvf wxruby-2.0.1.tar.gz
cd wxruby-2.0.1
rake

After this procedure end you can remove the old gem and build & install the new:

rake gem
sudo gem install wxruby-2.0.1-x86-linux.gem

Personally, I needed recompile wxRuby in openSUSE 11.2; with the new version (11.3) standard packages work fine, anyway i wished share my experience for someone could meet the same trouble in the future :))

a silhouette of a person's head and shoulders, used as a default avatar

Система инициализации Systemd. Часть II

Это продолжение начатого тут.




Собираем все вместе - systemd


Выше я объяснил, что должен делать хороший процесс с PID 1 и как работают существующие системы инициализации. Перед тем как перейти к самому главному, давайте сделаем еще паузу. Сходите налейте себе еще кружечку кофе. Это того стоит.

Как вы, наверное, уже догадались, те требования и возможности для идеальной системы инициализации, что я предложил выше, существуют уже сейчас в системе инициализации, названной нами systemd, которую я и хочу тут представить. Здесь ее код. Ниже приведен краткий список ее особенностей и их обоснование.

Поскольку systemd запускает и контролирует всю систему, отсюда и ее название. Она реализует все возможности, указанные выше, и еще кое-что. Система построена на концепции модулей (units). Модули имеют имя и тип. Поскольку их конфигурация обычно загружается из файловой системы - названия модулей на самом деле представляют собой имена файлов. Например: модуль avahi.service считывается из конфигурационного файла с тем же именем и естественно, что он реализует работу с демоном Avahi. Существует несколько видов модулей: 
  • service/сервис: наиболее очевидный тип модуля: это демоны, которые могут быть запущены, остановлены, перезапущены или перезагружены. Для совместимости с SysV в systemd помимо собственных файлов конфигурации для различных сервисов имеется возможность чтения классических скриптов инициализации SysV, а также она умеет разбирать заголовок LSB, если он существует. /etc/init.d является, следовательно, не более, чем просто еще одним источником конфигурации.
  • socket/сокет: данный модуль реализует сокет, расположенный в файловой системе или в Интернете. В настоящее время поддерживаются сокеты AF_INET, AF_INET6, AF_UNIX типов stream, datagram и последовательных пакетов (sequential packet). Также поддерживаются классические буферы FIFO. Каждый модуль типа «сокет» имеет соответствующий ему модуль «сервис», который запускается при попытке установки соединения с сокетом или буфером FIFO. Пример: nscd.socket при установке соединения запускает nscd.service.  
  • device/устройство: этот модуль реализует устройство в дереве устройств Linux. Если устройство описано через правила udev, оно будет представлено в systemd как модуль устройство. Набор параметров устройства, установленный udev, будет использоваться systemd как исходный в определении зависимостей для этого типа модулей. 
  • mount/точка монтирования: модуль реализует точку монтирования в файловой системе. systemd контролирует все точки монтирования (их подключение и отключение), а также может быть использована для монтирования и размонтирования отдельных файловых систем. Файл /etc/fstab используется как дополнительный источник конфигурации для них, подобно тому, как сценарии инициализации SysV могут быть использованы в качестве дополнительного источника конфигурации для модулей service. 
  • automount/точка монтирования с автоматическим подключением: модуль реализует точку монтирования с автоматическим подключением файловой системы. Каждый такой модуль имеет соответствующий ему модуль типа mount, который запускается (т.е. подключается), как только монтируемая файловая система становится доступной. 
  • target/указатель: данный тип модулей используется для логической группировки других модулей: на самом деле сам по себе он ничего не делает, он просто указывает на другие модули, которыми таким способом можно управлять вместе. В качестве примера можно привести модули multi-user.target, который играет роль 5-го уровня запуска в классической схеме SysV, и bluetooth.target, активируемый, как только становится доступен Bluetooth-адаптер, и запускающий сервисы, имеющие отношение к Bluetooth (которые обычно не запущены - bluetoothd и obexd) (т. е. по сути это придет на смену традиционным уровням запуска SysV - прим. перев.). 
  • snapshot/снимок: подобно предыдущему типу модулей снимки также ничего не делают сами, и их единственное преданзначение заключается в ссылке на другие модули. Снимки могут быть использованы для сохранения состояния и возможности отката назад состояния всех служб и модулей системы инициализации. Он, главным образом, предназначен для двух случаев. Первый, чтобы позволить пользователю временно перевести систему в какое-то специфичное состояние, например, однопользовательский режим с остановкой всех работающих сервисов, а затем легко вернуться в предыдущее состояние с одновременным запуском тех сервисов, которые были перед этим запущены. Второй вариант его использования - поддержка режима suspend: достаточно много сервисов не могут корректно работать с этой системой, и зачастую их лучше остановить перед засыпанием, а потом просто запустить.

Приведенные модули могут иметь зависимости друг от друга (как положительные, так и отрицательные, т. е. бывает, что одни без других не могут обойтись, а другие, наоборот, не могут терпеть друг друга): например, модуль устройство может зависеть от какого-то модуля сервис, т.е. как только устройство становится доступным - запускается определенный сервис. Модули mount имеют неявную зависимость от устройства, которое они пытаются смонтировать. Также они наследуют неявные зависимости от префиксов путей к точкам монтирования (например, модуль, подключающий /home/lennart, неявно зависит от модуля, подключающего /home)и так далее.

Краткий перечень остальных функциональных возможностей:
  1. Для каждого порожденного процесса вы можете контролировать: среду исполнения, ограничения ресурсов, рабочую и корневую директории, umask, настройки OOM killer, параметр nice, класс и приоритет операций ввода-вывода, политику и приоритеты использования процессора, привязку к процессору, таймер, идентификаторы пользователя, основной и дополнительных групп, списки директорий, доступных для чтения/записи, список директорий, доступ к которым запрещен, флаги монтирования, биты безопасности, параметры, относящиеся к планировщику процессора CPU, области видимости /tmp, привязку к cgroup для различных подсистем. Также можно присоединить stdin/stdout/stderr сервисов к syslog, /dev/kmsg, произвольным TTY. Если вы присоединяете TTY ко входу systemd - удостоверьтесь в том, что процесс получает эксклюзивный доступ. 
  2. Каждый запущенный процесс получает собственную cgroup (в текущем состоянии разработки по умолчанию они создаются в подсистеме debug, поскольку она все равно не используется). С помощью systemd также легко помещать отдельные сервисы в различные cgroups, причем, это можно сделать из пользовательского пространства, например, посредством утилит libcgroups. 
  3. Файлы конфигурации systemd имеют синтаксис, аналогичный используемому в файлах .desktop, который прекрасно разбирается (parse) многими имеющимися утилитами и имеет все необходимое для интернационализации. Поэтому администраторам и разработчикам не нужно учить новый синтаксис. 
  4. Как упоминалось выше, мы (Здесь и далее под "мы" понимаются разработчики и сама systemd, надо смотреть по контексту. Обычно это нормально, когда автор осознает свое единство со своим творением :). Список основных разработчиков приведен в конце этой статьи. Прим. перев.) обеспечиваем совместимость со скриптами SysV, дополнительно к этому обрабатываются заголовки LSB и утилиты chkconfig RedHat. Если их нет, просто используется любая доступная информация (такая, как приоритеты запуска сервисов) из /etc/rc.d. Поскольку эти скрипты начинают просто читать другой источник конфигурации, обновиться с SysV на systemd достаточно легко. Дополнительно мы можем читать классические PID-файлы сервисов, чтобы определить PID главного демона. Также мы можем использовать информацию о зависимостях из LSB-заголовка скрипта и транслировать ее в «родной» формат описания зависимостей для systemd. Важное замечание: Upstart не может использовать эту информацию. Во время запуска Upstart, в отличие от systemd, не распараллеливает запуск большей части скриптов LSB и/или SysV. Фактически, для Upstart все скрипты SysV - это одно исполняемое задание (Тут опять автор немного лукавит. В Upstart просто оставлен слой совместимости со скриптами SysV, который действительно работает, как описано. Но это именно что слой совместимости с теми службами, управляющие скрипты которых по каким-то причинам пока не отконвертированы в "родной" формат для Upstart, а не "злостная недоработка" разработчиков Upstart. Прим. перев.).
  5. Аналогичным образом, существующий файл /etc/fstab читается и используется как еще один источник конфигурации. А с использованием опции comment= fstab вы даже можете отметить отдельные записи в этом файле, чтобы передать их под контроль systemd (для обеспечения работы функционала автоматического монтирования). 
  6. Если для одного сервиса существует несколько файлов конфигурации (например, есть два файла /etc/systemd/system/avahi.service и /etc/init.d/avahi), тогда "родной" формат файлов имеет преимущество. Устаревший формат файлов игнорируется, позволяя легко провести обновление. 
  7. Мы также поддерживаем механизм использования шаблонов. Например, вместо того, чтобы иметь шесть одинаковых конфигурационных файлов для шести getty, у нас есть только один файл getty@.service, который используется сервисом getty@tty2.service и аналогичными ему. Интерфейсная часть также может наследоваться выражениями, описывающими зависимости, т. е. легко понять, что сервис dhcpcd@eth0.service запускается сервисом avahi-autoipd@eth0.service. 
  8. Для активации сервисов посредством сокетов, мы поддерживаем полную совместимость с традиционной моделью inetd, а также простой режим, имитирующий работу launchd, который рекомендуется к использованию для вновь создаваемых сервисов. Режим совместимости с inetd позволяет передавать запускаемому демону только один сокет, в то время как "родной" режим работы позволяет передавать произвольное количество дескрипторов файлов. Мы поддерживаем как режим с одним экземпляром сервиса на одно соединение, так и с одним экземпляром на все соединения. Например: sshd.socket может запускать сервис sshd@192.168.0.1-4711-192.168.0.2-22.service с cgroup sshd@.service/192.168.0.1-4711-192.168.0.2-22 (т. е. IP-адрес и номера портов используются в качестве имен). Для сокетов AF_UNIX, используется PID и идентификатор пользователя присоединяющегося клиента. Это предоставляет администратору прекрасный инструмент для определения различных экземпляров одного и того же демона и контроля за ним. «Родной режим» передачи сокета легко реализовать в приложениях: переменная $LISTEN_FDS, если она установлена, содержит количество передаваемых сокетов, и демон может найти их в файле .service, начиная с файлового дескриптора 3 (хорошо написанный демон также может использовать fstat() и getsockname() для идентификации сокетов в случае, если их больше одного). В дополнение мы устанавливаем переменную $LISTEN_PID, содержащую PID главного демона, который получает сокеты, потому что переменные среды обычно наследуются дочерними процессами, что может несколько запутать процессы, находящиеся далее в цепочке. Поскольку логика передачи сокетов очень проста, мы предоставляем примерную реализацию этого процесса под лицензией BSD. Также мы портировали множество существующих демонов на эту схему. 
  9. Мы предоставляем совместимость с интерфейсом /dev/initctl. Эта совместимость фактически реализована с помощью сервиса, активируемого посредством FIFO, который просто транслирует устаревшие запросы в запросы D-Bus. На практике это означает, что старые команды shutdown , poweroff и аналогичные им из Upstart и sysvinit будут работать с systemd. 
  10. Мы предоставляем совместимость с utmp и wtmp. Код, который это делает, выглядит гораздо более жизнеспособным, чем эти файлы :).
  11. systemd поддерживает несколько типов зависимостей между модулями. After/Before могут использоваться для определения последовательности запуска. Requires/Wants определяет статус зависимости, является она обязательной или опциональной. И наконец, Conflicts определяет отрицательный характер зависимости (т. е. две и более службы, у которых в зависимостях указана Conflicts, не смогут быть запущены одновременно - прим. перев.). Есть также еще три, менее часто используемые типы-зависимостей. 
  12. systemd построена как система с минимумом транзакций. Это означает: если модуль запросил запуск или остановку, мы добавляем его и все его зависимости во временную транзакцию. Затем проверяем целостность этой транзакции, т.е. последовательности обработки зависимостей After/Before для всех модулей на возможность появления циклических зависимостей. Если они есть, systemd пытается исправить ситуацию путем удаления из транзакции «несущественных» (non-essential) заданий. Также systemd пытается убрать из транзакции такие из «несущественных» заданий, которые могут остановить какой-либо другой сервис (не имеющий отношение к останавливаемому модулю). «Несущественными» являются такие задания, которые не относятся к оригинальному запросу, но при этом помещены в очередь на основе зависимостей Wants. В заключение проверяется, могут ли задания в транзакции противоречить заданиям, которые уже находятся в очереди и, если возникла такая ситуация, транзакция отменяется. Если все сработало корректно, транзакция целостна и минимизирована по количеству операций, она ставится в очередь на исполнение. В сухом остатке это означает, что перед запуском запрошенной операции мы проверяем, имеет ли смысл ее вообще выполнять, если возможно, исправляем возникшие ошибки, и затем ничего не делаем, если операцию выполнить невозможно. 
  13. Мы записываем время запуска/остановки, PID и статус завершения для каждого из порождаемых и/или контроллируемых процессов. Эти данные позволяют увязать демоны с их данными в abrtd, auditd и syslog и создать интерфейс, который выделял бы упавшие демоны и предоставлял бы всю необходимую о них информацию.
  14. Мы также реализовали самостоятельный перезапуск процесса init в любое время по требованию. Состояние демона замораживается перед этим и размораживается после. Таким образом мы упрощаем онлайнового обновления с SysV init на systemd, а также передачу полномочий от остановленного к перезапущенному демону. Запросы к открытым сокетам и точкам монтирования autofs, как уже отмечалось выше, будут корректно упорядочены и поставлены в очередь ядром, поэтому клиенты даже не почувствуют, что что-то вообще произошло. Поскольку большая часть информации о состоянии обслуживаемых systemd процессов хранится в виртуальной файловой системе cgroup, это позволяет нам не прерывать их исполнения из-за невозможности доступа к данным init. Код, реализующий перечитывание конфигурации init, является общим с кодом его перезапуска. 
  15. Избавляясь от shell-скриптов в процессе запуска системы, мы переписали основную их часть на C и поместили непосредственно в systemd. В частности, это код таких операций как монтирование виртуальных файловых систем /proc, /sys and /dev и установка имени хоста. 
  16. Состояние сервиса доступно и может контроллироваться через D-Bus (за это Upstart не пинал только самый ленивый - прим. перев.). Правда, эта возможность пока не реализована и находится в стадии активной разработки. 
  17. Мы придаем особое значение активации сервисов посредством сокетов либо через D-Bus (и, следовательно, поддерживаем обработку соответсвующих зависимостей). В то же время мы поддерживаем традиционные зависимости только между сервисами. Также поддерживается несколько способов, которыми сервис может сообщить о своей готовности: путем вызова fork() и завершением родительского процесса (традиционное поведение daemonize()) и посредством публикации своего имени на D-Bus.
  18. Существует интерактивный режим, который запрашивает подтверждения для каждого из процессов, порождаемого systemd. Вы можете включить это, передав параметр systemd.confirm_spawn=1 в строке параметров ядра.
  19. С помощью параметра systemd.default= в строке параметров ядра вы можете указывать, какой из модулей systemd нужно запускать при загрузке системы. Обычно здесь находится что-то вроде multi-user.target, но можно указать и какой-то один сервис вместо модулей типа «указатель», к примеру, «из коробки» мы поставляем сервис emergency.service, который по своему назначению подобен параметру init=/bin/bash, но по сравнению с ним имеет то преимущество, что можно запустить полнофункциональную систему прямо из оболочки восстановления от сбоев (emergency shell). 
  20. Также есть минимальный пользовательский интерфейс, позволяющий запускать/останавливать сервисы и наблюдать за ними. Правда, он еще далек от завершения, но вполне может использоваться как утилита для поиска ошибок. Он написан на Vala и называется systemadm.

Следует также заметить, что systemd использует много специфичных для Linux возможностей, не ограничиваясь стандартами POSIX. Это позволяет использовать огромное количество возможностей Linux, разработанных для портируемости, которые остальные системы не предоставляют.

Состояние разработки


Значительная часть перечисленных выше возможности уже реализована. В настоящее время systemd уже может использоваться как полноценная замена для Upstart и sysvinit (по крайней мере, пока не все сервисы еще отконвертированы в формат Upstart, за что спасибо разработчикам основных дистрибутивов).

Однако объем тестирования systemd минимальный, поэтому номер версии, которую мы имеем на сегодняшний день - это абсолютный и великолепный НОЛЬ. Так что, если решитесь использовать ее в таком виде, как она есть, ждите появления некоторого количества неожиданных проблем (автор намекает на необходимость обязательного наличия бубна при использовании systemd на рабочих машинах - прим. перев.). Другими словами, все должно работать почти стабильно. Кое-кто из нас был настолько смел, что загружал наши рабочие машины с помощью systemd (не только виртуальные, но и те, которые мы обычно используем для разработки). В общем, тут как повезет, особенно если пробовать systemd на дистрибутивах, которые мы - разработчики - не используем.

Предполагаемые направления развития


С набором возможностей, описанным выше, все понятно. Однако у нас в планах есть еще кое-что. Я на самом деле не люблю много говорить о больших планах, но ниже приведу небольшой обзор того, что мы еще планируем сделать.

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

Более важно часть наших планов - это не только экспериментировать с systemd для оптимизации времени запуска, но также сделать из него полноценный и идеальный менеджер сессий, чтобы заменить (или, по крайней мере, попытаться) gnome-session, kdeinit и подобные демоны. Набор проблем и задач, которые надо решить для менеджера сессий и системы инициализации по большому счету один и тот же: максимально быстрый запуск жизненно важных частей и выполнение функций няньки по отношению к запущенным процессам. Для этого можно использовать тот же код. В Apple для этого похожим образом используется launchd. Поэтому мы хотим использовать описанные выше способы активации сервисов через сокеты и D-Bus и максимальную параллелизацию запуска процессов и для менеджера сессий и для системных сервисов.

Надо отметить, что все эти возможности уже частично доступны (но реализованы не до конца) в существующей кодовой базе. Например, запускать systemd из-под обычного пользователя уже можно; он даже определяет, что запущен именно таким способом. Поддержка этого режима доступна с самого начала его разработки (Этот режим полезно использовать для отладки! Для его работы нет необходимости полностью конвертировать систему в формат systemd).

Однако есть некоторые вещи, которые мы должны предварительно исправить в ядре и в пользовательском пространстве, прежде чем закончить работу над systemd: нам нужны извещения об изменениях состояния подкачки, способом подобным тому, как сейчас работает с монтирование файловых систем; мы также хотим реализовать извещения когда CLOCK_REALTIME перескакивает на CLOCK_MONOTONIC; мы хотим позволить обычным процессам получить часть возможностей init; нам нужно хорошо документированное и общепризнанное место, куда нам нужно положить сокеты. Ничего из этого не является жизненно необходимым для systemd, но может здорово ее улучшить.

Вы хотите увидеть systemd в действии?


Мы пока еще не выпускали релизов, поэтому у нас нет готовых тарболов. Но если вам очень хочется, вы всегда можете сделать снимок с нашего текущего репозитория (git). В дополнение, чтобы вы вообще могли что либо запустить, здесь можно скачать тарбол с конфигурационными файлами для модулей, которые позволяют немодифицированной Fedora13 работать с systemd. У нас пока нет готовых RPM, чтобы их предложить вам.
Самый легкий путь - это скачать этот образ Fedora 13 для qemu, который специально приготовлен для systemd. В меню grub вы сможете выбрать - будете ли вы грузиться с помощью Upstart или с помощью systemd. Эта система имеет минимальный набор модификаций. Информация о сервисах читается исключительно из существующих скриптов SysV. «Благодаря» этому мы не получаем всех преимуществ от активации сервисов посредством сокетов и D-Bus. Но особенности systemd позволяют параллелизовать запуск сервисов только на основе чтения заголовков LSB и уже только это позволяет нам грузиться быстрее, чем через Upstart. Образ сконфигурирован таким образом, чтобы выдавать информацию для отладки на последовательную консоль и в буфер ядра для ведения логов (просматриваемый с помощью dmesg). Поэтому необходимо сконфигурировать для qemu поддержку виртуального последовательного терминала. В качестве всех паролей установлен systemd.

Еще более простой путь - это посмотреть на эти прекрасные скриншоты. На первом приведен интерфейс утилиты systemadm:



Здесь показан список загруженных модулей и вывод детальной информации об одном из экземпляров getty.



Это вывод команды ps xaf -eo pid,user,args,cgroup, показывающей насколько аккуратно все процессы отсортированы по своим cgroupsто показывает четвертая колонка с префиксом debug: такой префикс используется по той причине, что мы пока используем специальный контроллер cgroup для отладки. Это описывалось выше.)

К сожалению, у нас пока еще нет графиков загрузки или еще каких-то данных по времени запуска системы. Мы их опубликуем, как только сможем полностью параллелизовать запуск всех сервисов, поставляемых в Fedora. В тоже время, мы приветствуем проведение ваших собственных тестов и публикацию их результатов.

У меня пока есть только две цифры, которые я могу вам привести. Но они пока не заслуживают доверия, поскольку измерялись по времени загрузки виртуальной машины (один процессор). Fedora 13 грузится с помощью Upstart 27 секунд, с помощью systemd - 24 (от grub до gdm, с одними и теми же настройками, цифры измерены один раз, один запуск следовал за другим). Следует помнить, что цифры показывают только преимущество от использования параллелизации запуска скриптов на основе информации из их LSB заголовка. Поскольку не использовалась активация сервисов посредством сокетов или D-Bus - эти цифры по сути ничего не показывают.

Написание демонов


Идеальный демон, полноценно использующий возможности systemd должен делать некоторые вещи способами, отличными от традиционного поведения. Позже, мы опубликуем подробное руководство по написанию демона для использования с systemd. Ниже приведено краткое описание того, что нужно для разработчиков демонов:
  • Мы просим разработчиков не вызывать fork () (или даже двойной fork()) в своих процессах, используя цикл событий основного процесса, который systemd вызывает для вас. Также не вызывайте setsid().
  • Не стоит сбрасывать привилегии (имеется в виду, когда демон не должен быть запущен с root-привилегиями, прим. перев.) с помощью самого демона, предоставьте сделать это systemd и настраивайте это в ее конфигурационных файлах (Тут есть несколько исключений. К примеру, для некоторых демонов нужно сбрасывать привилегии только посредством самого демона после стадии инициализации, которая требует повышенных полномочий).
  • Не надо создавать PID-файлы. 
  • Имя демона следует получать с D-Bus.
  • Если вы хотите использовать возможности systemd для ведения логов, сбрасывайте все, что нужно включить в логи, на stderr.
  • Предоставьте systemd создать и обслуживать сокет для вас, благодаря чему будет работать активация посредством сокетов. Для этого нужно использовать $LISTEN_FDS и $LISTEN_PID как описывалось выше.
  • Используйте SIGTERM для остановки своего демона.

Все что приведено выше аналогично тому, что Apple рекомендует для демонов, совместимых с launchd. В то же время демоны, поддерживающие launchd легко портировать на systemd. Заметьте, что systemd (для совместимости) поддерживает и демоны, которые не поддерживают того, что описано выше. Демоны, совместимые с inetd, для активации посредством сокетов можно использовать без каких-либо модификаций. И, конечно же, как только systemd подтвердит свою жизнеспособность в наших экспериментах и начнет адаптироваться дистрибутивами - будет необходимо портировать на нее, по крайней мере, те сервисы, которые должны быть запущены по умолчанию. Мы уже пишем концепцию патчей и тогда процесс портирования станет очень легким. Кроме того, в определенной степени, мы можем использовать ту работу, которая уже была проделана для launchd. И, более того, демон, поддерживающий активацию посредством сокетов, не становится от этого несовместимым с системами отличными от systemd.

Часто задаваемые вопросы


Кто основные разработчики?
Большая часть кодовой базы - моя собственная работа, Lennart Poettering (Red Hat). Однако, общий дизайн и его отдельные детали - это результат моего взаимодействия с Kay Sievers (Novell). Также в проекте участвуют Harald Hoyer (Red Hat), Dhaval Giani (бывший сотрудник IBM), и многие другие из таких компаний как Intel, SUSE and Nokia.
 
Это проект Red Hat?
Нет, это мой персональный проект. И позвольте мне подчеркнуть: мнение, отраженное в данной статье - это только мое мнение. Это ни мнение моего работодателя, ни Рональда МакДональда, ни кого бы то ни было еще.
 
Увидим ли мы это в Fedora?
Если наши эксперименты покажут что наши подходы работают, если сообщество Fedora выскажется в поддержку, тогда да, мы увидим systemd в Fedora.    
 
Увидим ли мы это в OpenSUSE?
Этим занимается Kay, но думаю, что все будет также же, как и в Fedora.
 
Увидим ли мы это в Debian/Gentoo/Mandriva/MeeGo/Ubuntu/[Моем_любимом_дистрибутиве]?
Это вопрос к их разработчикам. Мы можем только приветствовать их интерес и помочь с интеграцией.
 
Почему бы не добавить все вышеперечисленное в Upstart, зачем было изобретать что-то новое? 
Недостатки Upstart приведены выше, так же было показано, что ее основной дизайн, по нашему мнению, ущербен. Этот проект выглядит, как имеющий кучу недостатков в своей основе. Однако, имейте в виду, что это не помешало нам найти много идей для вдохновения в кодовой базе Upstart.
 
Если вам так нравится launchd, почему было бы просто не адаптировать ее?
launchd - прекрасное изобретение, но я не уверен, что она хорошо впишется в Linux, более того, она вообще никак не вяжется по своему дизайну ни с его (Linux) масштабируемостью, ни с его гибкостью.    
Это проект NIH?
(Тонкий укол, намекающий на то, что разработчики пошли по собственному пути только по причине того, чтобы начать свой собственный проект. Проект ради проекта. Прим. перев.)
Я надеюсь, что ясно пояснил текстом выше, почему мы пошли по своему собственному пути, вместо того, чтобы использовать как основу Upstart или launchd. Мы начали разработку по техническим, а не политическим причинам. И не забывайте, что это Upstart, а не systemd, включает библиотеку NIH (которая является, своего рода, новой релизацией glib).    
 
Будет ли systemd работать на [моей_любимой_операционной_системе_отличной_от_ Linux]?
Маловероятно. Выше мы отметили systemd использует много специфичных для Linux API (таких как as epoll, signalfd, libudev, cgroups и т.п.), поэтому портирование его на другую операционную систему выглядит (по нашему мнению), как не стоящий своих затрат. Мы, разработчики проекта, не заинтересованы в работе, предполагающей портирование на другие платформы. Для тех, кто заинтересован в этом, мы можем только сказать, что git хорошо поддерживает концепцию ветвей (branches).
Скажу больше, портируемость ограничивается не только окружением, в котором работает systemd: нам нужны самые последние версии ядра Linux, glibc, libcgroup и libudev.
Если кто-либо хочет сделать нечто подобное для других операционных систем, можем предложить приемлемый режим взаимодействия: мы поможем вам определить какие интерфейсы являются общими с вашей системой, сделаем немножко легче жизнь тех, кто будет писать демоны для systemd и ее аналога. Мы можем помочь идеями, но не кодом.    
 
Я слышал, что [система загрузки Gentoo, initng, Solaris SMF, runit, uxlaunch, что-то еще] - это реально классная система инициализации, которая также позволяет параллелизовать запуск, почему бы не использовать ее как основу?
Прежде чем начать разрабатывать systemd мы изучили имеющиеся системы и ни одна из них не зацепила нас (естественно, за исключением launchd). Если вы этого никак не можете заметить - прочтите приведенный выше текст еще раз.

Помощь проекту 

 

Мы очень заинтересованы в патчах и другой помощи. В этом смысле наш проект ничем не отличается от любых других проектов свободного ПО, основные преимущества которых заключаются в как можно более широком взаимодействии с сообществом. И это, действительно, большей частью правда для такой фундаментальной части системы, как система инициализации. Нам ценно взаимодействие с вам, поэтому мы не требуем передачи прав (в отличие от Canonical/Upstart!). Мы также используем git, как всеми любимую систему контроля версий!
Мы сильно заинтересованы в том, чтобы systemd заработал на других дистрибутивах, отличных от Fedora и openSUSE (Эй, кто-нибудь из Debian, Gentoo, Mandriva, MeeGo, не хотите ли заняться этим?). Ну и помимо перечисленного, нам нужны коллеги любого уровня: мы приглашаем программистов на С, майнтейнеров пакетов, заинтересованных в написании документации или разработке логотипа.

Сообщество 

 

В настоящее время, все что у нас есть - это репозиторий с исходным кодом и IRC-канал (#systemd на Freenode). Нет списков рассылки, веб-сайта или системы отслеживания ошибок. Возможно, что скоро у нас будет нечто подобное на freedesktop.org. Если у вас есть некоторые вопрос, которые вы хотите задать нам, мы приглашаем вас к нам на IRC-канал!



a silhouette of a person's head and shoulders, used as a default avatar

Система инициализации Systemd. Часть I

Наверное, все уже слышали о новой системе инициализации systemd, которая разрабатывается под опекой Red Hat и Novell. Я решил перевести описание работы этой системы от ее автора из его же блога. Сама статья оказалась слишком большой, поэтому выкладываю пока только ее первую часть. Вторую часть я выложу в течение пары дней. Ссылка на оригинал традиционно приведена в конце поста. Также традиционно, мои комментарии по тексту приведены курсивом.


Если вы в теме и умеете хорошо читать между строк, то уже знаете, о чем пойдет речь. Но, думаю, все равно вам будет интересна эта статья. Поэтому налейте себе чашечку кофе, садитесь и читайте о том, что грядет.
История долгая, а для тех, кто не хочет читать целиком, скажу вкратце: мы экспериментируем с новой системой инициализации, и это весело!
Здесь код. А вот сама история:


Роль процесса с PID 1

 

Каждая Unix-система имеет процесс со своим специальным идентификатором, равным 1. Этот процесс запускается ядром прежде всех остальных и является родительским процессом для всех процессов, которые не имеют собственного родителя. Благодаря этому он может делать много чего такого, что не могут остальные процессы. Например отвечает за такие вещи, как инициализация и поддержка работы пользовательского пространства в процессе загрузки системы.

Исторически на Linux в качестве такого процесса выступает старый добрый sysvinit, преклонный возраст которого сказывается все чаще и чаще. Многие пытались предложить ему замену, но реально прижился только Upstart (что интересно, один из вариантов перевода слова «upstart» - «выскочка» - прим. перев.), который уже нашел свое место во всех основных дистрибутивах.

Как уже отмечалось выше, главная обязанность init'а - максимально быстро инициализировать и сделать доступным пользовательское пространство. К сожалению, традиционная схема инициализации SysV делает это не так быстро, как хотелось бы.
Для организации быстрого и эффективного процесса загрузки системы решающее значение имеет следующее:
  • Запустить минимум необходимого.
  • Попытаться запустить параллельно всё остальное.

Что это означает на практике?
Запустить минимум необходимого означает запустить лишь самые необходимые сервисы либо отложить запуск каких-либо из них до тех пор, пока они реально не понадобятся. Иногда мы заранее знаем, какие сервисы нам понадобятся (syslog, системная шина D-Bus и т.п.), но так бывает не всегда. К примеру, демон bluetoothd не должен быть запущен то тех пор, пока не будет подключен Bluetooth-адаптер либо пока какое-то из приложений не захочет установить с ним соединение через интерфейс D-Bus. Аналогично для системы печати: если машина физически не подключена к принтеру, и/или никакие приложения не пытаются напечатать что-нибудь, то необходимости запускать демон печати, такой как CUPS, нет. Так же и для Avahi: если машина не подключена к сети, или пока никакое из приложений не захочет использовать его API, его также нет необходимости запускать. Это справедливо даже для SSH: пока кто-либо не захочет зайти на машину - в нем нет необходимости, его нужно запустить лишь тогда, когда кто-то захочет установить первое соединение (и это же относится ко многим машинам, где может быть запущен ssh, в тех случаях, когда к нему присоединяются раз месяц или реже).
Параллельный запуск всего остального означает, что если нужно что-либо запустить, то мы должны делать это не последовательно, а пытаться запустить все одновременно, чтобы максимально нагрузить имеющиеся ресурсы системы, сократив время ее запуска.

 

Динамическое изменение аппаратного и программного обеспечения


Современные системы (в частности операционные системы общего назначения) являются весьма динамичными в плане своей конфигурации и использования: они мобильны, запускают и останавливают различные приложения, к ним подключают всевозможное оборудование. Система инициализации, отвечающая за работу сервисов, должна обнаруживать изменения в аппаратном и программном обеспечении,  запускать (а иногда и останавливать) сервисы, поскольку они необходимы для запуска программ и/или для обеспечения поддержки определенного оборудования.
Большинство современных систем, которые пытаются распараллелить процесс запуска, по-прежнему пытаются синхронизировать запуск различных демонов: например, Avahi для работы требуется D-Bus, поэтому сначала запускается D-Bus и только потом - Avahi.  Аналогично для других служб: для libvirtd и X11 необходим HAL (да, я знаю, что на Fedora 13 службы игнорируют устаревший HAL), поэтому сначала запускается HAL, а уж потом libvirtd и X11. А поскольку для libvirtd нужен Avahi, он ждет еще и запуска Avahi. К тому же всем упомянутым службам нужен Syslog, они все ждут его запуска. И так далее.

 

Параллелизация запуска сервисов, зависящих от сокетов (socket service)


Такого рода синхронизация запуска служб приводит к тому, что значительная часть запуска системы проводится последовательно. Правда было бы здорово избавится от описанных требований такой синхронизации? На самом деле, нет ничего невозможного! Для этого мы должны понять, что именно демоны требуют друг от друга и почему их запуск откладывается. Что касается традиционных демонов Unix, на этот вопрос есть только один ответ: они ждут, пока сокет другого демона станет доступен для соединения. Обычно это сокет AF_UNIX в файловой системе либо это может быть AF_INET [6]. К примеру, клиенты D-Bus ждут возможности подключения к /var/run/dbus/system_bus_socket, клиенты syslog - /dev/log, клиенты CUPS - /var/run/cups/cups.sock, NFS-клиенты  ожидают /var/run/rpcbind.sock и открытия порта portmapper и т. д. Только подумайте - это единственное, чего они ждут.
Таким образом, если причина задержки только в этом, если мы сможем добиться того, чтобы перечисленные сокеты стали доступны ранее запуска соответствующих демонов, мы сможем серьезно ускорить процесс запуска системы и запустить намного больше процессов одновременно. Как же этого добиться? На самом деле в Unix-подобных операционных системах все довольно просто: мы можем создать слушающие сокеты, задолго до реального запуска демона, а затем (когда он запустится) просто передать ему сокет посредством в exec(). Таким образом, мы можем создать все нужные нам сокеты для всех демонов на первом шаге системы инициализации, а затем на втором шаге просто запустить все демоны одновременно. Если одна служба нужна другой - ничего страшного не случится, даже если требуемая служба еще не запущена: единственное что произойдет - требуемое соединение встанет в очередь на ожидание и клиент будет ждать этого соединения (будет блокирован запросом). Но заблокирован будет только один клиент и только одним запросом. Кроме того, чтобы обеспечить необходимую параллелизацию запуска, теперь совсем не обязательно конфигурировать зависимости между службами, ведь мы запускаем все сокеты одновременно и запущенный сервис будет уверен в том, что он сможет присоединиться к нужному ему сокету.
Это ключевой момент, и без него все остальное понять будет нельзя, поэтому я попробую пояснить все то же самое, но другими словами и с примерами. Допустим, вы запускаете демон syslog и его клиенты одновременно. При этом все сообщения его клиентов будут добавлены в буфер сокета /dev/log.  Пока этот буфер не заполнится, клиентам не придется ждать, и они смогут запуститься. Как только syslog завершит процесс своего запуска, он обработает накопившуюся очередь сообщений. Другой пример: мы запускаем D-Bus и ее несколько клиентов одновременно. Если отправляется синхронный запрос (запрос, требующий мгновенного ответа) и поскольку ожидается ответ, клиент будет блокирован ожиданием, но только этот конкретный клиент и только до тех пор, пока D-Bus поймает этот запрос и обработает его.
По сути, буферы сокетов ядра работают на нас, помогая нам максимально распараллелить запуск служб, причем обработка последовательности запросов и их синхронизация выполняется ядром системы без какой-либо надобности вмешиваться в этот процесс из пользовательского пространства! И если все сокеты становятся доступными прежде реального запуска демонов, управление зависимостями также становится излишним (или, по крайней мере, вторичным): если демону нужен другой демон, он просто подключится к нему. И если целевой демон уже запущен, то первый сразу же обратится к последнему. А если нет, то обратившийся демон не будет ждать его запуска, если только он не отправил синхронного запроса. И даже если этот другой демон вообще не запущен, это может быть сделано автоматически. С точки зрения первого демона в описанных случаях нет никакой разницы, следовательно управление зависимостями становится не нужно или, по крайней мере, вторично. Процесс запуска происходит с оптимальной параллелизацией запуска демонов либо с их запуском по требованию. Кроме того, такой путь обеспечивает большую надежность, так как сокеты остаются доступны независимо от фактического состояния демона, который может иногда быть недоступным (например из-за своего падения). В самом деле, вы можете легко написать демон, который будет запускаться, останавливаться (или падать) и запускаться снова и т. п., причем клиенты не почувствуют остановок демона и ни один запрос не потеряется.
Ну что ж, теперь самое время для паузы - налейте себе еще кофе и будьте уверены, что дальше будет еще интереснее.
Только сначала давайте проясним несколько вещей: это какая-то новая идея? Нет, определенно нет. Я назову вам одну из самых известных систем, работающих как описано: это launchd от Apple - на MacOS прослушивание сокетов всех демонов осуществляется launchd. Сами сервисы могут все запускаться одновременно, и для них не надо настраивать никаких зависимостей. Это на самом деле действительно интересная идея, и именно в ней кроется причина того, почему MacOS удается обеспечить фантастическую скорость загрузки. Я настоятельно рекомендую одно видео , где разработчики launchd объясняют, как она работает. К сожалению, предложенная идея так и не получила распространения вне лагеря поклонников Apple.
Хотя она, на самом деле, даже старше, чем launchd. До нее хорошо известный почтенный inetd работал аналогичным образом: сокеты централизованно создавались демоном, который запускал необходимый сервис, передавая ему дескриптор файла сокета посредством exec(). Однако центральной идеей inetd, конечно же, были не локальные, а интернет-сервисы (хотя более поздняя реализация поддерживала и сокеты AF_UNIX). Также он не являлся инструментом для распараллеливания процесса загрузки системы или какого-либо управления зависимостями между сервисами. Для TCP-сокетов inetd, в первую очередь, использовался таким образом, что для каждого входящего соединения новый экземпляр порождался новый экземпляр демона. Это означает, что для каждого соединения порождался и инициализировался новый процесс, что не очень хорошо для высокопроизводительных серверов. Тем не менее, с самого своего рождения inetd также поддерживает и другой режим, где демон порождался первым соединением и потом тот же экземпляр принимал последующие соединения (опция wait/nowait в файле inetd.conf , которая, к сожалению, плохо документирована). Запуск демона для каждого соединения, вероятно, создал для inetd репутацию медленного сервера, что не совсем справедливо.

Параллелизация запуска служб, зависящих от D-Bus (d-bus services)


Современные демоны на Linux, как правило, предоставляют услуги посредством D-Bus, а не простого сокета AF_UNIX. Таким образом, появляется вопрос - а можем ли мы применить для них ту же логику распараллеливания запуска сервисов, что и для для традиционных сокетов? Да можем! В D-Bus уже есть все необходимое для этого: с помощью активации посредством D-Bus служба может быть запущена при первом же обращении к ней. Такой способ запуска дает нам минимальную возможность синхронизации на запрос, которая нам нужна для одновременного запуска служб-потребителей и служб-поставщиков: если мы хотим запустить Avahi одновременно с CUPS (CUPS использует Avahi для поиска mDNS/DNS-SD принтеров), то так и следует сделать, и если CUPS запустится раньше, то с помощью логики активации сервисов посредством шины мы заставляем D-Bus создать очередь запросов, пока Avahi запускается.

Резюме: активация демонов посредством сокетов и шины D-Bus позволяет нам запустить все демоны параллельно, без какой-либо синхронизации. Это позволяет нам получить «ленивые» сервисы: если сервис используется редко, можно просто загрузить его по потребности, вместо того, чтобы запускать его во время загрузки.
И если это не круто, тогда я не знаю, что круто!


Параллелизация заданий, имеющих отношение к файловой системе

Если вы посмотрите на графики визуализации загрузочного процесса текущих дистрибутивов, то увидите множество точек, требующих синхронных операций: самое важное - это задания, связанные с файловыми системами. Обычно при загрузке системы много времени тратится на ожидание инициализации всех устройств, перечисленных в файле /etc/fstab, затем на проверку файловых систем, инициализацию квот. Только после того как это все закончится, мы сможем продолжить процесс загрузки.
Можем ли мы как-то решить эту проблему? Оказывается, можем! Harald Hoyer выдвинул идею использования для этого старой доброй autofs. Системный вызов connect() показывает, что одна служба заинтересована в другой, аналогичным образом вызов open() (или подобный ему) показывает, что служба заинтересована в конкретном файле или файловой системе. Таким образом, чтобы улучшить параллелизацию запуска, можем заставить программы ждать, пока файловая система будет готова (смонтирована). Добиваемся мы этого следующим образом - мы создаем точки монтирования autofs, а затем, когда завершатся разные проверки целостности, инициализируются квоты и т.п., мы заменим ее реальной файловой системой. Когда работает autofs, попытки обращения к ней будут поставлены в очередь ядром системы и обратившийся процесс будет заблокирован (но  - только этот демон, и только эта конкретная попытка доступа). И таким образом мы сможем начинать запускать наших демонов  задолго до того, как наши файловые системы станут доступны, без каких-либо потерь файлов и с максимальной параллелизацией.
Распараллеливание заданий, связанных с файловой системой и с запуском сервисов, не имеет смысла для корневой системы, поскольку именно там хранятся бинарники всех сервисов. Однако по отношению к файловым системам, таким как, например, /home, которые обычно намного больше, а иногда даже зашифрованы, возможно даже находятся на удаленном компьютере, такой подход может серьезно оптимизировать время загрузки системы. И уж конечно стоит отметить, что такие виртуальные файловые системы, как procfs или sysfs, никогда не должны  монтироваться с помощью autofs.
Я не удивлюсь, если кто-то из читателей может посчитать, что интеграция autofs с системой инициализации ухудшит стабильность и что это решение вообще какое-то странное, страшное и уродливое. Однако, неоднократно опробовав это решение, я могу вам сказать, что оно совершенно правильное. Использование autofs позволяет, нам создать точку монтирования без необходимости обеспечить наличие самой файловой системы. На практике это влечет за собой только задержку доступа к ФС. Если приложение пытается получить доступ к файловой системе, находящейся под опекой autofs и мы очень долго не заменяем ее реальной файловой системой, оно будет находиться в состоянии interruptible sleep. Отметим также, что в любой момент, если точка монтирования так и не становится доступной к концу запуска (например, если fsck не удалось удачно проверить файловую систему), мы можем просто попросить autofs вернуть приложению код ошибки (например ENOENT). Поэтому я полагаю, что хоть на первый взгляд включение autofs в систему инициализации может показаться чересчур смелым, наш экспериментальный код показал, что эта идея работает на удивление хорошо на практике.

Сокращение количества вызываемых во время запуска системы скриптов
 
Еще один момент, который вытекает из логики загрузки MacOS: shell-скрипты - зло.
Shell-скрипты имеют свои преимущества и недостатки. Их можно быстро писать и отлаживать, но они медленно работают. Классическая логика загрузки sysvinit построена вокруг скриптов. Будь то /bin/bash или любая другая оболочка (написанная, чтобы сделать работу скриптов быстрой), в конце концов этот подход все равно упирается в медлительность работы. В моей системе скрипты, находящиеся в /etc/init.d/, вызывают grep по крайней мере 77 раз, awk - 92 раза, cut - 23 и sed - 74. Каждый раз, когда вызываются эти команды (или какие-то другие), порождаются новые процессы, производится поиск библиотек и т.д. А затем, когда запущенный процесс выполняет какую-то простейшую операцию с текстовыми строками - он завершается. Естественно, что это все работает ужасно медленно. Ни один другой язык, кроме оболочки, не работает, как описано. Кроме того, работа скриптов сильно зависит от различных переменных среды и тому подобного, причем это все трудно контролировать.
Итак, давайте избавимся от скриптов в процессе загрузки! Прежде чем мы сможем это сделать, нам нужно выяснить, как они используются сейчас: по большому счету картина такова - большую часть времени они заняты рутинными операциями. Большинство сценариев производит элементарные операции и вызов сервисов, поэтому эти операции можно переписать на С, либо отдельные исполняемые файлы, либо сами демоны, либо сделать конкретную операцию частью системы инициализации.
Маловероятно, что мы в ближайшее время полностью сможем избавиться от скриптов при старте системы. Переписывание их на C занимает много времени, в ряде случаев игра вообще не стоит свеч, а иногда, наоборот, без скриптов вообще трудно обойтись. Но мы, безусловно, можем уменьшить их влияние на процесс загрузки.
Хороший показатель для измерения количества вызова скриптов в течение запуска системы - это PID процесса, который он получает сразу после запуска системы. Загрузитесь, войдите в систему, откройте терминал и введите echo $$. Попробуйте сделать это на вашей Linux-системе, а затем сравните результат с MacOS! (Подсказка: на Linux PID будет порядка 1823; на MacOS примерный PID - 154).

Слежение за процессами


Центральная часть системы инициализации - это выполнение обязанностей няни по отношению к сервисам: она должна следить за ними. Перезапускать их, если они завершают свою работу. Если они падают, нужно собирать всю необходимую информацию о них и сохранить ее для администратора, предоставлять ее аварийным системам сбора информации (crash dump systems) и системам ведения журнала (например syslog) и/или системе аудита.
Также она должна позволять полностью завершать сервис со всеми своими потомками. Это, наверное, проще сказать, чем сделать. Традиционно в Unix процесс, который дважды вызывает fork(), может избежать контроля своего родителя, и родитель ничего не узнает об отношении нового процесса к тому, что он запустил. Например: неправильно написанный CGI скрипт, который вызван двойным fork(), не прерывает свою работы при завершении Apache. Кроме того, вы даже не сможете выяснить его отношение к Apache, если не знаете его имя и назначение.
Итак, как же мы сможем уследить за процессами, чтобы они не убежали от нашей няни, и  контролировать их как единое целое, даже если они форкаются огромное количество раз (в оригинале gazilion times :) - прим. перев.) ?
Разные люди предлагают различные решения. Скажу вкратце, что есть подходы, основанные на использовании интерфейса ptrace или netlink (интерфейс ядра, который позволяет получить сообщение netlink каждый раз, когда любой процесс в системе вызывает fork() или exit()), которые подвергались критике за топорность, неповоротливость и плохую масштабируемость.
А что же мы можем предложить? В ядре уже достаточно долго существует такая вещь, как Control Groups (aka "cgroups"). В основном они позволяют создавать иерархию групп процессов, которая непосредственно доступна через виртуальную файловую систему. Названия групп  - это обычно названия директорий в этой файловой системе. Если процесс, принадлежащий к определенной группе, вызывает fork(), его потомок становится членом той же группы. Если он не имеет привилегированного статуса, он никак не сможет этого избежать. Первоначально cgroups были добавлены в ядро для организации контейнеров: различные подсистемы ядра могут устанавливать лимиты на ресурсы (ограничение использования процессора и/или памяти) для определенных групп. Традиционные ограничения ресурсов (как реализовано setrlimit()) устанавливаются (в основном) только для каждого процесса. cgroups, с другой стороны, позволяют устанавливать ограничение на целые группы процессов. cgroups полезны также для обеспечения соблюдения ограничений в других случаях. Вы можете использовать его, например, для ограничений общего объема памяти или ресурсов процессора для Apache и всех его дочерних процессов. Поэтому неправильный CGI-скрипт не сможет сбежать от установленных ограничений ресурсов путем вызова fork().
В дополнение к своим функциям по созданию контейнеров и использованию для ограничения ресурсов cgroups являются очень полезными как средство для слежения за демонами: членство в cgroup надежно наследуется дочерними процессами и избежать этого невозможно. Существует система уведомлений, которая ставит в известность главный процесс, когда cgroup становится пустой. Вы можете найти cgroups для процесса путем чтения файла /proc/$PID/cgroup, следовательно, это очень хороший выбор средства для отслеживания процессов.

Контроль за средой исполнения процесса

Хорошая няня должна не только следить за демонами и контролировать их, но и создавать для них хорошее и безопасное окружение. Это означает, что мы не ограничиваемся очевидными параметрами, такими как настройка ограничений ресурсов для процесса посредством setrlimit(), идентификаторы пользователя и групп. Ядро Linux дает пользователям и администраторам достаточно контроля над процессами (некоторые из них в настоящее время используются редко).
Для каждого процесса нам нужно устанавливать контроль над использованием процессора, планировщика ввода-вывода, набор функциональных ограничений, привязку к процессору и, конечно же, дополнительные ограничения посредством cgroup. Самое главное здесь - это высокоуровневый контроль, такой как, например, монтирование файловой системы в режиме только чтения при вызове mount с опцией bind. Таким образом, можно запускать отдельные демоны так, что все (или некоторые) файловые системы будут ему доступны только для чтения. Это можно использовать для контроля за тем, что делают отдельные демоны, нечто вроде бюджетного варианта SELinux (хотя это, конечно, не призвано заменить SELinux).
Наконец, ведение логов является важной составной частью запуска сервисов: в идеале каждый бит информации, выдаваемый сервисом, должен записываться в журнал.  Следовательно, система инициализации должна обеспечить процесс ведения логов для демонов, с которыми она работает, подключая стандартный вывод (stdout) и вывод ошибок (stderr) к демону syslog. А иногда даже к /dev/kmsg, который во многих случаях очень полезная замена syslog (те, кто делает встроенные системы, прислушайтесь, пожалуйста, к этому!).

Upstart, внимание, марш!

Во-первых, я бы хотел подчеркнуть, что мне на самом деле нравится код Upstart, он очень хорошо комментирован и его легко изучать. Другим проектам в этом отношении еще учиться и учиться (в том числе и моим собственным). В то же время я не могу согласится с общим подходом, который реализован в Upstart. Но сначала несколько слов о проекте.
Upstart не разделяет код с sysvinit, а его функциональные возможности перекрывают возможности sysvinit, и обеспечивает совместимость с какой-то частью хорошо известных скриптов SysV. Его основная особенность - управление сервисами на основе событий: запуск и остановка процессов связаны с "событием", которое происходит в системе, где "событием" может быть все что угодно: доступность сетевых интерфейсов, запуск какого-то ПО и т.п.
Upstart обрабатывает последовательность запуска служб посредством событий: если срабатывает событие syslog-started - оно используется как индикатор для запуска D-Bus, т. к. шина теперь сможет использовать syslog. А затем, когда срабатывает событие dbus-started, запускается NetworkManager, после чего он может использовать D-Bus, и так далее.
Можно сказать, что логическое дерево зависимостей, которое существует и хорошо понимается администратором или разработчиком, транслируется в систему событий и набор правил, описывающих реакции на события: каждое логическое «для a нужно b» становится «запустить а, когда нужно b» плюс «остановить а, когда останавливается b». Это своего рода упрощение, особенно для кода самого Upstart. Тем не менее я утверждаю, что такое упрощение на самом деле вредно. Прежде всего, система логических зависимостей никуда не девается, и тот, кто пишет файлы для Upstart, теперь должен транслировать эти правила в формате «события/действия» (два правила для каждой зависимости). Таким образом, вместо того, чтобы позволить компьютеру выяснить, что нужно делать на основе зависимостей, пользователь должен вручную перевести зависимости в простое правило «событие - реакция на него». Кроме того, поскольку информация о зависимостях не может быть декодирована, она не доступна во время работы системы, фактически это означает, что у администратора, который пытается разобраться, почему что-то произошло, нет на это никаких шансов.
Кроме того, в случае Upstart логика работы с зависимостями переворачивается с ног на голову. Вместо того чтобы свести к минимуму объем работы (что является признаком и целью хорошей системы инициализации), на самом деле происходит увеличение количества работы, выполняемой во время операций. Другими словами, вместо того, чтобы имея четко поставленную цель, проделать все необходимые шаги сразу, она делает сначала один шаг, а потом делает все остальные шаги, которые к ней ведут. Или еще проще: то, что пользователь запустил D-Bus, ни в коей мере не означает, что NetworkManager должен быть также запущен (но это то, что будет делать Upstart). А должно быть с точностью до наоборот: когда пользователь обращается к NetworkManager, это признак того, что D-Bus также должна быть запущена (это, безусловно, именно то, что ожидают большинство пользователей, не так ли?). Хорошая система инициализации должна запускать только то, что нужно, и по требованию. Либо по потребности, либо максимально параллелизуя запуск. Однако она не должна запускать больше, чем необходимо, в частности не все из установленного, для чего может понадобится этот сервис
(Честно говоря, и это только мое мнение, без претензии на истинность, что тут автор пытается притянуть за уши аргументы против Upstart. Тем более, что приведенные автором примеры относительно D-Bus и NetworkManager не соответствуют реальности. Прим. перев.).
Наконец я не вижу реальной ценности от логики, основанной на событиях. Мне кажется, что большинство событий, обрабатываемых Upstart, фактически не мгновенны, а имеют некоторую продолжительность: сервис запускается, работает и останавливается. Устройство подключается, подключено и отключается. Точка монтирования находится в состоянии монтирования, полностью смонтирована, или же она размонтирована. Кабель питания подключен, система работает от сети переменного тока, кабель питания отключен. Лишь немногие из событий системы инициализации должны обрабатываться точно в срок, большая часть из них - это старт, запуск и остановка. Информации об этом также нет в Upstart.
Мне известно, что некоторые проблемы, на которые я указал выше, в некоторой степени решаются последними изменениями в конфигурационных правилах Upstart, такими как, например, start on (local-filesystems and net-device-up IFACE=lo). Тем не менее, я считаю, что это выглядит как попытка исправить систему (автор считает, что такое решение - «костыль» - прим. перев.), основной дизайн которой является некорректной.
Кроме того, Upstart вполне подходит на роль няни для демонов, хотя что-то она делает сомнительными способами (см. выше).
Есть и другие системы инициализации, кроме sysvinit, Upstart и launchd. В большинстве из них подходы намного серьезнее, чем в Upstart или sysvinit. Наиболее интересной является Solaris SMF, которая поддерживает надлежащую обработку зависимостей между службами. Тем не менее, во многих отношениях она чрезмерно усложнена и, скажем так, несколько академична, чрезмерно использует XML и новые термины для известных вещей. Она также сильно завязана на специфичных для Solaris функциями, такими как contract system.