Como forçar a ligação a libc `fcntl` mais antiga em vez de` fcntl64`?

Parece que o GLIBC 2.28 (lançado em agosto de 2018) fez uma alteração bastante agressiva no fcntl. A definição foi alterada <fcntl.h>para não ser mais uma função externa, mas #definepara fcntl64 .

O resultado é que se você compilar o código em um sistema com esta glibc - se ele usa fcntl () em tudo --o binário resultante não será executado em um sistema de antes de Agosto de 2018. Isso afeta toda uma variedade de aplicações .. .a página de manual de fcntl () mostra que é o ponto de entrada para um pequeno universo de sub-funções:

https://linux.die.net/man/2/fcntl

Seria bom se você pudesse dizer ao vinculador qual versão específica de uma função GLIBC você queria. Mas o mais próximo que encontrei foi esse truque descrito em uma resposta a outro post:

Responda a "Vinculando à versão mais antiga do símbolo em um arquivo .so"

Isso é um pouco mais complicado. fcntlé variável sem um vffcntlque leva uma va_list. Em tais situações, você não pode encaminhar uma invocação de uma função variável . :-(

Quando se tem código estável com dependências propositadamente baixas, é uma desilusão construí-lo em um Ubuntu atual ... e ter o executável se recusar a executar em outro Ubuntu lançado apenas um ano antes (quase o dia). Que recurso se tem para isso?

Que recurso se tem para isso?

O fato de o GLIBC não ter muito a #define USE_FCNTL_NOT_FCNTL64dizer diz muito. Seja certo ou errado, a maioria dos fabricantes de cadeias de ferramentas do OS + parece ter decidido que direcionar binários para versões mais antigas de seus sistemas a partir de uma mais nova não é uma alta prioridade.

O caminho de menor resistência é manter uma máquina virtual em torno da cadeia de ferramentas OS + mais antiga que cria seu projeto. Use isso para criar binários sempre que achar que o binário será executado em um sistema antigo.

Mas...

• Se você acredita que seus usos estão no subconjunto de chamadas fcntl () que não são afetadas pela alteração do tamanho do deslocamento (ou seja, você não usa bloqueios de intervalo de bytes)
• OU estão dispostos a verificar seu código nos casos de compensação para usar uma definição de estrutura compatível com versões anteriores
• E não têm medo de vodu

... então continue lendo.

O nome é diferente e fcntl é variável sem um vffcntl que leva uma va_list. Em tais situações, você não pode encaminhar uma invocação de uma função variável.

... para aplicar o truque de empacotamento mencionado , você deve passar linha por linha pela documentação da interface de fcntl (), descompactar a variável como seria e, em seguida, chamar a versão empacotada com uma nova chamada variável.

Felizmente, não é um caso tão difícil (fcntl recebe 0 ou 1 argumentos com tipos documentados). Para tentar poupar a alguém mais problemas, aqui está o código para isso. Certifique-se de passar --wrap = fcntl64 para o vinculador ( -Wl, - wrap = fcntl64 se não estiver chamando ld diretamente):

asm (".symver fcntl64, fcntl@GLIBC_2.2.5");

extern "C" int __wrap_fcntl64(int fd, int cmd, ...)
{
    int result;
    va_list va;
    va_start(va, cmd);

    switch (cmd) {
      //
      // File descriptor flags
      //
      case F_GETFD: goto takes_void;
      case F_SETFD: goto takes_int;

      // File status flags
      //
      case F_GETFL: goto takes_void;
      case F_SETFL: goto takes_int;

      // File byte range locking, not held across fork() or clone()
      //
      case F_SETLK: goto takes_flock_ptr_INCOMPATIBLE;
      case F_SETLKW: goto takes_flock_ptr_INCOMPATIBLE;
      case F_GETLK: goto takes_flock_ptr_INCOMPATIBLE;

      // File byte range locking, held across fork()/clone() -- Not POSIX
      //
      case F_OFD_SETLK: goto takes_flock_ptr_INCOMPATIBLE;
      case F_OFD_SETLKW: goto takes_flock_ptr_INCOMPATIBLE;
      case F_OFD_GETLK: goto takes_flock_ptr_INCOMPATIBLE;

      // Managing I/O availability signals
      //
      case F_GETOWN: goto takes_void;
      case F_SETOWN: goto takes_int;
      case F_GETOWN_EX: goto takes_f_owner_ex_ptr;
      case F_SETOWN_EX: goto takes_f_owner_ex_ptr;
      case F_GETSIG: goto takes_void;
      case F_SETSIG: goto takes_int;

      // Notified when process tries to open or truncate file (Linux 2.4+)
      //
      case F_SETLEASE: goto takes_int;
      case F_GETLEASE: goto takes_void;

      // File and directory change notification
      //
      case F_NOTIFY: goto takes_int;

      // Changing pipe capacity (Linux 2.6.35+)
      //
      case F_SETPIPE_SZ: goto takes_int;
      case F_GETPIPE_SZ: goto takes_void;

      // File sealing (Linux 3.17+)
      //
      case F_ADD_SEALS: goto takes_int;
      case F_GET_SEALS: goto takes_void;

      // File read/write hints (Linux 4.13+)
      //
      case F_GET_RW_HINT: goto takes_uint64_t_ptr;
      case F_SET_RW_HINT: goto takes_uint64_t_ptr;
      case F_GET_FILE_RW_HINT: goto takes_uint64_t_ptr;
      case F_SET_FILE_RW_HINT: goto takes_uint64_t_ptr;

      default:
        fprintf(stderr, "fcntl64 workaround got unknown F_XXX constant")
    }

  takes_void:
    va_end(va);
    return fcntl64(fd, cmd);

  takes_int:
    result = fcntl64(fd, cmd, va_arg(va, int));
    va_end(va);
    return result;

  takes_flock_ptr_INCOMPATIBLE:
    //
    // !!! This is the breaking case: the size of the flock
    // structure changed to accommodate larger files.  If you
    // need this, you'll have to define a compatibility struct
    // with the older glibc and make your own entry point using it,
    // then call fcntl64() with it directly (bear in mind that has
    // been remapped to the old fcntl())
    // 
    fprintf(stderr, "fcntl64 hack can't use glibc flock directly");
    exit(1);

  takes_f_owner_ex_ptr:
    result = fcntl64(fd, cmd, va_arg(va, struct f_owner_ex*));
    va_end(va);
    return result;

  takes_uint64_t_ptr:
    result = fcntl64(fd, cmd, va_arg(va, uint64_t*));
    va_end(va);
    return result;
}

Observe que, dependendo da versão em que você está realmente construindo, talvez seja necessário #ifdef algumas dessas seções de sinalizador, se não estiverem disponíveis.

Isso afeta diversas aplicações ... a página de manual do fcntl () mostra que é o ponto de entrada para um pequeno universo de sub-funções

... e provavelmente deve ser uma lição para as pessoas: evite criar essas funções de "pia da cozinha" por meio de abusos variados.

Como forçar a ligação à libc antiga em fcntlvez de fcntl64?

Compile em uma versão mais antiga do libc. Período.

Como o glibc não é compatível com versões anteriores , é apenas compatível com versões anteriores :

A GNU C Library foi projetada para ser uma biblioteca ISO C compatível com versões anteriores , portátil e de alto desempenho. O objetivo é seguir todos os padrões relevantes, incluindo ISO C11, POSIX.1-2008 e IEEE 754-2008.

Sem garantias de compatibilidade com a frente, você não sabe o que mais não funcionará corretamente .