Version:  2.0.40 2.2.26 2.4.37 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 3.17 3.18 3.19 4.0

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 (d_is_dir(dentry))
 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_read_iter(struct kiocb *iocb, struct iov_iter *to)
148 {
149         struct file *file = iocb->ki_filp;
150         char *data = file->private_data;
151         size_t available = strlen(data);
152         loff_t pos = iocb->ki_pos;
153         size_t count;
154 
155         if (pos < 0)
156                 return -EINVAL;
157         if (pos >= available || !iov_iter_count(to))
158                 return 0;
159         count = copy_to_iter(data + pos, available - pos, to);
160         if (!count)
161                 return -EFAULT;
162         iocb->ki_pos = pos + count;
163         file_accessed(file);
164         return count;
165 }
166 
167 static ssize_t hypfs_write_iter(struct kiocb *iocb, struct iov_iter *from)
168 {
169         int rc;
170         struct super_block *sb = file_inode(iocb->ki_filp)->i_sb;
171         struct hypfs_sb_info *fs_info = sb->s_fs_info;
172         size_t count = iov_iter_count(from);
173 
174         /*
175          * Currently we only allow one update per second for two reasons:
176          * 1. diag 204 is VERY expensive
177          * 2. If several processes do updates in parallel and then read the
178          *    hypfs data, the likelihood of collisions is reduced, if we restrict
179          *    the minimum update interval. A collision occurs, if during the
180          *    data gathering of one process another process triggers an update
181          *    If the first process wants to ensure consistent data, it has
182          *    to restart data collection in this case.
183          */
184         mutex_lock(&fs_info->lock);
185         if (fs_info->last_update == get_seconds()) {
186                 rc = -EBUSY;
187                 goto out;
188         }
189         hypfs_delete_tree(sb->s_root);
190         if (MACHINE_IS_VM)
191                 rc = hypfs_vm_create_files(sb->s_root);
192         else
193                 rc = hypfs_diag_create_files(sb->s_root);
194         if (rc) {
195                 pr_err("Updating the hypfs tree failed\n");
196                 hypfs_delete_tree(sb->s_root);
197                 goto out;
198         }
199         hypfs_update_update(sb);
200         rc = count;
201         iov_iter_advance(from, count);
202 out:
203         mutex_unlock(&fs_info->lock);
204         return rc;
205 }
206 
207 static int hypfs_release(struct inode *inode, struct file *filp)
208 {
209         kfree(filp->private_data);
210         return 0;
211 }
212 
213 enum { opt_uid, opt_gid, opt_err };
214 
215 static const match_table_t hypfs_tokens = {
216         {opt_uid, "uid=%u"},
217         {opt_gid, "gid=%u"},
218         {opt_err, NULL}
219 };
220 
221 static int hypfs_parse_options(char *options, struct super_block *sb)
222 {
223         char *str;
224         substring_t args[MAX_OPT_ARGS];
225         kuid_t uid;
226         kgid_t gid;
227 
228         if (!options)
229                 return 0;
230         while ((str = strsep(&options, ",")) != NULL) {
231                 int token, option;
232                 struct hypfs_sb_info *hypfs_info = sb->s_fs_info;
233 
234                 if (!*str)
235                         continue;
236                 token = match_token(str, hypfs_tokens, args);
237                 switch (token) {
238                 case opt_uid:
239                         if (match_int(&args[0], &option))
240                                 return -EINVAL;
241                         uid = make_kuid(current_user_ns(), option);
242                         if (!uid_valid(uid))
243                                 return -EINVAL;
244                         hypfs_info->uid = uid;
245                         break;
246                 case opt_gid:
247                         if (match_int(&args[0], &option))
248                                 return -EINVAL;
249                         gid = make_kgid(current_user_ns(), option);
250                         if (!gid_valid(gid))
251                                 return -EINVAL;
252                         hypfs_info->gid = gid;
253                         break;
254                 case opt_err:
255                 default:
256                         pr_err("%s is not a valid mount option\n", str);
257                         return -EINVAL;
258                 }
259         }
260         return 0;
261 }
262 
263 static int hypfs_show_options(struct seq_file *s, struct dentry *root)
264 {
265         struct hypfs_sb_info *hypfs_info = root->d_sb->s_fs_info;
266 
267         seq_printf(s, ",uid=%u", from_kuid_munged(&init_user_ns, hypfs_info->uid));
268         seq_printf(s, ",gid=%u", from_kgid_munged(&init_user_ns, hypfs_info->gid));
269         return 0;
270 }
271 
272 static int hypfs_fill_super(struct super_block *sb, void *data, int silent)
273 {
274         struct inode *root_inode;
275         struct dentry *root_dentry;
276         int rc = 0;
277         struct hypfs_sb_info *sbi;
278 
279         sbi = kzalloc(sizeof(struct hypfs_sb_info), GFP_KERNEL);
280         if (!sbi)
281                 return -ENOMEM;
282         mutex_init(&sbi->lock);
283         sbi->uid = current_uid();
284         sbi->gid = current_gid();
285         sb->s_fs_info = sbi;
286         sb->s_blocksize = PAGE_CACHE_SIZE;
287         sb->s_blocksize_bits = PAGE_CACHE_SHIFT;
288         sb->s_magic = HYPFS_MAGIC;
289         sb->s_op = &hypfs_s_ops;
290         if (hypfs_parse_options(data, sb))
291                 return -EINVAL;
292         root_inode = hypfs_make_inode(sb, S_IFDIR | 0755);
293         if (!root_inode)
294                 return -ENOMEM;
295         root_inode->i_op = &simple_dir_inode_operations;
296         root_inode->i_fop = &simple_dir_operations;
297         sb->s_root = root_dentry = d_make_root(root_inode);
298         if (!root_dentry)
299                 return -ENOMEM;
300         if (MACHINE_IS_VM)
301                 rc = hypfs_vm_create_files(root_dentry);
302         else
303                 rc = hypfs_diag_create_files(root_dentry);
304         if (rc)
305                 return rc;
306         sbi->update_file = hypfs_create_update_file(root_dentry);
307         if (IS_ERR(sbi->update_file))
308                 return PTR_ERR(sbi->update_file);
309         hypfs_update_update(sb);
310         pr_info("Hypervisor filesystem mounted\n");
311         return 0;
312 }
313 
314 static struct dentry *hypfs_mount(struct file_system_type *fst, int flags,
315                         const char *devname, void *data)
316 {
317         return mount_single(fst, flags, data, hypfs_fill_super);
318 }
319 
320 static void hypfs_kill_super(struct super_block *sb)
321 {
322         struct hypfs_sb_info *sb_info = sb->s_fs_info;
323 
324         if (sb->s_root)
325                 hypfs_delete_tree(sb->s_root);
326         if (sb_info->update_file)
327                 hypfs_remove(sb_info->update_file);
328         kfree(sb->s_fs_info);
329         sb->s_fs_info = NULL;
330         kill_litter_super(sb);
331 }
332 
333 static struct dentry *hypfs_create_file(struct dentry *parent, const char *name,
334                                         char *data, umode_t mode)
335 {
336         struct dentry *dentry;
337         struct inode *inode;
338 
339         mutex_lock(&parent->d_inode->i_mutex);
340         dentry = lookup_one_len(name, parent, strlen(name));
341         if (IS_ERR(dentry)) {
342                 dentry = ERR_PTR(-ENOMEM);
343                 goto fail;
344         }
345         inode = hypfs_make_inode(parent->d_sb, mode);
346         if (!inode) {
347                 dput(dentry);
348                 dentry = ERR_PTR(-ENOMEM);
349                 goto fail;
350         }
351         if (S_ISREG(mode)) {
352                 inode->i_fop = &hypfs_file_ops;
353                 if (data)
354                         inode->i_size = strlen(data);
355                 else
356                         inode->i_size = 0;
357         } else if (S_ISDIR(mode)) {
358                 inode->i_op = &simple_dir_inode_operations;
359                 inode->i_fop = &simple_dir_operations;
360                 inc_nlink(parent->d_inode);
361         } else
362                 BUG();
363         inode->i_private = data;
364         d_instantiate(dentry, inode);
365         dget(dentry);
366 fail:
367         mutex_unlock(&parent->d_inode->i_mutex);
368         return dentry;
369 }
370 
371 struct dentry *hypfs_mkdir(struct dentry *parent, const char *name)
372 {
373         struct dentry *dentry;
374 
375         dentry = hypfs_create_file(parent, name, NULL, S_IFDIR | DIR_MODE);
376         if (IS_ERR(dentry))
377                 return dentry;
378         hypfs_add_dentry(dentry);
379         return dentry;
380 }
381 
382 static struct dentry *hypfs_create_update_file(struct dentry *dir)
383 {
384         struct dentry *dentry;
385 
386         dentry = hypfs_create_file(dir, "update", NULL,
387                                    S_IFREG | UPDATE_FILE_MODE);
388         /*
389          * We do not put the update file on the 'delete' list with
390          * hypfs_add_dentry(), since it should not be removed when the tree
391          * is updated.
392          */
393         return dentry;
394 }
395 
396 struct dentry *hypfs_create_u64(struct dentry *dir,
397                                 const char *name, __u64 value)
398 {
399         char *buffer;
400         char tmp[TMP_SIZE];
401         struct dentry *dentry;
402 
403         snprintf(tmp, TMP_SIZE, "%llu\n", (unsigned long long int)value);
404         buffer = kstrdup(tmp, GFP_KERNEL);
405         if (!buffer)
406                 return ERR_PTR(-ENOMEM);
407         dentry =
408             hypfs_create_file(dir, name, buffer, S_IFREG | REG_FILE_MODE);
409         if (IS_ERR(dentry)) {
410                 kfree(buffer);
411                 return ERR_PTR(-ENOMEM);
412         }
413         hypfs_add_dentry(dentry);
414         return dentry;
415 }
416 
417 struct dentry *hypfs_create_str(struct dentry *dir,
418                                 const char *name, char *string)
419 {
420         char *buffer;
421         struct dentry *dentry;
422 
423         buffer = kmalloc(strlen(string) + 2, GFP_KERNEL);
424         if (!buffer)
425                 return ERR_PTR(-ENOMEM);
426         sprintf(buffer, "%s\n", string);
427         dentry =
428             hypfs_create_file(dir, name, buffer, S_IFREG | REG_FILE_MODE);
429         if (IS_ERR(dentry)) {
430                 kfree(buffer);
431                 return ERR_PTR(-ENOMEM);
432         }
433         hypfs_add_dentry(dentry);
434         return dentry;
435 }
436 
437 static const struct file_operations hypfs_file_ops = {
438         .open           = hypfs_open,
439         .release        = hypfs_release,
440         .read           = new_sync_read,
441         .write          = new_sync_write,
442         .read_iter      = hypfs_read_iter,
443         .write_iter     = hypfs_write_iter,
444         .llseek         = no_llseek,
445 };
446 
447 static struct file_system_type hypfs_type = {
448         .owner          = THIS_MODULE,
449         .name           = "s390_hypfs",
450         .mount          = hypfs_mount,
451         .kill_sb        = hypfs_kill_super
452 };
453 MODULE_ALIAS_FS("s390_hypfs");
454 
455 static const struct super_operations hypfs_s_ops = {
456         .statfs         = simple_statfs,
457         .evict_inode    = hypfs_evict_inode,
458         .show_options   = hypfs_show_options,
459 };
460 
461 static struct kobject *s390_kobj;
462 
463 static int __init hypfs_init(void)
464 {
465         int rc;
466 
467         rc = hypfs_dbfs_init();
468         if (rc)
469                 return rc;
470         if (hypfs_diag_init()) {
471                 rc = -ENODATA;
472                 goto fail_dbfs_exit;
473         }
474         if (hypfs_vm_init()) {
475                 rc = -ENODATA;
476                 goto fail_hypfs_diag_exit;
477         }
478         if (hypfs_sprp_init()) {
479                 rc = -ENODATA;
480                 goto fail_hypfs_vm_exit;
481         }
482         if (hypfs_diag0c_init()) {
483                 rc = -ENODATA;
484                 goto fail_hypfs_sprp_exit;
485         }
486         s390_kobj = kobject_create_and_add("s390", hypervisor_kobj);
487         if (!s390_kobj) {
488                 rc = -ENOMEM;
489                 goto fail_hypfs_diag0c_exit;
490         }
491         rc = register_filesystem(&hypfs_type);
492         if (rc)
493                 goto fail_filesystem;
494         return 0;
495 
496 fail_filesystem:
497         kobject_put(s390_kobj);
498 fail_hypfs_diag0c_exit:
499         hypfs_diag0c_exit();
500 fail_hypfs_sprp_exit:
501         hypfs_sprp_exit();
502 fail_hypfs_vm_exit:
503         hypfs_vm_exit();
504 fail_hypfs_diag_exit:
505         hypfs_diag_exit();
506 fail_dbfs_exit:
507         hypfs_dbfs_exit();
508         pr_err("Initialization of hypfs failed with rc=%i\n", rc);
509         return rc;
510 }
511 
512 static void __exit hypfs_exit(void)
513 {
514         unregister_filesystem(&hypfs_type);
515         kobject_put(s390_kobj);
516         hypfs_diag0c_exit();
517         hypfs_sprp_exit();
518         hypfs_vm_exit();
519         hypfs_diag_exit();
520         hypfs_dbfs_exit();
521 }
522 
523 module_init(hypfs_init)
524 module_exit(hypfs_exit)
525 
526 MODULE_LICENSE("GPL");
527 MODULE_AUTHOR("Michael Holzheu <holzheu@de.ibm.com>");
528 MODULE_DESCRIPTION("s390 Hypervisor Filesystem");
529 

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