Atualizando o VMPlayer 15.5.6 – Fedora 32

Uso o VMware Player no meu Fedora, tudo o que eu preciso funciona perfeitamente. Somente quando sai uma nova versão do kernel eu preciso recompilar o módulo do vmware para funcionar corretamente, faz parte :)

Eu já possuía o VMware Player 15.5.1 instalado (ok, um pouco desatualizado) e funcionando anteriormente no meu Fedora.

Para manter atualizado, na teoria bastaria baixar o bundle novo do VMware e instalar como sempre fiz, mas com a versão 15.5.6 ocorreu o erro abaixo:

[gp@gp]$ sudo ./VMware-Player-15.5.6-16341506.x86_64.bundle
Extracting VMware Installer…done.
/tmp/tmppx9x6f1l.vmis.env:4: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
import imp
/tmp/vmis.eoJqmS/install/vmware-installer/vmis-launcher: error while loading shared libraries: libbz2.so.1.0: cannot open shared object file: No such file or directory

Executando como root direto (sem o sudo), o mesmo erro ocorreu:

[root@gp]# ./VMware-Player-15.5.6-16341506.x86_64.bundle
Extracting VMware Installer…done.
/tmp/tmpffuk0k_k.vmis.env:4: DeprecationWarning: the imp module is deprecated in favour of importlib; see the module's documentation for alternative uses
import imp
/tmp/vmis.ab6XDZ/install/vmware-installer/vmis-launcher: error while loading shared libraries: libbz2.so.1.0: cannot open shared object file: No such file or directory

Pesquisando um pouco, vi como alternativa executar o binário vmware-instaler (vi isso em https://communities.vmware.com/message/2967312#2967312) e passar o bundle como parâmetro (para isso, uma versão anterior já precisa estar instalada na máquina, o que era meu caso), mas outro erro ocorre:

[root@gp ]# vmware-installer -i VMware-Player-15.5.6-16341506.x86_64.bundle
Installing VMware VMX 15.5.6
Configuring…bora/lib/string/str.c:284 Buffer too small
[############################################### ] 67%
VMware Workstation Error:
VMware Workstation unrecoverable error: (host-10070)
bora/lib/string/str.c:284 Buffer too small
You can request support.

Depois de penar um pouco, encontrei num blog (https://andrescrivener.wordpress.com/2019/09/26/erro-ao-instalar-vmware-player-no-linux-bora-lib-string-str-c284-buffer-too-small/comment-page-1/) a solução, executar com LC_ALL=C setado:

[root@gp]# LC_ALL=C vmware-installer -i VMware-Player-15.5.6-16341506.x86_64.bundle
Installing VMware Player 15.5.6
Configuring…
[######################################################################] 100%
Installation was successful.


Sucesso !!!

Agora é só instalar o patch disponível em https://github.com/mkubecek/vmware-host-modules para o módulo do kernel subir corretamente.

wget https://github.com/mkubecek/vmware-host-modules/archive/player-15.5.6.tar.gz
cd vmware-host-modules-player-15.5.6/
make clean
make
make install
systemctl restart vmware
systemctl restart vmware-USBArbitrator.service

E executar o vmplayer:

/usr/lib/vmware/bin/vmplayer

Pronto, tudo funcionando normalmente.

Este post não é bem um tutorial, é mais para reunir a solução de dois problemas distintos que tive ao atualizar o VMware e que podem auxiliar outras pessoas.

Como trocar o HD do PlayStation 3

Poucos sabem mas é possível trocar o HD que vem no PlayStation 3 por um novo. E por que fazer isso? Um exemplo é ter mais espaço para armazenamento (quem assina a Plus e faz muitos downloads sabe que a capacidade do HD original não resistirá muito tempo), outro exemplo é trocar por um disco mais rápido que o original (não testei mas há diversos relatos de funcionamento de SSD).

  • O que você vai precisar?
    1) Um HD externo para backup dos dados que, obviamente, deve ser pelo menos o tamanho do HD interno do seu PlayStation. Não é obrigatório fazer este backup mas saiba que sem o backup seus dados serão perdidos e todos os jogos deverão ser reinstalados e atualizados, todos os downloads deverão ser refeitos e todas as partidas salvas que não estiverem sincronizadas na nuvem serão perdidas.
    2) Um HD novo para o PS3. Sem isso não teria motivo para fazer os passos aqui descritos :)
    3) Uma cópia da mesma versão do firmware do PS3 que você usa, salva num pendrive.

 

Preparando as coisas
O HD externo para o backup deve estar formatado como FAT32. Embora o Windows reconheça os discos, desde o XP o Windows não os formata em FAT32 se a capacidade for maior que 32 GB. Como a intenção aqui é colocar um HD maior que o original do PlayStation 3, você precisará de um HD maior que 32 GB.

Uma das possíveis soluções no Windows para formatar um HD maior que 32 GB em FAT32 é baixar o freeware “fat32format” (disponível em http://www.ridgecrop.demon.co.uk/index.htm?fat32format.htm).

O uso do fat32format é simples e direto. Basta conectar o HD externo e executar “fat32format X:” onde “X:” deve ser substituído pelo drive correspondente. A imagem abaixo mostra como foi meu teste (pra constar, aqui o HD externo foi encontrado no Windows como “G”).

 

fat32format

Execução do fat32format

Se tiver um MacOS ou um Linux, não precisa se preocupar com ferramentas de terceiros pois os sistemas estão preparados para formatar discos maiores que 32 GB em FAT32.

No MacOS, basta abrir o Utilitário de Disco, selecionar o HD externo, clicar na aba “Apagar”, escolher o formato “MS-DOS (FAT)” e clicar no botão “Apagar…”, conforme imagem:

utilitario_de_disco

No caso do Linux, basta executar o comando “mkfs.vfat /dev/sdc1” (substituindo o “sdc1” pela partição correspondente ao drive externo).

Baixe também o pacote com a mesma versão do firmware do seu PS3 (pode baixar daqui http://uk.playstation.com/ps3/support/system-software/) e salve no pendrive sob o diretório “PS3\UPDATE” (é necessário que o nome dos diretórios esteja em maiúsculas).

1) Realizando o backup

Uma observação, o backup não salva seus troféus e de eventuais outros jogadores do vídeo game, convém sincronizar antes.

Para sincronizar os troféus, em cada jogador do vídeo game, vá ao menu [PSN], selecione [Coleção de troféus], botão triângulo e então selecione [Sincronizar com servidor]. Aguarde um pouco e pronto.

Caso tenha escolhido fazer um backup, o que recomendo, acesse o menu [Configurações], [Configurações do sistema], [Utilitário de backup], [Fazer backup]. O PS3 vai pedir para conectar o HD.

conecte_midia_backup

Conecte o HD externo no PS3 e siga as instruções na tela.
Aguarde um bom tempo (meu HD com 150 GB de dados levou +- 4 horas e meia para fazer backup).

realizando_backup

backup_concluido

 

2) Tirando o HD antigo

Obviamente, antes de tudo desligue o vídeo game, inclusive da tomada.

Vire o vídeo game de cabeça pra baixo e abra a tampa que protege o parafuso que fixa o HD, conforme abaixo.

tampa_parafuso_azul_aberta

Remova o parafuso azul e deslize a tampa do HDD para a direita.

tampa_hd_abrindo

tampa_hd_aberta

Remova o disco do vídeo game e então remova os quatro parafusos da proteção metálica.

hd_removido

Pronto.

3) Colocando o HD novo

Coloque o disco novo na proteção metálica e coloque os quatro parafusos.

Insira o disco no vídeo game, feche a tampa, recoloque o parafuso azul para fixar o HD e feche a tampa de proteção (é só refazer na ordem inversa os mesmos passos para remover o disco anterior).

4) O primeiro boot

Para o primeiro boot após a troca de HD, é necessário iniciar o sistema com o pendrive com o arquivo do firmware inserido. Só lembrando, o firmware deve ser a mesma versão que tem instalada no sistema e a mesma versão de quando o backup foi feito.

Caso tenha iniciado o sistema sem o pendrive inserido, será exibida uma mensagem como a seguinte:

boot_sem_pendrive

Neste caso, basta inserir o pendrive e reiniciar o PS3.

Com o pendrive inserido, o vídeo game irá instalar no disco o SO correspondente a firmware do sistema e, após alguns minutos, irá reiniciar. Se optou por não fazer backup, está pronto, pode usar seu PS3 com o novo HDD. Se optou pelo backup, o próximo passo mostra como restaurar.

5) Restaurando o backup

Para restaurar o backup, acesse [Configurações], [Configurações de sistema], [Utilitário de backup] e siga as instruções da tela.

Pronto, se todos os passos ocorreram sem problemas seu PS3 agora possui um novo disco.

Usando openssl para testar conectividade https

Algumas pessoas eventualmente utilizam o telnet para testar a conectividade ou obter informações de um webserver. Para isso, basta conectar na porta 80 e digitar alguns comandos do protocolo HTTP, como abaixo:

$ telnet www.umsitequalquer.com.br 80
GET /index.html HTTP/1.1
Host: www.umsitequalquer.com.br

(Lembre-se de pressionar “enter” duas vezes no final)

Isso é uma requisição GET do protocolo HTTP onde você deverá receber informações como cabeçalhos e o próprio conteúdo do “index.html” como resposta. Mas num site com SSL (https), isso não funciona pois a comunicação deve ser criptografada, como proceder então?

Se você tiver instalado (e se não tiver, instale), pode usar o “s_client” do OpenSSL, como abaixo:

$ openssl s_client -connect www.umsitequalquer.com.br:443
[o certificado SSL irá ser mostrado na tela]
GET /index.html HTTP/1.1
Host: www.umsitequalquer.com.br

Pronto, informações obtidas via https como se fosse um http sem criptografia.

SSH com “relocation error” no Solaris

Esta dica é mais pra “me lembrar no futuro” do que qualquer outra coisa mas vamos lá :)

Recentemente tive um problema em alguns servidores Solaris 10 onde o ssh (e comandos relacionados, como scp por exemplo) pararam de funcionar. Não tenho certeza, acredito que foi após a aplicação de algum patch mas isso não importa agora.

O erro que eu recebia era este:

$ ssh

ld.so.1: ssh: fatal: relocation error: file /usr/bin/ssh: symbol
SUNWcry_installed: referenced symbol not found

Killed

 

A solução foi editar o .profile do meu usuário (por exemplo, /export/home/fulano/.profile) e adicionar o diretório /usr/sfw/lib no começo do LD_LIBRARY_PATH, assim:

export LD_LIBRARY_PATH=/usr/sfw/lib:$LD_LIBRARY_PATH

 

Então, basta carregar o .profile novamente (ou deslogar e logar novamente) para usar o ssh sem receber o erro.

Adicionando um novo disco no Linux

Como adicionar um novo disco (estamos falado de HD e não de qualquer outro tipo de mídia) num Linux?

O escopo deste post é mostrar como configurar um novo disco num Linux, pulando a parte “hardware” da coisa, ou seja, não vamos falar de cabeamento, parafusos e eventuais jumpers.

Uma vez que o disco foi instalado fisicamente na máquina, devemos identificá-lo para prepará-lo e então poder utilizá-lo.

Primeiramente, com o comando “df”, vamos verificar qual é o nosso disco atual:

[root@localhost ~]# df
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sda2             19306788   2809356  15516696  16% /
tmpfs                   515428        88    515340   1% /dev/shm
/dev/sda1               297485     31238    250887  12% /boot

 

Com a saída do comando, verificamos que o disco atualmente utilizado é o /dev/sda.

Agora, para identificar o disco novo, podemos executar o comando “dmesg” e procurar por “disk”:

[root@localhost ~]# dmesg|grep disk
sd 1:0:0:0: [sdb] Attached SCSI disk
sd 0:0:0:0: [sda] Attached SCSI disk

 

Se nosso disco em uso é o “sda” e agora temos um “sdb”, acabamos de identificar nosso disco recém adicionado.

Com o disco identificado, agora vamos prepará-lo para utilizar no Linux. Preparar consiste basicamente em particionar e formatar o disco.

Para particionar, usaremos o comando “fdisk”:

[root@localhost ~]# fdisk /dev/sdb

WARNING: DOS-compatible mode is deprecated. It's strongly recommended to
         switch off the mode (command 'c') and change display units to
         sectors (command 'u').

 

Ok, vamos sair do modo de compatibilidade DOS e utilizar setores como medida de unidades:

[root@localhost ~]# fdisk -cu /dev/sdb
Command (m for help):

 

No fdisk, digitamos “p” para mostrar informações sobre o disco como as partições atuais (que no nosso caso, não existem):

Command (m for help): p
Disk /dev/sdb: 10.7 GB, 10737418240 bytes
 255 heads, 63 sectors/track, 1305 cylinders, total 20971520 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
 Disk identifier: 0x62e8c07a
Device Boot      Start         End      Blocks   Id  System
Command (m for help):

 

Se não temos partições, vamos criar uma:

 Command (m for help): n
Command action
   e   extended
   p   primary partition (1-4)
p
Partition number (1-4): 1
First sector (2048-20971519, default 2048):
Using default value 2048
Last sector, +sectors or +size{K,M,G} (2048-20971519, default 20971519):
Using default value 20971519
Command (m for help):

 

E então listar essa nova partição criada:

Command (m for help): p

Disk /dev/sdb: 10.7 GB, 10737418240 bytes
107 heads, 17 sectors/track, 11529 cylinders, total 20971520 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
Disk identifier: 0x62e8c07a

   Device Boot      Start         End      Blocks   Id  System
/dev/sdb1            2048    20971519    10484736   83  Linux
Command (m for help):

 

Por padrão, o tipo de partição criada é “Linux”. Este tipo é utilizado para sistemas de arquivo do tipo Ext2/Ext3/Ext4, por exemplo.

Se estiver apenas adicionando um disco e não quiser utilizá-lo com LVM, pode ignorar os próximos passos, salvar as alterações na tabela de partições (digitando “w” no fdisk) e ir direto para o comando “mkfs.ext4”, mais ao final do texto. Caso queira utilizar LVM, continue lendo.

Para  utilizar a partição com LVM, deve-se mudar o tipo de partição. Para isso, ainda no fdisk, digite “t” e mude o tipo para “8e” (Linux LVM):

Command (m for help): t
 Selected partition 1
 Hex code (type L to list codes): 8e
 Changed system type of partition 1 to 8e (Linux LVM)
Command (m for help):

 

Vamos listar a tabela de partições para verificar as modificações:

Command (m for help): p
Disk /dev/sdb: 10.7 GB, 10737418240 bytes
 255 heads, 63 sectors/track, 1305 cylinders, total 20971520 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
 Disk identifier: 0x62e8c07a
Device Boot      Start         End      Blocks   Id  System
 /dev/sdb1            2048    20971519    10484736   8e  Linux LVM
Command (m for help):

 

Se estiverem OK, basta salvar as mudanças e sair do fdisk (comando “w”):

Command (m for help): w
 The partition table has been altered!
Calling ioctl() to re-read partition table.
 Syncing disks.

 

De volta ao bash, podemos verificar se as mudanças realmente foram salvas com:

[root@localhost ~]# fdisk -cul /dev/sdb
Disk /dev/sdb: 10.7 GB, 10737418240 bytes
 107 heads, 17 sectors/track, 11529 cylinders, total 20971520 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
 Disk identifier: 0x62e8c07a
Device Boot      Start         End      Blocks   Id  System
 /dev/sdb1            2048    20971519    10484736   8e  Linux LVM

 

Até aqui temos partição criada e tipo modificado para Linux LVM. Devemos então criar um volume físico para o LVM. Isso pode ser feito com o comando “pvcreate”:

[root@localhost ~]# pvcreate /dev/sdb1
 Writing physical volume data to disk "/dev/sdb1"
 Physical volume "/dev/sdb1" successfully created

 

Então vamos visualizar algumas informações sobre este novo volume físico criado:

 [root@localhost ~]#  pvs
 PV         VG   Fmt  Attr PSize  PFree
 /dev/sdb1       lvm2 a--  10.00g 10.00g

 

E visualizar os atributos deste volume:

 [root@localhost ~]# # pvdisplay
 "/dev/sdb1" is a new physical volume of "10.00 GiB"
 --- NEW Physical volume ---
 PV Name               /dev/sdb1
 VG Name
 PV Size               10.00 GiB
 Allocatable           NO
 PE Size               0
 Total PE              0
 Free PE               0
 Allocated PE          0
 PV UUID               XqqgNn-WYhy-NFA8-ntae-hVVw-4wrl-uHy2fK

 

Em um volume físico, precisamos criar Volume Groups, que são as estruturas lógicas onde finalmente vamos armazenar os dados.

Para listar informações sobre os volume groups, usamos o comando “lvs”:

[root@localhost ~]# lvs
 No volume groups found

 

No nosso caso, ainda não temos nenhum criado. Vamos criar um volume group chamado “vg_teste” neste disco que acabamos de particionar e adicionar um volume físico, para isso, usaremos o comando “vgcreate”:

[root@localhost ~]# vgcreate vg_teste /dev/sdb1
 Volume group "vg_teste" successfully created

 

Para listar informações sobre os Volume Groups, podemos usar o comando “vgs”:

[root@localhost ~]# vgs
 VG       #PV #LV #SN Attr   VSize  VFree
 vg_teste   1   0   0 wz--n- 10.00g 10.00g

 

Se executarmos o comando “pvs” novamente iremos observar que a coluna “VG” agora está preenchida com o nosso “vg_teste” recém criado:

[root@localhost ~]# pvs
 PV         VG       Fmt  Attr PSize  PFree
 /dev/sdb1  vg_teste lvm2 a--  10.00g 10.00g

 

Tendo um volume group criado, podemos criar um ou mais volumes lógicos. A grande vantagem de trabalharmos com volumes é poder facilmente adicionar e/ou remover espaço de um volume lógico. Se tivermos espaço livre disponível no volume group, podemos adicionar espaço a um volume lógico sem sequer ter que parar o sistema.

Para criar um volume lógico, usamos o comando “lvcreate”:

[root@localhost ~]# lvcreate -L 10G -n lv_teste vg_teste
 Volume group "vg_teste" has insufficient free space (2559 extents): 2560 required.

 

Um ponto a se observar é que quando criamos o volume group alocamos 10 Gbytes para o mesmo mas agora não pudemos fazer o mesmo para o volume lógico, por que?

Todos os volumes são divididos em partes menores, chamadas “extents”. Uma extent é a menor parte alocável de um volume e, sempre que criamos um volume, uma extent é reservada e não podemos utilizá-la. Então nossa possibilidade de uso de um volume pode ser definida como “tamanho total do volume menos uma extent”.

Vamos ver com “vgdisplay” quantas extents temos livres no nosso volume group. Basta procurar a linha “Free  PE / Size” e observarmos que temos 2559 ao invés das 2560 necessárias para 10 Gbytes:

[root@localhost ~]# vgdisplay
 --- Volume group ---
 VG Name               vg_teste
 System ID
 Format                lvm2
 Metadata Areas        1
 Metadata Sequence No  1
 VG Access             read/write
 VG Status             resizable
 MAX LV                0
 Cur LV                0
 Open LV               0
 Max PV                0
 Cur PV                1
 Act PV                1
 VG Size               10.00 GiB
 PE Size               4.00 MiB
 Total PE              2559
 Alloc PE / Size       0 / 0
 Free  PE / Size       2559 / 10.00 GiB
 VG UUID               Mv0C69-2t56-tPSI-rNX9-cUcj-r28q-89tgSp

 

Então vamos criar um volume lógico novamente mas, ao invés de pedirmos 10 GB de tamanho (parâmetro “-L 10G”), vamos pedir 2559 extents (parâmetro “-l 2559”):

[root@localhost ~]# lvcreate -l 2559 -n lv_teste vg_teste
 Logical volume "lv_teste" created

Então executamos vgdisplay novamente para verificar que a linha “Alloc PE / Size” passou a mostrar “2559 / 10.00 GiB” ao invés de “0 / 0” que estava anteriormente:

 [root@localhost ~]# vgdisplay
 --- Volume group ---
 VG Name               vg_teste
 System ID
 Format                lvm2
 Metadata Areas        1
 Metadata Sequence No  2
 VG Access             read/write
 VG Status             resizable
 MAX LV                0
 Cur LV                1
 Open LV               0
 Max PV                0
 Cur PV                1
 Act PV                1
 VG Size               10.00 GiB
 PE Size               4.00 MiB
 Total PE              2559
 Alloc PE / Size       2559 / 10.00 GiB
 Free  PE / Size       0 / 0
 VG UUID               Mv0C69-2t56-tPSI-rNX9-cUcj-r28q-89tgSp

 

O comando pvdisplay também mostrará que temos todo o volume alocado:

[root@localhost ~]# pvdisplay
 --- Physical volume ---
 PV Name               /dev/sdb1
 VG Name               vg_teste
 PV Size               10.00 GiB / not usable 3.00 MiB
 Allocatable           yes (but full)
 PE Size               4.00 MiB
 Total PE              2559
 Free PE               0
 Allocated PE          2559
 PV UUID               TvGETI-FbsG-0UWt-4v0N-TwT5-bfnj-IZZsQ0

 

E o comando “lvs” listará todos os volumes lógicos criados:

[root@localhost ~]# lvs
 LV       VG       Attr     LSize  Pool Origin Data%  Move Log Copy%  Convert
 lv_teste vg_teste -wi-a--- 10.00g

 

Com todos os passos executados, basta formatar o volume lógico com o comando “mkfs.ext4”. Neste ponto, se escolheu não utilizar volumes, substitua o caminho para sua partição que neste caso seria /dev/sdb1:

[root@localhost ~]# mkfs.ext4 /dev/mapper/vg_teste-lv_teste
 mke2fs 1.41.12 (17-May-2010)
 Filesystem label=
 OS type: Linux
 Block size=4096 (log=2)
 Fragment size=4096 (log=2)
 Stride=0 blocks, Stripe width=0 blocks
 655360 inodes, 2620416 blocks
 131020 blocks (5.00%) reserved for the super user
 First data block=0
 Maximum filesystem blocks=2684354560
 80 block groups
 32768 blocks per group, 32768 fragments per group
 8192 inodes per group
 Superblock backups stored on blocks:
 32768, 98304, 163840, 229376, 294912, 819200, 884736, 1605632
Writing inode tables: done
 Creating journal (32768 blocks): done
 Writing superblocks and filesystem accounting information: done
This filesystem will be automatically checked every 27 mounts or
 180 days, whichever comes first.  Use tune2fs -c or -i to override.

 

Poderíamos parar por aqui mas não quero que meu disco seja testado a cada 27 montagens ou 180 dias, que são os valores padrão. Então, com “tune2fs”, vamos mudar para ele nunca mais checar automaticamente:

[root@localhost ~]# tune2fs -c0 -i 0 /dev/mapper/vg_teste-lv_teste
 tune2fs 1.41.12 (17-May-2010)
 Setting maximal mount count to -1
 Setting interval between checks to 0 seconds

 

E para montar o volume automaticamente em todo boot do sistema, vamos colocá-lo no arquivo /etc/fstab. Para isso, vamos identificar o “id” do volume, com o comando “blkid”:

[root@localhost ~]# blkid /dev/mapper/vg_teste-lv_teste
 /dev/mapper/vg_teste-lv_teste: UUID="fe556bcb-879a-4537-92cd-2d40519089df" TYPE="ext4"

 

Criar um diretório onde iremos montar este volume:

[root@localhost ~]# mkdir /teste

 

E adicionar uma linha ao final do /etc/fstab com o id do volume, diretório e demais parâmetros necessários:

[root@localhost ~]# echo "UUID=fe556bcb-879a-4537-92cd-2d40519089df /teste ext4 defaults 0 0" >> /etc/fstab

 

Montamos todos os dispositivos contidos no /etc/fstab:

[root@localhost ~]# mount -a

 

E por fim verificamos se está tudo OK.

[root@localhost ~]# df
Filesystem           1K-blocks      Used Available Use% Mounted on
/dev/sda2             19306788   2809160  15516892  16% /
tmpfs                   515428        88    515340   1% /dev/shm
/dev/sda1               297485     31238    250887  12% /boot
/dev/mapper/vg_teste-lv_teste
10317112    154100   9638932   2% /teste

 

Pronto, nosso volume lógico “lv_teste”, contido no volume group “vg_teste”, identificado como “/dev/mapper/vg_teste-lv_teste” foi montado no diretório “/teste”.

No dia a dia, não precisamos executar alguns dos comandos citados neste post. Estes foram citados para facilitar a visualização do processo. Um fluxo resumido para obter o mesmo resultado seria executar os comandos “fdisk”, “pvcreate”, “vgcreate”, “lvcreate”, “mkfs.ext4”, “mkdir” e “mount” com os respectivos parâmetros.

Para um computador pessoal, onde não há muita “movimentação” de discos, não é obrigatório utilizar volumes de disco.

A clara vantagem de se utilizar volumes de disco será vista num próximo post onde irei mostrar como adicionar um segundo disco num volume já existente (o que criamos aqui) e somar suas capacidades fazendo o sistema operacional “enxergar” como se fosse um único disco maior.

Rollback de atualizações de pacotes utilizando yum

O YUM (Yellowdog Updater Modified) é o gerenciador de pacotes utilizado por diversas distribuições Linux, como Fedora e Red Hat por exemplo.

Como gerenciador de pacotes, é possível utilizá-lo para instalar, remover ou atualizar pacotes, por exemplo.

Uma característica dele, implementada desde a versão 3.2.25, é a possibilidade de se fazer rollback de transações, ou seja, é possível reverter uma ação realizada anteriormente. Exemplo:

Vamos supor que atualizamos o sistema com o yum e, após isso, verificamos que algum tipo de incompatibilidade ocorreu. Como fazer para voltar os pacotes instalados no sistema para o estado anterior a este update? Ou ainda, instalo alguma ferramenta (que muitas vezes vem com trocentas dependências junto) e decido removê-la, como fazer para remover tudo de uma vez sem ter que pesquisar manualmente todas as dependências?

Como teste, instalei o GNOME via yum:

# yum groupinstall “GNOME Desktop”

[…]

Transaction Summary
==========================================================
Install  77 Packages (+209 Dependent packages)

Total download size: 211 M
Installed size: 791 M
Is this ok [y/N]:

 

E então resolvi removê-lo. Quase trezentos pacotes para remover (286 para ser mais exato), como fazer de maneira “indolor”?

Primeiro devemos listar todas as transações realizadas, isto pode ser feito com os parâmetros “history list” do yum:

# yum history list
Loaded plugins: langpacks, presto, refresh-packagekit
ID     | Login user               | Date and time    | Action(s)      | Altered
——————————————————————————-
5 |  <gustavo>               | 2013-02-22 10:45 | Install        |  286
4 |  <gustavo>               | 2013-02-22 10:20 | E, I, O, U     |  136 EE
3 |  <gustavo>               | 2013-02-06 17:55 | I, O, U        |  127  <
2 |  <gustavo>               | 2013-01-25 16:26 | I, O, U        |  246 >E
1 | System <unset>           | 2013-01-16 15:00 | Install        | 1044
history list

 

Pela data e hora, vi que o que desejo desfazer provavelmente possui ID 5, como confirmar?

Basta executar o yum com os parâmetros “history info”:

# yum history info 5
Loaded plugins: langpacks, presto, refresh-packagekit
Transaction ID : 5
Begin time     : Fri Feb 22 10:45:03 2013
Begin rpmdb    : 1061:186cde8ef6ee4dfdaba2f2d21f79f9f5702ce554
End time       :            10:49:24 2013 (261 seconds)
End rpmdb      : 1347:1316b52e0ebd064d4a657da17bf311f6e5d2d059
User           :  <gustavo>
Return-Code    : Success
Command Line   : groupinstall GNOME Desktop
Transaction performed with:
Installed     rpm-4.10.3.1-1.fc18.i686 @updates
Installed     yum-3.4.3-49.fc18.noarch @updates
Packages Altered:
Dep-Install OpenEXR-libs-1.7.1-1.fc18.i686                                                 @fedora
Install     PackageKit-command-not-found-0.8.7-1.fc18.i686                                 @updates

[…]

E ali no meio tem o segredo: “Command Line   : groupinstall GNOME Desktop”

É exatamente esta a transação que desejo desfazer. Então, basta executar o undo o ID correspondente:

# yum history undo 5
[…]
Transaction Summary
==========================================================
Remove  286 Packages

Installed size: 791 M
Is this ok [y/N]:

 

E pronto, rollback realizado.

Curiosidade: Tem como refazer o que desfizemos? (AKA rollback do rollback).

O próprio rollback gerou uma nova transação onde os 286 pacotes foram removidos. Basta fazer um “history list” para ver que surgiu um ID 6:

# yum history list
Loaded plugins: langpacks, presto, refresh-packagekit
ID     | Login user               | Date and time    | Action(s)      | Altered
——————————————————————————-
6 |  <gustavo>               | 2013-02-22 11:47 | Erase          |  286
5 |  <gustavo>               | 2013-02-22 10:45 | Install        |  286
4 |  <gustavo>               | 2013-02-22 10:20 | E, I, O, U     |  136 EE
3 |  <gustavo>               | 2013-02-06 17:55 | I, O, U        |  127  <
2 |  <gustavo>               | 2013-01-25 16:26 | I, O, U        |  246 >E
1 | System <unset>           | 2013-01-16 15:00 | Install        | 1044
history list

E então, para refazer o que desfizemos, basta executar um “history undo 6”:

# yum history undo 6

[…]

Transaction Summary
==========================================================
Install  286 Packages

Total download size: 211 M
Installed size: 791 M
Is this ok [y/N]:
Pronto, agora podemos testar ferramentas/atualizações novas com “menos medo”, se algo sair errado, basta executar yum history undo.

Coisas da informática de antigamente: MSX

Comecei com informática ainda criança, idos de 1984 quando meu pai apareceu em casa com um CP 200 da Prológica (http://pt.wikipedia.org/wiki/CP200). Lembro muito pouco deste microcomputador, mas do que me lembro os programas eram digitados “na hora” ou carregados via fita K7.

Em 1986 meu pai adquiriu o primeiro MSX, um Hot Bit branco. Este eu posso afirmar que foi o meu real início na informática. Aprendi as primeiras noções de programação utilizando o Basic do MSX e quando ganhei o primeiro drive de disquetes, pronto, um novo mundo começou para mim.

Caixa de disquete Nashua, a maioria dos disquetes que eu tinha era dessa marca

Nesta época assinávamos algumas revistas de informática (CPU que depois se tornou CPU MSX e a Micro Sistemas, por exemplo). O interessante é que as revistas da época tinham bem mais conteúdo técnico do que as revistas de hoje em dia. As matérias mostravam mais como as coisas realmente funcionavam do que uma “propaganda” das coisas, como ocorre hoje em dia na maioria das vezes. Lembro de casos onde as revistas publicavam até mesmo o código fonte de programas em Assembly!!!

Meu primeiro código funcional (tirando os “prints” e “inputs” básicos) foi um joguinho escrito em BASIC. Era o “Jogo do Industriário”. A ideia do jogo surgiu após eu “viciar” no “Jogo do Executivo” que existia na época. Pensei: será que consigo escrever algo semelhante? Um jogo (na época) não deixava de ser apenas um laço com um monte de prints, inputs e ifs com algumas variáveis. Isso eu sabia fazer :)

No fim vi que era mais divertido escrever o jogo do que jogar propriamente dito. Escrevi umas 3 ou 4 versões diferentes para Basic do MSX e sempre tive um grande problema com falta de memória: o MSX, embora possua 64 kbytes de RAM, apenas 32 poderiam ser utilizados para o Basic (sinceramente não me lembro o motivo). O pior? Nesses 32 kbytes coexistiam: o interpretador Basic, uma área reservada na memória para a controladora de disquetes, além é claro do código e dados do programa em Basic que você estava utilizando no momento. Tendo controladora de disquete na máquina sobravam pouco mais que 23 kbytes de memória para código e variáveis. Foi ali que comecei a me interessar por otimização/tunning (se bem que eu nem sabia que o que eu fazia significava isso).

Nesta época “descobri” que, por padrão, a controladora de disquete do MSX reservava memória para utilizar duas unidades de disquete (A: e B:). Caso tivesse apenas uma unidade e se ligasse a máquina mantendo pressionada a tecla [CTRL] durante o boot, até ouvir um beep, a controladora de disquete não reservava memória para a unidade B:, o que liberava algo como 1 Kbyte a mais de memória para programas em Basic. Pode parecer pouco, mas para a época isso poderia fazer com que um programa coubesse ou não na memória.

Ainda falando de programação em MSX, também “descobri” que o parser do BASIC sabia interpretar os comandos mesmo se não existissem espaços entre eles. Ao invés de escrever algo como:

10 a=texto : print a

Eu poderia escrever:

10 a=texto:printa

Funcionava e ainda se economizava um byte para cada espaço removido!!! Num código de 20 kbytes, se economizava fácil mais um ou dois kbytes apenas removendo os espaços entre as variáveis. Legibilidade de código é para os fracos, o importante é o código ocupar o mínimo de memória :) E assim meu joguinho agora dispunha memória para código que permitia salvar e carregar as partidas…

Tinha outros artifícios para economizar memória no Basic mas a maioria deles eu só conheci depois que migrei para PC e principalmente depois que comecei a utilizar a Internet.

O interessante do BASIC do MSX é que, mesmo num computador com recursos de hardware limitadíssimos, já existiam funções nativas que mesmo hoje exigem certa programação avançada. Por exemplo, naquele tempo já existiam funções para controle de joystick, funções gráficas para detectar colisão de sprites e, incrível, a função play já conseguia reproduzir 3 notas musicais simultâneas. E isto já estava disponível para MSX em 1983 !!! Para se ter uma ideia, no PC isso só se tornou possível quando surgiram as primeiras placas Adlib e Sound Blaster no final dos anos 1980 e utilizando drivers e bibliotecas próprias de desenvolvimento, nada nativo em nenhuma linguagem de programação da época.

O resumo é que quando migrei para o PC, se não me engano em 1995/1996, a primeira coisa que fiz foi tentar rodar meu jogo. Tirando algumas adaptações necessárias, minha grande decepção foi a função play do BASIC não suportar mais as três notas simultâneas.

Quando eu tiver mais algum tempo escrevo sobre como foi a época que comecei a utilizar PCs … :)

Script para ntp fake (AKA como atualizar horário via http usando shell script)

Disclaimer:

O conteúdo deste post é histórico, mantido aqui apenas para ter exemplificar como fazer um script parsear um HTML. Para funcionar, ele depende de uma URL que não está mais disponível.
Atualmente (consultei em 31/05/2020), o Observatório Nacional disponibiliza na URL http://www.horalegalbrasil.mct.on.br/RelogioServidor.php a data em formato “epoch” que, basicamente, são quantos segundos se passaram desde a meia noite do dia 01/01/1970. Então basta converter esse número com o comando date para saber a hora atual.

Para ter uma ideia para um script, pode-se pensar em algo como:

$ date --date=@`curl -s http://www.horalegalbrasil.mct.on.br/RelogioServidor.php`

Sun May 31 18:43:43 -03 2020

E então pode-se seguir uma lógica semelhante ao que tem no restante do post se quiser que esta hora seja aplicada ao sistema.

Agradeço ao Ricardo, da Amplus, por ter informado que a URL do texto não estava mais ativa e ainda por ter sugerido essa nova URL citada acima.

Resumo da história:

Preciso que uma máquina virtual tenha a hora sempre correta mas não posso instalar o vmware tools e nem usar ntp para isso. Como fazer?

A história completa:

Tenho uma máquina virtual onde não consigo instalar o vmware-tools (máquina extremamente customizada, quase nada funciona ali sem muita modificação). Esta máquina virtual está numa rede onde não tem um servidor ntp e, para “ajudar”, o firewall desta rede não permite que eu acesse nenhum servidor ntp externo. Preciso que o horário nesta máquina esteja correto (ok, um ou outro segundo não é problema, mas a data estar na “semana passada” definitivamente não é bom).

Por sorte esta máquina consegue acessar http (via proxy, óbvio) então, tudo o que eu precisava era de uma página web que sempre tivesse a hora correta.

No Brasil, quem é o “responsável” pela hora oficial é o Observatório Nacional. Navegando pelo site deles encontrei uma url que tem a hora legal brasileira e é atualizada a cada segundo.

No meio daquela página vai ter a hora assim: 20/3/2012 15:45:38. Mas o comando date espera receber esta hora assim: 032015452012.38 (se lê de dois em dois dígitos, exceto o ano: mês; dia; hora; minuto; ano; “.” e segundo).

Então basicamente o que eu precisei é “ler” a página e “traduzir” para o formato que o comando “date” do Linux entende.

A gambiarra (AKA “solução” do problema):

Abri o source da página e tentei entender onde a data e hora estava. Vi que a hora que preciso aparece no meio de algumas tags html na terceira linha após o texto “Hora Oficial”.

O trecho do source em questão:

<TD ALIGN="CENTER" BGCOLOR=#E0FFFF><B>Hora Oficial de Brasília</B></TD>
</TR>
<TR>
<TD ALIGN="CENTER" BGCOLOR=#ffcc66><B>20/3/2012 15:45:38</B></TD>

Separei somente a linha que queria e “limpei” todas as tags, deixando somente a hora.

20/3/2012 15:45:38

Para o script ler a página, usei o comando curl, grep para procurar no texto por “Hora Oficial” e separar as próximas três linhas, tail para separar a última dessas três linhas e, finalmente, sed para remover as tags html.

O código usado (porco, confesso, mas pode rodar no seu shell) , é esse:

curl -s http://pcdsh01.on.br/HoraLegalBrasileira.asp|grep -A3 “Hora Oficial”|tail -1|sed ‘s/<TD ALIGN=”CENTER” BGCOLOR=#ffcc66><B>//g;s/<\/B><\/TD>//g’
 

Armazenei a saída desse comando numa variável, no caso “hora_full”.

Então traduzi a hora que ele me retornou para o formato do date (mais um código porco, mas está “didático”):

hora=`echo $hora_full|cut -d ” ” -f 2|cut -d : -f 1`
minuto=`echo $hora_full|cut -d ” ” -f 2|cut -d : -f 2`
segundo=`echo $hora_full|cut -d ” ” -f 2|cut -d : -f 3|tr -d ‘\r’`
mes=`echo $hora_full|cut -d “/” -f 2`
dia=`echo $hora_full|cut -d “/” -f 1`
ano=`echo $hora_full|cut -d “/” -f 3|cut -d ” ” -f 1`

E juntei tudo como parâmetro para o comando date:

date $mes$dia$hora$minuto$ano.$segundo

Se seu usuário tiver permissão para alterar a data do sistema, isto deverá “sincronizar” com o horário legal brasileiro.

PS: depois (AKA talvez um dia) eu coloque o script todo, inclusive com verificação se o usuário tem ou não permissão para acertar o horário do sistema.

Dicas e notícias sobre Linux, Segurança, Shell Script, MSX, e etc …