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