1 | /* |
2 | FUSE: Filesystem in Userspace |
3 | Copyright (C) 2001-2008 Miklos Szeredi <miklos@szeredi.hu> |
4 | |
5 | This program can be distributed under the terms of the GNU GPL. |
6 | See the file COPYING. |
7 | */ |
8 | |
9 | #include "fuse_i.h" |
10 | |
11 | #include <linux/init.h> |
12 | #include <linux/module.h> |
13 | #include <linux/fs_context.h> |
14 | |
15 | #define FUSE_CTL_SUPER_MAGIC 0x65735543 |
16 | |
17 | /* |
18 | * This is non-NULL when the single instance of the control filesystem |
19 | * exists. Protected by fuse_mutex |
20 | */ |
21 | static struct super_block *fuse_control_sb; |
22 | |
23 | static struct fuse_conn *fuse_ctl_file_conn_get(struct file *file) |
24 | { |
25 | struct fuse_conn *fc; |
26 | mutex_lock(&fuse_mutex); |
27 | fc = file_inode(f: file)->i_private; |
28 | if (fc) |
29 | fc = fuse_conn_get(fc); |
30 | mutex_unlock(lock: &fuse_mutex); |
31 | return fc; |
32 | } |
33 | |
34 | static ssize_t fuse_conn_abort_write(struct file *file, const char __user *buf, |
35 | size_t count, loff_t *ppos) |
36 | { |
37 | struct fuse_conn *fc = fuse_ctl_file_conn_get(file); |
38 | if (fc) { |
39 | if (fc->abort_err) |
40 | fc->aborted = true; |
41 | fuse_abort_conn(fc); |
42 | fuse_conn_put(fc); |
43 | } |
44 | return count; |
45 | } |
46 | |
47 | static ssize_t fuse_conn_waiting_read(struct file *file, char __user *buf, |
48 | size_t len, loff_t *ppos) |
49 | { |
50 | char tmp[32]; |
51 | size_t size; |
52 | |
53 | if (!*ppos) { |
54 | long value; |
55 | struct fuse_conn *fc = fuse_ctl_file_conn_get(file); |
56 | if (!fc) |
57 | return 0; |
58 | |
59 | value = atomic_read(v: &fc->num_waiting); |
60 | file->private_data = (void *)value; |
61 | fuse_conn_put(fc); |
62 | } |
63 | size = sprintf(buf: tmp, fmt: "%ld\n" , (long)file->private_data); |
64 | return simple_read_from_buffer(to: buf, count: len, ppos, from: tmp, available: size); |
65 | } |
66 | |
67 | static ssize_t fuse_conn_limit_read(struct file *file, char __user *buf, |
68 | size_t len, loff_t *ppos, unsigned val) |
69 | { |
70 | char tmp[32]; |
71 | size_t size = sprintf(buf: tmp, fmt: "%u\n" , val); |
72 | |
73 | return simple_read_from_buffer(to: buf, count: len, ppos, from: tmp, available: size); |
74 | } |
75 | |
76 | static ssize_t fuse_conn_limit_write(struct file *file, const char __user *buf, |
77 | size_t count, loff_t *ppos, unsigned *val, |
78 | unsigned global_limit) |
79 | { |
80 | unsigned long t; |
81 | unsigned limit = (1 << 16) - 1; |
82 | int err; |
83 | |
84 | if (*ppos) |
85 | return -EINVAL; |
86 | |
87 | err = kstrtoul_from_user(s: buf, count, base: 0, res: &t); |
88 | if (err) |
89 | return err; |
90 | |
91 | if (!capable(CAP_SYS_ADMIN)) |
92 | limit = min(limit, global_limit); |
93 | |
94 | if (t > limit) |
95 | return -EINVAL; |
96 | |
97 | *val = t; |
98 | |
99 | return count; |
100 | } |
101 | |
102 | static ssize_t fuse_conn_max_background_read(struct file *file, |
103 | char __user *buf, size_t len, |
104 | loff_t *ppos) |
105 | { |
106 | struct fuse_conn *fc; |
107 | unsigned val; |
108 | |
109 | fc = fuse_ctl_file_conn_get(file); |
110 | if (!fc) |
111 | return 0; |
112 | |
113 | val = READ_ONCE(fc->max_background); |
114 | fuse_conn_put(fc); |
115 | |
116 | return fuse_conn_limit_read(file, buf, len, ppos, val); |
117 | } |
118 | |
119 | static ssize_t fuse_conn_max_background_write(struct file *file, |
120 | const char __user *buf, |
121 | size_t count, loff_t *ppos) |
122 | { |
123 | unsigned val; |
124 | ssize_t ret; |
125 | |
126 | ret = fuse_conn_limit_write(file, buf, count, ppos, val: &val, |
127 | global_limit: max_user_bgreq); |
128 | if (ret > 0) { |
129 | struct fuse_conn *fc = fuse_ctl_file_conn_get(file); |
130 | if (fc) { |
131 | spin_lock(lock: &fc->bg_lock); |
132 | fc->max_background = val; |
133 | fc->blocked = fc->num_background >= fc->max_background; |
134 | if (!fc->blocked) |
135 | wake_up(&fc->blocked_waitq); |
136 | spin_unlock(lock: &fc->bg_lock); |
137 | fuse_conn_put(fc); |
138 | } |
139 | } |
140 | |
141 | return ret; |
142 | } |
143 | |
144 | static ssize_t fuse_conn_congestion_threshold_read(struct file *file, |
145 | char __user *buf, size_t len, |
146 | loff_t *ppos) |
147 | { |
148 | struct fuse_conn *fc; |
149 | unsigned val; |
150 | |
151 | fc = fuse_ctl_file_conn_get(file); |
152 | if (!fc) |
153 | return 0; |
154 | |
155 | val = READ_ONCE(fc->congestion_threshold); |
156 | fuse_conn_put(fc); |
157 | |
158 | return fuse_conn_limit_read(file, buf, len, ppos, val); |
159 | } |
160 | |
161 | static ssize_t fuse_conn_congestion_threshold_write(struct file *file, |
162 | const char __user *buf, |
163 | size_t count, loff_t *ppos) |
164 | { |
165 | unsigned val; |
166 | struct fuse_conn *fc; |
167 | ssize_t ret; |
168 | |
169 | ret = fuse_conn_limit_write(file, buf, count, ppos, val: &val, |
170 | global_limit: max_user_congthresh); |
171 | if (ret <= 0) |
172 | goto out; |
173 | fc = fuse_ctl_file_conn_get(file); |
174 | if (!fc) |
175 | goto out; |
176 | |
177 | WRITE_ONCE(fc->congestion_threshold, val); |
178 | fuse_conn_put(fc); |
179 | out: |
180 | return ret; |
181 | } |
182 | |
183 | static const struct file_operations fuse_ctl_abort_ops = { |
184 | .open = nonseekable_open, |
185 | .write = fuse_conn_abort_write, |
186 | .llseek = no_llseek, |
187 | }; |
188 | |
189 | static const struct file_operations fuse_ctl_waiting_ops = { |
190 | .open = nonseekable_open, |
191 | .read = fuse_conn_waiting_read, |
192 | .llseek = no_llseek, |
193 | }; |
194 | |
195 | static const struct file_operations fuse_conn_max_background_ops = { |
196 | .open = nonseekable_open, |
197 | .read = fuse_conn_max_background_read, |
198 | .write = fuse_conn_max_background_write, |
199 | .llseek = no_llseek, |
200 | }; |
201 | |
202 | static const struct file_operations fuse_conn_congestion_threshold_ops = { |
203 | .open = nonseekable_open, |
204 | .read = fuse_conn_congestion_threshold_read, |
205 | .write = fuse_conn_congestion_threshold_write, |
206 | .llseek = no_llseek, |
207 | }; |
208 | |
209 | static struct dentry *fuse_ctl_add_dentry(struct dentry *parent, |
210 | struct fuse_conn *fc, |
211 | const char *name, |
212 | int mode, int nlink, |
213 | const struct inode_operations *iop, |
214 | const struct file_operations *fop) |
215 | { |
216 | struct dentry *dentry; |
217 | struct inode *inode; |
218 | |
219 | BUG_ON(fc->ctl_ndents >= FUSE_CTL_NUM_DENTRIES); |
220 | dentry = d_alloc_name(parent, name); |
221 | if (!dentry) |
222 | return NULL; |
223 | |
224 | inode = new_inode(sb: fuse_control_sb); |
225 | if (!inode) { |
226 | dput(dentry); |
227 | return NULL; |
228 | } |
229 | |
230 | inode->i_ino = get_next_ino(); |
231 | inode->i_mode = mode; |
232 | inode->i_uid = fc->user_id; |
233 | inode->i_gid = fc->group_id; |
234 | simple_inode_init_ts(inode); |
235 | /* setting ->i_op to NULL is not allowed */ |
236 | if (iop) |
237 | inode->i_op = iop; |
238 | inode->i_fop = fop; |
239 | set_nlink(inode, nlink); |
240 | inode->i_private = fc; |
241 | d_add(dentry, inode); |
242 | |
243 | fc->ctl_dentry[fc->ctl_ndents++] = dentry; |
244 | |
245 | return dentry; |
246 | } |
247 | |
248 | /* |
249 | * Add a connection to the control filesystem (if it exists). Caller |
250 | * must hold fuse_mutex |
251 | */ |
252 | int fuse_ctl_add_conn(struct fuse_conn *fc) |
253 | { |
254 | struct dentry *parent; |
255 | char name[32]; |
256 | |
257 | if (!fuse_control_sb || fc->no_control) |
258 | return 0; |
259 | |
260 | parent = fuse_control_sb->s_root; |
261 | inc_nlink(inode: d_inode(dentry: parent)); |
262 | sprintf(buf: name, fmt: "%u" , fc->dev); |
263 | parent = fuse_ctl_add_dentry(parent, fc, name, S_IFDIR | 0500, nlink: 2, |
264 | iop: &simple_dir_inode_operations, |
265 | fop: &simple_dir_operations); |
266 | if (!parent) |
267 | goto err; |
268 | |
269 | if (!fuse_ctl_add_dentry(parent, fc, name: "waiting" , S_IFREG | 0400, nlink: 1, |
270 | NULL, fop: &fuse_ctl_waiting_ops) || |
271 | !fuse_ctl_add_dentry(parent, fc, name: "abort" , S_IFREG | 0200, nlink: 1, |
272 | NULL, fop: &fuse_ctl_abort_ops) || |
273 | !fuse_ctl_add_dentry(parent, fc, name: "max_background" , S_IFREG | 0600, |
274 | nlink: 1, NULL, fop: &fuse_conn_max_background_ops) || |
275 | !fuse_ctl_add_dentry(parent, fc, name: "congestion_threshold" , |
276 | S_IFREG | 0600, nlink: 1, NULL, |
277 | fop: &fuse_conn_congestion_threshold_ops)) |
278 | goto err; |
279 | |
280 | return 0; |
281 | |
282 | err: |
283 | fuse_ctl_remove_conn(fc); |
284 | return -ENOMEM; |
285 | } |
286 | |
287 | /* |
288 | * Remove a connection from the control filesystem (if it exists). |
289 | * Caller must hold fuse_mutex |
290 | */ |
291 | void fuse_ctl_remove_conn(struct fuse_conn *fc) |
292 | { |
293 | int i; |
294 | |
295 | if (!fuse_control_sb || fc->no_control) |
296 | return; |
297 | |
298 | for (i = fc->ctl_ndents - 1; i >= 0; i--) { |
299 | struct dentry *dentry = fc->ctl_dentry[i]; |
300 | d_inode(dentry)->i_private = NULL; |
301 | if (!i) { |
302 | /* Get rid of submounts: */ |
303 | d_invalidate(dentry); |
304 | } |
305 | dput(dentry); |
306 | } |
307 | drop_nlink(inode: d_inode(dentry: fuse_control_sb->s_root)); |
308 | } |
309 | |
310 | static int fuse_ctl_fill_super(struct super_block *sb, struct fs_context *fsc) |
311 | { |
312 | static const struct tree_descr empty_descr = {"" }; |
313 | struct fuse_conn *fc; |
314 | int err; |
315 | |
316 | err = simple_fill_super(sb, FUSE_CTL_SUPER_MAGIC, &empty_descr); |
317 | if (err) |
318 | return err; |
319 | |
320 | mutex_lock(&fuse_mutex); |
321 | BUG_ON(fuse_control_sb); |
322 | fuse_control_sb = sb; |
323 | list_for_each_entry(fc, &fuse_conn_list, entry) { |
324 | err = fuse_ctl_add_conn(fc); |
325 | if (err) { |
326 | fuse_control_sb = NULL; |
327 | mutex_unlock(lock: &fuse_mutex); |
328 | return err; |
329 | } |
330 | } |
331 | mutex_unlock(lock: &fuse_mutex); |
332 | |
333 | return 0; |
334 | } |
335 | |
336 | static int fuse_ctl_get_tree(struct fs_context *fsc) |
337 | { |
338 | return get_tree_single(fc: fsc, fill_super: fuse_ctl_fill_super); |
339 | } |
340 | |
341 | static const struct fs_context_operations fuse_ctl_context_ops = { |
342 | .get_tree = fuse_ctl_get_tree, |
343 | }; |
344 | |
345 | static int fuse_ctl_init_fs_context(struct fs_context *fsc) |
346 | { |
347 | fsc->ops = &fuse_ctl_context_ops; |
348 | return 0; |
349 | } |
350 | |
351 | static void fuse_ctl_kill_sb(struct super_block *sb) |
352 | { |
353 | struct fuse_conn *fc; |
354 | |
355 | mutex_lock(&fuse_mutex); |
356 | fuse_control_sb = NULL; |
357 | list_for_each_entry(fc, &fuse_conn_list, entry) |
358 | fc->ctl_ndents = 0; |
359 | mutex_unlock(lock: &fuse_mutex); |
360 | |
361 | kill_litter_super(sb); |
362 | } |
363 | |
364 | static struct file_system_type fuse_ctl_fs_type = { |
365 | .owner = THIS_MODULE, |
366 | .name = "fusectl" , |
367 | .init_fs_context = fuse_ctl_init_fs_context, |
368 | .kill_sb = fuse_ctl_kill_sb, |
369 | }; |
370 | MODULE_ALIAS_FS("fusectl" ); |
371 | |
372 | int __init fuse_ctl_init(void) |
373 | { |
374 | return register_filesystem(&fuse_ctl_fs_type); |
375 | } |
376 | |
377 | void __exit fuse_ctl_cleanup(void) |
378 | { |
379 | unregister_filesystem(&fuse_ctl_fs_type); |
380 | } |
381 | |