Capítulo 9. Dicas do sistema

# Capítulo 9. Dicas do sistema

Aqui, descrevo dicas básicas para configurar e gerir sistemas, a maioria a partir da consola.

## 9.1. As dicas da consola

Existem alguns programas utilitários para ajudar as atividades da consola.

Tabela 9.1. Lista de programas de apoio às atividades da consola

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`mc` | V:41, I:182 | 1590 | Veja Seção 1.3, “Midnight Commander (MC)”
`bsdutils` | V:443, I:999 | 334 | script(1) comando para fazer um registo da sessão de terminal
`screen` | V:52, I:200 | 991 | terminal multiplexador com emulação de terminal VT100/ANSI
`tmux` | V:94, I:162 | 1291 | multiplexador alternativo de terminal (Use "Control-B" em vez disto)
`ripgrep` | V:14, I:42 | 5294 | pesquisa rápida e recursiva de cadeias de caracteres na árvore de código-fonte com filtragem automática
`fzf` | V:8, I:35 | 4983 | localizador de texto difuso
`fzy` | V:0.08, I:0.36 | 59 | localizador de texto difuso
`rlwrap` | V:1, I:12 | 328 | funcionalidade de revestimento e histórico da linha de comando
`ledit` | V:0.5, I:7.7 | 375 | funcionalidade de revestimento e histórico da linha de comando
`rlfe` | V:0.04, I:0.49 | 45 | funcionalidade de revestimento e histórico da linha de comando

### 9.1.1. Gravar as atividades da shell de modo limpo

O uso simples de script(1) (veja Seção 1.4.9, “Gravar as atividades da shell”) para gravar a atividade da shell produz um ficheiro com caracteres de controle. Isto pode ser evitado ao usar o col(1) como o seguinte.

    $ script
    Script started, file is typescript

Faça o que tem a fazer ... e carregue em `Ctrl-D` para terminar o `script`.

    $ col -bx < typescript > cleanedfile
    $ vim cleanedfile

Existem métodos alternativos para registar as atividades da shell:

- Use `tee` (utilizável durante o processo de arranque no initramfs):

      $ sh -i 2>&1 | tee typescript

- Use o `gnome-terminal` com a memória intermédia de linha estendida para conseguir rolar para trás.

- Utilize o `ecrã` com "`^A H`" (ver Seção 9.1.2, “O programa screen”) para efetuar a gravação da consola.

- Utilize o `vim` com "`:terminal`" para entrar no modo de terminal. Use "`Ctrl-W N`" para sair do modo terminal para o modo normal. Utilize "`:w typescript`" para escrever a memória intermédia num ficheiro.

- Use o `emacs` com "`M-x shell`", "`M-x eshell`", ou "`M-x term`" para entrar na consola de gravação. Use"`C-x C-w`" para escrever a memória intermédia para um ficheiro.

### 9.1.2. O programa screen

O screen(1) não apenas permite que uma janela terminal funcione com múltiplos processos, mas também permite que os processos de shell remota sobrevivam a ligações interrompidas. Aqui está um cenário típico de utilização do screen(1).

1. Faz login numa máquina remota.

2. Arranca o `screen` numa consola única.

3. Executa múltiplos programas na janela criada do `screen` com `^A c` ("Ctrl-A" seguido de "c").

4. Muda entre as múltiplas janelas do `screen` com `^A n` ("Ctrl-A" seguido de "n").

5. Subitamente precisa de abandonar o seu terminal, mas não quer perder o seu trabalho ativo a manter a ligação.

6. Pode separar a sessão do `screen` por quaisquer métodos.

   - Desligar a sua ligação de rede à bruta

   - Escrever `^A d` ("Ctrl-A" seguido de "d") e manualmente terminar a sessão da ligação remota

   - Escrever `^A DD` ("Ctrl-A" seguido de "DD") para separar o `screen` e terminar a sua sessão

7. Faz login de novo à mesma máquina remota (mesmo a partir de um terminal diferente).

8. Inicia o `screen` como "`screen -r`".

9. O `screen` magicamente reagrupa todas as janelas `screen` anteriores com todos os programas a funcionar activamente.

| Dica
Pode poupar despesas de ligação com o `screen` em ligações de rede medidas 'a metro' como as dial-up, porque pode deixar um processo ativo enquanto desligado e depois lhe re-ligar-se mais tarde quando ligar de novo.

Numa sessão do `screen`, todas as entradas do teclado são enviadas à sua janela atual excepto as teclas de comandos. Todas as teclas de comando do `screen` são inseridas ao escrever `^A` ("Control-A") mais uma única tecla [mais quaisquer parâmetros]. Aqui estão alguns importantes para fazer lembrar.

Tabela 9.2. Lista de ligações de teclas para o screen

tecla de atalho | significado
--- | ---
`^A ?` | mostra um écran de ajuda (mostra as teclas de atalho)
`^A c` | cria uma nova janela e muda para lá
`^A n` | vai à janela seguinte
`^A p` | vai à janela anterior
`^A 0` | vaia à janela número 0
`^A 1` | vai à janela número 1
`^A w` | mostra uma lista de janelas
`^A a` | envia Ctrl-A à janela atual como entrada do teclado
`^A h` | escreve uma cópia física da janela atual para um ficheiro
`^A H` | inicia/termina o registo da janela atual para um ficheiro
`^A ^X` | bloqueia o terminal (protegido por palavra-passe)
`^A d` | separa a sessão do ecrã do terminal
`^A DD` | separa a sessão do ecrã e termina a sessão

Veja screen(1) para detalhes.

Veja tmux(1) para as funcionalidades do comando alternativo.

### 9.1.3. Navegando nos diretórios

Em Seção 1.4.2, “Personalizar bash”, são descritas 2 dicas para permitir uma navegação rápida pelos diretórios: `$CDPATH` e `mc`.

Se utilizar o programa de filtragem de texto fuzzy, pode fazê-lo sem escrever o caminho exato. Para o `fzf`, inclua o seguinte em `~/.bashrc`.

    FZF_KEYBINDINGS_PATH=/usr/share/doc/fzf/examples/key-bindings.bash
    if [ -f $FZF_KEYBINDINGS_PATH ]; then
      . $FZF_KEYBINDINGS_PATH
    fi

Por exemplo:

- Pode saltar para um sub-diretório muito profundo com esforço mínimo. Primeiro, escreva "`cd **`" e prima `Tab`. Em seguida, ser-lhe-ão solicitados os caminhos candidatos. Escrever uma sequência de caminhos parciais, ex, `s/d/b foo`, irá reduzir os caminhos candidatos. Você seleciona o caminho a ser utilizado por `cd` com o cursor e as teclas de retorno.

- É possível selecionar um comando do histórico de comandos de forma mais eficiente e com o mínimo de esforço. Prima `Ctrl-R` na linha de comandos. Em seguida, ser-lhe-ão apresentados os comandos candidatos. Escrever cadeias de comandos parciais, e.g., `vim d`, irá reduzir os candidatos. Seleciona o comando a ser utilizado com as teclas de cursor e de retorno.

### 9.1.4. Revestimento da linha de leitura

Alguns comandos, como o `/usr/bin/dash`, que não tem capacidade de edição do histórico da linha de comandos, podem adicionar essa funcionalidade de forma transparente ao serem executados sob o `rlwrap` ou seus equivalentes.

     $ rlwrap dash -i

Isto fornece uma plataforma conveniente para testar pontos subtis para `dash` com um ambiente amigável semelhante ao `bash`.

### 9.1.5. Verificação da árvore de código-fonte

O comando rg(1) do pacote `ripgrep` oferece uma alternativa mais rápida ao comando grep(1) para varrer a árvore de código-fonte em situações típicas. Ele tira vantagem das modernas CPUs multi-core e automaticamente aplica filtros razoáveis para pular alguns arquivos.

## 9.2. Personalizar o vim

Depois de aprender as noções básicas do vim(1) através do Seção 1.4.8, “Utilizando o vim”, por favor leia o livro de Bram Moolenaar "Seven habits of effective text editing (2000)" para compreender como o `vim` deve ser utilizado.

### 9.2.1. Personalizando o vim com recursos internos

O comportamento do `vim` pode ser alterado significativamente ativando as suas caraterísticas internas através dos comandos do modo `Ex` tais como "`set ...`" para definir as opções do vim.

Estes comandos em modo `Ex` podem ser incluídos no ficheiro vimrc do utilizador, no tradicional "`~/.vimrc`" ou no git-friendly "`~/.vim/vimrc`". Aqui está um exemplo muito simples [2]:

    """ Generic baseline Vim and Neovim configuration (~/.vimrc)
    """   - For NeoVim, use "nvim -u ~/.vimrc [filename]"
    """""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    let mapleader = ' '             " :h mapleader
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    set nocompatible                " :h 'cp -- sensible (n)vim mode
    syntax on                       " :h :syn-on
    filetype plugin indent on       " :h :filetype-overview
    set encoding=utf-8              " :h 'enc (default: latin1) -- sensible encoding
    """ current vim option value can be verified by :set encoding?
    set backspace=indent,eol,start  " :h 'bs (default: nobs) -- sensible BS
    set statusline=%<%f%m%r%h%w%=%y[U+%04B]%2l/%2L=%P,%2c%V
    set listchars=eol:¶,tab:⇄\ ,extends:↦,precedes:↤,nbsp:␣
    set viminfo=!,'100,<5000,s100,h " :h 'vi -- bigger copy buffer etc.
    """ Pick "colorscheme" from blue darkblue default delek desert elflord evening
    """ habamax industry koehler lunaperche morning murphy pablo peachpuff quiet ron
    """ shine slate torte zellner
    colorscheme industry
    """ don't pick "colorscheme" as "default" which may kill SpellUnderline settings
    set scrolloff=5                 " :h 'scr -- show 5 lines around cursor
    set laststatus=2                " :h 'ls (default 1)  k
    """ boolean options can be unset by prefixing "no"
    set ignorecase                  " :h 'ic
    set smartcase                   " :h 'scs
    set autoindent                  " :h 'ai
    set smartindent                 " :h 'si
    set nowrap                      " :h 'wrap
    "set list                        " :h 'list (default nolist)
    set noerrorbells                " :h 'eb
    set novisualbell                " :h 'vb
    set t_vb=                       " :h 't_vb -- termcap visual bell
    set spell                       " :h 'spell
    set spelllang=en_us,cjk         " :h 'spl -- english spell, ignore CJK
    set clipboard=unnamedplus       " :h 'cb -- cut/copy/paste with other app
    set hidden                      " :h 'hid
    set autowrite                   " :h 'aw
    set timeoutlen=300              " :h 'tm

O mapa de teclas do `vim` pode ser alterado no ficheiro vimrc do utilizador. Por exemplo:

| Cuidado
Não tente alterar os atalhos de teclas predefinidos sem ter boas razões para o fazer.

    """ Popular mappings (imitating LazyVim etc.)
    """ Window moves without using CTRL-W which is dangerous in INSERT mode
    nnoremap <C-H> <C-W>h
    nnoremap <C-J> <C-W>j
    nnoremap <C-K> <C-W>k
    silent! nnoremap <C-L> <C-W>l
    """ Window resize
    nnoremap <C-LEFT> <CMD>vertical resize -2<CR>
    nnoremap <C-DOWN> <CMD>resize -2<CR>
    nnoremap <C-UP> <CMD>resize +2<CR>
    nnoremap <C-RIGHT> <CMD>vertical resize +2<CR>
    """ Clear hlsearch with <ESC> (<C-L> is mapped as above)
    nnoremap <ESC> <CMD>noh<CR><ESC>
    inoremap <ESC> <CMD>noh<CR><ESC>
    """ center after jump next
    nnoremap n nzz
    nnoremap N Nzz
    """ fast "jk" to get out of INSERT mode (<ESC>)
    inoremap  jk <CMD>noh<CR><ESC>
    """ fast "<ESC><ESC>" to get out of TERM mode (CTRL-\ CTRL-N)
    tnoremap <ESC><ESC> <C-\><C-N>
    """ fast "jk" to get out of TERM mode (CTRL-\ CTRL-N)
    tnoremap jk <C-\><C-N>
    """ previous/next trouble/quickfix item
    nnoremap [q <CMD>cprevious<CR>
    nnoremap ]q <CMD>cnext<CR>
    """ buffers
    nnoremap <S-H> <CMD>bprevious<CR>
    nnoremap <S-L> <CMD>bnext<CR>
    nnoremap [b <CMD>bprevious<CR>
    nnoremap ]b <CMD>bnext<CR>
    """ Add undo break-points
    inoremap  , ,<C-G>u
    inoremap  . .<C-G>u
    inoremap  ; ;<C-G>u
    """ save file
    inoremap <C-S> <CMD>w<CR><ESC>
    xnoremap <C-S> <CMD>w<CR><ESC>
    nnoremap <C-S> <CMD>w<CR><ESC>
    snoremap <C-S> <CMD>w<CR><ESC>
    """ better indenting
    vnoremap < <gv
    vnoremap > >gv
    """ terminal (Somehow under Linux, <C-/> becomes <C-_> in Vim)
    nnoremap <C-_> <CMD>terminal<CR>
    "nnoremap <C-/> <CMD>terminal<CR>
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    if ! has('nvim')
    """ Toggle paste mode with <SPACE>p for Vim (no need for Nvim)
    set pastetoggle=<leader>p
    """ nvim default mappings for Vim.  See :h default-mappings in nvim
    """ copy to EOL (no delete) like D for d
    noremap Y y$
    """ sets a new undo point before deleting
    inoremap <C-U> <C-G>u<C-U>
    inoremap <C-W> <C-G>u<C-W>
    """ <C-L> is re-purposed as above
    """ execute the previous macro recorded with Q
    nnoremap Q @@
    """ repeat last substitute and *KEEP* flags
    nnoremap & :&&<CR>
    """ search visual selected string for visual mode
    xnoremap * y/\V<C-R>"<CR>
    xnoremap # y?\V<C-R>"<CR>
    endif

Para que as combinações de teclas acima funcionem corretamente, o programa do terminal tem de ser configurado para gerar "ASCII DEL" para a tecla `Backspace` e "Escape sequence" para a tecla `Delete`.

Outras configurações diversas podem ser alteradas no ficheiro vimrc do utilizador. Por exemplo:

    """ Use faster 'rg' (ripgrep package) for :grep
    if executable("rg")
      set grepprg=rg\ --vimgrep\ --smart-case
      set grepformat=%f:%l:%c:%m
    endif
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    """ Retain last cursor position :h '"
    augroup RetainLastCursorPosition
      autocmd!
      autocmd BufReadPost *
        \ if line("'\"") > 0 && line ("'\"") <= line("$") |
        \   exe "normal! g'\"" |
        \ endif
    augroup END
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    """ Force to use underline for spell check results
    augroup SpellUnderline
      autocmd!
      autocmd ColorScheme * highlight SpellBad term=Underline gui=Undercurl
      autocmd ColorScheme * highlight SpellCap term=Underline gui=Undercurl
      autocmd ColorScheme * highlight SpellLocal term=Underline gui=Undercurl
      autocmd ColorScheme * highlight SpellRare term=Underline gui=Undercurl
    augroup END
    """"""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""""
    """ highlight tailing spaces except when typing as red (set after colorscheme)
    highlight TailingWhitespaces ctermbg=red guibg=red
    """ \s\+     1 or more whitespace character: <Space> and <Tab>
    """ \%#\@<!  Matches with zero width if the cursor position does NOT match.
    match TailingWhitespaces /\s\+\%#\@<!$/

### 9.2.2. Personalizando o vim com pacotes externos

Podem ser encontrados pacotes de plug-ins externos interessantes:

- Vim - o editor de texto ubíquo -- O site oficial do Vim e dos scripts vim

- VimAwsome -- A listagem de plugins Vim

- vim-scripts -- Pacote Debian: uma coleção de scripts vim

Os pacotes de plugins no pacote vim-scripts podem ser ativados usando o ficheiro vimrc do utilizador. Por exemplo:

    packadd! secure-modelines
    packadd! winmanager
    " IDE-like UI for files and buffers with <space>w
    nnoremap <leader>w         :WMToggle<CR>

O novo sistema de pacotes nativo do Vim funciona muito bem com "`git`" e "`git submodule`". Um exemplo de configuração pode ser encontrado no meu repositório git: dot-vim. Isto faz essencialmente o seguinte:

- Ao utilizar "`git`" e "`git submodule`", os pacotes externos mais recentes, tais como "`name`", são colocados em `~/.vim/pack/*/opt/name` e similares.

- Ao adicionar `:packadd! name` ao ficheiro vimrc do utilizador, estes pacotes são colocados no `runtimepath`.

- O Vim carrega estes pacotes no `runtimepath` durante a sua inicialização.

- No final da sua inicialização, as etiquetas dos documentos instalados são atualizadas com "`helptags ALL`".

Para mais, por favor inicie o `vim` com "`vim --startuptime vimstart.log`" para verificar a sequência de execução atual e o tempo gasto em cada passo.

É bastante confuso ver demasiadas formas[3] de gerir e carregar estes pacotes externos para o `vim`. Verificar a informação original é a melhor solução.

Tabela 9.3. Informações sobre a inicialização do `vim`

toques de tecla | informação
--- | ---
`:help package` | explicação sobre o mecanismo de pacotes do vim
`:help runtimepath` | explicação sobre o mecanismo de `runtimepath`
`:version` | estados internos incluindo candidatos para o ficheiro vimrc
`:echo $VIM` | a variável de ambiente "`$VIM`" utilizada para localizar o ficheiro vimrc
`:set runtimepath?` | lista de diretórios que serão pesquisados para todos os ficheiros de suporte de tempo de execução
`:echo $VIMRUNTIME` | a variável de ambiente "`$VIMRUNTIME`" utilizada para localizar vários ficheiros de suporte de tempo de execução fornecidos pelo sistema

## 9.3. Gravação de dados e apresentação

### 9.3.1. O daemon de log

Muitos programas tradicionais registam as suas atividades no formato de ficheiro de texto no diretório "`/var/log/`".

logrotate(8) é utilizado para simplificar a administração de ficheiros de registo num sistema que gera muitos ficheiros de registo.

Muitos programas novos registam as suas atividades no formato de ficheiro binário utilizando o serviço de diário systemd-journald(8) no diretório "`/var/log/journal`".

É possível registar dados no diário systemd-journald(8) a partir de um script shell utilizando o comando systemd-cat(1).

Veja Seção 3.5, “A mensagem do sistema” e Seção 3.4, “A mensagem do kernel”.

### 9.3.2. Analisador de relatório (Log)

Aqui estão analisadores de relatórios notáveis ("`~Gsecurity::log-analyzer`" no aptitude(8)).

Tabela 9.4. Lista de analisadores de log do sistema

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`fail2ban` | V:101, I:111 | 2192 | banir IPs que causam vários erros de autenticação
`logwatch` | V:9, I:11 | 2436 | analisador de log com saída bonita escrito em Perl
`awstats` | V:5.5, I:8.5 | 6934 | analisador de logs de servidor web poderoso e cheio de funcionalidades
`analog` | V:3, I:85 | 3739 | analisador de log do servidor web
`sarg` | V:0.74, I:0.81 | 863 | gerador de relatórios de análises do squid
`pflogsumm` | V:1.5, I:3.8 | 173 | resumidor de entradas do relatório do Postfix
`fwlogwatch` | V:0.11, I:0.17 | 487 | analisador de log da firewall
`squidview` | V:0.03, I:0.46 | 224 | monitoriza e analisa ficheiros access.log do squid
`swatch` | V:0.09, I:0.30 | 99 | visualizador de ficheiros de registo com correspondência de expressões regulares, destaque e hooks
`crm114` | V:0.07, I:0.34 | 1371 | Mutilador de Expressões Regulares Controlável e Filtro de Spam (CRM114)
`icmpinfo` | V:0.01, I:0.33 | 42 | interpretar mensagens ICMP

| Nota
CRM114 disponibiliza uma infraestrutura de linguagem para escrever filtros fuzzy com a biblioteca de expressões regulares TRE. O uso popular dela é o filtro de spam de mail, mas pode ser usado como um analisador de registos.

### 9.3.3. Amostragem personalizada de dados em texto

Apesar de ferramentas paginadoras com o more(1) e less(1) (veja Seção 1.4.5, “O pager”) e ferramentas personalizadas para destaque e formatação (veja Seção 11.1.8, “Destacar e formatar dados de texto simples”) poderem mostrar dados de texto muito bem, os editores de objetivos gerais (veja Seção 1.4.6, “O editor de texto”) são mais versáteis e personalizáveis.

| Dica
Para o vim(1) e o aliás de modo paginador dele view(1), "`:set hls`" ativa pesquisas destacadas.

### 9.3.4. Amostragem personalizada de hora e data

O formato de apresentação predefinido da hora e da data pelo comando "`ls -l`" depende do configuração regional (consulte Seção 1.2.6, “Marcas temporais (Timestamps)” para obter o valor). A variável "`$LANG`" é referida em primeiro lugar e pode ser substituída pelas variáveis de ambiente exportadas "`$LC_TIME`" ou "`$LC_ALL`".

O atual formato de apresentação por omissão para cada configuração regional depende da versão da biblioteca C standard (o pacote `libc6` ) utilizada. Isto é, diferentes lançamentos Debian têm diferentes predefinições. Para formatos iso, veja ISO 8601.

Se deseja realmente personalizar este formato de amostragem da hora e data para além do locale, deve definir o valor de estilo de hora com o argumento "`--time-style`" ou com o valor "`$TIME_STYLE`" (veja ls(1), date(1), "`info coreutils 'ls invocation'`").

Tabela 9.5. Mostrar exemplos de hora e data para o comando "`ls -l`" com o valor de estilo de hora

valor do estilo de hora | localização | mostra a hora e data
--- | --- | ---
`iso` | qualquer | `01-19 00:15`
`long-iso` | qualquer | `2009-01-19 00:15`
`full-iso` | qualquer | `2009-01-19 00:15:16.000000000 +0900`
`locale` | `C` | `Jan 19 00:15`
`locale` | `en_US.UTF-8` | `Jan 19 00:15`
`locale` | `es_ES.UTF-8` | `ene 19 00:15`
`+%d.%m.%y %H:%M` | qualquer | `19.01.09 00:15`
`+%d.%b.%y %H:%M` | `C` ou `en_US.UTF-8` | `19.Jan.09 00:15`
`+%d.%b.%y %H:%M` | `es_ES.UTF-8` | `19.ene.09 00:15`

| Dica

Pode eliminar a digitação de uma opção longa na linha de comando utilizando um alias de comando (ver Seção 1.5.9, “Comando alias”):

    alias ls='ls --time-style=+%d.%m.%y %H:%M'

### 9.3.5. Echo de shell colorido

A escrita da shell nos terminais mais modernos pode ser colorida a usar código de escape de ANSI (veja "`/usr/share/doc/xterm/ctlseqs.txt.gz`").

Por exemplo, tente o seguinte:

    $ RED=$(printf "\x1b[31m")
    $ NORMAL=$(printf "\x1b[0m")
    $ REVERSE=$(printf "\x1b[7m")
    $ echo "${RED}RED-TEXT${NORMAL} ${REVERSE}REVERSE-TEXT${NORMAL}"

### 9.3.6. Comandos coloridos

Comandos coloridos são úteis para inspeccionar os seus resultados no ambiente interativo. Incluí o seguinte no meu "`~/.bashrc`".

    if [ "$TERM" != "dumb" ]; then
        eval "`dircolors -b`"
        alias ls='ls --color=always'
        alias ll='ls --color=always -l'
        alias la='ls --color=always -A'
        alias less='less -R'
        alias ls='ls --color=always'
        alias grep='grep --color=always'
        alias egrep='egrep --color=always'
        alias fgrep='fgrep --color=always'
        alias zgrep='zgrep --color=always'
    else
        alias ll='ls -l'
        alias la='ls -A'
    fi

O uso de alias limita os efeitos coloridos da utilização interactiva do comando. Tem vantagem sobre exportar a variável de ambiente "`export GREP_OPTIONS='--color=auto'`" porque a cor pode ser vista sob programas paginadores como o less(1). Se deseja suprimir a cor quando canaliza (pipe) para outros programas, use antes "`--color=auto`" no exemplo em cima para "`~/.bashrc`".

| Dica
Pode desligar estes nomes alternativos coloridos no ambiente interativo ao invocar a shell com "`TERM=dumb bash`".

### 9.3.7. Recordar as atividades do editor para repetições complexas

Pode recordar as atividades do editor para repetições complexas.

Para o Vim, como a seguir.

- "`qa`": inicia a gravação de caracteres teclados no registo nomeado "`a`".

- ... atividades do editor

- "`q`": termina a gravação de caracteres escritos.

- "`@a`": executa o conteúdo do registo "`a`".

Para Emacs, como a seguir.

- "`C-x (`": começa a definir uma macro de teclado.

- ... atividades do editor

- "`C-x )`": termina de definir uma macro de teclado.

- "`C-x e`": executa uma macro de teclado.

### 9.3.8. Gravar a imagem gráfica de uma aplicação X

Existem algumas maneiras de gravar a imagem gráfica de uma aplicação X, a incluir um ecrã `xterm`.

Tabela 9.6. Lista de ferramentas gráficas de manipulação de imagens

pacote | popcon | tamanho | ecrã | comando
--- | --- | --- | --- | ---
`gnome-screenshot` | V:12, I:101 | 1115 | Wayland | aplicação de captura de ecrã para GNOME
`flameshot` | V:8, I:18 | 3534 | Wayland | aplicação de captura de ecrã com esteróides
`gimp` | V:44, I:216 | 32791 | Wayland + X | captura de ecrã no menu GUI
`x11-apps` | V:30, I:445 | 2461 | X | xwd(1)
`imagemagick` | V:9, I:278 | 79 | X | import(1)
`scrot` | V:4, I:50 | 144 | X | scrot(1)

### 9.3.9. Gravar alterações em ficheiros de configuração

Existem ferramentas especializadas para registar alterações nos ficheiros de configuração com a ajuda do DVCS e para criar instantâneos do sistema no Btrfs.

Tabela 9.7. Lista de pacotes que podem registar o histórico de configuração

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`etckeeper` | V:24, I:27 | 157 | armazenar ficheiros de configuração e os seus meta-dados com Git (predefinido), Mercurial, ou GNU Bazaar (novo)
`timeshift` | V:8, I:13 | 4481 | utilitário de restauração do sistema usando rsync ou instantâneos BTRFS
`snapper` | V:6.1, I:8.1 | 2396 | Ferramenta de gestão de instantâneos do sistema de ficheiros Linux

Também pode pensar em usar scripts locais Seção 10.2.3, “Sugestões de cópia de segurança”.

## 9.4. Monitorizar, controlar e iniciar as atividades de programas

As atividades de programas podem ser monitorizadas e controladas a usar ferramentas especiais.

Tabela 9.8. Lista de ferramentas para monitorizar e controlar as atividades de programas

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`coreutils` | V:911, I:1000 | 17994 | nice(1): correr um programa com prioridade de agendamento modificada
`bsdutils` | V:443, I:999 | 334 | renice(1): modifica a prioridade de agendamento de um processo em execução
`procps` | V:834, I:997 | 2389 | "`/proc`" utilitários de sistema de ficheiros: ps(1), top(1), kill(1) , watch(1), …
`psmisc` | V:404, I:727 | 950 | "`/proc`" utilitários de sistema de ficheiros: killall(1), fuser(1), peekfd(1), pstree(1)
`time` | V:6, I:81 | 148 | time(1): corre um programa para reportar as utilizações de recursos do sistema no que respeita a tempo
`sysstat` | V:120, I:166 | 1904 | sar(1), iostat(1), mpstat(1), …: ferramentas de performance do sistema para Linux
`isag` | V:0.1, I:3.3 | 109 | Interactive System Activity Grapher para sysstat
`lsof` | V:445, I:949 | 492 | lsof(8): lista os ficheiro abertos por um processo em execução a usar a opção "`-p`"
`strace` | V:10, I:102 | 4393 | strace(1): rastreia chamadas e sinais do sistema
`ltrace` | V:1, I:12 | 420 | ltrace(1): rastreia chamadas de bibliotecas
`xtrace` | V:0.04, I:0.70 | 342 | xtrace(1): rastreia a comunicação entre cliente X11 e servidor
`powertop` | V:33, I:224 | 696 | powertop(1): informação sobre a utilização do sistema de energia
`cron` | V:922, I:997 | 247 | corre processos de acordo com uma agenda nos bastidores a partir do daemon cron(8)
`anacron` | V:419, I:476 | 110 | agenda de comandos tipo cron para sistemas que não funcionam 24 horas por dia
`at` | V:73, I:98 | 158 | at(1) ou batch(1): executam um trabalho a uma hora especificada ou abaixo de um certo nível de carga

| Dica
Os pacotes `procps` disponibilizam as bases de monitorizar, controlar e iniciar atividades de programas. Deve aprendê-las todas.

### 9.4.1. Temporizar um processo

Mostrar o tempo usado pelo processo invocado pelo comando.

    # time some_command >/dev/null
    real    0m0.035s       # time on wall clock (elapsed real time)
    user    0m0.000s       # time in user mode
    sys     0m0.020s       # time in kernel mode

### 9.4.2. A prioridade de agendamento

Um valor nice é usado para controlar a prioridade de agendamento para o processo.

Tabela 9.9. Lista de valores nice para a prioridade de agendamento

o valor nice | prioridade de agendamento
--- | ---
19 | processo de prioridade menor (nice)
0 | processo de prioridade muito alta para o utilizador
-20 | processo de prioridade muito alta para o root (não-nice)

    # nice  -19 top                                      # very nice
    # nice --20 wodim -v -eject speed=2 dev=0,0 disk.img # very fast

Por vezes um valor nice extremo faz mais danos que benefícios ao sistema. Use este comando com cuidado.

### 9.4.3. O comando ps

O comando ps(1) num sistema Debian suporta ambas funcionalidades do BSD e SystemV e ajuda-o a identificar estaticamente a atividade do processo.

Tabela 9.10. Lista dos estilos do comando ps

estilo | comando típico | funcionalidade
--- | --- | ---
BSD | `ps aux` | mostrar %CPU %MEM
System V | `ps -efH` | mostra PPID

Para o processo filho zombie (defunto), pode matá-lo pelo ID do processo pai identificado no campo "`PPID`".

O comando pstree(1) mostra uma árvore de processos.

### 9.4.4. O comando top

O top(1) no sistema Debian tem funcionalidades ricas e ajuda-o a identificar dinamicamente que processo está a actuar de modo esquisito.

É um programa interativo de ecrã total. Pode obter a ajuda de utilização dele ao pressionar a tecla "h" e terminá-lo ao pressionar a tecla "q".

### 9.4.5. Listar ficheiros abertos por um processo

Pode listar todos os ficheiros abertos por um processo com o ID do processo (PID), ex. 1, com o seguinte.

    $ sudo lsof -p 1

PID=1 é geralmente o programa de `init`.

### 9.4.6. Rastear as atividades de programas

Pode rastrear a atividade do programa com o strace(1), ltrace(1), ou xtrace(1) para chamadas de sistema e sinais, chamadas de bibliotecas, ou comunicação entre cliente e servidor do X11.

Pode rastrear as chamadas do sistema do comando `ls` como a seguir.

    $ sudo strace ls

| Dica
Utilize o script strace-graph que se encontra em /usr/share/doc/strace/examples/ para fazer uma boa visualização em árvore

### 9.4.7. Identificação de um processo a usar ficheiros ou sockets

Também pode identificar processos que usam ficheiros pelo fuser(1), ex. para "`/var/log/mail.log`" com o seguinte.

    $ sudo fuser -v /var/log/mail.log
                         USER        PID ACCESS COMMAND
    /var/log/mail.log:   root       2946 F.... rsyslogd

Vê que o ficheiro "`/var/log/mail.log`" está aberto para escrita pelo comando rsyslogd(8).

Também pode identificar processos que usam sockets pelo fuser(1), ex. para "`smtp/tcp`" com o seguinte.

    $ sudo fuser -v smtp/tcp
                         USER        PID ACCESS COMMAND
    smtp/tcp:            Debian-exim   3379 F.... exim4

Agora sabe que o seu sistema executa o exim4(8) para lidar com as ligações TCP para a porta SMTP (25).

### 9.4.8. Repetir um comando com um intervalo constante

O watch(1) executa um programa repetidamente num intervalo constante enquanto mostra os seus resultados em ecrã completo.

    $ watch w

Isto mostra quem tem sessão iniciada (logged) no sistema e é atualizado a cada 2 segundos.

### 9.4.9. Repetir um ciclo de comandos sobre ficheiros

Existem várias maneiras de repetir um ciclo de comandos sobre ficheiros que correspondem a alguma condição, ex. que correspondem ao modelo glob "`*.ext`".

- Método for-loop da shell (veja Seção 12.1.4, “Ciclos (loops) da shell”):

    for x in *.ext; do if [ -f "$x"]; then command "$x" ; fi; done

- combinação do find(1) e do xargs(1):

    find . -type f -maxdepth 1 -name '*.ext' -print0 | xargs -0 -n 1 command

- find(1) com a opção "`-exec`" com um comando:

    find . -type f -maxdepth 1 -name '*.ext' -exec command '{}' \;

- find(1) com a opção "`-exec`" com um script de shell curto:

    find . -type f -maxdepth 1 -name '*.ext' -exec sh -c "command '{}' && echo 'successful'" \;

Os exemplos em cima foram escritos para assegurar o lidar apropriado dos nomes de ficheiros esquisitos como os que contêm espaços. Veja Seção 10.1.5, “Idiomas para a seleção de ficheiros” para utilizações mais avançadas do find(1).

### 9.4.10. Arrancar um programa a partir da GUI

Para a interface de linha de comandos (CLI), é executado o primeiro programa com o nome correspondente encontrado nos diretórios especificados na variável de ambiente `$PATH`. Veja Seção 1.5.3, “A variável "`$PATH`"”.

Para a interface gráfica do utilizador (GUI) compatível com as normas freedesktop.org, os ficheiros `*.desktop` no diretório `/usr/share/applications/` fornecem os atributos necessários para a apresentação do menu GUI de cada programa. Cada pacote que é compatível com o sistema de menu xdg do Freedesktop.org instala os seus dados de menu fornecidos por "*.desktop" em "/usr/share/applications/". Os ambientes de trabalho modernos que são compatíveis com a norma Freedesktop.org utilizam estes dados para gerar o seu menu utilizando o pacote xdg-utils. Veja "/usr/share/doc/xdg-utils/README".

Por exemplo, os atributos do ficheiro `chromium.desktop` para o "Navegador Web Chromium" tais como "Nome" para o nome do programa, "Exec" para o caminho de execução do programa e argumentos, "Icon" para o ícone usado, etc. (veja Desktop Entry Specification) como a seguir:

    [Desktop Entry]
    Version=1.0
    Name=Chromium Web Browser
    GenericName=Web Browser
    Comment=Access the Internet
    Comment[fr]=Explorer le Web
    Exec=/usr/bin/chromium %U
    Terminal=false
    X-MultipleArgs=false
    Type=Application
    Icon=chromium
    Categories=Network;WebBrowser;
    MimeType=text/html;text/xml;application/xhtml_xml;x-scheme-handler/http;x-scheme-handler/https;
    StartupWMClass=Chromium
    StartupNotify=true

Esta é uma descrição muito simplificada. Os arquivos `*.desktop` são examinados como a seguir:

O ambiente de trabalho define as variáveis de ambiente `$XDG_DATA_HOME` e `$XDG_DATA_DIR`. Por exemplo, sob o GNOME:

- `$XDG_DATA_HOME` é desconfigurada. (É usado o valor predefinido de `$HOME/.local/share`.)

- `$XDG_DATA_DIRS` é definida para `/usr/share/gnome:/usr/local/share/:/usr/share/`.

Assim, os diretórios base (veja Especificação de Diretório Base XDG) e os diretórios `applications` são como a seguir:

- `$HOME/.local/share/` → `$HOME/.local/share/applications/`

- `/usr/share/gnome/` → `/usr/share/gnome/applications/`

- `/usr/local/share/` → `/usr/local/share/applications/`

- `/usr/share/` → `/usr/share/applications/`

Os ficheiros `*.desktop` são examinados nestes diretórios `applications` por esta ordem.

| Dica
Pode ser criada uma entrada personalizada no menu da GUI ao adicionar um ficheiro `*.desktop` no diretório `$HOME/.local/share/applications/`.

| Dica
A linha "`Exec=...`" não é analisada pela shell. Utilize o comando env(1) se for necessário definir variáveis de ambiente.

| Dica
Se modo semelhante, se um ficheiro `*.desktop` for criado no diretório `autostart` sob esses diretórios base, o programa especificado no ficheiro `*.desktop` é executado automaticamente quando o ambiente de trabalho é iniciado. Veja Especificação de Arranque Automático de Aplicações do Ambiente de Trabalho.

| Dica
De modo semelhante, se um ficheiro `*.desktop` for criado no diretório `$HOME/Desktop` e o ambiente de trabalho estiver configurado para suportar funcionalidade de lançamento por ícones do ambiente de trabalho, o programa especificado nele é executado ao se clicar no ícone. Por favor note que o nome real do diretório `$HOME/Desktop` é dependente da localização. Veja xdg-user-dirs-update(1).

### 9.4.11. Personalizar o programa a ser iniciado

Alguns programas iniciam outros programas automaticamente. Aqui estão alguns pontos de controle para personalizar este processo.

- Menu de configuração da aplicação:

  - Ambiente GNOME: "Definições" → "Aplicações" → "Aplicações Predefinidas"

  - Ambiente KDE: "Lançador de Aplicações" → "Definições do Sistema" → "Aplicações Predefinidas"

  - Navegador Iceweasel: "Editar" → "Preferências" → "Aplicações"

  - mc(1): "`/etc/mc/mc.ext`"

- Variáveis de ambiente como a "`$BROWSER`", "`$EDITOR`", "`$VISUAL`", and "`$PAGER`" (see environ(7))

- O sistema update-alternatives(1) para programas como o "`editor`", "`view`", "`x-www-browser`", "`gnome-www-browser`" e "`www-browser`" (veja Seção 1.4.7, “Definir um editor de texto predefinido”)

- os conteúdos dos ficheiros "`~/.mailcap`" e "`/etc/mailcap`" com a associação do tipo MIME com o programa (veja mailcap(5))

- Os conteúdos dos ficheiros "`~/.mime.types`" e "`/etc/mime.types`" que associam a extensão do nome do ficheiro com o tipo MIME (veja run-mailcap(1))

| Dica
update-mime(8) atualiza o ficheiro "`/etc/mailcap`" a usar o ficheiro "`/etc/mailcap.order`" (veja mailcap.order(5)).

| Dica
O pacote `debianutils` disponibiliza sensible-browser(1), sensible-editor(1) e sensible-pager(1) que fazem decisões sensíveis sobre qual editor, paginador e explorador web chamar, respectivamente. Recomendo-lhe a leitura destes scripts de shell.

| Dica

De modo a correr uma aplicação de consola como o `mutt` sob o GUI como a sua aplicação preferida, deve criar uma aplicação GUI como a seguir e definir "`/usr/local/bin/mutt-term`" como a sua aplicação preferida a ser iniciada como descrito.

    # cat /usr/local/bin/mutt-term <<EOF
    #!/bin/sh
    gnome-terminal -e "mutt \$@"
    EOF
    # chmod 755 /usr/local/bin/mutt-term

### 9.4.12. Matar um processo

Use kill(1) para matar (ou enviar um sinal para) um processo pelo ID do processo.

Use killall(1) ou pkill(1) para fazer o mesmo pelo nome do comando do processo ou outro atributo.

Tabela 9.11. Lista dos sinais frequentemente usados para o comando kill

valor do sinal | nome do sinal | acção | nota
--- | --- | --- | ---
0 | --- | nenhum sinal é enviado (ver kill(2)) | verificar se o processo está em execução
1 | SIGHUP | Terminar o processo | terminal desligado (sinal perdido)
2 | SIGINT | Terminar o processo | interrupção a partir do teclado (`CTRL-C`)
3 | SIGQUIT | terminar o processo e despejar o núcleo | sair a partir do teclado (`CTRL-\`)
9 | SIGKILL | Terminar o processo | sinal de paragem forçada não bloqueável
15 | SIGTERM | Terminar o processo | sinal de término bloqueável

### 9.4.13. Agendar tarefas uma vez

Corra o comando at(1) para agendar uma tarefa de uma-vez com o seguinte.

    $ echo 'command -args'| at 3:40 monday

### 9.4.14. Agendar tarefas regularmente

Use cron(8) para agendar tarefas regularmente. Veja crontab(1) e crontab(5).

Pode agendar a execução de processos como um utilizador normal, ex. `foo` ao criar um ficheiro crontab(5) como "`/var/spool/cron/crontabs/foo`" com o comando "`crontab -e`".

Aqui está um exemplo de um ficheiro crontab(5).

    # use /usr/bin/sh to run commands, no matter what /etc/passwd says
    SHELL=/bin/sh
    # mail any output to paul, no matter whose crontab this is
    MAILTO=paul
    # Min Hour DayOfMonth Month DayOfWeek command (Day... are OR'ed)
    # run at 00:05, every day
    5  0  *  * *   $HOME/bin/daily.job >> $HOME/tmp/out 2>&1
    # run at 14:15 on the first of every month -- output mailed to paul
    15 14 1  * *   $HOME/bin/monthly
    # run at 22:00 on weekdays(1-5), annoy Joe. % for newline, last % for cc:
    0 22 *   * 1-5 mail -s "It's 10pm" joe%Joe,%%Where are your kids?%.%%
    23 */2 1 2 *   echo "run 23 minutes after 0am, 2am, 4am ..., on Feb 1"
    5  4 *   * sun echo "run at 04:05 every Sunday"
    # run at 03:40 on the first Monday of each month
    40 3 1-7 * *   [ "$(date +%a)" == "Mon" ] && command -args

| Dica
Para o sistema que não corre continuamente, instale o pacote `anacron` para agendar comandos periódicos a intervalos especificados o mais próximo que os tempos de ligação de máquina permitem. Veja anacron(8) e anacrontab(5).

| Dica
Para scripts agendados de manutenção do sistema, pode executá-los periodicamente a partir da conta root ao pôr tais scripts em "`/etc/cron.hourly/`", "`/etc/cron.daily/`", "`/etc/cron.weekly/`", ou "`/etc/cron.monthly/`". Os tempos de execução destes scripts podem ser personalizados pelo "`/etc/crontab`" e "`/etc/anacrontab`".

O Systemd tem capacidade de baixo nível para agendar programas para correr sem o daemon `cron`. Por exemplo, `/lib/systemd/system/apt-daily.timer` e `/lib/systemd/system/apt-daily.service` configuram actividades diárias de download do apt. Veja systemd.timer(5) .

### 9.4.15. Programação de tarefas em eventos

O Systemd pode agendar programas não só em eventos temporais, mas também em eventos de montagem. Veja Seção 10.2.3.3, “Cópia de segurança acionada por um evento de temporizador” e Seção 10.2.3.2, “Cópia de segurança acionada por evento de montagem” para exemplos.

### 9.4.16. Tecla Alt-SysRq

Premir Alt-SysRq (PrtScr) seguido de uma tecla faz a magia de recuperar o controlo do sistema.

Tabela 9.12. Lista de teclas de comando SAK notáveis

tecla que segue a Alt-SysRq | descrição da acção
--- | ---
`k` | kill (mata) todos os processos na consola virtual atual (SAK)
`s` | sincroniza todos os sistemas de ficheiros montados para evitar corrupção de dados
`u` | remontar todos os sistemas de ficheiros montados em modo de apenas-leitura (umount)
`r` | restaurar o teclado a partir de modo raw após crash do X

Veja mais em Guia do utilizador e do administrador do kernel Linux » Linux Magic System Request Key Hacks

| Dica
A partir de um terminal SSH etc., pode usar a funcionalidade Alt-SysRq ao escrever para o "`/proc/sysrq-trigger`". Por exemplo, "`echo s > /proc/sysrq-trigger; echo u > /proc/sysrq-trigger`" a partir do aviso da shell de root ssincroniza e umounts (desmonta) todos os sistemas de ficheiros montados.

O kernel Linux Debian amd64 atual (2021) tem `/proc/sys/kernel/sysrq=438=0b110110110`:

- 2 = 0x2 - permite o controlo do nível de registo da consola (ON)

- 4 = 0x4 - ativar o controlo do teclado (SAK, unraw) (ON)

- 8 = 0x8 - ativar depuração de processos, etc. (OFF)

- 16 = 0x10 - ativar comando de sincronização (ON)

- 32 = 0x20 - ativar remontagem só de leitura (ON)

- 64 = 0x40 - ativa a sinalização de processos (term, kill, oom-kill) (OFF)

- 128 = 0x80 - permitir o reinício/desligar(ON)

- 256 = 0x100 - permite iniciar todas as tarefas RT (ON)

## 9.5. Dicas de manutenção do sistema

### 9.5.1. Quem está no sistema?

Pode verificar quem está no sistema com o seguinte.

- who(1) mostra quem tem sessão iniciada.

- w(1) mostra quem tem sessão iniciada e o que estão a fazer.

- last(1) mostra a listagem do último utilizador a iniciar sessão.

- `lastb`(1 )mostra a listagem dos últimos utilizadores a falharem o inicio de sessão.

| Dica
"`/var/run/utmp`" e "`/var/log/wtmp`" detém tal informação do utilizador. Veja login(1) e utmp(5).

### 9.5.2. Avisar todos

Pode mandar uma mensagem para todos os que têm sessão iniciada no sistema com wall(1) com o seguinte.

    $ echo "We are shutting down in 1 hour" | wall

### 9.5.3. Identificação do hardware

Para os aparelhos tipo PCI (AGP, PCI-Express, CardBus, ExpressCard, etc.), o lspci(8) (provavelmente com a opção "`-nn`") é um bom inicio para a identificação do hardware.

Alternativamente, pode identificar o hardware ao ler os conteúdos de "`/proc/bus/pci/devices`" ou explorar a árvore de diretórios sob "`/sys/bus/pci`" (veja Seção 1.2.12, “procfs e sysfs”).

Tabela 9.13. Lista de ferramenta de identificação de hardware

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`pciutils` | V:258, I:993 | 289 | Utilitários PCI do Linux: lspci(8)
`usbutils` | V:83, I:887 | 322 | Utilitários USB do Linux: lsusb(8)
`nvme-cli` | V:24, I:34 | 2222 | Utilitários NVMe para Linux: nvme(1)
`pcmciautils` | V:4.1, I:6.4 | 92 | Utilitários PCMCIA par Linux: pccardctl(8)
`scsitools` | V:0.2, I:2.3 | 261 | colecção de ferramentas para gestão de hardware SCSI: lsscsi(8)
`procinfo` | V:0.4, I:6.2 | 149 | informação do sistema obtida de "`/proc`": lsdev(8)
`lshw` | V:13, I:90 | 971 | informação acerca da configuração do hardware: lshw(1)
`discover` | V:26, I:620 | 81 | sistema de identificação de hardware: discover(8)

### 9.5.4. Configuração do hardware

Apesar da maioria da configuração de hardware nos sistemas de ambiente de trabalho GUI modernos como o GNOME e KDE poder ser gerida através de acompanhamento por ferramentas de configuração com GUI, é uma boa ideia conhecer alguns métodos básicos de o configurar.

Para a configuração do teclado e do terminal, veja Seção 8.2, “A entrada do teclado” e Seção 8.3, “O ecrã de resultados”.

Tabela 9.14. Lista de ferramentas de configuração do hardware

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`console-setup` | V:81, I:974 | 422 | tipo de letra da consola Linux e utilitários da tabela de teclas
`keyd` | V:1.1, I:1.3 | 1437 | Daemon de remapeamento de teclas do teclado que usa nível de kernel de entrada primitiva (evdev, uinput)
`keyd-application-mapper` | V:0.00, I:0.09 | 34 | Daemon de remapeamento de teclas do teclado - remapeador específico da aplicação
`x11-xserver-utils` | V:309, I:531 | 559 | Utilitários do servidor X: xset(1), xmodmap(1)
`acpid` | V:55, I:85 | 158 | daemon para gerir eventos entregues pelo Advanced Configuration and Power Interface (ACPI)
`acpi` | V:7, I:79 | 49 | utilitário para mostrar informação em aparelhos ACPI
`sleepd` | V:0.08, I:0.11 | 84 | daemon para pôr um portátil em modo de adormecimento durante a inatividade
`hdparm` | V:117, I:213 | 246 | optimização do acesso ao disco rígido (veja Seção 9.6.9, “Optimização do disco rígido”)
`smartmontools` | V:235, I:265 | 2455 | controlar e monitorizar sistemas de armazenamento a usar S.M.A.R.T.
`setserial` | V:3.2, I:5.2 | 104 | colecção de ferramentas para gestão de portas série
`memtest86+` | V:1, I:19 | 12483 | colecção de ferramentas para gestão de hardware de memória
`scsitools` | V:0.2, I:2.3 | 261 | colecção de ferramentas para gestão de hardware SCSI
`setcd` | V:0.06, I:0.66 | 33 | optimização de acesso a drives de discos compactos
`big-cursor` | I:0.64 | 26 | cursores de rato maiores para o X

Aqui, o ACPI é uma estrutura mais recente para o sistema de gestão de energia que o APM.

| Dica
O escalar de frequências da CPU em sistemas modernos é governado por módulos do kernel como o `acpi_cpufreq`.

### 9.5.5. Hora do sistema e do hardware

O seguinte define a hora do sistema e hardware para MM/DD hh:mm, AAAA.

    # date MMDDhhmmCCYY
    # hwclock --utc --systohc
    # hwclock --show

A horas são mostradas normalmente na hora local no sistema Debian mas o hardware e a hora do sistema geralmente usam UTC(GMT).

Se a hora do hardware estiver definida para UTC, mude a definição para "`UTC=yes`" em "`/etc/default/rcS`".

O seguinte reconfigura a zona horária usada pelo sistema Debian.

    # dpkg-reconfigure tzdata

Se desejar atualizar a hora do sistema através da rede, considere usar o serviço NTP como pacotes como os `ntp`, `ntpdate` e `chrony`.

| Dica
Sob systemd, use `systemd-timesyncd` para a sincronização da hora com a rede. Veja systemd-timesyncd(8).

Veja o seguinte.

- Como Gerir a Data e Hora com Precisão

- NTP Public Services Project

- O pacote `ntp-doc`

| Dica
O ntptrace(8) no pacote `ntp` pode rastrear uma cadeia de servidores NTP até à sua fonte principal.

### 9.5.6. A infraestrutura de som

As drivers para placas de som para o Linux atual são disponibilizadas pelo Advanced Linux Sound Architecture (ALSA). ALSA disponibiliza um modo de emulação para o anterior Open Sound System (OSS) para compatibilidade.

Os software aplicativos podem ser configurados não apenas para acessar dispositivos de som diretamente, mas também para acessá-los através de algum sistema de servidor de som padronizado. Atualmente, PulseAudio, JACK, e PipeWire são usados como sistemas de servidores de som. Veja a página wiki do Debian sobre Som para a situação mais recente.

Existe normalmente um motor de som comum para cada ambiente de trabalho popular. Cada motor de som usado pela aplicação pode escolher ligar a diferentes servidores de som.

| Dica
Use "`cat /dev/urandom > /dev/audio`" ou speaker-test(1) para testar os altifalantes (^C para parar).

| Dica
Se não conseguir obter som, os seus altifalantes podem estar ligados a uma saída silenciada (mute). Os sistemas de som modernos têm muitas saídas. O alsamixer(1) no pacote `alsa-utils` é útil para configurar as definições de volume e mute.

Tabela 9.15. Lista de pacotes de som

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`alsa-utils` | V:340, I:459 | 2696 | utilitários para configurar e utilizar ALSA
`oss-compat` | V:0.6, I:9.7 | 21 | compatibilidade de OSS sob ALSA para prevenir erros de "`/dev/dsp não encontrado`"
`pipewire` | V:321, I:365 | 135 | motor de processamento de áudio e vídeo servidor multimédia - meta-pacote
`pipewire-bin` | V:328, I:365 | 2219 | motor de processamento de áudio e vídeo servidor multimédia - servidor de áudio e programas CLI
`pipewire-alsa` | V:169, I:234 | 190 | motor de processamento de áudio e vídeo servidor multimédia - servidor de áudio para substituir o ALSA
`pipewire-pulse` | V:289, I:337 | 53 | motor de processamento de áudio e vídeo servidor multimédia - servidor de áudio para substituir o PulseAudio
`pulseaudio` | V:156, I:182 | 6602 | servidor PulseAudio
`libpulse0` | V:440, I:577 | 969 | biblioteca cliente PulseAudio
`jackd` | V:2, I:14 | 8 | servidor (baixa latência) JACK Audio Connection Kit. (JACK)
`libjack0` | V:1.8, I:8.8 | 329 | biblioteca (baixa latência) JACK Audio Connection Kit. (JACK)
`libphonon4qt5-4` | V:22, I:50 | 572 | Phonon: motor de som do KDE

### 9.5.7. desativar o protector de ecrã (screensaver)

Para desativar o protector de ecrã, utilize os seguintes comandos.

Tabela 9.16. Lista de comandos para desativar o protector de ecrã

ambiente | comando
--- | ---
A consola do Linux | `setterm -powersave off`
O X Window (desativar o protector de ecrã) | `xset s off`
O X Window (desativar o dpms) | `xset -dpms`
O X Window (GUI de configuração do protector de ecrã) | `xscreensaver-command -prefs`

### 9.5.8. desativar os sons de beep

Pode-se sempre desligar o altifalante do PC para desativar os apitos. Remover o módulo de kernel `pcspkr` faz isso por si.

O seguinte previne o programa readline(3) usado pelo bash(1) de apitar quando encontra um caractere de alerta (ASCII=7).

    $ echo "set bell-style none">> ~/.inputrc

### 9.5.9. Utilização da memória

Existem 2 recursos disponíveis para obter o estado da utilização de memória.

- A mensagem de arranque do kernel em "`/var/log/dmesg`" contém o tamanho total exacto da memória disponível.

- free(1) e top(1) mostram informação sobre os recursos de memória no sistema em execução.

Aqui está um exemplo.

    # grep '\] Memory' /var/log/dmesg
    [    0.004000] Memory: 990528k/1016784k available (1975k kernel code, 25868k reserved, 931k data, 296k init)
    $ free -k
                 total       used       free     shared    buffers     cached
    Mem:        997184     976928      20256          0     129592     171932
    -/+ buffers/cache:     675404     321780
    Swap:      4545576          4    4545572

Pode estar a pensar "o dmesg fala-me em 990 MB livres e o free -k diz 320 MB livres. Faltam mais de 600 MB ...".

Não se preocupe com o grande tamanho de "`used`" e o pequeno tamanho de "`free`" na linha "`Mem:`", mas leia a que está sob elas (675404 e 321780 no exemplo em cima) e relaxe.

Para o meu MacBook com 1GB=1048576k de DRAM (o sistema de vídeo rouba alguma), vejo o seguinte.

Tabela 9.17. Lista dos tamanhos de memória reportados

relatório | tamanho
--- | ---
Tamanho total no dmesg | 1016784k = 1GB - 31792k
Livre no dmesg | 990528k
Total sob a shell | 997184k
Livre sob a shell | 20256k (mas efectivamente 321780k)

### 9.5.10. Segurança do sistema e verificação de integridade

Uma manutenção pobre do sistema pode expor o seu sistema à exploração externa.

Para segurança do sistema e verificação de integridade, deve começar com o seguinte.

- O pacote `debsums`, veja debsums(1) e Seção 2.5.2, “Arquivo "Release" de nível de topo e autenticidade:”.

- O pacote `chkrootkit`, veja chkrootkit(1).

- A família de pacotes `clamav`, veja clamscan(1) e freshclam(1).

- FAQ de Segurança Debian.

- Manual de Segurança Debian.

Tabela 9.18. Lista de ferramentas para segurança do sistema e verificação de integridade

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`logcheck` | V:4.8, I:5.9 | 120 | daemon para enviar as anomalias nos ficheiros de log do sistema ao administrador por mail
`debsums` | V:4, I:30 | 108 | utilitário para verificar os pacotes instalados contra chaves de verificação MD5
`chkrootkit` | V:9, I:14 | 987 | detector de rootkit
`clamav` | V:9, I:39 | 39204 | utilitário de anti-vírus para Unix - interface de linha de comandos
`tiger` | V:1.2, I:1.5 | 7800 | relatar vulnerabilidades de segurança do sistema
`tripwire` | V:1.3, I:1.6 | 5060 | verificador de integridade de ficheiros e diretórios
`john` | V:1.1, I:7.3 | 469 | ferramenta activa de crack de palavras-passe
`aide` | V:2.0, I:2.4 | 324 | Ambiente de Detecção de Intrusão Avançado - binário estático
`integrit` | V:0.10, I:0.18 | 2771 | programa de verificação de integridade de ficheiros
`crack` | V:0.09, I:0.57 | 153 | programa de adivinhação de palavra-passe

Aqui está um script simples para verificar as típicas permissões de ficheiros escritas incorrectamente.

    # find / -perm 777 -a \! -type s -a \! -type l -a \! \( -type d -a -perm 1777 \)

| Cuidado
Como o pacote `debsums` usa sumários de verificação MD5 armazenados localmente, não pode ser de total confiança como ferramenta de auditoria à segurança do sistema contra ataques maliciosos.

## 9.6. Dicas de armazenamento de dados

Arrancar o seu sistema coo o sistema Linux live (veja Seção 3.2.2, “Sistema de salvamento Linux live em USB” and Seção 3.2.3, “Sistema de salvamento Linux live a partir do GRUB”) torna mais fácil para si reconfigurar o armazenamento de dados no sistema instalado.

| Nota
Declarações sobre disco rijo (HDD) são aplicáveis a outros dispositivos de armazenamento tais como SSD / Pen flash USB / Cartão de memória / ... . Substitua os nomes dos dispositivos nos exemplos como `/dev/sda` com nomes de dispositivos apropriados `/dev/nvme0`, `/dev/mmcblk0`, ... .

Poderá ser necessário desmontar(8) alguns dispositivos manualmente a partir da linha de comandos antes de os operar, caso sejam montados automaticamente pelo sistema de ambiente de trabalho GUI.

### 9.6.1. Utilização do espaço em disco

A utilização do espaço em disco pode ser avaliada por programas disponibilizados pelos pacotes `mount`, `coreutils` e `xdu`:

- mount(8) reporta todos os sistemas de ficheiros montados (= discos).

- df(1) reporta a utilização do espaço em disco para o sistema de ficheiros.

- du(1) reporta a utilização do espaço em disco para a árvore do diretório.

| Dica
Pode alimentar a saída de du(8) a xdu(1) para produzir a apresentação gráfica dele e interactiva com "`du -k . |xdu`", "`sudo du -k -x / |xdu`", etc.

### 9.6.2. Configuração das partições do disco

Para configuração de partições de disco, apesar do fdisk(8) ser considerado o standard, o parted(8) merece alguma atenção. "Dados de particionamento do disco", "Tabela de partições", "Mapa de partições" e "Etiqueta do disco" são todos sinónimos.

PCs antigos usam o esquema clássico do Master Boot Record (MBR) para manter os dados de partições do disco no primeiro sector, isto é, LBA sector 0 (512 bytes).

PCs novos com Unified Extensible Firmware Interface (UEFI), incluindo os Macs baseados em Intel, usam o esquema GUID Partition Table (GPT) para manter os dados de partições do disco não no primeiro sector.

Apesar do fdisk(8) ter sido o standard como ferramenta de particionamento de disco, o parted(8) está a substituí-lo.

Tabela 9.19. Lista de pacotes de gestão de partições do disco

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`util-linux` | V:917, I:1000 | 4658 | vários utilitários de sistema incluindo fdisk(8) e cfdisk(8)
`parted` | V:449, I:568 | 122 | GNU Parted programa de redimensionamento de partições do disco
`gparted` | V:12, I:87 | 2313 | Editor de partições do GNOME baseado na `libparted`
`gdisk` | V:19, I:277 | 967 | editor de partições para o disco híbrido GPT/MBR
`kpartx` | V:17, I:26 | 76 | programa para criar mapeamentos de aparelho para partições

| Cuidado
Apesar do parted(8) afirmar também criar e redimensionar sistemas de ficheiros, é mais seguro fazer tais coisas a usar ferramentas especializadas e com melhor manutenção como as ferramentas mkfs(8) (mkfs.msdos(8), mkfs.ext2(8), mkfs.ext3(8), mkfs.ext4(8), …) e resize2fs(8).

| Nota
De modo a mudar entre GPT e MBR, precisa de apagar os primeiros blocos de conteúdo do disco directamente (veja Seção 9.8.6, “Limpar conteúdo de ficheiro”) e usar "`parted /dev/sdx mklabel gpt`" ou "`parted /dev/sdx mklabel msdos`" para o definir. Por favor note que "`msdos`" é usado aqui para o MBR.

### 9.6.3. Aceder a partição a usar UUID

Apesar da reconfiguração da sua partição ou ordem de ativação de medias de armazenamento amovíveis poder apresentar nomes diferentes para as partições, pode aceder-lhes de modo consistente. Isto é também útil se tem múltiplos discos e a sua BIOS/UEFI não lhes fornecer nomes de dispositivo consistentes.

- mount(8) com a opção "`-U`" pode montar um aparelho de bloco a usar o UUID, em vez de usar o nome de ficheiro dele tal como "`/dev/sda3`".

- "`/etc/fstab`" (veja fstab(5)) pode usar UUID.

- Os gestores de arranque (Seção 3.1.2, “Estágio 2: o gestor de arranque”) também podem usar UUID.

| Dica
Pode testar o UUID de um aparelho especial de bloco com blkid(8). Também pode sondar o UUID e outras informações com "`lsblk -f`".

### 9.6.4. LVM2

LVM2 é um gestor de volumes lógicos para o kernel Linux. Com o LVM2, podem ser criadas partições de disco em volumes lógicos em vez de discos rijos físicos.

O LVM requer o seguinte.

- suporte a device-mapper no kernel Linux (predefinido para os kernels Debian)

- a biblioteca de suporte a device-mapper no espaço de utilizador (pacote (`libdevmapper*`)

- as ferramentas LVM2 do espaço de utilizador (pacote `lvm2`)

Por favor comece a aprender LVM2 a partir dos seguintes manuais.

- lvm(8): Bases do mecanismo LVM2 (lista de todos os comandos LVM2)

- lvm.conf(5): Ficheiro de configuração para LVM2

- lvs(8): Reporta informação acerca de volumes lógicos

- vgs(8): Reporta informação acerca de grupos de volumes

- pvs(8): Reporta informação acerca de volumes físicos

### 9.6.5. Configuração do sistema de ficheiros

Para o sistema de ficheiro ext4, o pacote `e2fsprogs` disponibiliza o seguinte.

- mkfs.ext4(8) para criar um novo sistema de ficheiros ext4

- fsck.ext4(8) para verificar e reparar um sistema de ficheiros ext4 existente

- tune2fs(8) para configurar o super-bloco do sistema de ficheiros ext4

- debugfs(8) para depurar um sistema de ficheiros ext4 interativamente. (Era o comando `undel` para recuperar ficheiros apagados.)

Os comandos mkfs(8) e fsck(8) são disponibilizados pelo pacote `e2fsprogs` como frontends para vários programas dependentes do sistema de ficheiros (`mkfs.fstype` e `fsck.fstype`). Para o sistema de ficheiros ext4 existem os mkfs.ext4(8) e o fsck.ext4(8) (estão ligados simbolicamente ao mke2fs(8) and e2fsck(8)).

Estão disponíveis comandos semelhantes para cada sistema de ficheiros suportado pelo Linux.

Tabela 9.20. Lista de pacotes de gestão de sistemas de ficheiros

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`e2fsprogs` | V:822, I:997 | 1543 | utilitários para os sistemas de ficheiros ext2/ext3/ext4
`btrfs-progs` | V:51, I:78 | 5250 | utilitários para o sistema de ficheiros btrfs
`reiserfsprogs` | V:11, I:22 | 473 | utilitários para o sistema de ficheiros Reiserfs
`zfsutils-linux` | V:33, I:33 | 1895 | utilitários para o sistema de ficheiros OpenZFS
`dosfstools` | V:257, I:564 | 310 | utilitários para o sistema de ficheiros FAT. (Microsoft: MS-DOS, Windows)
`exfatprogs` | V:34, I:459 | 558 | para o sistema de ficheiros exFAT mantido pela Samsung.
`exfat-fuse` | V:2, I:45 | 73 | controlador de leitura/gravação de sistema de arquivos exFAT (Microsoft) para FUSE.
`xfsprogs` | V:41, I:87 | 4382 | utilitários para o sistema de ficheiros XFS. (SGI: IRIX)
`ntfs-3g` | V:201, I:512 | 1501 | controlador de leitura/gravação do sistema de arquivos NTFS (Microsoft: Windows NT, ...) para FUSE.
`jfsutils` | V:0.4, I:6.9 | 1104 | utilitários para o sistema de ficheiros JFS. (IBM: AIX, OS/2)
`xorriso` | V:14, I:64 | 378 | utilitários para sistema de ficheiros ISO-9660 e escrita de CD/DVD a partir de libburnia
`wodim` | V:7, I:89 | 898 | ferramenta de escrita de CD/DVD de linha de comandos a partir de cdrkit
`genisoimage` | V:17, I:160 | 1567 | ferramenta de sistema de ficheiros ISO-9660 de linha de comandos a partir de cdrkit
`reiser4progs` | V:0.1, I:1.2 | 1367 | utilitários para o sistema de ficheiros Reiser4
`hfsprogs` | V:0.3, I:3.2 | 394 | utilitários para os sistemas de ficheiros HFS e HFS Plus. (Apple: Mac OS)
`zerofree` | V:7, I:120 | 30 | programa para zerar blocos livres de sistemas de ficheiros ext2/3/4

| Dica

O sistema de ficheiros Ext4 é o sistema de ficheiros predefinido para o sistema Linux e a utilização é fortemente recomendada a menos que tenha razões especificas para não o fazer.

O estado do Btrfs pode ser encontrado em Debian wiki on btrfs e kernel.org wiki on btrfs. Espera-se que seja o próximo sistema de ficheiros padrão depois do sistema de ficheiros ext4.

Algumas ferramentas permitem acesso a sistemas de ficheiros sem suporte do kernel do Linux (veja Seção 9.8.2, “Manipular ficheiros sem montar o disco”).

### 9.6.6. Criação do sistema de ficheiros e verificação de integridade

O comando mkfs(8) cria o sistema de ficheiros num sistema Linux. O comando fsck(8) disponibiliza a verificação de integridade e reparação do sistema de ficheiros num sistema Linux.

Debian agora, por predefinição, não faz `fsck` periódicos após a criação do sistema de ficheiros.

| Cuidado
Geralmente não é seguro correr o `fsck` em sistemas de ficheiros montados.

| Dica

Pode executar o comando fsck(8) com segurança em todos os sistemas de ficheiros incluindo o sistema raiz durante o arranque da máquina ao definir "`enable_periodic_fsck`" em "`/etc/mke2fs.conf`" e a contagem máxima de montagens para 0 a usar "`tune2fs -c0 /dev/partition_name`". Veja mke2fs.conf(5) e tune2fs(8).

Verifique os ficheiros em "`/var/log/fsck/`" pelos resultados do comando fsck(8) executado do script de arranque.

### 9.6.7. Optimização do sistema de ficheiros por opções de montagem

A configuração estática básica dos sistemas de ficheiros é dada por "`/etc/fstab`". Por exemplo,

    «file system»                   «mount point» «type» «options»    «dump» «pass»
    proc                                      /proc proc   defaults          0 0
    UUID=709cbe4c-80c1-56db-8ab1-dbce3146d2f7 /     ext4   errors=remount-ro 0 1
    UUID=817bae6b-45d2-5aca-4d2a-1267ab46ac23 none  swap   sw                0 0
    /dev/scd0                        /media/cdrom0  udf,iso9660 user,noauto  0 0

| Dica
O UUID (veja Seção 9.6.3, “Aceder a partição a usar UUID”) pode ser utilizado para identificar um aparelho de bloco em vez de nomes vulgares de aparelhos de bloco, tal como "`/dev/sda1`", "`/dev/sda2`",…

Desde o Linux 2.6.30, o kernel adota por defeito o comportamento fornecido pela opção "`relatime`".

Veja fstab(5) e mount(8).

### 9.6.8. Optimização do sistema de ficheiros através do superblock

As características de um sistema de ficheiros podem ser optimizadas via o super-bloco dele a usar o comando tune2fs(8).

- A execução de "`sudo tune2fs -l /dev/sda1`" mostra o conteúdo do super-bloco do sistema de ficheiros em "`/dev/sda1`".

- A execução de "`sudo tune2fs -c 50 /dev/sda1`" muda a frequência das verificações do sistema de ficheiros (execução do `fsck` durante o arranque) para cada 50 arranques em "`/dev/sda1`".

- A execução de "`sudo tune2fs -j /dev/sda1`" adiciona capacidade de journal ao sistema de ficheiros, isto é, conversão de ext2 para ext3 em "`/dev/sda1`". (Faça isto no sistema de ficheiros desmontado.)

- A execução de "`sudo tune2fs -O extents,uninit_bg,dir_index /dev/sda1 && fsck -pf /dev/sda1`" converte-o de ext3 para ext4 em "`/dev/sda1`". (Faça isto no sistema de ficheiros desmontado.)

| Dica
Apesar do nome dele, o tune2fs(8) não funciona apenas no sistema de ficheiros ext2, mas também nos sistemas de ficheiros ext3 e ext4.

### 9.6.9. Optimização do disco rígido

| Atenção
Por favor verifique o seu hardware e leia o manual do hdparm(8) antes de brincar com a configuração do disco rígido porque isto pode ser bastante perigoso para a integridade dos dados.

Pode testar a velocidade de acesso ao disco de um disco rígido, p.e. "`/dev/sda`", por "`hdparm -tT /dev/sda`". Para algum disco rígido ligado com (E)IDE, pode acelerá-lo com "`hdparm -q -c3 -d1 -u1 -m16 /dev/sda`" ao ativar o suporte a "(E)IDE 32-bit I/O", a ativar a flag "using_dma", a definir a flag "interrupt-unmask" e a definir o "multiple 16 sector I/O" (perigoso!).

Pode testar a funcionalidade de cache de escrita de um disco rígido, por exemplo "`/dev/sda`", com "`hdparm -W /dev/sda`". Pode desativar a funcionalidade de cache de escrita dele com "`hdparm -W 0 /dev/sda`".

Pode ser capaz de ler CDROMs muito pressionados em drives de CDROM modernas de alta velocidade ao abrandá-la com "`setcd -x 2`".

### 9.6.10. Optimização de disco de estado sólido (SSD)

A unidade de estado sólido (SSD) é agora automaticamente detetada.

Reduza os acessos desnecessários ao disco para evitar o desgaste do disco, montando "`tmpfs`" no caminho de dados volátil em `/etc/fstab`.

### 9.6.11. Usar SMART para prever falhas no disco rígido

Pode monitorizar e registar em log o seu disco rígido que é compatível com SMART com o daemon smartd(8).

1. ativar a função SMART na BIOS.

2. Instalar o pacote `smartmontools`.

3. Identificar os seus discos rígidos ao listá-los com df(1).

   - Vamos assumir uma drive de disco rígido a ser monitorizada como "`/dev/sda`".

4. Verifique o resultado de "`smartctl -a /dev/sda`" para ver se a funcionalidade SMART está atualmente ligada.

   - Se não, active-o com "`smartctl -s on -a /dev/sda`".

5. Active o daemon smartd(8) ao correr o seguinte.

   - retire a marca de comentário na linha "`start_smartd=yes`" no ficheiro "`/etc/default/smartmontools`".

   - reiniciar o daemon smartd(8) com "`sudo systemctl restart smartmontools`".

| Dica
O daemon smartd(8) pode ser personalizado com o ficheiro `/etc/smartd.conf` incluindo em como ser notificado dos avisos.

### 9.6.12. Especifique o diretório de armazenamento temporário através de $TMPDIR

As aplicações criam ficheiros temporários normalmente sob o diretório de armazenamento temporário "`/tmp`". Se "`/tmp`" não disponibilizar espaço suficiente, pode especificar um diretório de espaço temporário, a programas bem-comportados, através da variável `$TMPDIR`.

### 9.6.13. Expandir o espaço de armazenamento utilizável via LVM

Para partições criadas em Logical Volume Manager (LVM) (funcionalidade do Linux) durante a instalação, elas podem ser redimensionadas facilmente ao concatenar extensões nelas ou ao truncar extensões delas sobre múltiplos aparelhos de armazenamento sem grandes reconfigurações do sistema.

### 9.6.14. Expandir o espaço de armazenamento utilizável ao montar outra partição

Se tiver uma partição vazia (ex. "`/dev/sdx`"), pode formatá-la com mkfs.ext4(1) e mount(8) para um diretório onde precise de mais espaço. (necessita copiar os conteúdos originais.)

    $ sudo mv work-dir old-dir
    $ sudo mkfs.ext4 /dev/sdx
    $ sudo mount -t ext4 /dev/sdx work-dir
    $ sudo cp -a old-dir/* work-dir
    $ sudo rm -rf old-dir

| Dica
Pode em alternativa montar um ficheiro de imagem de disco vazio (veja Seção 9.7.5, “Criar um ficheiro de imagem de disco vazio”) como um aparelho de loop (veja Seção 9.7.3, “Montar o ficheiro de imagem de disco”). A utilização real do disco cresce com os dados reais armazenados.

### 9.6.15. Expandir o espaço de armazenamento utilizável ao fazer bind-mount para outro diretório

Se tiver um diretório vazio (p.e. "`/caminho/para/diretório-vazio`") com espaço utilizável noutra partição, pode fazer mount(8) ao mesmo com a opção "`--bind` para um diretório (p.e., "`diretório-de-trabalho`") onde necessite de mais espaço.

    $ sudo mount --bind /path/to/emp-dir work-dir

### 9.6.16. Expansão do espaço de armazenamento utilizável ao fazer overlay-mounting para outro diretório

Se tem espaço utilizável noutra partição (ex. "`/path/to/empty`") e "`/path/to/work`"), pode criar um diretório nela e empilhá-lo no diretório antigo (ex, "`/path/to/old`") onde precisa de espaço a usar o OverlayFS para Linux kernel 3.18 ou mais recente (Debian Stretch 9.0 ou posterior).

    $ sudo mount -t overlay overlay \
      -olowerdir=/path/to/old-dir,upperdir=/path/to/empty,workdir=/path/to/work

Aqui, "`/path/to/empty`" e "`/path/to/work`" devem estar na partição com Escrita-Leitura activa a escrever em "`/path/to/old`".

### 9.6.17. Expandir o espaço de armazenamento utilizável a usar ligações simbólicas

| Cuidado
Este é um método descontinuado. Alguns programas podem não funcionar bem com uma "ligação simbólica a um diretório". Em vez disso, use as opções de "montagem" descritas em cima.

Se tem um diretório vazio (ex. "`/caminho/para/diretório-vazio`") noutra partição com espaço utilizável, pode criar uma ligação simbólica ao diretório com o ln(8).

    $ sudo mv work-dir old-dir
    $ sudo mkdir -p /path/to/emp-dir
    $ sudo ln -sf /path/to/emp-dir work-dir
    $ sudo cp -a old-dir/* work-dir
    $ sudo rm -rf old-dir

| Atenção
Não utilize uma "ligação simbólica para um diretório" para diretórios geridos pelo sistema, tais como o "`/opt`". Tal ligação simbólica poderá ser sobrescrita quando o sistema for atualizado.

## 9.7. A imagem de disco

Aqui discutimos manipulações da imagem do disco.

### 9.7.1. Criar o ficheiro de imagem de disco

O ficheiro de imagem de disco, "`disco.img`", de um dispositivo não montado, ex., a segunda drive SCSI ou serial ATA "`/dev/sdb`", pode ser feito por um dos seguintes.

    # dd if=/dev/sdb of=disk.img; sync

    # cp /dev/sdb disk.img ; sync

    # cat /dev/sdb > disk.img ; sync

O master boot record (MBR) da imagem de disco dos PC's tradicionais (veja Seção 9.6.2, “Configuração das partições do disco”) que reside no primeiro sector no disco IDE primário pode ser feito a usar o dd(1) com o seguinte.

    # dd if=/dev/sda of=mbr.img bs=512 count=1
    # dd if=/dev/sda of=mbr-nopart.img bs=446 count=1
    # dd if=/dev/sda of=mbr-part.img skip=446 bs=1 count=66

- "`mbr.img`": O MBR com a tabela de partições

- "`mbr-nopart.img`": O MBR sem a tabela de partições

- "`mbr-part.img`": A tabela de partições apenas do MBR

Se está a criar uma imagem de uma partição de disco do disco original, substitua "`/dev/sda`" por "`/dev/sda1`" etc.

### 9.7.2. Escrever directamente no disco

O ficheiro de imagem de disco "`disk.img`" pode ser escrito para um dispositivo desmontado, ex. a segunda drive SCSI "`/dev/sdb`" com tamanho correspondente, por uma das seguintes maneiras.

    # dd if=disk.img of=/dev/sdb ; sync

    # cp disk.img /dev/sdb ; sync

    # cat disk.img >/dev/sdb ; sync

Se modo semelhante, o ficheiro de imagem de partição de disco, "`partition.img`" pode ser escrito para uma partição desmontada, ex., a primeira partição do segundo disco SCSI "`/dev/sdb1`" com tamanho correspondente, com o seguinte.

    # dd if=partition.img of=/dev/sdb1 ; sync

### 9.7.3. Montar o ficheiro de imagem de disco

A imagem de disco "`partition.img`" que contém uma partição única pode ser montada e desmontada ao usar o aparelho loop como a seguir.

    # losetup --show -f partition.img
    /dev/loop0
    # mkdir -p /mnt/loop0
    # mount -t auto /dev/loop0 /mnt/loop0
    ...hack...hack...hack
    # umount /dev/loop0
    # losetup -d /dev/loop0

Isto pode ser simplificado como a seguir.

    # mkdir -p /mnt/loop0
    # mount -t auto -o loop partition.img /mnt/loop0
    ...hack...hack...hack
    # umount partition.img

Cada partição da imagem de disco "`disk.img`" que contém múltiplas partições pode ser montada a usar o aparelho loop.

    # losetup --show -f -P disk.img
    /dev/loop0
    # ls -l /dev/loop0*
    brw-rw---- 1 root disk   7,  0 Apr  2 22:51 /dev/loop0
    brw-rw---- 1 root disk 259, 12 Apr  2 22:51 /dev/loop0p1
    brw-rw---- 1 root disk 259, 13 Apr  2 22:51 /dev/loop0p14
    brw-rw---- 1 root disk 259, 14 Apr  2 22:51 /dev/loop0p15
    # fdisk -l /dev/loop0
    Disk /dev/loop0: 2 GiB, 2147483648 bytes, 4194304 sectors
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: gpt
    Disk identifier: 6A1D9E28-C48C-2144-91F7-968B3CBC9BD1

    Device         Start     End Sectors  Size Type
    /dev/loop0p1  262144 4192255 3930112  1.9G Linux root (x86-64)
    /dev/loop0p14   2048    8191    6144    3M BIOS boot
    /dev/loop0p15   8192  262143  253952  124M EFI System

    Partition table entries are not in disk order.
    # mkdir -p /mnt/loop0p1
    # mkdir -p /mnt/loop0p15
    # mount -t auto /dev/loop0p1 /mnt/loop0p1
    # mount -t auto /dev/loop0p15 /mnt/loop0p15
    # mount |grep loop
    /dev/loop0p1 on /mnt/loop0p1 type ext4 (rw,relatime)
    /dev/loop0p15 on /mnt/loop0p15 type vfat (rw,relatime,fmask=0002,dmask=0002,allow_utime=0020,codepage=437,iocharset=ascii,shortname=mixed,utf8,errors=remount-ro)
    ...hack...hack...hack
    # umount /dev/loop0p1
    # umount /dev/loop0p15
    # losetup -d /dev/loop0

Alternativamente, podem-se fazer efeitos semelhantes ao usar os aparelhos device mapper criados pelo kpartx(8) do pacote `kpartx` como a seguir.

    # kpartx -a -v disk.img
    add map loop0p1 (253:0): 0 3930112 linear 7:0 262144
    add map loop0p14 (253:1): 0 6144 linear 7:0 2048
    add map loop0p15 (253:2): 0 253952 linear 7:0 8192
    # fdisk -l /dev/loop0
    Disk /dev/loop0: 2 GiB, 2147483648 bytes, 4194304 sectors
    Units: sectors of 1 * 512 = 512 bytes
    Sector size (logical/physical): 512 bytes / 512 bytes
    I/O size (minimum/optimal): 512 bytes / 512 bytes
    Disklabel type: gpt
    Disk identifier: 6A1D9E28-C48C-2144-91F7-968B3CBC9BD1

    Device         Start     End Sectors  Size Type
    /dev/loop0p1  262144 4192255 3930112  1.9G Linux root (x86-64)
    /dev/loop0p14   2048    8191    6144    3M BIOS boot
    /dev/loop0p15   8192  262143  253952  124M EFI System

    Partition table entries are not in disk order.
    # ls -l /dev/mapper/
    total 0
    crw------- 1 root root 10, 236 Apr  2 22:45 control
    lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p1 -> ../dm-0
    lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p14 -> ../dm-1
    lrwxrwxrwx 1 root root       7 Apr  2 23:19 loop0p15 -> ../dm-2
    # mkdir -p /mnt/loop0p1
    # mkdir -p /mnt/loop0p15
    # mount -t auto /dev/mapper/loop0p1 /mnt/loop0p1
    # mount -t auto /dev/mapper/loop0p15 /mnt/loop0p15
    # mount |grep loop
    /dev/loop0p1 on /mnt/loop0p1 type ext4 (rw,relatime)
    /dev/loop0p15 on /mnt/loop0p15 type vfat (rw,relatime,fmask=0002,dmask=0002,allow_utime=0020,codepage=437,iocharset=ascii,shortname=mixed,utf8,errors=remount-ro)
    ...hack...hack...hack
    # umount /dev/mapper/loop0p1
    # umount /dev/mapper/loop0p15
    # kpartx -d disk.img

### 9.7.4. Limpar um ficheiro de imagem de disco

Um ficheiro de imagem de disco, "`disk.img`" pode ser limpo de todos os ficheiros removidos numa imagem limpa "`new.img`" com o seguinte.

    # mkdir old; mkdir new
    # mount -t auto -o loop disk.img old
    # dd bs=1 count=0 if=/dev/zero of=new.img seek=5G
    # mount -t auto -o loop new.img new
    # cd old
    # cp -a --sparse=always ./ ../new/
    # cd ..
    # umount new.img
    # umount disk.img

Se o "`disk.img`" está em ext2, ext3 ou ext4, você também pode usar o zerofree(8) do pacote `zerofree` como a seguir.

    # losetup --show -f disk.img
    /dev/loop0
    # zerofree /dev/loop0
    # cp --sparse=always disk.img new.img
    # losetup -d /dev/loop0

### 9.7.5. Criar um ficheiro de imagem de disco vazio

A imagem de disco vazia "`disk.img`" que pode crescer até aos 5GiB pode ser feita a usar o dd(1) como a seguir.

    $ dd bs=1 count=0 if=/dev/zero of=disk.img seek=5G

Em vez de utilizar dd(1), pode ser utilizado aqui o `fallocate` especializado (8).

Pode criar um sistema de ficheiros ext4 nesta imagem de disco "`disk.img`" a usar o aparelho loop como a seguir.

    # losetup --show -f disk.img
    /dev/loop0
    # mkfs.ext4 /dev/loop0
    ...hack...hack...hack
    # losetup -d /dev/loop0
    $ du  --apparent-size -h disk.img
    5.0G  disk.img
    $ du -h disk.img
    83M disk.img

Para "`disk.img`", o tamanho de ficheiro dele é 5.0 Gb e a utilização real do disco dele é apenas 83 Mb. Esta discrepância é possível porque o ext4 pode manter o ficheiro sparse.

| Dica
A utilização de disco real do ficheiro sparse cresce com os dados que são escritos nele.

A usar uma operação semelhante em aparelhos criados pelo aparelho loop ou o mapeador de aparelhos como Seção 9.7.3, “Montar o ficheiro de imagem de disco”, pode particionar esta imagem de disco "`disk.img`" a usar o parted(8) ou o fdisk(8) e pode criar um sistema de ficheiros nela a usar mkfs.ext4(8), mkswap(8), etc.

### 9.7.6. Criar o ficheiro de imagem ISO9660

| Dica
Ambos genisoimage(1) fornecido por cdrkit e xorrisofs(1) fornecido por Libburnia partilham a mesma sintaxe de comando excepto o nome do comando.

O ficheiro de imagem ISO9660, "`cd.iso`", a partir da árvore de diretórios fonte em "`source_diretory`" pode ser feito a usar o genisoimage(1) disponibilizado pelo cdrkit com o seguinte.

    #  genisoimage -r -J -T -V volume_id -o cd.iso source_directory

De modo semelhante, o ficheiro de imagem ISO9660 de arranque, "`cdboot.iso`", pode ser feito a partir do `instalador-debian` como árvore de diretórios em "`source_diretory`" com o seguinte.

    #  genisoimage -r -o cdboot.iso -V volume_id \
       -b isolinux/isolinux.bin -c isolinux/boot.cat \
       -no-emul-boot -boot-load-size 4 -boot-info-table source_directory

Aqui é usado para arranque o boot loader Isolinux (veja Seção 3.1.2, “Estágio 2: o gestor de arranque”).

Pode calcular o valor md5sum e fazer a imagem ISO9660 directamente a partir do aparelho CD-ROM como a seguir.

    $ isoinfo -d -i /dev/cdrom
    CD-ROM is in ISO 9660 format
    ...
    Logical block size is: 2048
    Volume size is: 23150592
    ...
    # dd if=/dev/cdrom bs=2048 count=23150592 conv=notrunc,noerror | md5sum
    # dd if=/dev/cdrom bs=2048 count=23150592 conv=notrunc,noerror > cd.iso

| Atenção
Tem de ter o cuidado de evitar o bug de leitura antecipada do sistema de ficheiros ISO9660 do Linux como em cima para obter o resultado correcto.

### 9.7.7. Escrever directamente ao CD/DVD-R/RW

| Dica
Um DVD é apenas um CD grande para o wodim(1) fornecido por cdrkit e xorrecord(1) fornecido por Libburnia. Estes comandos partilham a mesma sintaxe de comando excepto o nome do comando.

Pode procurar um aparelho utilizável com o seguinte.

    # wodim --devices

Então o CD-R vazio é inserido na drive de CD e o ficheiro de imagem ISO9660, "`cd.iso`" é escrito neste aparelho, ex. "`/dev/sda`", a usar o wodim(1) com o seguinte.

    # wodim -v -eject dev=/dev/sda cd.iso

Se for usado um CD-RW em vez de um CD-R, faça antes o seguinte.

    # wodim -v -eject blank=fast dev=/dev/sda cd.iso

| Dica
Se o seu ambiente montar CDs automaticamente, desmonte-o com "`sudo umount /dev/sda`" a partir da consola antes de usar o wodim(1).

### 9.7.8. Montar o ficheiro de imagem ISO9660

Se "`cd.iso`" conter uma imagem ISO9660, então o seguinte monta-o manualmente em "`/cdrom`".

    # mount -t iso9660 -o ro,loop cd.iso /cdrom

| Dica
Os sistemas de ambiente de trabalho modernos podem montar medias amovíveis, tais como um CD formatado em ISO9660, automaticamente (veja Seção 10.1.7, “Aparelho de armazenamento amovível”).

## 9.8. Os dados binários

Aqui, discutimos manipulação directa de dados binários em meios de armazenamento.

### 9.8.1. Ver e editar dados binários

o método de visualização mais básico de dados binários é usar o comando "`od -t x1`".

Tabela 9.21. Lista de pacote para ver e editar dados binários

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`coreutils` | V:911, I:1000 | 17994 | pacote básico que tem od(1) para despejar ficheiros (HEX, ASCII, OCTAL, …)
`bsdmainutils` | V:4, I:136 | 17 | pacote utilitário que tem hd(1) para despejar ficheiros (HEX, ASCII, OCTAL, …)
`hexedit` | V:0.8, I:7.9 | 70 | editor binário e visualizador (HEX, ASCII)
`bless` | V:0.2, I:1.4 | 924 | editor hexadecimal cheiro de funcionalidades (GNOME)
`okteta` | V:1, I:12 | 1589 | editor hexadecimal cheiro de funcionalidades (KDE4)
`ncurses-hexedit` | V:0.1, I:1.2 | 130 | editor binário e visualizador (HEX, ASCII, EBCDIC)
`beav` | V:0.04, I:0.32 | 137 | editor binário e visualizador (HEX, ASCII, EBCDIC, OCTAL, …)

| Dica
HEX é usado como um acrónimo para o formato hexadecimal com radix 16. OCTAL é para formato octal com radix 8. ASCII é para American Standard Code for Information Interchange, isto é, código de texto Inglês normal. EBCDIC é para Extended Binary Coded Decimal Interchange Code usado em sistemas operativos com infraestrutura da IBM.

### 9.8.2. Manipular ficheiros sem montar o disco

Existem ferramentas para ler e escrever ficheiros sem montar o disco.

Tabela 9.22. Lista de pacotes para ler e escrever ficheiros sem montar o disco

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`mtools` | V:7, I:53 | 400 | utilitários para sistemas de ficheiros MSDOS sem os montar
`hfsutils` | V:0.2, I:2.7 | 178 | utilitários para sistemas de ficheiros HFS e HFS+ sem os montar

### 9.8.3. Redundância de dados

Os sistemas RAID por software oferecidos pelo kernel Linux oferecem redundância de dados ao nível do sistema de ficheiros do kernel, para se conseguir altos níveis de fiabilidade de armazenamento.

Também existem ferramentas para adicionar redundância a ficheiros ao nível de programa aplicação, para se conseguir altos níveis de fiabilidade de armazenamento.

Tabela 9.23. Lista de ferramentas para adicionar redundância de dados a ficheiros

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`par2` | V:9, I:116 | 297 | Parity Archive Volume Set, para verificação e reparação de ficheiros
`dvdisaster` | V:0.1, I:1.2 | 1422 | protecção de dados contra percas/riscos/envelhecimento para medias CD/DVD
`dvbackup` | V:0.01, I:0.03 | 413 | ferramenta de backup que usa câmaras de filmar MiniDV (a disponibilizar rsbep(1))

### 9.8.4. Recuperação de ficheiros e dados e análise forense

Existem ferramentas para recuperação de ficheiros e dados e análise forense.

Tabela 9.24. Lista de pacotes para recuperação de ficheiros e dados e análise forense

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`testdisk` | V:2, I:25 | 2275 | utilitários para sondagem de partições e recuperação de discos
`magicrescue` | V:0.2, I:1.7 | 257 | utilitário para recuperar ficheiros ao procurar por bytes mágicos
`scalpel` | V:0.2, I:2.2 | 89 | frugal, entalhador de ficheiros de alta performance
`myrescue` | V:0.2, I:1.8 | 81 | recuperar dados de discos rígidos danificados
`extundelete` | V:0.5, I:7.3 | 152 | utilitários para recuperar ficheiros apagados no sistema de ficheiros ext3/4
`ext4magic` | V:0.3, I:3.4 | 235 | utilitários para recuperar ficheiros apagados no sistema de ficheiros ext3/4
`ext3grep` | V:0.2, I:1.8 | 299 | ferramenta para ajudar a recuperar ficheiros apagados no sistema de ficheiros ext3
`scrounge-ntfs` | V:0.2, I:1.5 | 49 | programa de recuperação de dados para sistemas de ficheiros NTFS
`gzrt` | V:0.03, I:0.47 | 34 | conjunto de ferramentas de recuperação gzip
`sleuthkit` | V:2, I:25 | 1119 | ferramentas para análise forense. (Sleuthkit)
`autopsy` | V:0.2, I:1.1 | 1026 | interface gráfica para o SleuthKit
`foremost` | V:0.4, I:4.0 | 102 | aplicação forense para recuperar dados
`guymager` | V:0.13, I:0.75 | 1049 | ferramenta de imagem forense baseada em Qt
`dcfldd` | V:0.3, I:2.7 | 113 | versão melhorada do `dd` para forenses e segurança

| Dica
Pode recuperar ficheiros apagados no sistema de ficheiros ext2 a usar os comandos `list_deleted_inodes` e `undel` de debugfs(8) no pacote `e2fsprogs`.

### 9.8.5. Dividir um ficheiro grande em ficheiros pequenos

Quando os dados são muito grandes para fazer backup num ficheiro único, pode fazer backup ao conteúdo dele após dividi-lo em fatias de, por exemplo, 2000Mb e mais tarde fundir essas fatias de volta para o ficheiro original.

    $ split -b 2000m large_file
    $ cat x* >large_file

| Cuidado
Por favor certifique-se que não tem nenhuns ficheiros que começam com "`x`" para evitar crashes com nomes.

### 9.8.6. Limpar conteúdo de ficheiro

De modo a limpar o conteúdo de um ficheiro como um ficheiro log, não use o rm(1) para apagar o ficheiro e depois crie um ficheiro vazio, porque o ficheiro pode ainda estar a ser acedido no intervalo entre comandos. O seguinte é o modo seguro de limpar o conteúdo do ficheiro.

    $ :>file_to_be_cleared

### 9.8.7. Ficheiros dummy

Os seguintes comandos criam ficheiros dummy ou vazios.

    $ dd if=/dev/zero    of=5kb.file bs=1k count=5
    $ dd if=/dev/urandom of=7mb.file bs=1M count=7
    $ touch zero.file
    $ : > alwayszero.file

Deve encontrar os seguintes ficheiros.

- "`5kb.file`" é 5KB de zeros.

- "`7mb.file`" são 7MB de dados aleatórios.

- "`zero.file`" pode ser um ficheiro de 0 bytes. Se existir, o `mtime` dele é atualizado enquanto o conteúdo e tamanho dele são mantidos.

- "`alwayszero.file`" é sempre um ficheiro de 0 bytes. Se existir, o `mtime` dele é atualizado e o conteúdo dele é reposto.

### 9.8.8. apagar um disco rígido inteiro

Existem várias maneiras de apagar completamente os dados dum dispositivo inteiro tipo disco rígido, ex., Memória flash USB em "`/dev/sda`".

| Cuidado
Primeiro verifique a localização da sua Memória flash USB com o mount(8) antes de executar os comandos aqui. O dispositivo apontado por "`/dev/sda`" pode ser um disco rígido SCSI ou SATA onde pode residir todo o seu sistema.

Apagar todo o conteúdo do disco ao repor os dados a 0 com o seguinte.

    # dd if=/dev/zero of=/dev/sda

Apagar tudo ao sobrescrever com dados aleatórios como a seguir.

    # dd if=/dev/urandom of=/dev/sda

Apagar tudo muito eficientemente ao sobrescrever com dados aleatórios como a seguir.

    # shred -v -n 1 /dev/sda

Em alternativa, pode utilizar badblocks(8) com a opção `-t random`.

Como o dd(1) está disponível a partir da shell de muitos CDs de arranque de Linux como o CD de instalação de Debian, pode apagar completamente o seu sistema instalado no disco rígido, por exemplo, "`/dev/sda`", "`/dev/sda`", etc., ao correr um comando de limpeza a partir de tal media de arranque.

### 9.8.9. Apagar uma área não utilizada do disco rígido

A área não utilizada de um disco rígido (ou Memória flash USB), por exemplo "`/dev/sdb1`" pode ainda conter os próprios dados apagados pois eles são apenas 'desligados' do sistema de ficheiros. Estes podem ser limpos ao sobrescrever a área onde estão.

    # mount -t auto /dev/sdb1 /mnt/foo
    # cd /mnt/foo
    # dd if=/dev/zero of=junk
    dd: writing to `junk': No space left on device
    ...
    # sync
    # umount /dev/sdb1

| Atenção
Normalmente isto é suficientemente bom para a sua Memória flash USB. Mas não é perfeito. A maioria das partes dos nomes de ficheiros apagados e os atributos deles podem ficar escondidos e permanecerem no sistema de ficheiros.

### 9.8.10. Recuperar ficheiros apagados mas ainda abertos

Mesmo que tenha acidentalmente apagado um ficheiro, desde que esse ficheiro esteja ainda a ser usado por alguma aplicação (em modo de leitura ou escrita), é possível recuperar tal ficheiro.

Por exemplo, tente o seguinte:

    $ echo foo > bar
    $ less bar
    $ ps aux | grep ' less[ ]'
    bozo    4775  0.0  0.0  92200   884 pts/8    S+   00:18   0:00 less bar
    $ rm bar
    $ ls -l /proc/4775/fd | grep bar
    lr-x------ 1 bozo bozo 64 2008-05-09 00:19 4 -> /home/bozo/bar (deleted)
    $ cat /proc/4775/fd/4 >bar
    $ ls -l
    -rw-r--r-- 1 bozo bozo 4 2008-05-09 00:25 bar
    $ cat bar
    foo

Execute em outro terminal (quando tem o pacote `lsof` instalado) o seguinte.

    $ ls -li bar
    2228329 -rw-r--r-- 1 bozo bozo 4 2008-05-11 11:02 bar
    $ lsof |grep bar|grep less
    less 4775 bozo 4r REG 8,3 4 2228329 /home/bozo/bar
    $ rm bar
    $ lsof |grep bar|grep less
    less 4775 bozo 4r REG 8,3 4 2228329 /home/bozo/bar (deleted)
    $ cat /proc/4775/fd/4 >bar
    $ ls -li bar
    2228302 -rw-r--r-- 1 bozo bozo 4 2008-05-11 11:05 bar
    $ cat bar
    foo

### 9.8.11. Procurar todas as ligações rígidas

Os ficheiros com ligações rígidas podem ser identificados com "`ls -li`".

    $ ls -li
    total 0
    2738405 -rw-r--r-- 1 root root 0 2008-09-15 20:21 bar
    2738404 -rw-r--r-- 2 root root 0 2008-09-15 20:21 baz
    2738404 -rw-r--r-- 2 root root 0 2008-09-15 20:21 foo

Ambos "`baz`" e "`foo`" têm contagens de ligações de "2" (>1) a mostrar que têm ligaçõesrígidas. Os números de inode deles são comuns "2738404". Isto significa que são o mesmo ficheiro em ligação rígida. Se não encontrar todos os ficheiros em ligação rígida por acaso, pode procurá-los pelo inode, ex., "2738404" com o seguinte.

    # find /path/to/mount/point -xdev -inum 2738404

### 9.8.12. Consumo invisível do espaço do disco

Todos os ficheiros apagadas mas abertos consomem espaço no disco apesar de não estarem visíveis ao du(1) normal. Eles podem ser listados com o tamanho deles com o seguinte.

    # lsof -s -X / |grep deleted

## 9.9. Dicas de encriptação de dados

Com acesso físico ao seu PC, qualquer um pode facilmente ganhar privilégios de root e aceder a todos os ficheiros no seu PC (veja Seção 4.6.4, “Tornar a palavra-passe do root segura”). Isto significa que o sistema de palavra passe no login não pode proteger os seus dados privados e sensíveis contra um possível roubo do seu PC. Tem que implementar uma tecnologia de encriptação de dados para o fazer. Apesar do GNU privacy guard (veja Seção 10.3, “Infraestrutura da segurança de dados”) poder encriptar ficheiro,consome alguns esforços do utilizador.

Dm-crypt facilitam a encriptação de dados automática nativamente através de módulos do kernel Linux com o mínimo de esforço do utilizador utilizando device-mapper.

Tabela 9.25. Lista de utilitários de encriptação de dados

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`cryptsetup` | V:35, I:78 | 462 | utilitários para aparelhos de bloco encriptados (dm-crypt / LUKS)
`cryptmount` | V:1.9, I:2.5 | 236 | utilitários para aparelhos de bloco encriptados (dm-crypt / LUKS) com focagem na montagem/desmontagem por utilizadores normais
`fscrypt` | V:0.4, I:1.1 | 6545 | utilitários para a encriptação do sistema de ficheiros Linux (fscrypt)
`libpam-fscrypt` | V:0.27, I:0.34 | 6594 | Módulo PAM para encriptação do sistema de ficheiros Linux(fscrypt)

| Cuidado
A encriptação de dados custa tempo de CPU, etc. Os dados encriptados ficam inacessíveis se a palavra-passe for perdida. Pondere as suas vantagens e custos.

| Nota
O sistema Debian inteiro pode ser instalado num disco encriptado pelo instalador debian (lenny ou mais recente) a usar dm-crypt/LUKS e initramfs.

| Dica
Veja Seção 10.3, “Infraestrutura da segurança de dados” para utilitário de encriptação do espaço de utilizador: GNU Privacy Guard.

### 9.9.1. Encriptação de discos amovíveis com dm-crypt/LUKS

Pode encriptar o conteúdo de dispositivos de massa amovíveis, por exemplo, uma Memória flash USB em "`/dev/sdx`", a usar dm-crypt/LUKS. Simplesmente formate-a como se segue.

    # fdisk /dev/sdx
    ... "n" "p" "1" "return" "return" "w"
    # cryptsetup luksFormat /dev/sdx1
    ...
    # cryptsetup open /dev/sdx1 secret
    ...
    # ls -l /dev/mapper/
    total 0
    crw-rw---- 1 root root  10, 60 2021-10-04 18:44 control
    lrwxrwxrwx 1 root root       7 2021-10-04 23:55 secret -> ../dm-0
    # mkfs.vfat /dev/mapper/secret
    ...
    # cryptsetup close secret

Depois, pode ser montado normalmente em "`/media/username/disk_label`", exceto para pedir a password (veja Seção 10.1.7, “Aparelho de armazenamento amovível”) no ambiente de trabalho moderno utilizando o pacote `udisks2`. A diferença é que todos os dados escritos nele são encriptados. A introdução da palavra-passe pode ser automatizada utilizando um porta-chaves (ver Seção 10.3.6, “Gestor de palavras-passe”).

Pode, em alternativa, formatar os media num sistema de ficheiros diferente, por exemplo, ext4 com "`mkfs.ext4 /dev/mapper/sdx1`". Se em vez disso for utilizado o btrfs, o pacote `udisks2-btrfs` precisa de ser instalado. Para estes sistemas de ficheiros, a propriedade do ficheiro e as permissões podem ter de ser configuradas.

### 9.9.2. Montar discos encriptados com dm-crypt/LUKS

Por exemplo, uma partição de disco criada com dm-crypt/LUKS em "`/dev/sdc5`" pelo instalador Debian pode ser montada em `/mnt`" como a seguir:

    $ sudo cryptsetup open /dev/sdc5 ninja --type luks
    Enter passphrase for /dev/sdc5: ****
    $ sudo lvm
    lvm> lvscan
      inactive          '/dev/ninja-vg/root' [13.52 GiB] inherit
      inactive          '/dev/ninja-vg/swap_1' [640.00 MiB] inherit
      ACTIVE            '/dev/goofy/root' [180.00 GiB] inherit
      ACTIVE            '/dev/goofy/swap' [9.70 GiB] inherit
    lvm> lvchange -a y /dev/ninja-vg/root
    lvm> exit
      Exiting.
    $ sudo mount /dev/ninja-vg/root /mnt

## 9.10. O kernel

Debian distribui o kernel Linux organizado em módulos como pacotes para as arquitecturas suportadas.

Se está a ler esta documentação, provavelmente não precisa de compilar o kernel Linux por si próprio.

### 9.10.1. Parâmetros do kernel

Muitas funcionalidades do Linux são configuráveis via parâmetros de kernel como a seguir.

- Parâmetros de kernel iniciados pelo gestor de arranque (veja Seção 3.1.2, “Estágio 2: o gestor de arranque”)

- Parâmetros de kernel alterados pelo sysctl(8) durante a execução para os acessíveis via sysfs (veja Seção 1.2.12, “procfs e sysfs”)

- Parâmetros de módulos definidos por argumentos do modprobe(8) quando um módulo é activado (veja Seção 9.7.3, “Montar o ficheiro de imagem de disco”)

Ver "Guia do utilizador e do administrador do kernel Linux » Os parâmetros da linha de comandos do kernel" para mais detalhes.

### 9.10.2. Cabeçalhos do kernel

A maioria dos programas normais não precisa dos cabeçalhos do kernel e na verdade podem bloquear se os usar directamente para compilação. Eles devem ser compilados contra os cabeçalhos em "`/usr/include/linux`" e "`/usr/include/asm`" disponibilizado pelo pacote `libc6-dev` (criado a partir do pacote fonte `glibc`) no sistema Debian.

| Nota
Para compilar alguns programas específicos do kernel, tais como os módulos do kernel a partir da fonte externa e o daemon automounter (`amd`), tem de incluir o caminho para os cabeçalhos correspondentes do kernel, e.g. "`-I/usr/src/linux-particular-version/include/`", na sua linha de comandos.

### 9.10.3. Compilar o kernel e módulos relacionados

O Debian tem método próprio dele para compilar o kernel e os módulos relacionados.

Tabela 9.26. Lista de pacotes chave a serem instalados para a recompilação do kernel no sistema Debian

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`build-essential` | V:16, I:511 | 17 | pacotes essenciais para construir pacotes Debian: `make`, `gcc`, …
`bzip2` | V:163, I:972 | 113 | utilitários de compressão e descompressão para ficheiros bz2
`libncurses5-dev` | I:36 | 6 | bibliotecas de programadores e documentos para ncurses
`git` | V:406, I:616 | 50972 | git: sistema de controle de versão distribuído usado pelo kernel Linux
`fakeroot` | V:31, I:513 | 224 | disponibiliza um ambiente de falso-root para construção de pacotes como não-root
`initramfs-tools` | V:465, I:988 | 49 | ferramenta para construir uma initramfs (específico de Debian)
`dkms` | V:79, I:147 | 235 | suporte de módulos de kernel dinâmicos (DKMS) (genérico)
`module-assistant` | V:1, I:13 | 395 | ferramenta auxiliar para fazer pacotes de módulos (específico para Debian)
`devscripts` | V:5, I:32 | 2763 | scripts de ajuda para um responsável de pacote Debian (específico de Debian)

Se usa `initrd` em Seção 3.1.2, “Estágio 2: o gestor de arranque”, certifique-se de ler a informação relacionada em initramfs-tools(8), update-initramfs(8), mkinitramfs(8) e initramfs.conf(5).

| Atenção
Não ponha ligações simbólicas aos diretórios na árvore fonte (ex. "`/usr/src/linux*`") a partir de "`/usr/include/linux`" e "`/usr/include/asm`" quando compilar a fonte do kernel Linux. (Alguns documentos antigos sugerem isto.)

| Nota

Quando compilar o kernel Linux mais recente no sistema Debian `stable`, pode ser necessário o uso das ferramentas backport mais recentes do Debian `unstable`.

module-assistant(8) (ou a sua forma curta `m-a`) ajuda os utilizadores a construir e instalar facilmente pacote(s) de módulos para um ou mais kernels personalizados.

O suporte dinâmico a módulos do kernel (DKMS) é uma nova infraestrutura independente da distribuição desenhada para permitir que módulos de kernel individuais sejam atualizados sem se alterar todo o kernel. Isto é usado para a manutenção de módulos de fora-da-árvore. Isto também facilita a reconstrução de módulos quando se atualiza os kernels.

### 9.10.4. Compilar código-fonte do kernel: a recomendação da equipa do kernel de Debian

Para compilar pacotes binários de kernels personalizados a partir do código-fonte original, deve utilizar o alvo disponibilizado por "`deb-pkg`".

    $ sudo apt-get build-dep linux
    $ cd /usr/src
    $ wget https://mirrors.edge.kernel.org/pub/linux/kernel/v6.x/linux-version.tar.xz
    $ tar --xz -xvf linux-version.tar.xz
    $ cd linux-version
    $ cp /boot/config-version .config
    $ make menuconfig
     ...
    $ make deb-pkg

| Dica
O pacote linux-source-version disponibiliza o código-fonte do kernel Linux com os patches Debian como "`/usr/src/linux-version.tar.bz2`".

Para construir pacotes binários específicos a partir do pacote de código-fonte do kernel Debian, deve utilizar os alvos "`binary-arch_architecture_featureset_flavour`"em "`debian/rules.gen`".

    $ sudo apt-get build-dep linux
    $ apt-get source linux
    $ cd linux-3.*
    $ fakeroot make -f debian/rules.gen binary-arch_i386_none_686

Veja mais informação:

- Wiki Debian: KernelFAQ

- Wiki Debian: DebianKernel

- Debian Linux Kernel Handbook: https://kernel-handbook.debian.net

### 9.10.5. Controladores de hardware e firmware

O driver de hardware é o código que corre nos CPUs principais do sistema alvo. A maioria dos drivers de hardware estão agora disponíveis como software livre e estão incluídos nos pacotes normais do kernel Debian na área `main`.

- Controlador de GPU

  - Controlador de GPU Intel (`main`)

  - Controlador de GPU AMD/ATI (`main`)

  - Controlador de GPU NVIDIA (`main` nouveau e em `non-free` controladores binários, sem código fonte, suportados pelo fabricante.)

O firmware é o código ou os dados carregados no dispositivo ligado ao sistema de destino (por exemplo, micro-código da CPU, código de renderização executado na GPU, ou dados FPGA / CPLD, ...). Alguns pacotes de firmware estão disponíveis como software livre, mas muitos pacotes de firmware não estão disponíveis como software livre, uma vez que contêm dados binários sem fonte. A instalação destes dados de firmware é essencial para que o dispositivo funcione como esperado.

- Os pacotes de dados do firmware que contêm dados carregados na memória volátil do dispositivo de destino.

  - firmware-linux-free (`main`)

  - firmware-linux-nonfree (`non-free-firmware`)

  - firmware-linux-* (`non-free-firmware`)

  - *-firmware (`non-free-firmware`)

  - intel-microcode (`non-free-firmware`)

  - amd64-microcode (`non-free-firmware`)

- Os pacotes de programas de atualização do firmware que actualizam os dados na memória não volátil do dispositivo alvo.

  - fwupd (`principal`): Daemon de atualização de firmware que descarrega dados de firmware do Linux Vendor Firmware Service.

  - gnome-firmware (`main`): Interface GTK para o fwupd

  - plasma-discover-backend-fwupd (`main`): Interface Qt para fwupd

Por favor note que o acesso aos pacotes `non-free-firmware` são disponibilizados pelo meio de instalação oficial para oferecer uma experiência de instalação funcional ao utilizador desde Debian 12 Bookworm. A área `non-free-firmware` é descrita em Seção 2.1.5, “Básico do arquivos Debian”.

Tenha também em atenção que os dados de firmware descarregados pelo fwupd a partir do Linux Vendor Firmware Service e carregados para o kernel Linux em execução podem não ser `livres`.

## 9.11. Sistema virtualizado

O uso de sistema virtualizado permite-nos correr várias instâncias do sistema simultâneamente num único hardware.

| Dica
Veja o wiki Debian sobre SystemVirtualization.

### 9.11.1. Ferramentas de virtualização e emulação

Existem várias plataformas de ferramentas de virtualização e emulação.

- Pacotes completos de emulação de hardware, como os instalados pelo meta-pacote games-emulator

- Principalmente emulação de nível de CPU com algumas emulações de dispositivos de E/S, como o QEMU

- Principalmente virtualização no nível da CPU com algumas emulações de dispositivos de E/S, como a Máquina Virtual baseada em Kernel (KVM)

- Virtualização de contentores ao nível do SO com suporte ao nível do kernel, como LXC (Linux Containers), Docker, systemd-nspawn(1), ...

- Virtualização do acesso ao sistema de ficheiros ao nível do SO com a substituição da chamada da biblioteca do sistema no caminho do ficheiro, como o chroot

- Virtualização do acesso ao sistema de ficheiros ao nível do SO com a substituição da chamada da biblioteca do sistema sobre a propriedade do ficheiro, como o fakeroot

- Emulação da API do SO, como o Wine

- Virtualização ao nível do interpretador com a sua seleção de executáveis e substituições de bibliotecas em tempo de execução, tais como virtualenv e venv para Python

A virtualização de contentores utiliza Seção 4.7.5, “Caraterísticas de segurança do Linux” e é a tecnologia por trás de Seção 7.7, “Sandbox”.

Aqui estão alguns pacotes para o ajudar a configurar o sistema virtualizado.

Tabela 9.27. Lista de ferramentas de virtualização

pacote | popcon | tamanho | descrição
--- | --- | --- | ---
`coreutils` | V:911, I:1000 | 17994 | Utilitários do núcleo GNU que contêm chroot(8)
`util-linux` | V:917, I:1000 | 4658 | utilitários de sistema variados que contêm unshare(1)
`systemd-container` | V:73, I:76 | 2710 | ferramentas de contentor/nspawn do systemd que contêm systemd-nspawn(1)
`schroot` | V:6.8, I:8.8 | 2222 | ferramenta especializada para executar pacotes binários Debian em chroot
`sbuild` | V:1.3, I:6.4 | 154 | ferramenta para construir pacotes binários Debian a partir de fontes Debian
`debootstrap` | V:5, I:45 | 331 | bootstrap um sistema Debian básico (escrito em sh)
`mmdebstrap` | V:7, I:12 | 574 | bootstrap um sistema Debian (escrito em Perl)
`cdebootstrap` | V:0.1, I:1.3 | 114 | bootstrap um sistema Debian (escrito em C)
`cloud-image-utils` | V:1, I:14 | 66 | utilitários de gestão de imagens na nuvem
`cloud-guest-utils` | V:5, I:22 | 71 | utilitários para hóspedes na nuvem
`virt-manager` | V:12, I:48 | 2310 | Virtual Machine Manager: aplicação de ambiente de trabalho para gerir máquinas virtuais
`libvirt-clients` | V:49, I:71 | 1159 | programas para a biblioteca libvirt
`docker.io` | V:48, I:50 | 81426 | docker: tempo de execução do contentor Linux
`podman` | V:31, I:34 | 84758 | podman: motor para executar contentores baseados em OCI em Pods
`podman-docker` | V:2.8, I:3.3 | 270 | motor para executar contentores baseados em OCI em Pods - revestimento para docker
`incus` | V:0.8, I:2.9 | 23 | Incus: contentor de sistema e gestor de máquinas virtuais
`games-emulator` | I:0.18 | 21 | emulador de jogos: Emuladores Debian para jogos
`bochs` | V:0.07, I:0.64 | 8180 | Bochs: emulador PC IA-32
`qemu-system` | I:21 | 61 | QEMU: binários de emulação de sistema completo
`qemu-user` | V:5.8, I:9.3 | 468923 | QEMU: binários de emulação em modo de utilizador
`qemu-utils` | V:14, I:108 | 12175 | QEMU: utilitários
`qemu-system-x86` | V:53, I:92 | 68056 | KVM: virtualização completa em hardware x86 com virtualização assistida por hardware
`virtualbox` | V:3.4, I:4.1 | 151566 | VirtualBox: solução de virtualização x86 em i386 e amd64
`gnome-boxes` | V:1.2, I:6.4 | 7045 | Boxes: Aplicativo GNOME simples para acessar sistemas virtuais
`xen-tools` | V:0.1, I:1.5 | 719 | ferramentas para gerir o servidor virtual XEN do debian
`wine` | V:13, I:55 | 204 | Wine: Windows API Implementation (suite standard)
`dosbox` | V:1, I:12 | 2697 | DOSBox: emulador x86 com gráficos Tandy/Herc/CGA/EGA/VGA/SVGA, som e DOS
`lxc` | V:10, I:13 | 1629 | Ferramentas de espaço do utilizador de contentores Linux
`python3-venv` | V:8, I:147 | 6 | venv para criar ambientes virtuais python (biblioteca de sistema)
`python3-virtualenv` | V:7, I:39 | 374 | virtualenv para criar ambientes python virtuais isolados
`pipx` | V:7, I:47 | 4409 | pipx para instalar aplicações python em ambientes isolados

Veja o artigo da Wikipedia Comparação de plataformas de máquinas virtuais para uma comparação detalhada das diferentes soluções de plataformas de virtualização.

### 9.11.2. Fluxo de trabalho da virtualização

| Nota
Os kernels predefinidos de Debian suportam KVM desde `lenny`.

O fluxo e trabalho típico para virtualização envolve vários passos.

- Criar um sistema de ficheiros vazio (uma árvore de ficheiros ou uma imagem de disco).

  - A árvore de ficheiros pode ser criada por "`mkdir -p /path/to/chroot`".

  - A imagem de disco crua pode ser criada com o dd(1) (veja Seção 9.7.1, “Criar o ficheiro de imagem de disco” e Seção 9.7.5, “Criar um ficheiro de imagem de disco vazio”).

  - qemu-img(1) pode ser usado para criar e converter ficheiros de imagem de disco suportados pelo QEMU.

  - Os formatos de ficheiro cru e VMDK podem ser usados como formatos comuns entre ferramentas de virtualização.

- Montar a imagem de disco com mount(8) no sistema de ficheiros (opcional).

  - Para o ficheiro de imagem de disco cru, monte-o como aparelho loop ou aparelho do device mapper (veja Seção 9.7.3, “Montar o ficheiro de imagem de disco”).

  - Para imagens de disco suportadas pelo QEMU, monte-as como aparelhos de bloco de rede (veja Seção 9.11.3, “Montar o ficheiro de imagem de disco virtual”).

- Povoar o sistema de ficheiros alvo com os dados de sistema necessários.

  - O uso de programas como o `debootstrap` e o `cdebootstrap` ajudam com este processo (veja Seção 9.11.4, “Sistema chroot”).

  - Use instaladores de SOs sob o emulador de sistema completo.

- Correr um programa sob um ambiente virtualizado.

  - chroot disponibiliza um ambiente virtualizado básico suficiente para compilar programas, correr aplicações de consola e correr daemons nele.

  - QEMU oferece emulação de CPU de várias plataformas.

  - QEMU com KVM oferece emulação de sistema completo pela virtualização assistida a hardware.

  - VirtualBox oferece emulação de sistema completo em i386 ou amd64 com ou sem a virtualização assistida a hardware.

### 9.11.3. Montar o ficheiro de imagem de disco virtual

Para o ficheiro de imagem de disco raw, veja Seção 9.7, “A imagem de disco”.

Para outros ficheiros de imagem de disco virtual, pode usar o `qemu-nbd` para exportá-los pelo protocolo aparelho de bloco de rede e montá-los a usar o módulo de kernel `nbd`.

O qemu-nbd(8) suporta os formatos de disco suportados pelo QEMU: raw, qcow2, qcow, vmdk, vdi, bochs, cow (modo-de-utilizador de Linux de copiar-ao-escrever), parallels, dmg, cloop, vpc, vvfat (VFAT virtual) e aparelho_máquina.

O aparelho de bloco em rede pode suportar partições do mesmo modo que o aparelho de loop (veja Seção 9.7.3, “Montar o ficheiro de imagem de disco”). Pode montar a primeira partição de "`disk.img`" como a seguir.

    # modprobe nbd max_part=16
    # qemu-nbd -v -c /dev/nbd0 disk.img
    ...
    # mkdir /mnt/part1
    # mount /dev/nbd0p1 /mnt/part1

| Dica
Pode exportar apenas a primeira partição de "`disk.img`" a usar a opção "`-P 1`" para qemu-nbd(8).

### 9.11.4. Sistema chroot

Se deseja experimentar um novo ambiente Debian a partir de uma consola terminal, eu recomendo que use chroot. Isto permite-lhe correr aplicações de consola em Debian `unstable` e `testing` sem os riscos habituais associados e sem reiniciar. chroot(8) é a forma mais básica.

| Cuidado
Os exemplos abaixo assumem que tanto o sistema base como o sistema chroot partilham a mesma arquitetura de CPU `amd64`.

Embora possa criar manualmente um ambiente chroot(8) utilizando o debootstrap(1), isto requer esforços não triviais.

O pacote sbuild para construir pacotes Debian a partir da fonte usa o ambiente chroot gerido pelo pacote schroot. Vem com o script auxiliar sbuild-createchroot(1). Vamos aprender como ele funciona, executando-o da seguinte forma.

    $ sudo mkdir -p /srv/chroot
    $ sudo sbuild-createchroot -v --include=eatmydata,ccache unstable /srv/chroot/unstable-amd64-sbuild http://deb.debian.org/debian
     ...

Pode ver como debootstrap(8) preenche os dados do sistema para o ambiente `unstable` em "`/srv/chroot/unstable-amd64-sbuild`" para um sistema de compilação mínimo.

Pode iniciar sessão neste ambiente utilizando schroot(1).

    $ sudo schroot -v -c chroot:unstable-amd64-sbuild

Veja como é criada uma shell de sistema a correr num ambiente `unstable`.

| Nota
O ficheiro "`/usr/sbin/policy-rc.d`" que sai sempre com 101 impede que os programas daemon sejam iniciados automaticamente no sistema Debian. Veja "`/usr/share/doc/init-system-helpers/README.policy-rc.d.gz`".

| Nota
Alguns programas sob chroot podem requerer acesso a mais ficheiros do sistema pai para funcionarem do que o `sbuild-createchroot` disponibiliza como acima. Por exemplo, "`/sys`", "`/etc/passwd`", "`/etc/group`", "`/var/run/utmp`", "`/var/log/wtmp`", etc. podem precisar de ser montados em união ou copiados.

| Dica
O pacote `sbuild` ajuda a construir um sistema chroot e constrói um pacote dentro do chroot usando `schroot` como seu backend. É um sistema ideal para verificar dependências de construção. Veja mais sobre o sbuild na wiki Debian e um exemplo de configuração do sbuild em "Guia para administradores Debian".

| Dica
O comando systemd-nspawn(1) ajuda a executar um comando ou SO num contentor leve de forma semelhante ao `chroot`. Ele é mais poderoso, pois usa namespaces para virtualizar completamente a árvore de processos, IPC, nome de host, nome de domínio e, opcionalmente, rede e bancos de dados de usuários. Veja systemd-nspawn.

### 9.11.5. Sistemas de vários ambientes de trabalho

Se deseja experimentar um novo ambiente de trabalho GUI de qualquer SO, eu recomendo que use QEMU ou KVM num sistema Debian `stable` para correr múltiplos sistemas de desktop de forma segura usando virtualização. Estes permitem-lhe correr quaisquer aplicações de área de trabalho incluindo as da Debian `unstable` e `testing` sem os riscos habituais associados a elas e sem reiniciar.

Como o QEMU puro é muito lento, é recomendado acelerá-lo com KVM quando o sistema da máquina o suporta.

Virtual Machine Manager, também conhecido como `virt-manager`, é uma ferramenta GUI conveniente para gerir máquinas virtuais KVM através da libvirt.

A imagem de disco virtual "`virtdisk.qcow2`" que contem um sistema Debian para o QEMU pode ser criada a usar o instalador de debian em pequenos CDs como a seguir.

    $ wget https://cdimage.debian.org/debian-cd/5.0.3/amd64/iso-cd/debian-503-amd64-netinst.iso
    $ qemu-img create -f qcow2 virtdisk.qcow2 5G
    $ qemu -hda virtdisk.qcow2 -cdrom debian-503-amd64-netinst.iso -boot d -m 256
    ...

| Dica
Correr outras distribuições de GNU/Linux como o Ubuntu e o Fedora sob virtualização é um bom modo de aprender dicas de configuração. Também outros SOs proprietários podem correr muito bem sob esta virtualização do GNU/Linux.

Veja mais dicas em Debian wiki: SystemVirtualization.

[2] Exemplos de personalização mais elaborados: "Vim Galore", "sensible.vim", ...

[3] vim-pathogen foi popular.

Capítulo 8. I18N e L10N |  | Capítulo 10. Gestão de dados