A criação e o gerenciamento de processos de espaço de usuário no Linux®

Conceito

Espaço de endereçamento é o intervalo de endereços de memória que um processo pode acessar.

A criação e o gerenciamento de processos de espaço de usuário no Linux® possuem muitos fundamentos em comum com o UNIX® mas também incluem várias otimizações específicas para Linux. Reveja aqui o ciclo de vida dos processos Linux e explore o interior do kernel para a criação, o gerenciamento de memória, o planejamento e a destruição do processo.

Linux é um sistema muito dinâmico com constantes necessidades de alterações de computação. A representação das necessidades computacionais dos centros Linux cerca a abstração comum do processo. Os processos podem ter vida curta (um comando executado da linha de comandos) ou vida longa (um serviço de rede). Por esta razão, o gerenciamento geral dos processos e seus planejamentos são muito importantes.

No espaço do usuário, os processos podem ser representados por identificadores de processo (PIDs). Na perspectiva do usuário, um PID é um valor numérico que identifica exclusivamente o processo. Um PID não é alterado durante o ciclo de vida de um processo, mas pode ser reutilizado depois que o processo termina, portanto, nem sempre é ideal armazená-lo em cache.

No espaço do usuário, é possível criar processos de qualquer uma destas formas. É possível executar um programa (o que resulta na criação de um novo processo) ou, dentro de um programa, é possível chamar uma chamada do sistema fork ou exec. A chamada fork resulta na criação de um processo filho, enquanto uma chamada exec substitui o contexto do processo atual pelo novo programa.

Um ponto importante relacionado ao endereçamento de memória é constatado nesse momento. Quando o fork é realizado, internamente no Linux, é chamado um comando denominado do_fork(). A função do_fork começa com uma chamada para alloc_pidmap, que aloca um novo PID. Em seguida, do_fork faz a verificação para ver se o depurador está rastreando o processo pai. Se estiver, o sinalizador CLONE_PTRACE será configurado em clone_flags na preparação para a bifurcação. A função do_fork continua então com uma chamada para copy_process, transmitindo os sinalizadores, a pilha, os registros, o processo pai e o PID recentemente alocado.

Quando o fork é realizado é feita uma cópia da área de memmória mm para o processo filho recém-criado. Isso é feito da seguinte forma: - O processo filho recebe um novo descritor de memória,uma cópia do descritor de memória do processo pai. - A função copy_mm() é usada para copiar o descritor de memória do pai para o seu filho. - A macro allocate_mm em kernel/fork.c é responsável por alocar a estrutura mm_struct e uma chamada a memcpy copia o conteúdo do descritor do pai para o descritor do filho.

Após realizado estes passos o processó já está criado e a sua área de memória está definida para a utilização durante a execução deste novo processo filho.

Um processo como uma instância de execução de um programa

Memória, Programa e Processo

Um processo ao ser criado ou executado não enxerga diretamente a memória física da máquina, e sim, a memória lógica. Na hora da exuceção do processo quando ele acessa a um endereço lógico, aí sim, eles são "transformados" em endereços reais que indicam onde os dados necessários estão gravados. Esse mapeamento lógico-físico é feito pela MMU (Memory Management Unit) que é a responsável por realizar tal tarefa.

O espaço de endereços lógicos é dividido em unidades chamadas páginas e o espaço de memória física é dividido em unidades chamadas quadros de página, de mesmo tamanho das páginas. A MMU tem uma tabela que indica para cada página, qual o quadro de página que corresponde à mesma. Se o processador tenta acessar o endereço 0, a MMU verifica que isto corresponde ao primeiro endereço da primeira página, verifica então que essa primeira página está alocada no terceiro quadro de página. Converte então esse endereço para 8192 (decimal) e envia o endereço convertido para a memória (nem a memória e nem o processador precisam ficar sabendo da existência de paginação).

Como nem todas as páginas do espaço virtual podem estar residentes na memória simultaneamente, ocorrer o caso de que um acesso seja realizado para um página que não está na memória. Para saber isso a MMU mantém na tabela de translação um bit para cada página que indica se a mesma está presente ou não na memória. Se um acesso for realizado a uma página ausente, é gerada uma falta de página, que chama uma rotina de tratamento de interrupção específica para o SO, que então se encarrega do carregamento da página faltante e o ajuste correspondente na tabela de translação.

Processos

Quando um programa está para ser executado é criado um processo que será incumbido de realizar todas as suas tarefas e buscar os recursos necessários na máquina para tanto. Ao ser alocado em processo, ele realiza uma alocação de descritor de processo e áreas de memória para pilha, dados e código.

Um processo em Linux é representado pela estrutura task_struct:

struct task_struct {

volatile long state;

void *stack;

unsigned int flags;

int prio, static_prio;

struct list_head tasks;

struct mm_struct *mm, *active_mm;

pid_t pid;

pid_t tgid;

struct task_struct *real_parent;

char comm[TASK_COMM_LEN];

struct thread_struct thread;

struct files_struct *files;

...

Criando uma nova task

No espaço do usuário, é possível criar processos de qualquer uma destas formas:

É possível executar um programa (o que resulta na criação de um novo processo) ou, dentro de um programa, é possível chamar uma chamada do sistema fork ou exec. A chamada fork resulta na criação de um processo filho, enquanto uma chamada exec substitui o contexto do processo atual pelo novo programa.

mm e active_mm

O