LCOV - code coverage report
Current view: top level - fs/autofs - inode.c (source / functions) Hit Total Coverage
Test: Real Lines: 117 181 64.6 %
Date: 2020-10-17 15:46:16 Functions: 0 9 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 2005-2006 Ian Kent <raven@themaw.net>
       5                 :            :  */
       6                 :            : 
       7                 :            : #include <linux/seq_file.h>
       8                 :            : #include <linux/pagemap.h>
       9                 :            : #include <linux/parser.h>
      10                 :            : 
      11                 :            : #include "autofs_i.h"
      12                 :            : 
      13                 :          3 : struct autofs_info *autofs_new_ino(struct autofs_sb_info *sbi)
      14                 :            : {
      15                 :            :         struct autofs_info *ino;
      16                 :            : 
      17                 :          3 :         ino = kzalloc(sizeof(*ino), GFP_KERNEL);
      18                 :          3 :         if (ino) {
      19                 :          3 :                 INIT_LIST_HEAD(&ino->active);
      20                 :          3 :                 INIT_LIST_HEAD(&ino->expiring);
      21                 :          3 :                 ino->last_used = jiffies;
      22                 :          3 :                 ino->sbi = sbi;
      23                 :            :         }
      24                 :          3 :         return ino;
      25                 :            : }
      26                 :            : 
      27                 :          0 : void autofs_clean_ino(struct autofs_info *ino)
      28                 :            : {
      29                 :          0 :         ino->uid = GLOBAL_ROOT_UID;
      30                 :          0 :         ino->gid = GLOBAL_ROOT_GID;
      31                 :          0 :         ino->last_used = jiffies;
      32                 :          0 : }
      33                 :            : 
      34                 :          0 : void autofs_free_ino(struct autofs_info *ino)
      35                 :            : {
      36                 :          0 :         kfree_rcu(ino, rcu);
      37                 :          0 : }
      38                 :            : 
      39                 :          0 : void autofs_kill_sb(struct super_block *sb)
      40                 :            : {
      41                 :            :         struct autofs_sb_info *sbi = autofs_sbi(sb);
      42                 :            : 
      43                 :            :         /*
      44                 :            :          * In the event of a failure in get_sb_nodev the superblock
      45                 :            :          * info is not present so nothing else has been setup, so
      46                 :            :          * just call kill_anon_super when we are called from
      47                 :            :          * deactivate_super.
      48                 :            :          */
      49                 :          0 :         if (sbi) {
      50                 :            :                 /* Free wait queues, close pipe */
      51                 :          0 :                 autofs_catatonic_mode(sbi);
      52                 :          0 :                 put_pid(sbi->oz_pgrp);
      53                 :            :         }
      54                 :            : 
      55                 :            :         pr_debug("shutting down\n");
      56                 :          0 :         kill_litter_super(sb);
      57                 :          0 :         if (sbi)
      58                 :          0 :                 kfree_rcu(sbi, rcu);
      59                 :          0 : }
      60                 :            : 
      61                 :          3 : static int autofs_show_options(struct seq_file *m, struct dentry *root)
      62                 :            : {
      63                 :          3 :         struct autofs_sb_info *sbi = autofs_sbi(root->d_sb);
      64                 :          3 :         struct inode *root_inode = d_inode(root->d_sb->s_root);
      65                 :            : 
      66                 :          3 :         if (!sbi)
      67                 :            :                 return 0;
      68                 :            : 
      69                 :          3 :         seq_printf(m, ",fd=%d", sbi->pipefd);
      70                 :          3 :         if (!uid_eq(root_inode->i_uid, GLOBAL_ROOT_UID))
      71                 :          0 :                 seq_printf(m, ",uid=%u",
      72                 :            :                         from_kuid_munged(&init_user_ns, root_inode->i_uid));
      73                 :          3 :         if (!gid_eq(root_inode->i_gid, GLOBAL_ROOT_GID))
      74                 :          0 :                 seq_printf(m, ",gid=%u",
      75                 :            :                         from_kgid_munged(&init_user_ns, root_inode->i_gid));
      76                 :          3 :         seq_printf(m, ",pgrp=%d", pid_vnr(sbi->oz_pgrp));
      77                 :          3 :         seq_printf(m, ",timeout=%lu", sbi->exp_timeout/HZ);
      78                 :          3 :         seq_printf(m, ",minproto=%d", sbi->min_proto);
      79                 :          3 :         seq_printf(m, ",maxproto=%d", sbi->max_proto);
      80                 :            : 
      81                 :          3 :         if (autofs_type_offset(sbi->type))
      82                 :          0 :                 seq_puts(m, ",offset");
      83                 :          3 :         else if (autofs_type_direct(sbi->type))
      84                 :          3 :                 seq_puts(m, ",direct");
      85                 :            :         else
      86                 :          0 :                 seq_puts(m, ",indirect");
      87                 :          3 :         if (sbi->flags & AUTOFS_SBI_STRICTEXPIRE)
      88                 :          0 :                 seq_puts(m, ",strictexpire");
      89                 :          3 :         if (sbi->flags & AUTOFS_SBI_IGNORE)
      90                 :          0 :                 seq_puts(m, ",ignore");
      91                 :            : #ifdef CONFIG_CHECKPOINT_RESTORE
      92                 :            :         if (sbi->pipe)
      93                 :            :                 seq_printf(m, ",pipe_ino=%ld", file_inode(sbi->pipe)->i_ino);
      94                 :            :         else
      95                 :            :                 seq_puts(m, ",pipe_ino=-1");
      96                 :            : #endif
      97                 :            :         return 0;
      98                 :            : }
      99                 :            : 
     100                 :          0 : static void autofs_evict_inode(struct inode *inode)
     101                 :            : {
     102                 :          0 :         clear_inode(inode);
     103                 :          0 :         kfree(inode->i_private);
     104                 :          0 : }
     105                 :            : 
     106                 :            : static const struct super_operations autofs_sops = {
     107                 :            :         .statfs         = simple_statfs,
     108                 :            :         .show_options   = autofs_show_options,
     109                 :            :         .evict_inode    = autofs_evict_inode,
     110                 :            : };
     111                 :            : 
     112                 :            : enum {Opt_err, Opt_fd, Opt_uid, Opt_gid, Opt_pgrp, Opt_minproto, Opt_maxproto,
     113                 :            :         Opt_indirect, Opt_direct, Opt_offset, Opt_strictexpire,
     114                 :            :         Opt_ignore};
     115                 :            : 
     116                 :            : static const match_table_t tokens = {
     117                 :            :         {Opt_fd, "fd=%u"},
     118                 :            :         {Opt_uid, "uid=%u"},
     119                 :            :         {Opt_gid, "gid=%u"},
     120                 :            :         {Opt_pgrp, "pgrp=%u"},
     121                 :            :         {Opt_minproto, "minproto=%u"},
     122                 :            :         {Opt_maxproto, "maxproto=%u"},
     123                 :            :         {Opt_indirect, "indirect"},
     124                 :            :         {Opt_direct, "direct"},
     125                 :            :         {Opt_offset, "offset"},
     126                 :            :         {Opt_strictexpire, "strictexpire"},
     127                 :            :         {Opt_ignore, "ignore"},
     128                 :            :         {Opt_err, NULL}
     129                 :            : };
     130                 :            : 
     131                 :          3 : static int parse_options(char *options,
     132                 :            :                          struct inode *root, int *pgrp, bool *pgrp_set,
     133                 :            :                          struct autofs_sb_info *sbi)
     134                 :            : {
     135                 :            :         char *p;
     136                 :            :         substring_t args[MAX_OPT_ARGS];
     137                 :            :         int option;
     138                 :          3 :         int pipefd = -1;
     139                 :            :         kuid_t uid;
     140                 :            :         kgid_t gid;
     141                 :            : 
     142                 :          3 :         root->i_uid = current_uid();
     143                 :          3 :         root->i_gid = current_gid();
     144                 :            : 
     145                 :          3 :         sbi->min_proto = AUTOFS_MIN_PROTO_VERSION;
     146                 :          3 :         sbi->max_proto = AUTOFS_MAX_PROTO_VERSION;
     147                 :            : 
     148                 :          3 :         sbi->pipefd = -1;
     149                 :            : 
     150                 :          3 :         if (!options)
     151                 :            :                 return 1;
     152                 :            : 
     153                 :          3 :         while ((p = strsep(&options, ",")) != NULL) {
     154                 :            :                 int token;
     155                 :            : 
     156                 :          3 :                 if (!*p)
     157                 :          0 :                         continue;
     158                 :            : 
     159                 :          3 :                 token = match_token(p, tokens, args);
     160                 :          3 :                 switch (token) {
     161                 :            :                 case Opt_fd:
     162                 :          3 :                         if (match_int(args, &pipefd))
     163                 :            :                                 return 1;
     164                 :          3 :                         sbi->pipefd = pipefd;
     165                 :          3 :                         break;
     166                 :            :                 case Opt_uid:
     167                 :          0 :                         if (match_int(args, &option))
     168                 :            :                                 return 1;
     169                 :          0 :                         uid = make_kuid(current_user_ns(), option);
     170                 :          0 :                         if (!uid_valid(uid))
     171                 :            :                                 return 1;
     172                 :          0 :                         root->i_uid = uid;
     173                 :          0 :                         break;
     174                 :            :                 case Opt_gid:
     175                 :          0 :                         if (match_int(args, &option))
     176                 :            :                                 return 1;
     177                 :          0 :                         gid = make_kgid(current_user_ns(), option);
     178                 :          0 :                         if (!gid_valid(gid))
     179                 :            :                                 return 1;
     180                 :          0 :                         root->i_gid = gid;
     181                 :          0 :                         break;
     182                 :            :                 case Opt_pgrp:
     183                 :          3 :                         if (match_int(args, &option))
     184                 :            :                                 return 1;
     185                 :          3 :                         *pgrp = option;
     186                 :          3 :                         *pgrp_set = true;
     187                 :          3 :                         break;
     188                 :            :                 case Opt_minproto:
     189                 :          3 :                         if (match_int(args, &option))
     190                 :            :                                 return 1;
     191                 :          3 :                         sbi->min_proto = option;
     192                 :          3 :                         break;
     193                 :            :                 case Opt_maxproto:
     194                 :          3 :                         if (match_int(args, &option))
     195                 :            :                                 return 1;
     196                 :          3 :                         sbi->max_proto = option;
     197                 :          3 :                         break;
     198                 :            :                 case Opt_indirect:
     199                 :            :                         set_autofs_type_indirect(&sbi->type);
     200                 :            :                         break;
     201                 :            :                 case Opt_direct:
     202                 :            :                         set_autofs_type_direct(&sbi->type);
     203                 :            :                         break;
     204                 :            :                 case Opt_offset:
     205                 :            :                         set_autofs_type_offset(&sbi->type);
     206                 :            :                         break;
     207                 :            :                 case Opt_strictexpire:
     208                 :          0 :                         sbi->flags |= AUTOFS_SBI_STRICTEXPIRE;
     209                 :          0 :                         break;
     210                 :            :                 case Opt_ignore:
     211                 :          0 :                         sbi->flags |= AUTOFS_SBI_IGNORE;
     212                 :          0 :                         break;
     213                 :            :                 default:
     214                 :            :                         return 1;
     215                 :            :                 }
     216                 :            :         }
     217                 :          3 :         return (sbi->pipefd < 0);
     218                 :            : }
     219                 :            : 
     220                 :          3 : int autofs_fill_super(struct super_block *s, void *data, int silent)
     221                 :            : {
     222                 :            :         struct inode *root_inode;
     223                 :            :         struct dentry *root;
     224                 :            :         struct file *pipe;
     225                 :            :         struct autofs_sb_info *sbi;
     226                 :            :         struct autofs_info *ino;
     227                 :          3 :         int pgrp = 0;
     228                 :          3 :         bool pgrp_set = false;
     229                 :            :         int ret = -EINVAL;
     230                 :            : 
     231                 :          3 :         sbi = kzalloc(sizeof(*sbi), GFP_KERNEL);
     232                 :          3 :         if (!sbi)
     233                 :            :                 return -ENOMEM;
     234                 :            :         pr_debug("starting up, sbi = %p\n", sbi);
     235                 :            : 
     236                 :          3 :         s->s_fs_info = sbi;
     237                 :          3 :         sbi->magic = AUTOFS_SBI_MAGIC;
     238                 :          3 :         sbi->pipefd = -1;
     239                 :          3 :         sbi->pipe = NULL;
     240                 :          3 :         sbi->exp_timeout = 0;
     241                 :          3 :         sbi->oz_pgrp = NULL;
     242                 :          3 :         sbi->sb = s;
     243                 :          3 :         sbi->version = 0;
     244                 :          3 :         sbi->sub_version = 0;
     245                 :          3 :         sbi->flags = AUTOFS_SBI_CATATONIC;
     246                 :            :         set_autofs_type_indirect(&sbi->type);
     247                 :          3 :         sbi->min_proto = 0;
     248                 :          3 :         sbi->max_proto = 0;
     249                 :          3 :         mutex_init(&sbi->wq_mutex);
     250                 :          3 :         mutex_init(&sbi->pipe_mutex);
     251                 :          3 :         spin_lock_init(&sbi->fs_lock);
     252                 :          3 :         sbi->queues = NULL;
     253                 :          3 :         spin_lock_init(&sbi->lookup_lock);
     254                 :          3 :         INIT_LIST_HEAD(&sbi->active_list);
     255                 :          3 :         INIT_LIST_HEAD(&sbi->expiring_list);
     256                 :          3 :         s->s_blocksize = 1024;
     257                 :          3 :         s->s_blocksize_bits = 10;
     258                 :          3 :         s->s_magic = AUTOFS_SUPER_MAGIC;
     259                 :          3 :         s->s_op = &autofs_sops;
     260                 :          3 :         s->s_d_op = &autofs_dentry_operations;
     261                 :          3 :         s->s_time_gran = 1;
     262                 :            : 
     263                 :            :         /*
     264                 :            :          * Get the root inode and dentry, but defer checking for errors.
     265                 :            :          */
     266                 :          3 :         ino = autofs_new_ino(sbi);
     267                 :          3 :         if (!ino) {
     268                 :            :                 ret = -ENOMEM;
     269                 :            :                 goto fail_free;
     270                 :            :         }
     271                 :          3 :         root_inode = autofs_get_inode(s, S_IFDIR | 0755);
     272                 :          3 :         root = d_make_root(root_inode);
     273                 :          3 :         if (!root) {
     274                 :            :                 ret = -ENOMEM;
     275                 :            :                 goto fail_ino;
     276                 :            :         }
     277                 :            :         pipe = NULL;
     278                 :            : 
     279                 :          3 :         root->d_fsdata = ino;
     280                 :            : 
     281                 :            :         /* Can this call block? */
     282                 :          3 :         if (parse_options(data, root_inode, &pgrp, &pgrp_set, sbi)) {
     283                 :          0 :                 pr_err("called with bogus options\n");
     284                 :          0 :                 goto fail_dput;
     285                 :            :         }
     286                 :            : 
     287                 :            :         /* Test versions first */
     288                 :          3 :         if (sbi->max_proto < AUTOFS_MIN_PROTO_VERSION ||
     289                 :          3 :             sbi->min_proto > AUTOFS_MAX_PROTO_VERSION) {
     290                 :          0 :                 pr_err("kernel does not match daemon version "
     291                 :            :                        "daemon (%d, %d) kernel (%d, %d)\n",
     292                 :            :                        sbi->min_proto, sbi->max_proto,
     293                 :            :                        AUTOFS_MIN_PROTO_VERSION, AUTOFS_MAX_PROTO_VERSION);
     294                 :          0 :                 goto fail_dput;
     295                 :            :         }
     296                 :            : 
     297                 :            :         /* Establish highest kernel protocol version */
     298                 :          3 :         if (sbi->max_proto > AUTOFS_MAX_PROTO_VERSION)
     299                 :          0 :                 sbi->version = AUTOFS_MAX_PROTO_VERSION;
     300                 :            :         else
     301                 :          3 :                 sbi->version = sbi->max_proto;
     302                 :          3 :         sbi->sub_version = AUTOFS_PROTO_SUBVERSION;
     303                 :            : 
     304                 :          3 :         if (pgrp_set) {
     305                 :          3 :                 sbi->oz_pgrp = find_get_pid(pgrp);
     306                 :          3 :                 if (!sbi->oz_pgrp) {
     307                 :          0 :                         pr_err("could not find process group %d\n",
     308                 :            :                                 pgrp);
     309                 :          0 :                         goto fail_dput;
     310                 :            :                 }
     311                 :            :         } else {
     312                 :          0 :                 sbi->oz_pgrp = get_task_pid(current, PIDTYPE_PGID);
     313                 :            :         }
     314                 :            : 
     315                 :          3 :         if (autofs_type_trigger(sbi->type))
     316                 :            :                 __managed_dentry_set_managed(root);
     317                 :            : 
     318                 :          3 :         root_inode->i_fop = &autofs_root_operations;
     319                 :          3 :         root_inode->i_op = &autofs_dir_inode_operations;
     320                 :            : 
     321                 :            :         pr_debug("pipe fd = %d, pgrp = %u\n",
     322                 :            :                  sbi->pipefd, pid_nr(sbi->oz_pgrp));
     323                 :          3 :         pipe = fget(sbi->pipefd);
     324                 :            : 
     325                 :          3 :         if (!pipe) {
     326                 :          0 :                 pr_err("could not open pipe file descriptor\n");
     327                 :          0 :                 goto fail_put_pid;
     328                 :            :         }
     329                 :            :         ret = autofs_prepare_pipe(pipe);
     330                 :          3 :         if (ret < 0)
     331                 :            :                 goto fail_fput;
     332                 :          3 :         sbi->pipe = pipe;
     333                 :          3 :         sbi->flags &= ~AUTOFS_SBI_CATATONIC;
     334                 :            : 
     335                 :            :         /*
     336                 :            :          * Success! Install the root dentry now to indicate completion.
     337                 :            :          */
     338                 :          3 :         s->s_root = root;
     339                 :          3 :         return 0;
     340                 :            : 
     341                 :            :         /*
     342                 :            :          * Failure ... clean up.
     343                 :            :          */
     344                 :            : fail_fput:
     345                 :          0 :         pr_err("pipe file descriptor does not contain proper ops\n");
     346                 :          0 :         fput(pipe);
     347                 :            : fail_put_pid:
     348                 :          0 :         put_pid(sbi->oz_pgrp);
     349                 :            : fail_dput:
     350                 :          0 :         dput(root);
     351                 :          0 :         goto fail_free;
     352                 :            : fail_ino:
     353                 :            :         autofs_free_ino(ino);
     354                 :            : fail_free:
     355                 :          0 :         kfree(sbi);
     356                 :          0 :         s->s_fs_info = NULL;
     357                 :          0 :         return ret;
     358                 :            : }
     359                 :            : 
     360                 :          3 : struct inode *autofs_get_inode(struct super_block *sb, umode_t mode)
     361                 :            : {
     362                 :          3 :         struct inode *inode = new_inode(sb);
     363                 :            : 
     364                 :          3 :         if (inode == NULL)
     365                 :            :                 return NULL;
     366                 :            : 
     367                 :          3 :         inode->i_mode = mode;
     368                 :          3 :         if (sb->s_root) {
     369                 :          0 :                 inode->i_uid = d_inode(sb->s_root)->i_uid;
     370                 :          0 :                 inode->i_gid = d_inode(sb->s_root)->i_gid;
     371                 :            :         }
     372                 :          3 :         inode->i_atime = inode->i_mtime = inode->i_ctime = current_time(inode);
     373                 :          3 :         inode->i_ino = get_next_ino();
     374                 :            : 
     375                 :          3 :         if (S_ISDIR(mode)) {
     376                 :          3 :                 set_nlink(inode, 2);
     377                 :          3 :                 inode->i_op = &autofs_dir_inode_operations;
     378                 :          3 :                 inode->i_fop = &autofs_dir_operations;
     379                 :          0 :         } else if (S_ISLNK(mode)) {
     380                 :          0 :                 inode->i_op = &autofs_symlink_inode_operations;
     381                 :            :         } else
     382                 :          0 :                 WARN_ON(1);
     383                 :            : 
     384                 :          3 :         return inode;
     385                 :            : }
    

Generated by: LCOV version 1.14