Organização dos cabeçalhos do kernel Linux

Enquanto lia algumas chamadas do sistema, procurei "syscalls.h" para encontrar o arquivo de cabeçalho no LXR. Os resultados da pesquisa me intrigaram. Há uma dúzia de arquivos "syscalls.h" provenientes dos diretórios em "arch / _arch_name_ / include / asm". Tudo bem, são definições específicas da arquitetura ou algo mais necessário. A questão é por que temos dois cabeçalhos "syscalls.h" diferentes em ambos / include / linux e / include / asm-generic?

Além disso, quero descobrir que servem os cabeçalhos / include / linux e para que servem os cabeçalhos / include / asm-generic. Como eles se diferenciam? Qual é a lógica por trás de duas pastas de cabeçalho separadas? Como eles se relacionam?

obrigado

O software precisa ser portátil. Se você compilar suas fontes C / C ++, não precisará saber se está executando o i386 / x86_64 / arm / mips ou o que quer que seja. Os cabeçalhos são vinculados de maneira que o software seja compilado.

Todos os outros arquivos de cabeçalho existem porque foram implementados muitos padrões diferentes, existem portas do BSD e assim por diante. Muitos deles são baseados historicamente. De onde cada um vem e por que eles existem, existem muitas razões diferentes e certamente darão respostas.

E uma resposta para asm-generic: stackoverflow

Os cabeçalhos abaixo asm/genericsão usados ​​principalmente como medidas paliativas, versões portáteis em C até que uma versão específica da arquitetura seja escrita. Você também descobrirá que, em alguns casos, /usr/include/foobar.hinclui uma série de cabeçalhos de "implementação interna" e, finalmente, recorre a uma parte que vem do kernel, geralmente chamada de mesma. Exemplos são math.he (mais dependentes do Linux) syscall.h.

arch/x86/entry/ possui dois arquivos syscall especiais:

syscalls/syscall_32.tbl e aqui "64"

Syscalls são especiais porque o kernel precisa reunir ABI e API.

Em geral, os diretórios de inclusão e os outros arquivos de cabeçalho (arquivos independentes como kernel / sched / sched.h) seguem uma lógica hierárquica. Acho que make e gcc desempenham um papel.

Há um uso sistemático desses símbolos para garantir que cada "unidade" de cabeçalho seja lida apenas uma vez. ("invólucros de proteção", porque pode haver muito entrecruzamento). Aqui de include/linux/mm.h:

    #ifndef _LINUX_MM_H
    #define _LINUX_MM_H

    #include <linux/errno.h>

    #ifdef __KERNEL__

    ...  (#includes)
    ...  (ext. decl. etc., the whole mm.h)

    #endif /* __KERNEL__ */
    #endif /* _LINUX_MM_H */

Os arquivos tbl têm:

# 32-bit system call numbers and entry vectors

A lista começa com:

0    i386    restart_syscall    sys_restart_syscall       __ia32_sys_restart_syscall
1    i386    exit               sys_exit                  __ia32_sys_exit
2    i386    fork               sys_fork                  __ia32_sys_fork
3    i386    read               sys_read                  __ia32_sys_read




#
# 64-bit system call numbers and entry vectors
#
# The format is:
# <number> <abi> <name> <entry point>
#
# The __x64_sys_*() stubs are created on-the-fly for sys_*() system calls
#
# The abi is "common", "64" or "x32" for this file.

Eu vou fazer o layout mais tarde ...