Pileus Git - ~andy/linux/blob - fs/exportfs/expfs.c

   1 /*
   2  * Copyright (C) Neil Brown 2002
   3  * Copyright (C) Christoph Hellwig 2007
   4  *
   5  * This file contains the code mapping from inodes to NFS file handles,
   6  * and for mapping back from file handles to dentries.
   7  *
   8  * For details on why we do all the strange and hairy things in here
   9  * take a look at Documentation/filesystems/nfs/Exporting.
  10  */
  11 #include <linux/exportfs.h>
  12 #include <linux/fs.h>
  13 #include <linux/file.h>
  14 #include <linux/module.h>
  15 #include <linux/mount.h>
  16 #include <linux/namei.h>
  17 #include <linux/sched.h>
  18
  19 #define dprintk(fmt, args...) do{}while(0)
  20
  21
  22 static int get_name(const struct path *path, char *name, struct dentry *child);
  23
  24
  25 static int exportfs_get_name(struct vfsmount *mnt, struct dentry *dir,
  26                 char *name, struct dentry *child)
  27 {
  28         const struct export_operations *nop = dir->d_sb->s_export_op;
  29         struct path path = {.mnt = mnt, .dentry = dir};
  30
  31         if (nop->get_name)
  32                 return nop->get_name(dir, name, child);
  33         else
  34                 return get_name(&path, name, child);
  35 }
  36
  37 /*
  38  * Check if the dentry or any of it's aliases is acceptable.
  39  */
  40 static struct dentry *
  41 find_acceptable_alias(struct dentry *result,
  42                 int (*acceptable)(void *context, struct dentry *dentry),
  43                 void *context)
  44 {
  45         struct dentry *dentry, *toput = NULL;
  46         struct inode *inode;
  47
  48         if (acceptable(context, result))
  49                 return result;
  50
  51         inode = result->d_inode;
  52         spin_lock(&inode->i_lock);
  53         hlist_for_each_entry(dentry, &inode->i_dentry, d_alias) {
  54                 dget(dentry);
  55                 spin_unlock(&inode->i_lock);
  56                 if (toput)
  57                         dput(toput);
  58                 if (dentry != result && acceptable(context, dentry)) {
  59                         dput(result);
  60                         return dentry;
  61                 }
  62                 spin_lock(&inode->i_lock);
  63                 toput = dentry;
  64         }
  65         spin_unlock(&inode->i_lock);
  66
  67         if (toput)
  68                 dput(toput);
  69         return NULL;
  70 }
  71
  72 /*
  73  * Find root of a disconnected subtree and return a reference to it.
  74  */
  75 static struct dentry *
  76 find_disconnected_root(struct dentry *dentry)
  77 {
  78         dget(dentry);
  79         while (!IS_ROOT(dentry)) {
  80                 struct dentry *parent = dget_parent(dentry);
  81
  82                 if (!(parent->d_flags & DCACHE_DISCONNECTED)) {
  83                         dput(parent);
  84                         break;
  85                 }
  86
  87                 dput(dentry);
  88                 dentry = parent;
  89         }
  90         return dentry;
  91 }
  92
  93 static bool dentry_connected(struct dentry *dentry)
  94 {
  95         dget(dentry);
  96         while (dentry->d_flags & DCACHE_DISCONNECTED) {
  97                 struct dentry *parent = dget_parent(dentry);
  98
  99                 dput(dentry);
 100                 if (IS_ROOT(dentry)) {
 101                         dput(parent);
 102                         return false;
 103                 }
 104                 dentry = parent;
 105         }
 106         dput(dentry);
 107         return true;
 108 }
 109
 110 static void clear_disconnected(struct dentry *dentry)
 111 {
 112         dget(dentry);
 113         while (dentry->d_flags & DCACHE_DISCONNECTED) {
 114                 struct dentry *parent = dget_parent(dentry);
 115
 116                 WARN_ON_ONCE(IS_ROOT(dentry));
 117
 118                 spin_lock(&dentry->d_lock);
 119                 dentry->d_flags &= ~DCACHE_DISCONNECTED;
 120                 spin_unlock(&dentry->d_lock);
 121
 122                 dput(dentry);
 123                 dentry = parent;
 124         }
 125         dput(dentry);
 126 }
 127
 128 /*
 129  * Reconnect a directory dentry with its parent.
 130  *
 131  * This can return a dentry, or NULL, or an error.
 132  *
 133  * In the first case the returned dentry is the parent of the given
 134  * dentry, and may itself need to be reconnected to its parent.
 135  *
 136  * In the NULL case, a concurrent VFS operation has either renamed or
 137  * removed this directory.  The concurrent operation has reconnected our
 138  * dentry, so we no longer need to.
 139  */
 140 static struct dentry *reconnect_one(struct vfsmount *mnt,
 141                 struct dentry *dentry, char *nbuf)
 142 {
 143         struct dentry *parent;
 144         struct dentry *tmp;
 145         int err;
 146
 147         parent = ERR_PTR(-EACCES);
 148         mutex_lock(&dentry->d_inode->i_mutex);
 149         if (mnt->mnt_sb->s_export_op->get_parent)
 150                 parent = mnt->mnt_sb->s_export_op->get_parent(dentry);
 151         mutex_unlock(&dentry->d_inode->i_mutex);
 152
 153         if (IS_ERR(parent)) {
 154                 dprintk("%s: get_parent of %ld failed, err %d\n",
 155                         __func__, dentry->d_inode->i_ino, PTR_ERR(parent));
 156                 return parent;
 157         }
 158
 159         dprintk("%s: find name of %lu in %lu\n", __func__,
 160                 dentry->d_inode->i_ino, parent->d_inode->i_ino);
 161         err = exportfs_get_name(mnt, parent, nbuf, dentry);
 162         if (err == -ENOENT)
 163                 goto out_reconnected;
 164         if (err)
 165                 goto out_err;
 166         dprintk("%s: found name: %s\n", __func__, nbuf);
 167         mutex_lock(&parent->d_inode->i_mutex);
 168         tmp = lookup_one_len(nbuf, parent, strlen(nbuf));
 169         mutex_unlock(&parent->d_inode->i_mutex);
 170         if (IS_ERR(tmp)) {
 171                 dprintk("%s: lookup failed: %d\n", __func__, PTR_ERR(tmp));
 172                 goto out_err;
 173         }
 174         if (tmp != dentry) {
 175                 dput(tmp);
 176                 goto out_reconnected;
 177         }
 178         dput(tmp);
 179         if (IS_ROOT(dentry)) {
 180                 err = -ESTALE;
 181                 goto out_err;
 182         }
 183         return parent;
 184
 185 out_err:
 186         dput(parent);
 187         return ERR_PTR(err);
 188 out_reconnected:
 189         dput(parent);
 190         /*
 191          * Someone must have renamed our entry into another parent, in
 192          * which case it has been reconnected by the rename.
 193          *
 194          * Or someone removed it entirely, in which case filehandle
 195          * lookup will succeed but the directory is now IS_DEAD and
 196          * subsequent operations on it will fail.
 197          *
 198          * Alternatively, maybe there was no race at all, and the
 199          * filesystem is just corrupt and gave us a parent that doesn't
 200          * actually contain any entry pointing to this inode.  So,
 201          * double check that this worked and return -ESTALE if not:
 202          */
 203         if (!dentry_connected(dentry))
 204                 return ERR_PTR(-ESTALE);
 205         return NULL;
 206 }
 207
 208 /*
 209  * Make sure target_dir is fully connected to the dentry tree.
 210  *
 211  * On successful return, DCACHE_DISCONNECTED will be cleared on
 212  * target_dir, and target_dir->d_parent->...->d_parent will reach the
 213  * root of the filesystem.
 214  *
 215  * Whenever DCACHE_DISCONNECTED is unset, target_dir is fully connected.
 216  * But the converse is not true: target_dir may have DCACHE_DISCONNECTED
 217  * set but already be connected.  In that case we'll verify the
 218  * connection to root and then clear the flag.
 219  *
 220  * Note that target_dir could be removed by a concurrent operation.  In
 221  * that case reconnect_path may still succeed with target_dir fully
 222  * connected, but further operations using the filehandle will fail when
 223  * necessary (due to S_DEAD being set on the directory).
 224  */
 225 static int
 226 reconnect_path(struct vfsmount *mnt, struct dentry *target_dir, char *nbuf)
 227 {
 228         int err = -ESTALE;
 229
 230         while (target_dir->d_flags & DCACHE_DISCONNECTED) {
 231                 struct dentry *pd = find_disconnected_root(target_dir);
 232
 233                 BUG_ON(pd == mnt->mnt_sb->s_root);
 234
 235                 if (!IS_ROOT(pd)) {
 236                         /* must have found a connected parent - great */
 237                         clear_disconnected(target_dir);
 238                         dput(pd);
 239                         break;
 240                 } else {
 241                         struct dentry *parent;
 242                         /*
 243                          * We have hit the top of a disconnected path, try to
 244                          * find parent and connect.
 245                          */
 246                          parent = reconnect_one(mnt, pd, nbuf);
 247                          if (!parent)
 248                                 goto out_reconnected;
 249                         if (IS_ERR(parent)) {
 250                                 err = PTR_ERR(parent);
 251                                 break;
 252                         }
 253                         dput(parent);
 254                 }
 255                 dput(pd);
 256         }
 257
 258         if (target_dir->d_flags & DCACHE_DISCONNECTED) {
 259                 /* something went wrong - oh-well */
 260                 if (!err)
 261                         err = -ESTALE;
 262                 return err;
 263         }
 264
 265         return 0;
 266 out_reconnected:
 267         clear_disconnected(target_dir);
 268         return 0;
 269 }
 270
 271 struct getdents_callback {
 272         struct dir_context ctx;
 273         char *name;             /* name that was found. It already points to a
 274                                    buffer NAME_MAX+1 is size */
 275         u64 ino;                /* the inum we are looking for */
 276         int found;              /* inode matched? */
 277         int sequence;           /* sequence counter */
 278 };
 279
 280 /*
 281  * A rather strange filldir function to capture
 282  * the name matching the specified inode number.
 283  */
 284 static int filldir_one(void * __buf, const char * name, int len,
 285                         loff_t pos, u64 ino, unsigned int d_type)
 286 {
 287         struct getdents_callback *buf = __buf;
 288         int result = 0;
 289
 290         buf->sequence++;
 291         if (buf->ino == ino && len <= NAME_MAX) {
 292                 memcpy(buf->name, name, len);
 293                 buf->name[len] = '\0';
 294                 buf->found = 1;
 295                 result = -1;
 296         }
 297         return result;
 298 }
 299
 300 /**
 301  * get_name - default export_operations->get_name function
 302  * @dentry: the directory in which to find a name
 303  * @name:   a pointer to a %NAME_MAX+1 char buffer to store the name
 304  * @child:  the dentry for the child directory.
 305  *
 306  * calls readdir on the parent until it finds an entry with
 307  * the same inode number as the child, and returns that.
 308  */
 309 static int get_name(const struct path *path, char *name, struct dentry *child)
 310 {
 311         const struct cred *cred = current_cred();
 312         struct inode *dir = path->dentry->d_inode;
 313         int error;
 314         struct file *file;
 315         struct kstat stat;
 316         struct path child_path = {
 317                 .mnt = path->mnt,
 318                 .dentry = child,
 319         };
 320         struct getdents_callback buffer = {
 321                 .ctx.actor = filldir_one,
 322                 .name = name,
 323         };
 324
 325         error = -ENOTDIR;
 326         if (!dir || !S_ISDIR(dir->i_mode))
 327                 goto out;
 328         error = -EINVAL;
 329         if (!dir->i_fop)
 330                 goto out;
 331         /*
 332          * inode->i_ino is unsigned long, kstat->ino is u64, so the
 333          * former would be insufficient on 32-bit hosts when the
 334          * filesystem supports 64-bit inode numbers.  So we need to
 335          * actually call ->getattr, not just read i_ino:
 336          */
 337         error = vfs_getattr_nosec(&child_path, &stat);
 338         if (error)
 339                 return error;
 340         buffer.ino = stat.ino;
 341         /*
 342          * Open the directory ...
 343          */
 344         file = dentry_open(path, O_RDONLY, cred);
 345         error = PTR_ERR(file);
 346         if (IS_ERR(file))
 347                 goto out;
 348
 349         error = -EINVAL;
 350         if (!file->f_op->iterate)
 351                 goto out_close;
 352
 353         buffer.sequence = 0;
 354         while (1) {
 355                 int old_seq = buffer.sequence;
 356
 357                 error = iterate_dir(file, &buffer.ctx);
 358                 if (buffer.found) {
 359                         error = 0;
 360                         break;
 361                 }
 362
 363                 if (error < 0)
 364                         break;
 365
 366                 error = -ENOENT;
 367                 if (old_seq == buffer.sequence)
 368                         break;
 369         }
 370
 371 out_close:
 372         fput(file);
 373 out:
 374         return error;
 375 }
 376
 377 /**
 378  * export_encode_fh - default export_operations->encode_fh function
 379  * @inode:   the object to encode
 380  * @fh:      where to store the file handle fragment
 381  * @max_len: maximum length to store there
 382  * @parent:  parent directory inode, if wanted
 383  *
 384  * This default encode_fh function assumes that the 32 inode number
 385  * is suitable for locating an inode, and that the generation number
 386  * can be used to check that it is still valid.  It places them in the
 387  * filehandle fragment where export_decode_fh expects to find them.
 388  */
 389 static int export_encode_fh(struct inode *inode, struct fid *fid,
 390                 int *max_len, struct inode *parent)
 391 {
 392         int len = *max_len;
 393         int type = FILEID_INO32_GEN;
 394
 395         if (parent && (len < 4)) {
 396                 *max_len = 4;
 397                 return FILEID_INVALID;
 398         } else if (len < 2) {
 399                 *max_len = 2;
 400                 return FILEID_INVALID;
 401         }
 402
 403         len = 2;
 404         fid->i32.ino = inode->i_ino;
 405         fid->i32.gen = inode->i_generation;
 406         if (parent) {
 407                 fid->i32.parent_ino = parent->i_ino;
 408                 fid->i32.parent_gen = parent->i_generation;
 409                 len = 4;
 410                 type = FILEID_INO32_GEN_PARENT;
 411         }
 412         *max_len = len;
 413         return type;
 414 }
 415
 416 int exportfs_encode_inode_fh(struct inode *inode, struct fid *fid,
 417                              int *max_len, struct inode *parent)
 418 {
 419         const struct export_operations *nop = inode->i_sb->s_export_op;
 420
 421         if (nop && nop->encode_fh)
 422                 return nop->encode_fh(inode, fid->raw, max_len, parent);
 423
 424         return export_encode_fh(inode, fid, max_len, parent);
 425 }
 426 EXPORT_SYMBOL_GPL(exportfs_encode_inode_fh);
 427
 428 int exportfs_encode_fh(struct dentry *dentry, struct fid *fid, int *max_len,
 429                 int connectable)
 430 {
 431         int error;
 432         struct dentry *p = NULL;
 433         struct inode *inode = dentry->d_inode, *parent = NULL;
 434
 435         if (connectable && !S_ISDIR(inode->i_mode)) {
 436                 p = dget_parent(dentry);
 437                 /*
 438                  * note that while p might've ceased to be our parent already,
 439                  * it's still pinned by and still positive.
 440                  */
 441                 parent = p->d_inode;
 442         }
 443
 444         error = exportfs_encode_inode_fh(inode, fid, max_len, parent);
 445         dput(p);
 446
 447         return error;
 448 }
 449 EXPORT_SYMBOL_GPL(exportfs_encode_fh);
 450
 451 struct dentry *exportfs_decode_fh(struct vfsmount *mnt, struct fid *fid,
 452                 int fh_len, int fileid_type,
 453                 int (*acceptable)(void *, struct dentry *), void *context)
 454 {
 455         const struct export_operations *nop = mnt->mnt_sb->s_export_op;
 456         struct dentry *result, *alias;
 457         char nbuf[NAME_MAX+1];
 458         int err;
 459
 460         /*
 461          * Try to get any dentry for the given file handle from the filesystem.
 462          */
 463         if (!nop || !nop->fh_to_dentry)
 464                 return ERR_PTR(-ESTALE);
 465         result = nop->fh_to_dentry(mnt->mnt_sb, fid, fh_len, fileid_type);
 466         if (!result)
 467                 result = ERR_PTR(-ESTALE);
 468         if (IS_ERR(result))
 469                 return result;
 470
 471         if (S_ISDIR(result->d_inode->i_mode)) {
 472                 /*
 473                  * This request is for a directory.
 474                  *
 475                  * On the positive side there is only one dentry for each
 476                  * directory inode.  On the negative side this implies that we
 477                  * to ensure our dentry is connected all the way up to the
 478                  * filesystem root.
 479                  */
 480                 if (result->d_flags & DCACHE_DISCONNECTED) {
 481                         err = reconnect_path(mnt, result, nbuf);
 482                         if (err)
 483                                 goto err_result;
 484                 }
 485
 486                 if (!acceptable(context, result)) {
 487                         err = -EACCES;
 488                         goto err_result;
 489                 }
 490
 491                 return result;
 492         } else {
 493                 /*
 494                  * It's not a directory.  Life is a little more complicated.
 495                  */
 496                 struct dentry *target_dir, *nresult;
 497
 498                 /*
 499                  * See if either the dentry we just got from the filesystem
 500                  * or any alias for it is acceptable.  This is always true
 501                  * if this filesystem is exported without the subtreecheck
 502                  * option.  If the filesystem is exported with the subtree
 503                  * check option there's a fair chance we need to look at
 504                  * the parent directory in the file handle and make sure
 505                  * it's connected to the filesystem root.
 506                  */
 507                 alias = find_acceptable_alias(result, acceptable, context);
 508                 if (alias)
 509                         return alias;
 510
 511                 /*
 512                  * Try to extract a dentry for the parent directory from the
 513                  * file handle.  If this fails we'll have to give up.
 514                  */
 515                 err = -ESTALE;
 516                 if (!nop->fh_to_parent)
 517                         goto err_result;
 518
 519                 target_dir = nop->fh_to_parent(mnt->mnt_sb, fid,
 520                                 fh_len, fileid_type);
 521                 if (!target_dir)
 522                         goto err_result;
 523                 err = PTR_ERR(target_dir);
 524                 if (IS_ERR(target_dir))
 525                         goto err_result;
 526
 527                 /*
 528                  * And as usual we need to make sure the parent directory is
 529                  * connected to the filesystem root.  The VFS really doesn't
 530                  * like disconnected directories..
 531                  */
 532                 err = reconnect_path(mnt, target_dir, nbuf);
 533                 if (err) {
 534                         dput(target_dir);
 535                         goto err_result;
 536                 }
 537
 538                 /*
 539                  * Now that we've got both a well-connected parent and a
 540                  * dentry for the inode we're after, make sure that our
 541                  * inode is actually connected to the parent.
 542                  */
 543                 err = exportfs_get_name(mnt, target_dir, nbuf, result);
 544                 if (!err) {
 545                         mutex_lock(&target_dir->d_inode->i_mutex);
 546                         nresult = lookup_one_len(nbuf, target_dir,
 547                                                  strlen(nbuf));
 548                         mutex_unlock(&target_dir->d_inode->i_mutex);
 549                         if (!IS_ERR(nresult)) {
 550                                 if (nresult->d_inode) {
 551                                         dput(result);
 552                                         result = nresult;
 553                                 } else
 554                                         dput(nresult);
 555                         }
 556                 }
 557
 558                 /*
 559                  * At this point we are done with the parent, but it's pinned
 560                  * by the child dentry anyway.
 561                  */
 562                 dput(target_dir);
 563
 564                 /*
 565                  * And finally make sure the dentry is actually acceptable
 566                  * to NFSD.
 567                  */
 568                 alias = find_acceptable_alias(result, acceptable, context);
 569                 if (!alias) {
 570                         err = -EACCES;
 571                         goto err_result;
 572                 }
 573
 574                 return alias;
 575         }
 576
 577  err_result:
 578         dput(result);
 579         return ERR_PTR(err);
 580 }
 581 EXPORT_SYMBOL_GPL(exportfs_decode_fh);
 582
 583 MODULE_LICENSE("GPL");