LCOV - code coverage report
Current view: top level - fs/autofs - expire.c (source / functions) Hit Total Coverage
Test: Real Lines: 0 180 0.0 %
Date: 2020-10-17 15:46:43 Functions: 0 14 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

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

Generated by: LCOV version 1.14