fs/tfs/dir.c

   1 #include <stdio.h>
   2 #include <string.h>
   3 #include <malloc.h>
   4 #include <err.h>
   5 #include <fs.h>
   6 #include <tfs.h>
   7 #include <cache.h>
   8 #include <dirent.h>
   9
  10 /*
  11  * NOTE! unlike strncmp, ext2_match_entry returns 1 for success, 0 for failure.
  12  *
  13  * len <= EXT2_NAME_LEN and de != NULL are guaranteed by caller.
  14  */
  15 static inline int tfs_match_entry (const char * const name,
  16                                    struct tfs_dir_entry * de)
  17 {
  18         if (!de->d_inode)
  19                 return 0;
  20         if (strlen(name) != strlen(de->d_name) && strlen(name) != TFS_NAME_LEN)
  21                 return 0;
  22         return !strncmp(name, de->d_name, strlen(name));
  23 }
  24
  25 /*
  26  * Returns:
  27  *      NULL, entry not found
  28  *      ERROR, errors happend.
  29  *      cs,   entry found
  30  */
  31 struct cache_struct * tfs_find_entry(struct inode *inode, const char *dname, struct tfs_dir_entry **res)
  32 {
  33         uint32_t block;
  34         int index = 0;
  35         struct tfs_dir_entry *de;
  36         struct cache_struct *cs;
  37         struct tfs_sb_info *sbi = TFS_SBI(inode->i_fs);
  38
  39         block = inode->i_data[index++];
  40         if (!block)
  41                 return NULL;
  42         cs = get_cache_block(inode->i_fs, block);
  43         if (!cs)
  44                 return ERR_PTR(-EIO);
  45         de = (struct tfs_dir_entry *)cs->data;
  46
  47         while(1) {
  48                 if ((char *)de >= (char *)cs->data + sbi->s_block_size) {
  49                         if ((block = inode->i_data[index++]) < sbi->s_data_area)
  50                                 return NULL;
  51                         cs = get_cache_block(inode->i_fs, block);
  52                         if (!cs)
  53                                 return ERR_PTR(-EIO);
  54                         de = (struct tfs_dir_entry *)cs->data;
  55                 }
  56                 if (de->d_inode == 0) {
  57                         de++;
  58                         continue;
  59                 }
  60                 if (tfs_match_entry(dname, de)) {
  61                         *res = de;
  62                         return cs;
  63                 }
  64
  65                 de++;
  66         }
  67
  68         return NULL;
  69 }
  70
  71 int tfs_add_entry(struct inode *dir, const char *name, int inr, int * dirty)
  72 {
  73         uint32_t block;
  74         int index = 0;
  75         struct cache_struct *cs;
  76         struct tfs_dir_entry *de;
  77         struct tfs_sb_info *sbi = TFS_SBI(dir->i_fs);
  78
  79         if (strlen(name) > TFS_NAME_LEN)
  80                 return -ENAMETOOLONG;
  81
  82         if (!(block = dir->i_data[index++]))
  83                 goto alloc_new_block;
  84         cs = get_cache_block(dir->i_fs, block);
  85         if (!cs)
  86                 return -EIO;
  87         de = (struct tfs_dir_entry *)cs->data;
  88         while (1) {
  89                 if ((void *)de >= cs->data + sbi->s_block_size) {
  90                         if (!(block = dir->i_data[index++]))
  91                                 break;
  92                         cs = get_cache_block(dir->i_fs, block);
  93                         if (!cs)
  94                                 return -EIO;
  95                         de = (struct tfs_dir_entry *)cs->data;
  96                 }
  97                 if (!de->d_inode)
  98                         break;
  99                 de++;
 100         }
 101
 102         *dirty = 0;
 103
 104 alloc_new_block:
 105         /* allocate a new block to hold the new entry */
 106         if (!block) {
 107                 block = tfs_alloc_block(sbi, sbi->s_data_area);
 108                 if (block < 0)
 109                         return -ENOSPC;
 110                 if (index > TFS_N_BLOCKS)
 111                         return -EFBIG;
 112
 113                 dir->i_data[index - 1] = block;
 114                 cs = get_cache_block(dir->i_fs, block);
 115                 if (!cs)
 116                         return -EIO;
 117                 de = (struct tfs_dir_entry *)cs->data;
 118                 memset(cs->data, 0, sbi->s_block_size);
 119         }
 120
 121         /* Add a new entry at last */
 122         dir->i_size += sizeof(struct tfs_dir_entry);
 123         /* tell the caller to update this inode */
 124         *dirty = 1;
 125
 126         memset(de, 0, sizeof(*de));
 127         de->d_inode = inr;
 128         memcpy(de->d_name, name, strlen(name));
 129
 130         /* write the entry back to disk */
 131         if (tfs_bwrite(sbi, block, cs->data))
 132                 return -EIO;
 133
 134         return 0;
 135 }
 136
 137
 138 int tfs_mkdir(struct inode *parent_dir, const char *dname)
 139 {
 140         struct inode *dir;
 141         int dirty;
 142         int err = 0;
 143
 144         dir = tfs_mknod(parent_dir, dname, TFS_DIR);
 145         if (IS_ERR(dir)) {
 146                 free_inode(parent_dir);
 147                 return PTR_ERR(dir);
 148         }
 149
 150         err = tfs_add_entry(dir, ".", dir->i_ino, &dirty);
 151         if (err)
 152                 goto out;
 153
 154         err = tfs_add_entry(dir, "..", parent_dir->i_ino, &dirty);
 155         if (err < 0)
 156                 goto out;
 157
 158         if (dirty)
 159                 err = tfs_iwrite(dir);
 160 out:
 161         free_inode(dir);
 162         free_inode(parent_dir);
 163
 164         return err;
 165 }
 166
 167 /*
 168  * Check if the dir is empty or not.
 169  */
 170 static int is_empty_dir(struct inode *dir)
 171 {
 172         if (dir->i_size > 2 * sizeof(struct tfs_dir_entry))
 173                 return 0;
 174         else if (dir->i_size < 2 * sizeof(struct tfs_dir_entry))
 175                 return -1;
 176         else
 177                 return 1;
 178 }
 179
 180
 181 int tfs_rmdir(struct inode *dir, const char *dname)
 182 {
 183         struct inode *inode;
 184         struct cache_struct *cs;
 185         struct tfs_dir_entry *de;
 186         struct tfs_sb_info *sbi = TFS_SBI(dir->i_fs);
 187         int err;
 188
 189
 190         cs = tfs_find_entry(dir, dname, &de);
 191         if (IS_ERR_OR_NULL(cs)) {
 192                 err = cs ? PTR_ERR(cs) : -ENOENT;
 193                 goto out;
 194         }
 195
 196         inode = tfs_iget_by_inr(dir->i_fs, de->d_inode);
 197         if (IS_ERR(inode)) {
 198                 err = PTR_ERR(inode);
 199                 goto out;
 200         }
 201
 202         if (inode->i_mode != TFS_DIR) {
 203                 err = -ENOTDIR;
 204                 goto error;
 205         }
 206
 207         err = is_empty_dir(inode);
 208         if (err == 0) {
 209                 err = -ENOTEMPTY;
 210                 goto error;
 211         } else if (err == -1) {
 212                 printk("%s: path correupted: the size is less than two direntry!\n", dname);
 213                 err = -EINVAL;
 214                 goto error;
 215         }
 216
 217         dir->i_size -= sizeof(struct tfs_dir_entry);
 218         err = tfs_iwrite(dir);
 219         if (err)
 220                 goto error;
 221         de->d_inode = 0;
 222         err = tfs_bwrite(sbi, cs->block, cs->data);
 223         if (err)
 224                 goto error;
 225         err = tfs_release_inode(sbi, inode);
 226         goto out;
 227
 228 error:
 229         free_inode(inode);
 230 out:
 231         return err;
 232 }
 233
 234
 235 int tfs_unlink(struct inode *dir, const char *dname)
 236 {
 237         struct inode *inode;
 238         struct cache_struct *cs;
 239         struct tfs_dir_entry *de;
 240         struct tfs_sb_info *sbi = TFS_SBI(dir->i_fs);
 241         int err;
 242
 243         cs = tfs_find_entry(dir, dname, &de);
 244         if (IS_ERR_OR_NULL(cs)) {
 245                 err = cs ? PTR_ERR(cs) : -ENOENT;
 246                 goto out;
 247         }
 248
 249         inode = tfs_iget_by_inr(dir->i_fs, de->d_inode);
 250         if (IS_ERR(inode)) {
 251                 err = PTR_ERR(inode);
 252                 goto out;
 253         }
 254
 255         if (inode->i_mode != TFS_FILE) {
 256                 printk("%s: not a file!\n", dname);
 257                 goto error;
 258         }
 259
 260         dir->i_size -= sizeof(struct tfs_dir_entry);
 261         err = tfs_iwrite(dir);
 262         if (err)
 263                 goto error;
 264         de->d_inode = 0;
 265         err = tfs_bwrite(sbi, cs->block, cs->data);
 266         if (err)
 267                 goto error;
 268         err = tfs_release_inode(sbi, inode);
 269         goto out;
 270
 271 error:
 272         free_inode(inode);
 273 out:
 274         return err;
 275 }
 276
 277
 278 /* read one directry entry at a time */
 279 struct dirent * tfs_readdir(struct file *file)
 280 {
 281         struct dirent *dirent;
 282         struct tfs_dir_entry *de;
 283         struct cache_struct *cs;
 284         struct inode *inode = file->inode;
 285         struct tfs_sb_info *sbi  = TFS_SBI(file->fs);
 286         int index = file->offset >> sbi->s_block_shift;
 287         uint32_t block;
 288
 289         if (!(block = tfs_bmap(inode, index)))
 290                 return NULL;
 291         cs = get_cache_block(file->fs, block);
 292         de = (struct tfs_dir_entry *)(cs->data + (file->offset & (sbi->s_block_size- 1)));
 293
 294         if (!(dirent = malloc(sizeof(*dirent)))) {
 295                 printk("malloc dirent structure in tfs_readdir error!\n");
 296                 return NULL;
 297         }
 298         memset(dirent, 0, sizeof(*dirent));
 299         dirent->d_ino = de->d_inode;
 300         dirent->d_off = file->offset;
 301         dirent->d_reclen = sizeof(struct tfs_dir_entry);
 302         dirent->d_type = 0;
 303         memcpy(dirent->d_name, de->d_name, TFS_NAME_LEN);
 304
 305         file->offset += sizeof(struct tfs_dir_entry);
 306
 307         /* Skip the invalid one */
 308         if (de->d_inode == 0) {
 309                 free(dirent);
 310                 return tfs_readdir(file);
 311         }
 312
 313
 314         return dirent;
 315 }
 316
 317 void tfs_closedir(DIR *dir)
 318 {
 319         if (dir) {
 320                 free_inode(dir->dd_dir->inode);
 321                 free(dir->dd_dir);
 322                 free(dir);
 323         }
 324 }