Qualche idea per cui il mio codice C non può leggere da/proc?

Question

Sono stato in grado di scrivere un programma in grado di leggere qualsiasi file di testo ... tranne quelli che si trovano in/proc. Qualsiasi file che provo a leggere da/proc si presenta vuoto.

Ma ogni volta che si digita

cat /proc/cpuinfo 

sul terminale, mi sono presentato con la mia informazioni della CPU.

Posso anche vedere il file quando lo apro con un editor di testo, come gedit o leafpad.

Quindi sembra che i file proc siano effettivamente file di testo, ma il mio programma C ha difficoltà a leggerli.

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> 
#include <unistd.h> 

char* readFileString(char* loc) { 
     char *fileDat; 
     FILE * pFile; 
     long lsize; 

     pFile = fopen(loc, "r"); 

     // Grab the file size. 
     fseek(pFile, 0L, SEEK_END); 
     lsize = ftell(pFile); 
     fseek(pFile, 0L, SEEK_SET); 

     fileDat = calloc(lsize + 1, sizeof(char)); 

     fread(fileDat, 1, lsize, pFile); 

     return fileDat; 
} 

int main(void) { 
     char *cpuInfo; 

     cpuInfo = readFileString("/proc/cpuinfo"); 

     printf("%s\n", cpuInfo); 

     return 0; 
} 

Qualche idea, perché?

Answer 1

I file da /proc hanno una dimensione di 0 byte perché sono generati al volo dal kernel.

Vedi qui per maggiori informazioni sul filesystem proc:

http://tldp.org/LDP/Linux-Filesystem-Hierarchy/html/proc.html

Answer 2

Se volete conoscere la dimensione di un file, stat (2) è la strada da percorrere. Ma per quello che stai facendo, puoi allocare un buffer molto grande (la RAM è economica e questo è un programma one-shot) su cui gira() dopo averlo fopen(), o imparare su realloc (3) e usarlo in il tuo ciclo di lettura dei file. Come ha detto Ouah, i file in/proc sono speciali.

Per uso generico, e in particolare per le stringhe, calloc() è uno spreco di cicli cpu, poiché l'impostazione dello 0 ° carattere dell'area di allocazione restituita su '\ 0' è sufficiente per renderlo una stringa vuota, indipendentemente dei dati che seguono quel primo byte.

Answer 3

La maggior parte /proc/ file testuali sono destinati ad essere letto in sequenza da un anello classica come

FILE *f = fopen("/proc/cpuinfo", "r"); 
size_t sz = 0; 
char * lin = 0; 
do { 
    ssize_t lsz = getline (&lin, &sz, f); 
    if (lsz<0) break; 
    handle_line_of_size (lin, lsz); 
} while (!feof (f)); 
fclose (f); 

cerca di non lavorare su di essi. Un po 'come per le pipe.