API do kernel 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:
#incluirfd = 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:
#incluirchar *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.