arch/s390/hypfs/inode.c

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