fs/minix/namei.c

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