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