Skip to content
Navigation Menu
Toggle navigation
Sign in
In this repository
All GitHub Enterprise
↵
Jump to
↵
No suggested jump to results
In this repository
All GitHub Enterprise
↵
Jump to
↵
In this organization
All GitHub Enterprise
↵
Jump to
↵
In this repository
All GitHub Enterprise
↵
Jump to
↵
Sign in
Reseting focus
You signed in with another tab or window.
Reload
to refresh your session.
You signed out in another tab or window.
Reload
to refresh your session.
You switched accounts on another tab or window.
Reload
to refresh your session.
Dismiss alert
{{ message }}
mariux64
/
linux
Public
Notifications
You must be signed in to change notification settings
Fork
0
Star
0
Code
Issues
2
Pull requests
0
Actions
Projects
0
Wiki
Security
Insights
Additional navigation options
Code
Issues
Pull requests
Actions
Projects
Wiki
Security
Insights
Files
1dc51b8
Documentation
arch
alpha
arc
arm
arm64
avr32
blackfin
c6x
cris
frv
h8300
hexagon
ia64
m32r
m68k
metag
microblaze
mips
mn10300
nios2
openrisc
parisc
powerpc
s390
appldata
boot
configs
crypto
hypfs
Makefile
hypfs.h
hypfs_dbfs.c
hypfs_diag.c
hypfs_diag0c.c
hypfs_sprp.c
hypfs_vm.c
inode.c
include
kernel
kvm
lib
mm
net
oprofile
pci
Kbuild
Kconfig
Kconfig.debug
Makefile
defconfig
score
sh
sparc
tile
um
unicore32
x86
xtensa
.gitignore
Kconfig
block
crypto
drivers
firmware
fs
include
init
ipc
kernel
lib
mm
net
samples
scripts
security
sound
tools
usr
virt
.gitignore
.mailmap
COPYING
CREDITS
Kbuild
Kconfig
MAINTAINERS
Makefile
README
REPORTING-BUGS
Breadcrumbs
linux
/
arch
/
s390
/
hypfs
/
inode.c
Blame
Blame
Latest commit
History
History
517 lines (461 loc) · 12.3 KB
Breadcrumbs
linux
/
arch
/
s390
/
hypfs
/
inode.c
Top
File metadata and controls
Code
Blame
517 lines (461 loc) · 12.3 KB
Raw
/* * Hypervisor filesystem for Linux on s390. * * Copyright IBM Corp. 2006, 2008 * Author(s): Michael Holzheu <holzheu@de.ibm.com> */ #define KMSG_COMPONENT "hypfs" #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt #include <linux/types.h> #include <linux/errno.h> #include <linux/fs.h> #include <linux/namei.h> #include <linux/vfs.h> #include <linux/slab.h> #include <linux/pagemap.h> #include <linux/time.h> #include <linux/parser.h> #include <linux/sysfs.h> #include <linux/module.h> #include <linux/seq_file.h> #include <linux/mount.h> #include <linux/uio.h> #include <asm/ebcdic.h> #include "hypfs.h" #define HYPFS_MAGIC 0x687970 /* ASCII 'hyp' */ #define TMP_SIZE 64 /* size of temporary buffers */ static struct dentry *hypfs_create_update_file(struct dentry *dir); struct hypfs_sb_info { kuid_t uid; /* uid used for files and dirs */ kgid_t gid; /* gid used for files and dirs */ struct dentry *update_file; /* file to trigger update */ time_t last_update; /* last update time in secs since 1970 */ struct mutex lock; /* lock to protect update process */ }; static const struct file_operations hypfs_file_ops; static struct file_system_type hypfs_type; static const struct super_operations hypfs_s_ops; /* start of list of all dentries, which have to be deleted on update */ static struct dentry *hypfs_last_dentry; static void hypfs_update_update(struct super_block *sb) { struct hypfs_sb_info *sb_info = sb->s_fs_info; struct inode *inode = d_inode(sb_info->update_file); sb_info->last_update = get_seconds(); inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME; } /* directory tree removal functions */ static void hypfs_add_dentry(struct dentry *dentry) { dentry->d_fsdata = hypfs_last_dentry; hypfs_last_dentry = dentry; } static void hypfs_remove(struct dentry *dentry) { struct dentry *parent; parent = dentry->d_parent; mutex_lock(&d_inode(parent)->i_mutex); if (simple_positive(dentry)) { if (d_is_dir(dentry)) simple_rmdir(d_inode(parent), dentry); else simple_unlink(d_inode(parent), dentry); } d_delete(dentry); dput(dentry); mutex_unlock(&d_inode(parent)->i_mutex); } static void hypfs_delete_tree(struct dentry *root) { while (hypfs_last_dentry) { struct dentry *next_dentry; next_dentry = hypfs_last_dentry->d_fsdata; hypfs_remove(hypfs_last_dentry); hypfs_last_dentry = next_dentry; } } static struct inode *hypfs_make_inode(struct super_block *sb, umode_t mode) { struct inode *ret = new_inode(sb); if (ret) { struct hypfs_sb_info *hypfs_info = sb->s_fs_info; ret->i_ino = get_next_ino(); ret->i_mode = mode; ret->i_uid = hypfs_info->uid; ret->i_gid = hypfs_info->gid; ret->i_atime = ret->i_mtime = ret->i_ctime = CURRENT_TIME; if (S_ISDIR(mode)) set_nlink(ret, 2); } return ret; } static void hypfs_evict_inode(struct inode *inode) { clear_inode(inode); kfree(inode->i_private); } static int hypfs_open(struct inode *inode, struct file *filp) { char *data = file_inode(filp)->i_private; struct hypfs_sb_info *fs_info; if (filp->f_mode & FMODE_WRITE) { if (!(inode->i_mode & S_IWUGO)) return -EACCES; } if (filp->f_mode & FMODE_READ) { if (!(inode->i_mode & S_IRUGO)) return -EACCES; } fs_info = inode->i_sb->s_fs_info; if(data) { mutex_lock(&fs_info->lock); filp->private_data = kstrdup(data, GFP_KERNEL); if (!filp->private_data) { mutex_unlock(&fs_info->lock); return -ENOMEM; } mutex_unlock(&fs_info->lock); } return nonseekable_open(inode, filp); } static ssize_t hypfs_read_iter(struct kiocb *iocb, struct iov_iter *to) { struct file *file = iocb->ki_filp; char *data = file->private_data; size_t available = strlen(data); loff_t pos = iocb->ki_pos; size_t count; if (pos < 0) return -EINVAL; if (pos >= available || !iov_iter_count(to)) return 0; count = copy_to_iter(data + pos, available - pos, to); if (!count) return -EFAULT; iocb->ki_pos = pos + count; file_accessed(file); return count; } static ssize_t hypfs_write_iter(struct kiocb *iocb, struct iov_iter *from) { int rc; struct super_block *sb = file_inode(iocb->ki_filp)->i_sb; struct hypfs_sb_info *fs_info = sb->s_fs_info; size_t count = iov_iter_count(from); /* * Currently we only allow one update per second for two reasons: * 1. diag 204 is VERY expensive * 2. If several processes do updates in parallel and then read the * hypfs data, the likelihood of collisions is reduced, if we restrict * the minimum update interval. A collision occurs, if during the * data gathering of one process another process triggers an update * If the first process wants to ensure consistent data, it has * to restart data collection in this case. */ mutex_lock(&fs_info->lock); if (fs_info->last_update == get_seconds()) { rc = -EBUSY; goto out; } hypfs_delete_tree(sb->s_root); if (MACHINE_IS_VM) rc = hypfs_vm_create_files(sb->s_root); else rc = hypfs_diag_create_files(sb->s_root); if (rc) { pr_err("Updating the hypfs tree failed\n"); hypfs_delete_tree(sb->s_root); goto out; } hypfs_update_update(sb); rc = count; iov_iter_advance(from, count); out: mutex_unlock(&fs_info->lock); return rc; } static int hypfs_release(struct inode *inode, struct file *filp) { kfree(filp->private_data); return 0; } enum { opt_uid, opt_gid, opt_err }; static const match_table_t hypfs_tokens = { {opt_uid, "uid=%u"}, {opt_gid, "gid=%u"}, {opt_err, NULL} }; static int hypfs_parse_options(char *options, struct super_block *sb) { char *str; substring_t args[MAX_OPT_ARGS]; kuid_t uid; kgid_t gid; if (!options) return 0; while ((str = strsep(&options, ",")) != NULL) { int token, option; struct hypfs_sb_info *hypfs_info = sb->s_fs_info; if (!*str) continue; token = match_token(str, hypfs_tokens, args); switch (token) { case opt_uid: if (match_int(&args[0], &option)) return -EINVAL; uid = make_kuid(current_user_ns(), option); if (!uid_valid(uid)) return -EINVAL; hypfs_info->uid = uid; break; case opt_gid: if (match_int(&args[0], &option)) return -EINVAL; gid = make_kgid(current_user_ns(), option); if (!gid_valid(gid)) return -EINVAL; hypfs_info->gid = gid; break; case opt_err: default: pr_err("%s is not a valid mount option\n", str); return -EINVAL; } } return 0; } static int hypfs_show_options(struct seq_file *s, struct dentry *root) { struct hypfs_sb_info *hypfs_info = root->d_sb->s_fs_info; seq_printf(s, ",uid=%u", from_kuid_munged(&init_user_ns, hypfs_info->uid)); seq_printf(s, ",gid=%u", from_kgid_munged(&init_user_ns, hypfs_info->gid)); return 0; } static int hypfs_fill_super(struct super_block *sb, void *data, int silent) { struct inode *root_inode; struct dentry *root_dentry; int rc = 0; struct hypfs_sb_info *sbi; sbi = kzalloc(sizeof(struct hypfs_sb_info), GFP_KERNEL); if (!sbi) return -ENOMEM; mutex_init(&sbi->lock); sbi->uid = current_uid(); sbi->gid = current_gid(); sb->s_fs_info = sbi; sb->s_blocksize = PAGE_CACHE_SIZE; sb->s_blocksize_bits = PAGE_CACHE_SHIFT; sb->s_magic = HYPFS_MAGIC; sb->s_op = &hypfs_s_ops; if (hypfs_parse_options(data, sb)) return -EINVAL; root_inode = hypfs_make_inode(sb, S_IFDIR | 0755); if (!root_inode) return -ENOMEM; root_inode->i_op = &simple_dir_inode_operations; root_inode->i_fop = &simple_dir_operations; sb->s_root = root_dentry = d_make_root(root_inode); if (!root_dentry) return -ENOMEM; if (MACHINE_IS_VM) rc = hypfs_vm_create_files(root_dentry); else rc = hypfs_diag_create_files(root_dentry); if (rc) return rc; sbi->update_file = hypfs_create_update_file(root_dentry); if (IS_ERR(sbi->update_file)) return PTR_ERR(sbi->update_file); hypfs_update_update(sb); pr_info("Hypervisor filesystem mounted\n"); return 0; } static struct dentry *hypfs_mount(struct file_system_type *fst, int flags, const char *devname, void *data) { return mount_single(fst, flags, data, hypfs_fill_super); } static void hypfs_kill_super(struct super_block *sb) { struct hypfs_sb_info *sb_info = sb->s_fs_info; if (sb->s_root) hypfs_delete_tree(sb->s_root); if (sb_info->update_file) hypfs_remove(sb_info->update_file); kfree(sb->s_fs_info); sb->s_fs_info = NULL; kill_litter_super(sb); } static struct dentry *hypfs_create_file(struct dentry *parent, const char *name, char *data, umode_t mode) { struct dentry *dentry; struct inode *inode; mutex_lock(&d_inode(parent)->i_mutex); dentry = lookup_one_len(name, parent, strlen(name)); if (IS_ERR(dentry)) { dentry = ERR_PTR(-ENOMEM); goto fail; } inode = hypfs_make_inode(parent->d_sb, mode); if (!inode) { dput(dentry); dentry = ERR_PTR(-ENOMEM); goto fail; } if (S_ISREG(mode)) { inode->i_fop = &hypfs_file_ops; if (data) inode->i_size = strlen(data); else inode->i_size = 0; } else if (S_ISDIR(mode)) { inode->i_op = &simple_dir_inode_operations; inode->i_fop = &simple_dir_operations; inc_nlink(d_inode(parent)); } else BUG(); inode->i_private = data; d_instantiate(dentry, inode); dget(dentry); fail: mutex_unlock(&d_inode(parent)->i_mutex); return dentry; } struct dentry *hypfs_mkdir(struct dentry *parent, const char *name) { struct dentry *dentry; dentry = hypfs_create_file(parent, name, NULL, S_IFDIR | DIR_MODE); if (IS_ERR(dentry)) return dentry; hypfs_add_dentry(dentry); return dentry; } static struct dentry *hypfs_create_update_file(struct dentry *dir) { struct dentry *dentry; dentry = hypfs_create_file(dir, "update", NULL, S_IFREG | UPDATE_FILE_MODE); /* * We do not put the update file on the 'delete' list with * hypfs_add_dentry(), since it should not be removed when the tree * is updated. */ return dentry; } struct dentry *hypfs_create_u64(struct dentry *dir, const char *name, __u64 value) { char *buffer; char tmp[TMP_SIZE]; struct dentry *dentry; snprintf(tmp, TMP_SIZE, "%llu\n", (unsigned long long int)value); buffer = kstrdup(tmp, GFP_KERNEL); if (!buffer) return ERR_PTR(-ENOMEM); dentry = hypfs_create_file(dir, name, buffer, S_IFREG | REG_FILE_MODE); if (IS_ERR(dentry)) { kfree(buffer); return ERR_PTR(-ENOMEM); } hypfs_add_dentry(dentry); return dentry; } struct dentry *hypfs_create_str(struct dentry *dir, const char *name, char *string) { char *buffer; struct dentry *dentry; buffer = kmalloc(strlen(string) + 2, GFP_KERNEL); if (!buffer) return ERR_PTR(-ENOMEM); sprintf(buffer, "%s\n", string); dentry = hypfs_create_file(dir, name, buffer, S_IFREG | REG_FILE_MODE); if (IS_ERR(dentry)) { kfree(buffer); return ERR_PTR(-ENOMEM); } hypfs_add_dentry(dentry); return dentry; } static const struct file_operations hypfs_file_ops = { .open = hypfs_open, .release = hypfs_release, .read_iter = hypfs_read_iter, .write_iter = hypfs_write_iter, .llseek = no_llseek, }; static struct file_system_type hypfs_type = { .owner = THIS_MODULE, .name = "s390_hypfs", .mount = hypfs_mount, .kill_sb = hypfs_kill_super }; MODULE_ALIAS_FS("s390_hypfs"); static const struct super_operations hypfs_s_ops = { .statfs = simple_statfs, .evict_inode = hypfs_evict_inode, .show_options = hypfs_show_options, }; static int __init hypfs_init(void) { int rc; rc = hypfs_dbfs_init(); if (rc) return rc; if (hypfs_diag_init()) { rc = -ENODATA; goto fail_dbfs_exit; } if (hypfs_vm_init()) { rc = -ENODATA; goto fail_hypfs_diag_exit; } if (hypfs_sprp_init()) { rc = -ENODATA; goto fail_hypfs_vm_exit; } if (hypfs_diag0c_init()) { rc = -ENODATA; goto fail_hypfs_sprp_exit; } rc = sysfs_create_mount_point(hypervisor_kobj, "s390"); if (rc) goto fail_hypfs_diag0c_exit; rc = register_filesystem(&hypfs_type); if (rc) goto fail_filesystem; return 0; fail_filesystem: sysfs_remove_mount_point(hypervisor_kobj, "s390"); fail_hypfs_diag0c_exit: hypfs_diag0c_exit(); fail_hypfs_sprp_exit: hypfs_sprp_exit(); fail_hypfs_vm_exit: hypfs_vm_exit(); fail_hypfs_diag_exit: hypfs_diag_exit(); fail_dbfs_exit: hypfs_dbfs_exit(); pr_err("Initialization of hypfs failed with rc=%i\n", rc); return rc; } static void __exit hypfs_exit(void) { unregister_filesystem(&hypfs_type); sysfs_remove_mount_point(hypervisor_kobj, "s390"); hypfs_diag0c_exit(); hypfs_sprp_exit(); hypfs_vm_exit(); hypfs_diag_exit(); hypfs_dbfs_exit(); } module_init(hypfs_init) module_exit(hypfs_exit) MODULE_LICENSE("GPL"); MODULE_AUTHOR("Michael Holzheu <holzheu@de.ibm.com>"); MODULE_DESCRIPTION("s390 Hypervisor Filesystem");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
You can’t perform that action at this time.