Qual è il modo migliore per leggere dalle interfacce Linux/proc utilizzando il codice spazio utente C?

Question

Secondo man 5 proc, si può usare il filesystem /proc per accedere alle seguenti informazioni su Linux:

/proc/[pid]/maps 
      A file containing the currently mapped memory regions and their access 
      permissions. 

      The format is: 

      address   perms offset dev inode pathname 
      08048000-08056000 r-xp 00000000 03:0c 64593 /usr/sbin/gpm 
      08056000-08058000 rw-p 0000d000 03:0c 64593 /usr/sbin/gpm 
      08058000-0805b000 rwxp 00000000 00:00 0 
      40000000-40013000 r-xp 00000000 03:0c 4165 /lib/ld-2.2.4.so 
      40013000-40015000 rw-p 00012000 03:0c 4165 /lib/ld-2.2.4.so 
      4001f000-40135000 r-xp 00000000 03:0c 45494 /lib/libc-2.2.4.so 
      40135000-4013e000 rw-p 00115000 03:0c 45494 /lib/libc-2.2.4.so 
      4013e000-40142000 rw-p 00000000 00:00 0 
      bffff000-c0000000 rwxp 00000000 00:00 0 

      where "address" is the address space in the process that it occupies, 
      "perms" is a set of permissions: 

       r = read 
       w = write 
       x = execute 
       s = shared 
       p = private (copy on write) 

      "offset" is the offset into the file/whatever, "dev" is the device 
      (major:minor), and "inode" is the inode on that device. 0 indicates 
      that no inode is associated with the memory region, as the case would 
      be with BSS (uninitialized data). 

      Under Linux 2.0 there is no field giving pathname. 

Non voglio davvero essere la scrittura di codice di testo analisi in C; Preferisco semplicemente effettuare chiamate al sistema operativo e leggere le informazioni direttamente nelle strutture. Ho cercato in /usr/include/linux per verificare se esistesse una struttura evidente con le API, ma non ho visto nulla.

Così, due domanda parte:

1. Può questo essere considerata una "cattiva idea"? Cioè, i programmi utente dovrebbero solo mordere il proiettile e leggere il testo da /proc nel caso in cui le interfacce del kernel cambino? In tal caso, esiste una "best practice" accettata per la lettura da /proc utilizzando C? (fscanf()? Le espressioni regolari?)
2. Come potrei fare per trovare la documentazione per le interfacce del kernel (supponendo che esistano) che mi consentirebbe di leggere direttamente questi dati? (La sorgente del kernel è di per sé il posto migliore da cui partire? Se sì, dove devo cercare nel sorgente del kernel?) Punti bonus se sai quale interfaccia può fornire i dati in modo specifico. =)

Answer 1

Penso che per uno script perl o shell sia perfettamente corretto leggere e analizzare/proc/data. In un programma C, se è necessaria la robustezza, utilizzerei un'interfaccia kernel (probabilmente un sysctl).

scopre che il procps-bundled pmap implementation analizza /proc/PID/maps file riga per riga come segue (vedi one_proc() funzione):

sscanf(mapbuf,"%"KLF"x-%"KLF"x %31s %Lx %x:%x %Lu", &start, &end, flags, &file_offset, &dev_major, &dev_minor, &inode); 

EDIT: la versione originale della mia risposta ha mostrato un modo per analizzare i dati sulla memoria condivisa solo segmenti, non tutti i segmenti di memoria mappati come l'OP desiderato.

Credo che ipcs -m fornirà gli stessi dati per più processi. Quindi la risposta alla tua seconda domanda è che si dovrebbe leggere il codice ipcs: (es BSD version, Linux version):

Answer 2

lettura sequenziale testuali pseudo-files come /proc/self/maps è il modo canonico, su Linux, per ottenere che le informazioni (e non ci non è un modo semplice per ottenerlo altrimenti, è il modo in cui il kernel lo sta dando.).

È possibile utilizzare qualche libreria (come libproc) che lo fa per voi. Ma alla fine la tua applicazione analizzerà (forse attraverso alcune librerie) i file sotto /proc. Non sono sicuro che tu abbia ragione di evitarlo.

Basta provare a eseguire un comando come ps o top con /proc di essere smontato. Probabilmente non funzionerà più.

Answer 3

libproc fornisce un modo conveniente per accedere al contenuto in /proc.