• GPL - GNU Public License v2 or later
• GPL v2 - GNU Public License v2
• GPL and additional rights - GNU Public License v2 rights and more
• Dual BSD/GPL - GNU Public License v2  or BSD license choice
• Dual MIT/GPL - GNU Public License v2 or MIT license choice
• Dual MPL/GPL - GNU Public License v2 or Mozilla license choice

Como vocês podem notar, há componentes que podem ser definidos com licenças duplas, contudo quando executado no Linux apenas a GPL é relevante. Algumas razões para definir a licença:

1. O modinfo pode mostrar informações para usuários que desejam avaliar as licenças dos módulos sua instalação.
2. A comunidade pode ignorar relatórios de bugs dos módulos proprietários.
3. Os fabricantes podem fazer o mesmo com suas próprias políticas.

Para inserir a licença, basta colocar no seu código-fonte a macro  ”MODULE_LICENCE”. Exemplo:

  MODULE_LICENCE("GPL");

Lembre-se que alguns recursos do kernel são disponíveis apenas se seu código é livre.

Um exemplo é o sysfs (através da macro EXPORT_SYMBOL_GPL) que por questões de manutenção e consistência exige que você licencie seu módulo em alguma licença compatível com a GPL.

Slides: http://www.slideshare.net/maluta/calourada2010

:wq

You would have noted that kernel IP auto-configuration is not usable for some USB-Ethenet dongles on newer kernel because it starts before the USB devices are found. This was already discussed on LKML.  I proposed a workaround adding a section on menuconfig to user increase delay (patch) but other developer proposed another patch to configure this delay at runtime rather than at compile time. This patches weren’ t  applied to mainline (to further information check link). I decided post here because I take some time to configure my NFS  rootfs due this delay. My tests were made using BeagleBoard and USB-Ethernet dongle based on ASIX 8877x.

Eu costumo utilizar o $HOME/.ssh/config para deixar todos meus hosts ssh configurados, pra quem não conhece isso, basta criar este arquivo, e ele usa o seguinte formato:

Host <nome servidor>
HostName <host/ip>
User <usuário>

realizando a configuração de um servidor fictício:

Host servidor
HostName localhost
User root

Feito isto, basta digitar: ssh servidor, que seria o equivalente a ssh root@localhost, isto facilita quando não se tem acesso ao /etc/hosts para guardar nome amigável para determinados ips, e quando se acessa diferentes servidores com diferentes nomes de usuários. Voltando ao nosso problema, eu tenho meu config, mas meu known_hosts esta desatualizado ou pior, vazio!

A cada nova conexão seria necessário aceitar cada chave do servidor, como a seguir:

The authenticity of host ’servidor (127.0.0.1)’ can’t be established.
RSA key fingerprint is bc:b1:8d:c3:61:6a:5b:9f:c1:b2:16:c5:e4:d2:b1:b2.
Are you sure you want to continue connecting (yes/no)?

O que torna cansativo, principalmente se tiver que executar um comando em cada servidor, então temos o seguinte script:

KNOWN_HOSTS=./ssh_known_hosts
SSH_ARGS="-o StrictHostKeyChecking=no -o UserKnownHostsFile=$KNOWN_HOSTS"
 
for host in `cat $HOME/.ssh/config |grep "^Host "|cut -d" " -f2`; do
    echo $host;
    ssh $host $SSH_ARGS echo '';
done
 
cnt=1
for host in `cat $HOME/.ssh/config |grep "^Host "|cut -d" " -f2`; do
    linha1=`sed "${cnt}q;d" $KNOWN_HOSTS`
    echo $linha1 $host >> ${KNOWN_HOSTS}.tmp
    echo "" >> ${KNOWN_HOSTS}.tmp
    let cnt++
done
 
mv ${KNOWN_HOSTS}.tmp ${KNOWN_HOSTS}

O que este script faz, nada mais é do que ler cada Host configurado no arquivo $HOME/.ssh/config e aceitar automaticamente a chave primária do mesmo através da opção -o StrictHostKeyChecking=no e salva no arquivo -o UserKnownHostsFile=$KNOWN_HOSTS (no nosso caso KNOWN_HOSTS=./ssh_known_hosts), fiz isso para não sobrescrever o seu arquivo known_hosts e ainda para facilitar a leitura do arquivo, ou pegar somente os hosts que lhe interessam, o segundo for do script coloca o valor do ‘Host’ como comentário em cada fingerprint.

Vale a pena lembrar que cada chave será automaticamente aceita, então cabe a você garantir que realmente cada chave pertence ao servidor em questão, e não esta ocorrendo nenhum tipo de ataque man-in-the-middle. E após executado o script, é só colocar os fingerprints no known_hosts e estamos prontos para conectar no servidor sem confirmação dos mesmos.

Até breve.

Um dos pontos que a estatística não mostra é que – mesmo sendo empregado de grandes empresas – boa parte do trabalho é feita fora do horário “comercial”, se alguém observar as datas de todos os commits e organizá-los pela frequência em horas, você tem o seguinte resultado para diferentes releases.

v2.6.33-rc7		v2.6.32			  v2.6.24	

Hora	Commits		Hora	Commits		Hora	Commits
0	8069		0	7808		0	4745
1	7052		1	6800		1	4155
2	4715		2	4556		2	2835
3	2717		3	2601		3	1395
4	2236		4	2096		4	898
5	1426		5	1193		5	559
6	1299		6	1134		6	381
7	1933		7	1723		7	580
8	4108		8	3798		8	1445
9	6429		9	6003		9	2261
10	8550		10	7969		10	3027
11	10284		11	9640		11	3946
12	9191		12	8403		12	3313
13	11728		13	11024		13	4522
14	13127		14	12340		14	5052
15	14281		15	13295		15	5813
16	13685		16	12721		16	5212
17	11486		17	10793		17	5050
18	7938		18	7334		18	3335
19	7354		19	6933		19	2850
20	7460		20	6953		20	3161
21	8561		21	8138		21	3436
22	8953		22	8498		22	3872
23	7741		23	7335		23	3843

Comando utilizado para gerar esses dados:

git log v2.6.33 | grep ^Date: | perl -pe ’s/^(?:\S+\s+){4}(\d+).*/$1/’ | sort -g | uniq -c

A conclusão é que muitos desenvolvedores fazem o código durante a noite e acordam tarde.

• Alguma distribuição GNU/Linux
• mplayer
• lame (caso queria converter para mp3)
• vorbis-tools (caso queira converter para ogg)

Os videos do YouTube, normalmente qualquer conteúdo Flash, fica armazenados na pasta /tmp do sistema operacional na forma FlashXXXX (exemplo: FlashaOiW6k). Para cada arquivo flash existirá um arquivo correspondente, para descobrir de qual se trata utilize o mplayer, no console (cd /tmp):

mplayer FlashaOiW6k

Após descobrir o arquivo, vamos primeiro converter o arquivo para wav e depois para algum formato mais compacto.

mplayer FlashaOiW6k -novideo -ao pcm:file=musica.wav

Convertendo para mp3:

lame -V2 musica.wav musica.mp3

Ou ogg:

oggenc musica.wav

No final temos os seguintes tamanhos para cada arquivo, considerando uma música de 4 minutos.

• 8.9M    FlashaOiW6k
• 21.0M    saida.wav
• 2.4M   saida.mp3
• 1.5M   saida.ogg

Este procedimento provavelmente irá funcionar para qualquer conteúdo Flash (ex. outros sites de video) que fique armazenado na tmp.

Um exemplo com o ext4:

./scripts/get_maintainer.pl -f  fs/ext4/

“Theodore Ts’o” <tytso@…>

Aneesh Kumar K.V <aneesh.kumar@…>

Eric Sandeen <sandeen@…>

linux-kernel@vger.kernel.org (lembre-se de se cadastrar e sempre de copiar a lista de email junto)

Um exemplo com o driver de video da Intel:

./scripts/get_maintainer.pl -f drivers/video/intelfb/

Sylvain Meyer <sylvain.meyer@…>

Andrew Morton <akpm@…>

Thomas Hilber <sparkie@…>

Stefan Husemann <shusemann@…>

Hannes Eder <hannes@…>

Paul Menzel <paulepanter@…>

linux-fbdev-devel@lists.sourceforge.net

linux-kernel@vger.kernel.org

Dar o retorno do uso de algum programa é ótimo para o desenvolvedor e garante a qualidade do sotfware.

# Set the ARCH and CROSS_COMPILE default values
ARCH            ?= arm
CROSS_COMPILE   ?= arm-unknown-linux-gnu-

Latest Linux (~2.6.31) turns it deprecated (commit 575543347b5baed0ca927cb90ba8807396fe9cc9). Now the settings are saved in two files named:

include/generated/kernel.arch
include/generated/kernel.cross

What changes?

Using the new way you don’t edit Makefile anymore, just need set once your definitions for cross compiling:

$ make ARCH=arm CROSS_COMPILE=arm-unknown-linux-gnu-

And for next builds just run make

$ make

This works both for plain builds and for O=… builds.

#nasm -g -f elf programa.asm
#ld programa.o
#gdb -q a.out

Vamos fazer um pequeno programa teste que carrega no registro ecx o valor da variável (var1) e em edx seu endereço:

section .data
 
   var1 dd 40
 
section .text
 
   global _start
 
   _start:
      nop
      nop
      mov   ecx, [var1]
      lea   edx, [var1]
 
   _exit:
      mov   eax, 1
      int   80h

Dentro do gdb:

(gdb) break 11
Breakpoint 1 at 0x80480a1: file teste.asm, line 11.
(gdb) r
Starting program: /home/maluta/coding/a.out
Breakpoint 1, _start () at teste.asm:11
11            nop
(gdb) print var1
$1 = 40
(gdb) info registers ecx edx
ecx            0x0      0
edx            0x0      0

Adicionamos um breakpoint (eu precisei inserir duas instruções nop para o gdb realmente para no ponto) e verificamos os valores de var1, ecx e edx.

(gdb) si
_start () at teste.asm:12
12            mov   ecx, [var1]
(gdb) si
_start () at teste.asm:13
13            lea   edx, [var1]
(gdb) info registers ecx
ecx            0x28     40
(gdb) si
_exit () at teste.asm:16
16            mov   eax, 1
(gdb) info registers edx
edx            0x80490b8        134516920

E por fim, verificamos o conteúdo no endereço definido em edx.

(gdb) print *0x80490b8
$2 = 40

Algumas considerações:

• O Data Diplay Debugger (DDD) é um front-end muito bom para o GDB que pode ser utilizado ao invés da interface de linha de comando.

• O após label _exit há uma chamada a uma syscall (adivinha qual?) do kernel. Passa-se o valor (no registro eax) e chama uma interrupção (80h).  A verdadeira “diversão” está em associar essas syscalls (write, fork, execve, …) mas isto é para outro post… Por enquanto vou lidar com os diferentes modos de endereçamento e operações lógicas e aritméticas.

No terminal:

# lsusb | grep Nokia
Bus 005 Device 004: ID 0421:04f0 Nokia Mobile Phone

É preciso carregar os módulos necessários, se você precisar compilar o kernel são as opções CONFIG_USB_ACM e CONFIG_USB_SERIAL do .config

# modprobe cdc-acm
# modprobe usbserial vendor=0x0421 product=0x04f0

Observe que os valores dos parametros do módulo usbserial são obtidos através do comando lsusb. A partir desse ponto será criado um device node referenciado por /dev/ttyACM0. O código é bem simples, aonde apenas instanciamos um objeto da classe PySerial e utilizamos os métodos de escrita e leitura.

import serial
ser = serial.Serial()
ser.port='/dev/ttyACM0'
ser.baudrate=19200
ser.rtscts=1
ser.timeout=3
ser.open()

Depois foi apenas usar os métodos write() e read() para fazer a prova do conceito. Como eu não sabia a quantidade de bytes a serem recebidos “chutei” um valor (10 bytes) e especifiquei um timeout para sair.

ser.write('AT'+'\x0d\x0a') # AT
ser.read(10)

O exemplo de envio de um SMS que o Mauro apresentou pode ser feito dessa forma, lembrando que a extensão ‘\x0d\x0a’ é o valor hexadecimal para o terminador de linha (o equivalente a pressionar [ENTER]).

ser.write('AT+CMGF=1'+'\x0d\x0a')
time.sleep(2)
ser.write('AT+CMGS="0XXYYYYYYYY"'+'\x0d\x0a')
time.sleep(2)
ser.write('www.coding.com.br'+'\x0d\x0a\x1a')
 # envia a mensagem (www.coding.com.br) para o número definido

Meus primeiros testes só funcionaram quando dei um atraso (não se esqueça do import time) entre cada comando, abritrariamente escolhi 2 segundos, mas acredito que esse valor possa ser menor (fiz testes e funcionou). Passei uma boa parte da noite experimentando diversos comandos AT que encontrei no manual, os comandos de faziam a requisição de alguma informação: nível do sinal, número de série, fabricante, etc funcionaram, mas quando tentei fazer uma requisição da lista de contatos ou das mensagens SMS não obtive sucesso (mas é claro que fiz testes rápidos sem dar atenção merecida a documentação).

Uma solução para fazer o equivalente no Excel é exportar a planilha no formato CSV e fazer um parser (lembrando que o Python já tem um módulo pronto que faz isso) ou então até mesmo fazer um plug-in para o OpenOffice