API do kernel Linux

Passaremos pela interface de programação do aplicativo Linux, a API. Linux Kernel fornece as chamadas do sistema que podem ser usadas para realizar a tarefa através do kernel. Vamos discutir as poucas chamadas de sistema amplamente usadas do Linux.

Descrição:

O Linux Kernel fornece o conjunto ou lista de funções que podem ser usadas pelos programas espaciais do usuário para utilizar os serviços do kernel Linux.

O diagrama de blocos se parece com o seguinte:

Algumas das poucas chamadas de sistema amplamente utilizadas são abertas, fechadas, lidas e escritas. Essas são chamadas básicas de sistema fornecidas pelo kernel Linux. Cada tarefa é realizada através do arquivo no Linux. Portanto, as operações básicas em qualquer arquivo podem ser feitas por meio de abertura, fechamento, leitura e gravação.

Vamos dar um exemplo real onde queremos imprimir o "Hello World" no console serial. Para realizar esta tarefa através de chamadas do sistema, precisamos abrir o arquivo de dispositivo para console em /dev. Depois de localizarmos o arquivo de dispositivo para console ou UART, podemos usar a chamada do sistema aberto para abrir o dispositivo.

Aqui está a sintaxe da chamada do sistema aberto:

int aberto (const char *pathname, int sinalizadores);
int open (const char *pathname, int sinalizadores, mode_t mode);

A partir desta sintaxe, o primeiro argumento é o caminho do arquivo que queremos abrir. No nosso caso, é o arquivo de dispositivo que localizamos como um dispositivo de console. No próximo argumento, as bandeiras fornecem ao usuário alguma flexibilidade para jogar com o arquivo. Poucos exemplos das bandeiras são O_creat, O_APPEND, etc. Essas bandeiras têm significados e propósitos específicos e a discussão está fora do escopo desta discussão. Para mais detalhes sobre as bandeiras e parâmetros, consulte as páginas do Kernel Man.

Depois que o arquivo estiver aberto com sucesso, precisamos usar a chamada do sistema de gravação para enviar o "Hello World" para o dispositivo de console. O protótipo da chamada do sistema de gravação é a seguinte:

ssize_t write (int fd, const void *buf, size_t count);

O primeiro parâmetro da chamada do sistema de gravação é o FD, que é o descritor de arquivo. O "FD" é dado a nós pela chamada do sistema aberto. Depois de abrir o arquivo com sucesso, devemos obter o descritor de arquivo. Este FD é usado ainda mais para escrever os dados.

O segundo parâmetro é o endereço do buffer para os dados a serem enviados para o dispositivo de console. No nosso caso, os dados do teste são "Hello World".

O último parâmetro é o número total de bytes que o usuário deseja escrever no dispositivo de console. No nosso caso, o número de bytes é o tamanho de "Hello World". Podemos usar o operador sizeof ou a função strlen para obter o número de bytes. Devemos ter cuidado ao usar o strlen. Esta função ignora o caractere do terminador de string como "\ 0". Então, enquanto lê a corda, temos que garantir que o personagem nulo seja tratado corretamente. Caso contrário, acabaremos com a falha de segmentação.

Agora, vamos implementar a parte do código deste exemplo. Primeiro, precisamos localizar o console serial ou o dispositivo UART. Na máquina, o que usamos tem o dispositivo TTY serial AS/dev/pts/0. Então, como discutido, primeiro precisamos abrir este arquivo. Também devemos incluir o arquivo mais difícil que fornece a declaração de chamada de sistema aberto.

Nosso código para abrir o arquivo de dispositivo se parece com o seguinte:

#incluir
fd = aberto ("/dev/pts/0", o_wronly);

Em seguida, quando queremos ligar para a chamada do sistema de gravação, usamos o FD fornecido pelo aberto. Nossa chamada para escrever a função parece o seguinte:

#incluir
char *dados = "Hello World";
Write (FD, Data, Strlen (Data) +1);

O snippet de código anterior escreve o "Hello World" para o console serial que localizamos e queremos escrever.

Vamos montar todas as peças:

#incluir
#incluir
#incluir
#incluir
#incluir
int main ()

int fd; int rc;
char *dados = "Hello World";
fd = aberto ("/dev/pts/0", o_wronly);
if (fd<0)

printf (“Arquivo de abertura de erro:%d”, fd);
saída (-1);

rc = write (fd, dados, strlen (dados) +1);
if (rc<0)

printf (“Erro de gravação do arquivo:%d”, rc);
saída (-1);

fechar (FD); // operação de arquivo está concluída, feche o arquivo.
retornar 0;

A compilação do programa anterior é a mesma que compilar os outros programas C, como os seguintes:

gcc test_write.C -o test_write.

O test_write.C é o nome do arquivo para o nosso código C.

Após a compilação, recebemos o executável com o nome Test_write.

Consulte o seguinte instantâneo:

Depois de executar o binário compilado e gerado, temos a seguinte saída.

A saída do nosso programa é destacada em letras em negrito. A seguir, é apresentado o instantâneo para referência:

Até agora, vimos um exemplo em que usamos a API Linux para exibir a sequência de teste no console. Este é o exemplo simples. Existem muitas outras ofertas que são fornecidas pela chamada do sistema. Poucas chamadas do sistema fornecidas pelo Linux são as seguintes:

• ler: Lendo do arquivo.
• escrever: Escrevendo para o arquivo.
• abrir: Abrindo o arquivo.
• fechar: Fechando o arquivo.
• enquete: Pessão do dispositivo para a mudança no estado.
• LSEEK: Buscando em um determinado deslocamento no arquivo.
• Mmap: Mapeando a memória virtual para a memória física.
• Brk: Altere o tamanho do segmento.
• ioctl: Dispositivos de controle.
• acesso: Acesso para obter as permissões de arquivo.
• cano: Refere -se à criação de tubos.

e muitos mais.

Esta é a enorme lista de funções fornecidas pelo Linux Kernel. Nós vimos e discutimos muito poucos. Consulte a fonte do kernel para obter a lista completa de chamadas do sistema fornecidas pelo kernel.

Conclusão

Discutimos sobre as chamadas do sistema, que é uma maneira de pedir ao kernel que execute as tarefas para os programas espaciais do usuário. Sem a chamada do sistema, não será possível para os programas espaciais do usuário fazer a tarefa realizada pelo kernel. Tomamos uma tarefa simples ou exemplo de escrever os dados do teste, "Hello World", para o dispositivo serial. Empregamos as APIs abertas, escritas e próximas do kernel para concluir a tarefa em mãos. Uma coisa mais importante é verificar o valor do retorno da chamada do sistema. O kernel fornece valores de retorno adequados para explicar o motivo em caso de falha da função. O usuário pode ter a ideia do motivo de falha, vendo os valores de retorno da chamada do sistema. Os valores de retorno têm algum significado específico e são bem capturados na documentação do kernel.