2 * Copyright (C) 2002 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
3 * Licensed under the GPL
6 #include <linux/ctype.h>
7 #include <linux/dcache.h>
8 #include <linux/file.h>
10 #include <linux/init.h>
11 #include <linux/kernel.h>
12 #include <linux/list.h>
13 #include <linux/module.h>
14 #include <linux/mount.h>
15 #include <linux/slab.h>
16 #include <linux/statfs.h>
17 #include <linux/types.h>
18 #include <linux/pid_namespace.h>
19 #include <asm/uaccess.h>
22 static struct inode *get_inode(struct super_block *, struct dentry *);
25 struct list_head list;
26 char contents[PAGE_SIZE - sizeof(struct list_head)];
29 struct hppfs_private {
30 struct file *proc_file;
33 struct hppfs_data *contents;
36 struct hppfs_inode_info {
37 struct dentry *proc_dentry;
38 struct inode vfs_inode;
41 static inline struct hppfs_inode_info *HPPFS_I(struct inode *inode)
43 return container_of(inode, struct hppfs_inode_info, vfs_inode);
46 #define HPPFS_SUPER_MAGIC 0xb00000ee
48 static const struct super_operations hppfs_sbops;
50 static int is_pid(struct dentry *dentry)
52 struct super_block *sb;
56 if (dentry->d_parent != sb->s_root)
59 for (i = 0; i < dentry->d_name.len; i++) {
60 if (!isdigit(dentry->d_name.name[i]))
66 static char *dentry_name(struct dentry *dentry, int extra)
68 struct dentry *parent;
75 while (parent->d_parent != parent) {
77 len += strlen("pid") + 1;
78 else len += parent->d_name.len + 1;
79 parent = parent->d_parent;
84 name = kmalloc(len + extra + 1, GFP_KERNEL);
90 while (parent->d_parent != parent) {
93 seg_len = strlen("pid");
96 seg_name = parent->d_name.name;
97 seg_len = parent->d_name.len;
102 strncpy(&name[len + 1], seg_name, seg_len);
103 parent = parent->d_parent;
105 strncpy(name, root, strlen(root));
109 static int file_removed(struct dentry *dentry, const char *file)
116 extra += strlen(file) + 1;
118 host_file = dentry_name(dentry, extra + strlen("/remove"));
119 if (host_file == NULL) {
120 printk(KERN_ERR "file_removed : allocation failed\n");
125 strcat(host_file, "/");
126 strcat(host_file, file);
128 strcat(host_file, "/remove");
130 fd = os_open_file(host_file, of_read(OPENFLAGS()), 0);
139 static struct dentry *hppfs_lookup(struct inode *ino, struct dentry *dentry,
140 struct nameidata *nd)
142 struct dentry *proc_dentry, *new, *parent;
146 deleted = file_removed(dentry, NULL);
148 return ERR_PTR(deleted);
150 return ERR_PTR(-ENOENT);
153 parent = HPPFS_I(ino)->proc_dentry;
154 mutex_lock(&parent->d_inode->i_mutex);
155 proc_dentry = d_lookup(parent, &dentry->d_name);
156 if (proc_dentry == NULL) {
157 proc_dentry = d_alloc(parent, &dentry->d_name);
158 if (proc_dentry == NULL) {
159 mutex_unlock(&parent->d_inode->i_mutex);
162 new = (*parent->d_inode->i_op->lookup)(parent->d_inode,
169 mutex_unlock(&parent->d_inode->i_mutex);
171 if (IS_ERR(proc_dentry))
175 inode = get_inode(ino->i_sb, proc_dentry);
179 d_add(dentry, inode);
188 static const struct inode_operations hppfs_file_iops = {
191 static ssize_t read_proc(struct file *file, char __user *buf, ssize_t count,
192 loff_t *ppos, int is_user)
194 ssize_t (*read)(struct file *, char __user *, size_t, loff_t *);
197 read = file->f_path.dentry->d_inode->i_fop->read;
202 n = (*read)(file, buf, count, &file->f_pos);
212 static ssize_t hppfs_read_file(int fd, char __user *buf, ssize_t count)
219 new_buf = kmalloc(PAGE_SIZE, GFP_KERNEL);
220 if (new_buf == NULL) {
221 printk(KERN_ERR "hppfs_read_file : kmalloc failed\n");
226 cur = min_t(ssize_t, count, PAGE_SIZE);
227 err = os_read_file(fd, new_buf, cur);
229 printk(KERN_ERR "hppfs_read : read failed, "
230 "errno = %d\n", err);
236 if (copy_to_user(buf, new_buf, err)) {
249 static ssize_t hppfs_read(struct file *file, char __user *buf, size_t count,
252 struct hppfs_private *hppfs = file->private_data;
253 struct hppfs_data *data;
257 if (hppfs->contents != NULL) {
260 if (*ppos >= hppfs->len)
263 data = hppfs->contents;
265 while (off >= sizeof(data->contents)) {
266 data = list_entry(data->list.next, struct hppfs_data,
268 off -= sizeof(data->contents);
271 if (off + count > hppfs->len)
272 count = hppfs->len - off;
273 rem = copy_to_user(buf, &data->contents[off], count);
274 *ppos += count - rem;
277 } else if (hppfs->host_fd != -1) {
278 err = os_seek_file(hppfs->host_fd, *ppos);
280 printk(KERN_ERR "hppfs_read : seek failed, "
281 "errno = %d\n", err);
284 err = hppfs_read_file(hppfs->host_fd, buf, count);
286 printk(KERN_ERR "hppfs_read: read failed: %d\n", err);
293 else count = read_proc(hppfs->proc_file, buf, count, ppos, 1);
298 static ssize_t hppfs_write(struct file *file, const char __user *buf,
299 size_t len, loff_t *ppos)
301 struct hppfs_private *data = file->private_data;
302 struct file *proc_file = data->proc_file;
303 ssize_t (*write)(struct file *, const char __user *, size_t, loff_t *);
305 write = proc_file->f_path.dentry->d_inode->i_fop->write;
306 return (*write)(proc_file, buf, len, ppos);
309 static int open_host_sock(char *host_file, int *filter_out)
314 end = &host_file[strlen(host_file)];
317 fd = os_connect_socket(host_file);
323 fd = os_connect_socket(host_file);
327 static void free_contents(struct hppfs_data *head)
329 struct hppfs_data *data;
330 struct list_head *ele, *next;
335 list_for_each_safe(ele, next, &head->list) {
336 data = list_entry(ele, struct hppfs_data, list);
342 static struct hppfs_data *hppfs_get_data(int fd, int filter,
343 struct file *proc_file,
344 struct file *hppfs_file,
347 struct hppfs_data *data, *new, *head;
351 data = kmalloc(sizeof(*data), GFP_KERNEL);
353 printk(KERN_ERR "hppfs_get_data : head allocation failed\n");
357 INIT_LIST_HEAD(&data->list);
363 while ((n = read_proc(proc_file, data->contents,
364 sizeof(data->contents), NULL, 0)) > 0)
365 os_write_file(fd, data->contents, n);
366 err = os_shutdown_socket(fd, 0, 1);
368 printk(KERN_ERR "hppfs_get_data : failed to shut down "
374 n = os_read_file(fd, data->contents, sizeof(data->contents));
377 printk(KERN_ERR "hppfs_get_data : read failed, "
378 "errno = %d\n", err);
385 if (n < sizeof(data->contents))
388 new = kmalloc(sizeof(*data), GFP_KERNEL);
390 printk(KERN_ERR "hppfs_get_data : data allocation "
396 INIT_LIST_HEAD(&new->list);
397 list_add(&new->list, &data->list);
408 static struct hppfs_private *hppfs_data(void)
410 struct hppfs_private *data;
412 data = kmalloc(sizeof(*data), GFP_KERNEL);
416 *data = ((struct hppfs_private ) { .host_fd = -1,
418 .contents = NULL } );
422 static int file_mode(int fmode)
424 if (fmode == (FMODE_READ | FMODE_WRITE))
426 if (fmode == FMODE_READ)
428 if (fmode == FMODE_WRITE)
433 static int hppfs_open(struct inode *inode, struct file *file)
435 const struct cred *cred = file->f_cred;
436 struct hppfs_private *data;
437 struct vfsmount *proc_mnt;
438 struct dentry *proc_dentry;
440 int err, fd, type, filter;
447 host_file = dentry_name(file->f_path.dentry, strlen("/rw"));
448 if (host_file == NULL)
451 proc_dentry = HPPFS_I(inode)->proc_dentry;
452 proc_mnt = inode->i_sb->s_fs_info;
454 /* XXX This isn't closed anywhere */
455 data->proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt),
456 file_mode(file->f_mode), cred);
457 err = PTR_ERR(data->proc_file);
458 if (IS_ERR(data->proc_file))
461 type = os_file_type(host_file);
462 if (type == OS_TYPE_FILE) {
463 fd = os_open_file(host_file, of_read(OPENFLAGS()), 0);
467 printk(KERN_ERR "hppfs_open : failed to open '%s', "
468 "errno = %d\n", host_file, -fd);
470 data->contents = NULL;
471 } else if (type == OS_TYPE_DIR) {
472 fd = open_host_sock(host_file, &filter);
474 data->contents = hppfs_get_data(fd, filter,
477 if (!IS_ERR(data->contents))
480 printk(KERN_ERR "hppfs_open : failed to open a socket "
481 "in '%s', errno = %d\n", host_file, -fd);
485 file->private_data = data;
491 free_contents(data->contents);
497 static int hppfs_dir_open(struct inode *inode, struct file *file)
499 const struct cred *cred = file->f_cred;
500 struct hppfs_private *data;
501 struct vfsmount *proc_mnt;
502 struct dentry *proc_dentry;
510 proc_dentry = HPPFS_I(inode)->proc_dentry;
511 proc_mnt = inode->i_sb->s_fs_info;
512 data->proc_file = dentry_open(dget(proc_dentry), mntget(proc_mnt),
513 file_mode(file->f_mode), cred);
514 err = PTR_ERR(data->proc_file);
515 if (IS_ERR(data->proc_file))
518 file->private_data = data;
527 static loff_t hppfs_llseek(struct file *file, loff_t off, int where)
529 struct hppfs_private *data = file->private_data;
530 struct file *proc_file = data->proc_file;
531 loff_t (*llseek)(struct file *, loff_t, int);
534 llseek = proc_file->f_path.dentry->d_inode->i_fop->llseek;
535 if (llseek != NULL) {
536 ret = (*llseek)(proc_file, off, where);
541 return default_llseek(file, off, where);
544 static const struct file_operations hppfs_file_fops = {
546 .llseek = hppfs_llseek,
548 .write = hppfs_write,
552 struct hppfs_dirent {
555 struct dentry *dentry;
558 static int hppfs_filldir(void *d, const char *name, int size,
559 loff_t offset, u64 inode, unsigned int type)
561 struct hppfs_dirent *dirent = d;
563 if (file_removed(dirent->dentry, name))
566 return (*dirent->filldir)(dirent->vfs_dirent, name, size, offset,
570 static int hppfs_readdir(struct file *file, void *ent, filldir_t filldir)
572 struct hppfs_private *data = file->private_data;
573 struct file *proc_file = data->proc_file;
574 int (*readdir)(struct file *, void *, filldir_t);
575 struct hppfs_dirent dirent = ((struct hppfs_dirent)
578 .dentry = file->f_path.dentry
582 readdir = proc_file->f_path.dentry->d_inode->i_fop->readdir;
584 proc_file->f_pos = file->f_pos;
585 err = (*readdir)(proc_file, &dirent, hppfs_filldir);
586 file->f_pos = proc_file->f_pos;
591 static int hppfs_fsync(struct file *file, int datasync)
596 static const struct file_operations hppfs_dir_fops = {
598 .readdir = hppfs_readdir,
599 .open = hppfs_dir_open,
600 .fsync = hppfs_fsync,
601 .llseek = default_llseek,
604 static int hppfs_statfs(struct dentry *dentry, struct kstatfs *sf)
611 sf->f_type = HPPFS_SUPER_MAGIC;
615 static struct inode *hppfs_alloc_inode(struct super_block *sb)
617 struct hppfs_inode_info *hi;
619 hi = kmalloc(sizeof(*hi), GFP_KERNEL);
623 hi->proc_dentry = NULL;
624 inode_init_once(&hi->vfs_inode);
625 return &hi->vfs_inode;
628 void hppfs_evict_inode(struct inode *ino)
631 dput(HPPFS_I(ino)->proc_dentry);
632 mntput(ino->i_sb->s_fs_info);
635 static void hppfs_destroy_inode(struct inode *inode)
637 kfree(HPPFS_I(inode));
640 static const struct super_operations hppfs_sbops = {
641 .alloc_inode = hppfs_alloc_inode,
642 .destroy_inode = hppfs_destroy_inode,
643 .evict_inode = hppfs_evict_inode,
644 .statfs = hppfs_statfs,
647 static int hppfs_readlink(struct dentry *dentry, char __user *buffer,
650 struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
651 return proc_dentry->d_inode->i_op->readlink(proc_dentry, buffer,
655 static void *hppfs_follow_link(struct dentry *dentry, struct nameidata *nd)
657 struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
659 return proc_dentry->d_inode->i_op->follow_link(proc_dentry, nd);
662 static void hppfs_put_link(struct dentry *dentry, struct nameidata *nd,
665 struct dentry *proc_dentry = HPPFS_I(dentry->d_inode)->proc_dentry;
667 if (proc_dentry->d_inode->i_op->put_link)
668 proc_dentry->d_inode->i_op->put_link(proc_dentry, nd, cookie);
671 static const struct inode_operations hppfs_dir_iops = {
672 .lookup = hppfs_lookup,
675 static const struct inode_operations hppfs_link_iops = {
676 .readlink = hppfs_readlink,
677 .follow_link = hppfs_follow_link,
678 .put_link = hppfs_put_link,
681 static struct inode *get_inode(struct super_block *sb, struct dentry *dentry)
683 struct inode *proc_ino = dentry->d_inode;
684 struct inode *inode = new_inode(sb);
687 return ERR_PTR(-ENOMEM);
689 if (S_ISDIR(dentry->d_inode->i_mode)) {
690 inode->i_op = &hppfs_dir_iops;
691 inode->i_fop = &hppfs_dir_fops;
692 } else if (S_ISLNK(dentry->d_inode->i_mode)) {
693 inode->i_op = &hppfs_link_iops;
694 inode->i_fop = &hppfs_file_fops;
696 inode->i_op = &hppfs_file_iops;
697 inode->i_fop = &hppfs_file_fops;
700 HPPFS_I(inode)->proc_dentry = dget(dentry);
702 inode->i_uid = proc_ino->i_uid;
703 inode->i_gid = proc_ino->i_gid;
704 inode->i_atime = proc_ino->i_atime;
705 inode->i_mtime = proc_ino->i_mtime;
706 inode->i_ctime = proc_ino->i_ctime;
707 inode->i_ino = proc_ino->i_ino;
708 inode->i_mode = proc_ino->i_mode;
709 inode->i_nlink = proc_ino->i_nlink;
710 inode->i_size = proc_ino->i_size;
711 inode->i_blocks = proc_ino->i_blocks;
716 static int hppfs_fill_super(struct super_block *sb, void *d, int silent)
718 struct inode *root_inode;
719 struct vfsmount *proc_mnt;
722 proc_mnt = mntget(current->nsproxy->pid_ns->proc_mnt);
723 if (IS_ERR(proc_mnt))
726 sb->s_blocksize = 1024;
727 sb->s_blocksize_bits = 10;
728 sb->s_magic = HPPFS_SUPER_MAGIC;
729 sb->s_op = &hppfs_sbops;
730 sb->s_fs_info = proc_mnt;
733 root_inode = get_inode(sb, proc_mnt->mnt_sb->s_root);
737 sb->s_root = d_alloc_root(root_inode);
751 static int hppfs_read_super(struct file_system_type *type,
752 int flags, const char *dev_name,
753 void *data, struct vfsmount *mnt)
755 return get_sb_nodev(type, flags, data, hppfs_fill_super, mnt);
758 static struct file_system_type hppfs_type = {
759 .owner = THIS_MODULE,
761 .get_sb = hppfs_read_super,
762 .kill_sb = kill_anon_super,
766 static int __init init_hppfs(void)
768 return register_filesystem(&hppfs_type);
771 static void __exit exit_hppfs(void)
773 unregister_filesystem(&hppfs_type);
776 module_init(init_hppfs)
777 module_exit(exit_hppfs)
778 MODULE_LICENSE("GPL");