fs/autofs/expire.c

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