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

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