UNIVERSIDADE FEDERAL DE UBERLNDIA

FACULDADE DE ENGENHARIA MECNICA

Curso de Graduao em Engenharia Mecatrnica

Trabalho de Concluso de Disciplina

Grupo 2
Professor Rivalino Matias Jnior

Guilherme Ramalho 11311EMT008

Rafael Froede 11311EMT016
Taynara Brito 11311EMT027

Uberlndia, dezembro de 2015

SUMRIO

Introduo ......................................................................................................................... 3
1

Objetivo ..................................................................................................................... 4

Problema proposto..................................................................................................... 5

Fundamentao Terica ............................................................................................ 6

3.1

System Call ........................................................................................................ 6

Implementao da System Call ................................................................................. 7

4.1

Compilao do Kernel ....................................................................................... 7

4.2

System Call ........................................................................................................ 8

4.3

A implementao da System Call .................................................................... 12

Concluses .............................................................................................................. 13

Bibliografia.............................................................................................................. 14

INTRODUO

Este relatrio visa detalhar o trabalho realizado pelos alunos referentes ao Grupo
2 como parte integrante da disciplina de Sistemas Operacionais do curso de Engenharia
Mecatrnica da Universidade Federal de Uberlndia.
O tema decorrente da discusso de gerenciamento de processos, que um dos
tpicos abordados na teoria, sendo o presente trabalho uma das tcnicas adotadas para
melhor abordagem do assunto, bem como tornar um pouco mais prtico os conhecimentos
adquiridos em sala de aula.
Desta forma, este relatrio ir abordar assuntos referentes a como implementar
uma system call no sistema operacional Linux que efetue anlises a nvel de processos
correntes no sistema.
Inicialmente, o grupo optou por uma abordagem terica, embasada por fontes
eletrnicas e livros. Em sequncia, encontra-se um detalhamento das prticas adotadas
para a implementao da mesma. E, finalmente, concluses apresentado resultados e
dificuldades encontradas na execuo do trabalho.

OBJETIVO

Este trabalho tem como objetivo a anlise, o projeto, bem como a implementao
de uma system call para o sistema operacional Linux (x86) por parte dos alunos que esto
cursando a presente disciplina.
Tal system call tem como funo a anlise de caractersticas tpicas de processos
existentes em sistemas operacionais, como PID do processo pai (PPID parent process
identify), UID (user identify) e tempo de existncia.

PROBLEMA PROPOSTO

Recebendo como parmetro um valor do PID a ser pesquisado nos processos

correntes do sistema operacional, a system call implementada deve retornar os seguintes
dados pertencentes ao processo identificado pelo valor de PID escolhido:

UID identificador de usurio;

PPID identificador do processo pai; e

Tempo de existncia.

Caso o valor entrado seja de um processo que no possui existncia, a system

call dever retornar -1 e encerrar a execuo.

3.1

FUNDAMENTAO TERICA

System Call

System Call, ou em portugus, chamada de sistema, pode ser definida como uma
funo responsvel por chamar o kernel do sistema para que este faa uma determinada
tarefa. Como o usurio no pode, diretamente, realizar operaes com o kernel, as
chamadas de sistemas foram criadas.
A Figura 1 trata-se de uma ilustrao de como funciona as system calls. Como
pode-se notar, uma determinada aplicao, ou mesmo o usurio, quando deseja solicitar
determinado servio do kernel, faz uma system call, sendo que a mesma ir se ocupar do
papel de passar todas as informaes para que ele execute a ao desejada.

Figura 1 - Ilustrao da ao de uma system call no sistema operacional.

Para uma melhor anlise, as system calls foram divididas em quatro grandes
grupos, sendo estes:

Chamadas de sistema para gerenciamento de processos;

Chamadas de sistema para gerenciamento de diretrios;

Chamadas de sistemas para gerenciamento de arquivo;

Chamadas de sistemas restantes.

Dado o fato de que o foco deste trabalho se d sobre gerenciamento de processos,

este tpico ser abordado mais detalhadamente.

4.1

IMPLEMENTAO DA SYSTEM CALL

Compilao do Kernel

A compilao do kernel se deu de forma apresentada pelo professor em sala de

aula. Ela ser descrita brevemente pois no possui grande nfase neste projeto.
Os arquivos do kernel utilizados e apresentados neste documento so
pertencentes a verso 3.17.1 do kernel do Linux Ubuntu e foram obtidos pelo site
kernel.org.
Com os arquivos previamente descompactados em um novo diretrio (mas no
necessariamente, podendo utilizar um diretrio existente), pode-se inicializar as etapas de
compilao e instalao de um kernel modificado. Entretanto, neste primeiro momento,
o kernel est exatamente como quando foi baixado.
Para a execuo do processo de compilao e instalao de um novo kernel,
necessrio que algumas funes estejam presentes no sistema operacional. Ativar estas
funes o primeiro passo para a compilao e instalao.
Com tais funes j ativadas, deve-se estar no diretrio em que os arquivos do
kernel, j baixados e descompactados. E ento inicia-se as configuraes do kernel para
a compilao e instalao. Embora existam diversas configuraes que poderiam
aperfeioar a compilao, no se tratava do foco deste projeto ento as nicas
configuraes feitas foram a mudana do nome do novo kernel e a alterao da famlia
de processadores utilizado (quando necessrio).
Assim, os arquivos esto prontos para a compilao. O comando para tal ao
o make. Este comando responsvel por organizar um nmero mnimo de compilaes
necessrias para que se possa atualizar todo o kernel. Ele foi utilizado com a sequncia
j4 para que todos os 4 processadores lgicos pudessem ser utilizados em sua mxima
capacidade a fim de minimizar o tempo de compilao.
Aps o kernel compilado, compilou-se os mdulos pertencentes e ento os
instalou-se.
E, finalmente, o kernel pode ser instalado e, para que ele fosse inicializado com
o sistema operacional, uma reinicializao necessria e a escolha do kernel se d pelo
gerenciador de boot do Linux.
7

4.2

System Call

#include <linux/sched.h>
#include <linux/pid.h>
#include <linux/kernel.h>
#include <linux/cred.h>
#include <linux/ktime.h>
asmlinkage long sys_tcdso(int p){
pid_t pid = p;
kuid_t credd_uid;
long int tempost;
struct pid *pid_struct = find_get_pid(pid);
struct task_struct *task =
pid_task(pid_struct,PIDTYPE_PID);
struct task_struct *taskp =
pid_task(pid_struct,PIDTYPE_PID);
struct timespec tmp;
if (task == NULL){
return (-1);
}
else {
tempost = task -> start_time;
tmp = ktime_to_timespec(ktime_get_boottime());
credd_uid = task->cred->uid;
taskp = taskp -> parent;
printk("UID do processo: %ld.\n",credd_uid);
printk("PID do PAI: %ld.\n",(long int)taskp ->
pid);
printk("Tempo de vida [s]: %ld.\n", tmp.tv_sec
- tempost/1000000000);
return (0);
}
}
8

O cdigo que apresentado o utilizado para executar os requisitos do problema

proposto para o grupo. Nos pargrafos seguintes ele est explicado detalhadamente para
um melhor entendimento do leitor, tal explicao ser dada por partes.
#include <linux/sched.h>
#include <linux/pid.h>
#include <linux/kernel.h>
#include <linux/cred.h>
#include <linux/ktime.h>
Este cabealho presente na system call mostra as bibliotecas utilizadas para o
funcionamento de todas as funes que foram necessrias para o desenvolvimento da
system call. A biblioteca <linux/sched.h> contm a estrutura necessria para
encontrar os parmetros de identificao do processo. Por sua vez, <linux/pid.h>
possui parmetros necessrios para a localizao de estruturas relacionadas ao PID do
processo procurado. Estas estruturas sero abordadas a seguir. A utilizao da biblioteca
<linux/kernel.h> necessria de modo a ser permitida a utilizao da funo de
impresso no buffer do kernel (funo printk()). Para que o UID seja encontrado, a
biblioteca <linux/cred.h> necessria. E, por fim mas no menos importante, a
biblioteca referente a anlise do tempo de vida do processo, <linux/ktime.h>.
O trecho do cdigo a seguir possui todas as declaraes necessrias para o
funcionamento da system call que fora implementada.
asmlinkage long sys_tcdso(int p){
pid_t pid = p;
kuid_t credd_uid;
long int tempost;
struct pid *pid_struct = find_get_pid(pid);
struct task_struct *task =
pid_task(pid_struct,PIDTYPE_PID);
struct task_struct *taskp =
pid_task(pid_struct,PIDTYPE_PID);
struct timespec tmp;
Na primeira linha, est representado a declarao da system call nomeada por
sys_tcdso. Nota-se que esta funo retornar um tipo long quando for chamada pelo

usurio ou por alguma aplicao. O marcador asmlinkage representa um macro que

instrui ao compilador GCC de que esta funo necessita que seus argumentos sejam
colocados na pilha, ao invs de serem alocados em registradores. O argumento, como j
mencionado anteriormente, ser um inteiro representando o PID que se deseja analisar.
A linha consequente responsvel de alocar o argumento passado pelo usurio
em uma varivel tipo pid_t para que esta possa ser utilizadas em funes para anlises
de PID.
Seguindo, assim como a linha anterior, as duas linhas seguintes se comprometem
a determinar um tipo kuid_t para um campo onde ir receber o UID requisitado pelo
projeto e um tipo long int para armazenar o tempo de incio do processo.
A primeira estrutura ser utilizada para encontrar um ponteiro para outra
estrutura. Esta estrutura conhecida como task_struct. A task_struct se trata
de uma estrutura de dados que contm todas as informaes que o kernel possui sobre um
processo e, para ela, criou-se um ponteiro. Que ser inicializada nas duas linhas seguintes.
O fato de existir duas estruturas idnticas, apenas com nomes diferentes, se d ao fato da
necessidade de encontrar o PID do processo pai do processo identificado pelo PID
passado como argumento. Logo, deve-se encontrar a estrutura para o processo pai
tambm.
E, por fim, uma ltima estrutura foi declarada. Este tipo de estrutura,
timespec, fora necessrio para que o acesso ao tempo, em segundos desde o ltimo
boot, fosse possvel.
Assim, a seo de declaraes finalizada. O prximo trecho mostra o retorno
da system call caso o PID recebido no exista no momento da chamada. Como solicitado
pelo projeto, esta situao deve retornar o valor 1 para o usurio.
if (task == NULL){
return (-1);
}
Caso a comparao feita no trecho acima seja invlida, a chamada de sistema
continuar para o trecho mostrado a seguir:
else {
tempost = task -> start_time;
tmp = ktime_to_timespec(ktime_get_boottime());
credd_uid = task->cred->uid;

10

taskp = taskp -> parent;

printk("UID do processo: %ld.\n",credd_uid);
printk("PID do PAI: %ld.\n",(long int)taskp ->
pid);
printk("Tempo de vida [s]: %ld.\n", tmp.tv_sec tempost/1000000000);
return (0);
}
De forma a atender os dados solicitados pelo projeto, foi necessrio acessar
alguns campos das estruturas.
O primeiro campo mostrado um campo referente ao tempo em que o processo
foi inicializado no sistema, o start_time. Este campo dado em nano segundos,
contados desde o boot do sistema at a inicializao do sistema.
Em sequncia, deseja-se obter o tempo desde o boot at o momento de chamada
da funo. Para isso, foi necessrio a utilizao de duas funes. A primeira,
ktime_get_boottime(), faz com que o tempo desde o boot seja acessado num tipo
de tempo chamado de ktime, o que inicialmente no utilizvel para o objetivo final.
Com este valor obtido, a segunda funo, ktime_to_timespec(), transforma este
tempo de forma a preencher a estrutura timespec apresentada anteriormente. Nesta
estrutura encontra-se um campo para segundos e nano segundos.
Seguindo, encontramos a sequncia de ponteiros que so utilizados para que o
valor do UID do processo identificado pelo PID passado pelo argumento seja encontrado.
Este valor se encontra dentro de uma estrutura diferente, a estrutura cred, mas que possui
um campo na estrutura task_struct. Com isso, apenas necessrio apontar para o
campo cred da task_struct e ento apontar para o campo que possui o UID do
processo.
Assim como para o UID, o PPID no se encontra dentro da task_struct do
processo procurado. Entretanto, existe um campo que possui um ponteiro apontando para
a task_struct do processo pai. Assim, para que o PPID seja encontrado, necessrio
apontar para o processo pai, e ento apontar para o PID. Esta ltima ao s executada
na linha onde imprime o valor do PPID no buffer do kernel.
Por fim, os comandos de impresso so executados. Note que a converso do
tempo de incio do processo feita diretamente.
11

4.3

A implementao da System Call

Aps a definio do cdigo, deve-se implementar a system call no kernel e ento

compila-lo.
Os passos a seguir foram seguidos para que esta implementao fosse possvel,
e assim, fosse utilizada aps a compilao e instalao do novo kernel.
Ao iniciar, deve-se adicionar o cdigo da system call no diretrio /kernel nos
arquivos descompactados do kernel do Linux citados acima. Em seguida, as
configuraes dos arquivos base para o reconhecimento da nova system call adicionada.
A ordem destes comandos no altera o resultado final, mas todos eles devem ser
feitos para a obteno de sucesso na implementao.
Deve-se associar um nmero para a nova chamada de sistema. A tabela de
nmero das chamadas de sistema existentes no kernel pode ser encontrada em
arch/x86/syscalls/syscall_64.tbl e o formato para adicionar ela na lista
[nmero] [ABI] [nome] [entry_point]. O nmero deve seguir a sequncia
da tabela, o ABI deve ser preenchido com common para que a system call funcione em
diferentes ABIs, o nome da chamada de sistema, neste caso tcdso e o nome da funo
sys_tcdso, que chamar a system call adicionada.
Deve-se ento fornecer um prottipo para a system call e adicion-lo em
include/linux/syscalls.h. Este prottipo ser a declarao da system call
contida no cdigo, asmlinkage long sys_tcdso(int p);.
Por fim, edita-se o arquivo /kernel/Makefile com a extenso da system
call, tcdso.o, para que a system call seja compilada quando acontecer a compilao do
kernel.
Aps todas estas mudanas, o kernel pode ser compilado e a system call poder
ser utilizada normalmente pelo usurio.

12

CONCLUSES

Com a modernizao desenfreada do mundo atual, constantes atualizaes

devem ser necessrias em sistemas regidos sistemas computacionais. Portanto, no se
existe o espao para a criao diria de novos sistemas operacionais a fim de suprir as
necessidades de todos os consumidores.
As chamadas de sistemas analisadas durante o desenvolvimento desde trabalho
so um grande exemplo destas atualizaes de forma a modificar um sistema j existente
e operando, a fim de acrescentar e este apenas novas funes.
Embora as funes implementadas neste projeto tenham sido bastantes
simplificadas, no foram triviais na implementao. A programao neste nvel no era
familiar a nenhum dos integrantes. Houve grandes dificuldades relacionadas desde a
compilao e instalao do kernel, implementao do cdigo da system call. Outro fator
para grandes buscas fora o fato de estar programando em um ambiente diferente do
acostumado, dada a impossibilidade de utilizao das funes de user level em kernel
level.
Contudo, conclumos que o presente trabalho foi de suma importncia e de
grande incremento na vida acadmica e profissional, uma vez que possibilitou atravs de
uma experincia prtica, se adquirir um conhecimento mais aprofundado de como se
alterar um sistema operacional de forma a realizar funes impostas por condies de
projeto.

13

BIBLIOGRAFIA

[1] Chamadas de Sistema - O que so, Para que servem e Exemplos de System Call,
Programao
Progressiva.net,
[Online].
Available:
http://www.programacaoprogressiva.net/2014/09/O-que-sao-Chamadas-deSistema-para-que-servem-Exemplos-de-System-Calss.html. [Acesso em 19
Novembro 2015].
[2] R. M. JUNIOR, Sistemas Operacionais - Gerncia de processador, [Online].
Available:
http://www.facom.ufu.br/~rivalino/facom49060/%5b1%5d%20Slides%20(Lecture
%20Notes)/UNIDADE%20IV/FACOM49060%20-%20Unidade%20IV.pdf.
[Acesso em 19 Novembro 2015].
[3] Tutorial - Compilao de um novo Kernel Linux, [Online]. Available:
http://www.facom.ufu.br/~rivalino/facom49060/%5B2%5D%20Papers%20&%20
TRs/tutorial-kernel-generico.pdf. [Acesso em 19 Novembro 2015].
[4] Tutorial - Adicionando novas chamadas de sistema ao kernel Linux, [Online].
Available:
http://www.facom.ufu.br/~rivalino/facom49060/%5B2%5D%20Papers%20&%20
TRs/tutorial-syscall-linux.pdf. [Acesso em 22 Novembro 2015].
[5] A. S. TANENBAUM, Sistemas Operacionais Modernos, 3 ed., vol. I, So Paulo:
Pearson Education do Brasil Ltda., 2010.
[6] R. LOVE, Linux Kernel Development - A thorough guide to the design and
implementation of the Linux kernel, 3 ed., Crawfordsville: Pearson Education, Inc.,
2010.

14