Memória de vídeo no Linux

Descobrir a quantidade de memória de vídeo no Linux…

1) Utilizando o comando lspci:

$ lspci -v | grep -A4 -i vga
00:02.0 VGA compatible controller: Intel Corporation Core Processor Integrated Graphics Controller (rev 18) (prog-if 00 [VGA controller])
Subsystem: Dell Device 049c
Flags: bus master, fast devsel, latency 0, IRQ 46
Memory at fe000000 (64-bit, non-prefetchable) [size=4M]
Memory at c0000000 (64-bit, prefetchable) [size=256M]

O comando lspci lista os dispositivos instalados no computador. No caso, utilizei o -v (verbose) para ter mais informações e filtrei a saída com o comando grep, pedindo para mostrar 4 linhas após encontrar o padrão vga.

E na saída do comando, temos na ultima linha a quantidade de memória de vídeo.

2) Analisando o log do Xorg:

$ cat /var/log/Xorg.0.log | grep VideoRam
[    21.295] (==) intel(0): VideoRam: 262144 KB

Nesse caso, a quantidade de memória está em KB então, para saber ao certo, pega o valor total e divide por 1024:

262144/1024 = 256

Os dois modos para se ver a quantidade de memória são válidos, porém achei o segundo método mais atualizado, pois o que está registrado no log é o que o sistema identificou durante o boot.

Referências:

Video Memory – http://fixunix.com/x/19532-video-memory.html

Servidor X – https://ivanix.wordpress.com/2009/09/06/servidor-x/

Variáveis de ambiente

Como já falamos em um post anteriormente, o shell é a interface entre o usuário e o kernel do sistema operacional.

O shell padrão do Linux é o bash; ele é executado em um ambiente controlado pelas variáveis de ambiente, que nada mais são do que definições e valores que, tanto o shell como outros programas utilizam para configuração do ambiente do usuário no momento em que é realizado o login.

Existem dois tipos de variáveis:

✔ Variáveis de Usuários – variáveis criadas pelo próprio usuário.
✔ Variáveis de Sistema – variáveis criadas pelo próprio sistema.

Variáveis de Ambiente

Como dito anteriormente, variáveis são nomes que contém algum valor e tem a forma Nome=Valor. Lembram, quando estavam na escola e tinha que fazer as continhas para descobrir o valor da variável x? Por exemplo, x=10. Traduzindo para a forma Nome=Valor, aqui o x, seria o Nome, e Valor, o conteúdo da variável.

As variáveis de ambiente são individuais para cada usuário do sistema ou consoles virtuais e permanecem residentes na memória RAM até que o usuário saia do sistema (logoff) ou até que o sistema seja desligado.

Algumas variáveis do GNU/Linux afetam o comportamento de todo o Sistema Operacional, como por exemplo, o idioma utilizado e o path.

A declaração de variáveis é feita da seguinte forma:

NOME_DA_VARIAVEL=valor_inicial

Onde:

NOME_DA_VARIAVEL – Nada mais é que o nome que queremos dar a nossa variável.

valor_inicial – É o primeiro valor que daremos a nossa variável. Este valor se faz necessário para determinar ao sistema que “tipo” de informação iremos ter na variável.

Exemplo:

Criar uma variável chamada LINUX com o valor Debian:

# LINUX=Debian

Para visualizarmos o conteúdo de uma variável, utilizamos o comando echo, que, além de exibir mensagens na tela, também tem o poder de exibir o conteúdo de uma variável.

Visualizando o conteúdo da variável criada:

# echo $LINUX
Debian

No exemplo acima, estamos visualizando o valor da variável LINUX, que é Debian.

Para que o shell saiba que o comando echo deve exibir o conteúdo de uma variável e não mostrar uma mensagem na tela, devemos adicionar no início do nome da variável o caractere $.

Comandos para manipular variáveis de ambiente

set
O comando set lista todas as variáveis de ambiente do usuário tais como o nome da máquina, arquitetura da máquina, usuário logado, etc…

Exemplo:

# set
HOSTNAME=switch
HOSTTYPE=i486
USER=root
MACHTYPE=i486-pc-linux-gnu
OSTYPE=linux-gnu

Se quisermos visualizar a variável que criamos, podemos filtrar a saída do comando set:

# set | grep LINUX
LINUX=Debian

export
O comando export faz com que a variável criada seja visualizada em todos shells. No exemplo em que criamos a variável LINUX, esta ficou disponível somente no shell em que foi criada… para que seja visualizada em um novo shell, é necessário exportar; e aí, utilizamos o comando export.

Exemplo:

# export LINUX

Para visualizar a variável que foi exportada, utilizamos o comando env, que é o responsável por visualizar as variáveis definidas globalmente:

# env

Visualizar somente a variável LINUX que foi exportada:

# env | grep -i linux
LINUX=Debian

Arquivos de configuração do ambiente do usuário

Além dos comandos que vimos acima, existem arquivos que são utilizados para configurar e carregar o ambiente do usuário. Isso quer dizer que, em um shell que exige login, ou seja, pede um nome de usuário e senha, o sistema irá verificar a existência dos arquivos listados abaixo e executará os comandos que estiverem dentro dos mesmos:

1) /etc/profile
2) ~/.bash_profile
3) ~/.bash_login
4) ~/.profile

/etc/profile
Este arquivo contém comandos que são executados para todos os usuários do sistema no momento do login; somente o usuário root tem permissão para modificar este arquivo.

Ele é lido antes do arquivo de configuração pessoal de cada usuário (.profile caso seja root e .bash_profile caso seja um usuário comum).
.bash_profile
Este arquivo reside no diretório pessoal de cada usuário. É executado em ambientes que usam autenticação (nome e senha). O .bash_profile contém comandos que são executados para o usuário no momento do login no sistema.

Lembrando que se trata de um arquivo oculto pois tem um “.” no início do nome. Aqui, podemos configurar por exemplo, os alias que vimos no post anterior.

Por exemplo:

# echo “alias rm=’rm i'” >> ~/.bash_profile

O comando acima, irá acrescentar a linha alias dentro do arquivo .bash_profile. Fique atento ao operador de redirecionamento, que é o >>, isto é, está acrescentando a linha no arquivo!

Variável PS1
Essa é a variável que contém o formato do prompt do Linux. Ela pode ser modificada através do arquivo .bash_profile (para usuários comuns) ou no .profile (para usuário root).

Por padrão, ela vem configurada da seguinte forma:

PS1=”[\u@\h \W]\$”

Cada uma dessas letras, exibe uma informação no prompt:
\u => Exibe o usuário no momento;
\h => Exibe o nome da máquina;
\W => Exibe o caminho completo do diretório que você está no momento
\$ => Indica o tipo de usuário logado. Se você for usuário comum, será apresentado o símbolo $, em caso do superusuário (root), será #.

Assim como praticamente tudo no Linux, seu prompt pode ser personalizado também. Por exemplo, alguém pode sentir saudade do ‘cebiquim’, isto é, do famoso C:\>.

Não é elegante como o prompt do Linux, mas… se quiser matar a saudade, faça assim:

PS1=”C:\> “

Configurando a variável PS1 conforme mostrado acima, seu terminal trará o C:\>.

Depois que altera o arquivo, é necessário atualizá-lo para que as configurações sejam aplicadas. Você pode deslogar e logar novamente, ou então, utilizar o comando source:

# source ~/.bashrc

O comando acima, irá reler o arquivo .bashrc e efetuar as alterações no prompt.

É isso aí, pessoas… até o próximo post 😉 !

Comando alias

Neste post, vou falar sobre alias, que seriam mais ou menos como apelidos que podemos colocar em comandos. Muitas vezes temos uma linha de comando muito extensa, então é mais fácil criar um apelido para essa  linha de comando ao invés de digitar a linha toda.

O comando que cria os tais apelidos, é o alias… e sua sintaxe é:

alias <apelido>='<comando_linux>

Onde, <apelido> é o “apelido”, e, <comando_linux>, é o comando real que receberá o alias.

E detalhe… não deve existir espaços antes e depois do “=” e, caso o <comando_linux> tenha mais de uma palavra, ele deve vir entre ‘aspas simples’.

Por exemplo… teve um post que falei sobre o comando rm… e até mencionei que este é um comando que deve ser utilizado com muito cuidado!

Nos exemplos do comando rm, vimos que existe a opção -i, que é interativo… e teve até um comentário no post, falando sobre criar um alias para pedir confirmação ao remover um arquivo ou diretório!

Então, vamos criar o alias aqui:

# alias rm=’rm -i’

Após executar o comando acima, toda vez que for remover um arquivo ou diretório, será solicitado uma confirmação. Por exemplo:

# cd /tmp

# touch teste.txt

# rm teste.txt
rm: remove arquivo comum vazio `teste.txt’? y

Para confirmar a remoção, basta teclar y ou então, se desistir de remover, basta teclar n.

Outro exemplo de alias: para limpar o terminal, no Linux utilizamos o comando clear. Para quem tem saudades do DOS e quer usar o cls, basta criar um alias com esse nome:

# alias cls=’clear’

Aí, toda vez que executar o comando cls, irá limpar a tela.

É importante lembrar que, ao criar o alias, o comando original, não será apagado! Isso quer dizer que, caso digite o comando clear, ele irá limpar a tela normalmente! Só no caso do comando rm que, se você não remover o alias ele sempre irá pedir confirmação… se bem que no caso do rm, sempre é bom manter o alias que pede a confirmação 😉 !

Para checar os alias disponíveis, basta executar o comando alias sem argumentos:

# alias
alias rm=’rm -i’
alias cls=’clear’

Para remover um alias, basta executar:

# unalias cls

# alias
alias rm=’rm -i’

Para remover todos os alias:

# unalias -a

Onde a opção -a irá remover todas as definições de alias.

Até o próximo post! 😉

Perdeu algo no sistema? Utilize o find ou o locate!

Neste post, irei abordar os comandos find e locate que são utilizados para fazer buscas no sistema.

Ambos tem a mesma função; porém o comando find executa a busca direto no local que você especificou, enquanto o comando locate executa a busca a partir de uma base.

Explicando melhor… com o comando find, cada vez que solicitamos uma busca, ele tenta localizar o que pedimos dentro do local que especificamos e aproveita checa os subdiretórios também. Assim, uma busca com o find pode demorar um pouco, principalmente se o local especificado tiver muitos diretórios!

A sintaxe do comando find é:

find caminho opções nome_do_que_será_procurado

Exemplo:

# find / -name passwd
/etc/passwd
/etc/pam.d/passwd
/usr/bin/passwd
/usr/share/lintian/overrides/passwd
/usr/share/linda/overrides/passwd
/usr/share/doc/passwd

A leitura do comando acima, seria algo como “procure no diretório / algo que case com o nome (opção -name) passwd”; ou seja, pedimos para o find procurar dentro da estrutura do diretório / algo que tenha passwd no nome!

Outro exemplo de uso do find:

# find /etc/ -type d -name apt
/etc/apt

Acima, pedi para o comando find localizar dentro da estrutura do /etc algum diretório (opção type -d) algo que case com o nome apt!

A opção -type aceita os seguintes argumentos: farquivos; ddiretórios e llinks simbólicos.

Agora, falando sobre o comando locate, ele faz a busca dentro de uma base que é construída com um outro comando, o updateb.

Assim a busca sendo um pouco mais rápida, pois o locate vai usar a base que o updatedb construiu! Só um detalhe muito importante: imagine que você tenha atualizado a base do comando locate e em seguida crie um novo arquivo. Se você não executar o updatedb novamente, o arquivo que acabou de ser criado não será localizado pelo locate!

Então, antes de vermos um exemplo do locate, vamos construir a base que ele irá utilizar:

# updatedb

Esse comando pode demorar um pouquinho para ser terminar e deve ser rodado como root (o usuário administrador da máquina). Enquanto o updatedb estiver rodando, o terminal fica indisponível… quando você receber o prompt de volta, significa que o comando terminou e aí pode passar para o próximo passo, que é executar uma busca com o locate.

Exemplo:

# locate passwd
/etc/pam.d/passwd
/etc/passwd
/etc/passwd-
/lib/security/pam_unix_passwd.so
/usr/bin/gpasswd

Um outro exemplo… imagine que você tenha criado um arquivo no sistema e não lembre onde está guardado. E o pior, não faz nem idéia se criou o arquivo como Marketing.txt ou marketing.txt ou MARKETING.TXT….

Aí complicou… são muitas possibilidades, e você está perdido… então vamos usar a opção -i do locate para localizar o tal arquivo! Essa opção é ignore-case, ou seja, ele vai procurar independente do arquivo estar nomeado em maiúsculo ou não!

Então.. primeiro a gente atualiza a base do locate:

# updatedb

Agora, vamos tentar localizar o arquivo:

# locate -i marketing
/root/MaRkEtIng.tXt

Mmmmm.. que nome hein! Se não existisse a opção -i ia ser difícil advinhar onde estava o arquivo!

Bem, esses são os exemplos deste post.Os comandos find e locate são muito úteis para localizar algo dentro do sistema….

O comando find é poderoso (tem um monte de opções bacanas) e, reza a lenda que ele acha até moeda de um centavo perdida no limbo do seu home 😉 !

Ficam aí duas opções que podemos usar para localizar arquivos e diretórios, mas é importante lembrar que o que foi mostrado aqui não é tudo! Então, para saber mais…

# man find

# find –help

# man locate

# locate –help

Renomeando arquivos e diretórios

Neste post, vou falar sobre o comando mv. Este comando possui 2 funções: renomear e mover.

E quando eu digo mover, é isso mesmo que você está imaginando… é mudar o arquivo ou diretório de um lugar para outro… e a função renomear o arquivo, seria como se você estivesse no modo gráfico e clicasse com o botão direito do mouse e escolhesse a opção ‘Renomear’!

A sintaxe do comando mv é igual à sintaxe do comando cp… basicamente, só muda o comando!

# mv origem destino

Mas essa sintaxe é tradicioanl e muito chata de ler. Então, vamos bater um papo com o comando que fica mais fácil:

mv (mover) o que? (que é a origem)  para onde? (destino, o local para onde mudar, ou o novo nome do arquivo ou diretório)

Vamos ver um exemplo do comando mv… por partes, como faria Jack:

# cd /tmp

# echo “Aprendendo a usar o mv” > mover.txt

# cat mover.txt
Aprendendo a usar o mv

No exemplo acima, entramos no diretório /tmp e usamos o comando echo para criar um arquivo chamado mover.txt.

Mas não gostei desse nome, então, eu vou renomear esse arquivo para nix.txt:

# cd /tmp

# mv mover.txt nix.txt

E o comando mv também tem a opção de verbose, isto é, mostra na tela a ação que está executando! Por exemplo, vamos renomear o arquivo nix.txt para teste.txt mostrando os detalhes:

# mv nix.txt teste.txt
`nix.txt’ -> `teste.txt’

Vejam que o mv, ao renomear mostra a ação que está executando! Ou seja, está dizendo prá você: “Estou renomeando o nix.txt para teste.txt!”
E, se você executar um ls para tentar achar o arquivo nix.txt, verá que o arquivo não existe mais:

# ls nix.txt
ls: nix.txt: Arquivo ou diretório não encontrado

Falando da outra função do mv, que é mover um arquivo ou diretório de um lugar para outro! Novamente, vamos por partes, como faria Jack!

Primeiro, vamos entrar no diretório /tmp e criar um diretório para usarmos como exemplo:

# cd /tmp

# mkdir domingaobrabo

# ls
domingaobrabo

Criamos o diretório, mas não quero que o nome seja domingaobrabo… vamos renomear para domingofeliz:

# mv domingaobrabo domingofeliz

Acima só renomeamos o diretório (viram… o mv não serve só para renomear arquivos!!!)… só que ele está dentro do /tmp! E não quero deixar ele aí pois quando eu desligar a máquina, ele será apagado!

Então agora, vamos fazer assim… vou mover, ou seja, vou mudar meu domingofeliz para o /mnt! E, para ajudar a ver a ‘mudança’, vamos usar o comando com o -v, mostrando na tela o que ele está fazendo:

# mv domingaobrabo domingofeliz

#  mv -v domingofeliz /mnt
`domingofeliz’ -> `/mnt/domingofeliz’

# ls /mnt/
domingofeliz

Outra opção do comando mv, que é muito interessante para se utilizar no dia-a-dia, é a -i. Essa opção é de interative; ou seja, vai pedir a confirmação do usuário para sobrescrever um arquivo já existente! Já ajuda a evitar desastres, pois você pode confirmar se quer sobrescrever ou não!

De novo, vamos por partes! Primeiro, vamos criar um arquivo chamado teste.txt dentro do diretório /mnt/domingofeliz:

# touch /mnt/domingofeliz/teste.txt

Em seguida, vamos no diretório /tmp para criar um arquivo também chamado teste.txt:

# touch /tmp/teste.txt

Acima, criamos 2 arquivos com o mesmo nome! Lembrem-se que um arquivo está no /mnt/domingofeliz e outro está no /tmp!

Vamos mv o arquivo teste.txt que está em /tmp para /mnt/domingofeliz, usando a opção de confirmação:

# mv -i teste.txt /mnt/domingofeliz/
mv: sobrescrever `/mnt/domingofeliz/teste.txt’? y
`teste.txt’ -> `/mnt/domingofeliz/teste.txt’

Acima, como o arquivo teste.txt já existe no /mnt/domingofeliz, a opção -i irá solicitar a confirmação para sobrescrever o arquivo existente.

Quer conhecer mais opções do comando mv?

# man mv

# mv –help

Até o próximo post! 😉

Removendo arquivos e diretórios

O comando rm é utilizado para apagar arquivos, diretórios e subdiretórios que estejam vazios ou que contenham arquivos.

Este comando deve ser utilizado com cuidado, pois quando removemos algo com rm, “foi-se”… e essa remoção pode custar um passada no RH e não vai ser para ganhar aumento de salário 😉 !

Exemplo:

# cd /tmp

# touch teste.txt

Acima, entramos no diretório /tmp e criamos um arquivo vazio chamado teste.txt. Mas decidimos que não queremos mais esse arquivo. Então, para removê-lo:

# rm teste.txt

Assim como no comando cp, o rm também pode utilizar a opção -i, que é o modo interative, para perguntar se queremos remover ou não um determinado arquivo ou diretório.

Exemplo:

# cd /tmp

# echo “Novo teste do rm” > teste.txt

# cat teste.txt
Novo teste do rm

# rm teste.txt
rm: remove regular file `teste.txt’? y

Vejam a sequência dos comandos executados:

Primeiro, entramos no /tmp; em seguida, criamos um arquivo… para isso, usamos o comando echo para jogar a mensagem dentro desse arquivo! Lembram do comando echo? Ele foi comentado há alguns posts atrás!

Depois, checamos o conteúdo do arquivo com o comando cat! Daí, resolvemos apagar o arquivo, mas pedindo uma confirmação. Então, entra em ação o comando rm, com a opção -i para perguntar se realmente queremos remover 😉 .

Como queremos… basta responder y e ele vai remover! Se depois do arquivo removido executarmos:

# cat teste.txt
cat: teste.txt: No such file or directory

Vejam… eu tentei ver o conteúdo do arquivo que apaguei, mas como não existe mais, ele reclamou que não achou o arquivo ou diretório!

Outro teste:

# ls teste.txt
ls: teste.txt: No such file or directory

Vejam que com o ls é a mesma coisa! Removi o arquivo… então ele não vai achar para listar!

Agora, para remover diretórios! Aqui, para o rm, vale a mesma regra do cp, quando eu quero copiar diretórios!!!

Ou seja, no cp, eu preciso da opção -r; e aqui, também vamos usar o -r que vai nos ajudar a remover diretórios que estejam cheios (que contenham arquivos dentro!

Exemplo:

# cp -r /etc /tmp

Copiamos o /etc para dentro do /tmp… e agora vamos removê-lo:

# cd /tmp

# rm -r etc

Vejam que não tem “/” na frente desse etc, pois é o que está dentro do diretório /tmp!

Mais uma vez, fica a dica: Tenham muita atenção ao usar o comando rm, pois uma uma vez que os arquivos e diretórios são removidos não podem mais ser recuperados, e um arquivo apagado incorretamente, pode danificar o sistema.

Vejam um exemplo – mas atenção:

NÃO FAÇAM ISSO EM CASA OU NO SERVIDOR DA EMPRESA!!!!!!!!!!!!


# rm -rf /

O comando acima, irá apagar todo o diretório / recursivamente… e ainda foi combinado com a opção f, que é force, para que ele remova sem perguntar nada. Ou seja, ele irá apagar todo o seu sistema!

Caso esse comando seja executado, é importante que você tenha um backup e repense nas políticas de acesso ao seu servidor para que ninguém saia executando esse comando 😉 !

Para finalizar o post, caso você tenha um diretório que esteja vazio, pode usar o comando rmdir. Esse comando, remove diretórios que estejam vazios, isto é, que não tenham arquivos dentro.

Exemplo:

# mkdir /tmp/lixo

# cd lixo

# cp /etc/passwd lixo

# ls lixo
passwd

# rmdir lixo
rmdir: lixo: Diretório não vazio

Na sequência de comandos acima, criamos um diretório chamado lixo dentro do /tmp e em seguida, entramos no diretório e copiamos um arquivo para dentro dele e listamos.

Quando fomos tentar remover o diretório lixo com o comando rmdir, ele não permitiu, pois o diretório contém arquivos. Para usar o comando rmdir, primeiro vamos ter que apagar os arquivos que estão dentro do diretório lixo e, ai sim, utilizar o rmdir:

# rm lixo/passwd

# ls lixo

# rmdir lixo

Agora que o diretório está vazio, o rmdir conseguiu apagar!

Para saber mais…

# man rm

# man rmdir

Copiando arquivos e diretórios

Neste post, vou falar sobre um comando, que é a forma mais simples de backup que existe! É o comando cp, que significa copy, ou cópia!

E ele é a forma mais simples de backup que existe, porque você está fazendo cópia de um arquivo ou diretório de um lugar para outro!

Esse comando tem a função de copiar arquivos e diretórios!!!

A sintaxe dele é:

# cp origem destino

Essa é a sintaxe tradicional! Mas para ficar mais simples, é preferível bater um papo com o comando e responder as perguntas que o comando costuma fazer para executar a ação que desejamos:

cp (copie) o que? (que é a origem) para onde? (é o destino, o local para onde quero copiar)

Essa regra de perguntas, é bem legal para ser usada com comandos… afinal de contas, o comando sempre vai esperar as nossas coordenadas para executar uma ação!

No caso do cp, a ação é copiar o que para onde!

Prática!

Criar um diretório chamado backup dentro de /mnt, e copiar um arquivo prá lá! Esse exemplo é legal porque vamos usar comandos que já foram comentados em posts anteriores:

# mkdir /mnt/backup

# cp /etc/passwd /mnt/backup

Nesse exemplo, o cp vai copiar o arquivo /etc/passwd para o /mnt/backup!

Uma coisa legal do comando cp que podemos usar… é a opção -v de verbose… ou seja.. modo detalhado! Ele vai te mostrar na tela a ação que ele fez!

Por exemplo!!

# cd /mnt/backup

# cp -v passwd
`passwd’ -> `/mnt/backup’

O que fizemos com o cp, foi simplesmente copiar o arquivo, mas mostrando na tela o que ele está copiando e para onde!

Ah, e o cp tem o poder de copiar o arquivo ou diretório para um nome diferente do original!

Isso é útil quando se vai mexer em arquivos de configuração, e aí é sempre bom ter um backup! Assim, se acontecer alguma coisa com o arquivo que está sendo trabalhado, temos o original!

Enfim… abençoados sejam os pessimistas pois eles fizeram backup 😛 !

Exemplo:

# cp /etc/ssh/sshd_config /etc/ssh/sshd_config_backup

Acima, um exemplo simples, onde eu joguei o conteúdo de /etc/ssh/sshd_config para /etc/ssh/sshd_config_backup! E o último arquivo não existia, então ele criou na hora!

Em tempo: o arquivo sshd_config, é para a configuração do serviço de acesso remoto ssh. Mais pra frente, comento sobre esse serviço em post só pra ele!

No caso do exemplo, forneci o caminho completo. Poderia ter feito assim:

# cd /etc

# cd ssh

# cp sshd_config sshd_config_backup

É a mesma coisa que fizemos anteriormente… mas é só para mostrar que não preciso estar exatamente dentro do diretório que tem o que eu quero copiar… posso copiar de qualquer lugar desde que eu forneça o caminho completo!

Uma outra opção do comando cp que é muuuuuuito importante, é a -r! Ela é usada quando eu quero copiar diretórios que tenham subdiretórios!

Exemplo:

#cp -r /etc /mnt/backup

Esse comando vai copiar o diretório /etc para dentro de /mnt/backup, incluindo os subdiretórios que existem nele!

Caso eu não coloque a opção (-r), ele não vai copiar nada, pois não foi especificado que queromo todo o diretório /etc dentro do diretóri /mnt/backup!

Exemplo:

# cp /etc /mnt/backup

Não vai copiar nada, pois o /etc é um diretório. Pode até executar um ls dentro de /mnt/backup e ver que não foi nada do /etc prá la!

Agora, se executarmos:

# cp -r /etc /mnt/backup

Ele vai copiar todo o diretório /etc para dentro de /mnt/backup, inclusive os diretórios que estão dentro de /etc!

E se realmente quisermos o conteúdo do /etc, sem o -r, temos que fazer:

# cp /etc/* /mnt/backup

E ele irá copiar tudo! O * (asterisco) indica tudo, porém esse tudo, é referente a arquivos, e não diretórios; isto é, vai omitir os diretórios… e copiar somente os arquivos!

Outra opção do cp, para ser utilizado no dia-a-dia, é a -i. Essa opção é de interative; ou seja, vai pedir a confirmação do usuário para sobrescrever um arquivo já existente!

Já ajuda a evitar desastres, pois você pode confirmar se quer sobrescrever ou não!

Exemplo:

# touch /mnt/backup/teste.txt

# touch /tmp/teste.txt

Acima, criamos 2 arquivos com o mesmo nome! Reparem que um arquivo está no /mnt/backup e outro está no /tmp!

Vamos copiar o arquivo teste.txt que está em /mnt/backup/ para /tmp, usando a opção de confirmação!

# cp -i /mnt/backup/teste.txt /tmp/
cp: sobrescrever `/tmp/teste.txt’? y

Acima, como o arquivo teste.txt já existe no /tmp, a opção -i solicita a confirmação para sobrescrever o arquivo existente.

Quer conhecer mais opções do comando cp?

# man cp

# cp –help

Até o próximo post! 😉