fs/orangefs/namei.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * (C) 2001 Clemson University and The University of Chicago
   4  *
   5  * See COPYING in top-level directory.
   6  */
   7
   8 /*
   9  *  Linux VFS namei operations.
  10  */
  11
  12 #include "protocol.h"
  13 #include "orangefs-kernel.h"
  14
  15 /*
  16  * Get a newly allocated inode to go with a negative dentry.
  17  */
  18 static int orangefs_create(struct inode *dir,
  19                         struct dentry *dentry,
  20                         umode_t mode,
  21                         bool exclusive)
  22 {
  23         struct orangefs_inode_s *parent = ORANGEFS_I(dir);
  24         struct orangefs_kernel_op_s *new_op;
  25         struct orangefs_object_kref ref;
  26         struct inode *inode;
  27         struct iattr iattr;
  28         int ret;
  29
  30         gossip_debug(GOSSIP_NAME_DEBUG, "%s: %pd\n",
  31                      __func__,
  32                      dentry);
  33
  34         new_op = op_alloc(ORANGEFS_VFS_OP_CREATE);
  35         if (!new_op)
  36                 return -ENOMEM;
  37
  38         new_op->upcall.req.create.parent_refn = parent->refn;
  39
  40         fill_default_sys_attrs(new_op->upcall.req.create.attributes,
  41                                ORANGEFS_TYPE_METAFILE, mode);
  42
  43         strncpy(new_op->upcall.req.create.d_name,
  44                 dentry->d_name.name, ORANGEFS_NAME_MAX - 1);
  45
  46         ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
  47
  48         gossip_debug(GOSSIP_NAME_DEBUG,
  49                      "%s: %pd: handle:%pU: fsid:%d: new_op:%p: ret:%d:\n",
  50                      __func__,
  51                      dentry,
  52                      &new_op->downcall.resp.create.refn.khandle,
  53                      new_op->downcall.resp.create.refn.fs_id,
  54                      new_op,
  55                      ret);
  56
  57         if (ret < 0)
  58                 goto out;
  59
  60         ref = new_op->downcall.resp.create.refn;
  61         op_release(new_op);
  62
  63         inode = orangefs_new_inode(dir->i_sb, dir, S_IFREG | mode, 0, &ref);
  64         if (IS_ERR(inode)) {
  65                 gossip_err("%s: Failed to allocate inode for file :%pd:\n",
  66                            __func__,
  67                            dentry);
  68                 ret = PTR_ERR(inode);
  69                 goto out;
  70         }
  71
  72         gossip_debug(GOSSIP_NAME_DEBUG,
  73                      "%s: Assigned inode :%pU: for file :%pd:\n",
  74                      __func__,
  75                      get_khandle_from_ino(inode),
  76                      dentry);
  77
  78         d_instantiate_new(dentry, inode);
  79         orangefs_set_timeout(dentry);
  80         ORANGEFS_I(inode)->getattr_time = jiffies - 1;
  81         ORANGEFS_I(inode)->getattr_mask = STATX_BASIC_STATS;
  82
  83         gossip_debug(GOSSIP_NAME_DEBUG,
  84                      "%s: dentry instantiated for %pd\n",
  85                      __func__,
  86                      dentry);
  87
  88         dir->i_mtime = dir->i_ctime = current_time(dir);
  89         memset(&iattr, 0, sizeof iattr);
  90         iattr.ia_valid |= ATTR_MTIME;
  91         orangefs_inode_setattr(dir, &iattr);
  92         mark_inode_dirty_sync(dir);
  93         ret = 0;
  94 out:
  95         gossip_debug(GOSSIP_NAME_DEBUG,
  96                      "%s: %pd: returning %d\n",
  97                      __func__,
  98                      dentry,
  99                      ret);
 100         return ret;
 101 }
 102
 103 /*
 104  * Attempt to resolve an object name (dentry->d_name), parent handle, and
 105  * fsid into a handle for the object.
 106  */
 107 static struct dentry *orangefs_lookup(struct inode *dir, struct dentry *dentry,
 108                                    unsigned int flags)
 109 {
 110         struct orangefs_inode_s *parent = ORANGEFS_I(dir);
 111         struct orangefs_kernel_op_s *new_op;
 112         struct inode *inode;
 113         struct dentry *res;
 114         int ret = -EINVAL;
 115
 116         /*
 117          * in theory we could skip a lookup here (if the intent is to
 118          * create) in order to avoid a potentially failed lookup, but
 119          * leaving it in can skip a valid lookup and try to create a file
 120          * that already exists (e.g. the vfs already handles checking for
 121          * -EEXIST on O_EXCL opens, which is broken if we skip this lookup
 122          * in the create path)
 123          */
 124         gossip_debug(GOSSIP_NAME_DEBUG, "%s called on %pd\n",
 125                      __func__, dentry);
 126
 127         if (dentry->d_name.len > (ORANGEFS_NAME_MAX - 1))
 128                 return ERR_PTR(-ENAMETOOLONG);
 129
 130         new_op = op_alloc(ORANGEFS_VFS_OP_LOOKUP);
 131         if (!new_op)
 132                 return ERR_PTR(-ENOMEM);
 133
 134         new_op->upcall.req.lookup.sym_follow = ORANGEFS_LOOKUP_LINK_NO_FOLLOW;
 135
 136         gossip_debug(GOSSIP_NAME_DEBUG, "%s:%s:%d using parent %pU\n",
 137                      __FILE__,
 138                      __func__,
 139                      __LINE__,
 140                      &parent->refn.khandle);
 141         new_op->upcall.req.lookup.parent_refn = parent->refn;
 142
 143         strncpy(new_op->upcall.req.lookup.d_name, dentry->d_name.name,
 144                 ORANGEFS_NAME_MAX - 1);
 145
 146         gossip_debug(GOSSIP_NAME_DEBUG,
 147                      "%s: doing lookup on %s under %pU,%d\n",
 148                      __func__,
 149                      new_op->upcall.req.lookup.d_name,
 150                      &new_op->upcall.req.lookup.parent_refn.khandle,
 151                      new_op->upcall.req.lookup.parent_refn.fs_id);
 152
 153         ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
 154
 155         gossip_debug(GOSSIP_NAME_DEBUG,
 156                      "Lookup Got %pU, fsid %d (ret=%d)\n",
 157                      &new_op->downcall.resp.lookup.refn.khandle,
 158                      new_op->downcall.resp.lookup.refn.fs_id,
 159                      ret);
 160
 161         if (ret < 0) {
 162                 if (ret == -ENOENT) {
 163                         /*
 164                          * if no inode was found, add a negative dentry to
 165                          * dcache anyway; if we don't, we don't hold expected
 166                          * lookup semantics and we most noticeably break
 167                          * during directory renames.
 168                          *
 169                          * however, if the operation failed or exited, do not
 170                          * add the dentry (e.g. in the case that a touch is
 171                          * issued on a file that already exists that was
 172                          * interrupted during this lookup -- no need to add
 173                          * another negative dentry for an existing file)
 174                          */
 175
 176                         gossip_debug(GOSSIP_NAME_DEBUG,
 177                                      "orangefs_lookup: Adding *negative* dentry "
 178                                      "%p for %pd\n",
 179                                      dentry,
 180                                      dentry);
 181
 182                         d_add(dentry, NULL);
 183                         res = NULL;
 184                         goto out;
 185                 }
 186
 187                 /* must be a non-recoverable error */
 188                 res = ERR_PTR(ret);
 189                 goto out;
 190         }
 191
 192         orangefs_set_timeout(dentry);
 193
 194         inode = orangefs_iget(dir->i_sb, &new_op->downcall.resp.lookup.refn);
 195         if (IS_ERR(inode)) {
 196                 gossip_debug(GOSSIP_NAME_DEBUG,
 197                         "error %ld from iget\n", PTR_ERR(inode));
 198                 res = ERR_CAST(inode);
 199                 goto out;
 200         }
 201
 202         gossip_debug(GOSSIP_NAME_DEBUG,
 203                      "%s:%s:%d "
 204                      "Found good inode [%lu] with count [%d]\n",
 205                      __FILE__,
 206                      __func__,
 207                      __LINE__,
 208                      inode->i_ino,
 209                      (int)atomic_read(&inode->i_count));
 210
 211         /* update dentry/inode pair into dcache */
 212         res = d_splice_alias(inode, dentry);
 213
 214         gossip_debug(GOSSIP_NAME_DEBUG,
 215                      "Lookup success (inode ct = %d)\n",
 216                      (int)atomic_read(&inode->i_count));
 217 out:
 218         op_release(new_op);
 219         return res;
 220 }
 221
 222 /* return 0 on success; non-zero otherwise */
 223 static int orangefs_unlink(struct inode *dir, struct dentry *dentry)
 224 {
 225         struct inode *inode = dentry->d_inode;
 226         struct orangefs_inode_s *parent = ORANGEFS_I(dir);
 227         struct orangefs_kernel_op_s *new_op;
 228         struct iattr iattr;
 229         int ret;
 230
 231         gossip_debug(GOSSIP_NAME_DEBUG,
 232                      "%s: called on %pd\n"
 233                      "  (inode %pU): Parent is %pU | fs_id %d\n",
 234                      __func__,
 235                      dentry,
 236                      get_khandle_from_ino(inode),
 237                      &parent->refn.khandle,
 238                      parent->refn.fs_id);
 239
 240         new_op = op_alloc(ORANGEFS_VFS_OP_REMOVE);
 241         if (!new_op)
 242                 return -ENOMEM;
 243
 244         new_op->upcall.req.remove.parent_refn = parent->refn;
 245         strncpy(new_op->upcall.req.remove.d_name, dentry->d_name.name,
 246                 ORANGEFS_NAME_MAX - 1);
 247
 248         ret = service_operation(new_op, "orangefs_unlink",
 249                                 get_interruptible_flag(inode));
 250
 251         gossip_debug(GOSSIP_NAME_DEBUG,
 252                      "%s: service_operation returned:%d:\n",
 253                      __func__,
 254                      ret);
 255
 256         op_release(new_op);
 257
 258         if (!ret) {
 259                 drop_nlink(inode);
 260
 261                 dir->i_mtime = dir->i_ctime = current_time(dir);
 262                 memset(&iattr, 0, sizeof iattr);
 263                 iattr.ia_valid |= ATTR_MTIME;
 264                 orangefs_inode_setattr(dir, &iattr);
 265                 mark_inode_dirty_sync(dir);
 266         }
 267         return ret;
 268 }
 269
 270 static int orangefs_symlink(struct inode *dir,
 271                          struct dentry *dentry,
 272                          const char *symname)
 273 {
 274         struct orangefs_inode_s *parent = ORANGEFS_I(dir);
 275         struct orangefs_kernel_op_s *new_op;
 276         struct orangefs_object_kref ref;
 277         struct inode *inode;
 278         struct iattr iattr;
 279         int mode = 755;
 280         int ret;
 281
 282         gossip_debug(GOSSIP_NAME_DEBUG, "%s: called\n", __func__);
 283
 284         if (!symname)
 285                 return -EINVAL;
 286
 287         if (strlen(symname)+1 > ORANGEFS_NAME_MAX)
 288                 return -ENAMETOOLONG;
 289
 290         new_op = op_alloc(ORANGEFS_VFS_OP_SYMLINK);
 291         if (!new_op)
 292                 return -ENOMEM;
 293
 294         new_op->upcall.req.sym.parent_refn = parent->refn;
 295
 296         fill_default_sys_attrs(new_op->upcall.req.sym.attributes,
 297                                ORANGEFS_TYPE_SYMLINK,
 298                                mode);
 299
 300         strncpy(new_op->upcall.req.sym.entry_name,
 301                 dentry->d_name.name,
 302                 ORANGEFS_NAME_MAX - 1);
 303         strncpy(new_op->upcall.req.sym.target, symname, ORANGEFS_NAME_MAX - 1);
 304
 305         ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
 306
 307         gossip_debug(GOSSIP_NAME_DEBUG,
 308                      "Symlink Got ORANGEFS handle %pU on fsid %d (ret=%d)\n",
 309                      &new_op->downcall.resp.sym.refn.khandle,
 310                      new_op->downcall.resp.sym.refn.fs_id, ret);
 311
 312         if (ret < 0) {
 313                 gossip_debug(GOSSIP_NAME_DEBUG,
 314                             "%s: failed with error code %d\n",
 315                             __func__, ret);
 316                 goto out;
 317         }
 318
 319         ref = new_op->downcall.resp.sym.refn;
 320         op_release(new_op);
 321
 322         inode = orangefs_new_inode(dir->i_sb, dir, S_IFLNK | mode, 0, &ref);
 323         if (IS_ERR(inode)) {
 324                 gossip_err
 325                     ("*** Failed to allocate orangefs symlink inode\n");
 326                 ret = PTR_ERR(inode);
 327                 goto out;
 328         }
 329
 330         gossip_debug(GOSSIP_NAME_DEBUG,
 331                      "Assigned symlink inode new number of %pU\n",
 332                      get_khandle_from_ino(inode));
 333
 334         d_instantiate_new(dentry, inode);
 335         orangefs_set_timeout(dentry);
 336         ORANGEFS_I(inode)->getattr_time = jiffies - 1;
 337         ORANGEFS_I(inode)->getattr_mask = STATX_BASIC_STATS;
 338
 339         gossip_debug(GOSSIP_NAME_DEBUG,
 340                      "Inode (Symlink) %pU -> %pd\n",
 341                      get_khandle_from_ino(inode),
 342                      dentry);
 343
 344         dir->i_mtime = dir->i_ctime = current_time(dir);
 345         memset(&iattr, 0, sizeof iattr);
 346         iattr.ia_valid |= ATTR_MTIME;
 347         orangefs_inode_setattr(dir, &iattr);
 348         mark_inode_dirty_sync(dir);
 349         ret = 0;
 350 out:
 351         return ret;
 352 }
 353
 354 static int orangefs_mkdir(struct inode *dir, struct dentry *dentry, umode_t mode)
 355 {
 356         struct orangefs_inode_s *parent = ORANGEFS_I(dir);
 357         struct orangefs_kernel_op_s *new_op;
 358         struct orangefs_object_kref ref;
 359         struct inode *inode;
 360         struct iattr iattr;
 361         int ret;
 362
 363         new_op = op_alloc(ORANGEFS_VFS_OP_MKDIR);
 364         if (!new_op)
 365                 return -ENOMEM;
 366
 367         new_op->upcall.req.mkdir.parent_refn = parent->refn;
 368
 369         fill_default_sys_attrs(new_op->upcall.req.mkdir.attributes,
 370                               ORANGEFS_TYPE_DIRECTORY, mode);
 371
 372         strncpy(new_op->upcall.req.mkdir.d_name,
 373                 dentry->d_name.name, ORANGEFS_NAME_MAX - 1);
 374
 375         ret = service_operation(new_op, __func__, get_interruptible_flag(dir));
 376
 377         gossip_debug(GOSSIP_NAME_DEBUG,
 378                      "Mkdir Got ORANGEFS handle %pU on fsid %d\n",
 379                      &new_op->downcall.resp.mkdir.refn.khandle,
 380                      new_op->downcall.resp.mkdir.refn.fs_id);
 381
 382         if (ret < 0) {
 383                 gossip_debug(GOSSIP_NAME_DEBUG,
 384                              "%s: failed with error code %d\n",
 385                              __func__, ret);
 386                 goto out;
 387         }
 388
 389         ref = new_op->downcall.resp.mkdir.refn;
 390         op_release(new_op);
 391
 392         inode = orangefs_new_inode(dir->i_sb, dir, S_IFDIR | mode, 0, &ref);
 393         if (IS_ERR(inode)) {
 394                 gossip_err("*** Failed to allocate orangefs dir inode\n");
 395                 ret = PTR_ERR(inode);
 396                 goto out;
 397         }
 398
 399         gossip_debug(GOSSIP_NAME_DEBUG,
 400                      "Assigned dir inode new number of %pU\n",
 401                      get_khandle_from_ino(inode));
 402
 403         d_instantiate_new(dentry, inode);
 404         orangefs_set_timeout(dentry);
 405         ORANGEFS_I(inode)->getattr_time = jiffies - 1;
 406         ORANGEFS_I(inode)->getattr_mask = STATX_BASIC_STATS;
 407
 408         gossip_debug(GOSSIP_NAME_DEBUG,
 409                      "Inode (Directory) %pU -> %pd\n",
 410                      get_khandle_from_ino(inode),
 411                      dentry);
 412
 413         /*
 414          * NOTE: we have no good way to keep nlink consistent for directories
 415          * across clients; keep constant at 1.
 416          */
 417         dir->i_mtime = dir->i_ctime = current_time(dir);
 418         memset(&iattr, 0, sizeof iattr);
 419         iattr.ia_valid |= ATTR_MTIME;
 420         orangefs_inode_setattr(dir, &iattr);
 421         mark_inode_dirty_sync(dir);
 422 out:
 423         return ret;
 424 }
 425
 426 static int orangefs_rename(struct inode *old_dir,
 427                         struct dentry *old_dentry,
 428                         struct inode *new_dir,
 429                         struct dentry *new_dentry,
 430                         unsigned int flags)
 431 {
 432         struct orangefs_kernel_op_s *new_op;
 433         int ret;
 434
 435         if (flags)
 436                 return -EINVAL;
 437
 438         gossip_debug(GOSSIP_NAME_DEBUG,
 439                      "orangefs_rename: called (%pd2 => %pd2) ct=%d\n",
 440                      old_dentry, new_dentry, d_count(new_dentry));
 441
 442         ORANGEFS_I(new_dentry->d_parent->d_inode)->getattr_time = jiffies - 1;
 443
 444         new_op = op_alloc(ORANGEFS_VFS_OP_RENAME);
 445         if (!new_op)
 446                 return -EINVAL;
 447
 448         new_op->upcall.req.rename.old_parent_refn = ORANGEFS_I(old_dir)->refn;
 449         new_op->upcall.req.rename.new_parent_refn = ORANGEFS_I(new_dir)->refn;
 450
 451         strncpy(new_op->upcall.req.rename.d_old_name,
 452                 old_dentry->d_name.name,
 453                 ORANGEFS_NAME_MAX - 1);
 454         strncpy(new_op->upcall.req.rename.d_new_name,
 455                 new_dentry->d_name.name,
 456                 ORANGEFS_NAME_MAX - 1);
 457
 458         ret = service_operation(new_op,
 459                                 "orangefs_rename",
 460                                 get_interruptible_flag(old_dentry->d_inode));
 461
 462         gossip_debug(GOSSIP_NAME_DEBUG,
 463                      "orangefs_rename: got downcall status %d\n",
 464                      ret);
 465
 466         if (new_dentry->d_inode)
 467                 new_dentry->d_inode->i_ctime = current_time(new_dentry->d_inode);
 468
 469         op_release(new_op);
 470         return ret;
 471 }
 472
 473 /* ORANGEFS implementation of VFS inode operations for directories */
 474 const struct inode_operations orangefs_dir_inode_operations = {
 475         .lookup = orangefs_lookup,
 476         .get_acl = orangefs_get_acl,
 477         .set_acl = orangefs_set_acl,
 478         .create = orangefs_create,
 479         .unlink = orangefs_unlink,
 480         .symlink = orangefs_symlink,
 481         .mkdir = orangefs_mkdir,
 482         .rmdir = orangefs_unlink,
 483         .rename = orangefs_rename,
 484         .setattr = orangefs_setattr,
 485         .getattr = orangefs_getattr,
 486         .listxattr = orangefs_listxattr,
 487         .permission = orangefs_permission,
 488         .update_time = orangefs_update_time,
 489 };