How to open dump file linux

Linux dump резервное копирование и восстановление

Для системного администратора самой трудоёмкой, скрупулёзной и ответственной работой является (что непрерывно подтверждается практикой) не установка и наладка систем, программного обеспечения и т. д., а организация и проведение процедуры резервного копирования системы. Даже небольшие организации располагают своими, пусть и небольшими, но локальными сетями, обслуживаемыми серверами. Это позволяет значительно упростить и ускорить (при грамотном подходе, конечно) рутинную работу по специфике деятельности всей организации. Потеря информации, хранящейся даже в таких сетях и даже для небольших организаций, предприятий (или даже офиса) — в большинстве случаев наносит трудно поправимый ущерб с длительным и дорогостоящим восстановлением. Чего уж говорить о гигантских компаниях или корпорациях. В подавляющем большинстве случаев потеря информации стоит гораздо дороже, чем само оборудование.

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

Использование команды dump

Утилита dump обладает рядом особенностей, благодаря чему многие системные администраторы используют именно её для резервного копирования данных:

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

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

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

Кстати, утилита dump также уверенно работает с именами файлов произвольной длины, т. е. ей абсолютно не важна глубина иерархии каталогов файловой системы.

Создание резервных копий

Команда dump сканирует файл /etc/dumpdates на предмет того, как давно создавался последний архив. С помощью ключа -u можно заставить dump самостоятельно после завершения резервного копирования обновлять вышеуказанный файл, занося в него информацию о дате, имени файловой системы и уровне архива. Без использования ключа -u (если он вообще ни разу не использовался) все архивы будут иметь нулевой уровень.

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

Итак, для создания резервной копии утилитой dump нужно дать следующую команду:

Или для варианта с ленточным носителем:

Здесь с ключом -u задаётся нулевой уровень архива (0), а ключом -f – устройство /dev/sdd1 для сохранения резервной копии файловой системы /home. Удалённый носитель (во втором примере ленточный носитель nst0) задаётся в формате имя_компьютера:устройство.

Восстановление файлов из резервных архивов

Чтобы восстановить отдельные файлы из резервных копий, следует воспользоваться командой restore. Эта команда обладает большим набором опций для выполнения. Среди которых одной из самых важных является -i – этот ключ позволяет работать с восстановлением в интерактивном режиме. Также имеются опции -r – для восстановления файловой системы целиком. И -x – для автоматического восстановления заранее указанных файлов.

В интерактивном режиме (ключ -i) команда restore сначала читает состав содержимого архива, после чего даёт возможность пользователю перемещаться по этому содержимому как по дереву каталогов в файловой системе, используя команды cd, ls и pwd. Чтобы восстановить требуемые файлы, нужно сначала добавить их в список восстановления командой add. Для восстановления выбранных (добавленных в список восстановления) файлов нужно выполнить команду extract. Также можно удалять файлы из списка восстановления — командой delete. Пример:

В приведённом примере показан наиболее общий и «суровый» случай, когда нужно восстановить архив с удалённого ленточного носителя по SSH. Здесь также используется перемотка ленты командой mt для перехода к нужному архиву — это тот случай, когда на одной ленте их несколько. В качестве параметров команде mt передаются: удаленное устройство и параметры перемотки — fsf 3, т. е. лента должна быть перемотана вперёд на 3 файла. Если архив умещается на одной ленте, то на запрос «Specify next volume #:» нужно ввести 1. Также нужно определить, должен ли текущий каталог соответствовать корневому каталогу текущей ленты и если восстанавливается не вся файловая система целиком, то можно ответить «n» — нет. Восстановление производится в текущий каталог /var/restore.

Если вы нашли ошибку, пожалуйста, выделите фрагмент текста и нажмите Ctrl+Enter.

Источник

Julia Evans

This week at work I spent all week trying to debug a segfault. I’d never done this before, and some of the basic things involved (get a core dump! find the line number that segfaulted!) took me a long time to figure out. So here’s a blog post explaining how to do those things!

At the end of this blog post, you should know how to go from “oh no my program is segfaulting and I have no idea what is happening” to “well I know what its stack / line number was when it segfaulted, at least!“.

what’s a segfault?

A “segmentation fault” is when your program tries to access memory that it’s not allowed to access, or tries to . This can be caused by:

• trying to dereference a null pointer (you’re not allowed to access the memory address 0 )
• trying to dereference some other pointer that isn’t in your memory
• a C++ vtable pointer that got corrupted and is pointing to the wrong place, which causes the program to try to execute some memory that isn’t executable
• some other things that I don’t understand, like I think misaligned memory accesses can also segfault

This “C++ vtable pointer” thing is what was happening to my segfaulting program. I might explain that in a future blog post because I didn’t know any C++ at the beginning of this week and this vtable lookup thing was a new way for a program to segfault that I didn’t know about.

But! This blog post isn’t about C++ bugs. Let’s talk about the basics, like, how do we even get a core dump?

step 1: run valgrind

I found the easiest way to figure out why my program is segfaulting was to use valgrind: I ran

and this gave me a stack trace of what happened. Neat!

But I also wanted to do a more in-depth investigation and find out more than just what valgrind was telling me! So I wanted to get a core dump and explore it.

How to get a core dump

A core dump is a copy of your program’s memory, and it’s useful when you’re trying to debug what went wrong with your problematic program.

When your program segfaults, the Linux kernel will sometimes write a core dump to disk. When I originally tried to get a core dump, I was pretty frustrated for a long time because – Linux wasn’t writing a core dump!! Where was my core dump.

Here’s what I ended up doing:

1. Run ulimit -c unlimited before starting my program
2. Run sudo sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t

ulimit: set the max size of a core dump

ulimit -c sets the maximum size of a core dump. It’s often set to 0, which means that the kernel won’t write core dumps at all. It’s in kilobytes. ulimits are per process – you can see a process’s limits by running cat /proc/PID/limit

For example these are the limits for a random Firefox process on my system:

The kernel uses the soft limit (in this case, “max core file size = 0”) when deciding how big of a core file to write. You can increase the soft limit up to the hard limit using the ulimit shell builtin ( ulimit -c unlimited !)

kernel.core_pattern: where core dumps are written

kernel.core_pattern is a kernel parameter or a “sysctl setting” that controls where the Linux kernel writes core dumps to disk.

Kernel parameters are a way to set global settings on your system. You can get a list of every kernel parameter by running sysctl -a , or use sysctl kernel.core_pattern to look at the kernel.core_pattern setting specifically.

So sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t will write core dumps to /tmp/core-

If you want to know more about what these %e , %p parameters read, see man core.

It’s important to know that kernel.core_pattern is a global settings – it’s good to be a little careful about changing it because it’s possible that other systems depend on it being set a certain way.

kernel.core_pattern & Ubuntu

By default on Ubuntu systems, this is what kernel.core_pattern is set to

This caused me a lot of confusion (what is this apport thing and what is it doing with my core dumps??) so here’s what I learned about this:

• Ubuntu uses a system called “apport” to report crashes in apt packages
• Setting kernel.core_pattern=|/usr/share/apport/apport %p %s %c %d %P means that core dumps will be piped to apport
• apport has logs in /var/log/apport.log
• apport by default will ignore crashes from binaries that aren’t part of an Ubuntu packages

I ended up just overriding this Apport business and setting kernel.core_pattern to sysctl -w kernel.core_pattern=/tmp/core-%e.%p.%h.%t because I was on a dev machine, I didn’t care whether Apport was working on not, and I didn’t feel like trying to convince Apport to give me my core dumps.

So you have a core dump. Now what?

Okay, now we know about ulimits and kernel.core_pattern and you have actually have a core dump file on disk in /tmp . Amazing! Now what. We still don’t know why the program segfaulted!

The next step is to open the core file with gdb and get a backtrace.

Getting a backtrace from gdb

You can open a core file with gdb like this:

Next, we want to know what the stack was when the program crashed. Running bt at the gdb prompt will give you a backtrace. In my case gdb hadn’t loaded symbols for the binary, so it was just like . . Luckily, loading symbols fixed it.

Here’s how to load debugging symbols.

This loads symbols from the binary and from any shared libraries the binary uses. Once I did that, gdb gave me a beautiful stack trace with line numbers when I ran bt .

If you want this to work, the binary should be compiled with debugging symbols. Having line numbers in your stack traces is extremely helpful when trying to figure out why a program crashed 🙂

look at the stack for every thread

Here’s how to get the stack for every thread in gdb!

gdb + core dumps = amazing

If you have a core dump & debugging symbols and gdb, you are in an amazing situation!! You can go up and down the call stack, print out variables, and poke around in memory to see what happened. It’s the best.

If you are still working on being a gdb wizard, you can also just print out the stack trace with bt and that’s okay 🙂

Another path to figuring out your segfault is to do one compile the program with AddressSanitizer (“ASAN”) ( $CC -fsanitize=address ) and run it. I’m not going to discuss that in this post because this is already pretty long and anyway in my case the segfault disappeared with ASAN turned on for some reason, possibly because the ASAN build used a different memory allocator (system malloc instead of tcmalloc).

I might write about ASAN more in the future if I ever get it to work 🙂

getting a stack trace from a core dump is pretty approachable!

This blog post sounds like a lot and I was pretty confused when I was doing it but really there aren’t all that many steps to getting a stack trace out of a segfaulting program:

if that doesn’t work, or if you want to have a core dump to investigate:

1. make sure the binary is compiled with debugging symbols
2. set ulimit and kernel.core_pattern correctly
3. run the program
4. open your core dump with gdb , load the symbols, and run bt
5. try to figure out what happened!!

I was able using gdb to figure out that there was a C++ vtable entry that is pointing to some corrupt memory, which was somewhat helpful and helped me feel like I understood C++ a bit better. Maybe we’ll talk more about how to use gdb to figure things out another day!

You might also like the Recurse Center, my very favorite programming community (my posts about it)

Источник

команда dump в Linux с примерами

Команда dump в Linux используется для резервного копирования файловой системы на какое-либо устройство хранения. Это резервное копирование всей файловой системы, а не отдельных файлов. Другими словами, он создает резервные копии необходимых файлов на ленту, диск или любое другое устройство хранения для безопасного хранения. Команда dump в Linux работает только с файловой системой ext2 / ext3, а не с другими, такими как FAT и ReiserFS. Особенностью дампа является то, что он позволяет инкрементное резервное копирование. Инкрементное резервное копирование означает, что пользователь может настроить план резервного копирования, в соответствии с которым файловые системы будут резервироваться еженедельно, или будут копироваться только те файлы, которые были изменены или добавлены недавно.

Синтаксис:

dump [-level#] [-a autosize] [-A file] [-B records] [-b blocksize]
[-d density] [-D file] [-e inode numbers] [-E file] [-f file]
[-F script] [-h level] [-I nr errors] [-jcompression level] [-L label]
[-Q file] [-s feet] [-T date] [-y] [-zcompression level] files-to-dump
dump [-W | -w]

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

Параметры:

• -уровень #: уровень дампа, который является целым числом в диапазоне от 0 до 9. Если пользователь попросил выполнить полное резервное копирование или резервное копирование только тех новых файлов, которые были добавлены после последнего дампа более низкого уровня.
• — f file: указывает файл, в который будет записана резервная копия. Файл может быть ленточным накопителем, дискетой, обычным файлом или стандартным выводом.
• -u: записывает и обновляет резервную копию в файле / etc / dumpdates .

-B records: отображает количество записей дампа на тома. Другими словами, он показывает объем данных, который может поместиться на ленте. Это не всегда требуется, так как DUMP может обнаружить конец носителя или хранилища. Это принимает числовое значение и используется в сочетании с -b (упомянуто ниже).

-b blocksize: размер блока указывает количество килобайт на запись дампа. По умолчанию размер блока равен 10 . Обратите внимание, что в 4-й строке DUMP размер блока равен 20 вместо 10.

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

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

-z уровень сжатия: сжимает каждый блок для записи на ленту с использованием библиотеки zlib. Уровень сжатия по умолчанию равен 2.

S: Оценивает размер еще до того, как это сделает. Выводом является приблизительное количество байтов, которые займет дамп. Это полезно в случае добавочных дампов, чтобы определить, сколько томов носителя будет использоваться.

-I nr error: по умолчанию дамп игнорирует первые 32 ошибки чтения. Это значение можно вручную изменить на любое значение по выбору пользователя.

Некоторые другие параметры (которые используются реже):

• — Архивный_файл: архивирует оглавление в указанный архивный_файл.
• -d плотность: устанавливает плотность ленты. Он принимает числовой аргумент, и его значение по умолчанию составляет 1600 бит на дюйм.
• -n: Когда есть некоторые изменения в ленте или есть некоторые другие изменения, дамп отправляет сообщение пользователю. Эта опция не имеет аргументов.
• -s футов: это указывает длину ленты дампа в футах. Это принимает числовой аргумент.
• -t дата: указывает запись даты и времени, в соответствии с которой выполняется инкрементное резервное копирование. Любые изменения или дополнения после указанного времени будут сохранены.

Источник