LCOV - code coverage report
Current view: top level - fs/proc - proc_sysctl.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 548 791 69.3 %
Date: 2022-04-01 14:17:54 Functions: 40 53 75.5 %
Branches: 248 438 56.6 %

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0
       2                 :            : /*
       3                 :            :  * /proc/sys support
       4                 :            :  */
       5                 :            : #include <linux/init.h>
       6                 :            : #include <linux/sysctl.h>
       7                 :            : #include <linux/poll.h>
       8                 :            : #include <linux/proc_fs.h>
       9                 :            : #include <linux/printk.h>
      10                 :            : #include <linux/security.h>
      11                 :            : #include <linux/sched.h>
      12                 :            : #include <linux/cred.h>
      13                 :            : #include <linux/namei.h>
      14                 :            : #include <linux/mm.h>
      15                 :            : #include <linux/module.h>
      16                 :            : #include <linux/bpf-cgroup.h>
      17                 :            : #include "internal.h"
      18                 :            : 
      19                 :            : static const struct dentry_operations proc_sys_dentry_operations;
      20                 :            : static const struct file_operations proc_sys_file_operations;
      21                 :            : static const struct inode_operations proc_sys_inode_operations;
      22                 :            : static const struct file_operations proc_sys_dir_file_operations;
      23                 :            : static const struct inode_operations proc_sys_dir_operations;
      24                 :            : 
      25                 :            : /* shared constants to be used in various sysctls */
      26                 :            : const int sysctl_vals[] = { 0, 1, INT_MAX };
      27                 :            : EXPORT_SYMBOL(sysctl_vals);
      28                 :            : 
      29                 :            : /* Support for permanently empty directories */
      30                 :            : 
      31                 :            : struct ctl_table sysctl_mount_point[] = {
      32                 :            :         { }
      33                 :            : };
      34                 :            : 
      35                 :       1573 : static bool is_empty_dir(struct ctl_table_header *head)
      36                 :            : {
      37                 :       1573 :         return head->ctl_table[0].child == sysctl_mount_point;
      38                 :            : }
      39                 :            : 
      40                 :         11 : static void set_empty_dir(struct ctl_dir *dir)
      41                 :            : {
      42                 :         11 :         dir->header.ctl_table[0].child = sysctl_mount_point;
      43                 :         11 : }
      44                 :            : 
      45                 :          0 : static void clear_empty_dir(struct ctl_dir *dir)
      46                 :            : 
      47                 :            : {
      48                 :          0 :         dir->header.ctl_table[0].child = NULL;
      49                 :          0 : }
      50                 :            : 
      51                 :         11 : void proc_sys_poll_notify(struct ctl_table_poll *poll)
      52                 :            : {
      53         [ +  - ]:         11 :         if (!poll)
      54                 :            :                 return;
      55                 :            : 
      56                 :         11 :         atomic_inc(&poll->event);
      57                 :         11 :         wake_up_interruptible(&poll->wait);
      58                 :            : }
      59                 :            : 
      60                 :            : static struct ctl_table root_table[] = {
      61                 :            :         {
      62                 :            :                 .procname = "",
      63                 :            :                 .mode = S_IFDIR|S_IRUGO|S_IXUGO,
      64                 :            :         },
      65                 :            :         { }
      66                 :            : };
      67                 :            : static struct ctl_table_root sysctl_table_root = {
      68                 :            :         .default_set.dir.header = {
      69                 :            :                 {{.count = 1,
      70                 :            :                   .nreg = 1,
      71                 :            :                   .ctl_table = root_table }},
      72                 :            :                 .ctl_table_arg = root_table,
      73                 :            :                 .root = &sysctl_table_root,
      74                 :            :                 .set = &sysctl_table_root.default_set,
      75                 :            :         },
      76                 :            : };
      77                 :            : 
      78                 :            : static DEFINE_SPINLOCK(sysctl_lock);
      79                 :            : 
      80                 :            : static void drop_sysctl_table(struct ctl_table_header *header);
      81                 :            : static int sysctl_follow_link(struct ctl_table_header **phead,
      82                 :            :         struct ctl_table **pentry);
      83                 :            : static int insert_links(struct ctl_table_header *head);
      84                 :            : static void put_links(struct ctl_table_header *header);
      85                 :            : 
      86                 :            : static void sysctl_print_dir(struct ctl_dir *dir)
      87                 :            : {
      88                 :            :         if (dir->header.parent)
      89                 :            :                 sysctl_print_dir(dir->header.parent);
      90                 :            :         pr_cont("%s/", dir->header.ctl_table[0].procname);
      91                 :            : }
      92                 :            : 
      93                 :      39402 : static int namecmp(const char *name1, int len1, const char *name2, int len2)
      94                 :            : {
      95                 :      39402 :         int minlen;
      96                 :      39402 :         int cmp;
      97                 :            : 
      98                 :      39402 :         minlen = len1;
      99                 :      39402 :         if (minlen > len2)
     100                 :            :                 minlen = len2;
     101                 :            : 
     102                 :      39402 :         cmp = memcmp(name1, name2, minlen);
     103                 :      39402 :         if (cmp == 0)
     104                 :        594 :                 cmp = len1 - len2;
     105                 :      39402 :         return cmp;
     106                 :            : }
     107                 :            : 
     108                 :            : /* Called under sysctl_lock */
     109                 :            : static struct ctl_table *find_entry(struct ctl_table_header **phead,
     110                 :            :         struct ctl_dir *dir, const char *name, int namelen)
     111                 :            : {
     112                 :            :         struct ctl_table_header *head;
     113                 :            :         struct ctl_table *entry;
     114                 :            :         struct rb_node *node = dir->root.rb_node;
     115                 :            : 
     116                 :            :         while (node)
     117                 :            :         {
     118                 :            :                 struct ctl_node *ctl_node;
     119                 :            :                 const char *procname;
     120                 :            :                 int cmp;
     121                 :            : 
     122                 :            :                 ctl_node = rb_entry(node, struct ctl_node, node);
     123                 :            :                 head = ctl_node->header;
     124                 :            :                 entry = &head->ctl_table[ctl_node - head->node];
     125                 :            :                 procname = entry->procname;
     126                 :            : 
     127                 :            :                 cmp = namecmp(name, namelen, procname, strlen(procname));
     128                 :            :                 if (cmp < 0)
     129                 :            :                         node = node->rb_left;
     130                 :            :                 else if (cmp > 0)
     131                 :            :                         node = node->rb_right;
     132                 :            :                 else {
     133                 :            :                         *phead = head;
     134                 :            :                         return entry;
     135                 :            :                 }
     136                 :            :         }
     137                 :            :         return NULL;
     138                 :            : }
     139                 :            : 
     140                 :      10373 : static int insert_entry(struct ctl_table_header *head, struct ctl_table *entry)
     141                 :            : {
     142                 :      10373 :         struct rb_node *node = &head->node[entry - head->ctl_table].node;
     143                 :      10373 :         struct rb_node **p = &head->parent->root.rb_node;
     144                 :      10373 :         struct rb_node *parent = NULL;
     145                 :      10373 :         const char *name = entry->procname;
     146                 :      10373 :         int namelen = strlen(name);
     147                 :            : 
     148         [ +  + ]:      49775 :         while (*p) {
     149                 :      39402 :                 struct ctl_table_header *parent_head;
     150                 :      39402 :                 struct ctl_table *parent_entry;
     151                 :      39402 :                 struct ctl_node *parent_node;
     152                 :      39402 :                 const char *parent_name;
     153                 :      39402 :                 int cmp;
     154                 :            : 
     155                 :      39402 :                 parent = *p;
     156                 :      39402 :                 parent_node = rb_entry(parent, struct ctl_node, node);
     157                 :      39402 :                 parent_head = parent_node->header;
     158                 :      39402 :                 parent_entry = &parent_head->ctl_table[parent_node - parent_head->node];
     159                 :      39402 :                 parent_name = parent_entry->procname;
     160                 :            : 
     161         [ +  + ]:      39402 :                 cmp = namecmp(name, namelen, parent_name, strlen(parent_name));
     162         [ +  + ]:      39402 :                 if (cmp < 0)
     163                 :      19107 :                         p = &(*p)->rb_left;
     164         [ +  - ]:      20295 :                 else if (cmp > 0)
     165                 :      20295 :                         p = &(*p)->rb_right;
     166                 :            :                 else {
     167                 :          0 :                         pr_err("sysctl duplicate entry: ");
     168                 :          0 :                         sysctl_print_dir(head->parent);
     169                 :          0 :                         pr_cont("/%s\n", entry->procname);
     170                 :          0 :                         return -EEXIST;
     171                 :            :                 }
     172                 :            :         }
     173                 :            : 
     174                 :      10373 :         rb_link_node(node, parent, p);
     175                 :      10373 :         rb_insert_color(node, &head->parent->root);
     176                 :      10373 :         return 0;
     177                 :            : }
     178                 :            : 
     179                 :          0 : static void erase_entry(struct ctl_table_header *head, struct ctl_table *entry)
     180                 :            : {
     181                 :          0 :         struct rb_node *node = &head->node[entry - head->ctl_table].node;
     182                 :            : 
     183                 :          0 :         rb_erase(node, &head->parent->root);
     184                 :            : }
     185                 :            : 
     186                 :       1408 : static void init_header(struct ctl_table_header *head,
     187                 :            :         struct ctl_table_root *root, struct ctl_table_set *set,
     188                 :            :         struct ctl_node *node, struct ctl_table *table)
     189                 :            : {
     190                 :       1408 :         head->ctl_table = table;
     191                 :       1408 :         head->ctl_table_arg = table;
     192                 :       1408 :         head->used = 0;
     193                 :       1408 :         head->count = 1;
     194                 :       1408 :         head->nreg = 1;
     195                 :       1408 :         head->unregistering = NULL;
     196                 :       1408 :         head->root = root;
     197                 :       1408 :         head->set = set;
     198                 :       1408 :         head->parent = NULL;
     199                 :       1408 :         head->node = node;
     200                 :       1408 :         INIT_HLIST_HEAD(&head->inodes);
     201                 :       1408 :         if (node) {
     202                 :            :                 struct ctl_table *entry;
     203   [ +  +  +  + ]:      11594 :                 for (entry = table; entry->procname; entry++, node++)
     204                 :      10208 :                         node->header = head;
     205                 :            :         }
     206                 :            : }
     207                 :            : 
     208                 :          0 : static void erase_header(struct ctl_table_header *head)
     209                 :            : {
     210                 :          0 :         struct ctl_table *entry;
     211         [ #  # ]:          0 :         for (entry = head->ctl_table; entry->procname; entry++)
     212                 :          0 :                 erase_entry(head, entry);
     213                 :          0 : }
     214                 :            : 
     215                 :       1463 : static int insert_header(struct ctl_dir *dir, struct ctl_table_header *header)
     216                 :            : {
     217                 :       1463 :         struct ctl_table *entry;
     218                 :       1463 :         int err;
     219                 :            : 
     220                 :            :         /* Is this a permanently empty directory? */
     221         [ +  - ]:       1463 :         if (is_empty_dir(&dir->header))
     222                 :            :                 return -EROFS;
     223                 :            : 
     224                 :            :         /* Am I creating a permanently empty directory? */
     225         [ +  + ]:       1463 :         if (header->ctl_table == sysctl_mount_point) {
     226         [ +  - ]:         11 :                 if (!RB_EMPTY_ROOT(&dir->root))
     227                 :            :                         return -EINVAL;
     228                 :         11 :                 set_empty_dir(dir);
     229                 :            :         }
     230                 :            : 
     231                 :       1463 :         dir->header.nreg++;
     232                 :       1463 :         header->parent = dir;
     233                 :       1463 :         err = insert_links(header);
     234         [ -  + ]:       1463 :         if (err)
     235                 :          0 :                 goto fail_links;
     236         [ +  + ]:      11836 :         for (entry = header->ctl_table; entry->procname; entry++) {
     237                 :      10373 :                 err = insert_entry(header, entry);
     238         [ -  + ]:      10373 :                 if (err)
     239                 :          0 :                         goto fail;
     240                 :            :         }
     241                 :            :         return 0;
     242                 :            : fail:
     243                 :          0 :         erase_header(header);
     244                 :          0 :         put_links(header);
     245                 :          0 : fail_links:
     246         [ #  # ]:          0 :         if (header->ctl_table == sysctl_mount_point)
     247                 :          0 :                 clear_empty_dir(dir);
     248                 :          0 :         header->parent = NULL;
     249                 :          0 :         drop_sysctl_table(&dir->header);
     250                 :          0 :         return err;
     251                 :            : }
     252                 :            : 
     253                 :            : /* called under sysctl_lock */
     254                 :       3575 : static int use_table(struct ctl_table_header *p)
     255                 :            : {
     256                 :       3575 :         if (unlikely(p->unregistering))
     257                 :            :                 return 0;
     258                 :       3575 :         p->used++;
     259                 :       3212 :         return 1;
     260                 :            : }
     261                 :            : 
     262                 :            : /* called under sysctl_lock */
     263                 :       3575 : static void unuse_table(struct ctl_table_header *p)
     264                 :            : {
     265                 :       3575 :         if (!--p->used)
     266   [ -  +  -  -  :       3575 :                 if (unlikely(p->unregistering))
                   -  + ]
     267                 :          0 :                         complete(p->unregistering);
     268                 :            : }
     269                 :            : 
     270                 :            : static void proc_sys_prune_dcache(struct ctl_table_header *head)
     271                 :            : {
     272                 :            :         struct inode *inode;
     273                 :            :         struct proc_inode *ei;
     274                 :            :         struct hlist_node *node;
     275                 :            :         struct super_block *sb;
     276                 :            : 
     277                 :            :         rcu_read_lock();
     278                 :            :         for (;;) {
     279                 :            :                 node = hlist_first_rcu(&head->inodes);
     280                 :            :                 if (!node)
     281                 :            :                         break;
     282                 :            :                 ei = hlist_entry(node, struct proc_inode, sysctl_inodes);
     283                 :            :                 spin_lock(&sysctl_lock);
     284                 :            :                 hlist_del_init_rcu(&ei->sysctl_inodes);
     285                 :            :                 spin_unlock(&sysctl_lock);
     286                 :            : 
     287                 :            :                 inode = &ei->vfs_inode;
     288                 :            :                 sb = inode->i_sb;
     289                 :            :                 if (!atomic_inc_not_zero(&sb->s_active))
     290                 :            :                         continue;
     291                 :            :                 inode = igrab(inode);
     292                 :            :                 rcu_read_unlock();
     293                 :            :                 if (unlikely(!inode)) {
     294                 :            :                         deactivate_super(sb);
     295                 :            :                         rcu_read_lock();
     296                 :            :                         continue;
     297                 :            :                 }
     298                 :            : 
     299                 :            :                 d_prune_aliases(inode);
     300                 :            :                 iput(inode);
     301                 :            :                 deactivate_super(sb);
     302                 :            : 
     303                 :            :                 rcu_read_lock();
     304                 :            :         }
     305                 :            :         rcu_read_unlock();
     306                 :            : }
     307                 :            : 
     308                 :            : /* called under sysctl_lock, will reacquire if has to wait */
     309                 :          0 : static void start_unregistering(struct ctl_table_header *p)
     310                 :            : {
     311                 :            :         /*
     312                 :            :          * if p->used is 0, nobody will ever touch that entry again;
     313                 :            :          * we'll eliminate all paths to it before dropping sysctl_lock
     314                 :            :          */
     315         [ #  # ]:          0 :         if (unlikely(p->used)) {
     316                 :          0 :                 struct completion wait;
     317                 :          0 :                 init_completion(&wait);
     318                 :          0 :                 p->unregistering = &wait;
     319                 :          0 :                 spin_unlock(&sysctl_lock);
     320                 :          0 :                 wait_for_completion(&wait);
     321                 :            :         } else {
     322                 :            :                 /* anything non-NULL; we'll never dereference it */
     323                 :          0 :                 p->unregistering = ERR_PTR(-EINVAL);
     324                 :          0 :                 spin_unlock(&sysctl_lock);
     325                 :            :         }
     326                 :            :         /*
     327                 :            :          * Prune dentries for unregistered sysctls: namespaced sysctls
     328                 :            :          * can have duplicate names and contaminate dcache very badly.
     329                 :            :          */
     330                 :          0 :         proc_sys_prune_dcache(p);
     331                 :            :         /*
     332                 :            :          * do not remove from the list until nobody holds it; walking the
     333                 :            :          * list in do_sysctl() relies on that.
     334                 :            :          */
     335                 :          0 :         spin_lock(&sysctl_lock);
     336                 :          0 :         erase_header(p);
     337                 :          0 : }
     338                 :            : 
     339                 :       3212 : static struct ctl_table_header *sysctl_head_grab(struct ctl_table_header *head)
     340                 :            : {
     341         [ -  + ]:       3212 :         BUG_ON(!head);
     342                 :       3212 :         spin_lock(&sysctl_lock);
     343         [ +  - ]:       3212 :         if (!use_table(head))
     344                 :            :                 head = ERR_PTR(-ENOENT);
     345                 :       3212 :         spin_unlock(&sysctl_lock);
     346                 :       3212 :         return head;
     347                 :            : }
     348                 :            : 
     349                 :       3542 : static void sysctl_head_finish(struct ctl_table_header *head)
     350                 :            : {
     351         [ +  - ]:       3542 :         if (!head)
     352                 :            :                 return;
     353                 :       3542 :         spin_lock(&sysctl_lock);
     354         [ +  - ]:       3542 :         unuse_table(head);
     355                 :       3542 :         spin_unlock(&sysctl_lock);
     356                 :            : }
     357                 :            : 
     358                 :            : static struct ctl_table_set *
     359                 :         33 : lookup_header_set(struct ctl_table_root *root)
     360                 :            : {
     361                 :         33 :         struct ctl_table_set *set = &root->default_set;
     362                 :         33 :         if (root->lookup)
     363                 :         33 :                 set = root->lookup(root);
     364                 :         33 :         return set;
     365                 :            : }
     366                 :            : 
     367                 :        385 : static struct ctl_table *lookup_entry(struct ctl_table_header **phead,
     368                 :            :                                       struct ctl_dir *dir,
     369                 :            :                                       const char *name, int namelen)
     370                 :            : {
     371                 :        385 :         struct ctl_table_header *head;
     372                 :        385 :         struct ctl_table *entry;
     373                 :            : 
     374                 :        385 :         spin_lock(&sysctl_lock);
     375                 :        385 :         entry = find_entry(&head, dir, name, namelen);
     376   [ +  +  +  - ]:        385 :         if (entry && use_table(head))
     377                 :        330 :                 *phead = head;
     378                 :            :         else
     379                 :            :                 entry = NULL;
     380                 :        385 :         spin_unlock(&sysctl_lock);
     381                 :        385 :         return entry;
     382                 :            : }
     383                 :            : 
     384                 :          0 : static struct ctl_node *first_usable_entry(struct rb_node *node)
     385                 :            : {
     386                 :          0 :         struct ctl_node *ctl_node;
     387                 :            : 
     388         [ #  # ]:          0 :         for (;node; node = rb_next(node)) {
     389                 :          0 :                 ctl_node = rb_entry(node, struct ctl_node, node);
     390         [ #  # ]:          0 :                 if (use_table(ctl_node->header))
     391                 :          0 :                         return ctl_node;
     392                 :            :         }
     393                 :            :         return NULL;
     394                 :            : }
     395                 :            : 
     396                 :          0 : static void first_entry(struct ctl_dir *dir,
     397                 :            :         struct ctl_table_header **phead, struct ctl_table **pentry)
     398                 :            : {
     399                 :          0 :         struct ctl_table_header *head = NULL;
     400                 :          0 :         struct ctl_table *entry = NULL;
     401                 :          0 :         struct ctl_node *ctl_node;
     402                 :            : 
     403                 :          0 :         spin_lock(&sysctl_lock);
     404                 :          0 :         ctl_node = first_usable_entry(rb_first(&dir->root));
     405                 :          0 :         spin_unlock(&sysctl_lock);
     406         [ #  # ]:          0 :         if (ctl_node) {
     407                 :          0 :                 head = ctl_node->header;
     408                 :          0 :                 entry = &head->ctl_table[ctl_node - head->node];
     409                 :            :         }
     410                 :          0 :         *phead = head;
     411                 :          0 :         *pentry = entry;
     412                 :          0 : }
     413                 :            : 
     414                 :          0 : static void next_entry(struct ctl_table_header **phead, struct ctl_table **pentry)
     415                 :            : {
     416                 :          0 :         struct ctl_table_header *head = *phead;
     417                 :          0 :         struct ctl_table *entry = *pentry;
     418                 :          0 :         struct ctl_node *ctl_node = &head->node[entry - head->ctl_table];
     419                 :            : 
     420                 :          0 :         spin_lock(&sysctl_lock);
     421         [ #  # ]:          0 :         unuse_table(head);
     422                 :            : 
     423                 :          0 :         ctl_node = first_usable_entry(rb_next(&ctl_node->node));
     424                 :          0 :         spin_unlock(&sysctl_lock);
     425                 :          0 :         head = NULL;
     426         [ #  # ]:          0 :         if (ctl_node) {
     427                 :          0 :                 head = ctl_node->header;
     428                 :          0 :                 entry = &head->ctl_table[ctl_node - head->node];
     429                 :            :         }
     430                 :          0 :         *phead = head;
     431                 :          0 :         *pentry = entry;
     432                 :          0 : }
     433                 :            : 
     434                 :            : /*
     435                 :            :  * sysctl_perm does NOT grant the superuser all rights automatically, because
     436                 :            :  * some sysctl variables are readonly even to root.
     437                 :            :  */
     438                 :            : 
     439                 :       1551 : static int test_perm(int mode, int op)
     440                 :            : {
     441         [ +  + ]:       1551 :         if (uid_eq(current_euid(), GLOBAL_ROOT_UID))
     442                 :       1496 :                 mode >>= 6;
     443         [ -  + ]:         55 :         else if (in_egroup_p(GLOBAL_ROOT_GID))
     444                 :          0 :                 mode >>= 3;
     445         [ +  + ]:       1551 :         if ((op & ~mode & (MAY_READ|MAY_WRITE|MAY_EXEC)) == 0)
     446                 :       1540 :                 return 0;
     447                 :            :         return -EACCES;
     448                 :            : }
     449                 :            : 
     450                 :       1551 : static int sysctl_perm(struct ctl_table_header *head, struct ctl_table *table, int op)
     451                 :            : {
     452                 :       1551 :         struct ctl_table_root *root = head->root;
     453                 :       1551 :         int mode;
     454                 :            : 
     455         [ +  + ]:       1551 :         if (root->permissions)
     456                 :        143 :                 mode = root->permissions(head, table);
     457                 :            :         else
     458                 :       1408 :                 mode = table->mode;
     459                 :            : 
     460                 :       1551 :         return test_perm(mode, op);
     461                 :            : }
     462                 :            : 
     463                 :        330 : static struct inode *proc_sys_make_inode(struct super_block *sb,
     464                 :            :                 struct ctl_table_header *head, struct ctl_table *table)
     465                 :            : {
     466                 :        330 :         struct ctl_table_root *root = head->root;
     467                 :        330 :         struct inode *inode;
     468                 :        330 :         struct proc_inode *ei;
     469                 :            : 
     470                 :        330 :         inode = new_inode(sb);
     471         [ +  - ]:        330 :         if (!inode)
     472                 :            :                 return ERR_PTR(-ENOMEM);
     473                 :            : 
     474                 :        330 :         inode->i_ino = get_next_ino();
     475                 :            : 
     476                 :        330 :         ei = PROC_I(inode);
     477                 :            : 
     478                 :        330 :         spin_lock(&sysctl_lock);
     479         [ -  + ]:        330 :         if (unlikely(head->unregistering)) {
     480                 :          0 :                 spin_unlock(&sysctl_lock);
     481                 :          0 :                 iput(inode);
     482                 :          0 :                 return ERR_PTR(-ENOENT);
     483                 :            :         }
     484                 :        330 :         ei->sysctl = head;
     485                 :        330 :         ei->sysctl_entry = table;
     486                 :        330 :         hlist_add_head_rcu(&ei->sysctl_inodes, &head->inodes);
     487                 :        330 :         head->count++;
     488                 :        330 :         spin_unlock(&sysctl_lock);
     489                 :            : 
     490                 :        330 :         inode->i_mtime = inode->i_atime = inode->i_ctime = current_time(inode);
     491                 :        330 :         inode->i_mode = table->mode;
     492         [ +  + ]:        330 :         if (!S_ISDIR(table->mode)) {
     493                 :        220 :                 inode->i_mode |= S_IFREG;
     494                 :        220 :                 inode->i_op = &proc_sys_inode_operations;
     495                 :        220 :                 inode->i_fop = &proc_sys_file_operations;
     496                 :            :         } else {
     497                 :        110 :                 inode->i_mode |= S_IFDIR;
     498                 :        110 :                 inode->i_op = &proc_sys_dir_operations;
     499                 :        110 :                 inode->i_fop = &proc_sys_dir_file_operations;
     500         [ +  + ]:        110 :                 if (is_empty_dir(head))
     501                 :         11 :                         make_empty_dir_inode(inode);
     502                 :            :         }
     503                 :            : 
     504         [ +  + ]:        330 :         if (root->set_ownership)
     505                 :         55 :                 root->set_ownership(head, table, &inode->i_uid, &inode->i_gid);
     506                 :            :         else {
     507                 :        275 :                 inode->i_uid = GLOBAL_ROOT_UID;
     508                 :        275 :                 inode->i_gid = GLOBAL_ROOT_GID;
     509                 :            :         }
     510                 :            : 
     511                 :            :         return inode;
     512                 :            : }
     513                 :            : 
     514                 :          0 : void proc_sys_evict_inode(struct inode *inode, struct ctl_table_header *head)
     515                 :            : {
     516                 :          0 :         spin_lock(&sysctl_lock);
     517         [ #  # ]:          0 :         hlist_del_init_rcu(&PROC_I(inode)->sysctl_inodes);
     518         [ #  # ]:          0 :         if (!--head->count)
     519         [ #  # ]:          0 :                 kfree_rcu(head, rcu);
     520                 :          0 :         spin_unlock(&sysctl_lock);
     521                 :          0 : }
     522                 :            : 
     523                 :       3212 : static struct ctl_table_header *grab_header(struct inode *inode)
     524                 :            : {
     525         [ #  # ]:          0 :         struct ctl_table_header *head = PROC_I(inode)->sysctl;
     526   [ +  +  +  +  :       3212 :         if (!head)
          -  -  -  +  -  
             +  -  +  +  
                      + ]
     527                 :        792 :                 head = &sysctl_table_root.default_set.dir.header;
     528                 :       3212 :         return sysctl_head_grab(head);
     529                 :            : }
     530                 :            : 
     531                 :        385 : static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
     532                 :            :                                         unsigned int flags)
     533                 :            : {
     534         [ +  + ]:        385 :         struct ctl_table_header *head = grab_header(dir);
     535                 :        385 :         struct ctl_table_header *h = NULL;
     536                 :        385 :         const struct qstr *name = &dentry->d_name;
     537                 :        385 :         struct ctl_table *p;
     538                 :        385 :         struct inode *inode;
     539         [ +  - ]:        385 :         struct dentry *err = ERR_PTR(-ENOENT);
     540                 :        385 :         struct ctl_dir *ctl_dir;
     541                 :        385 :         int ret;
     542                 :            : 
     543         [ +  - ]:        385 :         if (IS_ERR(head))
     544                 :            :                 return ERR_CAST(head);
     545                 :            : 
     546                 :        385 :         ctl_dir = container_of(head, struct ctl_dir, header);
     547                 :            : 
     548                 :        385 :         p = lookup_entry(&h, ctl_dir, name->name, name->len);
     549         [ +  + ]:        385 :         if (!p)
     550                 :         55 :                 goto out;
     551                 :            : 
     552         [ +  + ]:        330 :         if (S_ISLNK(p->mode)) {
     553                 :         33 :                 ret = sysctl_follow_link(&h, &p);
     554         [ -  + ]:         33 :                 err = ERR_PTR(ret);
     555         [ -  + ]:         33 :                 if (ret)
     556                 :          0 :                         goto out;
     557                 :            :         }
     558                 :            : 
     559         [ +  - ]:        660 :         inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p);
     560         [ -  + ]:        330 :         if (IS_ERR(inode)) {
     561                 :          0 :                 err = ERR_CAST(inode);
     562                 :          0 :                 goto out;
     563                 :            :         }
     564                 :            : 
     565                 :        330 :         d_set_d_op(dentry, &proc_sys_dentry_operations);
     566                 :        330 :         err = d_splice_alias(inode, dentry);
     567                 :            : 
     568                 :        385 : out:
     569         [ +  + ]:        385 :         if (h)
     570                 :        330 :                 sysctl_head_finish(h);
     571                 :        385 :         sysctl_head_finish(head);
     572                 :        385 :         return err;
     573                 :            : }
     574                 :            : 
     575                 :        440 : static ssize_t proc_sys_call_handler(struct file *filp, void __user *buf,
     576                 :            :                 size_t count, loff_t *ppos, int write)
     577                 :            : {
     578         [ -  + ]:        440 :         struct inode *inode = file_inode(filp);
     579         [ -  + ]:        440 :         struct ctl_table_header *head = grab_header(inode);
     580         [ -  + ]:        440 :         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
     581                 :        440 :         void *new_buf = NULL;
     582                 :        440 :         ssize_t error;
     583                 :            : 
     584         [ -  + ]:        440 :         if (IS_ERR(head))
     585                 :          0 :                 return PTR_ERR(head);
     586                 :            : 
     587                 :            :         /*
     588                 :            :          * At this point we know that the sysctl was not unregistered
     589                 :            :          * and won't be until we finish.
     590                 :            :          */
     591                 :        440 :         error = -EPERM;
     592   [ +  +  -  + ]:        770 :         if (sysctl_perm(head, table, write ? MAY_WRITE : MAY_READ))
     593                 :          0 :                 goto out;
     594                 :            : 
     595                 :            :         /* if that can happen at all, it should be -EINVAL, not -EISDIR */
     596                 :        440 :         error = -EINVAL;
     597         [ -  + ]:        440 :         if (!table->proc_handler)
     598                 :          0 :                 goto out;
     599                 :            : 
     600                 :        440 :         error = BPF_CGROUP_RUN_PROG_SYSCTL(head, table, write, buf, &count,
     601                 :            :                                            ppos, &new_buf);
     602                 :        440 :         if (error)
     603                 :            :                 goto out;
     604                 :            : 
     605                 :            :         /* careful: calling conventions are nasty here */
     606                 :        440 :         if (new_buf) {
     607                 :            :                 mm_segment_t old_fs;
     608                 :            : 
     609                 :            :                 old_fs = get_fs();
     610                 :            :                 set_fs(KERNEL_DS);
     611                 :            :                 error = table->proc_handler(table, write, (void __user *)new_buf,
     612                 :            :                                             &count, ppos);
     613                 :            :                 set_fs(old_fs);
     614                 :            :                 kfree(new_buf);
     615                 :            :         } else {
     616                 :        440 :                 error = table->proc_handler(table, write, buf, &count, ppos);
     617                 :            :         }
     618                 :            : 
     619         [ -  + ]:        440 :         if (!error)
     620                 :        440 :                 error = count;
     621                 :          0 : out:
     622                 :        440 :         sysctl_head_finish(head);
     623                 :            : 
     624                 :        440 :         return error;
     625                 :            : }
     626                 :            : 
     627                 :        330 : static ssize_t proc_sys_read(struct file *filp, char __user *buf,
     628                 :            :                                 size_t count, loff_t *ppos)
     629                 :            : {
     630                 :        330 :         return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 0);
     631                 :            : }
     632                 :            : 
     633                 :        110 : static ssize_t proc_sys_write(struct file *filp, const char __user *buf,
     634                 :            :                                 size_t count, loff_t *ppos)
     635                 :            : {
     636                 :        110 :         return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 1);
     637                 :            : }
     638                 :            : 
     639                 :        308 : static int proc_sys_open(struct inode *inode, struct file *filp)
     640                 :            : {
     641         [ -  + ]:        308 :         struct ctl_table_header *head = grab_header(inode);
     642         [ -  + ]:        308 :         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
     643                 :            : 
     644                 :            :         /* sysctl was unregistered */
     645         [ -  + ]:        308 :         if (IS_ERR(head))
     646                 :          0 :                 return PTR_ERR(head);
     647                 :            : 
     648         [ +  + ]:        308 :         if (table->poll)
     649                 :         11 :                 filp->private_data = proc_sys_poll_event(table->poll);
     650                 :            : 
     651                 :        308 :         sysctl_head_finish(head);
     652                 :            : 
     653                 :        308 :         return 0;
     654                 :            : }
     655                 :            : 
     656                 :         11 : static __poll_t proc_sys_poll(struct file *filp, poll_table *wait)
     657                 :            : {
     658         [ -  + ]:         11 :         struct inode *inode = file_inode(filp);
     659         [ -  + ]:         11 :         struct ctl_table_header *head = grab_header(inode);
     660         [ +  - ]:         11 :         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
     661                 :         11 :         __poll_t ret = DEFAULT_POLLMASK;
     662                 :         11 :         unsigned long event;
     663                 :            : 
     664                 :            :         /* sysctl was unregistered */
     665         [ +  - ]:         11 :         if (IS_ERR(head))
     666                 :            :                 return EPOLLERR | EPOLLHUP;
     667                 :            : 
     668         [ -  + ]:         11 :         if (!table->proc_handler)
     669                 :          0 :                 goto out;
     670                 :            : 
     671         [ -  + ]:         11 :         if (!table->poll)
     672                 :          0 :                 goto out;
     673                 :            : 
     674                 :         11 :         event = (unsigned long)filp->private_data;
     675         [ +  - ]:         11 :         poll_wait(filp, &table->poll->wait, wait);
     676                 :            : 
     677         [ +  - ]:         11 :         if (event != atomic_read(&table->poll->event)) {
     678                 :          0 :                 filp->private_data = proc_sys_poll_event(table->poll);
     679                 :          0 :                 ret = EPOLLIN | EPOLLRDNORM | EPOLLERR | EPOLLPRI;
     680                 :            :         }
     681                 :            : 
     682                 :         11 : out:
     683                 :         11 :         sysctl_head_finish(head);
     684                 :            : 
     685                 :         11 :         return ret;
     686                 :            : }
     687                 :            : 
     688                 :            : static bool proc_sys_fill_cache(struct file *file,
     689                 :            :                                 struct dir_context *ctx,
     690                 :            :                                 struct ctl_table_header *head,
     691                 :            :                                 struct ctl_table *table)
     692                 :            : {
     693                 :            :         struct dentry *child, *dir = file->f_path.dentry;
     694                 :            :         struct inode *inode;
     695                 :            :         struct qstr qname;
     696                 :            :         ino_t ino = 0;
     697                 :            :         unsigned type = DT_UNKNOWN;
     698                 :            : 
     699                 :            :         qname.name = table->procname;
     700                 :            :         qname.len  = strlen(table->procname);
     701                 :            :         qname.hash = full_name_hash(dir, qname.name, qname.len);
     702                 :            : 
     703                 :            :         child = d_lookup(dir, &qname);
     704                 :            :         if (!child) {
     705                 :            :                 DECLARE_WAIT_QUEUE_HEAD_ONSTACK(wq);
     706                 :            :                 child = d_alloc_parallel(dir, &qname, &wq);
     707                 :            :                 if (IS_ERR(child))
     708                 :            :                         return false;
     709                 :            :                 if (d_in_lookup(child)) {
     710                 :            :                         struct dentry *res;
     711                 :            :                         inode = proc_sys_make_inode(dir->d_sb, head, table);
     712                 :            :                         if (IS_ERR(inode)) {
     713                 :            :                                 d_lookup_done(child);
     714                 :            :                                 dput(child);
     715                 :            :                                 return false;
     716                 :            :                         }
     717                 :            :                         d_set_d_op(child, &proc_sys_dentry_operations);
     718                 :            :                         res = d_splice_alias(inode, child);
     719                 :            :                         d_lookup_done(child);
     720                 :            :                         if (unlikely(res)) {
     721                 :            :                                 if (IS_ERR(res)) {
     722                 :            :                                         dput(child);
     723                 :            :                                         return false;
     724                 :            :                                 }
     725                 :            :                                 dput(child);
     726                 :            :                                 child = res;
     727                 :            :                         }
     728                 :            :                 }
     729                 :            :         }
     730                 :            :         inode = d_inode(child);
     731                 :            :         ino  = inode->i_ino;
     732                 :            :         type = inode->i_mode >> 12;
     733                 :            :         dput(child);
     734                 :            :         return dir_emit(ctx, qname.name, qname.len, ino, type);
     735                 :            : }
     736                 :            : 
     737                 :          0 : static bool proc_sys_link_fill_cache(struct file *file,
     738                 :            :                                     struct dir_context *ctx,
     739                 :            :                                     struct ctl_table_header *head,
     740                 :            :                                     struct ctl_table *table)
     741                 :            : {
     742                 :          0 :         bool ret = true;
     743                 :            : 
     744                 :          0 :         head = sysctl_head_grab(head);
     745         [ #  # ]:          0 :         if (IS_ERR(head))
     746                 :            :                 return false;
     747                 :            : 
     748                 :            :         /* It is not an error if we can not follow the link ignore it */
     749         [ #  # ]:          0 :         if (sysctl_follow_link(&head, &table))
     750                 :          0 :                 goto out;
     751                 :            : 
     752                 :          0 :         ret = proc_sys_fill_cache(file, ctx, head, table);
     753                 :          0 : out:
     754                 :          0 :         sysctl_head_finish(head);
     755                 :          0 :         return ret;
     756                 :            : }
     757                 :            : 
     758                 :          0 : static int scan(struct ctl_table_header *head, struct ctl_table *table,
     759                 :            :                 unsigned long *pos, struct file *file,
     760                 :            :                 struct dir_context *ctx)
     761                 :            : {
     762                 :          0 :         bool res;
     763                 :            : 
     764         [ #  # ]:          0 :         if ((*pos)++ < ctx->pos)
     765                 :            :                 return true;
     766                 :            : 
     767         [ #  # ]:          0 :         if (unlikely(S_ISLNK(table->mode)))
     768                 :          0 :                 res = proc_sys_link_fill_cache(file, ctx, head, table);
     769                 :            :         else
     770                 :          0 :                 res = proc_sys_fill_cache(file, ctx, head, table);
     771                 :            : 
     772         [ #  # ]:          0 :         if (res)
     773                 :          0 :                 ctx->pos = *pos;
     774                 :            : 
     775                 :          0 :         return res;
     776                 :            : }
     777                 :            : 
     778                 :          0 : static int proc_sys_readdir(struct file *file, struct dir_context *ctx)
     779                 :            : {
     780         [ #  # ]:          0 :         struct ctl_table_header *head = grab_header(file_inode(file));
     781                 :          0 :         struct ctl_table_header *h = NULL;
     782                 :          0 :         struct ctl_table *entry;
     783                 :          0 :         struct ctl_dir *ctl_dir;
     784                 :          0 :         unsigned long pos;
     785                 :            : 
     786         [ #  # ]:          0 :         if (IS_ERR(head))
     787                 :          0 :                 return PTR_ERR(head);
     788                 :            : 
     789                 :          0 :         ctl_dir = container_of(head, struct ctl_dir, header);
     790                 :            : 
     791         [ #  # ]:          0 :         if (!dir_emit_dots(file, ctx))
     792                 :          0 :                 goto out;
     793                 :            : 
     794                 :          0 :         pos = 2;
     795                 :            : 
     796         [ #  # ]:          0 :         for (first_entry(ctl_dir, &h, &entry); h; next_entry(&h, &entry)) {
     797         [ #  # ]:          0 :                 if (!scan(h, entry, &pos, file, ctx)) {
     798                 :          0 :                         sysctl_head_finish(h);
     799                 :          0 :                         break;
     800                 :            :                 }
     801                 :            :         }
     802                 :          0 : out:
     803                 :          0 :         sysctl_head_finish(head);
     804                 :          0 :         return 0;
     805                 :            : }
     806                 :            : 
     807                 :       1793 : static int proc_sys_permission(struct inode *inode, int mask)
     808                 :            : {
     809                 :            :         /*
     810                 :            :          * sysctl entries that are not writeable,
     811                 :            :          * are _NOT_ writeable, capabilities or not.
     812                 :            :          */
     813                 :       1793 :         struct ctl_table_header *head;
     814                 :       1793 :         struct ctl_table *table;
     815                 :       1793 :         int error;
     816                 :            : 
     817                 :            :         /* Executable files are not allowed under /proc/sys/ */
     818   [ +  +  +  - ]:       1793 :         if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))
     819                 :            :                 return -EACCES;
     820                 :            : 
     821         [ +  + ]:       1793 :         head = grab_header(inode);
     822         [ -  + ]:       1793 :         if (IS_ERR(head))
     823                 :          0 :                 return PTR_ERR(head);
     824                 :            : 
     825         [ +  + ]:       1793 :         table = PROC_I(inode)->sysctl_entry;
     826         [ +  + ]:       1793 :         if (!table) /* global root - r-xr-xr-x */
     827         [ +  + ]:        682 :                 error = mask & MAY_WRITE ? -EACCES : 0;
     828                 :            :         else /* Use the permissions on the sysctl table entry */
     829                 :       1111 :                 error = sysctl_perm(head, table, mask & ~MAY_NOT_BLOCK);
     830                 :            : 
     831                 :       1793 :         sysctl_head_finish(head);
     832                 :       1793 :         return error;
     833                 :            : }
     834                 :            : 
     835                 :         22 : static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
     836                 :            : {
     837         [ +  - ]:         22 :         struct inode *inode = d_inode(dentry);
     838                 :         22 :         int error;
     839                 :            : 
     840         [ +  - ]:         22 :         if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
     841                 :            :                 return -EPERM;
     842                 :            : 
     843                 :         22 :         error = setattr_prepare(dentry, attr);
     844         [ +  - ]:         22 :         if (error)
     845                 :            :                 return error;
     846                 :            : 
     847                 :         22 :         setattr_copy(inode, attr);
     848                 :         22 :         mark_inode_dirty(inode);
     849                 :         22 :         return 0;
     850                 :            : }
     851                 :            : 
     852                 :        275 : static int proc_sys_getattr(const struct path *path, struct kstat *stat,
     853                 :            :                             u32 request_mask, unsigned int query_flags)
     854                 :            : {
     855         [ +  + ]:        275 :         struct inode *inode = d_inode(path->dentry);
     856         [ +  + ]:        275 :         struct ctl_table_header *head = grab_header(inode);
     857         [ -  + ]:        275 :         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
     858                 :            : 
     859         [ -  + ]:        275 :         if (IS_ERR(head))
     860                 :          0 :                 return PTR_ERR(head);
     861                 :            : 
     862                 :        275 :         generic_fillattr(inode, stat);
     863         [ +  + ]:        275 :         if (table)
     864                 :        209 :                 stat->mode = (stat->mode & S_IFMT) | table->mode;
     865                 :            : 
     866                 :        275 :         sysctl_head_finish(head);
     867                 :        275 :         return 0;
     868                 :            : }
     869                 :            : 
     870                 :            : static const struct file_operations proc_sys_file_operations = {
     871                 :            :         .open           = proc_sys_open,
     872                 :            :         .poll           = proc_sys_poll,
     873                 :            :         .read           = proc_sys_read,
     874                 :            :         .write          = proc_sys_write,
     875                 :            :         .llseek         = default_llseek,
     876                 :            : };
     877                 :            : 
     878                 :            : static const struct file_operations proc_sys_dir_file_operations = {
     879                 :            :         .read           = generic_read_dir,
     880                 :            :         .iterate_shared = proc_sys_readdir,
     881                 :            :         .llseek         = generic_file_llseek,
     882                 :            : };
     883                 :            : 
     884                 :            : static const struct inode_operations proc_sys_inode_operations = {
     885                 :            :         .permission     = proc_sys_permission,
     886                 :            :         .setattr        = proc_sys_setattr,
     887                 :            :         .getattr        = proc_sys_getattr,
     888                 :            : };
     889                 :            : 
     890                 :            : static const struct inode_operations proc_sys_dir_operations = {
     891                 :            :         .lookup         = proc_sys_lookup,
     892                 :            :         .permission     = proc_sys_permission,
     893                 :            :         .setattr        = proc_sys_setattr,
     894                 :            :         .getattr        = proc_sys_getattr,
     895                 :            : };
     896                 :            : 
     897                 :       1166 : static int proc_sys_revalidate(struct dentry *dentry, unsigned int flags)
     898                 :            : {
     899         [ +  + ]:       1166 :         if (flags & LOOKUP_RCU)
     900                 :            :                 return -ECHILD;
     901                 :       1056 :         return !PROC_I(d_inode(dentry))->sysctl->unregistering;
     902                 :            : }
     903                 :            : 
     904                 :        462 : static int proc_sys_delete(const struct dentry *dentry)
     905                 :            : {
     906                 :        462 :         return !!PROC_I(d_inode(dentry))->sysctl->unregistering;
     907                 :            : }
     908                 :            : 
     909                 :            : static int sysctl_is_seen(struct ctl_table_header *p)
     910                 :            : {
     911                 :            :         struct ctl_table_set *set = p->set;
     912                 :            :         int res;
     913                 :            :         spin_lock(&sysctl_lock);
     914                 :            :         if (p->unregistering)
     915                 :            :                 res = 0;
     916                 :            :         else if (!set->is_seen)
     917                 :            :                 res = 1;
     918                 :            :         else
     919                 :            :                 res = set->is_seen(set);
     920                 :            :         spin_unlock(&sysctl_lock);
     921                 :            :         return res;
     922                 :            : }
     923                 :            : 
     924                 :        440 : static int proc_sys_compare(const struct dentry *dentry,
     925                 :            :                 unsigned int len, const char *str, const struct qstr *name)
     926                 :            : {
     927                 :        440 :         struct ctl_table_header *head;
     928                 :        440 :         struct inode *inode;
     929                 :            : 
     930                 :            :         /* Although proc doesn't have negative dentries, rcu-walk means
     931                 :            :          * that inode here can be NULL */
     932                 :            :         /* AV: can it, indeed? */
     933         [ +  - ]:        440 :         inode = d_inode_rcu(dentry);
     934         [ +  - ]:        440 :         if (!inode)
     935                 :            :                 return 1;
     936         [ +  - ]:        440 :         if (name->len != len)
     937                 :            :                 return 1;
     938         [ +  - ]:        440 :         if (memcmp(name->name, str, len))
     939                 :            :                 return 1;
     940         [ +  - ]:        440 :         head = rcu_dereference(PROC_I(inode)->sysctl);
     941   [ +  -  -  + ]:        440 :         return !head || !sysctl_is_seen(head);
     942                 :            : }
     943                 :            : 
     944                 :            : static const struct dentry_operations proc_sys_dentry_operations = {
     945                 :            :         .d_revalidate   = proc_sys_revalidate,
     946                 :            :         .d_delete       = proc_sys_delete,
     947                 :            :         .d_compare      = proc_sys_compare,
     948                 :            : };
     949                 :            : 
     950                 :       3784 : static struct ctl_dir *find_subdir(struct ctl_dir *dir,
     951                 :            :                                    const char *name, int namelen)
     952                 :            : {
     953                 :       3784 :         struct ctl_table_header *head;
     954                 :       3784 :         struct ctl_table *entry;
     955                 :            : 
     956                 :       3784 :         entry = find_entry(&head, dir, name, namelen);
     957         [ +  + ]:       3784 :         if (!entry)
     958                 :            :                 return ERR_PTR(-ENOENT);
     959         [ +  + ]:       2552 :         if (!S_ISDIR(entry->mode))
     960                 :            :                 return ERR_PTR(-ENOTDIR);
     961                 :       1903 :         return container_of(head, struct ctl_dir, header);
     962                 :            : }
     963                 :            : 
     964                 :        616 : static struct ctl_dir *new_dir(struct ctl_table_set *set,
     965                 :            :                                const char *name, int namelen)
     966                 :            : {
     967                 :        616 :         struct ctl_table *table;
     968                 :        616 :         struct ctl_dir *new;
     969                 :        616 :         struct ctl_node *node;
     970                 :        616 :         char *new_name;
     971                 :            : 
     972                 :        616 :         new = kzalloc(sizeof(*new) + sizeof(struct ctl_node) +
     973                 :            :                       sizeof(struct ctl_table)*2 +  namelen + 1,
     974                 :            :                       GFP_KERNEL);
     975         [ +  - ]:        616 :         if (!new)
     976                 :            :                 return NULL;
     977                 :            : 
     978                 :        616 :         node = (struct ctl_node *)(new + 1);
     979                 :        616 :         table = (struct ctl_table *)(node + 1);
     980                 :        616 :         new_name = (char *)(table + 2);
     981                 :        616 :         memcpy(new_name, name, namelen);
     982                 :        616 :         new_name[namelen] = '\0';
     983                 :        616 :         table[0].procname = new_name;
     984                 :        616 :         table[0].mode = S_IFDIR|S_IRUGO|S_IXUGO;
     985         [ +  - ]:        616 :         init_header(&new->header, set->dir.header.root, set, node, table);
     986                 :            : 
     987                 :            :         return new;
     988                 :            : }
     989                 :            : 
     990                 :            : /**
     991                 :            :  * get_subdir - find or create a subdir with the specified name.
     992                 :            :  * @dir:  Directory to create the subdirectory in
     993                 :            :  * @name: The name of the subdirectory to find or create
     994                 :            :  * @namelen: The length of name
     995                 :            :  *
     996                 :            :  * Takes a directory with an elevated reference count so we know that
     997                 :            :  * if we drop the lock the directory will not go away.  Upon success
     998                 :            :  * the reference is moved from @dir to the returned subdirectory.
     999                 :            :  * Upon error an error code is returned and the reference on @dir is
    1000                 :            :  * simply dropped.
    1001                 :            :  */
    1002                 :       1760 : static struct ctl_dir *get_subdir(struct ctl_dir *dir,
    1003                 :            :                                   const char *name, int namelen)
    1004                 :            : {
    1005                 :       1760 :         struct ctl_table_set *set = dir->header.set;
    1006                 :       1760 :         struct ctl_dir *subdir, *new = NULL;
    1007                 :       1760 :         int err;
    1008                 :            : 
    1009                 :       1760 :         spin_lock(&sysctl_lock);
    1010                 :       1760 :         subdir = find_subdir(dir, name, namelen);
    1011         [ +  + ]:       1760 :         if (!IS_ERR(subdir))
    1012                 :       1144 :                 goto found;
    1013         [ -  + ]:        616 :         if (PTR_ERR(subdir) != -ENOENT)
    1014                 :          0 :                 goto failed;
    1015                 :            : 
    1016                 :        616 :         spin_unlock(&sysctl_lock);
    1017                 :        616 :         new = new_dir(set, name, namelen);
    1018                 :        616 :         spin_lock(&sysctl_lock);
    1019         [ -  + ]:        616 :         subdir = ERR_PTR(-ENOMEM);
    1020         [ -  + ]:        616 :         if (!new)
    1021                 :          0 :                 goto failed;
    1022                 :            : 
    1023                 :            :         /* Was the subdir added while we dropped the lock? */
    1024                 :        616 :         subdir = find_subdir(dir, name, namelen);
    1025         [ -  + ]:        616 :         if (!IS_ERR(subdir))
    1026                 :          0 :                 goto found;
    1027         [ -  + ]:        616 :         if (PTR_ERR(subdir) != -ENOENT)
    1028                 :          0 :                 goto failed;
    1029                 :            : 
    1030                 :            :         /* Nope.  Use the our freshly made directory entry. */
    1031                 :        616 :         err = insert_header(dir, &new->header);
    1032         [ -  + ]:        616 :         subdir = ERR_PTR(err);
    1033         [ -  + ]:        616 :         if (err)
    1034                 :          0 :                 goto failed;
    1035                 :            :         subdir = new;
    1036                 :       1760 : found:
    1037                 :       1760 :         subdir->header.nreg++;
    1038                 :       1760 : failed:
    1039         [ -  + ]:       1760 :         if (IS_ERR(subdir)) {
    1040                 :          0 :                 pr_err("sysctl could not get directory: ");
    1041                 :          0 :                 sysctl_print_dir(dir);
    1042                 :          0 :                 pr_cont("/%*.*s %ld\n",
    1043                 :            :                         namelen, namelen, name, PTR_ERR(subdir));
    1044                 :            :         }
    1045                 :       1760 :         drop_sysctl_table(&dir->header);
    1046         [ +  + ]:       1760 :         if (new)
    1047                 :        616 :                 drop_sysctl_table(&new->header);
    1048                 :       1760 :         spin_unlock(&sysctl_lock);
    1049                 :       1760 :         return subdir;
    1050                 :            : }
    1051                 :            : 
    1052                 :            : static struct ctl_dir *xlate_dir(struct ctl_table_set *set, struct ctl_dir *dir)
    1053                 :            : {
    1054                 :            :         struct ctl_dir *parent;
    1055                 :            :         const char *procname;
    1056                 :            :         if (!dir->header.parent)
    1057                 :            :                 return &set->dir;
    1058                 :            :         parent = xlate_dir(set, dir->header.parent);
    1059                 :            :         if (IS_ERR(parent))
    1060                 :            :                 return parent;
    1061                 :            :         procname = dir->header.ctl_table[0].procname;
    1062                 :            :         return find_subdir(parent, procname, strlen(procname));
    1063                 :            : }
    1064                 :            : 
    1065                 :         33 : static int sysctl_follow_link(struct ctl_table_header **phead,
    1066                 :            :         struct ctl_table **pentry)
    1067                 :            : {
    1068                 :         33 :         struct ctl_table_header *head;
    1069                 :         33 :         struct ctl_table_root *root;
    1070                 :         33 :         struct ctl_table_set *set;
    1071                 :         33 :         struct ctl_table *entry;
    1072                 :         33 :         struct ctl_dir *dir;
    1073                 :         33 :         int ret;
    1074                 :            : 
    1075                 :         33 :         ret = 0;
    1076                 :         33 :         spin_lock(&sysctl_lock);
    1077                 :         33 :         root = (*pentry)->data;
    1078         [ +  - ]:         33 :         set = lookup_header_set(root);
    1079                 :         33 :         dir = xlate_dir(set, (*phead)->parent);
    1080         [ -  + ]:         33 :         if (IS_ERR(dir))
    1081                 :          0 :                 ret = PTR_ERR(dir);
    1082                 :            :         else {
    1083                 :         33 :                 const char *procname = (*pentry)->procname;
    1084                 :         33 :                 head = NULL;
    1085                 :         33 :                 entry = find_entry(&head, dir, procname, strlen(procname));
    1086                 :         33 :                 ret = -ENOENT;
    1087   [ +  -  +  - ]:         33 :                 if (entry && use_table(head)) {
    1088         [ +  - ]:         33 :                         unuse_table(*phead);
    1089                 :         33 :                         *phead = head;
    1090                 :         33 :                         *pentry = entry;
    1091                 :         33 :                         ret = 0;
    1092                 :            :                 }
    1093                 :            :         }
    1094                 :            : 
    1095                 :         33 :         spin_unlock(&sysctl_lock);
    1096                 :         33 :         return ret;
    1097                 :            : }
    1098                 :            : 
    1099                 :          0 : static int sysctl_err(const char *path, struct ctl_table *table, char *fmt, ...)
    1100                 :            : {
    1101                 :          0 :         struct va_format vaf;
    1102                 :          0 :         va_list args;
    1103                 :            : 
    1104                 :          0 :         va_start(args, fmt);
    1105                 :          0 :         vaf.fmt = fmt;
    1106                 :          0 :         vaf.va = &args;
    1107                 :            : 
    1108                 :          0 :         pr_err("sysctl table check failed: %s/%s %pV\n",
    1109                 :            :                path, table->procname, &vaf);
    1110                 :            : 
    1111                 :          0 :         va_end(args);
    1112                 :          0 :         return -EINVAL;
    1113                 :            : }
    1114                 :            : 
    1115                 :       5324 : static int sysctl_check_table_array(const char *path, struct ctl_table *table)
    1116                 :            : {
    1117                 :       5324 :         int err = 0;
    1118                 :            : 
    1119   [ +  +  +  + ]:       5324 :         if ((table->proc_handler == proc_douintvec) ||
    1120                 :            :             (table->proc_handler == proc_douintvec_minmax)) {
    1121         [ -  + ]:         55 :                 if (table->maxlen != sizeof(unsigned int))
    1122                 :          0 :                         err |= sysctl_err(path, table, "array not allowed");
    1123                 :            :         }
    1124                 :            : 
    1125                 :       5324 :         return err;
    1126                 :            : }
    1127                 :            : 
    1128                 :        770 : static int sysctl_check_table(const char *path, struct ctl_table *table)
    1129                 :            : {
    1130                 :        770 :         int err = 0;
    1131         [ +  + ]:      10362 :         for (; table->procname; table++) {
    1132         [ -  + ]:       9592 :                 if (table->child)
    1133                 :          0 :                         err |= sysctl_err(path, table, "Not a file");
    1134                 :            : 
    1135   [ +  +  +  + ]:       9592 :                 if ((table->proc_handler == proc_dostring) ||
    1136         [ +  + ]:       6644 :                     (table->proc_handler == proc_dointvec) ||
    1137         [ +  + ]:       6611 :                     (table->proc_handler == proc_douintvec) ||
    1138         [ +  + ]:       6589 :                     (table->proc_handler == proc_douintvec_minmax) ||
    1139         [ +  + ]:       5236 :                     (table->proc_handler == proc_dointvec_minmax) ||
    1140         [ +  - ]:       4642 :                     (table->proc_handler == proc_dointvec_jiffies) ||
    1141         [ +  + ]:       4642 :                     (table->proc_handler == proc_dointvec_userhz_jiffies) ||
    1142         [ +  + ]:       4499 :                     (table->proc_handler == proc_dointvec_ms_jiffies) ||
    1143         [ -  + ]:       4268 :                     (table->proc_handler == proc_doulongvec_minmax) ||
    1144                 :            :                     (table->proc_handler == proc_doulongvec_ms_jiffies_minmax)) {
    1145         [ -  + ]:       5324 :                         if (!table->data)
    1146                 :          0 :                                 err |= sysctl_err(path, table, "No data");
    1147         [ -  + ]:       5324 :                         if (!table->maxlen)
    1148                 :          0 :                                 err |= sysctl_err(path, table, "No maxlen");
    1149                 :            :                         else
    1150                 :       5324 :                                 err |= sysctl_check_table_array(path, table);
    1151                 :            :                 }
    1152         [ -  + ]:       9592 :                 if (!table->proc_handler)
    1153                 :          0 :                         err |= sysctl_err(path, table, "No proc_handler");
    1154                 :            : 
    1155         [ -  + ]:       9592 :                 if ((table->mode & (S_IRUGO|S_IWUGO)) != table->mode)
    1156                 :          0 :                         err |= sysctl_err(path, table, "bogus .mode 0%o",
    1157                 :            :                                 table->mode);
    1158                 :            :         }
    1159                 :        770 :         return err;
    1160                 :            : }
    1161                 :            : 
    1162                 :            : static struct ctl_table_header *new_links(struct ctl_dir *dir, struct ctl_table *table,
    1163                 :            :         struct ctl_table_root *link_root)
    1164                 :            : {
    1165                 :            :         struct ctl_table *link_table, *entry, *link;
    1166                 :            :         struct ctl_table_header *links;
    1167                 :            :         struct ctl_node *node;
    1168                 :            :         char *link_name;
    1169                 :            :         int nr_entries, name_bytes;
    1170                 :            : 
    1171                 :            :         name_bytes = 0;
    1172                 :            :         nr_entries = 0;
    1173                 :            :         for (entry = table; entry->procname; entry++) {
    1174                 :            :                 nr_entries++;
    1175                 :            :                 name_bytes += strlen(entry->procname) + 1;
    1176                 :            :         }
    1177                 :            : 
    1178                 :            :         links = kzalloc(sizeof(struct ctl_table_header) +
    1179                 :            :                         sizeof(struct ctl_node)*nr_entries +
    1180                 :            :                         sizeof(struct ctl_table)*(nr_entries + 1) +
    1181                 :            :                         name_bytes,
    1182                 :            :                         GFP_KERNEL);
    1183                 :            : 
    1184                 :            :         if (!links)
    1185                 :            :                 return NULL;
    1186                 :            : 
    1187                 :            :         node = (struct ctl_node *)(links + 1);
    1188                 :            :         link_table = (struct ctl_table *)(node + nr_entries);
    1189                 :            :         link_name = (char *)&link_table[nr_entries + 1];
    1190                 :            : 
    1191                 :            :         for (link = link_table, entry = table; entry->procname; link++, entry++) {
    1192                 :            :                 int len = strlen(entry->procname) + 1;
    1193                 :            :                 memcpy(link_name, entry->procname, len);
    1194                 :            :                 link->procname = link_name;
    1195                 :            :                 link->mode = S_IFLNK|S_IRWXUGO;
    1196                 :            :                 link->data = link_root;
    1197                 :            :                 link_name += len;
    1198                 :            :         }
    1199                 :            :         init_header(links, dir->header.root, dir->header.set, node, link_table);
    1200                 :            :         links->nreg = nr_entries;
    1201                 :            : 
    1202                 :            :         return links;
    1203                 :            : }
    1204                 :            : 
    1205                 :        176 : static bool get_links(struct ctl_dir *dir,
    1206                 :            :         struct ctl_table *table, struct ctl_table_root *link_root)
    1207                 :            : {
    1208                 :        176 :         struct ctl_table_header *head;
    1209                 :        176 :         struct ctl_table *entry, *link;
    1210                 :            : 
    1211                 :            :         /* Are there links available for every entry in table? */
    1212         [ +  + ]:        198 :         for (entry = table; entry->procname; entry++) {
    1213                 :        176 :                 const char *procname = entry->procname;
    1214                 :        176 :                 link = find_entry(&head, dir, procname, strlen(procname));
    1215         [ +  + ]:        176 :                 if (!link)
    1216                 :            :                         return false;
    1217   [ +  -  +  - ]:         22 :                 if (S_ISDIR(link->mode) && S_ISDIR(entry->mode))
    1218                 :         22 :                         continue;
    1219   [ #  #  #  # ]:          0 :                 if (S_ISLNK(link->mode) && (link->data == link_root))
    1220                 :          0 :                         continue;
    1221                 :            :                 return false;
    1222                 :            :         }
    1223                 :            : 
    1224                 :            :         /* The checks passed.  Increase the registration count on the links */
    1225         [ +  + ]:         44 :         for (entry = table; entry->procname; entry++) {
    1226                 :         22 :                 const char *procname = entry->procname;
    1227                 :         22 :                 link = find_entry(&head, dir, procname, strlen(procname));
    1228                 :         22 :                 head->nreg++;
    1229                 :            :         }
    1230                 :            :         return true;
    1231                 :            : }
    1232                 :            : 
    1233                 :       1463 : static int insert_links(struct ctl_table_header *head)
    1234                 :            : {
    1235                 :       1463 :         struct ctl_table_set *root_set = &sysctl_table_root.default_set;
    1236                 :       1463 :         struct ctl_dir *core_parent = NULL;
    1237                 :       1463 :         struct ctl_table_header *links;
    1238                 :       1463 :         int err;
    1239                 :            : 
    1240         [ +  + ]:       1463 :         if (head->set == root_set)
    1241                 :            :                 return 0;
    1242                 :            : 
    1243                 :        748 :         core_parent = xlate_dir(root_set, head->parent);
    1244         [ +  + ]:        748 :         if (IS_ERR(core_parent))
    1245                 :            :                 return 0;
    1246                 :            : 
    1247         [ +  + ]:         99 :         if (get_links(core_parent, head->ctl_table, head->root))
    1248                 :            :                 return 0;
    1249                 :            : 
    1250                 :         77 :         core_parent->header.nreg++;
    1251                 :         77 :         spin_unlock(&sysctl_lock);
    1252                 :            : 
    1253                 :         77 :         links = new_links(core_parent, head->ctl_table, head->root);
    1254                 :            : 
    1255                 :         77 :         spin_lock(&sysctl_lock);
    1256                 :         77 :         err = -ENOMEM;
    1257         [ -  + ]:         77 :         if (!links)
    1258                 :          0 :                 goto out;
    1259                 :            : 
    1260                 :         77 :         err = 0;
    1261         [ -  + ]:         77 :         if (get_links(core_parent, head->ctl_table, head->root)) {
    1262                 :          0 :                 kfree(links);
    1263                 :          0 :                 goto out;
    1264                 :            :         }
    1265                 :            : 
    1266                 :         77 :         err = insert_header(core_parent, links);
    1267         [ +  - ]:         77 :         if (err)
    1268                 :          0 :                 kfree(links);
    1269                 :         77 : out:
    1270                 :         77 :         drop_sysctl_table(&core_parent->header);
    1271                 :         77 :         return err;
    1272                 :            : }
    1273                 :            : 
    1274                 :            : /**
    1275                 :            :  * __register_sysctl_table - register a leaf sysctl table
    1276                 :            :  * @set: Sysctl tree to register on
    1277                 :            :  * @path: The path to the directory the sysctl table is in.
    1278                 :            :  * @table: the top-level table structure
    1279                 :            :  *
    1280                 :            :  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
    1281                 :            :  * array. A completely 0 filled entry terminates the table.
    1282                 :            :  *
    1283                 :            :  * The members of the &struct ctl_table structure are used as follows:
    1284                 :            :  *
    1285                 :            :  * procname - the name of the sysctl file under /proc/sys. Set to %NULL to not
    1286                 :            :  *            enter a sysctl file
    1287                 :            :  *
    1288                 :            :  * data - a pointer to data for use by proc_handler
    1289                 :            :  *
    1290                 :            :  * maxlen - the maximum size in bytes of the data
    1291                 :            :  *
    1292                 :            :  * mode - the file permissions for the /proc/sys file
    1293                 :            :  *
    1294                 :            :  * child - must be %NULL.
    1295                 :            :  *
    1296                 :            :  * proc_handler - the text handler routine (described below)
    1297                 :            :  *
    1298                 :            :  * extra1, extra2 - extra pointers usable by the proc handler routines
    1299                 :            :  *
    1300                 :            :  * Leaf nodes in the sysctl tree will be represented by a single file
    1301                 :            :  * under /proc; non-leaf nodes will be represented by directories.
    1302                 :            :  *
    1303                 :            :  * There must be a proc_handler routine for any terminal nodes.
    1304                 :            :  * Several default handlers are available to cover common cases -
    1305                 :            :  *
    1306                 :            :  * proc_dostring(), proc_dointvec(), proc_dointvec_jiffies(),
    1307                 :            :  * proc_dointvec_userhz_jiffies(), proc_dointvec_minmax(),
    1308                 :            :  * proc_doulongvec_ms_jiffies_minmax(), proc_doulongvec_minmax()
    1309                 :            :  *
    1310                 :            :  * It is the handler's job to read the input buffer from user memory
    1311                 :            :  * and process it. The handler should return 0 on success.
    1312                 :            :  *
    1313                 :            :  * This routine returns %NULL on a failure to register, and a pointer
    1314                 :            :  * to the table header on success.
    1315                 :            :  */
    1316                 :        770 : struct ctl_table_header *__register_sysctl_table(
    1317                 :            :         struct ctl_table_set *set,
    1318                 :            :         const char *path, struct ctl_table *table)
    1319                 :            : {
    1320                 :        770 :         struct ctl_table_root *root = set->dir.header.root;
    1321                 :        770 :         struct ctl_table_header *header;
    1322                 :        770 :         const char *name, *nextname;
    1323                 :        770 :         struct ctl_dir *dir;
    1324                 :        770 :         struct ctl_table *entry;
    1325                 :        770 :         struct ctl_node *node;
    1326                 :        770 :         int nr_entries = 0;
    1327                 :            : 
    1328         [ +  + ]:      10362 :         for (entry = table; entry->procname; entry++)
    1329                 :       9592 :                 nr_entries++;
    1330                 :            : 
    1331                 :        770 :         header = kzalloc(sizeof(struct ctl_table_header) +
    1332                 :        770 :                          sizeof(struct ctl_node)*nr_entries, GFP_KERNEL);
    1333         [ +  - ]:        770 :         if (!header)
    1334                 :            :                 return NULL;
    1335                 :            : 
    1336                 :        770 :         node = (struct ctl_node *)(header + 1);
    1337         [ +  - ]:        770 :         init_header(header, root, set, node, table);
    1338         [ -  + ]:        770 :         if (sysctl_check_table(path, table))
    1339                 :          0 :                 goto fail;
    1340                 :            : 
    1341                 :        770 :         spin_lock(&sysctl_lock);
    1342                 :        770 :         dir = &set->dir;
    1343                 :            :         /* Reference moved down the diretory tree get_subdir */
    1344                 :        770 :         dir->header.nreg++;
    1345                 :        770 :         spin_unlock(&sysctl_lock);
    1346                 :            : 
    1347                 :            :         /* Find the directory for the ctl_table */
    1348         [ +  + ]:       3619 :         for (name = path; name; name = nextname) {
    1349                 :       2079 :                 int namelen;
    1350                 :       2079 :                 nextname = strchr(name, '/');
    1351         [ +  + ]:       2079 :                 if (nextname) {
    1352                 :       1309 :                         namelen = nextname - name;
    1353                 :       1309 :                         nextname++;
    1354                 :            :                 } else {
    1355                 :        770 :                         namelen = strlen(name);
    1356                 :            :                 }
    1357         [ +  + ]:       2079 :                 if (namelen == 0)
    1358                 :        319 :                         continue;
    1359                 :            : 
    1360                 :       1760 :                 dir = get_subdir(dir, name, namelen);
    1361         [ -  + ]:       1760 :                 if (IS_ERR(dir))
    1362                 :          0 :                         goto fail;
    1363                 :            :         }
    1364                 :            : 
    1365                 :        770 :         spin_lock(&sysctl_lock);
    1366         [ -  + ]:        770 :         if (insert_header(dir, header))
    1367                 :          0 :                 goto fail_put_dir_locked;
    1368                 :            : 
    1369                 :        770 :         drop_sysctl_table(&dir->header);
    1370                 :        770 :         spin_unlock(&sysctl_lock);
    1371                 :            : 
    1372                 :        770 :         return header;
    1373                 :            : 
    1374                 :            : fail_put_dir_locked:
    1375                 :          0 :         drop_sysctl_table(&dir->header);
    1376                 :          0 :         spin_unlock(&sysctl_lock);
    1377                 :          0 : fail:
    1378                 :          0 :         kfree(header);
    1379                 :          0 :         dump_stack();
    1380                 :          0 :         return NULL;
    1381                 :            : }
    1382                 :            : 
    1383                 :            : /**
    1384                 :            :  * register_sysctl - register a sysctl table
    1385                 :            :  * @path: The path to the directory the sysctl table is in.
    1386                 :            :  * @table: the table structure
    1387                 :            :  *
    1388                 :            :  * Register a sysctl table. @table should be a filled in ctl_table
    1389                 :            :  * array. A completely 0 filled entry terminates the table.
    1390                 :            :  *
    1391                 :            :  * See __register_sysctl_table for more details.
    1392                 :            :  */
    1393                 :         22 : struct ctl_table_header *register_sysctl(const char *path, struct ctl_table *table)
    1394                 :            : {
    1395                 :         22 :         return __register_sysctl_table(&sysctl_table_root.default_set,
    1396                 :            :                                         path, table);
    1397                 :            : }
    1398                 :            : EXPORT_SYMBOL(register_sysctl);
    1399                 :            : 
    1400                 :        473 : static char *append_path(const char *path, char *pos, const char *name)
    1401                 :            : {
    1402                 :        473 :         int namelen;
    1403                 :        473 :         namelen = strlen(name);
    1404         [ +  - ]:        473 :         if (((pos - path) + namelen + 2) >= PATH_MAX)
    1405                 :            :                 return NULL;
    1406                 :        473 :         memcpy(pos, name, namelen);
    1407                 :        473 :         pos[namelen] = '/';
    1408                 :        473 :         pos[namelen + 1] = '\0';
    1409                 :        473 :         pos += namelen + 1;
    1410                 :        473 :         return pos;
    1411                 :            : }
    1412                 :            : 
    1413                 :        660 : static int count_subheaders(struct ctl_table *table)
    1414                 :            : {
    1415                 :        660 :         int has_files = 0;
    1416                 :        660 :         int nr_subheaders = 0;
    1417                 :        660 :         struct ctl_table *entry;
    1418                 :            : 
    1419                 :            :         /* special case: no directory and empty directory */
    1420   [ +  -  +  + ]:        660 :         if (!table || !table->procname)
    1421                 :            :                 return 1;
    1422                 :            : 
    1423         [ +  + ]:       3377 :         for (entry = table; entry->procname; entry++) {
    1424         [ +  + ]:       2739 :                 if (entry->child)
    1425                 :        451 :                         nr_subheaders += count_subheaders(entry->child);
    1426                 :            :                 else
    1427                 :            :                         has_files = 1;
    1428                 :            :         }
    1429                 :        638 :         return nr_subheaders + has_files;
    1430                 :            : }
    1431                 :            : 
    1432                 :        132 : static int register_leaf_sysctl_tables(const char *path, char *pos,
    1433                 :            :         struct ctl_table_header ***subheader, struct ctl_table_set *set,
    1434                 :            :         struct ctl_table *table)
    1435                 :            : {
    1436                 :        132 :         struct ctl_table *ctl_table_arg = NULL;
    1437                 :        132 :         struct ctl_table *entry, *files;
    1438                 :        132 :         int nr_files = 0;
    1439                 :        132 :         int nr_dirs = 0;
    1440                 :        132 :         int err = -ENOMEM;
    1441                 :            : 
    1442         [ +  + ]:       1826 :         for (entry = table; entry->procname; entry++) {
    1443         [ +  + ]:       1694 :                 if (entry->child)
    1444                 :        121 :                         nr_dirs++;
    1445                 :            :                 else
    1446                 :       1573 :                         nr_files++;
    1447                 :            :         }
    1448                 :            : 
    1449                 :        132 :         files = table;
    1450                 :            :         /* If there are mixed files and directories we need a new table */
    1451         [ +  + ]:        132 :         if (nr_dirs && nr_files) {
    1452                 :         22 :                 struct ctl_table *new;
    1453                 :         22 :                 files = kcalloc(nr_files + 1, sizeof(struct ctl_table),
    1454                 :            :                                 GFP_KERNEL);
    1455         [ +  - ]:         22 :                 if (!files)
    1456                 :          0 :                         goto out;
    1457                 :            : 
    1458                 :            :                 ctl_table_arg = files;
    1459         [ +  + ]:        957 :                 for (new = files, entry = table; entry->procname; entry++) {
    1460         [ +  + ]:        935 :                         if (entry->child)
    1461                 :         66 :                                 continue;
    1462                 :        869 :                         *new = *entry;
    1463                 :        869 :                         new++;
    1464                 :            :                 }
    1465                 :            :         }
    1466                 :            : 
    1467                 :            :         /* Register everything except a directory full of subdirectories */
    1468         [ +  + ]:        132 :         if (nr_files || !nr_dirs) {
    1469                 :        121 :                 struct ctl_table_header *header;
    1470                 :        121 :                 header = __register_sysctl_table(set, path, files);
    1471         [ -  + ]:        121 :                 if (!header) {
    1472                 :          0 :                         kfree(ctl_table_arg);
    1473                 :          0 :                         goto out;
    1474                 :            :                 }
    1475                 :            : 
    1476                 :            :                 /* Remember if we need to free the file table */
    1477                 :        121 :                 header->ctl_table_arg = ctl_table_arg;
    1478                 :        121 :                 **subheader = header;
    1479                 :        121 :                 (*subheader)++;
    1480                 :            :         }
    1481                 :            : 
    1482                 :            :         /* Recurse into the subdirectories. */
    1483         [ +  + ]:       1826 :         for (entry = table; entry->procname; entry++) {
    1484                 :       1694 :                 char *child_pos;
    1485                 :            : 
    1486         [ +  + ]:       1694 :                 if (!entry->child)
    1487                 :       1573 :                         continue;
    1488                 :            : 
    1489                 :        121 :                 err = -ENAMETOOLONG;
    1490                 :        121 :                 child_pos = append_path(path, pos, entry->procname);
    1491         [ -  + ]:        121 :                 if (!child_pos)
    1492                 :          0 :                         goto out;
    1493                 :            : 
    1494                 :        121 :                 err = register_leaf_sysctl_tables(path, child_pos, subheader,
    1495                 :            :                                                   set, entry->child);
    1496                 :        121 :                 pos[0] = '\0';
    1497         [ -  + ]:        121 :                 if (err)
    1498                 :          0 :                         goto out;
    1499                 :            :         }
    1500                 :            :         err = 0;
    1501                 :        132 : out:
    1502                 :            :         /* On failure our caller will unregister all registered subheaders */
    1503                 :        132 :         return err;
    1504                 :            : }
    1505                 :            : 
    1506                 :            : /**
    1507                 :            :  * __register_sysctl_paths - register a sysctl table hierarchy
    1508                 :            :  * @set: Sysctl tree to register on
    1509                 :            :  * @path: The path to the directory the sysctl table is in.
    1510                 :            :  * @table: the top-level table structure
    1511                 :            :  *
    1512                 :            :  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
    1513                 :            :  * array. A completely 0 filled entry terminates the table.
    1514                 :            :  *
    1515                 :            :  * See __register_sysctl_table for more details.
    1516                 :            :  */
    1517                 :        209 : struct ctl_table_header *__register_sysctl_paths(
    1518                 :            :         struct ctl_table_set *set,
    1519                 :            :         const struct ctl_path *path, struct ctl_table *table)
    1520                 :            : {
    1521                 :        209 :         struct ctl_table *ctl_table_arg = table;
    1522                 :        209 :         int nr_subheaders = count_subheaders(table);
    1523                 :        209 :         struct ctl_table_header *header = NULL, **subheaders, **subheader;
    1524                 :        209 :         const struct ctl_path *component;
    1525                 :        209 :         char *new_path, *pos;
    1526                 :            : 
    1527                 :        209 :         pos = new_path = kmalloc(PATH_MAX, GFP_KERNEL);
    1528         [ +  - ]:        209 :         if (!new_path)
    1529                 :            :                 return NULL;
    1530                 :            : 
    1531                 :        209 :         pos[0] = '\0';
    1532         [ +  + ]:        231 :         for (component = path; component->procname; component++) {
    1533                 :         22 :                 pos = append_path(new_path, pos, component->procname);
    1534         [ -  + ]:         22 :                 if (!pos)
    1535                 :          0 :                         goto out;
    1536                 :            :         }
    1537   [ +  -  +  +  :        539 :         while (table->procname && table->child && !table[1].procname) {
                   +  + ]
    1538                 :        330 :                 pos = append_path(new_path, pos, table->procname);
    1539         [ -  + ]:        330 :                 if (!pos)
    1540                 :          0 :                         goto out;
    1541                 :        330 :                 table = table->child;
    1542                 :            :         }
    1543         [ +  + ]:        209 :         if (nr_subheaders == 1) {
    1544                 :        198 :                 header = __register_sysctl_table(set, new_path, table);
    1545         [ +  - ]:        198 :                 if (header)
    1546                 :        198 :                         header->ctl_table_arg = ctl_table_arg;
    1547                 :            :         } else {
    1548                 :         11 :                 header = kzalloc(sizeof(*header) +
    1549                 :            :                                  sizeof(*subheaders)*nr_subheaders, GFP_KERNEL);
    1550         [ -  + ]:         11 :                 if (!header)
    1551                 :          0 :                         goto out;
    1552                 :            : 
    1553                 :         11 :                 subheaders = (struct ctl_table_header **) (header + 1);
    1554                 :         11 :                 subheader = subheaders;
    1555                 :         11 :                 header->ctl_table_arg = ctl_table_arg;
    1556                 :            : 
    1557         [ -  + ]:         11 :                 if (register_leaf_sysctl_tables(new_path, pos, &subheader,
    1558                 :            :                                                 set, table))
    1559                 :          0 :                         goto err_register_leaves;
    1560                 :            :         }
    1561                 :            : 
    1562                 :         11 : out:
    1563                 :        209 :         kfree(new_path);
    1564                 :        209 :         return header;
    1565                 :            : 
    1566                 :            : err_register_leaves:
    1567         [ #  # ]:          0 :         while (subheader > subheaders) {
    1568                 :          0 :                 struct ctl_table_header *subh = *(--subheader);
    1569                 :          0 :                 struct ctl_table *table = subh->ctl_table_arg;
    1570                 :          0 :                 unregister_sysctl_table(subh);
    1571                 :          0 :                 kfree(table);
    1572                 :            :         }
    1573                 :          0 :         kfree(header);
    1574                 :          0 :         header = NULL;
    1575                 :          0 :         goto out;
    1576                 :            : }
    1577                 :            : 
    1578                 :            : /**
    1579                 :            :  * register_sysctl_table_path - register a sysctl table hierarchy
    1580                 :            :  * @path: The path to the directory the sysctl table is in.
    1581                 :            :  * @table: the top-level table structure
    1582                 :            :  *
    1583                 :            :  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
    1584                 :            :  * array. A completely 0 filled entry terminates the table.
    1585                 :            :  *
    1586                 :            :  * See __register_sysctl_paths for more details.
    1587                 :            :  */
    1588                 :        209 : struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
    1589                 :            :                                                 struct ctl_table *table)
    1590                 :            : {
    1591                 :         11 :         return __register_sysctl_paths(&sysctl_table_root.default_set,
    1592                 :            :                                         path, table);
    1593                 :            : }
    1594                 :            : EXPORT_SYMBOL(register_sysctl_paths);
    1595                 :            : 
    1596                 :            : /**
    1597                 :            :  * register_sysctl_table - register a sysctl table hierarchy
    1598                 :            :  * @table: the top-level table structure
    1599                 :            :  *
    1600                 :            :  * Register a sysctl table hierarchy. @table should be a filled in ctl_table
    1601                 :            :  * array. A completely 0 filled entry terminates the table.
    1602                 :            :  *
    1603                 :            :  * See register_sysctl_paths for more details.
    1604                 :            :  */
    1605                 :        198 : struct ctl_table_header *register_sysctl_table(struct ctl_table *table)
    1606                 :            : {
    1607                 :        198 :         static const struct ctl_path null_path[] = { {} };
    1608                 :            : 
    1609                 :        198 :         return register_sysctl_paths(null_path, table);
    1610                 :            : }
    1611                 :            : EXPORT_SYMBOL(register_sysctl_table);
    1612                 :            : 
    1613                 :          0 : static void put_links(struct ctl_table_header *header)
    1614                 :            : {
    1615                 :          0 :         struct ctl_table_set *root_set = &sysctl_table_root.default_set;
    1616                 :          0 :         struct ctl_table_root *root = header->root;
    1617                 :          0 :         struct ctl_dir *parent = header->parent;
    1618                 :          0 :         struct ctl_dir *core_parent;
    1619                 :          0 :         struct ctl_table *entry;
    1620                 :            : 
    1621         [ #  # ]:          0 :         if (header->set == root_set)
    1622                 :            :                 return;
    1623                 :            : 
    1624                 :          0 :         core_parent = xlate_dir(root_set, parent);
    1625         [ #  # ]:          0 :         if (IS_ERR(core_parent))
    1626                 :            :                 return;
    1627                 :            : 
    1628         [ #  # ]:          0 :         for (entry = header->ctl_table; entry->procname; entry++) {
    1629                 :          0 :                 struct ctl_table_header *link_head;
    1630                 :          0 :                 struct ctl_table *link;
    1631                 :          0 :                 const char *name = entry->procname;
    1632                 :            : 
    1633                 :          0 :                 link = find_entry(&link_head, core_parent, name, strlen(name));
    1634         [ #  # ]:          0 :                 if (link &&
    1635   [ #  #  #  #  :          0 :                     ((S_ISDIR(link->mode) && S_ISDIR(entry->mode)) ||
                   #  # ]
    1636         [ #  # ]:          0 :                      (S_ISLNK(link->mode) && (link->data == root)))) {
    1637                 :          0 :                         drop_sysctl_table(link_head);
    1638                 :            :                 }
    1639                 :            :                 else {
    1640                 :          0 :                         pr_err("sysctl link missing during unregister: ");
    1641                 :          0 :                         sysctl_print_dir(parent);
    1642                 :          0 :                         pr_cont("/%s\n", name);
    1643                 :            :                 }
    1644                 :            :         }
    1645                 :            : }
    1646                 :            : 
    1647                 :       3223 : static void drop_sysctl_table(struct ctl_table_header *header)
    1648                 :            : {
    1649                 :       3223 :         struct ctl_dir *parent = header->parent;
    1650                 :            : 
    1651         [ -  + ]:       3223 :         if (--header->nreg)
    1652                 :            :                 return;
    1653                 :            : 
    1654         [ #  # ]:          0 :         if (parent) {
    1655                 :          0 :                 put_links(header);
    1656                 :          0 :                 start_unregistering(header);
    1657                 :            :         }
    1658                 :            : 
    1659         [ #  # ]:          0 :         if (!--header->count)
    1660         [ #  # ]:          0 :                 kfree_rcu(header, rcu);
    1661                 :            : 
    1662         [ #  # ]:          0 :         if (parent)
    1663                 :          0 :                 drop_sysctl_table(&parent->header);
    1664                 :            : }
    1665                 :            : 
    1666                 :            : /**
    1667                 :            :  * unregister_sysctl_table - unregister a sysctl table hierarchy
    1668                 :            :  * @header: the header returned from register_sysctl_table
    1669                 :            :  *
    1670                 :            :  * Unregisters the sysctl table and all children. proc entries may not
    1671                 :            :  * actually be removed until they are no longer used by anyone.
    1672                 :            :  */
    1673                 :          0 : void unregister_sysctl_table(struct ctl_table_header * header)
    1674                 :            : {
    1675                 :          0 :         int nr_subheaders;
    1676                 :          0 :         might_sleep();
    1677                 :            : 
    1678         [ #  # ]:          0 :         if (header == NULL)
    1679                 :            :                 return;
    1680                 :            : 
    1681                 :          0 :         nr_subheaders = count_subheaders(header->ctl_table_arg);
    1682         [ #  # ]:          0 :         if (unlikely(nr_subheaders > 1)) {
    1683                 :          0 :                 struct ctl_table_header **subheaders;
    1684                 :          0 :                 int i;
    1685                 :            : 
    1686                 :          0 :                 subheaders = (struct ctl_table_header **)(header + 1);
    1687         [ #  # ]:          0 :                 for (i = nr_subheaders -1; i >= 0; i--) {
    1688                 :          0 :                         struct ctl_table_header *subh = subheaders[i];
    1689                 :          0 :                         struct ctl_table *table = subh->ctl_table_arg;
    1690                 :          0 :                         unregister_sysctl_table(subh);
    1691                 :          0 :                         kfree(table);
    1692                 :            :                 }
    1693                 :          0 :                 kfree(header);
    1694                 :          0 :                 return;
    1695                 :            :         }
    1696                 :            : 
    1697                 :          0 :         spin_lock(&sysctl_lock);
    1698                 :          0 :         drop_sysctl_table(header);
    1699                 :          0 :         spin_unlock(&sysctl_lock);
    1700                 :            : }
    1701                 :            : EXPORT_SYMBOL(unregister_sysctl_table);
    1702                 :            : 
    1703                 :         22 : void setup_sysctl_set(struct ctl_table_set *set,
    1704                 :            :         struct ctl_table_root *root,
    1705                 :            :         int (*is_seen)(struct ctl_table_set *))
    1706                 :            : {
    1707                 :         22 :         memset(set, 0, sizeof(*set));
    1708                 :         22 :         set->is_seen = is_seen;
    1709                 :         22 :         init_header(&set->dir.header, root, set, NULL, root_table);
    1710                 :         22 : }
    1711                 :            : 
    1712                 :          0 : void retire_sysctl_set(struct ctl_table_set *set)
    1713                 :            : {
    1714         [ #  # ]:          0 :         WARN_ON(!RB_EMPTY_ROOT(&set->dir.root));
    1715                 :          0 : }
    1716                 :            : 
    1717                 :         11 : int __init proc_sys_init(void)
    1718                 :            : {
    1719                 :         11 :         struct proc_dir_entry *proc_sys_root;
    1720                 :            : 
    1721                 :         11 :         proc_sys_root = proc_mkdir("sys", NULL);
    1722                 :         11 :         proc_sys_root->proc_iops = &proc_sys_dir_operations;
    1723                 :         11 :         proc_sys_root->proc_dir_ops = &proc_sys_dir_file_operations;
    1724                 :         11 :         proc_sys_root->nlink = 0;
    1725                 :            : 
    1726                 :         11 :         return sysctl_init();
    1727                 :            : }

Generated by: LCOV version 1.14