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