fs/autofs4/root.c

   1 /* -*- c -*- --------------------------------------------------------------- *
   2  *
   3  * linux/fs/autofs/root.c
   4  *
   5  *  Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
   6  *  Copyright 1999 Jeremy Fitzhardinge <jeremy@goop.org>
   7  *
   8  * This file is part of the Linux kernel and is made available under
   9  * the terms of the GNU General Public License, version 2, or at your
  10  * option, any later version, incorporated herein by reference.
  11  *
  12  * ------------------------------------------------------------------------- */
  13
  14 #include <linux/errno.h>
  15 #include <linux/stat.h>
  16 #include <linux/param.h>
  17 #include "autofs_i.h"
  18
  19 static struct dentry *autofs4_dir_lookup(struct inode *,struct dentry *);
  20 static int autofs4_dir_symlink(struct inode *,struct dentry *,const char *);
  21 static int autofs4_dir_unlink(struct inode *,struct dentry *);
  22 static int autofs4_dir_rmdir(struct inode *,struct dentry *);
  23 static int autofs4_dir_mkdir(struct inode *,struct dentry *,int);
  24 static int autofs4_root_ioctl(struct inode *, struct file *,unsigned int,unsigned long);
  25 static struct dentry *autofs4_root_lookup(struct inode *,struct dentry *);
  26
  27 struct file_operations autofs4_root_operations = {
  28         read:           generic_read_dir,
  29         readdir:        dcache_readdir,
  30         ioctl:          autofs4_root_ioctl,
  31 };
  32
  33 struct file_operations autofs4_dir_operations = {
  34         read:           generic_read_dir,
  35         readdir:        dcache_readdir,
  36 };
  37
  38 struct inode_operations autofs4_root_inode_operations = {
  39         lookup:         autofs4_root_lookup,
  40         unlink:         autofs4_dir_unlink,
  41         symlink:        autofs4_dir_symlink,
  42         mkdir:          autofs4_dir_mkdir,
  43         rmdir:          autofs4_dir_rmdir,
  44 };
  45
  46 struct inode_operations autofs4_dir_inode_operations = {
  47         lookup:         autofs4_dir_lookup,
  48         unlink:         autofs4_dir_unlink,
  49         symlink:        autofs4_dir_symlink,
  50         mkdir:          autofs4_dir_mkdir,
  51         rmdir:          autofs4_dir_rmdir,
  52 };
  53
  54 /* Update usage from here to top of tree, so that scan of
  55    top-level directories will give a useful result */
  56 static void autofs4_update_usage(struct dentry *dentry)
  57 {
  58         struct dentry *top = dentry->d_sb->s_root;
  59
  60         for(; dentry != top; dentry = dentry->d_parent) {
  61                 struct autofs_info *ino = autofs4_dentry_ino(dentry);
  62
  63                 if (ino) {
  64                         update_atime(dentry->d_inode);
  65                         ino->last_used = jiffies;
  66                 }
  67         }
  68 }
  69
  70 static int try_to_fill_dentry(struct dentry *dentry,
  71                               struct super_block *sb,
  72                               struct autofs_sb_info *sbi)
  73 {
  74         struct autofs_info *de_info = autofs4_dentry_ino(dentry);
  75         int status = 0;
  76
  77         /* Block on any pending expiry here; invalidate the dentry
  78            when expiration is done to trigger mount request with a new
  79            dentry */
  80         if (de_info && (de_info->flags & AUTOFS_INF_EXPIRING)) {
  81                 DPRINTK(("try_to_fill_entry: waiting for expire %p name=%.*s, flags&PENDING=%s de_info=%p de_info->flags=%x\n",
  82                          dentry, dentry->d_name.len, dentry->d_name.name,
  83                          dentry->d_flags & DCACHE_AUTOFS_PENDING?"t":"f",
  84                          de_info, de_info?de_info->flags:0));
  85                 status = autofs4_wait(sbi, &dentry->d_name, NFY_NONE);
  86
  87                 DPRINTK(("try_to_fill_entry: expire done status=%d\n", status));
  88
  89                 return 0;
  90         }
  91
  92         DPRINTK(("try_to_fill_entry: dentry=%p %.*s ino=%p\n",
  93                  dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_inode));
  94
  95         /* Wait for a pending mount, triggering one if there isn't one already */
  96         while(dentry->d_inode == NULL) {
  97                 DPRINTK(("try_to_fill_entry: waiting for mount name=%.*s, de_info=%p de_info->flags=%x\n",
  98                          dentry->d_name.len, dentry->d_name.name,
  99                          de_info, de_info?de_info->flags:0));
 100                 status = autofs4_wait(sbi, &dentry->d_name, NFY_MOUNT);
 101
 102                 DPRINTK(("try_to_fill_entry: mount done status=%d\n", status));
 103
 104                 if (status && dentry->d_inode)
 105                         return 0; /* Try to get the kernel to invalidate this dentry */
 106
 107                 /* Turn this into a real negative dentry? */
 108                 if (status == -ENOENT) {
 109                         dentry->d_time = jiffies + AUTOFS_NEGATIVE_TIMEOUT;
 110                         dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
 111                         return 1;
 112                 } else if (status) {
 113                         /* Return a negative dentry, but leave it "pending" */
 114                         return 1;
 115                 }
 116                 /* status = autofs4_wait(sbi, &dentry->d_name, NFY_MOUNT); */
 117         }
 118
 119         /* If this is an unused directory that isn't a mount point,
 120            bitch at the daemon and fix it in user space */
 121         if (S_ISDIR(dentry->d_inode->i_mode) &&
 122             !d_mountpoint(dentry) &&
 123             list_empty(&dentry->d_subdirs)) {
 124                 DPRINTK(("try_to_fill_entry: mounting existing dir\n"));
 125                 return autofs4_wait(sbi, &dentry->d_name, NFY_MOUNT) == 0;
 126         }
 127
 128         /* We don't update the usages for the autofs daemon itself, this
 129            is necessary for recursive autofs mounts */
 130         if (!autofs4_oz_mode(sbi))
 131                 autofs4_update_usage(dentry);
 132
 133         dentry->d_flags &= ~DCACHE_AUTOFS_PENDING;
 134         return 1;
 135 }
 136
 137
 138 /*
 139  * Revalidate is called on every cache lookup.  Some of those
 140  * cache lookups may actually happen while the dentry is not
 141  * yet completely filled in, and revalidate has to delay such
 142  * lookups..
 143  */
 144 static int autofs4_root_revalidate(struct dentry * dentry, int flags)
 145 {
 146         struct inode * dir = dentry->d_parent->d_inode;
 147         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
 148         struct autofs_info *ino;
 149         int oz_mode = autofs4_oz_mode(sbi);
 150
 151         /* Pending dentry */
 152         if (autofs4_ispending(dentry)) {
 153                 if (autofs4_oz_mode(sbi))
 154                         return 1;
 155                 else
 156                         return try_to_fill_dentry(dentry, dir->i_sb, sbi);
 157         }
 158
 159         /* Negative dentry.. invalidate if "old" */
 160         if (dentry->d_inode == NULL)
 161                 return (dentry->d_time - jiffies <= AUTOFS_NEGATIVE_TIMEOUT);
 162
 163         ino = autofs4_dentry_ino(dentry);
 164
 165         /* Check for a non-mountpoint directory with no contents */
 166         if (S_ISDIR(dentry->d_inode->i_mode) &&
 167             !d_mountpoint(dentry) &&
 168             list_empty(&dentry->d_subdirs)) {
 169                 DPRINTK(("autofs_root_revalidate: dentry=%p %.*s, emptydir\n",
 170                          dentry, dentry->d_name.len, dentry->d_name.name));
 171                 if (oz_mode)
 172                         return 1;
 173                 else
 174                         return try_to_fill_dentry(dentry, dir->i_sb, sbi);
 175         }
 176
 177         /* Update the usage list */
 178         if (!oz_mode)
 179                 autofs4_update_usage(dentry);
 180
 181         return 1;
 182 }
 183
 184 static int autofs4_revalidate(struct dentry *dentry, int flags)
 185 {
 186         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
 187
 188         if (!autofs4_oz_mode(sbi))
 189                 autofs4_update_usage(dentry);
 190
 191         return 1;
 192 }
 193
 194 static void autofs4_dentry_release(struct dentry *de)
 195 {
 196         struct autofs_info *inf = autofs4_dentry_ino(de);
 197
 198         DPRINTK(("autofs4_dentry_release: releasing %p\n", de));
 199
 200         de->d_fsdata = NULL;
 201         if (inf) {
 202                 inf->dentry = NULL;
 203                 inf->inode = NULL;
 204
 205                 autofs4_free_ino(inf);
 206         }
 207 }
 208
 209 /* For dentries of directories in the root dir */
 210 static struct dentry_operations autofs4_root_dentry_operations = {
 211         d_revalidate:   autofs4_root_revalidate,        /* d_revalidate */
 212         d_release:      autofs4_dentry_release,
 213 };
 214
 215 /* For other dentries */
 216 static struct dentry_operations autofs4_dentry_operations = {
 217         d_revalidate:   autofs4_revalidate,     /* d_revalidate */
 218         d_release:      autofs4_dentry_release,
 219 };
 220
 221 /* Lookups in non-root dirs never find anything - if it's there, it's
 222    already in the dcache */
 223 static struct dentry *autofs4_dir_lookup(struct inode *dir, struct dentry *dentry)
 224 {
 225 #if 0
 226         DPRINTK(("autofs_dir_lookup: ignoring lookup of %.*s/%.*s\n",
 227                  dentry->d_parent->d_name.len, dentry->d_parent->d_name.name,
 228                  dentry->d_name.len, dentry->d_name.name));
 229 #endif
 230
 231         dentry->d_fsdata = NULL;
 232         d_add(dentry, NULL);
 233         return NULL;
 234 }
 235
 236 /* Lookups in the root directory */
 237 static struct dentry *autofs4_root_lookup(struct inode *dir, struct dentry *dentry)
 238 {
 239         struct autofs_sb_info *sbi;
 240         int oz_mode;
 241
 242         DPRINTK(("autofs_root_lookup: name = %.*s\n",
 243                  dentry->d_name.len, dentry->d_name.name));
 244
 245         if (dentry->d_name.len > NAME_MAX)
 246                 return ERR_PTR(-ENAMETOOLONG);/* File name too long to exist */
 247
 248         sbi = autofs4_sbi(dir->i_sb);
 249
 250         oz_mode = autofs4_oz_mode(sbi);
 251         DPRINTK(("autofs_lookup: pid = %u, pgrp = %u, catatonic = %d, oz_mode = %d\n",
 252                  current->pid, current->pgrp, sbi->catatonic, oz_mode));
 253
 254         /*
 255          * Mark the dentry incomplete, but add it. This is needed so
 256          * that the VFS layer knows about the dentry, and we can count
 257          * on catching any lookups through the revalidate.
 258          *
 259          * Let all the hard work be done by the revalidate function that
 260          * needs to be able to do this anyway..
 261          *
 262          * We need to do this before we release the directory semaphore.
 263          */
 264         dentry->d_op = &autofs4_root_dentry_operations;
 265
 266         if (!oz_mode)
 267                 dentry->d_flags |= DCACHE_AUTOFS_PENDING;
 268         dentry->d_fsdata = NULL;
 269         d_add(dentry, NULL);
 270
 271         if (dentry->d_op && dentry->d_op->d_revalidate) {
 272                 up(&dir->i_sem);
 273                 (dentry->d_op->d_revalidate)(dentry, 0);
 274                 down(&dir->i_sem);
 275         }
 276
 277         /*
 278          * If we are still pending, check if we had to handle
 279          * a signal. If so we can force a restart..
 280          */
 281         if (dentry->d_flags & DCACHE_AUTOFS_PENDING) {
 282                 if (signal_pending(current))
 283                         return ERR_PTR(-ERESTARTNOINTR);
 284         }
 285
 286         /*
 287          * If this dentry is unhashed, then we shouldn't honour this
 288          * lookup even if the dentry is positive.  Returning ENOENT here
 289          * doesn't do the right thing for all system calls, but it should
 290          * be OK for the operations we permit from an autofs.
 291          */
 292         if ( dentry->d_inode && d_unhashed(dentry) )
 293                 return ERR_PTR(-ENOENT);
 294
 295         return NULL;
 296 }
 297
 298 static int autofs4_dir_symlink(struct inode *dir,
 299                                struct dentry *dentry,
 300                                const char *symname)
 301 {
 302         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
 303         struct autofs_info *ino = autofs4_dentry_ino(dentry);
 304         struct inode *inode;
 305         char *cp;
 306
 307         DPRINTK(("autofs_dir_symlink: %s <- %.*s\n", symname,
 308                  dentry->d_name.len, dentry->d_name.name));
 309
 310         if (!autofs4_oz_mode(sbi))
 311                 return -EACCES;
 312
 313         ino = autofs4_init_ino(ino, sbi, S_IFLNK | 0555);
 314         if (ino == NULL)
 315                 return -ENOSPC;
 316
 317         ino->size = strlen(symname);
 318         ino->u.symlink = cp = kmalloc(ino->size + 1, GFP_KERNEL);
 319
 320         if (cp == NULL) {
 321                 kfree(ino);
 322                 return -ENOSPC;
 323         }
 324
 325         strcpy(cp, symname);
 326
 327         inode = autofs4_get_inode(dir->i_sb, ino);
 328         d_instantiate(dentry, inode);
 329
 330         if (dir == dir->i_sb->s_root->d_inode)
 331                 dentry->d_op = &autofs4_root_dentry_operations;
 332         else
 333                 dentry->d_op = &autofs4_dentry_operations;
 334
 335         dentry->d_fsdata = ino;
 336         ino->dentry = dget(dentry);
 337         ino->inode = inode;
 338
 339         dir->i_mtime = CURRENT_TIME;
 340
 341         return 0;
 342 }
 343
 344 /*
 345  * NOTE!
 346  *
 347  * Normal filesystems would do a "d_delete()" to tell the VFS dcache
 348  * that the file no longer exists. However, doing that means that the
 349  * VFS layer can turn the dentry into a negative dentry.  We don't want
 350  * this, because since the unlink is probably the result of an expire.
 351  * We simply d_drop it, which allows the dentry lookup to remount it
 352  * if necessary.
 353  *
 354  * If a process is blocked on the dentry waiting for the expire to finish,
 355  * it will invalidate the dentry and try to mount with a new one.
 356  *
 357  * Also see autofs_dir_rmdir()..
 358  */
 359 static int autofs4_dir_unlink(struct inode *dir, struct dentry *dentry)
 360 {
 361         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
 362         struct autofs_info *ino = autofs4_dentry_ino(dentry);
 363
 364         /* This allows root to remove symlinks */
 365         if ( !autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN) )
 366                 return -EACCES;
 367
 368         dput(ino->dentry);
 369
 370         dentry->d_inode->i_size = 0;
 371         dentry->d_inode->i_nlink = 0;
 372
 373         dir->i_mtime = CURRENT_TIME;
 374
 375         DPRINTK(("autofs_dir_unlink: unlinking %p %.*s, count=%d\n",
 376                 dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_count));
 377
 378         d_drop(dentry);
 379
 380         return 0;
 381 }
 382
 383 static int autofs4_dir_rmdir(struct inode *dir, struct dentry *dentry)
 384 {
 385         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
 386         struct autofs_info *ino = autofs4_dentry_ino(dentry);
 387
 388         if (!autofs4_oz_mode(sbi))
 389                 return -EACCES;
 390
 391         if (!list_empty(&dentry->d_subdirs))
 392                 return -ENOTEMPTY;
 393
 394         dput(ino->dentry);
 395
 396         dentry->d_inode->i_size = 0;
 397         dentry->d_inode->i_nlink = 0;
 398
 399         if (dir->i_nlink)
 400                 dir->i_nlink--;
 401
 402         DPRINTK(("autofs_dir_rmdir: rmdir %p %.*s, count=%d\n",
 403                 dentry, dentry->d_name.len, dentry->d_name.name, dentry->d_count));
 404
 405         d_drop(dentry);
 406
 407         return 0;
 408 }
 409
 410
 411
 412 static int autofs4_dir_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 413 {
 414         struct autofs_sb_info *sbi = autofs4_sbi(dir->i_sb);
 415         struct autofs_info *ino = autofs4_dentry_ino(dentry);
 416         struct inode *inode;
 417
 418         if ( !autofs4_oz_mode(sbi) )
 419                 return -EACCES;
 420
 421         DPRINTK(("autofs_dir_mkdir: dentry %p, creating %.*s\n",
 422                  dentry, dentry->d_name.len, dentry->d_name.name));
 423
 424         ino = autofs4_init_ino(ino, sbi, S_IFDIR | 0555);
 425         if (ino == NULL)
 426                 return -ENOSPC;
 427
 428         inode = autofs4_get_inode(dir->i_sb, ino);
 429         d_instantiate(dentry, inode);
 430
 431         if (dir == dir->i_sb->s_root->d_inode)
 432                 dentry->d_op = &autofs4_root_dentry_operations;
 433         else
 434                 dentry->d_op = &autofs4_dentry_operations;
 435
 436         dentry->d_fsdata = ino;
 437         ino->dentry = dget(dentry);
 438         ino->inode = inode;
 439         dir->i_nlink++;
 440         dir->i_mtime = CURRENT_TIME;
 441
 442         return 0;
 443 }
 444
 445 /* Get/set timeout ioctl() operation */
 446 static inline int autofs4_get_set_timeout(struct autofs_sb_info *sbi,
 447                                          unsigned long *p)
 448 {
 449         int rv;
 450         unsigned long ntimeout;
 451
 452         if ( (rv = get_user(ntimeout, p)) ||
 453              (rv = put_user(sbi->exp_timeout/HZ, p)) )
 454                 return rv;
 455
 456         if ( ntimeout > ULONG_MAX/HZ )
 457                 sbi->exp_timeout = 0;
 458         else
 459                 sbi->exp_timeout = ntimeout * HZ;
 460
 461         return 0;
 462 }
 463
 464 /* Return protocol version */
 465 static inline int autofs4_get_protover(struct autofs_sb_info *sbi, int *p)
 466 {
 467         return put_user(sbi->version, p);
 468 }
 469
 470 /* Identify autofs_dentries - this is so we can tell if there's
 471    an extra dentry refcount or not.  We only hold a refcount on the
 472    dentry if its non-negative (ie, d_inode != NULL)
 473 */
 474 int is_autofs4_dentry(struct dentry *dentry)
 475 {
 476         return dentry && dentry->d_inode &&
 477                 (dentry->d_op == &autofs4_root_dentry_operations ||
 478                  dentry->d_op == &autofs4_dentry_operations) &&
 479                 dentry->d_fsdata != NULL;
 480 }
 481
 482 /*
 483  * ioctl()'s on the root directory is the chief method for the daemon to
 484  * generate kernel reactions
 485  */
 486 static int autofs4_root_ioctl(struct inode *inode, struct file *filp,
 487                              unsigned int cmd, unsigned long arg)
 488 {
 489         struct autofs_sb_info *sbi = autofs4_sbi(inode->i_sb);
 490
 491         DPRINTK(("autofs_ioctl: cmd = 0x%08x, arg = 0x%08lx, sbi = %p, pgrp = %u\n",
 492                  cmd,arg,sbi,current->pgrp));
 493
 494         if ( _IOC_TYPE(cmd) != _IOC_TYPE(AUTOFS_IOC_FIRST) ||
 495              _IOC_NR(cmd) - _IOC_NR(AUTOFS_IOC_FIRST) >= AUTOFS_IOC_COUNT )
 496                 return -ENOTTY;
 497
 498         if ( !autofs4_oz_mode(sbi) && !capable(CAP_SYS_ADMIN) )
 499                 return -EPERM;
 500
 501         switch(cmd) {
 502         case AUTOFS_IOC_READY:  /* Wait queue: go ahead and retry */
 503                 return autofs4_wait_release(sbi,(autofs_wqt_t)arg,0);
 504         case AUTOFS_IOC_FAIL:   /* Wait queue: fail with ENOENT */
 505                 return autofs4_wait_release(sbi,(autofs_wqt_t)arg,-ENOENT);
 506         case AUTOFS_IOC_CATATONIC: /* Enter catatonic mode (daemon shutdown) */
 507                 autofs4_catatonic_mode(sbi);
 508                 return 0;
 509         case AUTOFS_IOC_PROTOVER: /* Get protocol version */
 510                 return autofs4_get_protover(sbi, (int *)arg);
 511         case AUTOFS_IOC_SETTIMEOUT:
 512                 return autofs4_get_set_timeout(sbi,(unsigned long *)arg);
 513
 514         /* return a single thing to expire */
 515         case AUTOFS_IOC_EXPIRE:
 516                 return autofs4_expire_run(inode->i_sb,filp->f_vfsmnt,sbi,
 517                                          (struct autofs_packet_expire *)arg);
 518         /* same as above, but can send multiple expires through pipe */
 519         case AUTOFS_IOC_EXPIRE_MULTI:
 520                 return autofs4_expire_multi(inode->i_sb,filp->f_vfsmnt,sbi,
 521                                         (int *)arg);
 522
 523         default:
 524                 return -ENOSYS;
 525         }
 526 }