Salta al contenuto principale

ldd: vedere da quali librerie dipende un eseguibile

Inviato da tuxsa il

Avvii un programma e ottieni error while loading shared libraries: libmio.so: cannot open shared object file. Il programma non parte nemmeno. Oppure devi copiare un binario su un altro server e vuoi sapere in anticipo cosa gli serve per funzionare. ldd risponde a entrambe le domande.

Cos'è

ldd (list dynamic dependencies) è un comando che elenca le librerie condivise richieste da un eseguibile o da un'altra libreria. Una libreria condivisa (file .so, shared object) è codice usato da più programmi, come la libreria C libc.so.6. Il sistema la carica quando il programma parte, invece di averla copiata dentro ogni binario.

Fa parte della libreria C di sistema (glibc), quindi è già installato su Debian, Ubuntu e derivate.

Cosa fa

Per ogni libreria da cui il programma dipende, ldd mostra il nome, il percorso del file che il sistema userebbe e l'indirizzo di memoria in cui verrebbe caricata. Se una libreria non si trova, accanto compare not found. È il primo controllo da fare quando un programma non parte per un problema di librerie.

Come si usa

$ ldd [opzioni] file...

Gli output sono quelli reali del mio test su Ubuntu 24.04 (glibc 2.39). Gli indirizzi tra parentesi cambiano a ogni esecuzione, e su un sistema con locale italiano alcuni messaggi possono essere tradotti.

Esempio 1: le librerie di un comando di sistema

$ ldd /bin/ls
    linux-vdso.so.1 (0x00007f7c3a391000)
    libselinux.so.1 => /lib/x86_64-linux-gnu/libselinux.so.1 (0x00007f7c3a329000)
    libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f7c3a000000)
    libpcre2-8.so.0 => /lib/x86_64-linux-gnu/libpcre2-8.so.0 (0x00007f7c3a28f000)
    /lib64/ld-linux-x86-64.so.2 (0x00007f7c3a393000)

Ogni riga con => dice: "il programma cerca questa libreria, il sistema la trova qui". Due righe sono speciali: linux-vdso.so.1 non è un file ma una piccola libreria fornita dal kernel, e /lib64/ld-linux-x86-64.so.2 è il loader, il programma che carica tutte le altre. Entrambe compaiono sempre.

Esempio 2: trovare le librerie mancanti

$ ./prog
./prog: error while loading shared libraries: libmio.so: cannot open shared object
file: No such file or directory

$ ldd ./prog | grep 'not found'
    libmio.so => not found

Il programma prog è un binario di prova che ho compilato apposta, collegato a una libreria libmio.so messa in una cartella non standard. Ho spezzato io il messaggio di errore su due righe per la pagina. ldd mostra subito il nome che manca. Su un caso reale si parte da lì: il pacchetto che la contiene si cerca con apt search o con apt-file, se è installato.

Esempio 3: indicare una cartella con LD_LIBRARY_PATH

$ LD_LIBRARY_PATH=$PWD/lib ldd ./prog | grep mio
    libmio.so => /tmp/ld/lib/libmio.so (0x00007fced1b48000)
$ LD_LIBRARY_PATH=$PWD/lib ./prog
42

La variabile LD_LIBRARY_PATH aggiunge cartelle alla ricerca delle librerie, solo per quel comando. ldd la rispetta, quindi si può verificare che con quel percorso la libreria viene trovata prima di avviare davvero il programma. Per una soluzione permanente, di solito si installa la libreria in una cartella standard e si aggiorna la cache con ldconfig, che sarà il tema di un prossimo articolo.

Esempio 4: file che non sono dinamici

$ ldd f.txt
    not a dynamic executable
$ echo $?
1

Se il file non è un eseguibile dinamico, ldd lo dice ed esce con codice 1. La stessa risposta la dà un binario compilato in modo statico (con gcc -static), che ha già tutto dentro e non dipende da librerie esterne: nel mio test ldd lo ha segnalato così. Per un file inesistente il messaggio è invece No such file or directory, sempre con codice 1.

Esempio 5: versioni dei simboli e simboli non risolti

$ ldd -v /bin/ls
    ...
    Version information:
    /bin/ls:
        libselinux.so.1 (LIBSELINUX_1.0) => /lib/x86_64-linux-gnu/libselinux.so.1
        libc.so.6 (GLIBC_2.28) => /lib/x86_64-linux-gnu/libc.so.6
        libc.so.6 (GLIBC_2.38) => /lib/x86_64-linux-gnu/libc.so.6

$ ldd -r ./prog | tail -1
undefined symbol: dbl    (./prog)

Con -v si vedono le versioni richieste di ciascuna libreria (utile quando un binario compilato su un sistema recente non parte su uno vecchio perché chiede GLIBC_2.38 e quella installata è più vecchia). Ho tolto parte dell'output con "...". Con -r si controllano anche le funzioni non risolte: qui dbl manca perché la libreria che la contiene non era stata trovata. Un'alternativa che non esegue nulla è readelf -d programma | grep NEEDED, che elenca solo i nomi richiesti.

Esempio 6: uso negli script

#!/bin/bash
# Controlla se gli eseguibili indicati hanno librerie condivise mancanti
[ $# -ge 1 ] || { echo "Uso: $0 file..." >&2; exit 2; }
command -v ldd >/dev/null || { echo "ldd non trovato" >&2; exit 3; }
rc=0
for f in "$@"; do
    if [ ! -f "$f" ]; then
        echo "$f: file inesistente" >&2; rc=1; continue
    fi
    out=$(ldd "$f" 2>&1)
    if echo "$out" | grep -q 'not a dynamic'; then
        echo "$f: non dinamico (statico o non eseguibile)"
    elif echo "$out" | grep -q 'not found'; then
        echo "$f: MANCANO: $(echo "$out" | awk '/not found/ {print $1}' | tr '\n' ' ')"
        rc=1
    else
        echo "$f: ok"
    fi
done
exit $rc

Lo script controlla uno o più file e per ciascuno stampa "ok", l'elenco delle librerie mancanti o la segnalazione che non è un binario dinamico. Esce con 0 se non manca nulla, 1 se c'è un problema, 2 senza argomenti e 3 se ldd non c'è. È comodo dopo un aggiornamento o prima di copiare un binario: ./manca.sh /usr/local/bin/*. Nelle mie prove, con /bin/ls, il binario con la libreria mancante, un file inesistente, un file di testo e un binario statico, ha dato i risultati attesi; con LD_LIBRARY_PATH impostato la libreria mancante risulta trovata.

Opzioni utili

  • -v: mostra anche le versioni dei simboli richiesti a ogni libreria.
  • -r: controlla anche le funzioni e i dati non risolti (undefined symbol).
  • -u: elenca le dipendenze dirette non usate. Su /bin/ls non ha stampato nulla.
  • --version e --help: versione di glibc e riepilogo delle opzioni.

Attenzione a

  • Il codice di uscita è 0 anche con librerie mancanti. Nel mio test ldd ./prog con libmio.so => not found ha restituito 0. Per usarlo in uno script bisogna cercare not found nell'output, come nell'esempio 6.
  • Non usarlo su file di cui non ti fidi. Secondo il manuale, con alcune versioni e per certi binari ldd può eseguire il programma per ricavare le dipendenze. Per un file sospetto è più sicuro readelf -d file | grep NEEDED o objdump -p file | grep NEEDED. Io non ho provato il caso pericoloso: la raccomandazione viene dalla documentazione.
  • Mostra le dipendenze dirette e indirette. L'elenco comprende le librerie di cui hanno bisogno le librerie stesse. readelf -d invece mostra solo quelle richieste dal file che gli passi.
  • Il risultato vale per quella macchina e quell'ambiente. Cambiano con LD_LIBRARY_PATH, con la cache di ldconfig e con il percorso incorporato nel binario (rpath). Un "ok" qui non garantisce che il programma parta in un container o su un altro server con le stesse librerie.
  • Dire "ok" non vuol dire che il programma funzioni. Controlla solo che le librerie si trovino; i simboli mancanti si vedono con -r, e altri problemi (configurazione, permessi) restano fuori.
  • Altre architetture. Per binari di un'altra architettura (ad esempio ARM) ldd del sistema in uso può non funzionare. Non l'ho verificato.

Riepilogo

ComandoCosa fa
ldd programmaElenca le librerie condivise richieste
ldd programma | grep 'not found'Mostra solo le librerie mancanti
ldd -v programmaAggiunge le versioni dei simboli richieste
ldd -r programmaSegnala anche i simboli non risolti
LD_LIBRARY_PATH=dir ldd programmaProva con una cartella di librerie in più
readelf -d programma | grep NEEDEDElenca i nomi richiesti senza eseguire nulla