Основные команды консоли восстановления Windows

В один прекрасный день компьютер отказывается загружать систему …

В один прекрасный день компьютер отказывается загружать систему и выводит на экран тарабарщину на голубом фоне. Неизвестно откуда появляется сообщение о том, что система не может быть запущена, так как потерян или испорчен какой-то файл. Прежде всего вы пытаетесь перезагрузиться, однако этот способ не всегда срабатывает. В такой ситуации восстановить работоспособность системы можно с помощью нового инструмента, входящего в состав Windows 2000 Professional — Консоли восстановления (Recovery Console — RC).

Установка консоли восстановления

Для начала нужно запустить RC с установочного CD-ROM Windows 2000 Pro (в том случае, конечно, если система поддерживает загрузку с CD-ROM) или с установочных дискет. Можно установить RC как один из вариантов загрузки. Установив компакт-диск, выбираем меню Start, затем Run и вводим в командную строку:

{x}:\i386\winnt32 /cmdcons

где вместо х подставляется буква устройства чтения компакт-дисков. После запуска появится диалоговое окно с вопросом о том, нужно ли устанавливать RC. Выбираем Yes. Для установки консоли понадобится до 7Mбайт дискового пространства. По завершении установки система предложит перезагрузиться. После этого новая опция загрузки — <Консоль восстановления> — к вашим услугам.

Для запуска RC с установочных дискет или напрямую с CD-ROM придется загружать систему именно с них. В текстовой части программы установки Windows 2000 Pro появляется возможность выбора между инсталляцией системы (нажав Enter) или ее восстановлением (нажав R). Выбираем вариант восстановления. Далее программа установки предлагает выбрать режим восстановления с помощью консоли восстановления (нажав С) или диска аварийного восстановления emergency repair disk (снова нажав R).

Если система отказывается загружаться, я рекомендую выбирать R, т.е. восстановление с помощью диска аварийного восстановления, даже если самого диска нет. В этом случае автоматически проверяется наличие и целостность всех важнейших системных файлов. Я использовал эту опцию для восстановления Windows 2000 после того, как привел ее в нерабочее состояние установкой Windows NT 4.0. Если этот метод не работает, придется перезагрузиться и запустить RC.

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

Вне зависимости от того, как запускается RC — с CD-ROM, установочных дисков или из загрузчика — после запуска придется зарегистрироваться. В системах с двойной загрузкой нужно будет выбрать, в какой из установок это сделать (например, C:\winnt, D:\winnt), и ввести пароль администратора. После регистрации появится приглашение на ввод команд. По команде help выдается перечень всех команд, доступных в консоли восстановления. Большинство из них знакомы пользователям командной строки Windows 2000 Pro и DOS, однако информацию по каждой конкретной команде можно получить , набрав

help <command>

В этом примере приведена строка для выдачи информации о команде attrib и результат ее исполнения:

C:\WINNT>help attrib

Команда показывает или изменяет атрибуты файлов:

+ — Назначить атрибут.
— Снять атрибут.
R — Атрибут файла только для чтения.
S — Атрибут системного файла.
H — Атрибут скрытого файла.
C — Атрибут сжатого файла.

Приведенный результат практически полностью совпадает с результатом выполнения команды

help attrib

из командной строки Windows 2000 Pro. В RC, однако, отсутствует возможность установки или снятия атрибута архивного файла, вместо нее предоставляется возможность работы с атрибутом сжатия. В RC также отсутствуют переключатели /S и /D, изменяющие атрибуты подкаталогов и папок. Большинство команд RC предоставляют сокращенные возможности по сравнению с их вариантами в Windows 2000 Pro. Некоторые команды, однако, существуют только в RC.

Batch. Команда запуска на исполнение файла пакетной обработки. Определены два аргумента: имя запускаемого пакетного файла и файла, в который система перенаправляет выходные данные.

Disable. Команда позволяет предотвратить запуск служб и драйверов при загрузке системы. Она используется в том случае, если на стадии начальной загрузки системы происходит сбой в инициализации службы или драйвера устройства. В команде Disable используется один аргумент — наименование службы, запуск которой мы хотим предотвратить (получить список наименований можно с помощью команды Listsvc). Перед тем как пометить службу флажком запрета на исполнение, команда распечатает флаг запуска службы. Например, команда

disable cdrom

сообщает, что прежний флаг запуска был SERVICE_SYSTEM_START. Это значение нужно запомнить, оно потребуется для возобновления работы службы командой Enable после завершения процедуры восстановления.

Diskpart. С помощью этой команды можно разбить жесткий диск на разделы. Все параметры ей можно передавать из командной строки (введите help diskpart для получения списка аргументов команды). Однако проще работать с ней в диалоговом режиме

diskpart

На текстовом экране появится список разделов жесткого диска. Cтрелками вверх и вниз выбираем необходимый раздел или свободное пространство. После выбора раздела клавишей D удаляем его. Для создания нового раздела в свободном пространстве нажимаем клавишу С.

Система попросит задать размер нового раздела. Завершив все настройки, нажимаем Esc для возврата в RC. Не забудьте отформатировать вновь созданные разделы командой Format.

Enable. Команда разрешает запуск при загрузке системы ранее отключенных служб и драйверов. Она использует два аргумента — наименование службы и ее флаг запуска (если не указать флаг запуска, команда Enable выведет перечень допустимых флагов). Например

enable cdrom SERVICE_SYSTEM_START

разрешает запуск службы cdrom и устанавливает флаг ее запуска при загрузке системы.

Exit. Команда завершает работу RC и перезагружает компьютер.

Expand. Команда распаковывает архивные файлы (.cab), используемые программой установки Windows 2000 Pro. В консоли восстановления она работает так же, как и ее аналог в Windows 2000 Pro, однако использует слегка измененные аргументы. Команда help expand даст их подробное описание.

Fixboot. Команда позволит восстановить систему в случае небрежной установки NT или инсталляции Windows 9x поверх установленной Windows 2000 Pro — в такой ситуации загрузить Windows 2000 Pro обычно не удается. Команда Fixboot перезаписывает загрузочный сектор жесткого диска, что делает диск загружаемым. Понимает единственный аргумент — букву устройства, на которое производится запись. Например

fixboot c:

произведет запись нового загрузочного сектора на диск С.

Fixmbr. С помощью этой команды можно попытаться восстановить главную загрузочную запись (Master Boot Record) загрузочного раздела. С ее помощью можно попытаться заставить систему загружаться в тех случаях, когда она отказывается это делать. У нее определен только один аргумент — имя устройства, на которое устанавливается новая MBR. Если имя в команде не указано, Fixmbr запишет новую MBR в устройство по умолчанию (обычно диск С).

Format. Команда позволяет переформатировать дефектный диск или заново отформатировать раздел, созданный командой Diskpart. Ее аргументами могут быть только: буква устройства, /Q (quick format) — параметр быстрого форматирования и /FS:(file system) — тип файловой системы, с указанием одного из параметров FAT, FAT32, или NTFS. Например команда

format g: /Q /FS:FAT32

применит быстрое форматирование к устройству G и создаст на нем файловую систему FAT32. Если при запуске команды тип файловой системы не указан, по умолчанию задается NTFS, используемая только системами Windows 2000. Это может вызвать проблемы при настройке окружения на работу двух операционных систем одновременно. (Прим. переводчика: установка Windows NT 4.0 с сервисным пакетом SP4 позволяет NT работать с NTFS 5.0, созданной Windows 2000).

Listsvc. Команда выводит на экран перечень всех используемых в системе служб и драйверов с указанием их флагов запуска. Если система не может загрузиться из-за проблем с каким-либо драйвером, Listsvc может помочь. Выпишите наименования всех служб, появившихся на «голубом экране смерти» и загрузите RC. Запустив Listsvc, найдите в выданном ею списке выписанные службы. Командой Disable отключите подозрительные драйверы и покиньте RC. Если система после этого не запустится, загружайте RC и пробуйте снова.

Logon. При использовании нескольких вариантов загрузки эта команда позволит подключаться к различным разделам. Команда выводит список разделов, позволяет выбрать нужный и запрашивает пароль администратора (процедура аналогична той, которая возникает при запуске RC).

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

C: FAT162047MB
\Device\Harddisk0\Partition1

Аргументом этой команды может быть arc. В этом случае команда покажет разметку физического устройства в формате Advanced RISC Computing (ARC). Именно в таком виде эта информация обычно представлена в файле boot.ini.

Systemroot. Команда делает текущим корневой системный каталог Windows 2000 Pro (обычно C:\winnt).

Команды консоли восстановления могут помочь «оживить» систему. Когда исчерпаны все средства, RC подскажет верное решение.

Основы модуля mod_rewrite Apache

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

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

Однако нужно быть очень осторожным и даже дотошным при работе с этим модулем! Некоторые ошибки, которые Вы способны допустить, могут привести к логической петле, причиняя непрекращающуюся 100%-ую загрузку ценрального процессора (CPU).

Чтобы не казаться пространным в рассуждениях, приведу некоторые очень простые примеры.

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

Есть несколько способов проверить это:

  1. Спросить вашего системного администратора — знает ли он (или она) о наличии этого модуля на веб сервере. Они действительно должны знать, но как показывает практика — попадаются и не очень сведующие сисадмины. Не напрягайте других: если Вы используете ваш веб сервер с сотнями других доменов, ваши действия могут разбудить некоторых спящих
    собак, поскольку использование mod_rewrite будет всегда влечь за собой некоторую увеличенную загрузку ценрального процессора.
  2. Проверить ваш файл конфигурации Apache (httpd.conf), если вы имеете к нему доступ. Один из возможных стандартных путей может быть: /etc/httpd/httpd.conf. Однако, ваш путь может очевидно отличаться от этого.
  3. Проверить работу вашего сервера с нижеприведенными примерами. Если
    сервер работает без ошибок — mod_rewrite действительно установлен на вашей системе. Если нет, Вы получите следующее сообщение при запросе любой web-страницы с вашего сервера: «Внутренняя ошибка сервера». Также, вы увидите такую запись в файле «error.log»:
    «Invalid command RewriteEngine, perhaps mis-spelled or defined by a module not included in the server configuration».

Теперь давайте копнем поглубже и посмотрим первый практический примерчик.

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

Для нашего примера потребуется использование файла .htaccess. Для работы этого метода, вы должны загрузить файл под названием «.htaccess» (пожалуйста, обратите внимание на точку в начале имени файла!) в папку сервера, с которой Вы будете работать. Это можно сделать через telnet или ftp. (Предупреждение: .htaccess должен быть загружен в ‘режиме ASCII’, то есть не в двоичном режиме!)

Если у Вас уже имеется файл «.htaccess», например со следующими записями:

Options Includes +ExecCGI
AddType text/x-server-parsed-html .html

то просто добавьте снизу наш образец кода к уже существующему (важно: редактируйте ваш файл .htaccess в ASCII-редакторе типа Notepad).

Первые две записи запустят сам модуль:

RewriteEngine on
Options +FollowSymlinks

Совет: запись «RewriteEngine off» отменит все последующие команды. Это
очень полезная особенность — вместо необходимости комментировать все
последующие строки — все, что Вы должны сделать, это установить «off».

Если ваш системный администратор запрещает Вам использование «Options
+FollowSymlinks», Вы не сможете ограничить использование mod_rewrite
для отдельных каталогов, вместо этого изменения будут действовать на
весь сервер.

Следующая необходимая запись:

RewriteBase /

«/» является корневым (основным) URL. Если у вас какой-то другой URL, то вы можете указать это в данной директиве, однако «/» — обычно эквивалентно адресу «http://домен.ru».

А теперь, господа, перейдем к более интересным записям!

Предположим, что вы хотите защитить от несанкционированного доступа
ваш файл .htaccess. На некоторых серверах вы можете легко читать этот
файл просто вводя URL следующего формата в поле адреса вашего
браузера: http://www.domain.com/.htaccess — серьезное упущение защиты,
так как содержание вашего .htaccess может показать важную информацию
об установках и настройках вашего сайта человеку, знающему как эти
знания применить против вас.

Чтобы блокировать этот доступ, запишем следующее:

RewriteRule ^.htaccess$ - [F]

Это правило переводится так:

Если кто-то пробует обращаться к файлу .htaccess, система должна выдать код ошибки «HTTP response of 403» или «403 Forbidden — You don’t have permission to access /.htaccess on this server».

Конструкция ^.htaccess$ в этом регулярном выражении означает:

  • ^ — якорь начала строки;
  • $ — якорь конца строки;
  • . — в регулярных выражениях точка «.» обозначает мета-символ и должна быть защищена обратным слэшем (backslash), если вы все-таки хотите использовать именно фактическую точку.
  • Имя файла должно быть расположено точно между начальным и конечным якорем. Это будет гарантировать то, что только это определенное имя файла и никакое другое, сгенерирует код ошибки.
  • [F] — специальный «запрещающий» флажок (forbidden).

В этом примере, файл «.htaccess» теперь будет состоять из таких строк:

RewriteEngine on
Options +FollowSymlinks
RewriteBase /
RewriteRule ^.htaccess$ - [F]

Если мы добавим наш код (в примерах) к существовавшему ранее файлу «.htaccess», то получим следующую конструкцию:

Options Includes +ExecCGI
AddType text/x-server-parsed-html .html
RewriteEngine on
Options +FollowSymlinks
RewriteBase /
RewriteRule ^.htaccess$ - [F]

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

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

Синтаксис: условие должно предшествовать правилу!

Возьмем еще один пример (запись в файле .htaccess):

RewriteEngine on
Options +FollowSymlinks
RewriteBase /
RewriteCond %{HTTP_USER_AGENT} ^EmailSiphon
RewriteRule ^.*$ - [F]

Назначение первых трех записей было подробно разобрано в первой части публикации. Их функция — включение «движка перезаписи», то есть самого модуля.

Последние две строки запрещают доступ поисковому роботу под кодовым названием «EmailSiphon» (имеется ввиду имя пользовательского агента). Данный робот является сборщиком почтовых адресов с различных веб страниц.

Строка:

RewriteCond %{HTTP_USER_AGENT} ^EmailSiphon

состоит из трех частей:

  • Директива (указание): RewriteCond;
  • Проверочная строка: %{HTTP_USER_AGENT};
  • Образец условия: ^EmailSiphon.

Проверочная строка — переменная сервера, которая может быть записана в общей форме: ‘% {ИМЯ_ПЕРЕМЕННОЙ}’.

Образец условия — регулярное выражение. Для более полного понимания темы стоит рассмотреть регулярные выражения как класс.

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

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

Например, регулярное выражение:

s/abc/xyz/g

заменит строку ‘abc’, на строку ‘xyz’ во всем тексте.

Вот краткий обзор наиболее важных элементов с некоторыми примерами:

  • . (точка) — текст (любой символ);
  • | — чередование (то есть/abc|def/);
  • * — квантификатор (разрешено любое число);
  • ^ $ — якоря строки;
  • s — оператор (string1 заменить на string2);
  • g — модификатор (искать по всему тексту).

Регулярные выражения конструируются с помощью этих элементов и других
«обычных» символов. Они не являются отдельным языком, а используются другими средствами, например языками программирования типа Perl или PHP, а также текстовыми редакторами (Emacs).

Если говорить о связи регулярных выражений и модуля mod_rewrite, то они используются в директивах RewriteRule и RewriteCond.

«^» обозначает начало строки. Из этого следует, что User-agent должен начинаться со строки «EmailSiphon» и ни с чего другого («NewEmailSiphon», например, не работал бы).

Но, поскольку данное регулярное выражение не содержит символ «$» (якорь конца строки), User-agent мог бы быть, например, «EmailSiphon2».

Последняя строка нашего примера:

RewriteRule ^.*$ - [F]

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

Регулярное выражение ‘^.*$’ означает «Доступ ко всем файлам запрещен».

Точка «.» в регулярном выражении — мета символ (подстановочный знак), означающий любой случайный символ.

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

«EmailSiphon», конечно, не единственный почтовый сборщик. Другой известный член этого семейства — ‘ExtractorPro’. Допустим мы хотим запретить доступ и этому роботу. В таком случае нам необходимо еще одно условие.

Теперь файл .htaccess будет выглядеть так:

RewriteEngine on
Options +FollowSymlinks
RewriteBase /
RewriteCond %{HTTP_USER_AGENT} ^EmailSiphon [OR]
RewriteCond %{HTTP_USER_AGENT} ^ExtractorPro
RewriteRule ^.*$ - [F]

Третий аргумент [OR] (в первой строке RewriteCond) называется «флагом». Существуют два возможных флага:

NC — не учитывать регистр букв.
OR — означает «или следующее условие».

Флажок NC позволяет игнорировать регистр букв в искомом образце. Например:

RewriteCond %{HTTP_USER_AGENT} ^emailsiphon [NC]

Эта строка определяет, что и «emailsiphon» и «EmailSiphon» будут признаны как идентичные выражения.

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

RewriteCond % {HTTP_USER_AGENT} ^EmailSiphon [NC, OR]
RewriteCond % {HTTP_USER_AGENT} ^ExtractorPro

Нет никаких ограничений по числу условий. Таким образом, Вы можете блокировать 10, 100, 1000 или более известных почтовых сборщиков. Определение этих 1000 условий — просто вопрос загрузки сервера и прозрачности файла «.htaccess».

В вышеупомянутом примере используется глобальная переменная «HTTP_USER_AGENT». Существуют также другие переменные:

  • REMOTE_HOST;
  • REMOTE_ADDR.

Например, если вы хотите заблокировать паука пришедшего с www.site.ru, вы можете использовать глобальную переменную «REMOTE_HOST» таким образом:

RewriteCond % {REMOTE_HOST} ^www.site.ru$
RewriteRule ^.*$ - [F]

Если вы хотите заблокировать определенный IP-адрес, условие будет выглядеть так:

RewriteCond % {REMOTE_ADDR} ^212.37.64.10$
RewriteRule ^.*$ - [F]

В регулярном выражении по проверке точного и полного IP-адреса нужно использовать начальные и конечные якоря. Также можно исключить целый диапазон:

RewriteCond %{REMOTE_ADDR} ^212.37.64.
RewriteRule ^.*$ - [F]

Этот пример показывает, как можно заблокировать диапазон IP адресов с 212.37.64.0 по 212.37.64.255.

А вот маленькая задачка для проверки приобретенных знаний (решение будет дано в следующей части):

RewriteCond %{REMOTE_ADDR} ^212.37.64
RewriteRule ^.*$ - [F]

Внимание, вопрос!

Если мы пишем в регулярном выражении «^212.37.64» вместо «^212.37.64.» (с точкой в конце), то даст ли это тот же самый эффект, и будут ли исключены те же самые IP адреса?

Вот решение задачки:

Если мы пишем в регулярном выражении «^212.37.64» вместо «^212.37.64.» (с точкой в конце), то даст ли это тот же самый эффект, и будут ли исключены те же самые IP адреса?

Регулярное выражение ^212.37.64 удовлетворяет и применимо к следующим строкам:

212.37.64
212.37.640
212.37.641
212.37.64a
212.37.64abc
212.37.64.12
212.37.642.12

Следовательно, последняя цифра «4» может сопровождаться любой символьной строкой. Однако, максимальным значением IP является адрес 255.255.255.255 который подразумевает, что например 212.37.642.12 неправильный (недопустимый) IP. Единственный допустимый IP в
вышеприведенном списке — 212.37.64.12.

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

http://www.yoursite.com/cgi-bin/shop.cgi?product1
http://www.yoursite.com/cgi-bin/shop.cgi?product2
http://www.yoursite.com/cgi-bin/shop.cgi?product3

Эти адреса представлены как ссылки на большинстве страниц сайта.

А теперь допустим, что вы решили добавить сайт для индексации в поисковые системы. Тут вас поджидает небольшая неприятность — не все поисковики принимают, понимают и индексируют URL, в которых содержится символ «?». Более естественным и приемлемым для поисковика является URL вида:

http://www.yoursite.com/cgi-bin/shop.cgi/product1

В данном случае символ ‘?’ заменяется на ‘/’. Еще более комфортабельный URL с точки зрения поисковика будет иметь вид:

http://www.yoursite.com/shop/product1

Для поисковика, «shop» теперь как-бы является директорией, содержащей товары product1, product2 и т.д.

Если пользователь, со страницы результатов запроса в поисковике проследует по такой ссылке, то эта ссылка должна будет трансформироваться в ссылку /shop.cgi?product1.

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

RewriteEngine on
Options +FollowSymlinks
RewriteBase /
RewriteRule ^(.*)shop/(.*)$ $1cgi-bin/shop.cgi?$2

Переменные $1 и $2 составляют так называемые обратные ссылки. Они связаны с текстовыми группами. Вызываемый URL разбивается на части. Все, что находится перед «shop», плюс все что находится после «shop/» определяется и хранится в этих двух переменных: $1 и $2.

До этого момента, наши примеры использовали ‘правила’ типа:

RewriteRule ^.htaccess*$ - [F]

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

Для нашей записи вида:

RewriteRule ^(.*)shop/(.*)$ $1cgi-bin/shop.cgi?$2

применяется общий синтаксис:

RewriteRule текущийURL перезаписываемыйURL

Как видите, эта директива выполняет действительную «перезапись» URL адреса.

В дополнение к записям в файл .htaccess, нужно еще заменить все ссылки на сайте, которые имеют формат «cgi-bin/shop.cgi?product», на ссылки вида «shop/product».

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

Таким образом вы можете превратить чисто динамический сайт в сайт, имеющий статическую структуру, что явно принесет пользу в вопросе индексирования различными посковыми машинами. Обратите внимание на вид URL адресов на данном сайте. Вдобавок ко всему, они имеют еще и
легкочитамую для человека структуру — ЧПУ (человекопонятный УРЛ). Но об этом мы поговорим в другой статье.

В нашем втором примере мы обсудим, как переадресовать запросы «.txt» файлов к сценарию программы.

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

Однако, относительно запросов к файлу «robots.txt», предпочтительно иметь доступ ко всем этим данным, чтобы иметь больше информации о посещении поисковиков, чем просто знать их IP-дреса. Для того, чтобы оганизовать это, в «.htaccess» должны быть следующие записи:

RewriteEngine on
Options +FollowSymlinks
RewriteBase /
RewriteRule ^robots.txt$ /text.cgi?%{REQUEST_URI}

Теперь при запросе файла «robots.txt» наш RewriteRule переадресует посетителя (робота) к обрабатывающему запросы скрипту text.cgi. Кроме того, переменная передается скрипту, которая будет обработана в соответствии с вашими нуждами. «REQUEST_URI» определяет имя запрашиваемого файла. В данном примере это — «robots.txt». Скрипт прочтет содержание «robots.txt» и отправит его web-браузеру или роботу поискового сервера. Таким образом, мы можем считать хиты посетителей и вести свои лог-файлы.

С этой целью, скрипт будет использовать переменные окружения $ENV {‘HTTP_USER_AGENT’}’ и т.д. Это обеспечит получение всей требуемой информации. Вот исходный текст для сценария cgi, упомянутого выше (пример взят с сайта http://fantomaster.com):

#!/usr/bin/perl
# If required, adjust line above to point to Perl 5.
#################################
# (c) Copyright 2000 by fantomaster.com #
# All rights reserved. #
#################################
$stats_dir = "stats";
$log_file = "stats.log";
$remote_host = "$ENV{'REMOTE_HOST'}";
$remote_addr = "$ENV{'REMOTE_ADDR'}";
$user_agent = "$ENV{'HTTP_USER_AGENT'}";
$referer = "$ENV{'HTTP_REFERER'}";
$document_name = "$ENV{'QUERY_STRING'}";
open (FILE, "robots.txt");
@TEXT = ;
close (FILE);
&amp;get_date;
&amp;log_hits("$date $remote_host $remote_addr $user_agent $referer $document_name");
print "Content-type: text/plain
";
print @TEXT;
exit;
sub get_date {
($sec,$min,$hour,$mday,$mon,$year,$wday,$yday,$isdst) = localtime();
$mon++;
$sec = sprintf ("%02d", $sec);
$min = sprintf ("%02d", $min);
$hour = sprintf ("%02d", $hour);
$mday = sprintf ("%02d", $mday);
$mon = sprintf ("%02d", $mon);
$year = scalar localtime;
$year =~ s/.*?(d{4})/$1/;
$date="$year-$mon-$mday, $hour:$min:$sec";
}
sub log_hits {
open (HITS, "&gt;&gt;$stats_dir/$log_file");
print HITS @_;
close (HITS);
}

Загрузите файл с данным содержимым в корневую или в DocumentRoot директорию сервера и установите права доступа у файлу (chmod) 755. Затем, создайте каталог «stats». Более детальное описание о том, как установить скрипт вы можете получить на сайте разработчика. Если настройки вашего сервера не позволяют исполнять cgi-сценарии в главной директории (DocumentRoot), то попробуйте следующий вариант:

RewriteRule ^robots.txt$ /cgi-bin/text.cgi?%{REQUEST_URI}

Обратите внимание, что в этом случае, будет необходимо изменить пути в коде скрипта!

Если вы хотите вести логи всех операций, выполненных с помощью mod_rewrite, можно активировать это с помощью следующей записи:

RewriteLog /usr/local/apache/logs/mod_rewrite_log
RewriteLogLevel 1

Эту строку нужно вписать в «Раздел 2: Конфигурация основного сервера» в файле httpd.conf, а не в .htaccess!

Все манипуляции, произведенные mod_rewrite будут записываться в этот файл. Имя лог файла может быть любым. Вы можете указать абсолютный или относительный (относительно ServerRoot) путь к файлу.

Если вы хотите вести разные лог файлы для различных виртуальных хостов, то нужно ввести изменения в «Раздел 3: Виртуальные сервера», например так:

ServerAdmin webmaster@yourdomain.com
DocumentRoot /usr/www/htdocs/yourdomain
ServerName yourdomain.com
RewriteLog /usr/apache/logs/yourdomain_mod_rewrite_log
RewriteLogLevel 1

RewriteLogLevel может быть определен в пределах от 1 до 8. Обычно достаточно первого уровня. Более высокие уровни используются для отладки.

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

cde2c920.infoseek.com spider
205.226.201.32 spider
cde2c923.infoseek.com spider
205.226.201.35 spider
cde2c981.infoseek.com spider
205.226.201.129 spider
cde2cb23.infoseek.com spider
205.226.203.35 spider

Ключи, как вы видите, имена хостов или IP-адреса. В этом простеньком примере значение всегда одно — «spider». Естественно, в реальном файле значения будут другие. Эта директива может быть записана во второй («Конфигурация основного сервера») или третий («Виртуальные сервера»)
раздел файла httpd.conf:

RewriteMap botBase txt:/www/yourdomain/spiderspy.txt</code>
 
Карта перезаписи возымеет эффект на весь сервер. Также, в файл .htaccess записывается:
 
<pre lang="ini">RewriteCond ${botBase:%{REMOTE_HOST}} =spider [OR]
RewriteCond ${botBase:%{REMOTE_ADDR}} =spider
RewriteRule ^(.*).htm$ $1.htm [L]
RewriteRule ^.*.htm$ index.html [L]</code>
 
Данные условия будут производить системную проверку: произведен ли запрос поисковиком. С этой целью производится поиск по файлу spiderspy.txt. Если ключ найден, будет возвращено значение «spider», а «условие» будет являться истинным.Затем выполняется первый RewriteRule. Это означает то, что запрашиваемая '.htm' страница будет отдана поисковику. Переменная $1 равна части в круглых скобках '^(. *).htm$', то есть имя файла останется тем же самым.
 
Если же URL вызван обычным посетителем, то применяется второе «правило»: пользователь будет перенаправлен на страницу «index.html».
 
Поскольку «.htm» страницы будут читаться только «пауками», они могут быть оптимизированы соответственно для поисковых серверов. Вы можете также использовать файл в формате «dbm»вместо обычного текстового файла. Бинарный формат данных позволяет ускорить поиск, который
является особенно важным, если вы работаете с очень большими списками поисковиков. Пример, данный выше, предлагает простые функциональные возможности клоакинга. Все обычные посетители будут всегда переадресовываться к странице index.html и не будет вестись никаких
логов файлов вне логов mod_rewrite.
 
Можно заменить несколько строчек кода php (perl и т.д.) в ваших приложениях, используя всего одну-две строки mod_rewrite. Последний пример проиллюстрирует это более подробно.
 
Цель — показать посетителям 'фото дня'. Посетитель, кликнувший по ссылке http://yoursite.com/pic.html увидит лучшую фотографию или картинку дня, и так каждый день. Мы будем работать с серверными переменными:
 
<pre lang="ini">TIME_MON
TIME_DAY</code>
 
Поместим в файл .htaccess одну единственную строку:
 
<pre lang="ini">RewriteRule ^pic.html$ pic-%{TIME_MON}-%{TIME_DAY}.html</code>
 
Запрашиваемый URL будет перезаписан, например:
 
<pre lang="ini">pic-08-28.html
pic-08-29.html
pic-08-30.html
и так далее.

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

Изучаем параметры gcc

Перевод статьи «Getting Familiar with GCC Parameters», автор — Mulyadi Santosa

gcc (GNU C Compiler) — набор утилит для компиляции, ассемблирования и компоновки. Их целью является создание готового к запуску исполняемого файла в формате, понимаемом вашей ОС. Для Linux, этим форматом является ELF (Executable and Linking Format) на x86 (32- и 64-битных). Но знаете ли вы, что могут сделать для вас некоторые параметры gcc? Если вы ищете способы оптимизации получаемого бинарного файла, подготовки сессии отладки или просто наблюдать за действиями, предпринимаемыми gcc для превращения вашего исходного кода в исполняемый файл, то знакомство с этими параметрами обязательно. Так что, читайте.

Напомню, что gcc делает несколько шагов, а не только один. Вот небольшое объяснение их смысла:

Препроцессирование: Создание кода, более не содержащего директив. Вещи вроде «#if» не могут быть поняты компилятором, поэтому должны быть переведены в реальный код. Также на этой стадии разворачиваются макросы, делая итоговый код больше, чем оригинальный. [1]

Компиляция: Берется обработанный код, проводятся лексический и синтаксический анализы, и генерируется ассемблерный код. В течение этой фазы, gcc выдает сообщения об ошибках или предупреждениях в случае, если анализатор при парсинге вашего кода находит там какие-либо ошибки. Если запрашивается оптимизация, gcc продолжит анализировать ваш код в поисках улучшений и манипулировать с ними дальнейшем. Эта работа происходит в многопроходном стиле, что показывает то, что иногда требуется больше одного прохода по коду для оптимизации. [2]

Ассемблирование: Принимаются ассемблерные мнемоники и производятся объектные коды, содержащие коды команд. Часто недопонимают то, что на стадии компиляции не производятся коды команд, это делается на стадии ассемблирования. В результате получаются один или более объектных файла, содержащие коды команд, которые являются действительно машинозависимыми. [3]

Компоновка: Трансформирует объектные файлы в итоговые исполняемые. Одних только кодов операции недостаточно для того, чтобы операционная система распознала и выполнила их. Они должны быть встроены в более полную форму. Эта форма, известная как бинарный формат, указывает, как ОС загружает бинарный файл, компонует перемещение и делает другую необходимую работу. ELF является форматом по умолчанию для Linux на x86. [4]

Параметры gcc описаны здесь, прямо и косвенно затрагивая все четыре стадии, поэтому для ясности, эта статья построена следующим образом:

— Параметры, относящиеся к оптимизации

— Параметры, относящиеся к вызову функций

— Параметры, относящиеся к отладке

— Параметры, относящиеся к препроцессированию

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

— Коллекция утилит ELF, которая включает в себя такие программы, как objdump и readelf. Они парсят для нас информацию о ELF.

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

— time, простой способ узнать общее время работы программы.

Следующие инструкции могут быть применены в gcc версий 3.x и 4.x, так что они достаточно общие. Начнем копать?

Параметры, относящиеся к оптимизации кода

.

gcc предоставляет очень простой способ производить оптимизацию: опция -O. Она и ускоряет выполнение вашего кода, и сжимает размер итогового кода. У неё существует пять вариантов:

— от -O0 (O ноль) до -O3. «0» означает отсутствие оптимизации, а «3» — наивысший уровень оптимизации. «1» и «2» находятся между этими краями. Если просто используете -O без указания номера, это будет означать -O1.

— -Os говорит gcc оптимизировать размер. В общем-то, это похоже на -O2, но пропускает несколько шагов, которые могут увеличить размер.

Какое ускорение в действительности можно от них получить? Что ж, предположим, у нас есть такой код:

#include 
 
int main(int argc, char *argv[])
 
{
 
   int i,j,k;
 
   unsigned long acc=0; 
 
   for(i=0;i&lt;10000;i++)
 
        for(j=0;j&lt;5000;j++)
 
                for(k=0;k&lt;4;k++)
 
                        acc+=k;
 
   printf("acc = %lun",acc);
 
   return 0;
 
}

С помощью gcc, создадутся четыре разных бинарных файла, используя каждый из -O вариантов (кроме -Os). Утилита time запишет их время исполнения, таким образом:

$ time ./non-optimized
Без оптимизации -O1 -O2 -O3
real 0.728 0.1 0.1 0.1
user 0.728 0.097 0.1 0.1
sys 0.000 0.002 0.000 0.000

Для упрощения, будем использовать следующие обозначения:

Non-optimized обозначает исполняемый файл, скомпилированный с опцией -O0.

OptimizedO1 обозначает исполняемый файл, скомпилированный с опцией -O1.

OptimizedO2 обозначает исполняемый файл, скомпилированный с опцией -O2.

OptimizedO3 обозначает исполняемый файл, скомпилированный с опцией -O3.

Как вы могли заметить, время выполнения программы, скомпилированной с -O1 в семь раз меньше, чем время выполнения программы, при компиляции которой не использовалась оптимизация. Обратите внимание, что нет большой разницы между -O1, -O2 и -O3, — на самом деле, они почти одинаковы. Так в чем же магия -O1?

После беглого изучения исходного кода, вы должны отметить, что такой код конечен для оптимизации. Прежде всего, давайте посмотрим на короткое сравнение дизассемблированных версий non-optimized и optimizedO1:

$ objdump -D non-optimized
 
$ objdump -D optimizedO1

(Примечание: вы можете получить другие результаты, поэтому используйте эти как основные)

Non-optimized OptimizedO1
mov 0xfffffff4(%ebp)

add %eax,0xfffffff8(%ebp)

addl $0x1,0xfffffff4(%ebp)

cmpl $0x3,0xfffffff4(%ebp)

add $0x6,%edx

add $0x1,%eax

cmp $0x1388,%eax

Приведенные примеры реализуют самый вложенный цикл (for (k=0;k<4;k++)). Обратите внимание на различие: неоптимизированный код напрямую загружает и хранит из адреса памяти, в то время как optimized01 использует регистры ЦПУ в качестве сумматора и счетчик цикла. Как вам, возможно, известно, доступ к регистрам может быть получен в сотни или тысячи раз быстрее, чем к ячейкам ОЗУ.

Не удовлетворяясь простым использованием регистров ЦПУ, gcc использует другой трюк оптимизации. Давайте снова посмотрим дизассемблированный код optimizedO1 и обратим внимание на функцию main():

......
 
   08048390 :
 
   ...
 
   80483a1:       b9 00 00 00 00          mov    $0x0,%ecx
 
   80483a6:       eb 1f                   jmp    80483c7 
 
   80483a8:       81 c1 30 75 00 00       add    $0x7530,%ecx

0x7530 это 30000 в десятичной форме, поэтому мы можем быстро угадать цикл. Этот код представляет собой самый вложенный и самый внешний циклы (for(j=0;j<5000;j++) … for(k=0;k<4;k++)), так как они являются буквальным запросом на 30000 проходов. Примите во внимание, что вам нужно всего лишь три прохода внутри. Когда k=0, acc остается прежним, поэтому первый проход можно проигнорировать.

   80483ae:       81 f9 00 a3 e1 11       cmp    $0x11e1a300,%ecx
 
   80483b4:       74 1a                   je     80483d0 
 
   80483b6:       eb 0f                   jmp    80483c7

Хмм, теперь это соответствует 300 000 000 (10 000*5 000*6). Представлены все три цикла. После достижения этого числа проходов, мы переходим прямо к printf() для вывода суммы (адреса 0x80483d0 — 0x80483db).

   80483b8:       83 c2 06                add    $0x6,%edx
 
   80483bb:       83 c0 01                add    $0x1,%eax
 
   80483be:       3d 88 13 00 00          cmp    $0x1388,%eax
 
   80483c3:       74 e3                   je     80483a8 
 
   80483c5:       eb f1                   jmp    80483b8

Шесть добавляется в сумматор при каждой итерации. В итоге, %edx будет содержать всю сумму после выполнения всех трех циклов. Третья и четвертая строки показывают нам, что после выполнения 5000 раз, должен быть переход к адресу 0x80483a8 (как указано ранее).

Мы можем заключить, что gcc создает здесь упрощение. Вместо прохода три раза в самый вложенный цикл, он просто добавляет шесть для каждого среднего цикла. Это звучит просто, но это заставляет вашу программу сделать только 100 000 000 проходов вместо 300 000 000. Это упрощение, называемое разворачиванием цикла, одно из тех задач, которые делают -O1/2/3. Конечно же, вы и сами можете это сделать, но иногда неплохо знать, что gcc может определить такие вещи и оптимизировать их.

С опциями -O2 и -O3 gcc тоже пытается произвести оптимизацию. Обычно она достигается посредством переупорядочивания [5] и трансформацией кода. Целью этой процедуры является устранить столько ошибочных ветвей, сколько возможно, что повышает качество использования конвейера. Например, мы можем сравнить, как non-optimized и optimizedO2 выполняет самый внешний цикл.

 80483d4:       83 45 ec 01             addl   $0x1,0xffffffec(%ebp)
 
 80483d8:       81 7d ec 0f 27 00 00    cmpl   $0x270f,0xffffffec(%ebp)
 
 80483df:       7e c4                   jle    80483a5

Бинарный файл non-optimized использует jle для выполнения перехода. Математически это означает, что вероятность выбора ветви 50%. С другой стороны, версия optimizedO2 использует следующее:

80483b4:       81 c1 30 75 00 00       add    $0x7530,%ecx
 
80483ba:       81 f9 00 a3 e1 11       cmp    $0x11e1a300,%ecx
 
80483c0:       75 e1                   jne    80483a3

Теперь, вместо jle используется jne. При условии, что любое целое может быть сопоставлено в предыдущем cmp, нетрудно сделать вывод, что это увеличит шанс выбора ветви почти до 100%. Это небольшое, но полезное указание процессору для определения того, какой код должен быть выполнен. Хотя, для большинства современных процессоров, этот вид трансформации не является ужасно необходимым, так как предсказатель переходов достаточно умен для того, чтобы сделать это сам.

Для доказательства того, как сильно это изменение может помощь, к нам на помощь придет OProfile. Oprofile выполнен для записи числа изолированных ветвей и изолированных ошибочных ветвей. Изолированные здесь обозначает «выполненные внутри конвейера данных ЦПУ»

$ opcontrol --event=RETIRED_BRANCHES_MISPREDICTED:1000 --event=RETIRED_BRANCHES:1000;

Мы запустим non-optimized и optimizedO2 пять раз каждый. Затем мы возьмем максимум и минимум примеров. Мы посчитаем степень ошибки, используя эту формулу (выведена отсюда).

Степень ошибки = изолированные ошибочные ветви / изолированные ветви

Теперь вычислим степень ошибки для каждого бинарного файла. Для non-optimized получилось 0,5117%, в то время как optimizedO2 получил 0,4323% — в нашем случае, выгода очень мала. Фактическая выгода может различаться для реальных случаев, так как gcc сам по себе не может много сделать без внешних указаний. Пожалуйста, прочтите о __builtin_expect() в документации по gcc для подробной информации.

Параметры, относящиеся к вызову функций

По существу, gcc предоставляет вам несколько путей управления тем, как вызывается функция. Сначала давайте рассмотрим встраивание. С помощью встраивания, вы сокращаете стоимость вызова функции, так как тело функции подставлено прямо в вызывающую функцию. Пожалуйста, учтите, что это не по умолчанию, а только когда вы используете -O3 или, по крайней мере, -finline-functions.

Как полученный бинарный файл выглядит после того, как gcc сделает встраивание? Рассмотрим следующий листинг:

#include 
 
inline test(int a, int b, int c)
 
{
 
        int d;
 
        d=a*b*c;
 
        printf("%d * %d * %d is %dn",a,b,c,d);
 
}
 
static inline test2(int a, int b, int c)
 
{
 
         int d;
 
         d=a+b+c;
 
         printf("%d + %d + %d is %dn",a,b,c,d);
 
}
 
int main(int argc, char *argv[])
 
{
 
        test(1,2,3);
 
        test2(4,5,6);
 
}

Скомпилируем этот код со следующим параметром:

$ gcc -S -O3 -o

-S указывает gcc остановиться сразу после стадии компиляции (мы расскажем о ней позже в этой статье). Результат будет следующим:

....
 
test:
 
        pushl   %ebp
 
        movl    %esp, %ebp
 
        pushl   %ebx
 
....
 
main:
 
        leal    4(%esp), %ecx
 
        andl    $-16, %esp
 
        pushl   -4(%ecx)
 
...
 
        movl    $6, 16(%esp)
 
        movl    $3, 12(%esp)
 
        movl    $2, 8(%esp)
 
        movl    $1, 4(%esp)
 
        movl    $.LC0, (%esp)
 
        call    printf
 
...
 
        movl    $15, 16(%esp)
 
        movl    $6, 12(%esp)
 
        movl    $5, 8(%esp)
 
        movl    $4, 4(%esp)
 
        movl    $.LC1, (%esp)
 
        call    printf
 
...

И test(), и test() действительно встроены, но вы также можете видеть test(), который остался вне main(). Вот где играет роль ключевое слово static. Написав, что функция — static, вы сообщаете gcc, что эта функция не будет вызываться из какого-либо внешнего объектного файла, поэтому нет нужды порождать коды. Таким образом, это экономит размер, и если вы можете сделать функцию статичной, сделайте это где только возможно. С другой стороны, будьте благоразумны при решении, какая функция должна быть встраиваемой. Увеличение размера для небольшого увеличения скорости не всегда оправдано.

С помощью некоторой эвристики, gcc решает, должна быть функция встраиваемой, или нет. Одним из таких доводов является размер функции в терминах псевдо-инструкций. По умолчанию, лимитом является 600. Вы можете поменять этот лимит, используя -finline-limit. Проэксперементируйте для нахождения лучших лимитов встраивания для вашего конкретного случая. Также возможно переделать эвристику так, чтобы gcc всегда встраивал функцию. Просто объявите вашу функцию так:

__attribute__((always_inline)) static inline test(int a, int b, int c)

Теперь перейдем к передаче параметров. На архитектуре x86, параметры помещаются в стек и позже достаются из стека для дальнейшей обработки. Но gcc дает вам возможность изменить это поведение и использовать вместо этого регистры. Функции, у которых меньше трех параметров могут использовать эту возможность указанием -mregparm=, где n — число регистров, которое вы хотите использовать. Если мы применим этот параметр (n=3) к предыдущему коду, убрав атрибут inline и не используя оптимизацию, мы получим:

...
 
test:
 
        pushl   %ebp
 
        movl    %esp, %ebp
 
        subl    $56, %esp
 
        movl    %eax, -20(%ebp)
 
        movl    %edx, -24(%ebp)
 
        movl    %ecx, -28(%ebp)
 
...
 
main:
 
...
 
        movl    $3, %ecx
 
        movl    $2, %edx
 
        movl    $1, %eax
 
        call    test

Вместо стека, используются EAX, EDX и ECX для хранения первого, второго и третьего параметров. Поскольку доступ к регистру происходит быстрее, чем к ОЗУ, это будет одним из способов уменьшить время работы. Хотя вы должны обратить внимание на следующие вещи:

— Вы ДОЛЖНЫ компилировать весь ваш код с таким же числом -mregparm регистров. Иначе у вас будут проблемы с вызовом функций из другого объектного файла, если они будут принимать разные соглашения.

— Используя -mregparm, вы разрушаете совместимый с Intel x86 бинарный интерфейс приложений (ABI). Поэтому, вы должны учитывать это, если вы распространяете свое ПО только в бинарной форме.

Возможно, вы заметили эту последовательность в начале каждой функции:

push   %ebp
 
mov    %esp,%ebp
 
sub    $0x28,%esp

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

[ebp-01] Последний байт последней локальной переменной

[ebp+00] Старое значение ebp

[ebp+04] Возвращает адрес

[ebp+08] Первый аргумент

Можем мы пренебречь этим? Да, с помощью -fomit-frame-pointer, пролог будет укорочен, так что функция начнется просто с выделения стека (если есть локальные переменные):

sub    $0x28,%esp

Если функция вызывается очень часто, вырезание пролога спасет несколько тактов ЦПУ. Но будьте осторожны: делая это, вы также усложняете отладчику задачу по изучению стека. Например, давайте добавим test(7,7,7) в конец test2() и перекомпилируем с параметром -fomit-frame-pointer и без оптимизации. Теперь запустите gdb для исследования бинарного файла:

$ gdb inline
 
(gdb) break test
 
(gdb) r
 
Breakpoint 1, 0x08048384 in test ()
 
(gdb) cont
 
Breakpoint 1, 0x08048384 in test ()
 
(gdb) bt
 
#0  0x08048384 in test ()
 
#1  0x08048424 in test2 ()
 
#2  0x00000007 in ?? ()
 
#3  0x00000007 in ?? ()
 
#4  0x00000007 in ?? ()
 
#5  0x00000006 in ?? ()
 
#6  0x0000000f in ?? ()
 
#7  0x00000000 in ?? ()

При втором вызове test, программа остановилась, и gdb вывел трассировку стека. В нормальной ситуации, main() должна идти в фрейме №2, но мы видим только знаки вопроса. Запомните, что я сказал про расположение стека: отсутствие указателя фрейма мешает gdb находить расположение сохраненного возвращаемого адреса в фрейме №2.

Опции, относящиеся к отладке.

Каждый иногда нуждается в отладке его или её кода. Когда это время приходит, обычно вы запускаете gdb, ставите точки останова там и тут, анализируете бэктрейсы, и так далее, чтобы выявить расположение нарушающего работу кода. А что получаете на самом деле? Если вы не используете опции отладки, вы просто получаете адрес, указывающий на регистр EIP.

Вот в чем проблема, в действительности вы не хотите адрес. Вы хотите, чтобы gdb или другой отладчик просто показал требуемые строки. Но gdb не может этого сделать без определенного вида помощи. Эта помощь, называемая отладкой с приписываемыми форматами записи (Debugging With Attributed Record Formats — DWARF), помогает вам выполнять отладку на уровне исходного кода.

Как это сделать? Используйте -g при компиляции в объектный код, то есть:

  gcc -o -g test test.c

Что такого добавляет gcc, что отладчик может сопоставлять адрес с исходным кодом? Вам нужна dwarfdump [7] чтобы узнать это. Это утилита находится внутри тарболла libdwarf или в RPM, так что вы не найдете её в виде отдельного пакета. Скомпилируйте её сами или просто установите из репозитория вашего дистрибутива; оба варианта должны сработать. В этой части статьи я использую версию 20060614 RPM.

Используя readelf, вы можете отметить, что в неотлаженной версии первого листинга существует 28 разделов:

 $ readelf -S ./non-optimized

Но в отлаженной версий есть 36 разделов. Новые разделы:

* debug_arranges

* debug_pubnames

* debug_info

* debug_abbrev

* debug_line

* debug_frame

* debug_str

* debug_loc

Вам не нужно копаться во всех этих разделах; для быстрого изучения, будет достаточно рассмотреть .debug_line. Команда, которая вам нужна:

$ /path/to/dwarfdump -l <object width="100" height="100" type="application/x-shockwave-flash"></object>

Вот пример того, что вы получите:

 .debug_line: line number info for a single cu
 
   Source lines (from CU-DIE at .debug_info offset 11):
 
         [row,column]
    //
 
 /code/./non-optimized.c:  [  3,-1]        0x8048384       // new statement
 
 /code/./non-optimized.c:  [  5,-1]        0x8048395       // new statement
 
 ...............

Интерпретация этих сообщений довольно простая. Возьмите первую запись (идущую за строкой ) в качестве примера:

  line number 3 in file non-optimized.c is located in address 0x8048384.

gdb дает ту же информацию:

 $ gdb non-optimized-debugging
 
   (gdb) l *0x8048384
 
   0x8048384 is in main (./non-optimized.c:3).

readelf также предоставляет похожую информацию, используя —debug-info:

 $ readelf --debug-dump=line <object width="100" height="100" type="application/x-shockwave-flash"></object>

И readelf, и dwarfdump могут анализировать информацию отладки, так что вы вольны выбирать сами.

Что вы должны понимать, так это то, что исходный код сам по себе не встроен в объектный файл. На самом деле, отладчик должен проверять отдельный файл исходного кода. Запись в колонке помогает определять, откуда загружать файл исходного кода. Учтите, что она содержит полный путь, что значит невозможность его нахождения gdb в случае перемещения или переименования.

gcc сам имеет возможность давать много информации об отладке. Кроме DWARF, существуют:

* Stabs: -gstabs производит собственный формат stabs, в то время, как -gstabs+ включает в себя специфичные расширения GNU.

* Common Object File Format (COFF): Создается с помощью -gcoff.

* XCOFF: Создается с помощью -gxcoff. Если вы предпочитаете включать расширения GNU, используйте -gxcoff+.

* Virtual Memory System (VMS): Создается с помощью -gvms.

Каждый из этих форматов описаны в ссылках ([8], [9] и [10]), но для x86-совместимой архитектуры, без проблем, вам лучше использовать формат DWARF. Последней спецификацией DWARF является DWARF третьей версии, и gdb может создавать её с помощью -gdwarf-2. Это может ввести в заблуждение новых пользователей, так как вы можете подумать, что такая опция создаст информацию DWARF 2. На самом деле, DWARF 2 объединен с некоторыми возможностями DWARF 3. Не каждый отладчик поддерживает третью версию, поэтому используйте её с осторожностью.

Хотя не всегда все идет так гладко. Когда вы комбинируете опции -O и -g, для информации о строке необходимо установить связь с фактическим кодом в упомянутом сдвиге адреса. Пример может это пояснить. Возьмите файл (я снова использую первый листинг) и скомпилируйте его:

 $ gcc -O2 -ggdb -o debug-optimized listing-one.c
 
   $ readelf --debug-dump=line debug-optimized
 
   ..
 
   Special opcode 107: advance Address by 7 to 0x80483aa and Line by 4 to 11
 
   ...

Но что говорит gdb?

 $ gdb debug-optimized
 
   (gdb) l *0x80483aa
 
   0x80483aa is in main (./non-optimized.c:11).
 
   ...
 
   11              printf("acc = %lun",acc);
 
   ...
 
   (gdb) disassemble main
 
   ...
 
   0x080483aa :   add    $0x6,%edx
 
   0x080483ad :   cmp    $0x1388,%eax
 
   ...

Здесь вы видите полное расхождение. Изучая одну информацию об отладке, вы будете ожидать, что указанный адрес содержит что-то вроде инструкции CALL. Но в действительности, вы получите инструкции ADD и CMP, что больше похоже на конструкцию цикла. Это побочный эффект действий оптимизации — в этом случае меняется порядок инструкций. Так что возьмите себе за правило не смешивать опции -g (или её варианты) c -O.

Опции, управляющие стадиями компиляции.

В целях изучения, иногда вы хотите узнать, как ваш исходный код трансформируется в исполняемый. К счастью, gcc предоставляет вам опции для остановки на любой стадии обработки. Вспомните, что gcc имеет несколько стадий завершения, — например, компоновку. Есть такие опции:

* -c останавливает на стадии ассемблирования, но пропускает компоновку. Результатом является объектный код.

* -E останавливает на стадии препроцессинга. Все директивы препроцессора развернуты, так что вы видите только чистый код.

* -S останавливает после компиляции. Она оставляет вас с ассемблерным кодом.

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

$ gcc -o final-binary test1.c test2.c

будет лучше разделить их так:

$ gcc -c -o test1.o test1.c
 
$ gcc -c -o test2.o test2.c

и затем:

$ gcc -o final-binary ./test1.o ./test1.o

Возможно, вы заметили, что такая же последовательность используется, если вы собираете программу, используя Makefile. Преимущество использования -c ясно: вам нужно перекомпилировать только измененные исходные файлы. Только фаза, на которой переделывается компоновка всех объектных файлов, и это очень экономит время, особенно в больших проектах. Очевидным примером этого является ядро Linux.

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

#include 
 
#define A 2
 
#define B 4
 
#define calculate(a,b) a*a + b*b
 
void plain_dummy()
 
{
 
    printf("Just a dummyn");
 
}
 
static inline justtest()
 
{
 
    printf("Hi!n");
 
}
 
int main(int argc, char *argv[])
 
{
 
#ifdef TEST
 
    justtest();
 
#endif
 
    printf("%dn", calculate(A,B));
 
    return 0;
 
}

Скомпилируем его следующим образом:

$ gcc -E -o listing2.e listing2.c

Учтите, что мы не указываем параметров -D, что означает, что TEST не определен. Так и что мы имеем в препроцессорном файле?

void plain_dummy()
 
{
 
    printf("Just a dummyn");
 
}
 
static inline justtest()
 
{
 
    printf("Hi!n");
 
}
 
int main(int argc, char *argv[])
 
{
 
    printf("%dn", 2*2 + 4*4);
 
    return 0;
 
}

А где вызов justtest() внутри main()? Нигде. TEST не определен — вот почему код исключен. Вы также можете видеть, что макрос calculate уже развернут в умножение и сложение констант. В конечной исполняемой форме, эти числа будут заменены результатами операций. Как вы видите, -E довольно удобна для проверки корректности директив.

Обратите внимание, что plain_dummy() все ещё здесь, не смотря на то, что она ни разу не вызывается. Это не удивительно, так как ещё не была произведена компиляция, вот почему не произошло исключение «мертвого» кода на этой стадии. stdio.h также развернут, но не показан в листинге выше.

Я нашел интересное приложение использования -E в качестве утилиты создания HTML. Вкратце, она помогает вам перенимать обычные действия в программировании, такие как модуляризация кода и макросы в мир HTML — то, что не может быть сделано на чистом HTML.

-S дает вам код на ассемблере, больше похожий на то, что вы видите с помощью objdump -d/-D. Хотя с помощью -S вы продолжите видеть директивы и имена символов, который делают код проще к изучению. Например, вызов printf(«%dn», 20) может быть трансформирован в:

.section        .rodata.str1.1,"aMS",@progbits,1
 
.LC0:
 
        .string "%dn"
 
...
 
        movl    $20, 4(%esp)
 
        movl    $.LC0, (%esp)
 
        call    printf

Вы можете видеть, что format string %d помещена в область данных, доступную только для чтения (.rodata). Также, вы можете удостовериться, что аргументы помещаются в стек справа налево, со строкой форматирования на верху стека.

Заключение.

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

Благодарности.

Я хочу поблагодарить сообщества на irc каналах OFTC (#kernelnewbies и #gcc) и #osdev (Freenode) за их полезные идеи.

Ссылки

1. Статья в Википедии о Препроцессоре;

2. Статья в Википедии о Компиляторе;

3. Статья в Википедии об Ассемблере;

4. Статья в Википедии о Компоновщике.

5. Пример переупорядочивания кода (англ.);

6. Frame pointer omission (FPO) optimization and consequences when debugging, Часть 1 и Часть 2 (англ.);

7. Описание DWARF (англ.);

8. Описание stabs (англ.);

9. Описание COFF (англ.);

10. Описание XCOFF (варианта COFF) (англ.);

11. Использование препроцессора C в качестве утилиты создания HTML (англ.);

12. Документация по gcc (англ.);

13. AMD Athlon Processor x86 Code Optimization Guide (англ., pdf).

Быстрое обновление и восстановление портов

Содержание:

Введение.

1. Скачивание и установка дерева портов.
2. Обновление и исправление базы данных портов.
3. Редактирование /etc/make.conf (оптимизация, etc).
4. Простое обновление.
5. Полезные опции portupgrade.
6. Простой скрипт обновления.
7. Скрипт обновления, усовершенствованный (Рекомендуемый).
8. Скрипт автоматического обновления (экспериментально).
9. Исправление некоторых проблем.

Введение

если нужно обновить (и(или)восстановить) порты, может быть запутанная ситуация (например, если не обновлять год), portupgrade очень часто с первого раза не исправляет ошибки

OS: FreeBSD 7.0, FreeBSD 7.1, FreeBSD 8.0

1. Скачивание и установка дерева портов.

для начало перейти в:

cd /usr

скачаем архив дерева портов, это будет быстрее чем обновлять через cvsup, ищем ближайщый ftp провайдера/города/страны

качаем:

wget 'ftp://ftp2.ua.freebsd.org/pub/FreeBSD/ports/ports/ports.tar.gz'

перед скачиваем нужно обратить внимание чтобы архив был создан не позже чем 1-2 дня назад (желательно), некоторые ftp редко синхронизируются!

rm -rf /usr/ports

можно не большой скрипт который быстрее разархивирует:

#!/usr/bin/perl
 
open (OPEN, "tar -tf ports.tar.gz |");
 
while (my $p = ) {
system("tar -xvzf ports.tar.gz $p &gt; /dev/null &amp;");
}
 
close OPEN;

(если perl не стоит, то скорее всего он будет из мира, по-моему путь #!/usr/local/bin/perl )

PS вообще-то, portsnap лучше, чем архив качать и еще есть rsyns

2. Обновление и исправление базы данных портов.

бэкап базы пакетов:

cp /var/log/dpkgdb.db /home/dpkgdb.db

можно заархивировать каталоги /etc/ /usr/local/etc программа может затереть конфиг (осторожно с символическими ссылками чтобы не удалить случайно важную информацию)

pkgdb -aF

-a all, -F исправлять не спрашивая, считается безопасный метод
если база сбита, то на крайняк можно pkgdb -fu

3. Редактирование /etc/make.conf (оптимизация, etc).

по-моему: в FreeBSD 7.2, FreeBSD 8.0 CURRENT) в CFLAGS присутствует скрытый дефект: -ffast-math, который оборачиваектся для нас -funsafe-math-optimizations -fno-math-errno http://www.freebsd.org/cgi/query-pr.cgi?pr=137869
будьте внимательны

ee /etc/make.conf
 
WITCH=BATCH=yes # не выдавать окно в котором спрашивать с чем компилировать
BATCH=yes
 
# параллельная сборка портов, появилась с FreeBSD 7.2 лучше  не включать
#
# MAKE_JOBS_SAFE=yes
# MAKE_JOBS_NUMBER=8
# FORCE_MAKE_JOBS=yes
# DISABLE_MAKE_JOBS=yes
# MAKE_JOBS_UNSAFE=yes
 
# FORCE_MAKE_JOBS=
#MAKE_JOBS_NUMBER!= let $$(sysctl -n kern.smp.cpus) \* 4
#
#.for port in \
#        emacs-devel cross-binutils libgpg-error perl5.8 libthai \
#        libiconv m17n-lib nasm tightvnc db47 subversion* \
#        ghostscript8 pth cdrtools* w3m* xmp libslang2 ezm3 dcget libxml2 \
#        vim gperf ffcall ORBit2 py-gtk2 xkeyboard-config ruby18 clisp \
#        jdk16 p7zip zsh libsndfile openjdk6 gettext stumpwm
#
#. if ${.CURDIR:M*/${port}}
#    MAKE_JOBS_UNSAFE=
#. endif
#.endfor
#
 
# оптимизация
# CPUTYPE=pentium4 # архитектура
# CFLAGS+=-g
# CFLAGS=-O2 -pipe -ffast-math -funit-at-a-time -fpeel-loops -ftracer
# -funswitch-loops -mmmx -msse -msse2 -march=pentium4 -mtune=pentium4
# COPTFLAGS=-O2 -pipe  -ffast-math -funit-at-a-time -fpeel-loops -ftracer
# -funswitch-loops -mmmx -msse -msse2 -march=pentium4 -mtune=pentium4
# CXXFLAGS+=-fconserve-space
# NO_PROFILE=true
# LOCALIZED_LANG=ru
 
CPUTYPE=pentium4 # архитектура
CFLAGS=-O2 -pipe -funit-at-a-time -fpeel-loops -ftracer
-funswitch-loops -mmmx -msse -msse2 -march=pentium4 -mtune=pentium4
COPTFLAGS=-O2 -pipe -funit-at-a-time -fpeel-loops -ftracer
 -funswitch-loops -mmmx -msse -msse2 -march=pentium4 -mtune=pentium4
CXXFLAGS+=-fconserve-space
NO_PROFILE=true
LOCALIZED_LANG=ru
 
# зеркало (указать свои)
 
MASTER_SITE_OVERRIDE?= \
ftp://ftp5.ua.FreeBSD.org/pub/FreeBSD/distfiles/${DIST_SUBDIR}/ \
ftp://ftp7.ua.FreeBSD.org/pub/FreeBSD/distfiles/${DIST_SUBDIR}/ \
ftp://ftp.ua.FreeBSD.org/pub/FreeBSD/distfiles/${DIST_SUBDIR}/ \
ftp://ftp.gentoo.org.ua/distfiles/${DIST_SUBDIR}/ \
ftp://ftp2.ua.FreeBSD.org/pub/FreeBSD/distfiles/${DIST_SUBDIR}/ \
ftp://ftp6.ua.FreeBSD.org/pub/FreeBSD/distfiles/${DIST_SUBDIR}/ \
ftp://ftp8.ua.FreeBSD.org/pub/FreeBSD/distfiles/${DIST_SUBDIR}/ \
ftp://ftp.linux.kiev.ua/pub/Linux/Gentoo/distfiles/${DIST_SUBDIR}/ \
ftp://ftp.lucky.net/pub/FreeBSD/ports/distfiles/${DIST_SUBDIR} \
ftp://ftp3.ua.freebsd.org/pub/FreeBSD/ports/distfiles/${DIST_SUBDIR}/ \
ftp://ftp4.ua.freebsd.org/pub/FreeBSD/ports/distfiles/${DIST_SUBDIR}/ \
ftp://ftp.ntu-kpi.kiev.ua/pub/FreeBSD/distfiles/${DIST_SUBDIR}/ \
ftp://ftp.univ.kiev.ua/pub/FreeBSD/distfiles/${DIST_SUBDIR}/ \
ftp://ftp.univ.kiev.ua/pub/OS/FreeBSD/distfile/${DIST_SUBDIR} \

4. Простое обновление.

если portupgrade не стоит, то поставить:
(потянет ruby)

cd /usr/ports/sysutils/portupgrade &amp;&amp; make &amp;&amp; make install &amp;&amp; make clean

в headbook’е написано:

portupgrade -a

в других источниках сразу, рекомендуют:

portupgrade -arR

чтобы пройтись вдоль всех зависимостей

5. Полезные опции portupgrade.

полезные опции в portupgrade:
-W не чистить порт после обновления;
-w не чистить порт перед обновлением;
-F для того что скачать все исходники сразу, если проблемы с интернетом: portupgrade -aFrR
опции -f устанавливает дальше все зависимости, если даже где-то ошибка, то пытается продолжить дальше…;
-l /var/log/pport.log — записывает последнюю ошибку;
-L %s::%s создает файл в текущем каталоге, в котором записывает весь вывод установленных портов.

2 полезные команды make:
1) cd /usr/ports/deve/icu && make run-depends-list покажет зависимости данного порта,
2) make all-depends-list — все зависимости и зависимости тех портов которые зависят от порта

есть один важный недостаток, бывает версия порта называется не совсем корректно, например cairo-1.8.6_1,1 и portupgrade может всегда писать что порт устаревший

6. Простой скрипт.

portupgrade -arR часто тоже может выдаст ошибку!!
есть вариант написать скрипт, который обновит те порты который устаревшие в месте с зависимостями:

#!/usr/bin/perl
 
$nn = 0;
 
while (1) {
 
    $nn++;
 
    open( OPERN, "portversion |" );
 
    @all = ;
 
    if ( $nn &gt; 6 ) {
    print "while 6 exit";
    exit;
    }
 
    foreach (@all) {
 
        my ( $pp, $st ) = split( / /, $_, 2 );
 
        if ( $st =~ '&lt;' ) {
 
            print "UPDATE: $pp\n";
 
            system("portupgrade -f $pp");  
 
        } else {
            print "ok UPDATE";
            exit;
        }
    }
 
}

при этом может быть очень часто что что-то пропустит из-за подзависимоти каких-то скорее всего, цикл идет в 2 этапов if ( !$nn > 2 )

если порты запутанные, можно написать чтобы обновляло и новую версия как не корректную if ( $st =~ ‘<‘ || $st =~ ‘>’) {

Важное примечание: при обновлении Desktop лучше сначала попробовать portupgrade -aRr, так как опция -R (portupgrade -Rf $all[0] для скрипта ниже) (ее lissyara рекламировал) будет устанавливать все зависимости по новому, если нужно обновить, к примеру, 4 программы evince/firefox3/xfce4, то они потянут около 20-60 зависимостей каждая (не считал), и одно и тоже portupgrade будет собирать (но имейте ввиду что эта опция -R надежная), более «мягче» есть вариант в данном случае поставить portupgrade -rf ports_old, при этом будут собираться только «ближайшие» зависимости, самый жесткий вариант portupgrade -Rrf ports_old скорее всего лучше использовать в редких случаях, например, если не хочет компилироваться /devel/icu, так же можно просто -f.

перед кажой установленной программой желательно пересмотреть еще раз список устаревших портов, чтобы не компилировать одно и тоже лишный раз, так как с опциями -R или -r многое уже может быть обновленно, portversion быстро смотрит какие версии установлены…

7. Скрипт обновления, усовершенствованный (Рекомендуемый).

вот маленький скрипт для этого + еще реализовал запись в лог файл, чтобы было видно какой порт обновляется и сколько время прошло:

#!/usr/bin/perl
 
$nn = 0;
 
while (1) {
 
    $nn++;
 
    open( OPERN, "portversion |" );
 
    my @all2 = ;
 
    close OPERN;
 
    my @all;
 
    for ( $i = 0 ; $i &lt; @all2 ; $i++ ) {
 
        my ( $pp, $st ) = split( / /, $all2[$i], 2 );
        if ( $st =~ '&lt;' ) {
 
            push @all, $pp;    # $all[$i] = $pp;
 
        }
 
    }
 
    exit if ( !$all[0] || $nn &gt; 2 );
 
    while (1) {
 
        last if !$all[0];
 
        print "$all[0]\n";
 
        logsave( get_time(), $all[0] );
 
        system("portupgrade -rf $all[0]");
      # system("portupgrade -Rf $all[0]");
 
      # первый порт попробовать обновить вдоль и поперек
      # (выше system нужно закомментировать)
      # if ($nn == 1) {
      #  system("portupgrade -rRf $all[0]");
      #  } else {
      #  system("portupgrade -rf $all[0]");
      #  }
 
   #  экспериментально:
   #  можно добавить чтобы скрипт автоматически нажимал на энтер
   #    use IO::Select;
   #     my $select = IO::Select-&gt;new;
   #    for(@array)
   #     open my $pipe, "|$_";
   #     $select-&gt;add($pipe);
   #    }
   #    my @waiters = $select-&gt;can_write($timeout);
   #    print $_ "\x0a" for @waiters; 
 
        logsave( get_time(), $all[0] );
 
        shift @all;
 
        my @all = old(@all);
 
    }
 
}
 
sub old {
 
    my @all = @_;
 
    open( OPEN2, "portversion |" );
 
    my @all_all = ;
 
    close OPEN2;
 
    my @old;
    my @no_old;
 
    foreach my $p (@all_all) {
 
        my ( $pname, $status ) = split( / /, $p, 2 );
 
        if ( $status =~ '&lt;' ) {
 
            push @old, $pname;
 
        }
        else {
            push @no_old, $pname;
        }
    }
 
    my %seen;
    @seen{@all} = ();
    delete @seen{@no_old};
    return keys %seen;
 
}
 
sub get_time {
    my ( $sec, $min, $hour, $mday, $mon, $year, $wday, $yday, $isdst ) =
      localtime(time);
    $mon++;
    $year += 1900;
    if ( $mday &lt; 10 ) { $mday = "0$mday"; }
    if ( $mon &lt; 10 )  { $mon  = "0$mon"; }
    if ( $min &lt; 10 )  { $min  = "0$min"; }
    my $date        = "$mday $mon $year";
    my $time        = "$hour:$min:$sec";
    my $cur_all_day = $mday + $mon * 30 + $year * 365;
    my $radate      = "$year-$mon-$mday $hour:$min:$sec";
    return $radate;
}
 
sub logsave {
    my ( $time, $ports ) = @_;
    my $logfile;
    $logfile = "\n time:  $time \n  ports: $ports \n\n";
    system("touch /var/log/portupgrade.log");
    open( DB2, "/var/log/portupgrade.log" ) || die "Cannot open file: $!";
    my @base = ;
    close(DB2);
    open( DB, "&gt;/var/log/portupgrade.log" ) || die "Cannot open file : $!";
    print DB @base;
    print DB $logfile;
    close(DB);
}

8. Скрипт автоматического обновления (экспериментально).

дальше я написал простейший скрипт для автоматического обновления, который обновит дерево портов и порты через cron, отправит на email какие порты он обновил, и какие были устаревшие, можно поставить раз в неделю в cron

нужно заменить email адрес на тот который будет отсылаться Вам, и проверить работоспособность ftp с которого архив порта скачать

#!/usr/bin/perl
 
system("rm -rf /usr/ports.tar.gz");
 
system(
"cd /usr &amp;&amp;
wget ftp://ftp2.ua.freebsd.org/pub/FreeBSD/ports/ports/ports.tar.gz");
 
system("rm -rf /usr/ports");
 
open( OPEN, "tar -tf /usr/ports.tar.gz |" );
 
while ( my $p =  ) {
    system("tar -xvzf /usr/ports.tar.gz /usr/$p &gt; /dev/null &amp;");
}
 
close OPEN;
 
my $db = '/home/pkgdb.db' . time;
 
system("cp /var/db/pkg/pkgdb.db  $db");
 
system("pkgdb -aF");
 
my $etc       = '/home/etc' . time;
my $etc_local = '/home/etc_local' . time;
 
system("tar -cf $etc /etc");
system("tar -cf $etc_local /usr/local/etc");
 
open( OLD, "portversion -F|" );
my @all_old =
;
close OLD;
 
foreach (@all_old) {
    my ( $pname, $status ) = split( / /, $_, 2 );
    push @old, $pname if ( $status =~ '&lt;' );
}
 
$nn = 0;
 
while (1) {
 
    $nn++;
 
    open( OPERN, "portversion |" );
 
    my @all2 = ;
 
    my @all;
 
    for ( $i = 0 ; $i &lt; @all2 ; $i++ ) {
 
        my ( $pp, $st ) = split( / /, $all2[$i], 2 );
        if ( $st =~ '&lt;' ) {
 
            push @all, $pp;    # $all[$i] = $pp;
 
        }
 
    }
 
    exit if ( !$all[0] || $nn &gt; 2 );
 
    while (1) {
 
        last if !$all[0];
 
        print "$all[0]\n";
 
        system("portupgrade -rf $all[0]");
 
        shift @all;
 
        my @all = old(@all);
 
    }
 
}
 
sub old {
 
    my @all = @_;
 
    open( OPEN2, "portversion |" );
 
    my @all_all = ;
 
    my @old;
    my @no_old;
 
    foreach my $p (@all_all) {
 
        my ( $pname, $status ) = split( / /, $p, 2 );
 
        if ( $status =~ '&lt;' ) {
            push @old, $pname;
        }
        else {
            push @no_old, $pname;
        }
    }
 
    my %seen;
    @seen{@all} = ();
    delete @seen{@no_old};
    return keys %seen;
 
}
 
open( NEW, "portversion -F|" );
my @all_new = ;
close NEW;
 
foreach (@all_new) {
    my ( $pname, $status ) = split( / /, $_, 2 );
    push @new, $pname if ( $status =~ '&lt;' );
}
 
open( SENDMAIL, "|/usr/local/sbin/sendmail -t" )
  or die "sendmail not ready";
print SENDMAIL "From: FreeBSD \n";
print SENDMAIL "Reply-To: FreeBSD
\n";
print SENDMAIL "Subject: UPDATE from portupgrade\n\n";
print SENDMAIL "list old\n\n";    #
print SENDMAIL "@old\n\n";
print SENDMAIL "list new\n\n";
print SENDMAIL "@new\n\n";
print SENDMAIL "#################\n";
print SENDMAIL "list ALL old\n\n";    #
print SENDMAIL "@all_old\n\n";
print SENDMAIL "list ALL new\n\n";
print SENDMAIL "@all_new\n\n";
close(SENDMAIL) or warn "sendmail didn`t close nicely";

пример как можно написать что-то подобное portupgrade:

#!/usr/bin/perl
 
open( OPEN2, "portversion -o  |" );
 
@all_all = ;
 
my @all;
 
foreach (@all_all) {
    my ( $pname, $status ) = split( / /, $_, 2 );
    $pname = '/usr/ports/' . $pname;
    $pname =~ s/^\s+//;
    $pname =~ s/\s+$//;
    push @all, $pname;
}
 
my $port;
 
my @old;
my @no_old;
 
foreach my $p (@all_all) {
 
    my ( $pname, $status ) = split( / /, $p, 2 );
 
    if ( $status =~ '&gt;' || $status =~ '&lt;' ) {
 
        $pname = '/usr/ports/' . $pname;
        $pname =~ s/^\s+//;
        $pname =~ s/\s+$//;
        push @old, $pname;
 
    }
    else {
        $pname = '/usr/ports/' . $pname;
        $pname =~ s/^\s+//;
        $pname =~ s/\s+$//;
        push @no_old, $pname;
    }
 
}
 
@to_port = `cd $old[0] &amp;&amp; make all-depends-list`;
 
foreach (@to_port) {
    $_ =~ s/^\s+//;
    $_ =~ s/\s+$//;
}
 
my %seen;
@seen{@to_port} = ();
delete @seen{@no_old};
@dep2 = keys %seen;
 
print "@dep2\n";

9. Исправление некоторых проблем.

если обновилось php, то нужно обновить его библиотеки:

pkg_info  | grep '^php5*' | awk '{print $1}' | xargs portupgrade -f
|| pkgdb -fFu &amp;&amp; portsclean -CLPP

для perl часто тоже может понадобиться:

pkg_info  | grep '^p5-*' | awk '{print $1}' | xargs portupgrade -f
|| pkgdb -fFu &amp;&amp; portsclean -CLPP

так же есть скрипт perl-after-upgrade

Java (jdk*) прийдеться руками ставить

очистить порты и каталог distfile:

portsclean -CDD

Источник

Cоветы по использованию утилиты GNU Find

GNU find является одной из наиболее часто используемых программ. На первый взгляд опции find и их синтаксис выглядят слегка непонятными. Однако, немного попрактиковавшись с find, вы сможете быстро и без труда находить любой файл в вашей системе. Чтобы помочь вам начать работать с find, рассмотрите предлагаемые десять способов её использования.

Имейте ввиду, что не все версии find одинаковы, и та, которую вы используете в Linux, будет отличаться от версий для Mac, BSD или Solaris. В основном синтаксис одинаков во всех версиях, но местами встречаются небольшие различия.

Простой поиск

Давайте начнём с простого. Если вам известно имя файла, но вы не знаете точно в каком каталоге он расположен, синтаксис find будет предельно прост. Просто сообщите find имя искомого файла:

find -name имя_файла

Если файл с именем filename существует, то команда find покажет местоположение файла или файлов, которые соответствуют этому имени, следующим образом:

jzb@kodos:~$ find -name filename
./projects/filename
jzb@kodos:~$

Поиск по размеру

Иногда при поиске файла бывает нужно использовать его дополнительные атрибуты в качестве критерия поиска, а не только имя. Например, размер файла. Например, когда в вашей системе заканчивается свободное место в каком-то дисковом разделе и вам необходимо узнать, какие файлы занимают драгоценное дисковое пространство. При помощи find вы можете отыскать такие файлы и уже потом решить, за счёт чего можно высвободить необходимое дисковое пространство.

Для такого случая у find имеется опция -size, принимающая в качестве параметра размер, являющийся критерием поиска. Размер можно указывать начиная с байтов (b), заканчивая гигабайтами (G). Например, чтобы выполнить поиск файлов размером 100 килобайт, можно использовать команду:

find -size 100k

Однако такой вариант может не подойти в нашем случае. Более подходящим будет поискать файлы размеров больше (или меньше) заданного. Чтобы выполнить такой поиск, просто добавьте «+» или «-» к размеру, и find будет искать файлы большего или меньшего размера соответственно, чем указан. Например, следующая команда найдёт все файлы размеров более 100 килобайт:

find -size +100k

а эта — менее, чем 100 килобайт:

find -size -100k

Также, вы можете попросить find найти все пустые файлы:

find -empty -type f

Обратите внимание на указанную опцию -type с параметром «f», которая указывает find искать только обычные файлы. Если не указать это, то find выведет также и пустые каталоги.

Поиск по владельцу

Другой, часто используемый, вариант поиска — поиск по принадлежности файла какому-то пользователю или даже по его отсутствию. Например, вы переместили какие-то файлы в другую систему или же удалили какого-то пользователя, вероятно сделав файлы «сиротами». Отыскать такие файлы-сироты можно простой командой:

find -nouser

Для поиска файлов, принадлежащих какому-то конкретному пользователю, существуют опции -user и -uid. Первая опция принимает как имя пользователя, так и его идентификатор, а вторая — только идентификатор. Например, если мне нужно будет найти все файлы, владельцем которых я являюсь, я воспользуюсь одной из команд:

find -user jzb
find -user 1000
find -uid 1000

Также, вам может понадобиться найти файлы принадлежащие пользователю А или пользователю Б. Для этого необходимо объединить два условия поиска при помощи оператора «-o»:

find -user root -o -user www-data

Такая команда будет искать файлы, владельцем которых является пользователь root или же пользователь www-data. Если же, например, вы хотите найти файлы, владельцем которых пользователь не является, используйте оператор «-not»:

find -not -user www-data

Естественно, операторы работают и с другими опциями. К примеру, следующая команда найдёт файлы, владельцем которых является www-data и которые размером не более ста килобайт:

find -user www-data -not -size +100k

Поиск по группе-владельцу

Ещё один способ использования find — поиск файлов, принадлежащих какой-то группе пользователей. Для этого используется опция «-group», параметром которой должно быть имя группы или её идентификатор. Например:

find -group admin

В повседневной жизни вы, вероятней всего, будете комбинировать эту опцию с другими. Например, если вам нужно отыскать файлы, принадлежащие определённому пользователю и группе.

Поиск по правам доступа

Иногда у вас может возникать необходимость найти файлы, доступные для записи кому угодно или файлы, имеющие какие-либо другие «плохие» разрешения. Подобный поиск find может осуществлять при помощи различных опций. Простейшие из них — это операторы -readable, -writable и -executable, которые работают применительно к пользователю, запустившему find. Имейте ввиду, что в слишком древних версиях find эти опции отсутствуют.

Другой способ искать файлы определённым режимом доступа — использование опции -perm, позволяющей точно определять права доступа искомых файлов. Например, если вы хотите найти файлы, биты выполнения которых установлены для владельца и группы, используйте команду:

find -type f -perm -110

Здесь параметр «110» сообщает find набор битов доступа, а «-» заставляет игнорировать все остальные. Таким образом, если файл имеет ко всему прочему установленные биты чтения и записи, он также будет соответствовать критерию поиска, поскольку для find важно лишь то, что установлены указанные биты выполнения.

Если вам необходимо точное совпадение с указанным режимом доступа, то уберите опцию «-».

А что, если вам необходимо найти файлы, исполняемые владельцем или группой? В это случае вместо «-» используйте «/»:

find -type f -perm /110

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

Использование регулярных выражений

Иногда вам может потребоваться использование регулярных выражений, чтобы определить критерии поиска. И find поддерживает их даже в большей степени, чем вы, возможно, ожидали. find не только поддерживает использование регулярных выражений, но и позволяет использовать различные их типы. Тип регулярного выражения можно определить при помощи опции -regextype, которая принимает параметры posix-awk, posix-egrep и тому подобные. В man-странице вы найдёте полный перечень поддерживаемых типов регулярных выражений вашей версией find.

Небольшой пример. Скажем, вам нужно найти файлы, имеющие расширения «.php» и «.js». Такое можно осуществить следующей командой:

find -regextype posix-egrep -regex '.*(php|js)$'

Выглядит страшновато, не так ли? Эта команда говорит find использовать синтаксис регулярных выражений egrep (-regextype posix-egrep), а затем сообщает само регулярное выражение. Выражение обрамлено одинарными кавычками, чтобы оболочка не пыталась по-своему интерпретировать спецсимволы, использующиеся в выражении. В самом выражении «.*» означает любой символ, повторяющийся ноль или более раз. Часть выражения «(php|js)» сообщает о необходимости искать «php» или «js» (символ вертикальной черты используется для определения оператора «или»). И, наконец, знак доллара в конце выражения сообщает о том, что предыдущая часть выражения должна искаться в конце строки.

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

Работа со временем

Что, если вам понадобится найти файлы, основываясь на их возрасте? Иногда бывает, что знаешь, в каком промежутке времени файл был создан, а всё остальное — позабылось. Или же, вам может понадобиться отыскать какие-то старые файлы, которые пора удалить. В общем, причин может быть куча.

find в полном объёме умеет работать со временем, позволяя искать по времени последнего доступа к файлу (-atime), времени последнего изменения файла (-mtime), или по времени его создания (-сtime).

Например, давайте все найдём файлы, которые были изменены за последние два дня:

find -mtime +2

Параметры опций, работающих со временем, можно интерпретировать как «N раз по 24 часа» и в действительности означают промежуток времени. Если вы передадите find опцию «+1», то она поймёт это как «не менее, чем 24 часа назад, но не более, чем 48».

Эти опции вы также можете комбинировать, если нужно отыскать файлы, временные критерии поиска находятся в каком-то промежутке. Так, команда

find -mtime +2 -mtime -5

означает «два или более дня назад, но не более пяти дней назад».

Работа с минутами

Иногда бывает нужно найти файлы, изменённые за последние 24 часа, и в этом случае рассмотренные опции *time по понятным причинам не подойдут. Однако, на этот случай, у find припасены специальные опции -amin, -cmin, -mmin, которые работают подобно выше рассмотренным, с той разницей, что в качестве параметров они принимают минуты, а не сутки. Так что, если вам нужно найти какие-то файлы, изменённые, например, в течение рабочего дня — это те самые опции, которые вам помогут.

Ограничение поиска

Иногда find выдаёт намного больше результатов поиска, чем вам нужно. При помощи опции -maxdepth вы можете ограничить find таким образом, чтобы она не «зарывалась» слишком глубоко. Например, если вы хотите найти все файлы c расширением «js» в каталоге wordpress, можно воспользоваться командой:

find wordpress -name '*js'

Но что, если вас интересуют файлы лишь из каталога верхнего уровня? Нет проблем: ограничьте описк при помощи опции -maxdepth:

find wordpress -maxdepth 1 -name '*js'

Такая команда заставит искать find только в каталоге wordpress, не заходя в подкаталоги, которые в нём содержатся. Если вы хотите поискать в этих подкаталогах, но не соваться глубже — увеличьте параметр опции -maxdepth на единицу и т. д.
Действия над найденными файлами

Итак, вы нашли то, что искали. Что вы будете делать с найденным? Используя xargs или опцию find -exec, можно выполнять необходимые действия с найденными файлами.

Давайте представим, что вы хотите сменить владельца каких-то файлов с root на www-data. Для начала нужно все эти файлы найти, а затем уж сменять их владельца. Смена владельца вручную по списку, полученному от find звучит как-то скучно. Всё же, лучшим решением будет использовать опцию -exec:

find -user root -exec chown www-data {} \;

Такая команда заставляет find передавать пути всех найденных файлов утилите chown, которая и будет изменять владельца файлов. Легко и просто!

Заключение

Знание возможностей утилиты find является обязательным для всех пользователей Linux, которые хотят освоить свою систему. Когда используется рабочий стол, вы можете обойтись без утилиты find, но при администрировании системы вам нужно иметь свои приемы применения утилиты find. Если вы собираетесь использовать параметры -exec и xargs для внесения изменений в файлы или удаления файлов, сначала сделайте один или пару тестов с тем, чтобы убедиться, что команда работает так, как ожидается.