fs/proc/proc_sysctl.c

   1 /*
   2  * /proc/sys support
   3  */
   4 #include <linux/init.h>
   5 #include <linux/sysctl.h>
   6 #include <linux/proc_fs.h>
   7 #include <linux/security.h>
   8 #include "internal.h"
   9
  10 static const struct dentry_operations proc_sys_dentry_operations;
  11 static const struct file_operations proc_sys_file_operations;
  12 static const struct inode_operations proc_sys_inode_operations;
  13 static const struct file_operations proc_sys_dir_file_operations;
  14 static const struct inode_operations proc_sys_dir_operations;
  15
  16 static struct inode *proc_sys_make_inode(struct super_block *sb,
  17                 struct ctl_table_header *head, struct ctl_table *table)
  18 {
  19         struct inode *inode;
  20         struct proc_inode *ei;
  21
  22         inode = new_inode(sb);
  23         if (!inode)
  24                 goto out;
  25
  26         sysctl_head_get(head);
  27         ei = PROC_I(inode);
  28         ei->sysctl = head;
  29         ei->sysctl_entry = table;
  30
  31         inode->i_mtime = inode->i_atime = inode->i_ctime = CURRENT_TIME;
  32         inode->i_flags |= S_PRIVATE; /* tell selinux to ignore this inode */
  33         inode->i_mode = table->mode;
  34         if (!table->child) {
  35                 inode->i_mode |= S_IFREG;
  36                 inode->i_op = &proc_sys_inode_operations;
  37                 inode->i_fop = &proc_sys_file_operations;
  38         } else {
  39                 inode->i_mode |= S_IFDIR;
  40                 inode->i_nlink = 0;
  41                 inode->i_op = &proc_sys_dir_operations;
  42                 inode->i_fop = &proc_sys_dir_file_operations;
  43         }
  44 out:
  45         return inode;
  46 }
  47
  48 static struct ctl_table *find_in_table(struct ctl_table *p, struct qstr *name)
  49 {
  50         int len;
  51         for ( ; p->procname; p++) {
  52
  53                 if (!p->procname)
  54                         continue;
  55
  56                 len = strlen(p->procname);
  57                 if (len != name->len)
  58                         continue;
  59
  60                 if (memcmp(p->procname, name->name, len) != 0)
  61                         continue;
  62
  63                 /* I have a match */
  64                 return p;
  65         }
  66         return NULL;
  67 }
  68
  69 static struct ctl_table_header *grab_header(struct inode *inode)
  70 {
  71         if (PROC_I(inode)->sysctl)
  72                 return sysctl_head_grab(PROC_I(inode)->sysctl);
  73         else
  74                 return sysctl_head_next(NULL);
  75 }
  76
  77 static struct dentry *proc_sys_lookup(struct inode *dir, struct dentry *dentry,
  78                                         struct nameidata *nd)
  79 {
  80         struct ctl_table_header *head = grab_header(dir);
  81         struct ctl_table *table = PROC_I(dir)->sysctl_entry;
  82         struct ctl_table_header *h = NULL;
  83         struct qstr *name = &dentry->d_name;
  84         struct ctl_table *p;
  85         struct inode *inode;
  86         struct dentry *err = ERR_PTR(-ENOENT);
  87
  88         if (IS_ERR(head))
  89                 return ERR_CAST(head);
  90
  91         if (table && !table->child) {
  92                 WARN_ON(1);
  93                 goto out;
  94         }
  95
  96         table = table ? table->child : head->ctl_table;
  97
  98         p = find_in_table(table, name);
  99         if (!p) {
 100                 for (h = sysctl_head_next(NULL); h; h = sysctl_head_next(h)) {
 101                         if (h->attached_to != table)
 102                                 continue;
 103                         p = find_in_table(h->attached_by, name);
 104                         if (p)
 105                                 break;
 106                 }
 107         }
 108
 109         if (!p)
 110                 goto out;
 111
 112         err = ERR_PTR(-ENOMEM);
 113         inode = proc_sys_make_inode(dir->i_sb, h ? h : head, p);
 114         if (h)
 115                 sysctl_head_finish(h);
 116
 117         if (!inode)
 118                 goto out;
 119
 120         err = NULL;
 121         dentry->d_op = &proc_sys_dentry_operations;
 122         d_add(dentry, inode);
 123
 124 out:
 125         sysctl_head_finish(head);
 126         return err;
 127 }
 128
 129 static ssize_t proc_sys_call_handler(struct file *filp, void __user *buf,
 130                 size_t count, loff_t *ppos, int write)
 131 {
 132         struct inode *inode = filp->f_path.dentry->d_inode;
 133         struct ctl_table_header *head = grab_header(inode);
 134         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
 135         ssize_t error;
 136         size_t res;
 137
 138         if (IS_ERR(head))
 139                 return PTR_ERR(head);
 140
 141         /*
 142          * At this point we know that the sysctl was not unregistered
 143          * and won't be until we finish.
 144          */
 145         error = -EPERM;
 146         if (sysctl_perm(head->root, table, write ? MAY_WRITE : MAY_READ))
 147                 goto out;
 148
 149         /* if that can happen at all, it should be -EINVAL, not -EISDIR */
 150         error = -EINVAL;
 151         if (!table->proc_handler)
 152                 goto out;
 153
 154         /* careful: calling conventions are nasty here */
 155         res = count;
 156         error = table->proc_handler(table, write, buf, &res, ppos);
 157         if (!error)
 158                 error = res;
 159 out:
 160         sysctl_head_finish(head);
 161
 162         return error;
 163 }
 164
 165 static ssize_t proc_sys_read(struct file *filp, char __user *buf,
 166                                 size_t count, loff_t *ppos)
 167 {
 168         return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 0);
 169 }
 170
 171 static ssize_t proc_sys_write(struct file *filp, const char __user *buf,
 172                                 size_t count, loff_t *ppos)
 173 {
 174         return proc_sys_call_handler(filp, (void __user *)buf, count, ppos, 1);
 175 }
 176
 177
 178 static int proc_sys_fill_cache(struct file *filp, void *dirent,
 179                                 filldir_t filldir,
 180                                 struct ctl_table_header *head,
 181                                 struct ctl_table *table)
 182 {
 183         struct dentry *child, *dir = filp->f_path.dentry;
 184         struct inode *inode;
 185         struct qstr qname;
 186         ino_t ino = 0;
 187         unsigned type = DT_UNKNOWN;
 188
 189         qname.name = table->procname;
 190         qname.len  = strlen(table->procname);
 191         qname.hash = full_name_hash(qname.name, qname.len);
 192
 193         child = d_lookup(dir, &qname);
 194         if (!child) {
 195                 child = d_alloc(dir, &qname);
 196                 if (child) {
 197                         inode = proc_sys_make_inode(dir->d_sb, head, table);
 198                         if (!inode) {
 199                                 dput(child);
 200                                 return -ENOMEM;
 201                         } else {
 202                                 child->d_op = &proc_sys_dentry_operations;
 203                                 d_add(child, inode);
 204                         }
 205                 } else {
 206                         return -ENOMEM;
 207                 }
 208         }
 209         inode = child->d_inode;
 210         ino  = inode->i_ino;
 211         type = inode->i_mode >> 12;
 212         dput(child);
 213         return !!filldir(dirent, qname.name, qname.len, filp->f_pos, ino, type);
 214 }
 215
 216 static int scan(struct ctl_table_header *head, ctl_table *table,
 217                 unsigned long *pos, struct file *file,
 218                 void *dirent, filldir_t filldir)
 219 {
 220
 221         for (; table->procname; table++, (*pos)++) {
 222                 int res;
 223
 224                 /* Can't do anything without a proc name */
 225                 if (!table->procname)
 226                         continue;
 227
 228                 if (*pos < file->f_pos)
 229                         continue;
 230
 231                 res = proc_sys_fill_cache(file, dirent, filldir, head, table);
 232                 if (res)
 233                         return res;
 234
 235                 file->f_pos = *pos + 1;
 236         }
 237         return 0;
 238 }
 239
 240 static int proc_sys_readdir(struct file *filp, void *dirent, filldir_t filldir)
 241 {
 242         struct dentry *dentry = filp->f_path.dentry;
 243         struct inode *inode = dentry->d_inode;
 244         struct ctl_table_header *head = grab_header(inode);
 245         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
 246         struct ctl_table_header *h = NULL;
 247         unsigned long pos;
 248         int ret = -EINVAL;
 249
 250         if (IS_ERR(head))
 251                 return PTR_ERR(head);
 252
 253         if (table && !table->child) {
 254                 WARN_ON(1);
 255                 goto out;
 256         }
 257
 258         table = table ? table->child : head->ctl_table;
 259
 260         ret = 0;
 261         /* Avoid a switch here: arm builds fail with missing __cmpdi2 */
 262         if (filp->f_pos == 0) {
 263                 if (filldir(dirent, ".", 1, filp->f_pos,
 264                                 inode->i_ino, DT_DIR) < 0)
 265                         goto out;
 266                 filp->f_pos++;
 267         }
 268         if (filp->f_pos == 1) {
 269                 if (filldir(dirent, "..", 2, filp->f_pos,
 270                                 parent_ino(dentry), DT_DIR) < 0)
 271                         goto out;
 272                 filp->f_pos++;
 273         }
 274         pos = 2;
 275
 276         ret = scan(head, table, &pos, filp, dirent, filldir);
 277         if (ret)
 278                 goto out;
 279
 280         for (h = sysctl_head_next(NULL); h; h = sysctl_head_next(h)) {
 281                 if (h->attached_to != table)
 282                         continue;
 283                 ret = scan(h, h->attached_by, &pos, filp, dirent, filldir);
 284                 if (ret) {
 285                         sysctl_head_finish(h);
 286                         break;
 287                 }
 288         }
 289         ret = 1;
 290 out:
 291         sysctl_head_finish(head);
 292         return ret;
 293 }
 294
 295 static int proc_sys_permission(struct inode *inode, int mask)
 296 {
 297         /*
 298          * sysctl entries that are not writeable,
 299          * are _NOT_ writeable, capabilities or not.
 300          */
 301         struct ctl_table_header *head;
 302         struct ctl_table *table;
 303         int error;
 304
 305         /* Executable files are not allowed under /proc/sys/ */
 306         if ((mask & MAY_EXEC) && S_ISREG(inode->i_mode))
 307                 return -EACCES;
 308
 309         head = grab_header(inode);
 310         if (IS_ERR(head))
 311                 return PTR_ERR(head);
 312
 313         table = PROC_I(inode)->sysctl_entry;
 314         if (!table) /* global root - r-xr-xr-x */
 315                 error = mask & MAY_WRITE ? -EACCES : 0;
 316         else /* Use the permissions on the sysctl table entry */
 317                 error = sysctl_perm(head->root, table, mask);
 318
 319         sysctl_head_finish(head);
 320         return error;
 321 }
 322
 323 static int proc_sys_setattr(struct dentry *dentry, struct iattr *attr)
 324 {
 325         struct inode *inode = dentry->d_inode;
 326         int error;
 327
 328         if (attr->ia_valid & (ATTR_MODE | ATTR_UID | ATTR_GID))
 329                 return -EPERM;
 330
 331         error = inode_change_ok(inode, attr);
 332         if (error)
 333                 return error;
 334
 335         if ((attr->ia_valid & ATTR_SIZE) &&
 336             attr->ia_size != i_size_read(inode)) {
 337                 error = vmtruncate(inode, attr->ia_size);
 338                 if (error)
 339                         return error;
 340         }
 341
 342         setattr_copy(inode, attr);
 343         mark_inode_dirty(inode);
 344         return 0;
 345 }
 346
 347 static int proc_sys_getattr(struct vfsmount *mnt, struct dentry *dentry, struct kstat *stat)
 348 {
 349         struct inode *inode = dentry->d_inode;
 350         struct ctl_table_header *head = grab_header(inode);
 351         struct ctl_table *table = PROC_I(inode)->sysctl_entry;
 352
 353         if (IS_ERR(head))
 354                 return PTR_ERR(head);
 355
 356         generic_fillattr(inode, stat);
 357         if (table)
 358                 stat->mode = (stat->mode & S_IFMT) | table->mode;
 359
 360         sysctl_head_finish(head);
 361         return 0;
 362 }
 363
 364 static const struct file_operations proc_sys_file_operations = {
 365         .read           = proc_sys_read,
 366         .write          = proc_sys_write,
 367         .llseek         = default_llseek,
 368 };
 369
 370 static const struct file_operations proc_sys_dir_file_operations = {
 371         .readdir        = proc_sys_readdir,
 372         .llseek         = generic_file_llseek,
 373 };
 374
 375 static const struct inode_operations proc_sys_inode_operations = {
 376         .permission     = proc_sys_permission,
 377         .setattr        = proc_sys_setattr,
 378         .getattr        = proc_sys_getattr,
 379 };
 380
 381 static const struct inode_operations proc_sys_dir_operations = {
 382         .lookup         = proc_sys_lookup,
 383         .permission     = proc_sys_permission,
 384         .setattr        = proc_sys_setattr,
 385         .getattr        = proc_sys_getattr,
 386 };
 387
 388 static int proc_sys_revalidate(struct dentry *dentry, struct nameidata *nd)
 389 {
 390         return !PROC_I(dentry->d_inode)->sysctl->unregistering;
 391 }
 392
 393 static int proc_sys_delete(struct dentry *dentry)
 394 {
 395         return !!PROC_I(dentry->d_inode)->sysctl->unregistering;
 396 }
 397
 398 static int proc_sys_compare(struct dentry *dir, struct qstr *qstr,
 399                             struct qstr *name)
 400 {
 401         struct dentry *dentry = container_of(qstr, struct dentry, d_name);
 402         if (qstr->len != name->len)
 403                 return 1;
 404         if (memcmp(qstr->name, name->name, name->len))
 405                 return 1;
 406         return !sysctl_is_seen(PROC_I(dentry->d_inode)->sysctl);
 407 }
 408
 409 static const struct dentry_operations proc_sys_dentry_operations = {
 410         .d_revalidate   = proc_sys_revalidate,
 411         .d_delete       = proc_sys_delete,
 412         .d_compare      = proc_sys_compare,
 413 };
 414
 415 int __init proc_sys_init(void)
 416 {
 417         struct proc_dir_entry *proc_sys_root;
 418
 419         proc_sys_root = proc_mkdir("sys", NULL);
 420         proc_sys_root->proc_iops = &proc_sys_dir_operations;
 421         proc_sys_root->proc_fops = &proc_sys_dir_file_operations;
 422         proc_sys_root->nlink = 0;
 423         return 0;
 424 }