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 data
->proc_file
= dentry_open(dget(proc_dentry
), mntget(proc_mnt
),
455 file_mode(file
->f_mode
), cred
);
456 err
= PTR_ERR(data
->proc_file
);
457 if (IS_ERR(data
->proc_file
))
460 type
= os_file_type(host_file
);
461 if (type
== OS_TYPE_FILE
) {
462 fd
= os_open_file(host_file
, of_read(OPENFLAGS()), 0);
466 printk(KERN_ERR
"hppfs_open : failed to open '%s', "
467 "errno = %d\n", host_file
, -fd
);
469 data
->contents
= NULL
;
470 } else if (type
== OS_TYPE_DIR
) {
471 fd
= open_host_sock(host_file
, &filter
);
473 data
->contents
= hppfs_get_data(fd
, filter
,
476 if (!IS_ERR(data
->contents
))
479 printk(KERN_ERR
"hppfs_open : failed to open a socket "
480 "in '%s', errno = %d\n", host_file
, -fd
);
484 file
->private_data
= data
;
490 free_contents(data
->contents
);
496 static int hppfs_dir_open(struct inode
*inode
, struct file
*file
)
498 const struct cred
*cred
= file
->f_cred
;
499 struct hppfs_private
*data
;
500 struct vfsmount
*proc_mnt
;
501 struct dentry
*proc_dentry
;
509 proc_dentry
= HPPFS_I(inode
)->proc_dentry
;
510 proc_mnt
= inode
->i_sb
->s_fs_info
;
511 data
->proc_file
= dentry_open(dget(proc_dentry
), mntget(proc_mnt
),
512 file_mode(file
->f_mode
), cred
);
513 err
= PTR_ERR(data
->proc_file
);
514 if (IS_ERR(data
->proc_file
))
517 file
->private_data
= data
;
526 static loff_t
hppfs_llseek(struct file
*file
, loff_t off
, int where
)
528 struct hppfs_private
*data
= file
->private_data
;
529 struct file
*proc_file
= data
->proc_file
;
530 loff_t (*llseek
)(struct file
*, loff_t
, int);
533 llseek
= proc_file
->f_path
.dentry
->d_inode
->i_fop
->llseek
;
534 if (llseek
!= NULL
) {
535 ret
= (*llseek
)(proc_file
, off
, where
);
540 return default_llseek(file
, off
, where
);
543 static const struct file_operations hppfs_file_fops
= {
545 .llseek
= hppfs_llseek
,
547 .write
= hppfs_write
,
551 struct hppfs_dirent
{
554 struct dentry
*dentry
;
557 static int hppfs_filldir(void *d
, const char *name
, int size
,
558 loff_t offset
, u64 inode
, unsigned int type
)
560 struct hppfs_dirent
*dirent
= d
;
562 if (file_removed(dirent
->dentry
, name
))
565 return (*dirent
->filldir
)(dirent
->vfs_dirent
, name
, size
, offset
,
569 static int hppfs_readdir(struct file
*file
, void *ent
, filldir_t filldir
)
571 struct hppfs_private
*data
= file
->private_data
;
572 struct file
*proc_file
= data
->proc_file
;
573 int (*readdir
)(struct file
*, void *, filldir_t
);
574 struct hppfs_dirent dirent
= ((struct hppfs_dirent
)
577 .dentry
= file
->f_path
.dentry
581 readdir
= proc_file
->f_path
.dentry
->d_inode
->i_fop
->readdir
;
583 proc_file
->f_pos
= file
->f_pos
;
584 err
= (*readdir
)(proc_file
, &dirent
, hppfs_filldir
);
585 file
->f_pos
= proc_file
->f_pos
;
590 static int hppfs_fsync(struct file
*file
, int datasync
)
595 static const struct file_operations hppfs_dir_fops
= {
597 .readdir
= hppfs_readdir
,
598 .open
= hppfs_dir_open
,
599 .fsync
= hppfs_fsync
,
602 static int hppfs_statfs(struct dentry
*dentry
, struct kstatfs
*sf
)
609 sf
->f_type
= HPPFS_SUPER_MAGIC
;
613 static struct inode
*hppfs_alloc_inode(struct super_block
*sb
)
615 struct hppfs_inode_info
*hi
;
617 hi
= kmalloc(sizeof(*hi
), GFP_KERNEL
);
621 hi
->proc_dentry
= NULL
;
622 inode_init_once(&hi
->vfs_inode
);
623 return &hi
->vfs_inode
;
626 void hppfs_evict_inode(struct inode
*ino
)
629 dput(HPPFS_I(ino
)->proc_dentry
);
630 mntput(ino
->i_sb
->s_fs_info
);
633 static void hppfs_destroy_inode(struct inode
*inode
)
635 kfree(HPPFS_I(inode
));
638 static const struct super_operations hppfs_sbops
= {
639 .alloc_inode
= hppfs_alloc_inode
,
640 .destroy_inode
= hppfs_destroy_inode
,
641 .evict_inode
= hppfs_evict_inode
,
642 .statfs
= hppfs_statfs
,
645 static int hppfs_readlink(struct dentry
*dentry
, char __user
*buffer
,
648 struct dentry
*proc_dentry
= HPPFS_I(dentry
->d_inode
)->proc_dentry
;
649 return proc_dentry
->d_inode
->i_op
->readlink(proc_dentry
, buffer
,
653 static void *hppfs_follow_link(struct dentry
*dentry
, struct nameidata
*nd
)
655 struct dentry
*proc_dentry
= HPPFS_I(dentry
->d_inode
)->proc_dentry
;
657 return proc_dentry
->d_inode
->i_op
->follow_link(proc_dentry
, nd
);
660 static void hppfs_put_link(struct dentry
*dentry
, struct nameidata
*nd
,
663 struct dentry
*proc_dentry
= HPPFS_I(dentry
->d_inode
)->proc_dentry
;
665 if (proc_dentry
->d_inode
->i_op
->put_link
)
666 proc_dentry
->d_inode
->i_op
->put_link(proc_dentry
, nd
, cookie
);
669 static const struct inode_operations hppfs_dir_iops
= {
670 .lookup
= hppfs_lookup
,
673 static const struct inode_operations hppfs_link_iops
= {
674 .readlink
= hppfs_readlink
,
675 .follow_link
= hppfs_follow_link
,
676 .put_link
= hppfs_put_link
,
679 static struct inode
*get_inode(struct super_block
*sb
, struct dentry
*dentry
)
681 struct inode
*proc_ino
= dentry
->d_inode
;
682 struct inode
*inode
= new_inode(sb
);
685 return ERR_PTR(-ENOMEM
);
687 if (S_ISDIR(dentry
->d_inode
->i_mode
)) {
688 inode
->i_op
= &hppfs_dir_iops
;
689 inode
->i_fop
= &hppfs_dir_fops
;
690 } else if (S_ISLNK(dentry
->d_inode
->i_mode
)) {
691 inode
->i_op
= &hppfs_link_iops
;
692 inode
->i_fop
= &hppfs_file_fops
;
694 inode
->i_op
= &hppfs_file_iops
;
695 inode
->i_fop
= &hppfs_file_fops
;
698 HPPFS_I(inode
)->proc_dentry
= dget(dentry
);
700 inode
->i_uid
= proc_ino
->i_uid
;
701 inode
->i_gid
= proc_ino
->i_gid
;
702 inode
->i_atime
= proc_ino
->i_atime
;
703 inode
->i_mtime
= proc_ino
->i_mtime
;
704 inode
->i_ctime
= proc_ino
->i_ctime
;
705 inode
->i_ino
= proc_ino
->i_ino
;
706 inode
->i_mode
= proc_ino
->i_mode
;
707 inode
->i_nlink
= proc_ino
->i_nlink
;
708 inode
->i_size
= proc_ino
->i_size
;
709 inode
->i_blocks
= proc_ino
->i_blocks
;
714 static int hppfs_fill_super(struct super_block
*sb
, void *d
, int silent
)
716 struct inode
*root_inode
;
717 struct vfsmount
*proc_mnt
;
720 proc_mnt
= mntget(current
->nsproxy
->pid_ns
->proc_mnt
);
721 if (IS_ERR(proc_mnt
))
724 sb
->s_blocksize
= 1024;
725 sb
->s_blocksize_bits
= 10;
726 sb
->s_magic
= HPPFS_SUPER_MAGIC
;
727 sb
->s_op
= &hppfs_sbops
;
728 sb
->s_fs_info
= proc_mnt
;
731 root_inode
= get_inode(sb
, proc_mnt
->mnt_sb
->s_root
);
735 sb
->s_root
= d_alloc_root(root_inode
);
749 static int hppfs_read_super(struct file_system_type
*type
,
750 int flags
, const char *dev_name
,
751 void *data
, struct vfsmount
*mnt
)
753 return get_sb_nodev(type
, flags
, data
, hppfs_fill_super
, mnt
);
756 static struct file_system_type hppfs_type
= {
757 .owner
= THIS_MODULE
,
759 .get_sb
= hppfs_read_super
,
760 .kill_sb
= kill_anon_super
,
764 static int __init
init_hppfs(void)
766 return register_filesystem(&hppfs_type
);
769 static void __exit
exit_hppfs(void)
771 unregister_filesystem(&hppfs_type
);
774 module_init(init_hppfs
)
775 module_exit(exit_hppfs
)
776 MODULE_LICENSE("GPL");