fs/orangefs/namei.c

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