fs/autofs4/expire.c

   1 /*
   2  * Copyright 1997-1998 Transmeta Corporation -- All Rights Reserved
   3  * Copyright 1999-2000 Jeremy Fitzhardinge <jeremy@goop.org>
   4  * Copyright 2001-2006 Ian Kent <raven@themaw.net>
   5  *
   6  * This file is part of the Linux kernel and is made available under
   7  * the terms of the GNU General Public License, version 2, or at your
   8  * option, any later version, incorporated herein by reference.
   9  */
  10
  11 #include "autofs_i.h"
  12
  13 static unsigned long now;
  14
  15 /* Check if a dentry can be expired */
  16 static inline int autofs4_can_expire(struct dentry *dentry,
  17                                      unsigned long timeout, int do_now)
  18 {
  19         struct autofs_info *ino = autofs4_dentry_ino(dentry);
  20
  21         /* dentry in the process of being deleted */
  22         if (ino == NULL)
  23                 return 0;
  24
  25         if (!do_now) {
  26                 /* Too young to die */
  27                 if (!timeout || time_after(ino->last_used + timeout, now))
  28                         return 0;
  29         }
  30         return 1;
  31 }
  32
  33 /* Check a mount point for busyness */
  34 static int autofs4_mount_busy(struct vfsmount *mnt, struct dentry *dentry)
  35 {
  36         struct dentry *top = dentry;
  37         struct path path = {.mnt = mnt, .dentry = dentry};
  38         int status = 1;
  39
  40         pr_debug("dentry %p %pd\n", dentry, dentry);
  41
  42         path_get(&path);
  43
  44         if (!follow_down_one(&path))
  45                 goto done;
  46
  47         if (is_autofs4_dentry(path.dentry)) {
  48                 struct autofs_sb_info *sbi = autofs4_sbi(path.dentry->d_sb);
  49
  50                 /* This is an autofs submount, we can't expire it */
  51                 if (autofs_type_indirect(sbi->type))
  52                         goto done;
  53         }
  54
  55         /* Update the expiry counter if fs is busy */
  56         if (!may_umount_tree(path.mnt)) {
  57                 struct autofs_info *ino;
  58
  59                 ino = autofs4_dentry_ino(top);
  60                 ino->last_used = jiffies;
  61                 goto done;
  62         }
  63
  64         status = 0;
  65 done:
  66         pr_debug("returning = %d\n", status);
  67         path_put(&path);
  68         return status;
  69 }
  70
  71 /*
  72  * Calculate and dget next entry in the subdirs list under root.
  73  */
  74 static struct dentry *get_next_positive_subdir(struct dentry *prev,
  75                                                struct dentry *root)
  76 {
  77         struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);
  78         struct list_head *next;
  79         struct dentry *q;
  80
  81         spin_lock(&sbi->lookup_lock);
  82         spin_lock(&root->d_lock);
  83
  84         if (prev)
  85                 next = prev->d_child.next;
  86         else {
  87                 prev = dget_dlock(root);
  88                 next = prev->d_subdirs.next;
  89         }
  90
  91 cont:
  92         if (next == &root->d_subdirs) {
  93                 spin_unlock(&root->d_lock);
  94                 spin_unlock(&sbi->lookup_lock);
  95                 dput(prev);
  96                 return NULL;
  97         }
  98
  99         q = list_entry(next, struct dentry, d_child);
 100
 101         spin_lock_nested(&q->d_lock, DENTRY_D_LOCK_NESTED);
 102         /* Already gone or negative dentry (under construction) - try next */
 103         if (!d_count(q) || !simple_positive(q)) {
 104                 spin_unlock(&q->d_lock);
 105                 next = q->d_child.next;
 106                 goto cont;
 107         }
 108         dget_dlock(q);
 109         spin_unlock(&q->d_lock);
 110         spin_unlock(&root->d_lock);
 111         spin_unlock(&sbi->lookup_lock);
 112
 113         dput(prev);
 114
 115         return q;
 116 }
 117
 118 /*
 119  * Calculate and dget next entry in top down tree traversal.
 120  */
 121 static struct dentry *get_next_positive_dentry(struct dentry *prev,
 122                                                struct dentry *root)
 123 {
 124         struct autofs_sb_info *sbi = autofs4_sbi(root->d_sb);
 125         struct list_head *next;
 126         struct dentry *p, *ret;
 127
 128         if (prev == NULL)
 129                 return dget(root);
 130
 131         spin_lock(&sbi->lookup_lock);
 132 relock:
 133         p = prev;
 134         spin_lock(&p->d_lock);
 135 again:
 136         next = p->d_subdirs.next;
 137         if (next == &p->d_subdirs) {
 138                 while (1) {
 139                         struct dentry *parent;
 140
 141                         if (p == root) {
 142                                 spin_unlock(&p->d_lock);
 143                                 spin_unlock(&sbi->lookup_lock);
 144                                 dput(prev);
 145                                 return NULL;
 146                         }
 147
 148                         parent = p->d_parent;
 149                         if (!spin_trylock(&parent->d_lock)) {
 150                                 spin_unlock(&p->d_lock);
 151                                 cpu_relax();
 152                                 goto relock;
 153                         }
 154                         spin_unlock(&p->d_lock);
 155                         next = p->d_child.next;
 156                         p = parent;
 157                         if (next != &parent->d_subdirs)
 158                                 break;
 159                 }
 160         }
 161         ret = list_entry(next, struct dentry, d_child);
 162
 163         spin_lock_nested(&ret->d_lock, DENTRY_D_LOCK_NESTED);
 164         /* Negative dentry - try next */
 165         if (!simple_positive(ret)) {
 166                 spin_unlock(&p->d_lock);
 167                 lock_set_subclass(&ret->d_lock.dep_map, 0, _RET_IP_);
 168                 p = ret;
 169                 goto again;
 170         }
 171         dget_dlock(ret);
 172         spin_unlock(&ret->d_lock);
 173         spin_unlock(&p->d_lock);
 174         spin_unlock(&sbi->lookup_lock);
 175
 176         dput(prev);
 177
 178         return ret;
 179 }
 180
 181 /*
 182  * Check a direct mount point for busyness.
 183  * Direct mounts have similar expiry semantics to tree mounts.
 184  * The tree is not busy iff no mountpoints are busy and there are no
 185  * autofs submounts.
 186  */
 187 static int autofs4_direct_busy(struct vfsmount *mnt,
 188                                struct dentry *top,
 189                                unsigned long timeout,
 190                                int do_now)
 191 {
 192         pr_debug("top %p %pd\n", top, top);
 193
 194         /* If it's busy update the expiry counters */
 195         if (!may_umount_tree(mnt)) {
 196                 struct autofs_info *ino;
 197
 198                 ino = autofs4_dentry_ino(top);
 199                 if (ino)
 200                         ino->last_used = jiffies;
 201                 return 1;
 202         }
 203
 204         /* Timeout of a direct mount is determined by its top dentry */
 205         if (!autofs4_can_expire(top, timeout, do_now))
 206                 return 1;
 207
 208         return 0;
 209 }
 210
 211 /*
 212  * Check a directory tree of mount points for busyness
 213  * The tree is not busy iff no mountpoints are busy
 214  */
 215 static int autofs4_tree_busy(struct vfsmount *mnt,
 216                              struct dentry *top,
 217                              unsigned long timeout,
 218                              int do_now)
 219 {
 220         struct autofs_info *top_ino = autofs4_dentry_ino(top);
 221         struct dentry *p;
 222
 223         pr_debug("top %p %pd\n", top, top);
 224
 225         /* Negative dentry - give up */
 226         if (!simple_positive(top))
 227                 return 1;
 228
 229         p = NULL;
 230         while ((p = get_next_positive_dentry(p, top))) {
 231                 pr_debug("dentry %p %pd\n", p, p);
 232
 233                 /*
 234                  * Is someone visiting anywhere in the subtree ?
 235                  * If there's no mount we need to check the usage
 236                  * count for the autofs dentry.
 237                  * If the fs is busy update the expiry counter.
 238                  */
 239                 if (d_mountpoint(p)) {
 240                         if (autofs4_mount_busy(mnt, p)) {
 241                                 top_ino->last_used = jiffies;
 242                                 dput(p);
 243                                 return 1;
 244                         }
 245                 } else {
 246                         struct autofs_info *ino = autofs4_dentry_ino(p);
 247                         unsigned int ino_count = atomic_read(&ino->count);
 248
 249                         /* allow for dget above and top is already dgot */
 250                         if (p == top)
 251                                 ino_count += 2;
 252                         else
 253                                 ino_count++;
 254
 255                         if (d_count(p) > ino_count) {
 256                                 top_ino->last_used = jiffies;
 257                                 dput(p);
 258                                 return 1;
 259                         }
 260                 }
 261         }
 262
 263         /* Timeout of a tree mount is ultimately determined by its top dentry */
 264         if (!autofs4_can_expire(top, timeout, do_now))
 265                 return 1;
 266
 267         return 0;
 268 }
 269
 270 static struct dentry *autofs4_check_leaves(struct vfsmount *mnt,
 271                                            struct dentry *parent,
 272                                            unsigned long timeout,
 273                                            int do_now)
 274 {
 275         struct dentry *p;
 276
 277         pr_debug("parent %p %pd\n", parent, parent);
 278
 279         p = NULL;
 280         while ((p = get_next_positive_dentry(p, parent))) {
 281                 pr_debug("dentry %p %pd\n", p, p);
 282
 283                 if (d_mountpoint(p)) {
 284                         /* Can we umount this guy */
 285                         if (autofs4_mount_busy(mnt, p))
 286                                 continue;
 287
 288                         /* Can we expire this guy */
 289                         if (autofs4_can_expire(p, timeout, do_now))
 290                                 return p;
 291                 }
 292         }
 293         return NULL;
 294 }
 295
 296 /* Check if we can expire a direct mount (possibly a tree) */
 297 struct dentry *autofs4_expire_direct(struct super_block *sb,
 298                                      struct vfsmount *mnt,
 299                                      struct autofs_sb_info *sbi,
 300                                      int how)
 301 {
 302         unsigned long timeout;
 303         struct dentry *root = dget(sb->s_root);
 304         int do_now = how & AUTOFS_EXP_IMMEDIATE;
 305         struct autofs_info *ino;
 306
 307         if (!root)
 308                 return NULL;
 309
 310         now = jiffies;
 311         timeout = sbi->exp_timeout;
 312
 313         spin_lock(&sbi->fs_lock);
 314         ino = autofs4_dentry_ino(root);
 315         /* No point expiring a pending mount */
 316         if (ino->flags & AUTOFS_INF_PENDING)
 317                 goto out;
 318         if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
 319                 ino->flags |= AUTOFS_INF_NO_RCU;
 320                 spin_unlock(&sbi->fs_lock);
 321                 synchronize_rcu();
 322                 spin_lock(&sbi->fs_lock);
 323                 if (!autofs4_direct_busy(mnt, root, timeout, do_now)) {
 324                         ino->flags |= AUTOFS_INF_EXPIRING;
 325                         smp_mb();
 326                         ino->flags &= ~AUTOFS_INF_NO_RCU;
 327                         init_completion(&ino->expire_complete);
 328                         spin_unlock(&sbi->fs_lock);
 329                         return root;
 330                 }
 331                 ino->flags &= ~AUTOFS_INF_NO_RCU;
 332         }
 333 out:
 334         spin_unlock(&sbi->fs_lock);
 335         dput(root);
 336
 337         return NULL;
 338 }
 339
 340 /* Check if 'dentry' should expire, or return a nearby
 341  * dentry that is suitable.
 342  * If returned dentry is different from arg dentry,
 343  * then a dget() reference was taken, else not.
 344  */
 345 static struct dentry *should_expire(struct dentry *dentry,
 346                                     struct vfsmount *mnt,
 347                                     unsigned long timeout,
 348                                     int how)
 349 {
 350         int do_now = how & AUTOFS_EXP_IMMEDIATE;
 351         int exp_leaves = how & AUTOFS_EXP_LEAVES;
 352         struct autofs_info *ino = autofs4_dentry_ino(dentry);
 353         unsigned int ino_count;
 354
 355         /* No point expiring a pending mount */
 356         if (ino->flags & AUTOFS_INF_PENDING)
 357                 return NULL;
 358
 359         /*
 360          * Case 1: (i) indirect mount or top level pseudo direct mount
 361          *         (autofs-4.1).
 362          *         (ii) indirect mount with offset mount, check the "/"
 363          *         offset (autofs-5.0+).
 364          */
 365         if (d_mountpoint(dentry)) {
 366                 pr_debug("checking mountpoint %p %pd\n", dentry, dentry);
 367
 368                 /* Can we umount this guy */
 369                 if (autofs4_mount_busy(mnt, dentry))
 370                         return NULL;
 371
 372                 /* Can we expire this guy */
 373                 if (autofs4_can_expire(dentry, timeout, do_now))
 374                         return dentry;
 375                 return NULL;
 376         }
 377
 378         if (d_really_is_positive(dentry) && d_is_symlink(dentry)) {
 379                 pr_debug("checking symlink %p %pd\n", dentry, dentry);
 380                 /*
 381                  * A symlink can't be "busy" in the usual sense so
 382                  * just check last used for expire timeout.
 383                  */
 384                 if (autofs4_can_expire(dentry, timeout, do_now))
 385                         return dentry;
 386                 return NULL;
 387         }
 388
 389         if (simple_empty(dentry))
 390                 return NULL;
 391
 392         /* Case 2: tree mount, expire iff entire tree is not busy */
 393         if (!exp_leaves) {
 394                 /* Path walk currently on this dentry? */
 395                 ino_count = atomic_read(&ino->count) + 1;
 396                 if (d_count(dentry) > ino_count)
 397                         return NULL;
 398
 399                 if (!autofs4_tree_busy(mnt, dentry, timeout, do_now))
 400                         return dentry;
 401         /*
 402          * Case 3: pseudo direct mount, expire individual leaves
 403          *         (autofs-4.1).
 404          */
 405         } else {
 406                 /* Path walk currently on this dentry? */
 407                 struct dentry *expired;
 408
 409                 ino_count = atomic_read(&ino->count) + 1;
 410                 if (d_count(dentry) > ino_count)
 411                         return NULL;
 412
 413                 expired = autofs4_check_leaves(mnt, dentry, timeout, do_now);
 414                 if (expired) {
 415                         if (expired == dentry)
 416                                 dput(dentry);
 417                         return expired;
 418                 }
 419         }
 420         return NULL;
 421 }
 422 /*
 423  * Find an eligible tree to time-out
 424  * A tree is eligible if :-
 425  *  - it is unused by any user process
 426  *  - it has been unused for exp_timeout time
 427  */
 428 struct dentry *autofs4_expire_indirect(struct super_block *sb,
 429                                        struct vfsmount *mnt,
 430                                        struct autofs_sb_info *sbi,
 431                                        int how)
 432 {
 433         unsigned long timeout;
 434         struct dentry *root = sb->s_root;
 435         struct dentry *dentry;
 436         struct dentry *expired;
 437         struct autofs_info *ino;
 438
 439         if (!root)
 440                 return NULL;
 441
 442         now = jiffies;
 443         timeout = sbi->exp_timeout;
 444
 445         dentry = NULL;
 446         while ((dentry = get_next_positive_subdir(dentry, root))) {
 447                 spin_lock(&sbi->fs_lock);
 448                 ino = autofs4_dentry_ino(dentry);
 449                 if (ino->flags & AUTOFS_INF_NO_RCU)
 450                         expired = NULL;
 451                 else
 452                         expired = should_expire(dentry, mnt, timeout, how);
 453                 if (!expired) {
 454                         spin_unlock(&sbi->fs_lock);
 455                         continue;
 456                 }
 457                 ino = autofs4_dentry_ino(expired);
 458                 ino->flags |= AUTOFS_INF_NO_RCU;
 459                 spin_unlock(&sbi->fs_lock);
 460                 synchronize_rcu();
 461                 spin_lock(&sbi->fs_lock);
 462                 if (should_expire(expired, mnt, timeout, how)) {
 463                         if (expired != dentry)
 464                                 dput(dentry);
 465                         goto found;
 466                 }
 467
 468                 ino->flags &= ~AUTOFS_INF_NO_RCU;
 469                 if (expired != dentry)
 470                         dput(expired);
 471                 spin_unlock(&sbi->fs_lock);
 472         }
 473         return NULL;
 474
 475 found:
 476         pr_debug("returning %p %pd\n", expired, expired);
 477         ino->flags |= AUTOFS_INF_EXPIRING;
 478         smp_mb();
 479         ino->flags &= ~AUTOFS_INF_NO_RCU;
 480         init_completion(&ino->expire_complete);
 481         spin_unlock(&sbi->fs_lock);
 482         spin_lock(&sbi->lookup_lock);
 483         spin_lock(&expired->d_parent->d_lock);
 484         spin_lock_nested(&expired->d_lock, DENTRY_D_LOCK_NESTED);
 485         list_move(&expired->d_parent->d_subdirs, &expired->d_child);
 486         spin_unlock(&expired->d_lock);
 487         spin_unlock(&expired->d_parent->d_lock);
 488         spin_unlock(&sbi->lookup_lock);
 489         return expired;
 490 }
 491
 492 int autofs4_expire_wait(struct dentry *dentry, int rcu_walk)
 493 {
 494         struct autofs_sb_info *sbi = autofs4_sbi(dentry->d_sb);
 495         struct autofs_info *ino = autofs4_dentry_ino(dentry);
 496         int status;
 497
 498         /* Block on any pending expire */
 499         if (!(ino->flags & (AUTOFS_INF_EXPIRING | AUTOFS_INF_NO_RCU)))
 500                 return 0;
 501         if (rcu_walk)
 502                 return -ECHILD;
 503
 504         spin_lock(&sbi->fs_lock);
 505         if (ino->flags & AUTOFS_INF_EXPIRING) {
 506                 spin_unlock(&sbi->fs_lock);
 507
 508                 pr_debug("waiting for expire %p name=%pd\n", dentry, dentry);
 509
 510                 status = autofs4_wait(sbi, dentry, NFY_NONE);
 511                 wait_for_completion(&ino->expire_complete);
 512
 513                 pr_debug("expire done status=%d\n", status);
 514
 515                 if (d_unhashed(dentry))
 516                         return -EAGAIN;
 517
 518                 return status;
 519         }
 520         spin_unlock(&sbi->fs_lock);
 521
 522         return 0;
 523 }
 524
 525 /* Perform an expiry operation */
 526 int autofs4_expire_run(struct super_block *sb,
 527                        struct vfsmount *mnt,
 528                        struct autofs_sb_info *sbi,
 529                        struct autofs_packet_expire __user *pkt_p)
 530 {
 531         struct autofs_packet_expire pkt;
 532         struct autofs_info *ino;
 533         struct dentry *dentry;
 534         int ret = 0;
 535
 536         memset(&pkt, 0, sizeof(pkt));
 537
 538         pkt.hdr.proto_version = sbi->version;
 539         pkt.hdr.type = autofs_ptype_expire;
 540
 541         dentry = autofs4_expire_indirect(sb, mnt, sbi, 0);
 542         if (!dentry)
 543                 return -EAGAIN;
 544
 545         pkt.len = dentry->d_name.len;
 546         memcpy(pkt.name, dentry->d_name.name, pkt.len);
 547         pkt.name[pkt.len] = '\0';
 548         dput(dentry);
 549
 550         if (copy_to_user(pkt_p, &pkt, sizeof(struct autofs_packet_expire)))
 551                 ret = -EFAULT;
 552
 553         spin_lock(&sbi->fs_lock);
 554         ino = autofs4_dentry_ino(dentry);
 555         /* avoid rapid-fire expire attempts if expiry fails */
 556         ino->last_used = now;
 557         ino->flags &= ~AUTOFS_INF_EXPIRING;
 558         complete_all(&ino->expire_complete);
 559         spin_unlock(&sbi->fs_lock);
 560
 561         return ret;
 562 }
 563
 564 int autofs4_do_expire_multi(struct super_block *sb, struct vfsmount *mnt,
 565                             struct autofs_sb_info *sbi, int when)
 566 {
 567         struct dentry *dentry;
 568         int ret = -EAGAIN;
 569
 570         if (autofs_type_trigger(sbi->type))
 571                 dentry = autofs4_expire_direct(sb, mnt, sbi, when);
 572         else
 573                 dentry = autofs4_expire_indirect(sb, mnt, sbi, when);
 574
 575         if (dentry) {
 576                 struct autofs_info *ino = autofs4_dentry_ino(dentry);
 577
 578                 /* This is synchronous because it makes the daemon a
 579                  * little easier
 580                  */
 581                 ret = autofs4_wait(sbi, dentry, NFY_EXPIRE);
 582
 583                 spin_lock(&sbi->fs_lock);
 584                 /* avoid rapid-fire expire attempts if expiry fails */
 585                 ino->last_used = now;
 586                 ino->flags &= ~AUTOFS_INF_EXPIRING;
 587                 complete_all(&ino->expire_complete);
 588                 spin_unlock(&sbi->fs_lock);
 589                 dput(dentry);
 590         }
 591
 592         return ret;
 593 }
 594
 595 /*
 596  * Call repeatedly until it returns -EAGAIN, meaning there's nothing
 597  * more to be done.
 598  */
 599 int autofs4_expire_multi(struct super_block *sb, struct vfsmount *mnt,
 600                         struct autofs_sb_info *sbi, int __user *arg)
 601 {
 602         int do_now = 0;
 603
 604         if (arg && get_user(do_now, arg))
 605                 return -EFAULT;
 606
 607         return autofs4_do_expire_multi(sb, mnt, sbi, do_now);
 608 }
 609