Green-sell.info

Новые технологии
0 просмотров
Рейтинг статьи
1 звезда2 звезды3 звезды4 звезды5 звезд
Загрузка...

Write linux c

Write linux c

Количество записанных байт может быть меньше чем count если, например, недостаточно места на физическом носителе, или исчерпан отведённый лимит ресурса RLIMIT_FSIZE (см. setrlimit(2)), или вызов был прерван обработчиком сигналов после уже записанных меньше чем count байт. (См. также pipe(7).)

В случае с файлами, разрешающими позиционирование (т.е., к которым можно применить lseek(2), например, обычные файлы), запись производится по текущему файловому смещению, а смещение файла увеличивается на реальное число записанных байт. Если файл был открыт с помощью open(2) с аргументом O_APPEND, то перед записью файловое смещение устанавливается в конец файла. Согласование файлового смещения и операции записи выполняются атомарно.

По POSIX требуется, чтобы read(2), который может быть вызван сразу после write(), возвратил новые данные. Заметим, что не все файловые системы соответствуют стандарту POSIX.

ВОЗВРАЩАЕМОЕ ЗНАЧЕНИЕ

В случае ошибки возвращается -1 и значение errno устанавливается соответствующим образом.

Если count равен нулю и fd указывает на обычный файл, то write() может вернуть ошибку, если обнаружена одна из перечисленных ниже ошибок. Если ошибок не обнаружено или проверка ошибки не производилась, то возвращается 0 без каких-либо других последствий. Если count равен нулю и fd указывает на отличный от обычного файл, то результат не определён.

ОШИБКИ

В зависимости от объекта, на который указывает fd, могут происходить и другие ошибки.

СООТВЕТСТВИЕ СТАНДАРТАМ

Согласно SVr4, запись может быть прервана в любом месте (с возвратом EINTR), а не только перед тем как будут записаны какие-либо данные.

ЗАМЕЧАНИЯ

Если write() прерван обработчиком сигналов до начала записи, то вызов возвращает ошибку EINTR; если он прерван после начала записи, то вызов считается успешным, и возвращается число записанных байт.

В Linux write() (и похожие системные вызовы) передаст не больше 0x7ffff000 (2 147 479 552) байт, возвращая число байт, переданных на самом деле (это утверждение справедливо как к 32-битным, так и к 64-битным системам).

ДЕФЕКТЫ

Следующие функции должны выполняться атомарно по отношению друг к другу, чтобы работать с обычными файлами или символическими ссылками так, как указано в POSIX.1-2008: …

Среди перечисленных в программном интерфейсе есть write() и writev(2). И среди действий, которые должны выполняться атомарно между нитями (и процессами), если обновление файлового смещения. Однако в Linux до версии 3.14 это было не так: если два процесса с общим открытым файловым описанием (смотрите open(2)) выполняют write() (или writev(2)) одновременно, то операции ввода-вывода не атомарны при обновлении файлового смещения; в результате записанные двумя процессами блоки данных могут (некорректно) перекрываться. Эта ошибка исправлена в Linux 3.14.

TechyTalk

Thoughts on Magento, PHP, Linux and open source

Linux system programming: Open file, read file and write file

This is my first article in what I’m hoping will be a series of articles on system programming for POSIX compliant operating systems with focus on Linux. Actually I’ve touched this topic a while ago when I wrote three articles about library programming on Linux (static libraries, dynamic libraries and dynamic libraries using POSIX API). In this series my goal is to go trough basics of Linux system programming from the easiest topics like open file, read file and file write to a bit more complicated things like Berkeley sockets network programming. So lets get started with environment setup and an example of program that copies source file into destination file using POSIX API system calls to demonstrate open(), read() and write() system calls on Linux operating system.

Configuring your environment

I’ll use my trustworthy Ubuntu Linux operating system but you can actually use any POSIX compliant operating system, the only difference will probably be that you will need to configure your environment differently. What we need to begin with Linux system programming is gcc compiler with related packages and POSIX related man pages. So here’s how to install this packages on Ubuntu based operating system:

Basically that’s all you need to create serious system tools for Linux operating system. Later we will probably need some more libraries but we will install them when necessary.

open(), read() and write() system calls

If you have named this code file sp_linux_copy.c and if you want to name executable file sp_linux_copy to compile this program you would probably use something like this:

Then if your source file is named source_file.txt and if you want to name the destination file destination_file.txt you would run this program like this:

Now lets go trough the code and explain tricky parts. First thing we must do is to include necessary header files. Man page of every system call tells you what header files you need to include to be able to use this system call. Second we will define constant we will use to define size of our buffer in bytes. Smaller buffer size will make our copy process longer but it will save memory. Next we open source and destination file descriptors, source with O_RDONLY to make it read only, destination with O_WRONLY | O_CREAT to make it writable and to create destination file with 0644 file system permission flags. In case of error we use perror() man 3 perror to print relatively user friendly error message.

Now we are ready to start copy process. We run read() and write() inside loop (because source file might be bigger than our buffer) to copy from one file into another. Important to notice is that write() is using number of bytes read from source file returned by read() so it would know how much to write into destination file. If number of bytes read (ret_in) and number of bytes written (ret_out) differ this indicates error so once again we use perror() to print out error description. At the end if all went well we do cleanup by closing both file descriptors and returning 0 (EXIT_SUCCESS) to indicate that program ended without errors.

That’s it for this introductory article on Linux system programming topic. In my next article I will show you few more examples on POSIX input/output and then move on to memory management related system calls.

A quality focused Magento specialized web development agency. Get in touch!

Write linux c

Здравствуйте, уважаемые подписчики. В этом выпуске мы начинаем новую очень важную тему: низкоуровневый ввод-вывод в Linux.

Все вопросы, касающиеся рассылки или проекта Lindevel.Ru направляйте на мой новый адрес: nn@lindevel.ru или в форум на сайте Lindevel.Ru (http://www.lindevel.ru).

Читать еще:  Single mode linux

1. Низкоуровневый ввод/вывод

1.1. Что значит «низкоуровневый»?

До сих пор для чтения/записи файлов мы использовали библиотечный набор функций. Для языка C это были функции fopen(), fclose(), fputc(), fgetc(), fprintf(), printf() и т. д. В языке C++ мы пользовались поточными типами cout, cerr, cin, fstream, ifstream, ofstream и т. п. Все эти механизмы достаточно удобны и переносимы, однако как настоящие Linux-программисты мы должны понять, как же устроен механизм ввода/вывода в Linux (и в других Unix-системах), что скрывается за библиотечными интерфейсами.

За всем этим безобразием (читай: разнообразием) скрывается несколько системных вызовов. Как я уже объяснял, системные вызовы — это не простые функции, а механизмы, реализованные в ядре операционной системы. Мы уже знаем несколько системных вызовов, связанных с многозадачностью — это fork(), семейство exec () и семейство wait(). В этом выпуске мы научимся открывать, закрывать, читать и писать файлы, обращаясь непосредственно к ядру.

Непосредственное использование системных вызовов для работы с файлами в Linux — это и есть низкоуровневый ввод/вывод. Возникает логически обоснованный вопрос: зачем мне все это надо? Хочу заметить, что низкоуровневый ввод-вывод хорош не для всех программ. Есть ряд случаев, когда следует отказаться от системных вызовов в пользу библиотечных функций. Предлагаю рассмотреть преимущества и недостатки низкоуровневого ввода-вывода.

Преимущества

    Высокая скорость ввода-вывода.

Полезно, когда программа работает с большими файлами и/или с большим количеством файлов.

Отвечает стандарту POSIX.

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

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

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

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

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

Не смотря на то, что низкоуровневые механизмы ввода-вывода легко переносятся между Unix-системами, с другими ОС могут возникнуть проблемы. Не знаю точно, но скорее всего ОС $toomuch(TM) или MacOS(TM) спросят вас: «Что такое open() или write()?», если вы попытаетесь откомпилировать в них программу, использующую низкоуровневый ввод-вывод. Если вы хотите, чтобы программа работала везде, следует помнить о том, что не все операционные системы отвечают стандарту POSIX для системных вызовов.

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

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

1.2. Основные понятия

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

Файловый дескриптор (file descriptor)
Это целое знаковое число (int), используемое как аналог библиотечного указателя FILE*. Каждому открытому файлу операционная система назначает файловый дескриптор. Файловые дескрипторы, соответствующие реально открым файлам, больше или равны нулю. Каждый открытый файл имеет свой уникальный дескриптор. Понятие дескриптора привязано к процессу. Дочерний процесс наследует файловые дескрипторы своего родителя. Операционная система накладывает ограничения на количество открытых файлов для одного пользователя. Команда ulimit -n позволяет узнать это значение.

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

Режим записи файла
В отличие от флагов открытия, режимы записи определяют хорошо знакомые вам глобальные права доступа к файлу в пределах файловой системы (чтение, запись, выполнение, владельцы, пользователи, группы и проч. и проч.). Для установки режима записи файлов используется тип mode_t (заголовочный файл sys/stat.h в каталоге /usr/include или include/linux/stat.h в исходных кодах ядра Linux).

Позиция в файле
Использование позиций позволяет получать произвольный доступ к данным в файле. Для работы с позициями используется тип off_t (заголовочный файл /usr/include/sys/types.h или include/linux/types.h в исходных кодах ядра Linux). Следует заметить, что файлы, находящиеся на диске — это не память (RANDOM Access Memory) с реальным произвольным доступом. Частые перемещения внутри файла могут значительно снизить скорость выполнения вашей программы. Поэтому иногда (например, при многопроходном синтаксическом анализе или при сортировке) бывает выгоднее скопировать файл в память. Про то, как перемещаться по файлу будет рассказано в следующем выпуске рассылки.

1.3. Ввод, вывод и ошибки

В Unix-системах можно на пальцах пересчитать вещи, не являющиеся файлами. Стандартный ввод (stdin), стандартный вывод (stdout) и стандартный вывод для ошибок (stderr) — это тоже файлы. Теперь быстренько вспоминаем, что дочерний процесс наследует ВСЕ ОТКРЫТЫЕ файлы своего родителя. Если вы запускаете программу стандартным образом (например, из командной оболочки), то наследуете три открытых файла: стандартный ввод, стандартный вывод и стандартный поток для ошибок. По общепринятому соглашению эти файлы открыты под дескрипторами 0, 1 и 2 соответственно. То есть, запись в файл с дескриптором 2, например, значит вывод информации в стандартный поток ошибок. А что будет стандартным потоком ошибок — это уже вам решать. Любая нормальная командная оболочка располагает средствами для перенаправления стандартных потоков. Можете поэкспериментировать с принтером 🙂 Вот приблизительный рецепт для bash, если не жалко бумаги, чернил и нервов:

1.4. Обзор низкоуровневых системных вызовов ввода-вывода

В этом выпуске мы рассмотрим самые главные системные вызовы низкоуровневого ввода-вывода. Их четыре:

    int open (ИМЯ_ФАЙЛА, ФЛАГИ_ОТКРЫТИЯ) — для чтения
    int open (ИМЯ_ФАЙЛА, ФЛАГИ_ОТКРЫТИЯ, РЕЖИМ_ЗАПИСИ) — для чтения и/или записи.

Системный вызов open() открывает файл с указанными флагами открытия и указанным режимом записи. В случае успеха возвращается неотрицательный файловый дескриптор.

Флаги открытия представлены набором констант, которые можно объединять побитовым ИЛИ. Рассмотрим наиболее используемые флаги:
O_CREAT — создать файл, если не существует
O_RDWR — чтение + запись
O_WRONLY — только запись
O_RDONLY — только чтение
O_APPEND — запись в конец файла
O_TRUNC — перезапись существующего файла

Читать еще:  Mssql linux server

Полный список можно получить вот так:

Режимы записи также представляют собой набор констант, объединяемых при необходимости побитовым ИЛИ. Большинство из них можно записать в следующем формате:
S_I + +

S_IRUSR — пользователь может читать. Аналогично chmod u+r или chmod 400
S_IWOTH — остальные могут писАть. Аналогично chmod o+w или chmod 002
S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH — аналогично rw-r—r—

Полный список можно получить так:

Если файл открывается только для чтения, то последний аргумент можно опустить. И не говорите потом, что перегрузка функций есть только в C++ 🙂

int close (ДЕСКРИПТОР)

Системный вызов close() закрывает файл (освобождает дескриптор). При удачном завершении возвращается 0, при ошибке возвращается -1.

ssize_t read (ДЕСКРИПТОР, БУФЕР, КОЛИЧЕСТВО)

Системный вызов read() читает данные из файла в буфер (тип void*) указанное в последнем аргументе количество байт. При удачном считывании возвращает количество прочитанных байт, если достигнут конец файла — возвращается 0, а в случае ошибки возвращается -1.

int write (ДЕСКРИПТОР, БУФЕР, КОЛИЧЕСТВО)

write() записывает в файл определенное в третьем аргументе количество байт из буфера. Возвращает записанное количество байт, если все прошло удачно и -1, если произошла ошибка.

2. Примеры

2.1. Чтение из файла

2.2. Запись в файл

Заключение

Специально не буду проводить разбор полетов, потому что примеры очень простые. Кому еще не стало дурно от всех этих системных вызовов, советую поэкспериментировать с дескрипторами 0, 1 и 2. Посмотрите, что получится, если закрыть, например, файл с дескриптором 1 и т. д. Вопросы и пожелания направляйте в форум на Lindevel.Ru (http://www.lindevel.ru) или мне (nn@lindevel.ru).

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

Спасибо за внимание.
С наилучшими пожеланиями, Николай.

Файловые дескрипторы Linux

Основными операциями, предоставляемыми ядром операционной системы программам (а точнее — процессам) для работы с файлами, являются системные вызовы open read, write и close. В соответствии со своими именами, эти системные вызовы предназначены для открытия и закрытия файла, для чтения из файла и записи в файл. Дополнительный системный вызов ioctl (input output control) используется для управления драйверами устройств и, как следствие, применяется в основном для специальных файлов устройств.

При запросе процесса на открытие файла системным вызовом оpen производится его однократный (относительно медленный) поиск имени файла в дереве каталогов и для запросившего процесса создается так называемый файловый дескриптор (описатель, от англ, descriptor).

Файловый дескриптор «содержит» информацию, описывающую файл, например индексный дескриптор inode файла на файловой системе, номера major и minor устройства, на котором располагается файловая система файла, режим открытия файла, и прочую служебную информацию.

При последующих операциях read и write доступ к самим данным файла происходит с использованием файлового дескриптора (что исключает медленный поиск файла в дереве каталогов).

Файловые дескрипторы пронумерованы и содержатся в таблице открытых процессом файлов, которую можно получить при помощи диагностической программы lsof.

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

Таблица файловых дескрипторов

$ lsof -р $$

COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME

. . . . . . . . .
bash 17975 john 1u CHR 136,2 0t0 5 /dev/pts/2

# lsof /dev/log

COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME

rsyslogd 543 syslog 0u unix 0xefef5680 0t0 1338 /dev/log

# fuser /dev/log

/dev/log: 543
root@ubuntu:

# ps p 543

PID TTY STAT TIME COMMAND
543 ? Sl 0:43 rsyslogd -c5

# lsof /var/log/syslog

COMMAND PID USER FD TYPE DEVICE SIZE/OFF NODE NAME

rsyslogd 543 syslog lw REG 252,0 29039 26214496 /var/log/syslog

В первом примере из листинга выше показано получение списка файловых дескрипторов (столбец FD) процесса командного интерпретатора bash пользователя john, на котором файловый дескриптор номер 1 описывает открытый на чтение и запись и специальный символьный CHR файл устройства /dev/pts/2.

Во втором примере показано получение информации о процессе, открывшем файловый сокет unix с именем /dev/log (файловый дескриптор номер 0 на чтение и запись u) и обычный файл REG с именем /var/log/sysog (файловый дескриптор номер 1 на запись w).

Пронаблюдать за использованием системных вызовов файлового программного интерфейса в момент выполнения программам позволяет системный трассировщик strace.

Трассировка файлового программного интерфейса

$ date

Вт. окт. 15 18:17:42 MSK % 2018

$ strace -fe open, close, read, write, ioctl date

open(«/etc/localtime», 0_RDONLY|0_CLOEXEC) = 3

$ file /etc/localtime
/etc/localtime: timezone data, version 2, 13 gmt time flags, 13 std time flags, no leap

seconds, 77 transition tines, 13 abbreviation char
john@ubuntu:

$ ls -la /dev/dvd
lrwxrwxrwx 1 root root 3 окт. 16 18:09 /dev/dvd -> sr0

$ strace -fe open,close, read,write,ioctl eject

. . . . . . . . .
open(«/dev/sr0», O_RDWR|O_N0NBLOCK) = 3
ioctl(3, CDROMEJECT, 0x804cb4e) = 0
closed(3) = 0
john@ubuntu:

$ strace -fe open, read,write,close,ioctl setleds -L +num +scroll
ioctl(0, KDGKBLED, 0xbfe4f4ff) = 0
ioctl(0, KDGETLED, 0xbfe4f4fe) = 0
ioctl(0, KDSETLED, 0x3) = 0

Предположив, что программа date показывает правильное московское время, потому что узнаёт заданную временную зону MSK из некоего конфигурационного файла операционной системы, при трассировке ее «работы можно установить его точное имя — /etc/localtime.

Аналогично предположив, что программа eject открывает лоток привода CD/DVD при помощи специального файла устройства, при трассировке можно узнать имя файла /dev/sr0, номер файлового дескриптора при работе с файлом 3 и команду CDROMEJECT соответствующего устройству
драйвера ioctl_List.

Трассировка команды setleds показывает, что она вообще не открывает никаких файлов, но пользуется файловым дескриптором о так называемого стандартного потока ввода (прикрепленного, к текущему терминалу) и командами kdgetled и kdsetled драйвера консоли console_ioctl.

Работа с файловой системой Linux

Во время выполнения различных задач по администрированию системы может понадобится работать с файловой системой Linux, форматировать разделы, изменять их размер конвертировать файловые системы, может понадобиться дефрагментация в Linux или восстановление файловых систем. Многие из этих действий выполняются в графическом интерфейсе, многие и вовсе автоматически. Но может возникнуть ситуация, в которой придется делать все через терминал. Также при администрировании удаленных серверов работать с ними приходится только через ssh, а это означает недоступность графического интерфейса.

В этой статье мы рассмотрим как выполняется работа с файловой системой Linux в терминале. За основу возьмем семейство файловых систем ext2/3/4, так как они самые распространенные среди большого многообразия дистрибутивов Linux.

Основные команды

Для управления файловой системой ext в Linux используется целый набор команд из пакета e2progs. Сюда входят как команды для управления флагами файлов, создания и изменения файловых систем, так и утилиты для отладки файловой системы.

Читать еще:  Sql server management studio linux

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

  • badblocks — если у вас старый жесткий диск и на нем накопилось много битых блоков, вы можете с помощью этой утилиты пометить их все на уровне файловой системы, чтобы больше не использовать.
  • e2label — позволяет изменить метку раздела с файловой системой ext.
  • fsck — проверка файловой системы linux и исправление найденных ошибок
  • mkfs — позволяет создать файловую систему Linux.
  • resize2fs — изменить размер раздела с файловой системой
  • tune2fs — позволяет изменить файловую систему Linux, настроить ее параметры.

А теперь будет рассмотрена работа с файловой системой linux на примерах.

Работа с файловой системой в Linux

Перед тем как переходить к работе с реальным жестким диском важно попрактиковаться. Если сменить метку или проверить на битые сектора можно и рабочий диск, то создавать новую файловую систему, изменять ее размер, рискуя потерять данные на реальном диске не рекомендуется. Можно отделить небольшой раздел диска для экспериментов с помощью Gparted и выполнять все действия в нем. Допустим, у нас этот раздел будет называться /dev/sda6.

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

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

sudo mkfs -t тип устройство

Доступны дополнительные параметры:

  • — проверить устройство на наличие битых секторов
  • -b — размер блока файловой системы
  • -j — использовать журналирование для ext3
  • -L — задать метку раздела
  • -v — показать подробную информацию о процессе работы
  • -V — версия программы

Создаем файловую систему на нашем устройстве. Будем создавать ext3:

sudo mkfs -t ext4 -L root /dev/sda6

Creating filesystem with 7847168 4k blocks and 1962240 inodes

Filesystem UUID: 3ba3f7f5-1fb2-47af-b22c-fa4ca227744a
Superblock backups stored on blocks:
32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632, 2654208,
4096000

Allocating group tables: done
Writing inode tables: done
Creating journal (32768 blocks): done
Writing superblocks and filesystem accounting information: done

Изменение метки файловой системы

Утилита e2label позволяет изменить или посмотреть метку раздела диска. Принимает всего два параметра — устройство и новую метку если нужно.

sudo e2label /dev/sda6

sudo e2label /dev/sda6 root1

Настройка файловой системы linux

Различные параметры файловой системы, такие как размер блока данных, иноды или зарезервированное место под данные пользователя root можно настроить. Для этого существует утилита tune2fs.

Синтаксис команды очень прост:

$ tune2fs опции устройство

Поддерживаются следующие опции:

  • -j — создать файл журнала. Позволяет превратить файловую систему ext2 в ext3.
  • -J — настроить параметры журнала
  • -l — получить содержимое суперблока
  • -L — изменить метку раздела
  • -m — изменить процент дискового пространства, зарезервированного для суперпользователя
  • -M — изменить последнюю папку монтирования
  • -U — задать UUID файловой системы
  • -C — изменить значение счетчика монтирования
  • -T — изменить последнюю дату проверки файловой системы
  • — изменить периодичность проверок файловой системы с помощью fsck
  • -O — изменить опции файловой системы.

Изменить размер зарезервированного места для суперпользователя до пяти процентов:

sudo tune2fs -m 5 /dev/sda6

Setting reserved blocks percentage to 5% (392358 blocks)

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

Filesystem volume name: root
Last mounted on: /
Filesystem UUID: 3ba3f7f5-1fb2-47af-b22c-fa4ca227744a
Filesystem magic number: 0xEF53
Filesystem revision #: 1 (dynamic)
Filesystem features: has_journal ext_attr resize_inode dir_index filetype extent flex_bg spar
se_super large_file huge_file uninit_bg dir_nlink extra_isize
Filesystem flags: signed_directory_hash
Default mount options: user_xattr acl
Filesystem state: clean
Errors behavior: Continue
Filesystem OS type: Linux

Изменить счетчик количества монитрований:

tune2fs -C 0 /dev/sda6

Setting current mount count to 0

Думаю тут смысл понятен, нужно только немного со всем этим поэкспериментировать.

С помощью опции -O мы вообще можем превратить нашу ext3 в ext4 следующей командой:

sudo tune2fs -O extents,uninit_bg,dir_index

После этого действия нужно выполнить проверку файловой системы на ошибки в fsck. Подробнее об этом поговорим ниже.

sudo fsck -np /dev/sda6

Таким образом вы можете изменить файловую систему linux, и настроить по своему усмотрению любые ее параметры.

Изменение размера файловой системы Linux

Раньше такая функция поддерживалась в утилите parted, но потом ее убрали и для этого действия приходится использовать утилиту из набора e2fsprogs — resize2fs.

Запустить утилиту очень просто. Ей нужно передать всего два параметра:

$ resize2fs [опции] устройство размер

Доступны также опции:

  • -M уменьшить файловую систему до минимального размера
  • -f — принудительное изменение, не смотря на потерю данных
  • -F — очистить буфер файловой системы

Размер передается, как и во многих других утилитах, целым числом с указанием единиц измерения, например, 100М или 1G.

Для примера уменьшим размер нашего раздела до 400 Мегабайт:

sudo resize2fs /dev/sda6 400M

Resizing the filesystem on /dev/sda7 to 102400 (4k) blocks.
The filesystem on /dev/sda7 is now 102400 blocks long

Проверка файловой системы Linux

При неправильном отключении носителей или неожиданном отключении питания, файловая система Linux может быть повреждена. Обычно проверка корневой файловой системы и домашнего каталога на ошибки выполняется во время загрузки. Но если эта проверка не была выполнена или нужно поверить другой носитель, придется все делать вручную. Для этого есть утилита fsck.

$ fsck [опции] устройство

  • -p — автоматическое восстановление
  • -n — только проверка, без восстановления
  • -y — ответить да на все запросы программы
  • — проверить на битые сектора (аналог badblocks
  • -f — принудительная проверка, даже если раздел помечен как чистый
  • -j — внешний журнал файловой системы

Проверка файловой системы Linux выполняется такой командой, проверим диск /dev/sda6, заметьте, что диск должен быть не примонтирован:

sudo fsck -a /dev/sda6

root: clean, 11/32704 files, 37901/102400 blocks

Дефрагментация файловой системы

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

Чтобы проверить нужна ли дефрагментация в Linux выполните эту же команду с опцией -c:

Total/best extents 26247/24953
Average size per extent 1432 KB
Fragmentation score 0
[0-30 no problem: 31-55 a little bit fragmented: 56- needs defrag]
This device (/dev/sda6) does not need defragmentation.
Done.

В поле Fragmentation score отображен процент фрагментации, как видите, у меня 0, нормой считается до 30, 31-55 небольшие проблемы, и больше 56 — нужна дефрагментация.

Выводы

В одной из предыдущих статей мы рассмотрели как выполняется разметка диска с помощью parted. Из этой статьи вы узнали все что нужно о работе с файловой системой. Теперь у вас не возникнет проблем если у вас вдруг не будет доступа к графическим утилитам и нужно будет исправлять ошибки или настраивать файловую систему. Если остались вопросы, спрашивайте в комментариях!

Ссылка на основную публикацию
ВсеИнструменты
Adblock
detector