Em que biblioteca compartilhada é read ()?

Question

Eu quero saber onde o sistema chama read() é. Qual biblioteca compartilhada está vinculada quando eu ligo read ()?

    

Answer 1

A função read() é implementada em uma biblioteca compartilhada (libc), que disponibiliza as funções envolvidas no espaço do usuário. Isso expõe o "acesso" a essas funções que residem fisicamente no kernel.

Você pode se convencer disso dando uma olhada neste diagrama e observando que existem duas ferramentas para rastrear esses tipos de chamadas (sistema vs. biblioteca compartilhada).

OBSERVAÇÃO: No diagrama a seguir, eles são chamados de strace e ltrace . Veja abaixo exemplos de funções chamadas por essas ferramentas, nas respectivas saídas dessas duas ferramentas você pode ver quais funções estão sendo chamadas por um executável, como ls .

Exemplo

saída strace:

$ strace -c ls
file1  file2
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
100.00    0.000017           1        18           mprotect
  0.00    0.000000           0         8           read
  0.00    0.000000           0         1           write
  0.00    0.000000           0        10           open
  0.00    0.000000           0        13           close
  0.00    0.000000           0         1           stat
  0.00    0.000000           0        11           fstat
  0.00    0.000000           0        27           mmap
  0.00    0.000000           0         2           munmap
  0.00    0.000000           0         3           brk
  0.00    0.000000           0         2           rt_sigaction
  0.00    0.000000           0         1           rt_sigprocmask
  0.00    0.000000           0         2           ioctl
  0.00    0.000000           0         1         1 access
  0.00    0.000000           0         1           execve
  0.00    0.000000           0         2           getdents
  0.00    0.000000           0         1           getrlimit
  0.00    0.000000           0         2           statfs
  0.00    0.000000           0         1           arch_prctl
  0.00    0.000000           0         1           set_tid_address
  0.00    0.000000           0         1           openat
  0.00    0.000000           0         1           set_robust_list
------ ----------- ----------- --------- --------- ----------------
100.00    0.000017                   110         1 total

saída do ltrace:

$ ltrace -c ls
file1  file2
% time     seconds  usecs/call     calls      function
------ ----------- ----------- --------- --------------------
 11.42    0.001012          84        12 __ctype_get_mb_cur_max
 11.24    0.000996         124         8 getenv
 10.54    0.000934          93        10 __errno_location
  9.96    0.000883          98         9 malloc
  6.03    0.000534         106         5 memcpy
  5.99    0.000531         106         5 readdir
  4.60    0.000408         408         1 setlocale
  3.77    0.000334          83         4 free
  3.70    0.000328          82         4 __freading
  3.26    0.000289          96         3 __overflow
  2.95    0.000261          87         3 strlen
  2.66    0.000236         118         2 fclose
  2.46    0.000218         109         2 fwrite_unlocked
  2.05    0.000182         182         1 strrchr
  1.90    0.000168          84         2 __fpending
  1.87    0.000166          83         2 fflush
  1.87    0.000166          83         2 fileno
  1.52    0.000135         135         1 isatty
  1.43    0.000127         127         1 getopt_long
  1.41    0.000125         125         1 ioctl
  1.35    0.000120         120         1 textdomain
  1.35    0.000120         120         1 bindtextdomain
  1.29    0.000114         114         1 opendir
  1.22    0.000108         108         1 closedir
  1.21    0.000107         107         1 __cxa_atexit
  1.05    0.000093          93         1 strcoll
  0.95    0.000084          84         1 realloc
  0.94    0.000083          83         1 _setjmp
------ ----------- ----------- --------- --------------------
100.00    0.008862                    86 total

Então onde está a leitura ()?

Se você perceber na saída read está listado como uma função na saída strace , não na saída ltrace . Isso é porque faz parte da interface de chamada do sistema.

    

Answer 2

As chamadas brutas do sistema, como read(2) , são definidas na biblioteca C (geralmente glibc no Linux). Mas o que a definição na biblioteca faz é apenas coletar argumentos, configurá-los para a maneira especial em que eles são passados para o kernel e usar um mecanismo especial para pedir ao kernel que faça o trabalho. Ele coleta os resultados (incluindo possíveis indicações de erro) e os converte no valor retornado pela chamada.

Em geral, se você quiser saber sobre a função foo , man foo deve responder à sua pergunta. O cabeçalho da página de manual deve dizer, por exemplo foo(2) ou foo(3) ou similar. O número 2 significa chamada de sistema, 3 significa função de biblioteca. No caso raro de outro número, tente man 2 foo e man 3 foo .

As chamadas do sistema são definidas na biblioteca C (e o trabalho é feito pelo kernel); funções de biblioteca são definidas em bibliotecas, a página de manual deve informar quais bibliotecas usar (citando alguns -l<something> flags para link, então está na biblioteca <something> ).

    

Answer 3

Chamadas de sistema são implementadas no kernel - é por isso que são chamadas de "sistema" - mas o mecanismo para invocar uma chamada de sistema no kernel é específico da plataforma e pode envolver instruções de montagem especiais Assim, os programas normalmente não fazem isso diretamente.

A biblioteca C do sistema (libc) fornece funções de invólucro para chamadas do sistema. Estas são funções usuais do espaço do usuário que você pode chamar como qualquer outra função C, e elas executam a mágica necessária para delegar à chamada do sistema real no kernel.