xref: /linux/arch/s390/hypfs/inode.c (revision f24e9f586b377749dff37554696cf3a105540c94) 
1 /*
2  *  arch/s390/hypfs/inode.c
3  *    Hypervisor filesystem for Linux on s390.
4  *
5  *    Copyright (C) IBM Corp. 2006
6  *    Author(s): Michael Holzheu <holzheu@de.ibm.com>
7  */
8 
9 #include <linux/types.h>
10 #include <linux/errno.h>
11 #include <linux/fs.h>
12 #include <linux/namei.h>
13 #include <linux/vfs.h>
14 #include <linux/pagemap.h>
15 #include <linux/gfp.h>
16 #include <linux/time.h>
17 #include <linux/parser.h>
18 #include <linux/sysfs.h>
19 #include <linux/module.h>
20 #include <asm/ebcdic.h>
21 #include "hypfs.h"
22 #include "hypfs_diag.h"
23 
24 #define HYPFS_MAGIC 0x687970	/* ASCII 'hyp' */
25 #define TMP_SIZE 64		/* size of temporary buffers */
26 
27 static struct dentry *hypfs_create_update_file(struct super_block *sb,
28 					       struct dentry *dir);
29 
30 struct hypfs_sb_info {
31 	uid_t uid;			/* uid used for files and dirs */
32 	gid_t gid;			/* gid used for files and dirs */
33 	struct dentry *update_file;	/* file to trigger update */
34 	time_t last_update;		/* last update time in secs since 1970 */
35 	struct mutex lock;		/* lock to protect update process */
36 };
37 
38 static struct file_operations hypfs_file_ops;
39 static struct file_system_type hypfs_type;
40 static struct super_operations hypfs_s_ops;
41 
42 /* start of list of all dentries, which have to be deleted on update */
43 static struct dentry *hypfs_last_dentry;
44 
45 static void hypfs_update_update(struct super_block *sb)
46 {
47 	struct hypfs_sb_info *sb_info = sb->s_fs_info;
48 	struct inode *inode = sb_info->update_file->d_inode;
49 
50 	sb_info->last_update = get_seconds();
51 	inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
52 }
53 
54 /* directory tree removal functions */
55 
56 static void hypfs_add_dentry(struct dentry *dentry)
57 {
58 	dentry->d_fsdata = hypfs_last_dentry;
59 	hypfs_last_dentry = dentry;
60 }
61 
62 static void hypfs_remove(struct dentry *dentry)
63 {
64 	struct dentry *parent;
65 
66 	parent = dentry->d_parent;
67 	if (S_ISDIR(dentry->d_inode->i_mode))
68 		simple_rmdir(parent->d_inode, dentry);
69 	else
70 		simple_unlink(parent->d_inode, dentry);
71 	d_delete(dentry);
72 	dput(dentry);
73 }
74 
75 static void hypfs_delete_tree(struct dentry *root)
76 {
77 	while (hypfs_last_dentry) {
78 		struct dentry *next_dentry;
79 		next_dentry = hypfs_last_dentry->d_fsdata;
80 		hypfs_remove(hypfs_last_dentry);
81 		hypfs_last_dentry = next_dentry;
82 	}
83 }
84 
85 static struct inode *hypfs_make_inode(struct super_block *sb, int mode)
86 {
87 	struct inode *ret = new_inode(sb);
88 
89 	if (ret) {
90 		struct hypfs_sb_info *hypfs_info = sb->s_fs_info;
91 		ret->i_mode = mode;
92 		ret->i_uid = hypfs_info->uid;
93 		ret->i_gid = hypfs_info->gid;
94 		ret->i_blksize = PAGE_CACHE_SIZE;
95 		ret->i_blocks = 0;
96 		ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME;
97 		if (mode & S_IFDIR)
98 			ret->i_nlink = 2;
99 		else
100 			ret->i_nlink = 1;
101 	}
102 	return ret;
103 }
104 
105 static void hypfs_drop_inode(struct inode *inode)
106 {
107 	kfree(inode->u.generic_ip);
108 	generic_delete_inode(inode);
109 }
110 
111 static int hypfs_open(struct inode *inode, struct file *filp)
112 {
113 	char *data = filp->f_dentry->d_inode->u.generic_ip;
114 	struct hypfs_sb_info *fs_info;
115 
116 	if (filp->f_mode & FMODE_WRITE) {
117 		if (!(inode->i_mode & S_IWUGO))
118 			return -EACCES;
119 	}
120 	if (filp->f_mode & FMODE_READ) {
121 		if (!(inode->i_mode & S_IRUGO))
122 			return -EACCES;
123 	}
124 
125 	fs_info = inode->i_sb->s_fs_info;
126 	if(data) {
127 		mutex_lock(&fs_info->lock);
128 		filp->private_data = kstrdup(data, GFP_KERNEL);
129 		if (!filp->private_data) {
130 			mutex_unlock(&fs_info->lock);
131 			return -ENOMEM;
132 		}
133 		mutex_unlock(&fs_info->lock);
134 	}
135 	return 0;
136 }
137 
138 static ssize_t hypfs_aio_read(struct kiocb *iocb, __user char *buf,
139 			      size_t count, loff_t offset)
140 {
141 	char *data;
142 	size_t len;
143 	struct file *filp = iocb->ki_filp;
144 
145 	data = filp->private_data;
146 	len = strlen(data);
147 	if (offset > len) {
148 		count = 0;
149 		goto out;
150 	}
151 	if (count > len - offset)
152 		count = len - offset;
153 	if (copy_to_user(buf, data + offset, count)) {
154 		count = -EFAULT;
155 		goto out;
156 	}
157 	iocb->ki_pos += count;
158 	file_accessed(filp);
159 out:
160 	return count;
161 }
162 static ssize_t hypfs_aio_write(struct kiocb *iocb, const char __user *buf,
163 			       size_t count, loff_t pos)
164 {
165 	int rc;
166 	struct super_block *sb;
167 	struct hypfs_sb_info *fs_info;
168 
169 	sb = iocb->ki_filp->f_dentry->d_inode->i_sb;
170 	fs_info = sb->s_fs_info;
171 	/*
172 	 * Currently we only allow one update per second for two reasons:
173 	 * 1. diag 204 is VERY expensive
174 	 * 2. If several processes do updates in parallel and then read the
175 	 *    hypfs data, the likelihood of collisions is reduced, if we restrict
176 	 *    the minimum update interval. A collision occurs, if during the
177 	 *    data gathering of one process another process triggers an update
178 	 *    If the first process wants to ensure consistent data, it has
179 	 *    to restart data collection in this case.
180 	 */
181 	mutex_lock(&fs_info->lock);
182 	if (fs_info->last_update == get_seconds()) {
183 		rc = -EBUSY;
184 		goto out;
185 	}
186 	hypfs_delete_tree(sb->s_root);
187 	rc = hypfs_diag_create_files(sb, sb->s_root);
188 	if (rc) {
189 		printk(KERN_ERR "hypfs: Update failed\n");
190 		hypfs_delete_tree(sb->s_root);
191 		goto out;
192 	}
193 	hypfs_update_update(sb);
194 	rc = count;
195 out:
196 	mutex_unlock(&fs_info->lock);
197 	return rc;
198 }
199 
200 static int hypfs_release(struct inode *inode, struct file *filp)
201 {
202 	kfree(filp->private_data);
203 	return 0;
204 }
205 
206 enum { opt_uid, opt_gid, opt_err };
207 
208 static match_table_t hypfs_tokens = {
209 	{opt_uid, "uid=%u"},
210 	{opt_gid, "gid=%u"},
211 	{opt_err, NULL}
212 };
213 
214 static int hypfs_parse_options(char *options, struct super_block *sb)
215 {
216 	char *str;
217 	substring_t args[MAX_OPT_ARGS];
218 
219 	if (!options)
220 		return 0;
221 	while ((str = strsep(&options, ",")) != NULL) {
222 		int token, option;
223 		struct hypfs_sb_info *hypfs_info = sb->s_fs_info;
224 
225 		if (!*str)
226 			continue;
227 		token = match_token(str, hypfs_tokens, args);
228 		switch (token) {
229 		case opt_uid:
230 			if (match_int(&args[0], &option))
231 				return -EINVAL;
232 			hypfs_info->uid = option;
233 			break;
234 		case opt_gid:
235 			if (match_int(&args[0], &option))
236 				return -EINVAL;
237 			hypfs_info->gid = option;
238 			break;
239 		case opt_err:
240 		default:
241 			printk(KERN_ERR "hypfs: Unrecognized mount option "
242 			       "\"%s\" or missing value\n", str);
243 			return -EINVAL;
244 		}
245 	}
246 	return 0;
247 }
248 
249 static int hypfs_fill_super(struct super_block *sb, void *data, int silent)
250 {
251 	struct inode *root_inode;
252 	struct dentry *root_dentry;
253 	int rc = 0;
254 	struct hypfs_sb_info *sbi;
255 
256 	sbi = kzalloc(sizeof(struct hypfs_sb_info), GFP_KERNEL);
257 	if (!sbi)
258 		return -ENOMEM;
259 	mutex_init(&sbi->lock);
260 	sbi->uid = current->uid;
261 	sbi->gid = current->gid;
262 	sb->s_fs_info = sbi;
263 	sb->s_blocksize = PAGE_CACHE_SIZE;
264 	sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
265 	sb->s_magic = HYPFS_MAGIC;
266 	sb->s_op = &hypfs_s_ops;
267 	if (hypfs_parse_options(data, sb)) {
268 		rc = -EINVAL;
269 		goto err_alloc;
270 	}
271 	root_inode = hypfs_make_inode(sb, S_IFDIR | 0755);
272 	if (!root_inode) {
273 		rc = -ENOMEM;
274 		goto err_alloc;
275 	}
276 	root_inode->i_op = &simple_dir_inode_operations;
277 	root_inode->i_fop = &simple_dir_operations;
278 	root_dentry = d_alloc_root(root_inode);
279 	if (!root_dentry) {
280 		iput(root_inode);
281 		rc = -ENOMEM;
282 		goto err_alloc;
283 	}
284 	rc = hypfs_diag_create_files(sb, root_dentry);
285 	if (rc)
286 		goto err_tree;
287 	sbi->update_file = hypfs_create_update_file(sb, root_dentry);
288 	if (IS_ERR(sbi->update_file)) {
289 		rc = PTR_ERR(sbi->update_file);
290 		goto err_tree;
291 	}
292 	hypfs_update_update(sb);
293 	sb->s_root = root_dentry;
294 	return 0;
295 
296 err_tree:
297 	hypfs_delete_tree(root_dentry);
298 	d_genocide(root_dentry);
299 	dput(root_dentry);
300 err_alloc:
301 	kfree(sbi);
302 	return rc;
303 }
304 
305 static int hypfs_get_super(struct file_system_type *fst, int flags,
306 			const char *devname, void *data, struct vfsmount *mnt)
307 {
308 	return get_sb_single(fst, flags, data, hypfs_fill_super, mnt);
309 }
310 
311 static void hypfs_kill_super(struct super_block *sb)
312 {
313 	struct hypfs_sb_info *sb_info = sb->s_fs_info;
314 
315 	if (sb->s_root) {
316 		hypfs_delete_tree(sb->s_root);
317 		hypfs_remove(sb_info->update_file);
318 		kfree(sb->s_fs_info);
319 		sb->s_fs_info = NULL;
320 	}
321 	kill_litter_super(sb);
322 }
323 
324 static struct dentry *hypfs_create_file(struct super_block *sb,
325 					struct dentry *parent, const char *name,
326 					char *data, mode_t mode)
327 {
328 	struct dentry *dentry;
329 	struct inode *inode;
330 	struct qstr qname;
331 
332 	qname.name = name;
333 	qname.len = strlen(name);
334 	qname.hash = full_name_hash(name, qname.len);
335 	dentry = lookup_one_len(name, parent, strlen(name));
336 	if (IS_ERR(dentry))
337 		return ERR_PTR(-ENOMEM);
338 	inode = hypfs_make_inode(sb, mode);
339 	if (!inode) {
340 		dput(dentry);
341 		return ERR_PTR(-ENOMEM);
342 	}
343 	if (mode & S_IFREG) {
344 		inode->i_fop = &hypfs_file_ops;
345 		if (data)
346 			inode->i_size = strlen(data);
347 		else
348 			inode->i_size = 0;
349 	} else if (mode & S_IFDIR) {
350 		inode->i_op = &simple_dir_inode_operations;
351 		inode->i_fop = &simple_dir_operations;
352 		parent->d_inode->i_nlink++;
353 	} else
354 		BUG();
355 	inode->u.generic_ip = data;
356 	d_instantiate(dentry, inode);
357 	dget(dentry);
358 	return dentry;
359 }
360 
361 struct dentry *hypfs_mkdir(struct super_block *sb, struct dentry *parent,
362 			   const char *name)
363 {
364 	struct dentry *dentry;
365 
366 	dentry = hypfs_create_file(sb, parent, name, NULL, S_IFDIR | DIR_MODE);
367 	if (IS_ERR(dentry))
368 		return dentry;
369 	hypfs_add_dentry(dentry);
370 	parent->d_inode->i_nlink++;
371 	return dentry;
372 }
373 
374 static struct dentry *hypfs_create_update_file(struct super_block *sb,
375 					       struct dentry *dir)
376 {
377 	struct dentry *dentry;
378 
379 	dentry = hypfs_create_file(sb, dir, "update", NULL,
380 				   S_IFREG | UPDATE_FILE_MODE);
381 	/*
382 	 * We do not put the update file on the 'delete' list with
383 	 * hypfs_add_dentry(), since it should not be removed when the tree
384 	 * is updated.
385 	 */
386 	return dentry;
387 }
388 
389 struct dentry *hypfs_create_u64(struct super_block *sb, struct dentry *dir,
390 				const char *name, __u64 value)
391 {
392 	char *buffer;
393 	char tmp[TMP_SIZE];
394 	struct dentry *dentry;
395 
396 	snprintf(tmp, TMP_SIZE, "%lld\n", (unsigned long long int)value);
397 	buffer = kstrdup(tmp, GFP_KERNEL);
398 	if (!buffer)
399 		return ERR_PTR(-ENOMEM);
400 	dentry =
401 	    hypfs_create_file(sb, dir, name, buffer, S_IFREG | REG_FILE_MODE);
402 	if (IS_ERR(dentry)) {
403 		kfree(buffer);
404 		return ERR_PTR(-ENOMEM);
405 	}
406 	hypfs_add_dentry(dentry);
407 	return dentry;
408 }
409 
410 struct dentry *hypfs_create_str(struct super_block *sb, struct dentry *dir,
411 				const char *name, char *string)
412 {
413 	char *buffer;
414 	struct dentry *dentry;
415 
416 	buffer = kmalloc(strlen(string) + 2, GFP_KERNEL);
417 	if (!buffer)
418 		return ERR_PTR(-ENOMEM);
419 	sprintf(buffer, "%s\n", string);
420 	dentry =
421 	    hypfs_create_file(sb, dir, name, buffer, S_IFREG | REG_FILE_MODE);
422 	if (IS_ERR(dentry)) {
423 		kfree(buffer);
424 		return ERR_PTR(-ENOMEM);
425 	}
426 	hypfs_add_dentry(dentry);
427 	return dentry;
428 }
429 
430 static struct file_operations hypfs_file_ops = {
431 	.open		= hypfs_open,
432 	.release	= hypfs_release,
433 	.read		= do_sync_read,
434 	.write		= do_sync_write,
435 	.aio_read	= hypfs_aio_read,
436 	.aio_write	= hypfs_aio_write,
437 };
438 
439 static struct file_system_type hypfs_type = {
440 	.owner		= THIS_MODULE,
441 	.name		= "s390_hypfs",
442 	.get_sb		= hypfs_get_super,
443 	.kill_sb	= hypfs_kill_super
444 };
445 
446 static struct super_operations hypfs_s_ops = {
447 	.statfs		= simple_statfs,
448 	.drop_inode	= hypfs_drop_inode,
449 };
450 
451 static decl_subsys(s390, NULL, NULL);
452 
453 static int __init hypfs_init(void)
454 {
455 	int rc;
456 
457 	if (MACHINE_IS_VM)
458 		return -ENODATA;
459 	if (hypfs_diag_init()) {
460 		rc = -ENODATA;
461 		goto fail_diag;
462 	}
463 	kset_set_kset_s(&s390_subsys, hypervisor_subsys);
464 	rc = subsystem_register(&s390_subsys);
465 	if (rc)
466 		goto fail_sysfs;
467 	rc = register_filesystem(&hypfs_type);
468 	if (rc)
469 		goto fail_filesystem;
470 	return 0;
471 
472 fail_filesystem:
473 	subsystem_unregister(&s390_subsys);
474 fail_sysfs:
475 	hypfs_diag_exit();
476 fail_diag:
477 	printk(KERN_ERR "hypfs: Initialization failed with rc = %i.\n", rc);
478 	return rc;
479 }
480 
481 static void __exit hypfs_exit(void)
482 {
483 	hypfs_diag_exit();
484 	unregister_filesystem(&hypfs_type);
485 	subsystem_unregister(&s390_subsys);
486 }
487 
488 module_init(hypfs_init)
489 module_exit(hypfs_exit)
490 
491 MODULE_LICENSE("GPL");
492 MODULE_AUTHOR("Michael Holzheu <holzheu@de.ibm.com>");
493 MODULE_DESCRIPTION("s390 Hypervisor Filesystem");
494