Acrescente o a seguinte linha no arquivo logger.conf  na seção logfiles:

test => notice,warning

Na console do asterisk, digite:

pbx*CLI> logger reload

Pronto, um novo arquivo de log está sendo gerado na pasta de logs do asterisk com as informações de notice e warning.

# ulimit -c

O número retornado é o tamanho máximo que o coredump pode ter em kb. Caso seja 0, significa que não será gerado coredump. Para garantir a geração, o valor pode ser especificado como infinito:

# ulimit -c unlimited

O problema é que seu programa pode estar rodando em uma sessão diferente, e assim, os limites podem varias. Desta maneira, o próprio programa pode alterar este parâmetro em tempo de execução. Segue um pequeno código de exemplo:

#include <signal.h>
#include <sys/time.h>
#include <sys/resource.h>

int main(int ac,char *av[]) {
struct rlimit limit;
limit.rlim_cur=RLIM_INFINITY;
limit.rlim_max=RLIM_INFINITY;

setrlimit(RLIMIT_CORE,&limit);
printf("%d\n",10/0);

return 0;
}

Neste exemplo, foi usada a struct rlimit. Seus membros são rlim_cur e rlim_max, sendo eles softlimit e hardlimit respectivamente. O valor definido para ambos foi infinito (RLIM_INFINITY). Para efetivar a alteração, usa-se a função setrlimit. Veja que este código exemplo irá terminar  em crash, pois há uma divisão por zero e o coredump deverá ser gerado.

Por isso, precisei fazer manualmente, baixar o pacote, desempacotar e copiar para a pasta de headers. Não sei se futuramente esses valiosos arquivos serão inclusos no pacote oficial, mas de qualquer maneira, eu criei um SlackBuild que possa ajudar quem está na mesma que eu.

#!/bin/bash
MIRROR=${MIRROR:-http://ftp.belnet.be/packages/slackware/slackware_source/}
VERSION=${VERSION:-3.2.7}
ARCH=noarch
BUILD=${BUILD:-2duderamos}
CWD=$(pwd)
TMP=${TMP:-/tmp}
PKG=$TMP/package-procps-dev

rm -rf $PKG
rm -rf $TMP/procps-$VERSION
if [ ! -f procps-${VERSION}.tar.gz ];then
  wget "${MIRROR}/a/procps/procps-${VERSION}.tar.gz" || exit 1
fi

cd $TMP

tar xzvf $CWD/procps-$VERSION.tar.gz || exit 1

mkdir -p $PKG/install
mkdir -p $PKG/usr/include/procps
mkdir -p $PKG/lib

cd $TMP/procps-$VERSION
cp proc/*.h $PKG/usr/include/procps
cat $CWD/slack-desc > $PKG/install/slack-desc
cat $CWD/doinst.sh > $PKG/install/doinst.sh

cd $PKG

makepkg -l y -c n $TMP/procps-dev-$VERSION-$ARCH-$BUILD.txz

rm -rf $TMP/procps-$VERSION.tar.gz
rm -rf $TMP/procps-$VERSION
rm -rf $PKG

Não sei se ficou claro, mas segue a dica:

http://www.youtube.com/watch?v=[video id]#at=[tempo de offset em segundos]

Exemplo:

http://www.youtube.com/watch?v=EShea9vWFtI#at=30

Vai começar o vídeo METNAL – Perfect Strangers (Deep Purple Cover) – Curitiba a partir de 30 segundos do início.

altgr keycode  16 = slash
altgr keycode  17 = question

Com isto, adicionei no mapeamento do teclado a combinação necessária. Para carregar, usei o comando:

loadkeys br-abnt2

O seu funcionamento é baseado no módulo pbx_spool.so do Asterisk, e portanto, este deverá estar carregado para funcionar. Ele pode ser baixado aqui.

Pesquisando na Internet como eu poderia fazer isso, encontrei a solução implementada por Eric Hameleers em seu blog. Logo baixei e fiz funcionar. Pronto, agora só me falta configurar o slackpkg de todos.

Em máquinas virtuais baseadas no KVM, é possível montar uma partição de uma máquina virtual no servidor hospedeiro. Para isto, basta usar o módulo Network block driver (nbd). Para habilitar, verifique se sua configuração do kernel contém “CONFIG_BLK_DEV_NBD=m” ou “CONFIG_BLK_DEV_NBD=y”. Caso seja um módulo, basta carregá-lo com o modprobe.

modprobe nbd max_part=63

Mais informações, use: modinfo nbd.

No pacote do qemu-kvm, vem uma ferramenta chamada qemu-nbd. Com ela, basta conectar algum dos arquivos de bloco nbd à imagem do disco virtual. No meu caso:

qemu-nbd -c /dev/nbd0 /dev/logical/dns2

.

Ele critou outros arquivos de blocos, representando todas as partições do meu disco virtual: /dev/nbd0p1, /dev/nbd0p2 e /dev/nbd0p3. Com isto, basta eu montar este bloco a alguma pasta do sistema, como no exemplo:

mount /dev/nbd0p1 /mnt/tmp

Vale lembrar que o hospedeiro precisa ter suporte ao sistema de arquivos da partição que será montada.

Para desconectar, é preciso desmontar as partições montadas anteriormente e desconectar o dispositivo.

qemu-nbd -d /dev/nbd0

Mais informações use “qemu-nbd -h” ou “man qemu-nbd”.

No meu caso, eu tinha uma VM montada sobre um volume de 10GB, e eu desejava expandir este espaço para 30GB, sem ter que anexar outro volume. Segui rigorosamente estes passos: parar a VM, expandir o volume lógico, dar boot com um CD ou pendrive de boot da distribuição, recriar a tabela de partições com o fdisk com os novos valores, estender a partição ext4 com resize2fs. Acompanhe mais detalhadamente abaixo.

Volume lógico

Antes de mais nada, a máquina virtual deverá estar desligada. No servidor hypervisior, execute o seguinte comando:

lvextend -L +20G /dev/logical/plutus

Isto faz com que meu volume lógico ‘plutus’ seja aumentado em 20GiB (veja diferença entre GiB e GB)

Partição física do disco virtual

Depois de o volume esticado, basta dar o boot na máquina virtual usando um disco de boot externo. Isto é importante porque vamos mexer na estrutura básica das partições. No meu caso eu uso Slackware64 13.1 e fdisk, mas nada impede de usar outra distro e ferramenta. O importante é que não haja formatação na finalização do processo. Aqui, assume-se que você saiba usar a ferramenta escolhida.

Na minha VM, eu tenho duas partições: / (root ou barra) como sda1 de 9,5GiB e swap como sda2 0,5GiB. Neste passo, preciso entrar no fdisk no dispositivo sda e excluir as duas partições. Mas calma! Isto não fará com que você perca seus dados, pois estamos apenas mexendo no mapeamento das partições, onde começa e termina o que. Depois de excluir, criei a partição número 1, que corresponde ao / com o tamanho de 29,5GiB e o restante para swap. Aqui é importantíssimo que se observe o início da partição 1, que deverá estar no mesmo bloco da anterior. Caso contrário, os dados ficarão inacessíveis. Feito isto, basta salvar a nova tabela de partições.

Estendendo a partição ext4

Aproveitando que não estamos rodando em cima do disco em questão, vamos efetivar o tamanho da partição útil do sistema. Para isto usarei o comando resize2fs do pacote e2fsprogs. Este passo é muito simples, basta usar o comando:

resize2fs /dev/sda1

Isto fará com que ele aumente a partição ext4 para o máximo possível, no caso 29,5GiB. É provável que ele solicite uma checagem com o fsck antes de fazer isto. Basta usar o comando:

fsck /dev/sda1

Finalização

Agora, basta testar. Antes mesmo de um boot no disco principal, tente montara nova partição:

mount /dev/sda1 /mnt

Se tudo correu bem, você poderá navegar na nova partição pelo ponto de montagem /mnt. Agora basta dar um reboot usando o disco principal.