linux

Samba VirtualBox NT_STATUS_WRONG_PASSWORD

O Samba pode te fazer perder horas. Recentemente o VirtualBox começou a dar problemas com as pastas compartilhadas – Shared Folders – e alguns arquivos não abriam ou outros abriam corrompidos.

Fui atrás e o pessoal do VirtualBox explica que o serviço de incluir uma pasta de fora da máquina virtual (Guest) é básico e simples e que o correto e mais indicado seria usar NFS ou o Samba.

Pois bem, fui atrás de configurar o Samba. Como as pastas compartilhadas eram sensíveis resolvi colocar autenticação por usuário.

É o famoso:

[pasta]
        path = /home/carlos
        comment = Minha pasta
        writable = yes
        valid users = carlos

Porém nada do WinXP logar no samba no Linux. Habilitei o log nível 3  – dica: use tail * -f na pasta de logs para acompanhar o processo de login – e achei os famigerados NT_STATUS_WRONG_PASSWORD. Para resolver qualquer problema de acesso ao Samba você acha na internet aos montes pessoas adicionando o conhecidíssimo Bad User e outras formas habilitando o acesso guest e nobody soluções que liberam o Samba para o mundo. Lembre-se que eu preciso de acesso restrito as pastas.

Solução

O problema do WinXP acessando o Samba é que o WinXP usa por padrão authenticação LM & NTLM e o Samba depois do 3.6 não aceita esta forma de autenticação – o Windows XP é velho.

Para resolver isto ou você muda o WinXP para NTLMv2 ( veja como aqui ) ou adiciona a seguinte linha no smb.conf

ntlm auth = yes

 e pronto!

Meu smb

Para consulta segue a seção [Global] do meu smb.conf

[global]
 workgroup = workgroup
 server string = SambaNotebook
 netbios name = Arch
 security = user
#map to guest = bad user
 dns proxy = no
 wins support = yes
 username level = 2
 log level = 3
 log file = /var/log/samba/samba.log.%m
 max log size = 50
 debug timestamp = yes
 username map = /etc/samba/smbusers
 passdb backend = smbpasswd
 smb passwd file = /etc/smbpasswd
 ntlm auth = yes
 
; encrypt passwords = yes
; guest ok = no
; guest account = nobody

 

Edit – Nem tudo foi lindo

Pois bem. Depois de um tempo não funcionou mais. Então eu tirava esta linha, reiniciava o Samba, colocava novamente, reiniciava novamente, tentava e dava certo. Até que percebi que na verdade os pacotes da rede não estavam chegando do Windows virtualizado ao Linux.

Fui novamente atrás e achei estas informações (site em inglês) sugerindo que usemos uma segunda interface de rede no Virtualbox e no Windows que só permita ao Host acessar o Guest por esta interface nova.

Também não funcionou perfeitamente.

Liguei o Windows 7 também do VirtualBox e testei. Funciona perfeitamente sem problema algum o compartilhamento. Mudei meu ambiente de trabalho do Windows XP para o Windows 7 perdendo obviamente em memória disponível. Mas desativei tudo quanto é embelezamento do Windows 7 e até que ficou mais rápido que o Windows XP em alguns aspectos.

Sugestão: Esqueça o Windows XP e o Samba juntos.

ReEdit – Voltei ao Windows XP

Algumas coisas não funcionaram no Windows 7 e precisei voltar ao WinXp. Utilizei a solução descrita no site acima e há uma nota interessante: Quando você cria uma interface host-only no Virtualbox ela só estará ativa quando se ligar o Virtualbox. Como o Samba inicia no boot a interface ainda não existe então ele só fará Bind nas interfaces existentes. Para resolver isto ou você reinicia o serviço Samba ou faz um serviço para criar a interface host-only antes do Samba iniciar.

A linha de comando para criar a interface host-only é:

exec vboxmanage hostonlyif ipconfig vboxnet0 --ip 192.168.56.1

Feito isso. O mapeamento de pastas remotas em drivers no Windows XP voltou a funcionar.

AWS EC2 – Mudei do Ubuntu para o CentOS

“Aviso este artigo não usa língua culta. Acabei de sair da Deciclopédia e você imagina né?”

Por muito tempo usei o Ubuntu em servidores virtuais. Em casa a mais de 10 anos uso o ArchLinux. O Ubuntu para servidores não é ruim e é muito fácil a configuração e diversos scripts de configuração aceleram o setup e o repositório é completo.

Porém um dia desses ao instalar o Drupal deu um ‘PAU’ no mysql que corrompeu o banco de dados e fiquei a ver navios. Como era uma instalação tentei reinstalar tudo. Bom. Eu nunca gostei do apt-get afinal estou acostumado ao modo Arch de fazer as coisas. Fui então tentar reinstalar tudo novamente e a coisa ficou feia. Aquele dpkg não desinstalava as ‘coisas’ por completo então quando eu fui tentar instalar novamente dava conflitos … arhhh!

Até que descobri o CentoOS. Que maravilha! Aquele Yum é rapidinho! Nada de ficar atualizando man pages. Só puxava o necessário. Downloads rápidos. Descompactação veloz! Adorei.

Mas tenho algumas ressalvas quanto a ele:

  • Não consegui instalar o Drupal em uma instância t2.nano. Sempre que rodava o install.php o mysql morria por falta de memória???? Isso nunca me aconteceu no Ubuntu. Tentei criar um swapfile mas não dava certo. O Swapon dizia que o parametro era errado. Nunca vi isso.
  • As configurações não são interativas. não existe a2enmod, a2ensite. É tudo manual. Mas não tenho problemas com isto já que uso o Arch. Mas para alguns pode ser.
  • O repositório é conservador. O PHP disponível no repositório oficial não é suportado pelo Drupal. Tem que adicionar outros repositórios. Isso assusta no começo.
  • O SELinux é loucura!!!! Erros estranhos acontecem com ele. Como tentar gravar em um local com todas as permissões corretas mas o SELinux não deixa. Então preste atenção a isto. O SELinux é muito útil, mas uma fonte de erros estranhos se não for compreendido.

Pessoalmente recomendo o CentOS. E de fato ele é muito usado em servidores.

 

 

AWS EC2 – Mudei de São Paulo para o Oregon

Pelo simples motivo que o valor de uma instância t2.nano em São Paulo é quase o mesmo preço de uma t2.micro, ou até com mais um pouco de grana uma t2.small no Oregon. Veja na tabela abaixo de 16.Fev.2017 :

captura-de-tela-de-2017-02-16-15-23-49

captura-de-tela-de-2017-02-16-15-23-43

Vejamos

Uma instância t2.nano em São Paulo custa 0.0101 $/h enquanto no Oregon 0.0059 $/h. O custo para 720 horas – 1 mês de uso – para São Paulo é 7.272$ e no Oregon 4.248$.

Uma instância t2.micro no Oregon custaria 8.64$ por somente um Dólar a mais, então é melhor pegar uma instância no Oregon não acha?

Tabelinha

Local t2.nano 720 Horas
São Paulo 0.0101 7.272
Oregon 0.0059 4.248
Local t2.micro 720 Horas
São Paulo 0.02 14.4
Oregon 0.012 8.64

Mas …

O Ping é bem maior no Oregon para cá, sem dúvida. No terminal SSH em São Paulo parece que estou localmente. No Oregon há um atraso perceptível. Isso limita o uso para algumas aplicações. Este é um problema também com a DigitalOcean e qualquer servidor fora do Brasil.

Entretanto os downloads dentro da região (America Norte) ficaram muito, mas muito mais rápidos. 

Outro destaque é que houve alguns apagões nas ‘nuvems’ AWS dos EUAs; coisa de 8h fora do ar.

AWS EC2 – Montando volumes EBS em sua máquina local usando sshfs

Quebra o galho. Para isso montei um script BASH para conexão as instâncias remotas que automaticamente monta o volume EBS no meu sistema de arquivos local e abre uma sessão SSH:

con.sh:

#!/bin/bash
url=$1
sshfs [USUÁRIO]@$url:/    /[LOCAL] -o IdentityFile=~/.ssh/AWS-Instance1.pem &
ssh -i ~/.ssh/AWS-Instance1.pem [USUÁRIO]@$url

Vamos entende-lo e configurá-lo para sua instalação:

  • url=$1 –  Permite você especificar o DNS dinamico da Amazon de sua instância caso você não tenha um Elastic IP associado. Neste caso você invocará o script assim: ./con.sh ec2-52-67-85-194.sa-east-1.compute.amazonaws.com 
  • [USUÁRIO]@$url:/ – [USUÁRIO] deverá ser substituído pelo usuário remoto. No CentOs é o ‘centos’ no Ubuntu é o ‘ubuntu’. O “: / é local remoto onde você quer montar. Neste script montei tudo. Mas pode ser /var/www por exemplo.
  • /[LOCAL] É onde será montado em sua máquina o volume EBS. Alguns montam em um subdiretório em /mnt outros em /media. Exemplo /media/centosec2
  • ~/.ssh/AWS-Instance1.pem – É o arquivo de chave de acesso ao servidor remoto SSH. Supondo que você usa este método de segurança.

Como usar:

$ ./con.sh ec2-52-67-85-194.sa-east-1.compute.amazonaws.com 

Confira no navegador de arquivos se apareceram as pastas. Se montou mas não apareceu pode ser problemas com Udisks.

Requerimentos:

  • Fuse tem que estar instalado na sua máquina e o pacote fuse-sshfs também.
  • O servidor remoto tem que ter o serviço SSH rodando em suas configurações padrão tanto para Ubuntu como CentOS.

 

AWS EC2 – Como ter endereço IP fixo em um instância?

 

Este é outro serviço e é tarifado. Mas calma! é muito barato. Eu até agora (e a muito tempo) não passo de $0.01 por mês de custo não tenho certeza se já vi $0.04.

 

Vamos-lá!

Estando no console web EC2 – onde se administra suas instâncias -. No menu esquerdo acha-se o Elastic IPs conforme figura abaixo.

Captura de tela de 2017-02-08 18-28-39.png

Clique em Allocate new address (o botão azul) e um IP fixo se torna disponível conforme abaixo:

Captura de tela de 2017-02-08 18-32-56.png

Clique com o botão direito no IP criado e na opção Associate address é onde você ira ligar o IP fixo a uma instância sua rodando. Na pŕoxima tela você irá confirmar a associação.

Captura de tela de 2017-02-08 18-35-50.png

Selecione sua instância e o IP privado que será associado a ela e pronto! Se tiver dúvidas quanto ao custo – e eu tive no começo – . Abra a janela de custos – Billing –  e vá acompanhando por algumas horas e dias para ver quando custará.

É o Dólar está caro! Mas 1 centavo não pesa! EDIT: (Já não esta mais. É a gasolina que está)

Não adianta hacker este IP. Eu criei e apaguei logo em seguida –  e não custou nada.

AWS EC2 / DigitalOcean– Aonde consigo certificado SSL gratuito?

Deu sorte!

O site Let’S Encrypt fornece certificados SSL gratuitos por 3 meses renováveis por enquanto indefinidamente.

Há um programa que automaticamente registra no site, faz download do certificado e muda suas configurações apache habilitando https com certificado.

O programa fica em outro site o CertBot . Escolha seu servidor web e a distribuição e siga as orientações.

Captura de tela de 2017-02-08 18-21-39.png

Moleza …

 

AWS EC2 – Qual a diferença entre Stop e Terminate?

Terminate coloca fogo na sua casa. Ele desliga o servidor. Apaga a imagem EBS e adeus conteúdo.

Stop depende. Se o comportamento de desligamento estiver para Parar (STOP) a instância o servidor apenas desligará e seu volume EBS ainda estará lá. Isso quer dizer que nada será perdido. Basta rodar novamente (running). Mas se a opção de desligamento for a de Terminar (Terminate) ao comandar Stop diga adeus ao seu volume EBS ligado a instância.

Para ver isto clique com o botão na instância e siga em Instance Settings -> Change Shutdown Behavior e o popup igual à figura abaixo irá aparecer para mudar e conferir o comportamento padrão ao comandar STOP.

captura-de-tela-de-2017-02-08-17-58-14

AWS EC2 – Se eu parar (Stop) uma instância serei cobrado?

Inaugurando artigos sobre Cloud Servers.
Não e sim. Você ainda será cobrado por volumes EBS, Elastic IPs, Route 53 e outros recursos. Mas é claro, a não ser que você tenha um volume gigante os custos de mante-los serão muito baixos comparados à instância rodando (running).
Eu faço muito isso. Crio instância, paro, vou tomar café, dormir, rodo faço alguma configuração, paro novamente. Até que o servidor esteja de fato público – se este for o caso.

STM32 no Linux

Programar Kits ou microcontroladores STM32 no Linux é perfeitamente possível graças ao GNU ARM Toolchain para tanto é necessário instalar este e outros pacotes primos como veremos neste post. Será mostrado aqui a instalação destes pacotes e um simples programa blink sem bibliotecas de suporte.

Há vários toolchains disponíveis para uC ARMs alguns que se utilizam das syscall de algum SO como o Linux e outros que não esperam nenhum Sistema Operacional por trás, programar assim é chamado comumente como ‘baremetal’.

Para debugar e gravar um STM32 será utilizado o ST-Util e o OpenOCD.

Instalando os pacotes

GCC + GDB + OpenOCD

Eu utilizo o ArchLinux mas não poderia discriminar o Ubuntu.
Para o Ubuntu:

sudo add-apt-repository ppa:terry.guo/gcc-arm-embedded
sudo apt-get update
sudo apt-get install gcc-arm-none-eabi
sudo apt-get install gdb-arm-none-eabi
sudo apt-get install openocd

ArchLinux users:

sudo pacman -S arm-none-eabi-binutils arm-none-eabi-gcc arm-none-eabi-gdb arm-none-eabi-newlib openocd stlink

Se tudo ocorreu corretamente teste a instalação abrindo um shell e digitando arm-none <TAB> isso fará o bash autocompletar a sequência e mostrar os executáveis instalados como nesta saída tipica:

arm-none-eabi-addr2line arm-none-eabi-gcc-4.7.4 arm-none-eabi-ld.bfd
arm-none-eabi-ar arm-none-eabi-gcc-ar arm-none-eabi-nm
arm-none-eabi-as arm-none-eabi-gcc-nm arm-none-eabi-objcopy
arm-none-eabi-c++ arm-none-eabi-gcc-ranlib arm-none-eabi-objdump
arm-none-eabi-c++filt arm-none-eabi-gcov arm-none-eabi-ranlib
arm-none-eabi-cpp arm-none-eabi-gdb arm-none-eabi-readelf
arm-none-eabi-elfedit arm-none-eabi-gdbtui arm-none-eabi-size
arm-none-eabi-g++ arm-none-eabi-gprof arm-none-eabi-strings
arm-none-eabi-gcc arm-none-eabi-ld arm-none-eabi-strip

Primeiro Programa

Antes de tudo vamos iniciar a configuração do vetor de interrupções, a routina de reset e alguns Defines para alguns registradores que iremos usar. Este programa foi feito para o kit STM32 Discovery F0. Com poucas modificações e entendendo o processo a migração para outros (M3/M4) será fácil.

O primeiro arquivo boot.h contém alguns typedefs e Defines para registradores de clock e GPIOs, declaração de váriaveis externas do arquivo de link, prototypes de funções e o vetor de interrupções (que neste caso só cobrirá as interrupções ARM). Também o Reset e SystemInit bem como as funções de tratamento de interrupções serão declaradas.

boot.h

// boot.h
#define uint32_t unsigned int
#define IO_Uint32 volatile unsigned int
typedef struct
{
IO_Uint32 ACR;
IO_Uint32 KEYR;
IO_Uint32 OPTKEYR;
IO_Uint32 SR;
IO_Uint32 CR;
IO_Uint32 AR;
IO_Uint32 RESERVED;
IO_Uint32 OBR;
IO_Uint32 WRPR;
} _FLASH;

typedef struct
{
IO_Uint32 CR;
IO_Uint32 CFGR;
IO_Uint32 CIR;
IO_Uint32 APB2RSTR;
IO_Uint32 APB1RSTR;
IO_Uint32 AHBENR;
IO_Uint32 APB2ENR;
IO_Uint32 APB1ENR;
IO_Uint32 BDCR;
IO_Uint32 CSR;
IO_Uint32 AHBRSTR;
IO_Uint32 CFGR2;
IO_Uint32 CFGR3;
IO_Uint32 CR2;
} _RCC;

typedef struct {
IO_Uint32 MODER;
IO_Uint32 OTYPER;
IO_Uint32 OSPEEDR;
IO_Uint32 PUPDR;
IO_Uint32 IDR;
IO_Uint32 ODR;
IO_Uint32 BSRR;
IO_Uint32 LCKR;
IO_Uint32 AFRL[2];
IO_Uint32 BRR;
} _GPIO ;

#define GPIOC ((_GPIO *) 0x48000800)
#define RCC ((_RCC *) 0x40021000)
#define FLASH ((_FLASH *) 0x40022000)

// Globais do arquivo do linker
extern void *_estack;
extern unsigned char _sidata;
extern unsigned char _sdata;
extern unsigned char _edata;
extern unsigned char _sbss;
extern unsigned char _ebss;
extern void main (void);

// Entry Point
void Reset (void);
// Default Interrupt Handler
void Default_Handler(void) __attribute__( ( interrupt ) );
static void HardFault_Handler( void )/* __attribute__( ( naked ) )*/;

__attribute__ ((section(".isr_vector")))
void (* const Vectors[])(void) = {
(void(*)(void)) &amp;_estack,
Reset,
Default_Handler, //NMI_Handler,
HardFault_Handler, //FaultHandler,
0,
0,
0,
0,
0,
0,
0,
Default_Handler, //SVC_Handler,
0,
0,
Default_Handler, //PendSV_Handler,
Default_Handler, //SysTick_Handler,
};

static void HardFault_Handler( void ){
__asm__("BKPT");
while (1);
}

#pragma weak _exit = Default_Handler
void Default_Handler(void) {
__asm__("BKPT");
while (1);
}

void SystemInit(void)
{
/* Reseta o RCC clock para  o padrão ------------*/
/* Set HSION bit */
RCC-&gt;CR |= (uint32_t)0x00000001;

/* Reset SW[1:0], HPRE[3:0], PPRE[2:0], ADCPRE, MCOSEL[2:0], MCOPRE[2:0] and PLLNODIV bits */
RCC-&gt;CFGR &amp;= (uint32_t)0x08FFB80C;

/* Reset HSEON, CSSON and PLLON bits */
RCC-&gt;CR &amp;= (uint32_t)0xFEF6FFFF;

/* Reset HSEBYP bit */
RCC-&gt;CR &amp;= (uint32_t)0xFFFBFFFF;

/* Reset PLLSRC, PLLXTPRE and PLLMUL[3:0] bits */
RCC-&gt;CFGR &amp;= (uint32_t)0xFFC0FFFF;

/* Reset PREDIV[3:0] bits */
RCC-&gt;CFGR2 &amp;= (uint32_t)0xFFFFFFF0;

/* Reset USART1SW[1:0], I2C1SW, CECSW, USBSW and ADCSW bits */
RCC-&gt;CFGR3 &amp;= (uint32_t)0xFFFFFE2C;

/* Reset HSI14 bit */
RCC-&gt;CR2 &amp;= (uint32_t)0xFFFFFFFE;

/* Desabilita todas as interrupções*/
RCC-&gt;CIR = 0x00000000;

FLASH-&gt;ACR = 0x00000011;

}
// O começo de tudo antes de main
__attribute__( ( naked ) ) void Reset (void) {

register unsigned char *src, *dst;

// Copia os dados da flash para a ram (const, static initialized variables)
src = &amp;_sidata;
dst = &amp;_sdata;
while(dst &lt; &amp;_edata) *dst++ = *src++;

// Inicializa o bss (C static variables non initialized)
dst = &amp;_sbss;
while(dst &lt; &amp;_ebss) *dst++ = 0;

SystemInit();
//__libc_init_array();
// ... and finally call main saving sp
__asm__("b main");

}

A função Reset inicializa a variáveis estáticas com zero, chama SystemInit e finalmente chama a função Main com um brunch para economizar RAM na pilha.

main.h

O segundo arquivo é o fluxo principal do programa onde esta a função Main. Este programa irá piscar os LEDs do kit nas portas PC9 e PC8. O tipo GPIO foi declarado anteriormente em boot.h.

#include "boot.h"

__attribute__( ( naked ) ) void main (void){

RCC-&gt;AHBENR |= ((unsigned int) 0x00080000); // Enable GPIOC otherwise a hardfault
GPIOC-&gt;MODER = 0x55555555; // Output mode for all PORTC

volatile register int i;

while (1) {

GPIOC-&gt;BSRR = 0x0000ffff;
for (i = 0; i &lt; 50000; i++); GPIOC-&gt;BSRR = 0xffff0000;
for (i = 0; i &lt; 50000; i++);

};

__asm__("b .");
};

Makefile e Link Script

Acabou? Não  Ainda faltam dois arquivos o MakeFile e o Script do Linker.

Este MakeFile é completo o que compilará, mostrará o tamanho do código, converterá ELF para BIN, irá gerar uma listagem em assembly e finalmente grava na flash o programa. Simplesmente execute o make no terminal de onde estão estes arquivos.

all:
arm-none-eabi-gcc -mcpu=cortex-m0 -gdwarf-2 -mthumb -nostdlib -mlittle-endian -Tlink.ld main.c -o main
arm-none-eabi-size main
arm-none-eabi-nm -S main
arm-none-eabi-objdump -d -M intel -S main &gt; bin.asm
arm-none-eabi-objcopy -O binary main main.bin
st-flash erase
st-flash --reset write main.bin 0x08000000
debug:
arm-none-eabi-gdb main -tui --eval-command="target extended-remote :4242"

E por fim o link  script. Lugar onde as posições de memória são definidos, o Entry Point e algumas globais usadas pelo Reset para inicializar a variáveis estaticas e constantes.

/* Entry Point */
ENTRY(Reset)

/* Highest address of the user mode stack */
_estack = 0x20001FFF; /* end of RAM */

/* Generate a link error if heap and stack don't fit into RAM */
_Min_Heap_Size = 0; /* Only usefull if you use alloc, malloc */
_Min_Stack_Size = 0x800;

MEMORY
{
FLASH (rx) : ORIGIN = 0x8000000, LENGTH = 64K
RAM (xrw) : ORIGIN = 0x20000000, LENGTH = 8K
}

/* Define output sections */
SECTIONS
{
/* The startup code goes first into FLASH */
.isr_vector :
{
. = ALIGN(4);
KEEP(*(.isr_vector)) /* Startup code */
. = ALIGN(4);
} &gt;FLASH

/* The program code and other data goes into FLASH */
.text :
{
. = ALIGN(4);
*(.text) /* .text sections (code) */
*(.text*) /* .text* sections (code) */
*(.glue_7) /* glue arm to thumb code */
*(.glue_7t) /* glue thumb to arm code */
*(.eh_frame)

KEEP (*(.init))
KEEP (*(.fini))

. = ALIGN(4);
_etext = .; /* define a global symbols at end of code */
} &gt;FLASH

/* Constant data goes into FLASH */
.rodata :
{
. = ALIGN(4);
*(.rodata) /* .rodata sections (constants, strings, etc.) */
*(.rodata*) /* .rodata* sections (constants, strings, etc.) */
. = ALIGN(4);
} &gt;FLASH

.ARM.extab : { *(.ARM.extab* .gnu.linkonce.armextab.*) } &gt;FLASH
.ARM : {
__exidx_start = .;
*(.ARM.exidx*)
__exidx_end = .;
} &gt;FLASH

.preinit_array :
{
PROVIDE_HIDDEN (__preinit_array_start = .);
KEEP (*(.preinit_array*))
PROVIDE_HIDDEN (__preinit_array_end = .);
} &gt;FLASH
.init_array :
{
PROVIDE_HIDDEN (__init_array_start = .);
KEEP (*(SORT(.init_array.*)))
KEEP (*(.init_array*))
PROVIDE_HIDDEN (__init_array_end = .);
} &gt;FLASH
.fini_array :
{
PROVIDE_HIDDEN (__fini_array_start = .);
KEEP (*(SORT(.fini_array.*)))
KEEP (*(.fini_array*))
PROVIDE_HIDDEN (__fini_array_end = .);
} &gt;FLASH

/* used by the startup to initialize data */
_sidata = LOADADDR(.data);

/* Initialized data sections goes into RAM, load LMA copy after code */
.data :
{
. = ALIGN(4);
_sdata = .; /* create a global symbol at data start */
*(.data) /* .data sections */
*(.data*) /* .data* sections */

. = ALIGN(4);
_edata = .; /* define a global symbol at data end */
} &gt;RAM AT&gt; FLASH

/* Uninitialized data section */
. = ALIGN(4);
.bss :
{
_sbss = .; /* define a global symbol at bss start */
__bss_start__ = _sbss;
*(.bss)
*(.bss*)
*(COMMON)

. = ALIGN(4);
_ebss = .; /* define a global symbol at bss end */
__bss_end__ = _ebss;
} &gt;RAM

._user_heap_stack :
{
. = ALIGN(4);
PROVIDE ( end = . ); /* Necessary for newlibc */
PROVIDE ( _end = . );
. = . + _Min_Heap_Size;
. = . + _Min_Stack_Size;
. = ALIGN(4);
} &gt;RAM

/* Remove information from the standard libraries */
/DISCARD/ :
{
libc.a ( * )
libm.a ( * )
libgcc.a ( * )
}

.ARM.attributes 0 : { *(.ARM.attributes) }
}

Foi apresentado aqui como programar microcontroladores STM32 no Linux utilizando as ferramentas gratuitas disponíveis. Não utilizei o conjunto de bibliotecas oficiais da ST chamado Cube para demonstrar também como é um programar um uC sem este suporte.

Como evolução o leitor irá integrar o Cube e utilizar o CubeMX para facilmente inicializar o uC e partir para a programação em si.

Eu programo microcontroladores STM32 no Linux profissionalmente com estas ferramentas e integro tudo no Code:Blocks que é uma ótima alternativa aos ambientes caros como IAR e Keil. Eu não me adaptei muito aos derivados gratuitos do Eclipse porque não gosto de programas que demoram para inicializar …

EDIT: O WordPress vive mudando meu código postado transformando caracteres especiais em formato HTML Entity e não sei como mudar isso. Se alguém ai souber me ajude por favor porque se você copiar e colar os códigos daqui será necessário corrigir muita pontuação.

Usando Ulimit para evitar que o computador trave (Opera)

O Scheduler sofre na minha mão em qualquer sistema operacional. Abro um monte de programas ao mesmo tempo e dentro deles muitos outros threads. As vezes uso o Firefox, Opera e Chromium de uma vez só com várias abas … isso quando não há o VirtuaBox rodando o WinXP com 1,5GB de memória reservada e ainda teimosamente estou rodando o ‘pacman -Syu’.

E roda bem! O problema são esses browsers  que as vezes descambam tudo e saem comendo memória como loucos. Cada um tem seu fraco, mas em geral o Flash complica tudo. Um java script muito pesado faz alguns browsers se perderem. Assistir a um video torna tudo mais lento por aqui.

Faz tempo que queria uma solução que mate ou limite os recursos desses browsers até que achei o óbvio: ulimit.

Ulimit

Facil de usar este comando embutido faz o que o nome sugere: Limitar os recursos para um terminal. E esses recursos podem ser memória, arquivos abertos, tamanho de arquivo, tempo de CPU e outros recursos.

Para ver seus limites atuais comande:

ulimit -a

E uma saída tipica como esta deverá ser mostrada:

core file size (blocks, -c) 0
data seg size (kbytes, -d) unlimited
scheduling priority (-e) 20
file size (blocks, -f) unlimited
pending signals (-i) 15217
max locked memory (kbytes, -l) 1024
max memory size (kbytes, -m) unlimited
open files (-n) 1024
pipe size (512 bytes, -p) 8
POSIX message queues (bytes, -q) 819200
real-time priority (-r) 0
stack size (kbytes, -s) 8192
cpu time (seconds, -t) unlimited
max user processes (-u) 15217
virtual memory (kbytes, -v) unlimited
file locks (-x) unlimited

Para alterar o limite da memória de um terminal user:

ulimit -v MEMORIA_EM_KILO

Para voltar ao normal:

ulimit -v unlimited

Tenha em mente que somente para o terminal que ele for chamado estes limites funcionarão. Muito útil.

Opera

O executável do Opera para nossa sorte é um script em /usr/bin/opera. O default deve ser este:

#!/bin/bash
# Allow users to override command-line options
# Based on Gentoo's chromium package (and by extension, Debian's)
if [[ -f /etc/opera/default ]]; then
. /etc/opera/default
fi
# Prefer user defined CHROMIUM_USER_FLAGS (from env) over system
# default CHROMIUM_FLAGS (from /etc/chromium/default)
OPERA_FLAGS=${OPERA_USER_FLAGS:-$OPERA_FLAGS}
exec /usr/lib/opera/opera $OPERA_FLAGS "$@"

Então adicionei ulimit acima de exec e testei com 1G. Com três páginas o Opera já reclamava de falta de memória. As vezes desligava e voltava sozinho, com todas as páginas anteriores reabrindo! Isso é bom. Sem travar nada!
Então aumentei para 2G e nunca mais ele matou meu computador.

Quer testar se seu browser sofre com sites pesados? Tente nestes sites de jogos online por exemplo: diverti.com.br, poki.com.br, y8, miniclips.

Segue alteração:

#!/bin/bash
# Allow users to override command-line options
# Based on Gentoo's chromium package (and by extension, Debian's)
if [[ -f /etc/opera/default ]]; then
. /etc/opera/default
fi
# Prefer user defined CHROMIUM_USER_FLAGS (from env) over system
# default CHROMIUM_FLAGS (from /etc/chromium/default)
OPERA_FLAGS=${OPERA_USER_FLAGS:-$OPERA_FLAGS}
ulimit -v 2048576;
exec /usr/lib/opera/opera $OPERA_FLAGS "$@"

Perigos

Não se deve matar um processo do nada. E  limitar sua memória pode trazer problemas já que a maioria dos programadores não tratam falta de memória. Felizmente o Opera se comporta bem. Fique alerta que talvez você perca algum serviço em andamento. Porém como eu uso os browsers em edições remotas e para usos não criticos se eles se desligam é muito melhor para mim que impedir de fato de usar os outros programas críticos.