dirscan.c

   1 /*
   2  * dirscan.c - iterator for traversing the directory tree.
   3  *
   4  * We never have to hold more than a few inodes in memory.  Let
   5  * the OS cache em.
   6  *
   7  * TODO: add cycle detection
   8  */
   9
  10 #include <stdlib.h>
  11 #include "dirscan.h"
  12
  13 static dirscan_entry_t *_create_entry(omfs_inode_t *inode,
  14                 int level, int hindex, u64 parent, u64 block)
  15 {
  16         dirscan_entry_t *entry = malloc(sizeof(dirscan_entry_t));
  17         entry->inode = inode;
  18         entry->level = level;
  19         entry->hindex = hindex;
  20         entry->parent = parent;
  21         entry->block = block;
  22
  23         return entry;
  24 }
  25
  26 static void dirscan_release_entry(dirscan_entry_t *entry)
  27 {
  28         omfs_release_inode(entry->inode);
  29         free(entry);
  30 }
  31
  32
  33 int traverse (dirscan_t *d, dirscan_entry_t *entry)
  34 {
  35         omfs_inode_t *ino, *tmp;
  36         dirscan_entry_t *enew;
  37
  38         int res = d->visit(d, entry, d->user_data);
  39
  40         ino = entry->inode;
  41
  42         /* push next sibling all then all children */
  43         if (ino->sibling != ~0)
  44         {
  45                 tmp = omfs_get_inode(d->omfs_info, swap_be64(ino->sibling));
  46                 if (!tmp)
  47                 {
  48                         res = -1;
  49                         goto out;
  50                 }
  51
  52                 enew = _create_entry(tmp, entry->level, entry->hindex,
  53                                 entry->parent, swap_be64(ino->sibling));
  54                 traverse(d, enew);
  55         }
  56         if (ino->type == OMFS_DIR)
  57         {
  58                 int i;
  59                 u64 *ptr = (u64*) ((u8*) ino + OMFS_DIR_START);
  60
  61                 int num_entries = (swap_be32(ino->head.body_size) +
  62                         sizeof(omfs_header_t) - OMFS_DIR_START) / 8;
  63
  64                 for (i=0; i<num_entries; i++, ptr++)
  65                 {
  66                         u64 inum = swap_be64(*ptr);
  67                         if (inum != ~0)
  68                         {
  69                                 tmp = omfs_get_inode(d->omfs_info, inum);
  70                                 if (!tmp) {
  71                                         res = -1;
  72                                         goto out;
  73                                 }
  74                                 enew = _create_entry(tmp, entry->level+1, i,
  75                                         entry->block, inum);
  76                                 traverse(d, enew);
  77                         }
  78                 }
  79         }
  80 out:
  81         dirscan_release_entry(entry);
  82         return res;
  83 }
  84
  85 static void dirscan_end(dirscan_t *d)
  86 {
  87         free(d);
  88 }
  89
  90 int dirscan_begin(omfs_info_t *info, int (*visit)(dirscan_t *,
  91                         dirscan_entry_t*, void*), void *user_data)
  92 {
  93         omfs_inode_t *root_ino;
  94         int res;
  95
  96         dirscan_t *d = calloc(sizeof(dirscan_t), 1);
  97         if (!d)
  98                 goto error;
  99
 100         d->omfs_info = info;
 101         d->visit = visit;
 102         d->user_data = user_data;
 103
 104         root_ino = omfs_get_inode(info, swap_be64(info->root->root_dir));
 105         if (!root_ino)
 106                 goto error;
 107         res = traverse(d, _create_entry(root_ino, 0, 0, ~0,
 108                         swap_be64(info->root->root_dir)));
 109         dirscan_end(d);
 110
 111         return 0;
 112
 113 error:
 114         if (d) free(d);
 115         return -1;
 116 }
 117