1 /* 2 * fs/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 hypfs_delete_tree(sb->s_root); 316 hypfs_remove(sb_info->update_file); 317 kfree(sb->s_fs_info); 318 sb->s_fs_info = NULL; 319 kill_litter_super(sb); 320 } 321 322 static struct dentry *hypfs_create_file(struct super_block *sb, 323 struct dentry *parent, const char *name, 324 char *data, mode_t mode) 325 { 326 struct dentry *dentry; 327 struct inode *inode; 328 struct qstr qname; 329 330 qname.name = name; 331 qname.len = strlen(name); 332 qname.hash = full_name_hash(name, qname.len); 333 dentry = lookup_one_len(name, parent, strlen(name)); 334 if (IS_ERR(dentry)) 335 return ERR_PTR(-ENOMEM); 336 inode = hypfs_make_inode(sb, mode); 337 if (!inode) { 338 dput(dentry); 339 return ERR_PTR(-ENOMEM); 340 } 341 if (mode & S_IFREG) { 342 inode->i_fop = &hypfs_file_ops; 343 if (data) 344 inode->i_size = strlen(data); 345 else 346 inode->i_size = 0; 347 } else if (mode & S_IFDIR) { 348 inode->i_op = &simple_dir_inode_operations; 349 inode->i_fop = &simple_dir_operations; 350 parent->d_inode->i_nlink++; 351 } else 352 BUG(); 353 inode->u.generic_ip = data; 354 d_instantiate(dentry, inode); 355 dget(dentry); 356 return dentry; 357 } 358 359 struct dentry *hypfs_mkdir(struct super_block *sb, struct dentry *parent, 360 const char *name) 361 { 362 struct dentry *dentry; 363 364 dentry = hypfs_create_file(sb, parent, name, NULL, S_IFDIR | DIR_MODE); 365 if (IS_ERR(dentry)) 366 return dentry; 367 hypfs_add_dentry(dentry); 368 parent->d_inode->i_nlink++; 369 return dentry; 370 } 371 372 static struct dentry *hypfs_create_update_file(struct super_block *sb, 373 struct dentry *dir) 374 { 375 struct dentry *dentry; 376 377 dentry = hypfs_create_file(sb, dir, "update", NULL, 378 S_IFREG | UPDATE_FILE_MODE); 379 /* 380 * We do not put the update file on the 'delete' list with 381 * hypfs_add_dentry(), since it should not be removed when the tree 382 * is updated. 383 */ 384 return dentry; 385 } 386 387 struct dentry *hypfs_create_u64(struct super_block *sb, struct dentry *dir, 388 const char *name, __u64 value) 389 { 390 char *buffer; 391 char tmp[TMP_SIZE]; 392 struct dentry *dentry; 393 394 snprintf(tmp, TMP_SIZE, "%lld\n", (unsigned long long int)value); 395 buffer = kstrdup(tmp, GFP_KERNEL); 396 if (!buffer) 397 return ERR_PTR(-ENOMEM); 398 dentry = 399 hypfs_create_file(sb, dir, name, buffer, S_IFREG | REG_FILE_MODE); 400 if (IS_ERR(dentry)) { 401 kfree(buffer); 402 return ERR_PTR(-ENOMEM); 403 } 404 hypfs_add_dentry(dentry); 405 return dentry; 406 } 407 408 struct dentry *hypfs_create_str(struct super_block *sb, struct dentry *dir, 409 const char *name, char *string) 410 { 411 char *buffer; 412 struct dentry *dentry; 413 414 buffer = kmalloc(strlen(string) + 2, GFP_KERNEL); 415 if (!buffer) 416 return ERR_PTR(-ENOMEM); 417 sprintf(buffer, "%s\n", string); 418 dentry = 419 hypfs_create_file(sb, dir, name, buffer, S_IFREG | REG_FILE_MODE); 420 if (IS_ERR(dentry)) { 421 kfree(buffer); 422 return ERR_PTR(-ENOMEM); 423 } 424 hypfs_add_dentry(dentry); 425 return dentry; 426 } 427 428 static struct file_operations hypfs_file_ops = { 429 .open = hypfs_open, 430 .release = hypfs_release, 431 .read = do_sync_read, 432 .write = do_sync_write, 433 .aio_read = hypfs_aio_read, 434 .aio_write = hypfs_aio_write, 435 }; 436 437 static struct file_system_type hypfs_type = { 438 .owner = THIS_MODULE, 439 .name = "s390_hypfs", 440 .get_sb = hypfs_get_super, 441 .kill_sb = hypfs_kill_super 442 }; 443 444 static struct super_operations hypfs_s_ops = { 445 .statfs = simple_statfs, 446 .drop_inode = hypfs_drop_inode, 447 }; 448 449 static decl_subsys(s390, NULL, NULL); 450 451 static int __init hypfs_init(void) 452 { 453 int rc; 454 455 if (MACHINE_IS_VM) 456 return -ENODATA; 457 if (hypfs_diag_init()) { 458 rc = -ENODATA; 459 goto fail_diag; 460 } 461 kset_set_kset_s(&s390_subsys, hypervisor_subsys); 462 rc = subsystem_register(&s390_subsys); 463 if (rc) 464 goto fail_sysfs; 465 rc = register_filesystem(&hypfs_type); 466 if (rc) 467 goto fail_filesystem; 468 return 0; 469 470 fail_filesystem: 471 subsystem_unregister(&s390_subsys); 472 fail_sysfs: 473 hypfs_diag_exit(); 474 fail_diag: 475 printk(KERN_ERR "hypfs: Initialization failed with rc = %i.\n", rc); 476 return rc; 477 } 478 479 static void __exit hypfs_exit(void) 480 { 481 hypfs_diag_exit(); 482 unregister_filesystem(&hypfs_type); 483 subsystem_unregister(&s390_subsys); 484 } 485 486 module_init(hypfs_init) 487 module_exit(hypfs_exit) 488 489 MODULE_LICENSE("GPL"); 490 MODULE_AUTHOR("Michael Holzheu <holzheu@de.ibm.com>"); 491 MODULE_DESCRIPTION("s390 Hypervisor Filesystem"); 492