Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

Linux/arch/s390/hypfs/inode.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us