lunaix-os/kernel/fs/iso9660/directory.c

   1 #include <lunaix/dirent.h>
   2 #include <lunaix/fs.h>
   3 #include <lunaix/fs/iso9660.h>
   4 #include <lunaix/mm/cake.h>
   5 #include <lunaix/mm/valloc.h>
   6 #include <lunaix/spike.h>
   7
   8 #include <klibc/string.h>
   9
  10 extern struct cake_pile* drec_cache_pile;
  11
  12 void
  13 iso9660_fill_drecache(struct iso_drecache* cache,
  14                       struct iso_drecord* drec,
  15                       u32_t drec_len)
  16 {
  17     *cache = (struct iso_drecache){ .data_size = drec->data_size.le,
  18                                     .extent_addr = drec->extent_addr.le,
  19                                     .flags = drec->flags,
  20                                     .fu_size = drec->fu_sz ? drec->fu_sz : 1,
  21                                     .gap_size = drec->gap_sz,
  22                                     .xattr_len = drec->xattr_len };
  23     u32_t padding = ((drec->name.len + sizeof(drec->name)) % 2) != 0;
  24     u32_t su_offset = drec->name.len + sizeof(struct iso_drecord) + padding;
  25     int su_len = drec_len - su_offset - 2, i = 0;
  26
  27     while (i < su_len) {
  28         struct isosu_base* su_entry =
  29           (struct isosu_base*)((void*)drec + su_offset + i);
  30         switch (su_entry->signature) {
  31             case ISORR_NM:
  32                 i += isorr_parse_nm(cache, (void*)su_entry);
  33                 break;
  34             case ISORR_PX:
  35                 i += isorr_parse_px(cache, (void*)su_entry);
  36                 break;
  37             case ISORR_TF:
  38                 i += isorr_parse_tf(cache, (void*)su_entry);
  39                 break;
  40             case ISOSU_ST:
  41                 goto done;
  42             default:
  43                 i += su_entry->length;
  44                 break;
  45         }
  46     }
  47
  48 done:
  49     if (!cache->name.len) {
  50         // Load ISO9660 file id if no NM found.
  51         u32_t l = drec->name.len;
  52         while (l < (u32_t)-1 && drec->name.content[l--] != ';')
  53             ;
  54         l = (l + 1) ? l : drec->name.len;
  55         l = MIN(l, ISO9660_IDLEN - 1);
  56
  57         strncpy(cache->name_val, drec->name.content, l);
  58         cache->name = HSTR(cache->name_val, l);
  59         hstr_rehash(&cache->name, HSTR_FULL_HASH);
  60     }
  61 }
  62
  63 int
  64 iso9660_setup_dnode(struct v_dnode* dnode, struct v_inode* inode)
  65 {
  66     if (!(inode->itype & VFS_IFDIR)) {
  67         vfs_assign_inode(dnode, inode);
  68         return 0;
  69     }
  70
  71     int errno = 0;
  72     struct device* dev = dnode->super_block->dev;
  73     struct iso_inode* isoino = inode->data;
  74     struct llist_header* lead = valloc(sizeof(*lead));
  75     void* records = valloc(ISO9660_BLKSZ);
  76     u32_t current_pos = -ISO9660_BLKSZ, max_pos = inode->fsize,
  77           blk = inode->lb_addr * ISO9660_BLKSZ, blk_offset = (u32_t)-1;
  78
  79     llist_init_head(lead);
  80
  81     // As per 6.8.1, Directory structure shall NOT recorded in interleave mode.
  82     do {
  83         if (blk_offset >= ISO9660_BLKSZ - sizeof(struct iso_drecord)) {
  84             current_pos += ISO9660_BLKSZ;
  85             errno = dev->read(dev, records, blk + current_pos, ISO9660_BLKSZ);
  86             if (errno < 0) {
  87                 errno = EIO;
  88                 goto done;
  89             }
  90             blk_offset = 0;
  91         }
  92
  93         struct iso_drecord* drec;
  94         struct iso_var_mdu* mdu = (struct iso_var_mdu*)(records + blk_offset);
  95
  96         if (!(drec = iso9660_get_drecord(mdu))) {
  97             break;
  98         }
  99
 100         // ignore the '.', '..' as we have built-in support
 101         if (drec->name.len == 1) {
 102             goto cont;
 103         }
 104
 105         struct iso_drecache* cache = cake_grab(drec_cache_pile);
 106
 107         iso9660_fill_drecache(cache, drec, mdu->len);
 108         llist_append(lead, &cache->caches);
 109     cont:
 110         blk_offset += mdu->len;
 111     } while (current_pos + blk_offset < max_pos);
 112
 113     dnode->data = lead;
 114     isoino->drecaches = lead;
 115
 116     vfs_assign_inode(dnode, inode);
 117
 118     errno = 0;
 119
 120 done:
 121     vfree(records);
 122     return errno;
 123 }
 124
 125 int
 126 iso9660_dir_lookup(struct v_inode* this, struct v_dnode* dnode)
 127 {
 128     struct iso_inode* isoino = this->data;
 129     struct llist_header* lead = isoino->drecaches;
 130     struct iso_drecache *pos, *n;
 131
 132     llist_for_each(pos, n, lead, caches)
 133     {
 134         if (HSTR_EQ(&dnode->name, &pos->name)) {
 135             goto found;
 136         }
 137     }
 138
 139     return ENOENT;
 140 found:
 141     struct v_inode* inode = vfs_i_find(dnode->super_block, pos->extent_addr);
 142
 143     if (!inode) {
 144         inode = vfs_i_alloc(dnode->super_block);
 145         iso9660_fill_inode(inode, pos, pos->extent_addr);
 146         vfs_i_addhash(inode);
 147     }
 148
 149     return iso9660_setup_dnode(dnode, inode);
 150 }
 151
 152 static int
 153 __get_dtype(struct iso_drecache* pos)
 154 {
 155     if ((pos->flags & ISO_FDIR)) {
 156         return DT_DIR;
 157     } else {
 158         return DT_FILE;
 159     }
 160 }
 161
 162 int
 163 iso9660_readdir(struct v_file* file, struct dir_context* dctx)
 164 {
 165     struct llist_header* lead = file->dnode->data;
 166     struct iso_drecache *pos, *n;
 167     u32_t counter = dctx->index - 1;
 168
 169     llist_for_each(pos, n, lead, caches)
 170     {
 171         if (counter == (u32_t)-1 && !(pos->flags & ISO_FHIDDEN)) {
 172             dctx->read_complete_callback(
 173               dctx, pos->name_val, pos->name.len, __get_dtype(pos));
 174             return 1;
 175         }
 176         counter--;
 177     }
 178     return 0;
 179 }