fs/sysv/namei.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  *  linux/fs/sysv/namei.c
   4  *
   5  *  minix/namei.c
   6  *  Copyright (C) 1991, 1992  Linus Torvalds
   7  *
   8  *  coh/namei.c
   9  *  Copyright (C) 1993  Pascal Haible, Bruno Haible
  10  *
  11  *  sysv/namei.c
  12  *  Copyright (C) 1993  Bruno Haible
  13  *  Copyright (C) 1997, 1998  Krzysztof G. Baranowski
  14  */
  15
  16 #include <linux/pagemap.h>
  17 #include "sysv.h"
  18
  19 static int add_nondir(struct dentry *dentry, struct inode *inode)
  20 {
  21         int err = sysv_add_link(dentry, inode);
  22         if (!err) {
  23                 d_instantiate(dentry, inode);
  24                 return 0;
  25         }
  26         inode_dec_link_count(inode);
  27         iput(inode);
  28         return err;
  29 }
  30
  31 static int sysv_hash(const struct dentry *dentry, struct qstr *qstr)
  32 {
  33         /* Truncate the name in place, avoids having to define a compare
  34            function. */
  35         if (qstr->len > SYSV_NAMELEN) {
  36                 qstr->len = SYSV_NAMELEN;
  37                 qstr->hash = full_name_hash(dentry, qstr->name, qstr->len);
  38         }
  39         return 0;
  40 }
  41
  42 const struct dentry_operations sysv_dentry_operations = {
  43         .d_hash         = sysv_hash,
  44 };
  45
  46 static struct dentry *sysv_lookup(struct inode * dir, struct dentry * dentry, unsigned int flags)
  47 {
  48         struct inode * inode = NULL;
  49         ino_t ino;
  50
  51         if (dentry->d_name.len > SYSV_NAMELEN)
  52                 return ERR_PTR(-ENAMETOOLONG);
  53         ino = sysv_inode_by_name(dentry);
  54         if (ino)
  55                 inode = sysv_iget(dir->i_sb, ino);
  56         return d_splice_alias(inode, dentry);
  57 }
  58
  59 static int sysv_mknod(struct inode * dir, struct dentry * dentry, umode_t mode, dev_t rdev)
  60 {
  61         struct inode * inode;
  62         int err;
  63
  64         if (!old_valid_dev(rdev))
  65                 return -EINVAL;
  66
  67         inode = sysv_new_inode(dir, mode);
  68         err = PTR_ERR(inode);
  69
  70         if (!IS_ERR(inode)) {
  71                 sysv_set_inode(inode, rdev);
  72                 mark_inode_dirty(inode);
  73                 err = add_nondir(dentry, inode);
  74         }
  75         return err;
  76 }
  77
  78 static int sysv_create(struct inode * dir, struct dentry * dentry, umode_t mode, bool excl)
  79 {
  80         return sysv_mknod(dir, dentry, mode, 0);
  81 }
  82
  83 static int sysv_symlink(struct inode * dir, struct dentry * dentry,
  84         const char * symname)
  85 {
  86         int err = -ENAMETOOLONG;
  87         int l = strlen(symname)+1;
  88         struct inode * inode;
  89
  90         if (l > dir->i_sb->s_blocksize)
  91                 goto out;
  92
  93         inode = sysv_new_inode(dir, S_IFLNK|0777);
  94         err = PTR_ERR(inode);
  95         if (IS_ERR(inode))
  96                 goto out;
  97
  98         sysv_set_inode(inode, 0);
  99         err = page_symlink(inode, symname, l);
 100         if (err)
 101                 goto out_fail;
 102
 103         mark_inode_dirty(inode);
 104         err = add_nondir(dentry, inode);
 105 out:
 106         return err;
 107
 108 out_fail:
 109         inode_dec_link_count(inode);
 110         iput(inode);
 111         goto out;
 112 }
 113
 114 static int sysv_link(struct dentry * old_dentry, struct inode * dir,
 115         struct dentry * dentry)
 116 {
 117         struct inode *inode = d_inode(old_dentry);
 118
 119         inode->i_ctime = current_time(inode);
 120         inode_inc_link_count(inode);
 121         ihold(inode);
 122
 123         return add_nondir(dentry, inode);
 124 }
 125
 126 static int sysv_mkdir(struct inode * dir, struct dentry *dentry, umode_t mode)
 127 {
 128         struct inode * inode;
 129         int err;
 130
 131         inode_inc_link_count(dir);
 132
 133         inode = sysv_new_inode(dir, S_IFDIR|mode);
 134         err = PTR_ERR(inode);
 135         if (IS_ERR(inode))
 136                 goto out_dir;
 137
 138         sysv_set_inode(inode, 0);
 139
 140         inode_inc_link_count(inode);
 141
 142         err = sysv_make_empty(inode, dir);
 143         if (err)
 144                 goto out_fail;
 145
 146         err = sysv_add_link(dentry, inode);
 147         if (err)
 148                 goto out_fail;
 149
 150         d_instantiate(dentry, inode);
 151 out:
 152         return err;
 153
 154 out_fail:
 155         inode_dec_link_count(inode);
 156         inode_dec_link_count(inode);
 157         iput(inode);
 158 out_dir:
 159         inode_dec_link_count(dir);
 160         goto out;
 161 }
 162
 163 static int sysv_unlink(struct inode * dir, struct dentry * dentry)
 164 {
 165         struct inode * inode = d_inode(dentry);
 166         struct page * page;
 167         struct sysv_dir_entry * de;
 168         int err = -ENOENT;
 169
 170         de = sysv_find_entry(dentry, &page);
 171         if (!de)
 172                 goto out;
 173
 174         err = sysv_delete_entry (de, page);
 175         if (err)
 176                 goto out;
 177
 178         inode->i_ctime = dir->i_ctime;
 179         inode_dec_link_count(inode);
 180 out:
 181         return err;
 182 }
 183
 184 static int sysv_rmdir(struct inode * dir, struct dentry * dentry)
 185 {
 186         struct inode *inode = d_inode(dentry);
 187         int err = -ENOTEMPTY;
 188
 189         if (sysv_empty_dir(inode)) {
 190                 err = sysv_unlink(dir, dentry);
 191                 if (!err) {
 192                         inode->i_size = 0;
 193                         inode_dec_link_count(inode);
 194                         inode_dec_link_count(dir);
 195                 }
 196         }
 197         return err;
 198 }
 199
 200 /*
 201  * Anybody can rename anything with this: the permission checks are left to the
 202  * higher-level routines.
 203  */
 204 static int sysv_rename(struct inode * old_dir, struct dentry * old_dentry,
 205                        struct inode * new_dir, struct dentry * new_dentry,
 206                        unsigned int flags)
 207 {
 208         struct inode * old_inode = d_inode(old_dentry);
 209         struct inode * new_inode = d_inode(new_dentry);
 210         struct page * dir_page = NULL;
 211         struct sysv_dir_entry * dir_de = NULL;
 212         struct page * old_page;
 213         struct sysv_dir_entry * old_de;
 214         int err = -ENOENT;
 215
 216         if (flags & ~RENAME_NOREPLACE)
 217                 return -EINVAL;
 218
 219         old_de = sysv_find_entry(old_dentry, &old_page);
 220         if (!old_de)
 221                 goto out;
 222
 223         if (S_ISDIR(old_inode->i_mode)) {
 224                 err = -EIO;
 225                 dir_de = sysv_dotdot(old_inode, &dir_page);
 226                 if (!dir_de)
 227                         goto out_old;
 228         }
 229
 230         if (new_inode) {
 231                 struct page * new_page;
 232                 struct sysv_dir_entry * new_de;
 233
 234                 err = -ENOTEMPTY;
 235                 if (dir_de && !sysv_empty_dir(new_inode))
 236                         goto out_dir;
 237
 238                 err = -ENOENT;
 239                 new_de = sysv_find_entry(new_dentry, &new_page);
 240                 if (!new_de)
 241                         goto out_dir;
 242                 sysv_set_link(new_de, new_page, old_inode);
 243                 new_inode->i_ctime = current_time(new_inode);
 244                 if (dir_de)
 245                         drop_nlink(new_inode);
 246                 inode_dec_link_count(new_inode);
 247         } else {
 248                 err = sysv_add_link(new_dentry, old_inode);
 249                 if (err)
 250                         goto out_dir;
 251                 if (dir_de)
 252                         inode_inc_link_count(new_dir);
 253         }
 254
 255         sysv_delete_entry(old_de, old_page);
 256         mark_inode_dirty(old_inode);
 257
 258         if (dir_de) {
 259                 sysv_set_link(dir_de, dir_page, new_dir);
 260                 inode_dec_link_count(old_dir);
 261         }
 262         return 0;
 263
 264 out_dir:
 265         if (dir_de) {
 266                 kunmap(dir_page);
 267                 put_page(dir_page);
 268         }
 269 out_old:
 270         kunmap(old_page);
 271         put_page(old_page);
 272 out:
 273         return err;
 274 }
 275
 276 /*
 277  * directories can handle most operations...
 278  */
 279 const struct inode_operations sysv_dir_inode_operations = {
 280         .create         = sysv_create,
 281         .lookup         = sysv_lookup,
 282         .link           = sysv_link,
 283         .unlink         = sysv_unlink,
 284         .symlink        = sysv_symlink,
 285         .mkdir          = sysv_mkdir,
 286         .rmdir          = sysv_rmdir,
 287         .mknod          = sysv_mknod,
 288         .rename         = sysv_rename,
 289         .getattr        = sysv_getattr,
 290 };