Журнал LinuxFormat - перейти на главную

LXF142:LT2

Материал из Linuxformat
Перейти к: навигация, поиск
Тре­нин­ги Linux


Тренинги Linux от Майка Сондерса

Содержание

Майк Сон­дерс ве­дет Тре­нин­ги Linux

Часть 2: По­сле вы­лаз­ки в мир «же­ле­за», те­перь под­роб­но рас­смот­рим про­цесс за­груз­ки. Да вы­плюнь­те же­ва­тель­ную ре­зин­ку!

Вы на­жали кноп­ку вклю­чения ком­пь­ю­те­ра. На эк­ране мель­ка­ют со­об­щения или некая анима­ция (ес­ли у вас на­столь­ный ди­ст­ри­бу­тив), и на­конец по­яв­ля­ет­ся при­гла­шение для вхо­да в сис­те­му. Что же про­ис­хо­дит за это ко­рот­кое вре­мя? Это­му мы и по­свя­тим второй урок из цик­ла «Тренин­ги Linux». Как и пре-дыдущий урок, он по­мо­жет вам под­го­то­вить­ся к сер­ти­фи­ка­ции в LPI и пригодится тем, кто ищет ра­бо­ту в ми­ре Linux или про­сто хо­чет поболь­ше уз­нать о сво­ей операционной системе.

В ка­че­­ст­ве осно­вы для сер­ти­фи­ка­ции ис­поль­зу­ют­ся не пе­ре­мен­чи­вые и час­то об­нов­ляе­мые ди­ст­ри­бу­ти­вы, а бо­лее ста­биль­ные плат­фор­мы, ис­поль­зуе­мые в про­мыш­лен­ных ре­шениях, та­кие как Red Hat Enterprise Linux (RHEL), CentOS и Debian. На про­шлом уро­ке мы ра­бо­та­ли с CentOS; на сей раз на­ста­ла оче­редь Debian (вер­сия 5). Хо­тя оп­ре­де­лен­ные функ­ции в раз­ных ди­ст­ри­бу­ти­вах реа­ли­зо­ва­ны по-раз­но­му, боль­шин­ст­во из ска­зан­но­го при­менимо ко всем.

Раз­дел 1: От вклю­че­ния ПК до ра­бо­че­го сто­ла

Про­цесс за­груз­ки Linux вклю­ча­ет за­мы­сло­ва­тый на­бор про­цес­сов и скрип­тов, ко­то­рые пре­вра­ща­ют ком­пь­ю­тер, до это­го быв­ший лишь мерт­вой гру­дой ме­тал­ла, в мощ­ную ра­бо­чую стан­цию или сер­вер. Да­вай­те прой­дем по основ­ным эта­пам загрузки.

BIOS

BIOS (Basic Input/Output System – ба­зо­вая сис­те­ма вво­да/вы­во­да) – ма­лень­кая про­грам­ма, про­жи­ваю­щая в мик­ро­схе­ме на ма­те­рин­ской пла­те. По на­жа­тию кноп­ки вклю­чения пи­тания ком­пь­ю­те­ра про­цес­сор на­чи­на­ет вы­пол­нять код BIOS. Вы несо­мнен­но ви­де­ли со­об­щения ‘Hit F2 for setup’ [На­жми­те F2 для настройки], ко­то­рые по­яв­ля­ют­ся при за­груз­ке сис­те­мы. Так мож­но вой­ти в BIOS и из­менить на­строй­ки, на­при­мер, по­ря­док за­груз­ки дис­ков. Обыч­но BIOS вы­пол­ня­ет бы­ст­рую про­вер­ку уст­ройств – на­при­мер, мик­ро­схем опе­ра­тив­ной па­мя­ти – и за­тем пы­та­ет­ся най­ти за­груз­чик. Она пробует за­гру­зить пер­вые 512 байт с дис­ке­ты или же­ст­ко­го дис­ка в па­мять, и ес­ли это уда­лось сде­лать, вы­пол­ня­ет их.

За­груз­чик

Итак, BIOS пе­ре­дал управ­ление пер­вой час­ти ОС – за­груз­чи­ку раз­ме­ром пол-ки­ло­бай­та. В вось­ми­де­ся­тых та­ко­го неболь­шо­го объ­е­ма па­мя­ти бы­ло доста­точ­но, что­бы за­гру­зить яд­ро ОС [На самом деле никогда не было достаточно, просто раньше выбора не было и загружалось только одно ядро которому нельзя было передать параметры до загрузки, поэтому загрузчик содержал только адрес на диске где ему брать это ядро.]. Од­на­ко со­вре­мен­ные за­груз­чи­ки долж­ны под­дер­жи­вать мно­же­ст­во раз­лич­ных фай­ло­вых сис­тем, опе­ра­ци­он­ных сис­тем и гра­фи­че­­ских ре­жи­мов, по­это­му 512 байт для них недоста­точ­но. В слу­чае с Grub, ко­то­рый ис­поль­зу­ет­ся в боль­шин­ст­ве ди­ст­ри­бу­ти­вов Linux, за­груз­чик раз­ме­ром пол-ки­ло­бай­та за­гру­жа­ет дру­гую про­грам­му Stage 1.5.

Это за­груз­чик чуть по­боль­ше, рас­по­ло­жен­ный в на­ча­ле дис­ка, что­бы его мож­но бы­ло лег­ко най­ти. За­тем он за­гру­жа­ет Grub Stage 2, пол­но­цен­ный за­груз­чик, ко­то­рый пре­достав­ля­ет все при­выч­ные вам воз­мож­но­сти. Grub счи­ты­ва­ет файл на­строй­ки, за­гру­жа­ет яд­ро Linux в опе­ра­тив­ную па­мять и на­чи­на­ет его вы­пол­нять.

Яд­ро Linux и Init

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

Сде­лав все необ­хо­ди­мое, яд­ро пе­ре­да­ет управ­ление поль­зо­ва­тель­ско­му про­стран­ст­ву – мес­ту, где вы­пол­ня­ют­ся про­грам­мы. Яд­ру неин­те­рес­но за­пускать Bash, Gdm и т. д. на­пря­мую, по­это­му оно за­пуска­ет толь­ко од­ну глав­ную про­грам­му – /sbin/init. Это пер­вый на­стоя­щий про­цесс в сис­те­ме. Init от­ве­ча­ет за вызов за­гру­зоч­ных скрип­тов, за­пускаю­щих сис­те­му, но ему нуж­но знать, что за­пускать. Его основ­ной файл на­строй­ки – /etc/inittab, обыч­ный тек­сто­вый файл, ко­то­рый мож­но из­ме­нять.

В осно­ве это­го фай­ла ле­жит кон­цеп­ция уровней вы­полнения [runlevels] – раз­лич­ных со­стояний, в ко­то­рых мо­жет на­хо­дить­ся ра­бо­таю­щая сис­те­ма, та­ких как од­но- и мно­го­поль­зо­ва­тель­ский ре­жим и вы­клю­чение. О них мы по­го­во­рим поз­же, а по­ка вам нуж­но знать, что /etc/inittab ве­лит init за­пустить скрипт /etc/init.d/rc с уровнем вы­полнения в ка­че­­ст­ве па­ра­мет­ра.

Этот скрипт вы­зы­ва­ет дру­гие, для на­строй­ки раз­лич­ных час­тей сис­те­мы – уста­нов­ки се­те­во­го со­единения, за­пуска сис­тем­ных жур­на­лов и – на на­столь­ном ком­пь­ю­те­ре – за­пуска X Window System и менед­же­ра вхо­да в сис­те­му. По­сле вво­да ло­ги­на и па­ро­ля менед­жер вхо­да в сис­те­му за­пуска­ет вы­бран­ный ра­бо­чий стол или окон­ный менед­жер, и все го­то­во к ра­бо­те. Весь этот про­цесс – от вклю­чения пи­тания до вы­бо­ра ико­нок на ра­бо­чем сто­ле – вклю­ча­ет мас­су ра­бо­ты, но в це­лом хо­ро­шо упрятан от поль­зо­ва­те­ля.

Раз­дел 2: Из­менение на­стро­ек Grub

LXF142 77 1.jpg Grub — не­ве­ро­ят­но гиб­кий за­груз­чик. На­жав кла­ви­шу E, мож­но ре­дак­ти­ро­вать его па­ра­мет­ры пе­ред на­ча­лом за­груз­ки.

Те­перь поподробнее рас­смот­рим за­груз­чик. Ча­ще все­го это мощ­ный Grub, спо­соб­ный за­гру­жать мно­же­ст­во ОС и ме­нять кон­фи­гу­ра­цию во вре­мя за­груз­ки. Мы по­го­во­рим о его фай­лах на­строй­ки и свя­зан­ных с ним ути­ли­тах в дру­гих стать­ях, а по­ка изучим из­менение кон­фи­гу­ра­ции во вре­мя за­груз­ки в на­шем Debian.

По­сле за­груз­ки Grub сра­зу по­сле BIOS вы ви­ди­те спи­сок воз­мож­ных ва­ри­ан­тов за­груз­ки. Для вы­бо­ра од­но­го из них мож­но на­жать Enter, но мож­но и из­менить их пря­мо во вре­мя за­груз­ки: вы­бе­ри­те ва­ри­ант, ко­то­рый хо­ти­те из­ме­нить, и на­жми­те E. По­сле это­го на эк­ра­не поя­вят­ся сле­дую­щие три стро­ки:

root (hd0,0)
kernel /boot/vmlinuz-2.6.26-2-686 root=/dev/hda1 ro quiet
initrd /boot/initrd.img-2.6.26-2-686

По­смот­ри­те на вто­рую стро­ку. Она со­об­ща­ет Grub, где най­ти яд­ро Linux и ка­кие па­ра­мет­ры за­груз­ки ему пе­ре­дать. В этом слу­чае мы го­во­рим яд­ру, где на­хо­дит­ся корневой раз­дел (/); ro оз­на­ча­ет, что раз­дел нуж­но смон­ти­ро­вать в ре­жи­ме толь­ко для чтения. Это нуж­но за­тем, что­бы при необ­хо­ди­мо­сти про­ве­рить фай­ло­вую сис­те­му – чуть поз­же она бу­дет пе­ре­мон­ти­ро­ва­на в ре­жи­ме чтения и за­пи­си. А quiet го­во­рит яд­ру, что оно не долж­но вы­да­вать нам слиш­ком мно­го со­об­щений, что­бы за­груз­ка бы­ла яснее и за ней бы­ло про­ще сле­дить.

Мы мо­жем из­менить эти па­ра­мет­ры, на­жав стрел­ку вниз, что­бы вы­брать вто­рую стро­ку, и сно­ва на­жав E. Ок­но пе­рей­дет в ре­жим чис­то­го ре­дак­ти­ро­вания, в ко­то­ром вы смо­же­те до­ба­вить и уда­лить оп­ции. С по­мо­щью кла­виш управ­ления кур­со­ром его мож­но пе­ре­ме­щать по стро­ке. Да­вай­те кое-что по­про­бу­ем: по­сле quiet до­бавь­те букву s (их дол­жен раз­де­лять про­бел). Так мы за­да­ем уро­вень за­груз­ки, на ко­то­рый долж­но за­гру­зить­ся яд­ро – s оз­на­ча­ет од­но­поль­зо­ва­тель­ский ре­жим [single user].

На­жми­те Enter, что­бы вер­нуть­ся в ок­но Grub, за­тем B, что­бы на­чать про­цесс за­груз­ки. Так как мы за­гру­жа­ем­ся в од­но­поль­зо­ва­тель­ский ре­жим, по­сле инициа­ли­за­ции яд­ра и мон­ти­ро­вания корнево­го раз­де­ла про­цесс за­вер­шится, и у вас запросят па­роль поль­зо­ва­те­ля root. Вве­ди­те его, и вы попа­де­те в команд­ную стро­ку. Это ог­раничен­ный ре­жим ра­бо­ты, но он удо­бен для ре­шения про­блем с за­груз­кой – в нем мож­но бес­пре­пят­ст­вен­но из­ме­нять скрип­ты и ис­прав­лять ошиб­ки.

За­груз­ка в бу­ду­щем

Скорая помощь

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

За­гру­зоч­ные скрип­ты в Linux (и Unix) тра­ди­ци­он­но за­пуска­ют­ся по­сле­до­ва­тель­но, т. е. один за дру­гим. Это про­сто и га­ран­ти­ру­ет правильную очередность ак­ти­ви­за­ции оп­ре­де­лен­ных уст­ройств на оп­ре­де­лен­ных эта­пах про­цес­са за­груз­ки. Од­на­ко это неэф­фек­тив­но и при­во­дит к уве­ли­чению вре­мени за­груз­ки, осо­бен­но на ста­ром «же­ле­зе». Зна­чи­тель­ную часть вре­мени скрип­ты ждут, по­ка что-то про­изой­дет – на­при­мер, по­ка ак­ти­ви­ру­ет­ся уст­рой­ст­во или по­ка DHCP-сер­вер се­ти вы­даст раз­ре­шение.

Но ведь бы­ло бы здо­ро­во чем-то заняться во вре­мя этих за­дер­жек? Та­ко­ва цель рас­па­рал­ле­лен­ных скрип­тов init. По­ка се­те­вой скрипт ждет сиг­нал от DHCP-сер­ве­ра, дру­гой скрипт мо­жет очи­стить ка­та­лог /tmp или за­пустить X Window System. Впро­чем, что­бы за­пустить несколь­ко скрип­тов па­рал­лель­но, недоста­точ­но на­пи­сать их в строч­ку че­рез ам­пер­сан­ды – неко­то­рые скрип­ты за­ви­сят от оп­ре­де­лен­ных ре­сур­сов. На­при­мер, скрипт за­груз­ки, ко­то­рый по­лу­ча­ет IP-ад­рес че­рез DHCP, пред­по­ла­га­ет, что сеть уже ак­ти­ви­ро­ва­на дру­гим скрип­том.

InitNG – па­рал­лель­ная сис­те­ма за­груз­ки, в ко­то­рой за­ви­си­мо­сти скрип­тов уст­рое­ны так, что­бы по­ря­док их за­груз­ки не иг­рал ро­ли. Upstart, ис­поль­зуе­мый в Ubuntu, за­пуска­ет скрип­ты на осно­ве сис­тем­ных со­бы­тий, та­ких как об­на­ру­жение уст­рой­ст­ва. За­тем есть System D (ожи­да­ет­ся в Fedora 15) и дру­гие под­хо­ды. Ра­ди бла­га ав­то­ров до­ку­мен­тов и ад­минист­ра­то­ров бу­дем на­де­ять­ся, что мир Linux в итоге оста­но­вит­ся на чем-то од­ном, но ша­ги в этом на­прав­лении в лю­бом слу­чае зна­чи­тель­но уско­ря­ют про­цесс за­груз­ки Linux.

Раз­дел 3: Про­смотр фай­лов жур­на­лов

При упо­мя­ну­той ранее оп­ции quiet и об­щем бы­ст­ро­дей­ст­ви­и со­вре­мен­ных ком­пь­ю­те­ров вполне воз­мож­но, что фо­то­ны от со­об­щений за­груз­ки ед­ва успе­ют достиг­нуть ва­шей сет­чат­ки, как про­цесс за­груз­ки за­вер­шит­ся. К сча­стью, сообщения мож­но спо­кой­но про­честь, когда сис­те­ма пол­но­стью за­гру­зит­ся. За­гляните в файл /var/log/messages (для это­го у вас долж­ны быть пра­ва root), и уви­ди­те там все со­об­щения, сгенери­ро­ван­ные ядром с мо­мен­та его за­пуска. Од­на­ко при по­пыт­ках яд­ра оп­ре­де­лить, ка­кие уст­рой­ст­ва уста­нов­ле­ны, ре­зуль­та­ты иногда его удив­ля­ют, так что не паникуй­те, ес­ли уви­ди­те занима­тель­ные пре­ду­пре­ж­дения вро­де ‘Warning: strange, CPU MTRRs all blank?’ [Пре­ду­пре­ж­дение: стран­но, все диа­па­зон­ные ре­ги­ст­ры па­мя­ти про­цес­со­ра чис­ты?]

Сон­дерс рас­ска­зы­ва­ет о яд­ре

LXF142 78 1.jpg Что­бы ва­ши со­об­ще­ния в лог-фай­лах вы­гля­де­ли при­вле­ка­тель­нее, по­про­буй­те gnome-system-log или Ksystemlog в KDE.

По­ря­док ра­бо­ты яд­ра при­мер­но та­ков (хо­тя неко­то­рые эта­пы пе­ре­кры­ва­ют друг дру­га):

  • По­лу­чение ин­фор­ма­ции об уст­рой­ст­вах из BIOS (уч­ти­те, что ей не всегда мож­но до­ве­рять).
  • Оп­ре­де­ление ко­ли­че­­ст­ва про­цес­со­ров/ядер и изу­чение всех воз­мож­но­стей про­цес­со­ра.
  • По­лу­чение ин­фор­ма­ции ACPI и за­прос ин­фор­ма­ции об уст­рой­ст­вах на шине PCI.
  • Инициа­ли­за­ция се­те­во­го сте­ка TCP/IP.
  • По­иск же­ст­ких дис­ков, дис­ко­во­дов и при­во­дов CD-ROM.
  • Оп­ре­де­ление USB-кон­трол­ле­ров и под­клю­чен­ных к ним устройств.

Удов­ле­тво­рив­шись со­стоянием сис­те­мы, яд­ро мон­ти­ру­ет корневую фай­ло­вую сис­те­му и за­пуска­ет /sbin/init как опи­са­но вы­ше. Хо­тя /var/log/messages — цен­ный ре­сурс для оп­ре­де­ления дей­ст­вий яд­ра по­сле за­груз­ки, он мо­жет быть за­гро­мо­ж­ден со­об­щения­ми и от дру­гих про­грамм. На­при­мер, в на­шем ди­ст­ри­бу­ти­ве во мно­гих стро­ках встре­ча­ет­ся debian:, но есть и дру­гие – с dhcbd и т. д.

Ес­ли вы хо­ти­те про­смот­реть толь­ко со­об­щения яд­ра, за­пусти­те ко­ман­ду dmesg. (Для удоб­ст­ва мож­но пе­ре­на­пра­вить ее ре­зуль­та­ты в тек­сто­вый файл ко­ман­дой dmesg > listing.txt.) Хо­тя боль­шин­ст­во со­об­щений, ко­то­рые вы там най­де­те, бу­дут от­но­сить­ся к ранним эта­пам за­груз­ки, эта ин­фор­ма­ция бу­дет об­нов­ле­на, ес­ли вы под­клю­чи­те но­вое уст­рой­ст­во. На­при­мер, вставь­те USB-флэш­ку и сно­ва вы­полните ко­ман­ду, и вы уви­ди­те но­вые со­об­щения, из ко­то­рых бу­дет яс­но, как яд­ро опо­зна­ло уст­рой­ст­во.

Раз­дел 4: Уровни вы­полнения и ма­гия /etc/init.d/

Ранее мы го­во­ри­ли об уров­нях вы­полнения, ко­то­рые иг­ра­ют неве­ро­ят­но важ­ную роль в ва­шем ди­ст­ри­бу­ти­ве, да­же ес­ли вы никогда о них не слы­ша­ли. Уро­вень вы­полнения оп­ре­де­ля­ет со­стояние сис­те­мы – в ча­ст­но­сти, ка­кие про­цес­сы за­пу­ще­ны и ка­кие ре­сур­сы доступ­ны. Это не ка­кой-то сек­рет или чер­ная ма­гия яд­ра, а ис­клю­чи­тель­но сис­те­ма, в со­от­вет­ст­вии с ко­то­рой /sbin/init за­пуска­ет скрип­ты для ак­ти­ва­ции или де­ак­ти­ва­ции оп­ре­де­лен­ных функ­ций. Су­ще­ст­ву­ет во­семь уровней вы­полнения – у се­ми из них есть но­ме­ра:

  • 0 Ос­та­нов сис­те­мы Уро­вень вы­полнения, на ко­то­рый сис­те­ма пе­ре­хо­дит при вы­клю­чении ком­пь­ю­те­ра. При пе­ре­клю­чении на этот уро­вень за­пуска­ют­ся скрип­ты, ко­то­рые за­вер­ша­ют про­цес­сы и кор­рект­но оста­нав­ли­ва­ют сис­те­му.
  • 1 Од­но­поль­зо­ва­тель­ский ре­жим Обыч­ные поль­зо­ва­те­ли не мо­гут вой­ти в сис­те­му.
  • 2 – 5 Мно­го­поль­зо­ва­тель­ский ре­жим В Debian эти уровни иден­тич­ны, и вы мо­же­те из­менить один из них, ес­ли хо­ти­те. Это обыч­ный ре­жим ра­бо­ты, при ко­то­ром в сис­те­му мо­жет вой­ти несколь­ко поль­зо­ва­те­лей и все воз­мож­но­сти сис­те­мы ак­ти­ви­ро­ва­ны.
  • 6 Пе­ре­за­груз­ка Очень по­хож на уро­вень вы­полнения 0.

В других системах, например Red Hat/Fedora распределение уровней загрузки следующее:

  • 0 и 6 аналогично уже описанному
  • 1 - Однопельзовательский режим без поддержки сети
  • 2 - Однопользователский режим с поддержкой сети
  • 3 - Многопользовательский режим с поддержкой сети
  • 4 - Свободно, может быть использовано в личных целях
  • 5 - Многопользователский режим с поддержкой сети и автоматическим запуском X

Так­же есть уро­вень вы­полнения S, со­от­вет­ст­вую­щий од­но­поль­зо­ва­тель­ско­му ре­жи­му, ко­то­рый мы ак­ти­ви­ро­ва­ли пе­ред из­менением па­ра­мет­ров за­груз­ки Grub. Он очень по­хож на уро­вень вы­полнения 1, но есть и неболь­шие раз­ли­чия: S – уро­вень вы­полнения, ко­то­рый ис­поль­зу­ет­ся при за­груз­ке сис­те­мы, когда вам нуж­но пе­рей­ти в безо­пас­ный ре­жим восста­нов­ления. В про­ти­во­по­лож­ность ему, уро­вень вы­полнения 1 ис­поль­зу­ет­ся, когда сис­те­ма уже за­пу­ще­на и вам нуж­но пе­рей­ти в од­но­поль­зо­ва­тель­ский ре­жим, что­бы про­вес­ти ка­кие-то дей­ст­вия по об­слу­жи­ванию сис­те­мы. И не вол­нуй­тесь за поль­зо­ва­те­лей, ко­то­рые уже во­шли в сис­те­му: ничто их от­ту­да не вы­бро­сит.

Хо­тя уровни вы­полнения со 2 по 5 иден­тич­ны в Debian, в неко­то­рых дру­гих ди­ст­ри­бу­ти­вах в этом диа­па­зоне есть осо­бые уровни вы­полнения. На­при­мер, во мно­гих ди­ст­ри­бу­ти­вах уро­вень вы­полнения 3 – для мно­го­поль­зо­ва­тель­ско­го тек­сто­во­го ре­жи­ма, а уро­вень вы­полнения 5 – для вхо­да в сис­те­му в гра­фи­че­­ском ре­ жи­ме (та­ко­го как Xdm/Gdm/Kdm). Что­бы оп­ре­де­лить, на ка­ком уровне вы сейчас на­хо­ди­тесь, вы­полните ко­ман­ду /sbin/runlevel. Для пе­ре­клю­чения на дру­гой уро­вень вы­полнения восполь­зуй­тесь ко­ман­дой /sbin/telinit та­ким об­ра­зом (от име­ни root):

/sbin/telinit 2

А как уз­нать, на ка­ком уров­не вы­пол­не­ния ва­ша сис­те­ма ра­бо­та­ет по умол­ча­нию? Вол­шеб­ст­во здесь со­сре­до­то­че­но в фай­ле /etc/inittab. В на­ча­ле фай­ла вы уви­ди­те та­кие стро­ки:

# The default runlevel.
id:2:initdefault:

Стро­ки, на­чи­наю­щие­ся с сим­во­ла ре­шет­ки – ком­мен­та­рии, а ниж­няя стро­ка со­об­ща­ет init, что по умол­чанию ис­поль­зу­ет­ся уро­вень вы­полнения 2. Ес­ли вы соз­дае­те соб­ст­вен­ный уро­вень вы­полнения с по­мо­щью скрип­тов для уров­ня вы­полнения 3' и хо­ти­те за­гру­жать­ся на него по умол­чанию, мож­но про­сто от­крыть этот файл от имени root, из­менить но­мер уров­ня и пе­ре­за­гру­зить ком­пь­ю­тер.

Чуть ни­же в фай­ле /etc/inittab вы най­де­те не­сколь­ко строк при­мер­но та­ко­го ви­да:

l0:0:wait:/etc/init.d/rc 0
l1:1:wait:/etc/init.d/rc 1
l2:2:wait:/etc/init.d/rc 2
…

Они бу­дут про­дол­жать­ся до уров­ня 6. Эти стро­ки со­об­ща­ют init, что де­лать на ка­ж­дом уровне вы­полнения: за­пустить скрипт /etc/init.d/rc с но­ме­ром уров­ня вы­полнения в ка­че­­ст­ве па­ра­мет­ра. За­тем /etc/init.d/rc оп­ре­де­ля­ет, ка­кие скрип­ты ему нуж­но за­пустить для те­ку­ще­го уров­ня вы­полнения. Они ак­ку­рат­но раз­ло­же­ны по ка­та­ло­гам с со­от­вет­ст­вую­щи­ми но­ме­ра­ми в /etc. Там вы най­де­те ка­та­ло­ги /etc/rc0.d, /etc/rc1.d и т. д.

Пре­ду­пре­ж­де­ния об из­ме­не­нии уров­ней вы­пол­не­ния

Из­менение уровней вы­полнения на ком­пь­ю­те­ре с одним поль­зо­ва­те­лем – не про­бле­ма: вы уже го­то­вы к это­му. Но как на­счет мно­го­поль­зо­ва­тель­ской сис­те­мы? Что де­лать, ес­ли по SSH к вам под­клю­че­ны дру­гие поль­зо­ва­те­ли и они за­пусти­ли ка­кие-то про­грам­мы? Они не об­ра­ду­ют­ся, ес­ли вы­бить поч­ву у них из-под ног. К сча­стью, есть несколь­ко спо­со­бов опо­вес­тить их о гря­ду­щих из­менениях. Во-пер­вых, ес­ли вы за­шли в сис­те­му под поль­зо­ва­те­лем root, мо­же­те на­брать wall, текст со­об­щения и на­жать Ctrl+D. Это со­об­щение поя­вит­ся на тер­ми­на­лах всех на­хо­дя­щих­ся в сис­те­ме поль­зо­ва­те­лей. Так мож­но, на­при­мер, от­пра­вить со­об­щение «Вы­клю­чение че­рез 10 ми­нут». Обыч­ные поль­зо­ва­те­ли то­же мо­гут за­пускать ко­ман­ду wall, но они мо­гут и от­клю­чать со­об­щения от дру­гих обыч­ных поль­зо­ва­те­лей ко­ман­дой mesg.

Аль­тер­на­тив­ный спо­соб пре­ду­пре­дить поль­зо­ва­телей – на­пи­сать им пись­мо. Это мож­но сде­лать ко­ман­дой

echo “Пе­ре­за­груз­ка че­рез 10 ми­нут” | mail -s “Reboot notice” user@localhost

Ес­ли у поль­зо­ва­те­лей есть ути­ли­та опо­ве­ще­ния о но­вых пись­мах, они сра­зу уви­дят со­об­ще­ние. Но на боль­шой ус­та­нов­ке с не­сколь­ки­ми сот­ня­ми поль­зо­ва­те­лей в сис­те­ме луч­ше дать им не­сколь­ко ча­сов, а не ми­нут.

На уровне вы­полнения

За­глянем в ка­та­лог /etc/rc2.d уров­ня вы­полнения по умол­чанию в Debian. Внут­ри вы най­де­те несколь­ко скрип­тов с име­на­ми вро­де S05loadcpufreq и S89cron. Ка­ж­дый из них ак­ти­ви­зи­ру­ет оп­ре­де­лен­ную воз­мож­ность в ва­шей сис­те­ме – за­гляните в ка­кой-нибудь из них, и там вы уви­ди­те ком­мен­та­рий, опи­сы­ваю­щий дей­ст­вие скрипта.

Итак, у нас есть S30gdm, ко­то­рый за­пуска­ет Gnome Display Manager. Но что оз­на­ча­ют пер­вые три сим­во­ла? S оз­на­ча­ет, что этот скрипт что-то за­пуска­ет, а 30 за­да­ет его по­ло­жение в по­ряд­ке за­груз­ки. Вы ви­ди­те, что у ка­ж­до­го скрип­та есть но­мер, и они вы­пол­ня­ют­ся в по­ряд­ке воз­рас­тания но­ме­ров. Та­ким об­ра­зом, важ­ные скрип­ты, та­кие как S10rsyslog, вы­пол­ня­ют­ся рань­ше (для вклю­чения жур­на­ли­ро­вания), а бо­лее три­ви­аль­ные воз­мож­но­сти, та­кие как Cron (S89cron), ак­ти­ви­ру­ют­ся бли­же к кон­цу уров­ня вы­полнения.

Вгля­дев­шись в них с по­мо­щью ко­ман­ды ls -l, вы уви­ди­те, что это не фай­лы, а сим­во­ли­че­­ские ссыл­ки на скрип­ты в /etc/init.d – там на­хо­дят­ся на­стоя­щие скрип­ты. Так про­ис­хо­дит по­то­му, что скрип­ты мо­гут раз­де­лять­ся ме­ж­ду уров­ня­ми вы­полнения. На­при­мер, вы мо­же­те за­хо­теть из­менить спо­соб за­пуска Cron, и ва­ши из­менения в фай­ле /etc/init.d/cron рас­про­стра­нят­ся на все уровни вы­полнения, на ко­то­рых он ис­поль­зу­ет­ся. Мо­же­те за­гля­нуть в /etc/init.d и по­смот­реть, что там есть.

Эти скрип­ты – ак­ку­рат­но на­пи­сан­ные оберт­ки про­грамм, по име­нам ко­то­рых они на­зва­ны. На­при­мер, в фай­ле /etc/init.d/gdm со­дер­жит­ся не толь­ко ко­ман­да gdm; там уста­нав­ли­ва­ют­ся необ­хо­ди­мые пе­ре­мен­ные ок­ру­жения, вы­во­дят­ся со­об­щения в лог-фай­лы и т. д. В Debian боль­шин­ст­во из этих скрип­тов мож­но вы­зы­вать с па­ра­мет­ра­ми. Ска­жем, за­пус­тив /etc/init.d/gdm, вы уви­ди­те

Usage: /etc/init.d/gdm {start|stop|restart|reload|forcereload|status}

Та­ким об­ра­зом, ко­ман­дой /etc/init.d/gdm start мож­но за­пустить Gdm, а ко­ман­дой /etc/init.d/gdm stop — оста­но­вить его. Об­ра­ти­те внимание, что restart вы­пол­ня­ет оста­нов­ку и за­пуск, а reload про­сит про­грам­му пе­ре­чи­тать ее файл на­строй­ки без пе­ре­за­пуска, ес­ли это воз­мож­но. Эти­ми скрип­та­ми мож­но сво­бод­но поль­зо­вать­ся и вне сис­те­мы уровней вы­полнения – на­при­мер, для пе­ре­за­пуска Exim или Apache по­сле внесения из­менений в их фай­лы на­строй­ки.

На­конец, от­ме­тим еще кое-что из /etc/inittab, не имею­щее от­но­шения к уров­ням вы­полнения, но тем не менее по­лез­ное. Вы когда-нибудь за­да­ва­лись во­про­сом, от­ку­да во вре­мя за­груз­ки по­яв­ля­ют­ся тек­сто­вые тер­ми­на­лы? Те, на ко­то­рые мож­но пе­ре­клю­чить­ся из X-сер­ве­ра, на­жав Ctrl+Alt+Fx? Они за­да­ют­ся в нижней час­ти фай­ла /etc/inittab в та­ких стро­ках, как эта:

2:23:respawn:/sbin/getty 38400 tty2

Часть /sbin/getty 38400 tty2 — про­сто ко­ман­да, ко­то­рая за­пуска­ет при­гла­шение для вво­да ло­ги­на и па­ро­ля на вто­ром вир­ту­аль­ном тер­ми­на­ле. Ее мож­но за­менить чем угод­но – хоть вы­де­лить от­дель­ный тер­ми­нал под Tetris! А respawn оз­на­ча­ет, что он бу­дет пе­ре­за­пускать­ся ка­ж­дый раз при за­вер­шении ра­бо­ты. С ней за­бав­но по­иг­рать, но будь­те осто­рож­ны – ес­ли нена­ро­ком за­пустить про­грам­му, ко­то­рая пе­ре­хва­тит весь ввод с кла­виа­ту­ры, вы не смо­же­те пе­ре­клю­чить­ся на дру­гой тер­ми­нал, что­бы за­вер­шить ее. Но на­кла­ды­вать в шта­ны еще ра­но – про­сто пе­ре­за­гру­зи­тесь в од­но­поль­зо­ва­тель­ский ре­жим и от­ме­ни­те свои из­ме­не­ния.

Вы­клю­ча­ем сис­те­му безо­пас­но

В на­столь­ных опе­ра­ци­он­ных сис­те­мах вось­ми­де­ся­тых спе­ци­аль­но­го про­цес­са для вы­клю­чения сис­те­мы не бы­ло – по­сле окон­чания ра­бо­ты вы про­сто на­жи­ма­ли кноп­ку вы­клю­чения пи­тания. Тогда это бы­ло нор­маль­но, но на со­вре­мен­ных ком­пь­ю­те­рах мо­жет быть весь­ма рис­ко­ван­ным по двум при­чи­нам. Во-пер­вых, в неко­то­рых опе­ра­ци­он­ных сис­те­мах, вклю­чая Linux, при со­хранении фай­ла дан­ные не за­пи­сы­ва­ют­ся на диск сра­зу. Они ждут, по­ка дру­гие про­цес­сы не за­хо­тят со­хранить дан­ные, по­том эти дан­ные свя­зы­ва­ют­ся вме­сте в од­ну боль­шую опе­ра­цию за­пи­си, что по­мо­га­ет по­вы­сить про­из­во­ди­тель­ность. Впро­чем, Linux мож­но за­ста­вить за­пи­сать на диск все дан­ные, хра­ня­щие­ся в бу­фе­рах опе­ра­тив­ной па­мя­ти, ко­ман­дой sync.

Во-вто­рых, в Linux у скрип­тов за­пуска есть эк­ви­ва­лент­ные скрип­ты оста­но­ва, ко­то­рые га­ран­ти­ру­ют, что про­цес­сы за­вер­ша­ют­ся безо­пас­но, вре­мен­ные фай­лы уда­ля­ют­ся и т. д. Не бой­тесь, ниче­го страш­но­го не слу­чит­ся, ес­ли они не бу­дут за­пу­ще­ны, но они по­мо­га­ют со­хранить сис­те­му в чис­то­те. Боль­шин­ст­во из нас оста­нав­ли­ва­ет сис­те­му с по­мо­щью вид­же­тов на ра­бо­чем сто­ле, но ес­ли вам удобнее де­лать это с команд­ной стро­ки, взгляните на man-страницы команд shutdown, halt и reboot. С ко­ман­дой shutdown, на­при­мер, мож­но за­дать за­держ­ку, но са­мая рас­про­странен­ная ко­ман­да для немед­лен­но­го вы­клю­чения ком­пь­ю­те­ра – shutdown -h now.

Персональные инструменты
купить
подписаться
Яндекс.Метрика