Основы Linux, часть 2

Прежде, чем вы начнете

Об этом руководстве

Добро пожаловать в "Основы администрирования", второе из четырех руководств, предназначенных для подготовки к экзамену LPI-101 (Linux Professional Institute). В этом руководстве мы покажем вам, как использовать регулярные выражения для поиска тектсовых образцов в файлах. Далее, мы введем вас в стандарт иерархии файловой системы (FHS), а затем покажем вам, как определить местоположение файла в вашей системе. Затем мы покажем вам, как получить полный контроль процессов Linux, запуская из в фоновом режиме, получая список процессов, открепляя процессы от терминала и так далее. Потом мы дадим вам ураганное введение к конвейерам оболочки, перенаправлению и командам обработки текста. Наконец, мы представим вам модули ядра Linux.

Это конкретное руководство (часть 2) идеально для тех, кто имеет хорошие знания основ bash и хочет получить прочное представление об основных задачах администрирования Linux. Если вы новичок в Linux, мы рекомендуем вам, прежде чем продолжить, закончить часть 1 этой серии руководсть. Для некоторых большая часть этого материала будет новой, но более опытные пользователи Linux могут найти в этом руководстве хороший способ отшлифовки своего искусства администрирования Linux.

Тем, кто использовал версию 1 этого руководства для целей отличных от подготовки к экзаменам LPI, вероятно нет нужды использовать это руководство. Однако если вы планируете сдавать экзамены, чтение этого пересмотренного руководства настоятельно рекомендуется.

Регулярные выражения

Что такое регулярные выражения?

Регулярное выражение (также может называться "regex" или "regexp") это специальный синтаксис, используемый для описания текстовых образцов. В системе Linux регулярные выражения обычно используются для поиска образцов текста, а также чтобы выполнить операции поиска и замены в текстовом потоке.

Сравнение glob

Если посмотреть на регулярные выражения, то можно обнаружить, что синтаксис регулярных выражений выглядит как синтаксис подстановок имен файлов, с которыми мы познакомились в части 1. Однако не дайте обмануть себя; их похожесть только кажущаяся. И регулярные выражения и образцы подстановки имен, хотя и могут показаться похожими, существенно разные твари.

Простая подстрока

С таким предостережением, давайте посмотрим на самые основные регулярные выражения, простые подстроки. Чтобы сделать это, мы собираемся использовать команду 'grep' , которая просматривает содержимое файла в поиске регулярного выражения. grep выводит каждую строку, которая соответсвует регулярному выражению, и игнорирует каждую строку, которая не соответствует ему:

$ grep bash /etc/passwd
operator:x:11:0:operator:/root:/bin/bash
root:x:0:0::/root:/bin/bash
ftp:x:40:1::/home/ftp:/bin/bash

Здесь первый параметр 'grep' это регулярное выражение; второй -- имя файла. 'grep' читает каждую строку /etc/passwd и применяет к ней регулярное выражение bash (простую подстроку), ища совпадение. Если совпадение найдено, 'grep' выводит всю строку; в противном случае строка игнорируется.

Понимание простой подстроки

В общем, если вы ищете подстроку, вы просто можете указать текст дословно, не используя никаких "специальных" символов. Единственный случай, когда вам понадобится что-то специальное, это если ваша подстрока содержит +, ., *, [, ], или \, в этом случае эти символы нужно заключить в кавычки и предварить обратным слешем. Вот еще несколько примеров регулярных выражение -- простых строк:

  • /tmp (ищет точную строку /tmp)
  • "\[box\]" (ищет точну. строку [box])
  • "\*funny\*" (ищет точную строку *funny*)
  • "ld\.so" (ищет точную строку ld.so)

Метасимволы

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

$ grep dev.hda /etc/fstab
/dev/hda3       /               reiserfs        noatime,ro 1 1
/dev/hda1       /boot           reiserfs        noauto,noatime,notail 1 2
/dev/hda2       swap            swap            sw 0 0
#/dev/hda4      /mnt/extra      reiserfs        noatime,rw 1 1

В этом примере точный текст dev.hda не появляется ни в какой строке /etc/fstab. Однако grep не сканирует его в поиске буквальной строки dev.hda, он ищет образец dev.hda. Вспомним, что . соответствует любому одиночному символу. Как вы можете видеть, метасимвол . функционально эквивалентен метасимволу ? в подстановке имен файлов.

Использование []

Если мы хотим найти соответствие чуть более конкретное, чем ., мы можем использовать [ и ] (квадратные скобки), чтобы задать множество симовлов, которые должны противопоставляться:

$ grep dev.hda[12] /etc/fstab
/dev/hda1       /boot           reiserfs        noauto,noatime,notail 1 2
/dev/hda2       swap            swap            sw 0 0

Как вы можете видеть, эта специальная синтаксическая особенности работает идентично [] в раскрытии имен файлов. Опять же, это одна из хитростей регулярных выражений -- синтаксис похож, но не идентичен синтаксису раскрытия имен файлов, что часто вносит в изучение регулярных выражений небольшую путаницу.

Использование [^]

Вы можете изменить смысл квадратных скобок, поместив ^ сразу после [. В этом случае квадратные скобки будут соответствовать любому символу, который не включен внутри квадратных скобок. Опять же, заметим, что [^] мы используем с регулярным выражением, но с раскрытием имен файлов мы используем [!]:

$ grep dev.hda[^12] /etc/fstab
/dev/hda3       /               reiserfs        noatime,ro 1 1
#/dev/hda4      /mnt/extra      reiserfs        noatime,rw 1 1

Отличающийся синтаксис

Важно отметить, что синтаксис внутри квадратных скобок существенно отличается от синтаксиса в других частях регулярного выражения. Например, если вы в приведенных примерах поместите . внутри квадратных скобок, это сделает возможным соответствие квадратных скобок буквально ., точно так же как 1 и 2 в вышеприведенных примерах. Для сравнения, буквальная . вне квадратных скобок интерпретируется, если ей не предшествует \, как метасимвол. Мы можем воспользоваться этим фактом, чтобы напечатать список всех строк /etc/fstab, которые содержит буквальную строку dev.hda, набрав:

$ grep dev[.]hda /etc/fstab

Другой способ -- мы могли бы также набрать:

$ grep "dev\.hda" /etc/fstab

Ни то, ни другое регулярное выражение вероятно не соответствуют строкам вашего файла /etc/fstab.

Метасимвол "*"

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

  • ab*c соответствует abbbbc, но не abqc (при раскрытии имен файлов он соответствовал бы обеим строка -- можете понять почему?)
  • ab*c соответствует abc, но не abbqbbc (опять же, при раскрытии имен файлов он соответствовал бы обеим строкам)
  • ab*c соответствует ac, но не cba (при раскрытии имен файлов не сопоставился бы ни ac, ни cba)
  • b[cq]*e соответствует bqe and be (при раскрытии имен файлов он соответствовал бы bqe, но не соответствовал бы be)
  • b[cq]*e соответствует bccqqe, но не bccc (при раскрытии имен файлов он соответствовал бы первому, но также не соответствовал бы второму)
  • b[cq]*e соответствует bqqcce, но не cqe (при раскрытии имен файлов он соответствовал бы первому, но также не соответствовал бы второму)
  • b[cq]*e соответствует bbbeee (это не так при раскрытии имен файлов)
  • .* будет соответствовать любой строке (при раскрытии имен файлов он соответствовать любой строке, начинающейся с .)
  • foo.* будет соответствовать любой строке, которая начинается с foo (при раскрытии имен файлов он соответствовал бы любой строке, начинающейся с четырех точных символов foo..)

Теперь для быстрого взбадривающего мозг повторения: строка ac соответствует регулярному выражению ab*c, потому что звездочка позволяет предыдущему выражению (b) появиться нуль раз. Еще раз, необходимо заметить, метасимвол регулярного выражения интерпретируется существенно иначе, чем символ * при раскрытии имен файлов.

Начало и конец строки

Последние метасимволы, которые мы будем здесь детально рассматривать, это метасимволы ^ и $, используемые для соответствия началу и концу строки соответственно. Используя ^ в начале вашего регулярного выражения, вы можете сделать ваш образец, "связанным" с началом строки. В следующем примере мы используем регулярное выражение ^# для сопоставления любой строки, начинающейся с символа #:

$ grep ^# /etc/fstab
# /etc/fstab: статическая информация о файловой системе.
#

Полнострочные регулярные выражения

^ и $ можно комбинировать для сопоставления с целой строкой. Например, следующее регулярное выражение будет соответствовать строке, которая начинается с символа # и оканчивается символом ., с любым числом других символов между ними:

$ grep '^#.*\.$' /etc/fstab
# /etc/fstab: статическая информация о файловой системе.

В этом примере, мы окружили наше регулярное выражение одинарными кавычками, чтобы предотвратить интрепретацию $ оболочкой. Без одинарных кавычек $ исчез бы из нашего регулярного выражения прежде, чем grep имел бы шанс увидеть его.

FHS и поиск файлов

Стандарт иерархии файловой системы

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

  • / (корневая директория)
  • /boot (статические файлы начального загрузчика)
  • /dev (файлы устройств)
  • /etc (конфигурация системы для конкретного хоста)
  • /lib (необходимые разделяемые библиотеки и модули ядра)
  • /mnt (точки монтирования для временного монтирования файловых систем)
  • /opt (добавляемые в программное обеспечение пакеты приложений)
  • /sbin (необходимые системные бинарные файлы
  • /tmp (временные файлы)
  • /usr (вторичная иерархия)
  • /var (переменные данные)

Две независимые категории FHS

FHS основывает свою спецификацию уровней на идее двух независимых категорий файлов: разделяемые--неразделяемые и изменяемые--статические. Разделяемые данные могут распределяться между хостами; неразделяемые данные характерны для данного хоста (такие как конфигурационные файлы). Изменяемые данные можно модифицировать; статические данные не модифицируются (за исключением установки и сопровождения системы).

Следующая сетка приводит четыре возможных комбинации с примерами директорий, которые попадают в эти категории. Еще раз, эта таблица взята прямо из спецификации FHS:

+------------+-----------------+---------------+
|            | разделяемые     | неразделяемые |
+------------+-----------------+---------------+
|статические | /usr            | /etc          |
|            | /opt            | /boot         |
+------------+-----------------+---------------+
|переменные  | /var/mail       | /var/run      |
|            | /var/spool/news | /var/lock     |
+------------+-----------------+---------------+

Вторичная иерархия в /usr

Под /usr вы найдете вторичную иерархию, которая очень похожа на корневую файловую систему. Не критично, существует ли /usr, когда включается машина, следовательно, она может разделяться по сети (разделяемая) или ее можно смонтировать, например с CD-ROM (статическая). Большая часть установок Linux не пользуется разделяемостью /usr, но стоит понять полезность проведения различия между первичной иерархией и корневой директорией и вторичной иерархией в /usr.

Это все, что мы скажем о стандарте иерархии файловой системы. Сам документ хорошо читаем, так что вы можете взять и посмотреть на него. Вы многое поймете о файловой системе Linux, если прочтете его. Ищите его на http://www.pathname.com/fhs/.

Поиск файлов

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

Переменная PATH

Когда вы запускаете программу из командной строки, на самом деле, чтобы найти требуемую вам программу, bash производит поиск по списку директорий. Например, когда вы набираете 'ls' , 'bash' по существу не знает, что программа ls живет в /usr/bin. Поэтому bash обращается к переменной среды с именем PATH, которая представляет собой список директорий, разделенных двоеточием. Мы можем проверить значение PATH:

$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin

С таким значением PATH (ваше может отличаться) bash сначала проверил бы /usr/local/bin, затем /usr/bin на наличие программы 'ls'. Наиболее вероятно, 'ls' содержится в /usr/bin, так что bash на этом остановится.

Изменение PATH

Вы можете добавить в вашу PATH, присвоив ей в командной строке:

$ PATH=$PATH:~/bin
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin:/home/agriffis/bin

Вы можете также удалить элементы из PATH, хотя это не так просто, так как вы не можете обратиться к суцествующей $PATH. Ваш лучший выбор -- просто набрать значение PATH, которое вы хотите:

$ PATH=/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:~/bin
$ echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/X11R6/bin:/home/agriffis/bin

Чтобы сделать изменения вашей переменной PATH доступными любому будущему процессу, который вы запускаете из этой оболочки, экспортируйте ваши изменения с помощью команды export:

$ export PATH

Все о "which"

Вы можете проверить, находится ли данная программа в вашем PATH с помощью 'which' . Например, здесь мы выясняем, что наша система Linux не имеет (общего) sense:

$ which sense
which: no sense in (/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin:/usr/X11R6/bin)

В этом примере мы успешно определяем положение 'ls' :

$ which ls
/usr/bin/ls

"which -a"

Наконец, мы должны знать о флаге '-a' , который заставляет 'which' показать вам все экземпляры заданной программы в вашем PATH:

$ which -a ls
/usr/bin/ls
/bin/ls

whereis

Если вам интересно найти больше информации, а не просто местоположение программы, вы можете попробовать программу 'whereis' :

$ whereis ls
ls: /bin/ls /usr/bin/ls /usr/share/man/man1/ls.1.gz

Мы видим здесь, что 'ls' встречается в двух общих бинарных местах, /bin и /usr/bin. Кроме того, нас информируют, что есть страница руководства man в /usr/share/man. Эту страницу руководства man вы можете увидеть, набрав 'man ls' .

Программа 'whereis' может также искать исходники, указывать альтернативные пути поиска и искать необычные записи. Обращайтесь за дополнительной информацией к странице руководства man по whereis.

find

Команда 'find' -- другое удобное средство для ваших инструментов. С find вы не ограничены программами; вы можете искать любой файл, который захотите, используя множество критериев поиска. Например, чтобы найти файл README, начиная с /usr/share/doc:

$ find /usr/share/doc -name README
/usr/share/doc/ion-20010523/README
/usr/share/doc/bind-9.1.3-r6/dhcp-dynamic-dns-examples/README
/usr/share/doc/sane-1.0.5/README

find и подстановка образцов

Вы можете использовать подстановку образцов в аргументе -name, снабдив образец кавычками или используя обратный слеш (так чтобы он передался find нетронутым, а не был раскрыт оболочкой bash). Например, мы могли бы захотеть найти файлы README с расширениями:

$ find /usr/share/doc -name README\*
/usr/share/doc/iproute2-2.4.7/README.gz
/usr/share/doc/iproute2-2.4.7/README.iproute2+tc.gz
/usr/share/doc/iproute2-2.4.7/README.decnet.gz
/usr/share/doc/iproute2-2.4.7/examples/diffserv/README.gz
/usr/share/doc/pilot-link-0.9.6-r2/README.gz
/usr/share/doc/gnome-pilot-conduits-0.8/README.gz
/usr/share/doc/gimp-1.2.2/README.i18n.gz
/usr/share/doc/gimp-1.2.2/README.win32.gz
/usr/share/doc/gimp-1.2.2/README.gz
/usr/share/doc/gimp-1.2.2/README.perl.gz
[578 строк отрезаны]

Игнорирования регистра в find

Конечно, вы могли бы захотеть игнорировать в вашем поиске регистр:

$ find /usr/share/doc -name '[Rr][Ee][Aa][Dd][Mm][Ee]*'

Или проще:

$ find /usr/share/doc -iname readme\*

Как вы видите, вы можете использовать '-iname' чтобы сделать поиск независимым от регистра.

find и регулярные выражения

Если вы знакомы с регулярными выражениями, вы можете использовать опцию '-regex', чтобы ограничить вывод имен файлов, которые соответствуют образцу. и аналогично опции '-iname', есть соотвествующая опция '-iregex', которая игнорирует в образце регистр. Например:

$ find /etc -iregex '.*xt.*'
/etc/X11/xkb/types/extra
/etc/X11/xkb/semantics/xtest
/etc/X11/xkb/compat/xtest
/etc/X11/app-defaults/XTerm
/etc/X11/app-defaults/XTerm-color

Заметим, что в отличие от многих программ, 'find' требует, чтобы регулярное выражение соответствовало целому пути, а не его части. По этой причине задание лидирующих и хвостовых .* обязательно; использование в качестве регулярного выражения исключительно xt было бы недостаточно.

find и типы

Опция '-type' позволяет вам искать объекты файловой системы определенного типа. Возможные аргументы -type суть 'b' (блоковое устройство), 'c' (символьное устройство), 'd' (директория), 'p' (именованный конвейер), 'f' (регулярный файл), 'l' (символьная ссылкка), и 's' (сокет). Например, чтобы найти в /usr/bin символьную ссылку, которая содержит строку vim:

$ find /usr/bin -name '*vim*' -type l
/usr/bin/rvim
/usr/bin/vimdiff
/usr/bin/gvimdiff

find и mtimes

Опция '-mtime' позволяет вам выбрать файлы, основываясь на времени их последней модфикации. Аргумент -mtime задается в терминах 24-часового периода и наиболее полезен или со знаком плюс (означающим "после") или со знаком минут (означающим "до"). Например, рассмотрим следующий сценарий:

$ ls -l ?
-rw-------    1 root     root            0 Jan  7 18:00 a
-rw-------    1 root     root            0 Jan  6 18:00 b
-rw-------    1 root     root            0 Jan  5 18:00 c
-rw-------    1 root     root            0 Jan  4 18:00 d
$ date
Mon May  7 18:14:52 EST 2003

Вы могли бы искать файлы, которые созданы в последние 24 часа:

$ find . -name \? -mtime -1
./a

Или вы могли бы искать файлы которые созданы до текущего 24-часового периода:

$ find . -name \? -mtime +0
./b
./c
./d

Опция -daystart

Если вы дополнительно укажите опцию '-daystart' , то период времени будет начинаться с начала сегодняшнего дня, а не 24 часа назад. Например, вот множество файлов, созданных вчера и позовчера:

$ find . -name \? -daystart -mtime +0 -mtime -3
./b
./c
$ ls -l b c
-rw-------    1 root     root            0 May  6 18:00 b
-rw-------    1 root     root            0 May  5 18:00 c

Опция -size

Опция '-size' позволяет вам найти файлы, основываясь на их размере. По умолчанию аргумент '-size' 512-байтные блоки, но добавление суффикса может облегчить задачу. Доступные суффиксы 'b' (512-байтные блоки), 'c' (байты), 'k' (килобайты), and 'w' (2-байтные слова). Вдобавок вы можете вставить знак плюс ("больше, чем") или знак минус ("меньше, чем").

Например, чтобы найти в /usr/bin регулярные файлы, меньшие, чем 50 байт:

$ find /usr/bin -type f -size -50c
/usr/bin/krdb
/usr/bin/run-nautilus
/usr/bin/sgmlwhich
/usr/bin/muttbug

Обработка найденных файлов

Вы можете поинтересоваться, что вы можете сделать со всеми этими найденными вами файлами! Ну, 'find' имеет способность обрабатывать эти найденные им файлы с помощью опции '-exec'. Эта опция принимает для исполнения командную строку как свой аргумент, оканчивающияся точкой с запятой ;? и она заменяет каждое вхождение {} именем файла. Это лучше всего понять на примере:

$ find /usr/bin -type f -size -50c -exec ls -l '{}' ';'
-rwxr-xr-x    1 root     root           27 Oct 28 07:13 /usr/bin/krdb
-rwxr-xr-x    1 root     root           35 Nov 28 18:26 /usr/bin/run-nautilus
-rwxr-xr-x    1 root     root           25 Oct 21 17:51 /usr/bin/sgmlwhich
-rwxr-xr-x    1 root     root           26 Sep 26 08:00 /usr/bin/muttbug

Как вы можете видеть, 'find' очень мощная команда. Она росла в течение всех лет разработки UNIX и Linux. Есть много других полезных опций find. Вы можете узнать их на странице руководства man по find.

locate

Мы рассмотрели 'which' , 'whereis' и 'find' . Вы могли бы заметить, что 'find' может занять для выполнения некоторое время, так как ему нужно прочесть каждую директорию, в которой он производит поиск. Оказывается, что команда 'locate' может ускорить все, полагаясь на внешнюю базу данных, сгенерированную 'updatedb' (которая будет рассмотрена ниже).

Команда 'locate' сопоставляет с любой частью имени пути, а не только самим файлом. Например:

$ locate bin/ls
/var/ftp/bin/ls
/bin/ls
/sbin/lsmod
/sbin/lspci
/usr/bin/lsattr
/usr/bin/lspgpot
/usr/sbin/lsof

Использование updatedb

Большинство систем Linux имеют службу "cron" для периодического обновления базы данных. Если ваш 'locate' возвращает ошибку, похожую на приведенную ниже, то, чтобы сгенерировать поисковую базу данных, вы должны запустить 'updatedb' как суперпользователь:

$ locate bin/ls
locate: /var/spool/locate/locatedb: No such file or directory
$ su -
Password:
# updatedb

Команда 'updatedb' может выполняться продолжительное время. Если у вас шумный диск, вы услышите мношо шума, поскольку индексируетсмя вся файловая система. :)

slocate

Во многих дистрибутивах Linux команда 'locate' заменена на 'slocate' . Обычно есть символьная ссылка на 'locate' , так что вам не нужно вспоминать, что у вас есть. 'slocate' означает "безопасный locate". Он сохраняет в базе данных информацию о правах, так что обычные пользователи не могут взломать директории, которые они не имеют право читать. Информация об использовании 'slocate' по сущесву та же, что и для 'locate' , хотя вывод может отличаться, в зависимости от пользователя, запустившего команду.

Управление процессами

Запуск xeyes

Чтобы научиться управлять процессами, нам сначала нужно запустить процесс. Убедитесь, что у вас запущен X и выполните следующую команду:

$ xeyes -center red

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

Остановка процесса

Чтобы вернуть приглашение назад, вы можете нажать Control-C (часто пишут Ctrl-C или ^C):

Вы получите новое приглашение bash, но окно xeyes исчезло. Фактически убит весь процесс. Вместо того, чтобы убить его с помощью Control-C, мы могли бы просто остановить его с помощью Control-Z:

$ xeyes -center red
Control-Z
[1]+  Stopped                 xeyes -center red
$

На этот раз вы получите новое приглашение bash, и окно xeyes останется наверху. Однако если вы немного поиграете с ним, вы заметите, что глаза замерли на месте. Если окно xeyes накроется другим окном, а затем откроется снова, вы увидете, что оно даже не перерисовалось. Процесс не делает ничего. Он на самом деле "Stopped".

fg и bg

Чтобы вывести его из этого состояния, сделать его "un-stopped" и выполнять его снова, мы можем перевести его в режим переднего плана с помощью встроенной команды bash 'fg' :

$ fg
(проверьте это, затем остановите процесс снова)
Control-Z
[1]+  Stopped                 xeyes -center red
$

Теперь продолжите его в фоновом режиме с помощью встроенной команды bash 'bg' :

$ bg
[1]+ xeyes -center red &
$

Замечательно! Процесс xeyes теперь выполняется в фоновом режиме, и мы имеем новую работающую подсказку bash.

Использование "&"

Если мы с самого начала хотим стартовать xeyes в фоновом режиме (вместо Control-Z и bg), мы могли бы просто добавить "&" (амперсенд) к строке с командой xeyes:

$ xeyes -center blue &
[2] 16224

Многочисленные фоновые процессы

Теперь мы имеем и красный и синий xeyes, запущенные в фоновом режиме. Мы можем вывести список этих задания с помощью встроенной функции bash 'jobs' :

$ jobs -l
[1]- 16217 Running                 xeyes -center red &
[2]+ 16224 Running                 xeyes -center blue &

Числа в левой колонке это номера заданий, которые bash присвоил им, когда они запускались. Задание 2 имеет + (плюс), чтобы показать, что это "текущее задание", что означает, что набрав 'fg' мы переведем его в передний план. Вы можете перевести его в передний план, указав конкретное задание по его номеру; например, 'fg 1' сделает красный xeyes заданием переднего плана. Следующая колонка это идентификатор процесс или pid, включенный в листинг благодаря опцие -l. Наконец, оба задания в настоящее время "Running" (выполняются), а их командные строки приводятся справа.

Введение в сигналы

Чтобы убить, остановить или продолжить процессы Linux использует специальную форму коммуникация, которая называется "сигналы". Посылая процессу некоторый сигнал, вы можете заставить его завершиться, остановиться или сделать что-нибудь еще. Именно это вы на самом деле делаете, когда набираете Control-C, Control-Z или используете встроенные команды 'bg' или 'fg' -- вы используете bash, чтобы послать процессу особый сигнал. Эти сигналы можно также послать с помощью команды, 'kill' указав pid (id процесса) в командной строке:

$ kill -s SIGSTOP 16224
$ jobs -l
[1]- 16217 Running                 xeyes -center red &
[2]+ 16224 Stopped (signal)        xeyes -center blue

Как вы можете видеть, kill не обязательно "убивает" процесс, хотя и может. Используя опцию "-s", 'kill' может послать процессу любой сигнал. Linux убивает, останавливает или продолжает процесс, когда он посылает сигнал SIGINT, SIGSTOP или SIGCONT соответственно. Есть также и другие сигналы, которые вы можете послать процессу; интерпретация некоторых из этих сигналов может зависеть от приложения. Вы можете изучить, какие сигналы распознает конкретный процесс, посмотрев его страницу руководства man и найдя секцию SIGNALS.

SIGTERM и SIGINT

Если вы хотите убить процесс, у вас есть несколько возможностей. По умолчанию kill посыает SIGTERM, который не идентичен сигналу SIGINT (Control-C), но как правило имеет тот же результат:

$ kill 16217
$ jobs -l
[1]- 16217 Terminated              xeyes -center red
[2]+ 16224 Stopped (signal)        xeyes -center blue

Большой kill

Процессы могут игнорировать и SIGTERM, и SIGINT, или по выбору, или потому что они каким-то образом "придержаны". В этом случае может быть необходимым использовать большой молоток, сигнал SIGKILL. Процесс не может игнорировать SIGKILL:

$ kill 16224
$ jobs -l
[2]+ 16224 Stopped (signal)        xeyes -center blue
$ kill -s SIGKILL
$ jobs -l
[2]+ 16224 Interrupt               xeyes -center blue

nohup

Терминал, где вы запустили задание, называется управляющим терминалом задания. Некоторые оболочки (не bash по умолчанию), когда вы завершаете сеанс работыпе, редают фоновым заданиям сигнал SIGHUP, заставляя их прекратить работу. Чтобы предохранить процессы от такого поведения, когда вы запускаете процесс, используйте nohup:

$ nohup make &
[1] 15632
$ exit

Использование ps для получения списка процессов

Команда 'jobs', которую мы использовали раньше выводит только список процессов, которые были запущены из сеанса работы вашей оболочки. Чтобы увидеть все процессы вашей системы, используйте 'ps' вместе с опциями 'a' и 'x' :

$ ps ax
  PID TTY      STAT   TIME COMMAND
    1 ?        S      0:04 init [3]
    2 ?        SW     0:11 [keventd]
    3 ?        SWN    0:13 [ksoftirqd_CPU0]
    4 ?        SW     2:33 [kswapd]
    5 ?        SW     0:00 [bdflush]

Я привел лишь несколько первых строк, потому что обычно это очень длинный список. Это дает вам снимок того, что делает вся машина, но есть много информации, которую можно анализировать. Если бы вы опустили опции 'ax' , в увидели бы только процессы, которые принадлежат вам и которые контролируются терминалом. Команда 'ps x' показала бы вам все ваши процессы, даже те, которые терминалом не контролируются. Если бы вы использовали 'ps a' , вы получили бы список процессов всех пользователей, которые присоединены к терминалу.

Осмотр леса и деревьев

Вы можете также вывести список различной информации о каждом процессе. Опция '--forest' облегчает просмотр иерархии процессов, которая укажет, как взаимосвязаны различные процессы вашей системы. Когда процесс запускает новый процесс, этот новый процесс называется процессом-"потомком". В листинге '--forest', родители появляются слева, а дети появляются как ветви справа:

$ ps x --forest
  PID TTY      STAT   TIME COMMAND
  927 pts/1    S      0:00 bash
 6690 pts/1    S      0:00  \_ bash
26909 pts/1    R      0:00      \_ ps x --forest
19930 pts/4    S      0:01 bash
25740 pts/4    S      0:04  \_ vi processes.txt

Опции ps "u" и "l"

Опции 'u' или 'l' можно также добавить к любой комбинации 'a' и 'x', чтобы включить больше информации о каждом процессе:

$ ps au
USER       PID %CPU %MEM   VSZ  RSS TTY      STAT START   TIME COMMAND
agriffis   403  0.0  0.0  2484   72 tty1     S     2001   0:00 -bash
chouser    404  0.0  0.0  2508   92 tty2     S     2001   0:00 -bash
root       408  0.0  0.0  1308  248 tty6     S     2001   0:00 /sbin/agetty 3
agriffis   434  0.0  0.0  1008    4 tty1     S     2001   0:00 /bin/sh /usr/X
chouser    927  0.0  0.0  2540   96 pts/1    S     2001   0:00 bash
$ ps al
  F   UID   PID  PPID PRI  NI   VSZ  RSS WCHAN  STAT TTY        TIME COMMAND
100  1001   403     1   9   0  2484   72 wait4  S    tty1       0:00 -bash
100  1000   404     1   9   0  2508   92 wait4  S    tty2       0:00 -bash
000     0   408     1   9   0  1308  248 read_c S    tty6       0:00 /sbin/ag
000  1001   434   403   9   0  1008    4 wait4  S    tty1       0:00 /bin/sh
000  1000   927   652   9   0  2540   96 wait4  S    pts/1      0:00 bash

Использование top

Если вы обнаружите, что запускаете ps несколько раз в строке, пытаясь отследить, что же изменяется, то вероятно 'top' это то, что вы хотите. 'top' выводит непрерывно обновляющийся листинг процессов вместе с некоторой полезной суммарной информацией:

$ top
 10:02pm  up 19 days,  6:24,  8 users,  load average: 0.04, 0.05, 0.00
75 processes: 74 sleeping, 1 running, 0 zombie, 0 stopped
CPU states:  1.3% user,  2.5% system,  0.0% nice, 96.0% idle
Mem:   256020K av,  226580K used,   29440K free,       0K shrd,    3804K buff
Swap:  136544K av,   80256K used,   56288K free                  101760K cached

  PID USER     PRI  NI  SIZE  RSS SHARE STAT  LIB %CPU %MEM   TIME COMMAND
  628 root      16   0  213M  31M  2304 S       0  1.9 12.5  91:43 X
26934 chouser   17   0  1272 1272  1076 R       0  1.1  0.4   0:00 top
  652 chouser   11   0 12016 8840  1604 S       0  0.5  3.4   3:52 gnome-termin
  641 chouser    9   0  2936 2808  1416 S       0  0.1  1.0   2:13 sawfish

nice

Каждый процесс имеет установку приоритета, которую Linux использует для определения, как распределять временные доли CPU. Вы можете установить приоритет процесса, запустив его командой 'nice' :

$ nice -n 10 oggenc /tmp/song.wav

Так как установка приоритета называется 'nice' , то легко запомнить, что высокий приоритет будет приятен другим процессам, позволяя им получить приоритетный доступ к CPU. По умолчанию, процессы запускаются с установкой 0, так что установка 10 означает, что oggenc охотно уступает CPU другим процессам. Вообще, это означает, что oggenc будет позволять другим процессам выполняться с их нормальной скоростью, несмотря на то насколько жадным к CPU окажется oggenc. Вы можете увидеть эти уровни приятности в колонке NI приведенных листингов ps и top.

renice

Команда 'nice' млэеь изменить приоритет процесса, только когда вы запускаете его. Если вы хотите изменить установки приятности выполняющегося процесса, используйте 'renice' :

$ ps l 641
  F   UID   PID  PPID PRI  NI   VSZ  RSS WCHAN  STAT TTY        TIME COMMAND
000  1000   641     1   9   0  5876 2808 do_sel S    ?          2:14 sawfish
$ renice 10 641
641: old priority 0, new priority 10
$ ps l 641
  F   UID   PID  PPID PRI  NI   VSZ  RSS WCHAN  STAT TTY        TIME COMMAND
000  1000   641     1   9  10  5876 2808 do_sel S    ?          2:14 sawfish

Обработка текста

Еще раз о перенаправлении

Ранее, в этой серии руководств мы видели пример того, как использовать оператор '>' для перенаправления вывода команды в файл, вот такой:

$ echo "firstfile" > copyme

Вдобавок к перенаправлению вывода в файл, мы можем также воспользоваться мощным свойством оболочки, которое называется конвейером. С помощью конвейеров мы можем передать вывод одной команды на ввод другой. Рассмотрим следующий пример:

$ echo "hi there" | wc
      1       2       9

Символ '|' используется для связи вывода команды слева с вводом команды справа. В этом примере команда 'echo' ввыводит строку "hi there", за которой следует перевод строки. Вывод обычно появился бы на терминале, но конвейер перенаправляет его команде 'wc' , которая выводит число строк, слов и символов в своем вводе.

Пример конвейера

Вот другой простой пример:

$ ls -s | sort -n

В этом случае 'ls -s' обычно вывела бы листинг текущей директории на терминал, с размером файла перед его именем. Но вместо этого мы организуем конвейер и передаем вывод команде 'sort -n' , которая сортирует его численно. Это действительно полезный способ найти большие файлы в вашей домашней директории!

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

Распаковка с конвейером

Обычно, чтобы распаковать и разархивировать файл, вы можете сделать следующее:

$ bzip2 -d linux-2.4.16.tar.bz2
$ tar xvf linux-2.4.16.tar

Оборотная сторона этого метода состоит в том, что он требует создания на вашем диске промежуточного распакованного файла. Так как 'tar' имеет способность читать прямо из своего ввода (вместо указания файла), мы могли бы получить тот же конечные результат с помощью конвейера:

$ bzip2 -dc linux-2.4.16.tar.bz2 | tar xvf -

Получилось! Наш сжатый архив tar разархивирован и нам не потребовался промежуточный файл.

Длинный конвейер

Вот другой пример конвейера:

$ cat myfile.txt | sort | uniq | wc -l

Мы используем 'cat' чтобы скормить содержимое myfile.txt команде 'sort' . Когда команда 'sort' получает ввод, она сортирует все входные строки так, что они располагаются в алфавитном порядке, а затем посылает вывод команде 'uniq' . 'uniq' удаляет все двойные строки (и, между прочим, требует, чтобы ее вход был отсортирован), посылая очищенный вывод команде 'wc -l' . Мы встречали команду 'wc' раньше, но без опций командной строки. Если задать опцию '-l' , она выведет число строк в своем входном потоке, не включая числа слов и числа символов. Вы увидите, что этот конвейер напечатает число уникальных (не идентичных) строк текстового файла.

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

Лавина обработки текстов начинается

Теперь мы вступаем в лавинообразный тур стандартных команд Linux для обработки текста. Поскольку мы в этом руководстве рассматриваем много материала, нам не хватает места для примеров каждой команды. Вместо этого, мы подстрекаем вас прочитать страницу руководства man каждой команды (набрав 'man echo' , например) и узнать, как работает каждая команда и ее опции, и провести некоторое время, играясь с каждой командой. Как правило, эти команды выводят результаты какой-то обработки текста на терминал, а не изменяют указанные файлы. После нашего лавинного тура стандартных команд Linux для обработки текста, мы более пристально посмотрим на перенаправление вывода и ввода. Да, все же есть свет в конце туннеля :)

'echo' выводит свои аргументы на терминал. Используйте опцию '-e' если вы хотите вставить последовательности с бекслешем; например 'echo -e "foo\nfoo"' напечатает foo, затем выведет новую строку, а затем снова foo. Используйте опцию '-n' чтобы приказать echo опустить завершающий символ новой строки, который по умолчанию довавляется в вывод.

'cat' выведет содержимое файлов, указанных как аргументы, на терминал. Удобна в качестве первой команды конвейера, например, 'cat foo.txt | blah' .

'sort' выведет содержимое файла, указанного в командной строке в алфавитном порядке. Конечно, 'sort' также принимает ввод с конвейера. Наберите 'man sort', чтобы ознакомиться с ее различными опциями, которые управляют режимом сортировки.

'uniq' берет уже отсортированный файл или поток данных (через конвейер) и удаляет дублируемые строки.

'wc' выводит число строк, слов и байт в указанном файле или входном потоке (из конвейера). Наберите 'man wc', чтобы узнать, как можно определить, какие счетчики будут выводиться.

'head' выводит первые десять строк файла или потока. Используйте опцию '-n', чтобы указать, сколько строк нужно вывести.

'tail' выводит последние десять строк файла или потока. Используйте опцию '-n' чтобы указать, сколько строк нужно вывести.

'tac' подобна 'cat' , но выводит все строки в обратном порядке; другими словами, последняя строка выводится первой.

'expand' преобразует входные символы табуляции в пробелы. Используйте опцию '-t', чтобы указать положение табуляции.

'unexpand' преобразует входные пробелы в табуляцию. Используйте опцию '-t', чтобы указать положение табуляции.

'cut' используется, чтобы удалить поля, разделенные символами-разделителями, из каждой строки входного файла или потока.

The 'nl' команда добавляет номер строки к каждой строке входа. Полезна для печати.

'pr' используется, чтобы разбить файлы на несколько страниц вывода; обычно используется для печати.

'tr' средство преобразования символов; используется, чтобы отобразить некоторые символы входного потока в некоторые другие символы выходного потока.

'sed' мощные потоковый редактор текста. Вы можете узнать о sed больше в следующих статьях Funtoo:

Если вы планируете сдавать экзамен LPI, непременно прочитайте первые две статьи этой серии.

'awk' удобный строковый язык обработки текста. Чтобы узнать об awk больше, прочитайте следующие статьи Funtoo:

'od' предназначен для преобразования входного потока в восьмеричный или шестнадцатеричный формат (для "дампа").

'split' команда, которая используется для разбивки большого файла на много более управляемых кусков меньшего размера.

'fmt' переформатирует параграфы так, чтобы укладывались в поля. В наши дни она не так полезна, поскольку эта способность встроена в большинство текстовых редакторов, но всеже хорошо о ней знать.

'paste' берет два или более файла на входе, соединяет каждую последовательную строку из входных файлов и выводит строки результата. Может быть полезной для создания таблиц или колонок текста.

'join' аналогична paste, но использует поле (по умолчанию первое) в каждой входной строке для определения, что же должно быть скомпановано в одну строку.

'tee' печатает свой ввод и в файл, и на экран. Это полезно, если вы хотите создать протокол чего-нибудь, но вы также хотите и видеть его на экране.

Лавина закончилась! Перенаправление

Аналогично '>' вы можете также использовать в командной строке '<' , чтобы перенаправить файл в команду. Для многих команд вы можете просто указать имя файла в командной строке, однако некоторые команды работают только со стандартным входом.

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

$ sort <<END
яблоко
клюква
банан
END
банан
клюква
яблоко

В этом примере мы набрали слова яблоко, клюква и банан, за которыми следовал "END", чтобы обозначить конец ввода. Затем программа 'sort' вернула наши слова в алфавитном порядке.

Использование >>

Вы ожидали, что '>>' это что-то аналогичное '<<' , но в действительности нет. Это просто означает добавить вывод в файл, а не переписать, как сделал бы '>' . Например:

$ echo Привет > myfile
$ echo всем. > myfile
$ cat myfile
всем.

Ооо! Мы потеряли "Привет"! Вот то, что мы подразумевали:

$ echo Привет > myfile
$ echo всем. >> myfile
$ cat myfile
Привет
всем.

Много лучше!

Модули ядра

Встречайте, "uname"

The 'uname' command provides a variety of interesting information about your system. Here's what is displayed on my development workstation when I type 'uname -a' which tells the 'uname' command to print out all of its information in one swoop:

$ uname -a
Linux inventor 2.4.20-gaming-r1 #1 Fri Apr 11 18:33:35 MDT 2003 i686 AMD Athlon(tm) XP 2100+ AuthenticAMD GNU/Linux

More uname madness

Now, let's look at the information that 'uname' provides

info. option                    arg     example
kernel name                     -s      "Linux"
hostname                        -n      "inventor"
kernel release                  -r      "2.4.20-gaming-r1"
kernel version                  -v      "#1 Fri Apr 11 18:33:35 MDT 2003"
machine                         -m      "i686"
processor                       -p      "AMD Athlon(tm) XP 2100+"
hardware platform               -i      "AuthenticAMD"
operating system                -o      "GNU/Linux"

Intriguing! What does your 'uname -a' command print out?

The kernel release

Here's a magic trick. First, type 'uname -r' to have the uname command print out the release of the Linux kernel that's currently running.

Now, look in the /lib/modules directory and --presto!-- I bet you'll find a directory with that exact name! OK, not quite magic, but now may be a good time to talk about the significance of the directories in /lib/modules and explain what kernel modules are.

The kernel

The Linux kernel is the heart of what is commonly referred to as "Linux" -- it's the piece of code that accesses your hardware directly and provides abstractions so that regular old programs can run. Thanks to the kernel, your text editor doesn't need to worry about whether it is writing to a SCSI or IDE disk -- or even a RAM disk. It just writes to a filesystem, and the kernel takes care of the rest.

Introducing kernel modules

So, what are kernel modules? Well, they're parts of the kernel that have been stored in a special format on disk. At your command, they can be loaded into the running kernel and provide additional functionality.

Because the kernel modules are loaded on demand, you can have your kernel support a lot of additional functionality that you may not ordinarily want to be enabled. But once in a blue moon, those kernel modules are likely to come in quite handy and can be loaded -- often automatically -- to support that odd filesystem or hardware device that you rarely use.

Kernel modules in a nutshell

In sum, kernel modules allow for the running kernel to enable capabilities on an on-demand basis. Without kernel modules, you'd have to compile a completely new kernel and reboot in order for it to support something new.

lsmod

To see what modules are currently loaded on your system, use the 'lsmod' command:

# lsmod
Module                  Size  Used by    Tainted: PF
vmnet                  20520   5
vmmon                  22484  11
nvidia               1547648  10
mousedev                3860   2
hid                    16772   0  (unused)
usbmouse                1848   0  (unused)
input                   3136   0  [mousedev hid usbmouse]
usb-ohci               15976   0  (unused)
ehci-hcd               13288   0  (unused)
emu10k1                64264   2
ac97_codec              9000   0  [emu10k1]
sound                  51508   0  [emu10k1]
usbcore                55168   1  [hid usbmouse usb-ohci ehci-hcd]

Modules listing

As you can see, my system has quite a few modules loaded. the vmnet and vmmon modules provide necessary functionality for VMWare Workstation, which allows me to run a virtual PC in a window on my desktop. The "nvidia" module comes from NVIDIA corporation and allows me to use my high-performance 3D-accelerated graphics card under Linux whilst taking advantage of its many neat features.

Then I have a bunch of modules that are used to provide support for my USB-based input devices -- namely "mousedev," "hid," "usbmouse," "input," "usb-ohci," "ehci-hcd" and "usbcore." It often makes sense to configure your kernel to provide USB support as modules. Why? Because USB devices are "plug and play," and when you have your USB support in modules, then you can go out and buy a new USB device, plug it in to your system, and have the system automatically load the appropriate modules to enable that device. It's a handy way to do things.

Third-party modules

Rounding out my list of modules are "emu10k1," "ac97_codec," and "sound," which together provide support for my SoundBlaster Audigy sound card.

It should be noted that some of my kernel modules come from the kernel sources themselves. For example, all the USB-related modules are compiled from the standard Linux kernel sources. However, the nvidia, emu10k1 and VMWare-related modules come from other sources. This highlights another major benefit of kernel modules -- allowing third parties to provide much-needed kernel functionality and allowing this functionality to "plug in" to a running Linux kernel. No reboot necessary.

depmod and friends

In my /lib/modules/2.4.20-gaming-r1/ directory, I have a number of files that start with the string "modules.":

$ ls /lib/modules/2.4.20-gaming-r1/modules.*
/lib/modules/2.4.20-gaming-r1/modules.dep
/lib/modules/2.4.20-gaming-r1/modules.generic_string
/lib/modules/2.4.20-gaming-r1/modules.ieee1394map
/lib/modules/2.4.20-gaming-r1/modules.isapnpmap
/lib/modules/2.4.20-gaming-r1/modules.parportmap
/lib/modules/2.4.20-gaming-r1/modules.pcimap
/lib/modules/2.4.20-gaming-r1/modules.pnpbiosmap
/lib/modules/2.4.20-gaming-r1/modules.usbmap

These files contain some lots of dependency information. For one, they record *dependency* information for modules -- some modules require other modules to be loaded first before they will run. This information is recorded in these files.

How you get modules

Some kernel modules are designed to work with specific hardware devices, like my "emu10k1" module which is for my SoundBlaster Audigy card. For these types of modules, these files also record the PCI IDs and similar identifying marks of the hardware devices that they support. This information can be used by things like the "hotplug" scripts (which we'll take a look at in later tutorials) to auto-detect hardware and load the appropriate module to support said hardware automatically.

Using depmod

If you ever install a new module, this dependency information may become out of date. To make it fresh again, simply type 'depmod -a' . The 'depmod' program will then scan all the modules in your directories in /lib/modules and freshening the dependency information. It does this by scanning the module files in /lib/modules and looking at what are called "symbols" inside the modules.

Locating kernel modules

So, what do kernel modules look like? For 2.4 kernels, they're typically any file in the /lib/modules tree that ends in ".o". To see all the modules in /lib/modules, type the following:

# find /lib/modules -name '*.o'
/lib/modules/2.4.20-gaming-r1/misc/vmmon.o
/lib/modules/2.4.20-gaming-r1/misc/vmnet.o
/lib/modules/2.4.20-gaming-r1/video/nvidia.o
/lib/modules/2.4.20-gaming-r1/kernel/fs/fat/fat.o
/lib/modules/2.4.20-gaming-r1/kernel/fs/vfat/vfat.o
/lib/modules/2.4.20-gaming-r1/kernel/fs/minix/minix.o
[listing "snipped" for brevity]

insmod vs. modprobe

So, how does one load a module into a running kernel? One way is to use the 'insmod' command and specifying the full path to the module that you wish to load:

# insmod /lib/modules/2.4.20-gaming-r1/kernel/fs/fat/fat.o
# lsmod | grep fat
fat                    29272   0  (unused)

However, one normally loads modules by using the 'modprobe' command. One of the nice things about the 'modprobe' command is that it automatically takes care of loading any dependent modules. Also, one doesn't need to specify the path to the module you wish to load, nor does one specify the trailing ".o".

rmmod and modprobe in action

Let's unload our "fat.o" module and load it using 'modprobe' :

# rmmod fat
# lsmod | grep fat
# modprobe fat
# lsmod | grep fat
fat                    29272   0  (unused)

As you can see, the 'rmmod' command works similarly to modprobe, but has the opposite effect -- it unloads the module you specify.

Your friend modinfo and modules.conf

You can use the 'modinfo' command to learn interesting things about your favorite modules:

# modinfo fat
filename:    /lib/modules/2.4.20-gaming-r1/kernel/fs/fat/fat.o
description: <none>
author:      <none>
license:     "GPL"

And make special note of the /etc/modules.conf file. This file contains configuration information for 'modprobe' . It allows you to tweak the functionality of 'modprobe' by telling it to load modules before/after loading others, run scripts before/after modules load, and more.

modules.conf gotchas

The syntax and functionality of modules.conf is quite complicated, and we won't go into its syntax now (type 'man modules.conf' for all the gory details), but here are some things that you *should* know about this file.

For one, many distributions generate this file automatically from a bunch of files in another directory, like /etc/modules.d/. For example, Gentoo Linux has an /etc/modules.d/ directory, and running the 'update-modules' command will take every file in /etc/modules.d/ and concatenate them to produce a new /etc/modules.conf. Therefore, make your changes to the files in /etc/modules.d/ and run update-modules if you are using Gentoo. If you are using Debian, the procedure is similar except that the directory is called /etc/modutils/.

Summary and Resources

Summary

Congratulations; you've reached the end of this tutorial on basic Linux administration! We hope that it has helped you to firm up your foundational Linux knowledge. Please join us in our next tutorial covering intermediate administration, where we will build on the foundation laid here, covering topics like the Linux permissions and ownership model, user account management, filesystem creation and mounting, and more. And remember, by continuing in this tutorial series, you'll soon be ready to attain your LPIC Level 1 Certification from the Linux Professional Institute.

Resources

Speaking of LPIC certification, if this is something you're interested in, then we recommend that you study the following resources, which have been carefully selected to augment the material covered in this tutorial:

There are a number of good regular expression resources on the 'net. Here are a couple that we've found:

Be sure to read up on the Filesystem Hierarchy Standard at http://www.pathname.com/fhs/.

In the Bash by Example article series, I show you how to use bash programming constructs to write your own bash scripts. This series (particularly parts one and two) will be good preparation for the LPIC Level 1 exam:

You can learn more about 'sed' in the Sed by Example article series. If you're planning to take the LPI exam, be sure to read the first two articles of this series.

To learn more about 'awk' , read the Awk by Example article series.

If you're not too familiar with the 'vi' editor, I strongly recommend that you check out my Vi -- the cheat sheet method tutorial. This tutorial will give you a gentle yet fast-paced introduction to this powerful text editor. Consider this must-read material if you don't know how to use 'vi' .


Daniel Robbins

silly photo
This is not really me

Daniel Robbins is the founder of the Gentoo community and creator of the Gentoo Linux operating system. Daniel resides in New Mexico with his wife Mary and two energetic daughters, and is founder and lead of Funtoo. Daniel has also written many technical articles for IBM developerWorks, Intel Developer Services and C/C++ Users Journal.

Chris Houser

Chris Houser has been a UNIX proponent since 1994 when he joined the administration team for the computer science network at Taylor University in Indiana, where he earned his Bachelor's degree in Computer Science and Mathematics. Since then, he has worked on software in a variety of fields including web applications, video editing, UNIX device drivers, and defense, and is currently employed at Sentry Data Systems. He has also contributed to various free software projects such as Gentoo Linux and Clojure. He has most recently co-authored "The Joy of Clojure," available at http://joyofclojure.com.

Aron Griffis

Aron Griffis lives in the Boston area, where he's spent the past decade working for Hewlett-Packard on projects such as Tru64 UNIX network drivers, Linux security certification, Xen and KVM virtualization, and most recently HP's ePrint platform. When he's not actively hacking, Aron mulls over programming problems while riding his bicycle, juggling clubs, or cheering for the Red Sox.