fs/minix/namei.c

   1 /*
   2  *  linux/fs/minix/namei.c
   3  *
   4  *  Copyright (C) 1991, 1992  Linus Torvalds
   5  */
   6
   7 #include "minix.h"
   8
   9 static int add_nondir(struct dentry *dentry, struct inode *inode)
  10 {
  11         int err = minix_add_link(dentry, inode);
  12         if (!err) {
  13                 d_instantiate(dentry, inode);
  14                 return 0;
  15         }
  16         inode_dec_link_count(inode);
  17         iput(inode);
  18         return err;
  19 }
  20
  21 static struct dentry *minix_lookup(struct inode * dir, struct dentry *dentry, struct nameidata *nd)
  22 {
  23         struct inode * inode = NULL;
  24         ino_t ino;
  25
  26         if (dentry->d_name.len > minix_sb(dir->i_sb)->s_namelen)
  27                 return ERR_PTR(-ENAMETOOLONG);
  28
  29         ino = minix_inode_by_name(dentry);
  30         if (ino) {
  31                 inode = minix_iget(dir->i_sb, ino);
  32                 if (IS_ERR(inode))
  33                         return ERR_CAST(inode);
  34         }
  35         d_add(dentry, inode);
  36         return NULL;
  37 }
  38
  39 static int minix_mknod(struct inode * dir, struct dentry *dentry, int mode, dev_t rdev)
  40 {
  41         int error;
  42         struct inode *inode;
  43
  44         if (!old_valid_dev(rdev))
  45                 return -EINVAL;
  46
  47         inode = minix_new_inode(dir, mode, &error);
  48
  49         if (inode) {
  50                 minix_set_inode(inode, rdev);
  51                 mark_inode_dirty(inode);
  52                 error = add_nondir(dentry, inode);
  53         }
  54         return error;
  55 }
  56
  57 static int minix_create(struct inode * dir, struct dentry *dentry, int mode,
  58                 struct nameidata *nd)
  59 {
  60         return minix_mknod(dir, dentry, mode, 0);
  61 }
  62
  63 static int minix_symlink(struct inode * dir, struct dentry *dentry,
  64           const char * symname)
  65 {
  66         int err = -ENAMETOOLONG;
  67         int i = strlen(symname)+1;
  68         struct inode * inode;
  69
  70         if (i > dir->i_sb->s_blocksize)
  71                 goto out;
  72
  73         inode = minix_new_inode(dir, S_IFLNK | 0777, &err);
  74         if (!inode)
  75                 goto out;
  76
  77         minix_set_inode(inode, 0);
  78         err = page_symlink(inode, symname, i);
  79         if (err)
  80                 goto out_fail;
  81
  82         err = add_nondir(dentry, inode);
  83 out:
  84         return err;
  85
  86 out_fail:
  87         inode_dec_link_count(inode);
  88         iput(inode);
  89         goto out;
  90 }
  91
  92 static int minix_link(struct dentry * old_dentry, struct inode * dir,
  93         struct dentry *dentry)
  94 {
  95         struct inode *inode = old_dentry->d_inode;
  96
  97         if (inode->i_nlink >= minix_sb(inode->i_sb)->s_link_max)
  98                 return -EMLINK;
  99
 100         inode->i_ctime = CURRENT_TIME_SEC;
 101         inode_inc_link_count(inode);
 102         ihold(inode);
 103         return add_nondir(dentry, inode);
 104 }
 105
 106 static int minix_mkdir(struct inode * dir, struct dentry *dentry, int mode)
 107 {
 108         struct inode * inode;
 109         int err = -EMLINK;
 110
 111         if (dir->i_nlink >= minix_sb(dir->i_sb)->s_link_max)
 112                 goto out;
 113
 114         inode_inc_link_count(dir);
 115
 116         inode = minix_new_inode(dir, S_IFDIR | mode, &err);
 117         if (!inode)
 118                 goto out_dir;
 119
 120         minix_set_inode(inode, 0);
 121
 122         inode_inc_link_count(inode);
 123
 124         err = minix_make_empty(inode, dir);
 125         if (err)
 126                 goto out_fail;
 127
 128         err = minix_add_link(dentry, inode);
 129         if (err)
 130                 goto out_fail;
 131
 132         d_instantiate(dentry, inode);
 133 out:
 134         return err;
 135
 136 out_fail:
 137         inode_dec_link_count(inode);
 138         inode_dec_link_count(inode);
 139         iput(inode);
 140 out_dir:
 141         inode_dec_link_count(dir);
 142         goto out;
 143 }
 144
 145 static int minix_unlink(struct inode * dir, struct dentry *dentry)
 146 {
 147         int err = -ENOENT;
 148         struct inode * inode = dentry->d_inode;
 149         struct page * page;
 150         struct minix_dir_entry * de;
 151
 152         de = minix_find_entry(dentry, &page);
 153         if (!de)
 154                 goto end_unlink;
 155
 156         err = minix_delete_entry(de, page);
 157         if (err)
 158                 goto end_unlink;
 159
 160         inode->i_ctime = dir->i_ctime;
 161         inode_dec_link_count(inode);
 162 end_unlink:
 163         return err;
 164 }
 165
 166 static int minix_rmdir(struct inode * dir, struct dentry *dentry)
 167 {
 168         struct inode * inode = dentry->d_inode;
 169         int err = -ENOTEMPTY;
 170
 171         dentry_unhash(dentry);
 172
 173         if (minix_empty_dir(inode)) {
 174                 err = minix_unlink(dir, dentry);
 175                 if (!err) {
 176                         inode_dec_link_count(dir);
 177                         inode_dec_link_count(inode);
 178                 }
 179         }
 180         return err;
 181 }
 182
 183 static int minix_rename(struct inode * old_dir, struct dentry *old_dentry,
 184                            struct inode * new_dir, struct dentry *new_dentry)
 185 {
 186         struct minix_sb_info * info = minix_sb(old_dir->i_sb);
 187         struct inode * old_inode = old_dentry->d_inode;
 188         struct inode * new_inode = new_dentry->d_inode;
 189         struct page * dir_page = NULL;
 190         struct minix_dir_entry * dir_de = NULL;
 191         struct page * old_page;
 192         struct minix_dir_entry * old_de;
 193         int err = -ENOENT;
 194
 195         if (new_inode && S_ISDIR(new_inode->i_mode))
 196                 dentry_unhash(new_dentry);
 197
 198         old_de = minix_find_entry(old_dentry, &old_page);
 199         if (!old_de)
 200                 goto out;
 201
 202         if (S_ISDIR(old_inode->i_mode)) {
 203                 err = -EIO;
 204                 dir_de = minix_dotdot(old_inode, &dir_page);
 205                 if (!dir_de)
 206                         goto out_old;
 207         }
 208
 209         if (new_inode) {
 210                 struct page * new_page;
 211                 struct minix_dir_entry * new_de;
 212
 213                 err = -ENOTEMPTY;
 214                 if (dir_de && !minix_empty_dir(new_inode))
 215                         goto out_dir;
 216
 217                 err = -ENOENT;
 218                 new_de = minix_find_entry(new_dentry, &new_page);
 219                 if (!new_de)
 220                         goto out_dir;
 221                 minix_set_link(new_de, new_page, old_inode);
 222                 new_inode->i_ctime = CURRENT_TIME_SEC;
 223                 if (dir_de)
 224                         drop_nlink(new_inode);
 225                 inode_dec_link_count(new_inode);
 226         } else {
 227                 if (dir_de) {
 228                         err = -EMLINK;
 229                         if (new_dir->i_nlink >= info->s_link_max)
 230                                 goto out_dir;
 231                 }
 232                 err = minix_add_link(new_dentry, old_inode);
 233                 if (err)
 234                         goto out_dir;
 235                 if (dir_de)
 236                         inode_inc_link_count(new_dir);
 237         }
 238
 239         minix_delete_entry(old_de, old_page);
 240         mark_inode_dirty(old_inode);
 241
 242         if (dir_de) {
 243                 minix_set_link(dir_de, dir_page, new_dir);
 244                 inode_dec_link_count(old_dir);
 245         }
 246         return 0;
 247
 248 out_dir:
 249         if (dir_de) {
 250                 kunmap(dir_page);
 251                 page_cache_release(dir_page);
 252         }
 253 out_old:
 254         kunmap(old_page);
 255         page_cache_release(old_page);
 256 out:
 257         return err;
 258 }
 259
 260 /*
 261  * directories can handle most operations...
 262  */
 263 const struct inode_operations minix_dir_inode_operations = {
 264         .create         = minix_create,
 265         .lookup         = minix_lookup,
 266         .link           = minix_link,
 267         .unlink         = minix_unlink,
 268         .symlink        = minix_symlink,
 269         .mkdir          = minix_mkdir,
 270         .rmdir          = minix_rmdir,
 271         .mknod          = minix_mknod,
 272         .rename         = minix_rename,
 273         .getattr        = minix_getattr,
 274 };