LCOV - code coverage report
Current view: top level - fs/autofs - waitq.c (source / functions) Hit Total Coverage
Test: gcov_data_raspi2_real_modules_combined.info Lines: 0 214 0.0 %
Date: 2020-09-30 20:25:40 Functions: 0 8 0.0 %
Branches: 0 139 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 2001-2006 Ian Kent <raven@themaw.net>
       5                 :            :  */
       6                 :            : 
       7                 :            : #include <linux/sched/signal.h>
       8                 :            : #include "autofs_i.h"
       9                 :            : 
      10                 :            : /* We make this a static variable rather than a part of the superblock; it
      11                 :            :  * is better if we don't reassign numbers easily even across filesystems
      12                 :            :  */
      13                 :            : static autofs_wqt_t autofs_next_wait_queue = 1;
      14                 :            : 
      15                 :          0 : void autofs_catatonic_mode(struct autofs_sb_info *sbi)
      16                 :            : {
      17                 :            :         struct autofs_wait_queue *wq, *nwq;
      18                 :            : 
      19                 :          0 :         mutex_lock(&sbi->wq_mutex);
      20         [ #  # ]:          0 :         if (sbi->flags & AUTOFS_SBI_CATATONIC) {
      21                 :          0 :                 mutex_unlock(&sbi->wq_mutex);
      22                 :          0 :                 return;
      23                 :            :         }
      24                 :            : 
      25                 :            :         pr_debug("entering catatonic mode\n");
      26                 :            : 
      27                 :          0 :         sbi->flags |= AUTOFS_SBI_CATATONIC;
      28                 :          0 :         wq = sbi->queues;
      29                 :          0 :         sbi->queues = NULL;  /* Erase all wait queues */
      30         [ #  # ]:          0 :         while (wq) {
      31                 :          0 :                 nwq = wq->next;
      32                 :          0 :                 wq->status = -ENOENT; /* Magic is gone - report failure */
      33                 :          0 :                 kfree(wq->name.name);
      34                 :          0 :                 wq->name.name = NULL;
      35                 :          0 :                 wq->wait_ctr--;
      36                 :          0 :                 wake_up_interruptible(&wq->queue);
      37                 :            :                 wq = nwq;
      38                 :            :         }
      39                 :          0 :         fput(sbi->pipe);     /* Close the pipe */
      40                 :          0 :         sbi->pipe = NULL;
      41                 :          0 :         sbi->pipefd = -1;
      42                 :          0 :         mutex_unlock(&sbi->wq_mutex);
      43                 :            : }
      44                 :            : 
      45                 :          0 : static int autofs_write(struct autofs_sb_info *sbi,
      46                 :            :                         struct file *file, const void *addr, int bytes)
      47                 :            : {
      48                 :            :         unsigned long sigpipe, flags;
      49                 :            :         const char *data = (const char *)addr;
      50                 :            :         ssize_t wr = 0;
      51                 :            : 
      52                 :          0 :         sigpipe = sigismember(&current->pending.signal, SIGPIPE);
      53                 :            : 
      54                 :          0 :         mutex_lock(&sbi->pipe_mutex);
      55         [ #  # ]:          0 :         while (bytes) {
      56                 :          0 :                 wr = __kernel_write(file, data, bytes, &file->f_pos);
      57         [ #  # ]:          0 :                 if (wr <= 0)
      58                 :            :                         break;
      59                 :          0 :                 data += wr;
      60                 :          0 :                 bytes -= wr;
      61                 :            :         }
      62                 :          0 :         mutex_unlock(&sbi->pipe_mutex);
      63                 :            : 
      64                 :            :         /* Keep the currently executing process from receiving a
      65                 :            :          * SIGPIPE unless it was already supposed to get one
      66                 :            :          */
      67         [ #  # ]:          0 :         if (wr == -EPIPE && !sigpipe) {
      68                 :          0 :                 spin_lock_irqsave(&current->sighand->siglock, flags);
      69                 :          0 :                 sigdelset(&current->pending.signal, SIGPIPE);
      70                 :          0 :                 recalc_sigpending();
      71                 :          0 :                 spin_unlock_irqrestore(&current->sighand->siglock, flags);
      72                 :            :         }
      73                 :            : 
      74                 :            :         /* if 'wr' returned 0 (impossible) we assume -EIO (safe) */
      75   [ #  #  #  # ]:          0 :         return bytes == 0 ? 0 : wr < 0 ? wr : -EIO;
      76                 :            : }
      77                 :            : 
      78                 :          0 : static void autofs_notify_daemon(struct autofs_sb_info *sbi,
      79                 :            :                                  struct autofs_wait_queue *wq,
      80                 :            :                                  int type)
      81                 :            : {
      82                 :            :         union {
      83                 :            :                 struct autofs_packet_hdr hdr;
      84                 :            :                 union autofs_packet_union v4_pkt;
      85                 :            :                 union autofs_v5_packet_union v5_pkt;
      86                 :            :         } pkt;
      87                 :            :         struct file *pipe = NULL;
      88                 :            :         size_t pktsz;
      89                 :            :         int ret;
      90                 :            : 
      91                 :            :         pr_debug("wait id = 0x%08lx, name = %.*s, type=%d\n",
      92                 :            :                  (unsigned long) wq->wait_queue_token,
      93                 :            :                  wq->name.len, wq->name.name, type);
      94                 :            : 
      95                 :          0 :         memset(&pkt, 0, sizeof(pkt)); /* For security reasons */
      96                 :            : 
      97                 :          0 :         pkt.hdr.proto_version = sbi->version;
      98                 :          0 :         pkt.hdr.type = type;
      99                 :            : 
     100   [ #  #  #  # ]:          0 :         switch (type) {
     101                 :            :         /* Kernel protocol v4 missing and expire packets */
     102                 :            :         case autofs_ptype_missing:
     103                 :            :         {
     104                 :            :                 struct autofs_packet_missing *mp = &pkt.v4_pkt.missing;
     105                 :            : 
     106                 :            :                 pktsz = sizeof(*mp);
     107                 :            : 
     108                 :          0 :                 mp->wait_queue_token = wq->wait_queue_token;
     109                 :          0 :                 mp->len = wq->name.len;
     110                 :          0 :                 memcpy(mp->name, wq->name.name, wq->name.len);
     111                 :          0 :                 mp->name[wq->name.len] = '\0';
     112                 :          0 :                 break;
     113                 :            :         }
     114                 :            :         case autofs_ptype_expire_multi:
     115                 :            :         {
     116                 :            :                 struct autofs_packet_expire_multi *ep =
     117                 :            :                                         &pkt.v4_pkt.expire_multi;
     118                 :            : 
     119                 :            :                 pktsz = sizeof(*ep);
     120                 :            : 
     121                 :          0 :                 ep->wait_queue_token = wq->wait_queue_token;
     122                 :          0 :                 ep->len = wq->name.len;
     123                 :          0 :                 memcpy(ep->name, wq->name.name, wq->name.len);
     124                 :          0 :                 ep->name[wq->name.len] = '\0';
     125                 :          0 :                 break;
     126                 :            :         }
     127                 :            :         /*
     128                 :            :          * Kernel protocol v5 packet for handling indirect and direct
     129                 :            :          * mount missing and expire requests
     130                 :            :          */
     131                 :            :         case autofs_ptype_missing_indirect:
     132                 :            :         case autofs_ptype_expire_indirect:
     133                 :            :         case autofs_ptype_missing_direct:
     134                 :            :         case autofs_ptype_expire_direct:
     135                 :            :         {
     136                 :            :                 struct autofs_v5_packet *packet = &pkt.v5_pkt.v5_packet;
     137                 :          0 :                 struct user_namespace *user_ns = sbi->pipe->f_cred->user_ns;
     138                 :            : 
     139                 :            :                 pktsz = sizeof(*packet);
     140                 :            : 
     141                 :          0 :                 packet->wait_queue_token = wq->wait_queue_token;
     142                 :          0 :                 packet->len = wq->name.len;
     143                 :          0 :                 memcpy(packet->name, wq->name.name, wq->name.len);
     144                 :          0 :                 packet->name[wq->name.len] = '\0';
     145                 :          0 :                 packet->dev = wq->dev;
     146                 :          0 :                 packet->ino = wq->ino;
     147                 :          0 :                 packet->uid = from_kuid_munged(user_ns, wq->uid);
     148                 :          0 :                 packet->gid = from_kgid_munged(user_ns, wq->gid);
     149                 :          0 :                 packet->pid = wq->pid;
     150                 :          0 :                 packet->tgid = wq->tgid;
     151                 :          0 :                 break;
     152                 :            :         }
     153                 :            :         default:
     154                 :          0 :                 pr_warn("bad type %d!\n", type);
     155                 :          0 :                 mutex_unlock(&sbi->wq_mutex);
     156                 :          0 :                 return;
     157                 :            :         }
     158                 :            : 
     159                 :          0 :         pipe = get_file(sbi->pipe);
     160                 :            : 
     161                 :          0 :         mutex_unlock(&sbi->wq_mutex);
     162                 :            : 
     163      [ #  #  # ]:          0 :         switch (ret = autofs_write(sbi, pipe, &pkt, pktsz)) {
     164                 :            :         case 0:
     165                 :            :                 break;
     166                 :            :         case -ENOMEM:
     167                 :            :         case -ERESTARTSYS:
     168                 :            :                 /* Just fail this one */
     169                 :          0 :                 autofs_wait_release(sbi, wq->wait_queue_token, ret);
     170                 :          0 :                 break;
     171                 :            :         default:
     172                 :          0 :                 autofs_catatonic_mode(sbi);
     173                 :          0 :                 break;
     174                 :            :         }
     175                 :          0 :         fput(pipe);
     176                 :            : }
     177                 :            : 
     178                 :          0 : static int autofs_getpath(struct autofs_sb_info *sbi,
     179                 :            :                           struct dentry *dentry, char *name)
     180                 :            : {
     181                 :          0 :         struct dentry *root = sbi->sb->s_root;
     182                 :            :         struct dentry *tmp;
     183                 :            :         char *buf;
     184                 :            :         char *p;
     185                 :            :         int len;
     186                 :            :         unsigned seq;
     187                 :            : 
     188                 :            : rename_retry:
     189                 :            :         buf = name;
     190                 :            :         len = 0;
     191                 :            : 
     192                 :            :         seq = read_seqbegin(&rename_lock);
     193                 :            :         rcu_read_lock();
     194                 :            :         spin_lock(&sbi->fs_lock);
     195         [ #  # ]:          0 :         for (tmp = dentry ; tmp != root ; tmp = tmp->d_parent)
     196                 :          0 :                 len += tmp->d_name.len + 1;
     197                 :            : 
     198   [ #  #  #  # ]:          0 :         if (!len || --len > NAME_MAX) {
     199                 :            :                 spin_unlock(&sbi->fs_lock);
     200                 :            :                 rcu_read_unlock();
     201         [ #  # ]:          0 :                 if (read_seqretry(&rename_lock, seq))
     202                 :            :                         goto rename_retry;
     203                 :            :                 return 0;
     204                 :            :         }
     205                 :            : 
     206                 :          0 :         *(buf + len) = '\0';
     207                 :          0 :         p = buf + len - dentry->d_name.len;
     208                 :          0 :         strncpy(p, dentry->d_name.name, dentry->d_name.len);
     209                 :            : 
     210         [ #  # ]:          0 :         for (tmp = dentry->d_parent; tmp != root ; tmp = tmp->d_parent) {
     211                 :          0 :                 *(--p) = '/';
     212                 :          0 :                 p -= tmp->d_name.len;
     213                 :          0 :                 strncpy(p, tmp->d_name.name, tmp->d_name.len);
     214                 :            :         }
     215                 :            :         spin_unlock(&sbi->fs_lock);
     216                 :            :         rcu_read_unlock();
     217         [ #  # ]:          0 :         if (read_seqretry(&rename_lock, seq))
     218                 :            :                 goto rename_retry;
     219                 :            : 
     220                 :          0 :         return len;
     221                 :            : }
     222                 :            : 
     223                 :            : static struct autofs_wait_queue *
     224                 :          0 : autofs_find_wait(struct autofs_sb_info *sbi, const struct qstr *qstr)
     225                 :            : {
     226                 :            :         struct autofs_wait_queue *wq;
     227                 :            : 
     228         [ #  # ]:          0 :         for (wq = sbi->queues; wq; wq = wq->next) {
     229   [ #  #  #  # ]:          0 :                 if (wq->name.hash == qstr->hash &&
     230         [ #  # ]:          0 :                     wq->name.len == qstr->len &&
     231         [ #  # ]:          0 :                     wq->name.name &&
     232                 :          0 :                     !memcmp(wq->name.name, qstr->name, qstr->len))
     233                 :            :                         break;
     234                 :            :         }
     235                 :          0 :         return wq;
     236                 :            : }
     237                 :            : 
     238                 :            : /*
     239                 :            :  * Check if we have a valid request.
     240                 :            :  * Returns
     241                 :            :  * 1 if the request should continue.
     242                 :            :  *   In this case we can return an autofs_wait_queue entry if one is
     243                 :            :  *   found or NULL to idicate a new wait needs to be created.
     244                 :            :  * 0 or a negative errno if the request shouldn't continue.
     245                 :            :  */
     246                 :          0 : static int validate_request(struct autofs_wait_queue **wait,
     247                 :            :                             struct autofs_sb_info *sbi,
     248                 :            :                             const struct qstr *qstr,
     249                 :            :                             const struct path *path, enum autofs_notify notify)
     250                 :            : {
     251                 :          0 :         struct dentry *dentry = path->dentry;
     252                 :            :         struct autofs_wait_queue *wq;
     253                 :            :         struct autofs_info *ino;
     254                 :            : 
     255         [ #  # ]:          0 :         if (sbi->flags & AUTOFS_SBI_CATATONIC)
     256                 :            :                 return -ENOENT;
     257                 :            : 
     258                 :            :         /* Wait in progress, continue; */
     259                 :          0 :         wq = autofs_find_wait(sbi, qstr);
     260         [ #  # ]:          0 :         if (wq) {
     261                 :          0 :                 *wait = wq;
     262                 :          0 :                 return 1;
     263                 :            :         }
     264                 :            : 
     265                 :          0 :         *wait = NULL;
     266                 :            : 
     267                 :            :         /* If we don't yet have any info this is a new request */
     268                 :            :         ino = autofs_dentry_ino(dentry);
     269         [ #  # ]:          0 :         if (!ino)
     270                 :            :                 return 1;
     271                 :            : 
     272                 :            :         /*
     273                 :            :          * If we've been asked to wait on an existing expire (NFY_NONE)
     274                 :            :          * but there is no wait in the queue ...
     275                 :            :          */
     276         [ #  # ]:          0 :         if (notify == NFY_NONE) {
     277                 :            :                 /*
     278                 :            :                  * Either we've betean the pending expire to post it's
     279                 :            :                  * wait or it finished while we waited on the mutex.
     280                 :            :                  * So we need to wait till either, the wait appears
     281                 :            :                  * or the expire finishes.
     282                 :            :                  */
     283                 :            : 
     284         [ #  # ]:          0 :                 while (ino->flags & AUTOFS_INF_EXPIRING) {
     285                 :          0 :                         mutex_unlock(&sbi->wq_mutex);
     286                 :          0 :                         schedule_timeout_interruptible(HZ/10);
     287         [ #  # ]:          0 :                         if (mutex_lock_interruptible(&sbi->wq_mutex))
     288                 :            :                                 return -EINTR;
     289                 :            : 
     290         [ #  # ]:          0 :                         if (sbi->flags & AUTOFS_SBI_CATATONIC)
     291                 :            :                                 return -ENOENT;
     292                 :            : 
     293                 :          0 :                         wq = autofs_find_wait(sbi, qstr);
     294         [ #  # ]:          0 :                         if (wq) {
     295                 :          0 :                                 *wait = wq;
     296                 :          0 :                                 return 1;
     297                 :            :                         }
     298                 :            :                 }
     299                 :            : 
     300                 :            :                 /*
     301                 :            :                  * Not ideal but the status has already gone. Of the two
     302                 :            :                  * cases where we wait on NFY_NONE neither depend on the
     303                 :            :                  * return status of the wait.
     304                 :            :                  */
     305                 :            :                 return 0;
     306                 :            :         }
     307                 :            : 
     308                 :            :         /*
     309                 :            :          * If we've been asked to trigger a mount and the request
     310                 :            :          * completed while we waited on the mutex ...
     311                 :            :          */
     312         [ #  # ]:          0 :         if (notify == NFY_MOUNT) {
     313                 :            :                 struct dentry *new = NULL;
     314                 :            :                 struct path this;
     315                 :            :                 int valid = 1;
     316                 :            : 
     317                 :            :                 /*
     318                 :            :                  * If the dentry was successfully mounted while we slept
     319                 :            :                  * on the wait queue mutex we can return success. If it
     320                 :            :                  * isn't mounted (doesn't have submounts for the case of
     321                 :            :                  * a multi-mount with no mount at it's base) we can
     322                 :            :                  * continue on and create a new request.
     323                 :            :                  */
     324         [ #  # ]:          0 :                 if (!IS_ROOT(dentry)) {
     325   [ #  #  #  # ]:          0 :                         if (d_unhashed(dentry) &&
     326                 :            :                             d_really_is_positive(dentry)) {
     327                 :            :                                 struct dentry *parent = dentry->d_parent;
     328                 :            : 
     329                 :          0 :                                 new = d_lookup(parent, &dentry->d_name);
     330         [ #  # ]:          0 :                                 if (new)
     331                 :            :                                         dentry = new;
     332                 :            :                         }
     333                 :            :                 }
     334                 :          0 :                 this.mnt = path->mnt;
     335                 :          0 :                 this.dentry = dentry;
     336         [ #  # ]:          0 :                 if (path_has_submounts(&this))
     337                 :            :                         valid = 0;
     338                 :            : 
     339         [ #  # ]:          0 :                 if (new)
     340                 :          0 :                         dput(new);
     341                 :            :                 return valid;
     342                 :            :         }
     343                 :            : 
     344                 :            :         return 1;
     345                 :            : }
     346                 :            : 
     347                 :          0 : int autofs_wait(struct autofs_sb_info *sbi,
     348                 :            :                  const struct path *path, enum autofs_notify notify)
     349                 :            : {
     350                 :          0 :         struct dentry *dentry = path->dentry;
     351                 :            :         struct autofs_wait_queue *wq;
     352                 :            :         struct qstr qstr;
     353                 :            :         char *name;
     354                 :            :         int status, ret, type;
     355                 :            :         pid_t pid;
     356                 :            :         pid_t tgid;
     357                 :            : 
     358                 :            :         /* In catatonic mode, we don't wait for nobody */
     359         [ #  # ]:          0 :         if (sbi->flags & AUTOFS_SBI_CATATONIC)
     360                 :            :                 return -ENOENT;
     361                 :            : 
     362                 :            :         /*
     363                 :            :          * Try translating pids to the namespace of the daemon.
     364                 :            :          *
     365                 :            :          * Zero means failure: we are in an unrelated pid namespace.
     366                 :            :          */
     367                 :          0 :         pid = task_pid_nr_ns(current, ns_of_pid(sbi->oz_pgrp));
     368                 :          0 :         tgid = task_tgid_nr_ns(current, ns_of_pid(sbi->oz_pgrp));
     369         [ #  # ]:          0 :         if (pid == 0 || tgid == 0)
     370                 :            :                 return -ENOENT;
     371                 :            : 
     372         [ #  # ]:          0 :         if (d_really_is_negative(dentry)) {
     373                 :            :                 /*
     374                 :            :                  * A wait for a negative dentry is invalid for certain
     375                 :            :                  * cases. A direct or offset mount "always" has its mount
     376                 :            :                  * point directory created and so the request dentry must
     377                 :            :                  * be positive or the map key doesn't exist. The situation
     378                 :            :                  * is very similar for indirect mounts except only dentrys
     379                 :            :                  * in the root of the autofs file system may be negative.
     380                 :            :                  */
     381         [ #  # ]:          0 :                 if (autofs_type_trigger(sbi->type))
     382                 :            :                         return -ENOENT;
     383         [ #  # ]:          0 :                 else if (!IS_ROOT(dentry->d_parent))
     384                 :            :                         return -ENOENT;
     385                 :            :         }
     386                 :            : 
     387                 :            :         name = kmalloc(NAME_MAX + 1, GFP_KERNEL);
     388         [ #  # ]:          0 :         if (!name)
     389                 :            :                 return -ENOMEM;
     390                 :            : 
     391                 :            :         /* If this is a direct mount request create a dummy name */
     392   [ #  #  #  # ]:          0 :         if (IS_ROOT(dentry) && autofs_type_trigger(sbi->type))
     393                 :          0 :                 qstr.len = sprintf(name, "%p", dentry);
     394                 :            :         else {
     395                 :          0 :                 qstr.len = autofs_getpath(sbi, dentry, name);
     396         [ #  # ]:          0 :                 if (!qstr.len) {
     397                 :          0 :                         kfree(name);
     398                 :          0 :                         return -ENOENT;
     399                 :            :                 }
     400                 :            :         }
     401                 :          0 :         qstr.name = name;
     402                 :          0 :         qstr.hash = full_name_hash(dentry, name, qstr.len);
     403                 :            : 
     404         [ #  # ]:          0 :         if (mutex_lock_interruptible(&sbi->wq_mutex)) {
     405                 :          0 :                 kfree(qstr.name);
     406                 :          0 :                 return -EINTR;
     407                 :            :         }
     408                 :            : 
     409                 :          0 :         ret = validate_request(&wq, sbi, &qstr, path, notify);
     410         [ #  # ]:          0 :         if (ret <= 0) {
     411         [ #  # ]:          0 :                 if (ret != -EINTR)
     412                 :          0 :                         mutex_unlock(&sbi->wq_mutex);
     413                 :          0 :                 kfree(qstr.name);
     414                 :          0 :                 return ret;
     415                 :            :         }
     416                 :            : 
     417         [ #  # ]:          0 :         if (!wq) {
     418                 :            :                 /* Create a new wait queue */
     419                 :          0 :                 wq = kmalloc(sizeof(struct autofs_wait_queue), GFP_KERNEL);
     420         [ #  # ]:          0 :                 if (!wq) {
     421                 :          0 :                         kfree(qstr.name);
     422                 :          0 :                         mutex_unlock(&sbi->wq_mutex);
     423                 :          0 :                         return -ENOMEM;
     424                 :            :                 }
     425                 :            : 
     426                 :          0 :                 wq->wait_queue_token = autofs_next_wait_queue;
     427         [ #  # ]:          0 :                 if (++autofs_next_wait_queue == 0)
     428                 :          0 :                         autofs_next_wait_queue = 1;
     429                 :          0 :                 wq->next = sbi->queues;
     430                 :          0 :                 sbi->queues = wq;
     431                 :          0 :                 init_waitqueue_head(&wq->queue);
     432                 :          0 :                 memcpy(&wq->name, &qstr, sizeof(struct qstr));
     433                 :          0 :                 wq->dev = autofs_get_dev(sbi);
     434                 :          0 :                 wq->ino = autofs_get_ino(sbi);
     435                 :          0 :                 wq->uid = current_uid();
     436                 :          0 :                 wq->gid = current_gid();
     437                 :          0 :                 wq->pid = pid;
     438                 :          0 :                 wq->tgid = tgid;
     439                 :          0 :                 wq->status = -EINTR; /* Status return if interrupted */
     440                 :          0 :                 wq->wait_ctr = 2;
     441                 :            : 
     442         [ #  # ]:          0 :                 if (sbi->version < 5) {
     443         [ #  # ]:          0 :                         if (notify == NFY_MOUNT)
     444                 :            :                                 type = autofs_ptype_missing;
     445                 :            :                         else
     446                 :            :                                 type = autofs_ptype_expire_multi;
     447                 :            :                 } else {
     448         [ #  # ]:          0 :                         if (notify == NFY_MOUNT)
     449                 :          0 :                                 type = autofs_type_trigger(sbi->type) ?
     450         [ #  # ]:          0 :                                         autofs_ptype_missing_direct :
     451                 :            :                                          autofs_ptype_missing_indirect;
     452                 :            :                         else
     453                 :          0 :                                 type = autofs_type_trigger(sbi->type) ?
     454         [ #  # ]:          0 :                                         autofs_ptype_expire_direct :
     455                 :            :                                         autofs_ptype_expire_indirect;
     456                 :            :                 }
     457                 :            : 
     458                 :            :                 pr_debug("new wait id = 0x%08lx, name = %.*s, nfy=%d\n",
     459                 :            :                          (unsigned long) wq->wait_queue_token, wq->name.len,
     460                 :            :                          wq->name.name, notify);
     461                 :            : 
     462                 :            :                 /*
     463                 :            :                  * autofs_notify_daemon() may block; it will unlock ->wq_mutex
     464                 :            :                  */
     465                 :          0 :                 autofs_notify_daemon(sbi, wq, type);
     466                 :            :         } else {
     467                 :          0 :                 wq->wait_ctr++;
     468                 :            :                 pr_debug("existing wait id = 0x%08lx, name = %.*s, nfy=%d\n",
     469                 :            :                          (unsigned long) wq->wait_queue_token, wq->name.len,
     470                 :            :                          wq->name.name, notify);
     471                 :          0 :                 mutex_unlock(&sbi->wq_mutex);
     472                 :          0 :                 kfree(qstr.name);
     473                 :            :         }
     474                 :            : 
     475                 :            :         /*
     476                 :            :          * wq->name.name is NULL iff the lock is already released
     477                 :            :          * or the mount has been made catatonic.
     478                 :            :          */
     479   [ #  #  #  #  :          0 :         wait_event_killable(wq->queue, wq->name.name == NULL);
                   #  # ]
     480                 :          0 :         status = wq->status;
     481                 :            : 
     482                 :            :         /*
     483                 :            :          * For direct and offset mounts we need to track the requester's
     484                 :            :          * uid and gid in the dentry info struct. This is so it can be
     485                 :            :          * supplied, on request, by the misc device ioctl interface.
     486                 :            :          * This is needed during daemon resatart when reconnecting
     487                 :            :          * to existing, active, autofs mounts. The uid and gid (and
     488                 :            :          * related string values) may be used for macro substitution
     489                 :            :          * in autofs mount maps.
     490                 :            :          */
     491         [ #  # ]:          0 :         if (!status) {
     492                 :            :                 struct autofs_info *ino;
     493                 :            :                 struct dentry *de = NULL;
     494                 :            : 
     495                 :            :                 /* direct mount or browsable map */
     496                 :            :                 ino = autofs_dentry_ino(dentry);
     497         [ #  # ]:          0 :                 if (!ino) {
     498                 :            :                         /* If not lookup actual dentry used */
     499                 :          0 :                         de = d_lookup(dentry->d_parent, &dentry->d_name);
     500         [ #  # ]:          0 :                         if (de)
     501                 :            :                                 ino = autofs_dentry_ino(de);
     502                 :            :                 }
     503                 :            : 
     504                 :            :                 /* Set mount requester */
     505         [ #  # ]:          0 :                 if (ino) {
     506                 :            :                         spin_lock(&sbi->fs_lock);
     507                 :          0 :                         ino->uid = wq->uid;
     508                 :          0 :                         ino->gid = wq->gid;
     509                 :            :                         spin_unlock(&sbi->fs_lock);
     510                 :            :                 }
     511                 :            : 
     512         [ #  # ]:          0 :                 if (de)
     513                 :          0 :                         dput(de);
     514                 :            :         }
     515                 :            : 
     516                 :            :         /* Are we the last process to need status? */
     517                 :          0 :         mutex_lock(&sbi->wq_mutex);
     518         [ #  # ]:          0 :         if (!--wq->wait_ctr)
     519                 :          0 :                 kfree(wq);
     520                 :          0 :         mutex_unlock(&sbi->wq_mutex);
     521                 :            : 
     522                 :          0 :         return status;
     523                 :            : }
     524                 :            : 
     525                 :            : 
     526                 :          0 : int autofs_wait_release(struct autofs_sb_info *sbi,
     527                 :            :                         autofs_wqt_t wait_queue_token, int status)
     528                 :            : {
     529                 :            :         struct autofs_wait_queue *wq, **wql;
     530                 :            : 
     531                 :          0 :         mutex_lock(&sbi->wq_mutex);
     532         [ #  # ]:          0 :         for (wql = &sbi->queues; (wq = *wql) != NULL; wql = &wq->next) {
     533         [ #  # ]:          0 :                 if (wq->wait_queue_token == wait_queue_token)
     534                 :            :                         break;
     535                 :            :         }
     536                 :            : 
     537         [ #  # ]:          0 :         if (!wq) {
     538                 :          0 :                 mutex_unlock(&sbi->wq_mutex);
     539                 :          0 :                 return -EINVAL;
     540                 :            :         }
     541                 :            : 
     542                 :          0 :         *wql = wq->next;     /* Unlink from chain */
     543                 :          0 :         kfree(wq->name.name);
     544                 :          0 :         wq->name.name = NULL;        /* Do not wait on this queue */
     545                 :          0 :         wq->status = status;
     546                 :          0 :         wake_up(&wq->queue);
     547         [ #  # ]:          0 :         if (!--wq->wait_ctr)
     548                 :          0 :                 kfree(wq);
     549                 :          0 :         mutex_unlock(&sbi->wq_mutex);
     550                 :            : 
     551                 :          0 :         return 0;
     552                 :            : }

Generated by: LCOV version 1.14