Feeds:
Posts
Comments

Posts Tagged ‘linux’

Connecting QEMU/KVM virtual machines via serial port

If for some weird reason you need to connect two QEMU/KVM instances via a virtual null modem cable, here’s how to do it:

$ mkfifo null-cable-1.{in,out}
$ ln null-cable-1.in null-cable-2.out
$ ln null-cable-1.out null-cable-2.in
$ qemu -m 512 -nographic -serial pty -serial pipe:null-cable-1 -hda image1.qcow2
$ qemu -m 512 -nographic -serial pty -serial pipe:null-cable-2 -hda image2.qcow2

For each instance, you’ll be dropped into a monitor prompt:

char device redirected to /dev/pts/9
QEMU 0.12.1 monitor - type 'help' for more information
(qemu)

The machine is running already, but in the background. To access its console, open the pty mentioned in the output:

$ screen /dev/pts/9

Read Full Post »

Esses dias assinei um plano 3G da Vivo. Chegando em casa, comecei a usar a conexão 3G ao invés do ADSL que tenho aqui para testar o serviço. Foi meio broxante quando depois de um tempo de uso (1 hora talvez? não sei) a conexão ficou extremamente lenta, com pings de 30 segundos ou mais (o recorde foi 200 segundos!). Lá vou eu, ligar pro suporte da Vivo no mesmo dia em que assinei o serviço. A 1ª impressão foi pro ralo.

Interessante que o menu do telefone já classifica o usuário por sistema operacional:

Se você usa um computador com Windows, tecle 1.
Se você usa um computador com Mac OS, tecle 2.
Se você usa um computador com Linux, tecle 3.

Legal, eles reconhecem que existem clientes que usam Linux! Teclei 3. A experiência não foi lá tão boa, mas isso não surpreendeu. Obviamente o suporte da Vivo coloca sempre a culpa no seu equipamento e o problema nunca é na rede deles, então pedem pra fazer trocentos procedimentos de configuração e teste antes de cogitarem que eles têm que fazer algo do lado deles.

Mas isso é outra história. O interessante foi o procedimento que ele pediu pra eu fazer. Em primeiro lugar, pediu para abrir um terminal e digitar:

$ sudo echo 1 > /proc/sys/net/ipv6/conf/all/disable_ipv6

Imagine o tempo que levou pra soletrar tudo isso. 🙂

A 1ª coisa que salta aos olhos é que o comando tem um erro típico de quem não manja muito de Linux (quem eles contrataram pra elaborar os procedimentos de Linux deles?!?): o comando “echo 1” rodará como usuário root, mas a parte do “> blah” é feita pelo shell do usuário, portanto vai dar erro de permissão na hora de escrever no disable_ipv6.

Mais impressionante que isso, o atendente pediu pra eu digitar a parte do “$␣”, ou seja ele soletrou “Cifrão, espaço, s, u, d, o, …”.

FacePalm

Quando terminei de digitar o comando (fazendo as alterações necessárias) e apertei enter, ele perguntou se apareceu “Operação bem sucedida”.

NOT-SURE-IF-A-TROLL-OR-JUST-STUPID

Eu expliquei pra ele que quando não aparece nada é porque o comando deu certo então seguimos adiante. A próxima coisa que eu tinha que fazer era reiniciar o computador. Wait wat? Todo esse trabalho soletrando um comando gigante pra editar uma variável no /proc e ele quer que eu reinicie?

mr-bean-irritado

Pra quem não usa ou não manja de Linux (o que não tem problema nenhum, e é até saudável, a menos que você trabalhe com suporte técnico): as alterações no /proc são “efêmeras” e na próxima vez em que o computador é ligado volta tudo como estava antes.

O lado bom da história é que a Vivo suporta Linux. Os atendentes também são surpreendentemente prestativos. Quando o procedimento acima não funcionou (quem diria?), eu fiquei discutindo com o cara outras possibilidades, ele deu algumas sugestões genéricas, inclusive uma que ajudou bastante: o problema talvez fosse que o modem muda de 3G (HSUPA) para 2G (EDGE), e aí fica lento. Passei a reparar nisso e realmente é o que acontece.

Já estou fugindo do assunto mas resumidamente, em outra ligação a atendente mencionou que é possível forçar o modem a ficar só no 3G, e isso poderia resolver o problema. O procedimento que ela tinha era só pro Windows infelizmente mas tá valendo, entrei no Windows. Só que meu modem é da Claro e o “discador” que veio nele também, e ele é ligeiramente diferente do da Vivo. Apesar disso ela ficou um tempão tentando me ajudar, tentando mapear o procedimento que ela tinha pra interface do meu discador. No fim achei a opção e realmente resolveu o problema!

Agora, por que o modem muda pra EDGE? Isso ninguém soube explicar, e ainda não consegui convencer a Vivo a fazer uma revisão na rede dela aqui no meu bairro…

Read Full Post »

I have been meaning to write this post for a long time.

One thing which I often found myself doing was typing echo $? after running a command to find out if there was any error, or appending || echo failed to the end of the command line.

Commands generally warn if there was an error, but you have to stop for a second and carefully read the output to see whether anything went wrong. I’m lazy and that additional second and the extra cognitive effort always bothered me.

I eventually had the idea of making the shell prompt show the exit status of the last command if it was non-zero. I use zsh, so it’s got to be possible. 🙂

It turns out it is, this is my PS1 variable now:

CYAN="%{"$'33[00;36m'"%}"
RED="%{"$'33[01;31m'"%}"
NORM="%{"$'33[00m'"%}"

export PS1="${CYAN}%m${NORM}%# %(?..${RED}(%?%)${NORM} )"

The magical part is %(?..${RED}(%?%)${NORM} ). Here’s the result:

zsh prompt

As a side note, one other thing that the screenshot shows is the right-hand prompt. This is a great feature of zsh, and I use it to show the current working directory. That way, no matter where I am in the filesystem, the cursor prompt always starts at the same column. Here’s my RPS1 variable:

MAGENTA="%{"$'33[00;35m'"%}"

export RPS1="${MAGENTA}%~${NORM}"

Read Full Post »

Since version 2.6, you can tell Amarok to convert (transcode) every music track to MP3 when copying it to a given device.

There’s a bug, however which causes MP3 files converted from Ogg Vorbis to lose all metadata (artist, album, title etc). This is a showstopper for me.

This happens because Amarok needs to pass an option to ffmpeg to tell it to get the metadata from the first stream found in the Ogg file as opposed to the default of getting it from global metadata. Unfortunately as far as I can tell there’s no way to configure the ffmpeg command line used by Amarok. The solution then is to replace the ffmpeg binary in the path with a script that will do that, like this one:

#!/usr/bin/python
import os
import sys

AVCONV_FFMPEG = '/usr/bin/ffmpeg.distrib'
os.execv(AVCONV_FFMPEG, sys.argv + ['-map_metadata', '0:0,s0'])

In Debian or Ubuntu, you can divert the real ffmpeg binary and install the script above as /usr/bin/ffmpeg:

$ sudo dpkg-divert --add /usr/bin/ffmpeg
$ sudo cp /tmp/fake-ffmpeg.py /usr/bin/ffmpeg
$ sudo chmod +x /usr/bin/ffmpeg

There’s another bug where Amarok needlessly converts even MP3 files when copying them to the device.

Read Full Post »

Ok, so this time I won’t talk about Python scripting support in GDB. I’m getting tired of it myself. 🙂 I’ll just comment that it’s amazing the number of problems people in IRC report with GDB that can be solved with the Python support that we’re adding to it. Sometimes they need stuff which is only on the branch, but sometimes even the few bits already in CVS HEAD are enough!

Er, I actually do have one more thing to say about the subject: GDB had one project accepted in the Google Summer of Code 2009. Oguz Kayral is the student working on it, and I am his mentor. He will add support for subscribing to inferior events (e.g., signals, process and thread stops, thread creation) from Python. One use case for which this is useful was given by an IRC user at the #gdb channel:

<LimCore> how to run gdb from command line, so that it will run ./foo.bin with arguments: foo bar baz and it will run it instantly without waiting for ‘r’; And if program segfaults then it will do ‘bt’ without waiting for the command. (and if program terminates normally then it will also just quit)

LimCore will be able to write a simple and short Python script using the events API to solve his problem.

Now, moving on to other items: my team has been asked to improve GDB support for the hardware debug facilities in embedded PowerPC processors (for more info about these facilities, see Chapter 10 of Book III-E of the Power ISA v2.06). I announced this work to the GDB mailing list back in early March, and got useful insight from Joel Brobecker.

Today I posted an update on where we are with this work. We have the following ready for both native GDB and gdbserver on Linux:

  • one additional hardware watchpoint (two in total),
  • four hardware breakpoints,
  • one ranged hardware watchpoint.

And we still have the following features ahead of us:

  • support for the two DVC (Data Value Compare) registers, which enable hardware-accelerated conditions for hardware watchpoints,
  • two ranged hardware breakpoints.

Last and least, I was thinking of posting monthly GDB updates on what happened in GDB in the previous month as I did back in February, but I got busy and didn’t get around to it. I still entertain the idea though, so if you think it’s worth it, I’d be glad to know.

Read Full Post »

It’s been a while since I last talked about Python scripting support in GDB. Mostly because I’ve been focusing on getting stuff from the branch merged into CVS HEAD, so that GDB 7.0 can have some useful Python bindings.

The latest two patches committed upstream are for creating convenience functions in Python, and fo manipulating a program’s stack frames as Python objects. So, what can you do with those? I’ll borrow an example from Tom Tromey here: suppose you want to set a breakpoint which triggers only when the code is called by one specific function. You can create a convenience function like this:

import gdb
import re

class CallerIs (gdb.Function):
    """Return True if the calling function's name is equal to a string.
This function takes one or two arguments.
The first argument is the name of a function; if the calling function's
name is equal to this argument, this function returns True.
The optional second argument tells this function how many stack frames
to traverse to find the calling function.  The default is 1."""

    def __init__ (self):
        super (CallerIs, self).__init__ ("caller_is")

    def invoke (self, name, nframes = 1):
        frame = gdb.selected_frame ()
        while nframes > 0:
            frame = frame.older ()
            nframes = nframes - 1
        return frame.name () == name.string ()

CallerIs ()

And then create a conditional breakpoint using it, as in:

(gdb) break foo.c:42 if $caller_is ("some_function")

Or, to check the name of the grand-grand-caller of the code:

(gdb) break foo.c:42 if $caller_is ("some_function", 3)

Cool, huh? Now, why bother writing that big doc comment? GDB will use it as online help for the function you wrote:

(gdb) help function caller_is
Return True if the calling function's name is equal to a string.
This function takes one or two arguments.
The first argument is the name of a function; if the calling function's
name is equal to this argument, this function returns True.
The optional second argument tells this function how many stack frames
to traverse to find the calling function.  The default is 1.

One other patch which was merged in HEAD enables creating new GDB commands in Python, so you can write new commands to do some frame tricks too!

If you’d like to know more about the Python scripting work in GDB, I suggest you read the series of blog posts from Tom Tromey on this subject. It’ll give you a pretty good idea of what we have in the Python branch, and the direction we’re heading. Just keep in mind that some method names and syntax changed since he wrote that. Refer to the GDB manual in the Python branch (“make gdb.pdf” in gdb/doc/) or the example scripts (also in the Python branch, in gdb/python/lib/gdb/) for up-to-date details.

Read Full Post »

resolvendo nomes na rede de casa

Desde que eu tenho dois notebooks em casa eu senti a necessidade de ter resolução de nomes funcionando decentemente para eles, ao invés de ter que ficar vendo qual IP o roteador designou para cada notebook cada vez que preciso acessar um ou outro computador. Primeiro pensei em fixar um IP baseado no endereço MAC, mas meu roteador não tem essa funcionalidade. Depois fiquei imaginando se não existia algum servidor DNS pra uso doméstico que pode ter suas entradas atualizadas dinamica e automaticamente.

Qual não foi minha surpresa quando descobri que a solução pro meu problema não só já existe, como não exige configuração nenhuma e além disso já estava instalada e funcionando nos dois computadores! Chama-se Multicast DNS (mDNS), e faz parte de um conjunto de tecnologias de “zero configuration networking”, da qual o Apple Bonjour faz parte. No Linux, o serviço que implementa isso é o Avahi.

Para usá-lo no caso que eu tinha em mente (basicamente, ssh e scp) basta usar o hostname do computador a ser acessado e acrescentar a extensão .local. Exemplo:

hotblack% ssh hactar.local
hactar% ping hotblack.local
PING hotblack.local (192.168.1.2) 56(84) bytes of data.
64 bytes from hotblack.local (192.168.1.2): icmp_seq=1 ttl=64 time=0.328 ms

Ótimo!

Eu já tinha ouvido falar de Zeroconf e do Avahi, claro. Mas eu achava que era só para descoberta de serviços na rede (coisa que nunca precisei, pelo menos por enquanto (mas acho a idéia bem legal)), não sabia que integrava com DNS!

Read Full Post »

Older Posts »