Access inode table to list all filenames - c

Question

I would like to know the most efficient way to list the filenames on a Posix system. Doing either:
$ ls -R
Or:
$ find /
Or:
$ du /
Or 100 other variations (links abound on StackOverflow/ServerFault about various ways to do this). However, this is way too slow on the filesystem I am on, cifs -- for example, I have currently been running the ls -R for about two days (it takes about 50 hours to complete -- there are tons of files and directories on the system -- several petabytes worth).
So I am wondering if this can be done at a lower-level, hopefully in C. to list out the filenames from the inode database (example here). I don't need a recursive lookup of the entire path, but only the top-level name | filename -- and I would build out everything else manually. Is there a way to do this so that hopefully instead of taking ~50 hours to do an ls command with the billions of recursive lookups (yes, it does get cached after successive runs, but not most of it on the first run) can the inode database itself be dumped?
An an example, perhaps something like:
#filename,inode
myfile.mov,1234
myotherfile.csv,92033
But the main point here --and why I asked this question -- is speed not actually a command in order to do the above (such as $ ls -iR).

Answer 1

Here is a way to directly use getdents recursively. I will update timings of this shortly to compare it to ls and the other standard unix utils:
#define _GNU_SOURCE
#include <dirent.h>
#include <string.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/syscall.h>
#define handle_error(msg) do { perror(msg); exit(EXIT_FAILURE); } while (0)
struct linux_dirent {
unsigned long d_ino;
off_t d_off;
unsigned short d_reclen;
char d_name[];
};
void print_files(char* dir, FILE* out)
{
// open the file
int fd = open(dir, O_RDONLY | O_DIRECTORY);
if (fd == -1) handle_error("Error opening file.\n");
// grab a buffer to read the file data
#define BUF_SIZE (1024*1024*1)
char* buffer = malloc(sizeof *buffer * BUF_SIZE);
if (buffer == NULL) handle_error("Error malloc.\n");
// do the getdents syscall writing to buffer
int num_read = syscall(SYS_getdents, fd, buffer, BUF_SIZE);
if (num_read == -1) handle_error("Error getdents syscall.\n");
close(fd);
for (long buffer_position = 0; buffer_position < num_read;) {
struct linux_dirent *d = (struct linux_dirent *) (buffer + buffer_position);
char d_type = *(buffer + buffer_position + d->d_reclen - 1);
// skip on . and .. in the listing
if (d->d_name[0] == '.') {
buffer_position += d->d_reclen;
continue;
}
// path = dir + '/' + name
char path[400];
strcpy(path, dir);
strcat(path, "/");
strcat(path, d->d_name);
// recursive call, as necessary
if (d_type == DT_DIR)
print_files(path, out);
else if (d_type == DT_REG)
fprintf(out, "%s\n", path);
// advance buffer position
buffer_position += d->d_reclen;
}
free(buffer);
}
int main(int argc, char *argv[])
{
char dir[1024];
strcpy(dir, argc > 1 ? argv[1] : ".");
FILE *out = fopen("c-log.txt", "w");
fprintf(out, "-------------[ START ]---------------------\n");
print_files(dir, out);
}