driver.org/avflt/CHANGELOG		driver/avflt/CHANGELOG

⋮		⋮
		1+	version·0.6F·2015-03-03
		2+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		3+	» -·support·for·-3.19.x·kernels
		4+
		5+	version·0.6E·2015-02-28
		6+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		7+	» -·fixed·crash·kernel·3.5·or·lower
		8+
		9+	version·0.6D·2014-12-03
		10+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		11+	» -·source·cleanup
		12+
		13+	version·0.6C·2013-08-31
		14+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		15+	» -·source·cleanup
		16+
		17+	version·0.6B·2013-08-22
		18+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		19+	» -·fixed·leak·dget·in·avflt_get_file()
		20+
		21+	version·0.6A·2013-05-10
		22+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		23+	» -·support·for·-3.9.x·kernels
		24+
1	version·0.6·2010-05-20	25	version·0.6·2010-05-20
2	» *·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	26	» *·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
3	» -·reflected·changes·in·2.6.34·kernel	27	» -·reflected·changes·in·2.6.34·kernel

driver.org/avflt/avflt.h		driver/avflt/avflt.h
⋮		⋮
1	/*	1	/*
2	·*·AVFlt:·Anti-Virus·Filter	2	·*·AVFlt:·Anti-Virus·Filter
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
30	#include·<linux/file.h>	32	#include·<linux/file.h>
31	#include·<linux/mount.h>	33	#include·<linux/mount.h>
32	#include·<linux/version.h>	34	#include·<linux/version.h>
		35+	#if·(LINUX_VERSION_CODE·>·KERNEL_VERSION(2,6,18))
33	#include·<linux/freezer.h>	36	#include·<linux/freezer.h>
		37+	#endif
34	#include·<linux/fs.h>	38	#include·<linux/fs.h>
35	#include·<linux/slab.h>	39	#include·<linux/slab.h>
36-	#include·<redirfs.h>	40+	#include·<rfs.h>
37		41
38-	#define·AVFLT_VERSION» "0.6"	42+	#define·AVFLT_VERSION» "0.6F"
39		43
40	#define·AVFLT_EVENT_OPEN» 1	44	#define·AVFLT_EVENT_OPEN» 1
41	#define·AVFLT_EVENT_CLOSE» 2	45	#define·AVFLT_EVENT_CLOSE» 2

driver.org/avflt/avflt_check.c		driver/avflt/avflt_check.c
⋮		⋮
1	/*	1	/*
2	·*·AVFlt:·Anti-Virus·Filter	2	·*·AVFlt:·Anti-Virus·Filter
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
24	#include·"avflt.h"	26	#include·"avflt.h"
25		27
26	DECLARE_WAIT_QUEUE_HEAD(avflt_request_available);	28	DECLARE_WAIT_QUEUE_HEAD(avflt_request_available);
		29+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,39))
27	static·spinlock_t·avflt_request_lock·=·SPIN_LOCK_UNLOCKED;	30	static·spinlock_t·avflt_request_lock·=·SPIN_LOCK_UNLOCKED;
		31+	#else
		32+	static·DEFINE_SPINLOCK(avflt_request_lock);
		33+	#endif
28	static·LIST_HEAD(avflt_request_list);	34	static·LIST_HEAD(avflt_request_list);
29	static·int·avflt_request_accept·=·0;	35	static·int·avflt_request_accept·=·0;
30-	static·struct·kmem_cache·*avflt_event_cache·=·NULL;	36+	static·rfs_kmem_cache_t·*avflt_event_cache·=·NULL;
31	atomic_t·avflt_cache_ver·=·ATOMIC_INIT(0);	37	atomic_t·avflt_cache_ver·=·ATOMIC_INIT(0);
32	atomic_t·avflt_event_ids·=·ATOMIC_INIT(0);	38	atomic_t·avflt_event_ids·=·ATOMIC_INIT(0);
33		39
⋮		⋮
47	» atomic_set(&event->count,·1);	53	» atomic_set(&event->count,·1);
48	» event->type·=·type;	54	» event->type·=·type;
49	» event->id·=·-1;	55	» event->id·=·-1;
		56+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,9,0))
50	» event->mnt·=·mntget(file->f_vfsmnt);	57	» event->mnt·=·mntget(file->f_vfsmnt);
51	» event->dentry·=·dget(file->f_dentry);	58	» event->dentry·=·dget(file->f_dentry);
		59+	#else
		60+	» event->mnt·=·mntget(file->f_path.mnt);
		61+	» event->dentry·=·dget(file->f_path.dentry);
		62+	#endif
52	» event->flags·=·file->f_flags;	63	» event->flags·=·file->f_flags;
53	» event->fd·=·-1;	64	» event->fd·=·-1;
54	» event->pid·=·current->pid;	65	» event->pid·=·current->pid;
55	» event->tgid·=·current->tgid;	66	» event->tgid·=·current->tgid;
56	» event->cache·=·1;	67	» event->cache·=·1;
57		68
		69+	#if·LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0)
58	» root_data·=·avflt_get_root_data_inode(file->f_dentry->d_inode);	70	» root_data·=·avflt_get_root_data_inode(file->f_dentry->d_inode);
59	» inode_data·=·avflt_get_inode_data_inode(file->f_dentry->d_inode);	71	» inode_data·=·avflt_get_inode_data_inode(file->f_dentry->d_inode);
		72+	#else
		73+	» root_data·=·avflt_get_root_data_inode(file->f_path.dentry->d_inode);
		74+	» inode_data·=·avflt_get_inode_data_inode(file->f_path.dentry->d_inode);
		75+	#endif
60		76
61	» if·(root_data)·	77	» if·(root_data)·
62	» » event->root_cache_ver·=·atomic_read(&root_data->cache_ver);	78	» » event->root_cache_ver·=·atomic_read(&root_data->cache_ver);
⋮		⋮
256		272
257	int·avflt_get_file(struct·avflt_event·*event)	273	int·avflt_get_file(struct·avflt_event·*event)
258	{	274	{
		275+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
		276+	#else
		277+	» struct·path·path;
		278+	#endif
		279+
259	» struct·file·*file;	280	» struct·file·*file;
260	» int·flags;	281	» int·flags;
261	» int·fd;	282	» int·fd;
		283+	» int·rv·=·0;
262		284
		285+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
263	» fd·=·get_unused_fd();	286	» fd·=·get_unused_fd();
		287+	#else
		288+	» fd·=·get_unused_fd_flags(0);
		289+	#endif
		290+	»
264	» if·(fd·<·0)	291	» if·(fd·<·0)
265	» » return·fd;	292	» » return·fd;
266		293
267	» flags·=·O_RDONLY;	294	» flags·=·O_RDONLY;
268	» flags·\|=·event->flags·&·O_LARGEFILE;	295	» flags·\|=·event->flags·&·O_LARGEFILE;
269		296
270-	#if·LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,29)	297+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,29))
271	» file·=·dentry_open(dget(event->dentry),·mntget(event->mnt),·flags);	298	» file·=·dentry_open(dget(event->dentry),·mntget(event->mnt),·flags);
272-	#else	299+	#elif·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
273	» file·=·dentry_open(dget(event->dentry),·mntget(event->mnt),·flags,	300	» file·=·dentry_open(dget(event->dentry),·mntget(event->mnt),·flags,
274	» » » current_cred());	301	» » » current_cred());
		302+	#else
		303+	» path.mnt=mntget(event->mnt);
		304+	» path.dentry=dget(event->dentry);
		305+	» file·=·dentry_open(&path,·flags,·current_cred());
275	#endif	306	#endif
276-	» if·(IS_ERR(file))·{	307+
		308+	» if·(!IS_ERR(file)){
		309+	» » event->file·=·file;
		310+	» » event->fd·=·fd;
		311+	» }·else·{
277	» » put_unused_fd(fd);	312	» » put_unused_fd(fd);
278-	» » return·PTR_ERR(file);	313+	» » rv·=·PTR_ERR(file);
279	» }	314	» }
280		315
281-	» event->file·=·file;	316+	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(3,6,0))
282-	» event->fd·=·fd;	317+	» mntput(event->mnt);
		318+	» dput(event->dentry);
		319+	#endif
283		320
284-	» return·0;	321+	» return·rv;
285	}	322	}
286		323
287	void·avflt_put_file(struct·avflt_event·*event)	324	void·avflt_put_file(struct·avflt_event·*event)
⋮		⋮
485		522
486	int·avflt_check_init(void)	523	int·avflt_check_init(void)
487	{	524	{
		525+	» /*
488	» avflt_event_cache·=·kmem_cache_create("avflt_event_cache",	526	» avflt_event_cache·=·kmem_cache_create("avflt_event_cache",
489	» » » sizeof(struct·avflt_event),	527	» » » sizeof(struct·avflt_event),
490	» » » 0,·SLAB_RECLAIM_ACCOUNT,·NULL);	528	» » » 0,·SLAB_RECLAIM_ACCOUNT,·NULL);
		529+	» */
		530+	» avflt_event_cache·=·rfs_kmem_cache_create("avflt_event_cache",
		531+	» » » sizeof(struct·avflt_event));
491		532
492	» if·(!avflt_event_cache)	533	» if·(!avflt_event_cache)
493	» » return·-ENOMEM;	534	» » return·-ENOMEM;

driver.org/avflt/avflt_data.c		driver/avflt/avflt_data.c
⋮		⋮
1	/*	1	/*
2	·*·AVFlt:·Anti-Virus·Filter	2	·*·AVFlt:·Anti-Virus·Filter
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2014·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
23		25
24	#include·"avflt.h"	26	#include·"avflt.h"
25		27
26-	static·struct·kmem_cache·*avflt_inode_data_cache·=·NULL;	28+	static·rfs_kmem_cache_t·*avflt_inode_data_cache·=·NULL;
27		29
28	static·void·avflt_root_data_free(struct·redirfs_data·*rfs_data)	30	static·void·avflt_root_data_free(struct·redirfs_data·*rfs_data)
29	{	31	{
⋮		⋮
220		222
221	int·avflt_data_init(void)	223	int·avflt_data_init(void)
222	{	224	{
		225+	» /*
223	» avflt_inode_data_cache·=·kmem_cache_create("avflt_inode_data_cache",	226	» avflt_inode_data_cache·=·kmem_cache_create("avflt_inode_data_cache",
224	» » » sizeof(struct·avflt_inode_data),	227	» » » sizeof(struct·avflt_inode_data),
225	» » » 0,·SLAB_RECLAIM_ACCOUNT,·NULL);	228	» » » 0,·SLAB_RECLAIM_ACCOUNT,·NULL);
		229+	» */
		230+	» avflt_inode_data_cache·=·rfs_kmem_cache_create("avflt_inode_data_cache",
		231+	» » » sizeof(struct·avflt_inode_data));
226		232
227	» if·(!avflt_inode_data_cache)	233	» if·(!avflt_inode_data_cache)
228	» » return·-ENOMEM;	234	» » return·-ENOMEM;

driver.org/avflt/avflt_dev.c		driver/avflt/avflt_dev.c
⋮		⋮
1	/*	1	/*
2	·*·AVFlt:·Anti-Virus·Filter	2	·*·AVFlt:·Anti-Virus·Filter
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2014·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
110	» avflt_install_fd(event);	112	» avflt_install_fd(event);
111	» avflt_event_put(event);	113	» avflt_event_put(event);
112	» return·len;	114	» return·len;
		115+
113	error:	116	error:
114	» avflt_put_file(event);	117	» avflt_put_file(event);
115	» avflt_readd_request(event);	118	» avflt_readd_request(event);
⋮		⋮
170	» » return·PTR_ERR(avflt_class);	173	» » return·PTR_ERR(avflt_class);
171	» }	174	» }
172		175
173-	#if·LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,27)	176+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,27))
174	» avflt_device·=·device_create(avflt_class,·NULL,·avflt_dev,·"avflt");	177	» avflt_device·=·device_create(avflt_class,·NULL,·avflt_dev,·"avflt");
175	#else	178	#else
176	» avflt_device·=·device_create(avflt_class,·NULL,·avflt_dev,·NULL,·"avflt");	179	» avflt_device·=·device_create(avflt_class,·NULL,·avflt_dev,·NULL,·"avflt");

driver.org/avflt/avflt_mod.c		driver/avflt/avflt_mod.c
⋮		⋮
1	/*	1	/*
2	·*·AVFlt:·Anti-Virus·Filter	2	·*·AVFlt:·Anti-Virus·Filter
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2014·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
47	» if·(rv)	49	» if·(rv)
48	» » goto·err_sys;	50	» » goto·err_sys;
49		51
50-	» printk(KERN_INFO·"Anti-Virus·Filter·Version·"	52+	» printk(KERN_INFO·"Anti-Virus·Filter·Version·"·AVFLT_VERSION·"·<www.redirfs.org>\n");
51-	» » » AVFLT_VERSION·"·<www.redirfs.org>\n");	53+	» printk(KERN_INFO·"Midified·by·KINTA-JAPAN\n");
52	» return·0;	54	» return·0;
53		55
54	err_sys:	56	err_sys:
⋮		⋮
76		78
77	MODULE_LICENSE("GPL");	79	MODULE_LICENSE("GPL");
78	MODULE_AUTHOR("Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>");	80	MODULE_AUTHOR("Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>");
		81+	MODULE_AUTHOR("KINTA-JAPAN·<sanu@ruby.plala.or.jp>");
79	MODULE_DESCRIPTION("Anti-Virus·Filter·for·the·RedirFS·Framework");	82	MODULE_DESCRIPTION("Anti-Virus·Filter·for·the·RedirFS·Framework");
80		83

driver.org/avflt/avflt_proc.c		driver/avflt/avflt_proc.c
⋮		⋮
1	/*	1	/*
2	·*·AVFlt:·Anti-Virus·Filter	2	·*·AVFlt:·Anti-Virus·Filter
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2014·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
24	#include·"avflt.h"	26	#include·"avflt.h"
25		27
26	static·LIST_HEAD(avflt_proc_list);	28	static·LIST_HEAD(avflt_proc_list);
27-	static·spinlock_t·avflt_proc_lock·=·SPIN_LOCK_UNLOCKED;	29+	static·DEFINE_SPINLOCK(avflt_proc_lock);
28		30
29	static·LIST_HEAD(avflt_trusted_list);	31	static·LIST_HEAD(avflt_trusted_list);
30-	static·spinlock_t·avflt_trusted_lock·=·SPIN_LOCK_UNLOCKED;	32+	static·DEFINE_SPINLOCK(avflt_trusted_lock);
31		33
32	static·struct·avflt_trusted·*avflt_trusted_alloc(pid_t·tgid)	34	static·struct·avflt_trusted·*avflt_trusted_alloc(pid_t·tgid)
33	{	35	{

driver.org/avflt/avflt_rfs.c		driver/avflt/avflt_rfs.c
⋮		⋮
1	/*	1	/*
2	·*·AVFlt:·Anti-Virus·Filter	2	·*·AVFlt:·Anti-Virus·Filter
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2014·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
33		35
34	» if·(avflt_trusted_allow(current->tgid))	36	» if·(avflt_trusted_allow(current->tgid))
35	» » return·0;	37	» » return·0;
36-	»	38+
		39+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
37	» if·(!file->f_dentry->d_inode)	40	» if·(!file->f_dentry->d_inode)
38	» » return·0;	41	» » return·0;
39		42
40	» if·(!i_size_read(file->f_dentry->d_inode))	43	» if·(!i_size_read(file->f_dentry->d_inode))
41	» » return·0;	44	» » return·0;
		45+	#else
		46+	» if·(!file->f_path.dentry->d_inode)
		47+	» » return·0;
		48+
		49+	» if·(!i_size_read(file->f_path.dentry->d_inode))
		50+	» » return·0;
		51+	#endif
42		52
43	» return·1;	53	» return·1;
44	}	54	}
⋮		⋮
53	» if·(!atomic_read(&avflt_cache_enabled))	63	» if·(!atomic_read(&avflt_cache_enabled))
54	» » return·0;	64	» » return·0;
55		65
		66+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
56	» root_data·=·avflt_get_root_data_inode(file->f_dentry->d_inode);	67	» root_data·=·avflt_get_root_data_inode(file->f_dentry->d_inode);
		68+	#else
		69+	» root_data·=·avflt_get_root_data_inode(file->f_path.dentry->d_inode);
		70+	#endif
		71+
57	» if·(!root_data)	72	» if·(!root_data)
58	» » return·0;	73	» » return·0;
59		74
⋮		⋮
62	» » return·0;	77	» » return·0;
63	» }	78	» }
64		79
		80+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
65	» inode_data·=·avflt_get_inode_data_inode(file->f_dentry->d_inode);	81	» inode_data·=·avflt_get_inode_data_inode(file->f_dentry->d_inode);
		82+	#else
		83+	» inode_data·=·avflt_get_inode_data_inode(file->f_path.dentry->d_inode);
		84+	#endif
		85+
66	» if·(!inode_data)·{	86	» if·(!inode_data)·{
67	» » avflt_put_root_data(root_data);	87	» » avflt_put_root_data(root_data);
68	» » return·0;	88	» » return·0;
69	» }	89	» }
70		90
		91+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
71	» wc·=·atomic_read(&file->f_dentry->d_inode->i_writecount);	92	» wc·=·atomic_read(&file->f_dentry->d_inode->i_writecount);
		93+	#else
		94+	» wc·=·atomic_read(&file->f_path.dentry->d_inode->i_writecount);
		95+	#endif
72		96
73	» spin_lock(&inode_data->lock);	97	» spin_lock(&inode_data->lock);
74		98

driver.org/avflt/avflt_sysfs.c		driver/avflt/avflt_sysfs.c
⋮		⋮
1	/*	1	/*
2	·*·AVFlt:·Anti-Virus·Filter	2	·*·AVFlt:·Anti-Virus·Filter
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.

driver.org/dazuko/CHANGELOG		driver/dazuko/CHANGELOG
⋮		⋮
2	Dazuko·CHANGELOG	2	Dazuko·CHANGELOG
3	================	3	================
4		4
		5+	2.3.9B
		6+	··Bug·Fix·locked_ioctl·(int·->·long)
		7+
		8+
		9+	2.3.9A
		10+	-·Support·Linux·Kernel·-3.9·(Redirfs·Only)
		11+
		12+
5	2.3.9	13	2.3.9
6	-·integrate·patch·from·Jaroslav·Suchanek·for·FreeBSD·8·support	14	-·integrate·patch·from·Jaroslav·Suchanek·for·FreeBSD·8·support
7		15

driver.org/dazuko/configure		driver/dazuko/configure
⋮		⋮
116	» then	116	» then
117	» » echo·-n·"kernel·build·source·in·${LINUX_CHECK_OBJ}...·"	117	» » echo·-n·"kernel·build·source·in·${LINUX_CHECK_OBJ}...·"
118		118
119-	» » if·[·-f·"${LINUX_CHECK_OBJ}/include/linux/version.h"·]	119+	#» » if·[·-f·"${LINUX_CHECK_OBJ}/include/linux/version.h"·]
120-	» » then	120+	#» » then
121-	» » » if·[·-f·"${LINUX_CHECK_OBJ}/include/linux/autoconf.h"·-o·-f·"${LINUX_CHECK_OBJ}/include/generated/autoconf.h"·]	121+	#» » » if·[·-f·"${LINUX_CHECK_OBJ}/include/linux/autoconf.h"·-o·-f·"${LINUX_CHECK_OBJ}/include/generated/autoconf.h"·]
122-	» » » then	122+	#» » » then
123	» » » » LINUX_OBJ="$LINUX_CHECK_OBJ"	123	» » » » LINUX_OBJ="$LINUX_CHECK_OBJ"
124	» » » » echo·"yes"	124	» » » » echo·"yes"
125-	» » » else	125+	#» » » else
126-	» » » » echo·"no"	126+	#» » » » echo·"no"
127-	» » » fi	127+	#» » » fi
128-	» » else	128+	#» » else
129-	» » » echo·"no"	129+	#» » » echo·"no"
130-	» » fi	130+	#» » fi
131	» fi	131	» fi
132	}	132	}
133		133

driver.org/dazuko/dazuko_core.c		driver/dazuko/dazuko_core.c
⋮		⋮
44	const·char» *DAZUKO_VERSION_STAMP·=·"\nDazukoVersion="·DAZUKO_VERSION_MAJOR·"."·DAZUKO_VERSION_MINOR·"."·DAZUKO_VERSION_REVISION·"."·DAZUKO_VERSION_RELEASE·"\n";	44	const·char» *DAZUKO_VERSION_STAMP·=·"\nDazukoVersion="·DAZUKO_VERSION_MAJOR·"."·DAZUKO_VERSION_MINOR·"."·DAZUKO_VERSION_REVISION·"."·DAZUKO_VERSION_RELEASE·"\n";
45		45
46	/·version·string·for·display·/	46	/·version·string·for·display·/
47-	const·char» *VERSION_STRING·=·DAZUKO_VERSION_MAJOR·"."·DAZUKO_VERSION_MINOR·"."·DAZUKO_VERSION_REVISION	47+	const·char» *VERSION_STRING·=·DAZUKO_VERSION_MAJOR·"."·DAZUKO_VERSION_MINOR·"."·DAZUKO_VERSION_REVISION·"."·DAZUKO_VERSION_RELEASE
48	#ifdef·DAZUKO_PRERELEASE	48	#ifdef·DAZUKO_PRERELEASE
49	"-pre"·DAZUKO_VERSION_RELEASE	49	"-pre"·DAZUKO_VERSION_RELEASE
50	#endif	50	#endif

driver.org/dazuko/dazuko_redirfs.c		driver/dazuko/dazuko_redirfs.c
⋮		⋮
43	#endif	43	#endif
44	#include·<asm/uaccess.h>	44	#include·<asm/uaccess.h>
45		45
		46+	#include·<linux/slab.h>
46		47
47	#ifndef·DAZUKO_DM	48	#ifndef·DAZUKO_DM
48	#define·DAZUKO_DM·0	49	#define·DAZUKO_DM·0
49	#endif	50	#endif
50		51
51-
52	ssize_t·linux_dazuko_device_read(struct·file·,·char·__user·,·size_t,·loff_t·*);	52	ssize_t·linux_dazuko_device_read(struct·file·,·char·__user·,·size_t,·loff_t·*);
53	ssize_t·linux_dazuko_device_write(struct·file·,·const·char·__user·,·size_t,·loff_t·*);	53	ssize_t·linux_dazuko_device_write(struct·file·,·const·char·__user·,·size_t,·loff_t·*);
54	int·linux_dazuko_device_open(struct·inode·,·struct·file·);	54	int·linux_dazuko_device_open(struct·inode·,·struct·file·);
		55+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,36))
55	int·linux_dazuko_device_ioctl(struct·inode·inode,·struct·file·file,·unsigned·int·cmd,·unsigned·long·param);	56	int·linux_dazuko_device_ioctl(struct·inode·inode,·struct·file·file,·unsigned·int·cmd,·unsigned·long·param);
		57+	#else
		58+	long·linux_dazuko_device_ioctl(struct·file·*file,·unsigned·int·cmd,·unsigned·long·param);
		59+	#endif
56	int·linux_dazuko_device_release(struct·inode·,·struct·file·);	60	int·linux_dazuko_device_release(struct·inode·,·struct·file·);
57		61
58	#ifndef·WITHOUT_UDEV	62	#ifndef·WITHOUT_UDEV
⋮		⋮
86	» » .owner» » =·THIS_MODULE,	90	» » .owner» » =·THIS_MODULE,
87	» » .read» » =·linux_dazuko_device_read,	91	» » .read» » =·linux_dazuko_device_read,
88	» » .write» » =·linux_dazuko_device_write,	92	» » .write» » =·linux_dazuko_device_write,
		93+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,36))
89	» » .ioctl» » =·linux_dazuko_device_ioctl,	94	» » .ioctl» » =·linux_dazuko_device_ioctl,
		95+	#else
		96+	» » .unlocked_ioctl» =·linux_dazuko_device_ioctl,
		97+	#endif
90	» » .open» » =·linux_dazuko_device_open,	98	» » .open» » =·linux_dazuko_device_open,
91	» » .release»=·linux_dazuko_device_release,	99	» » .release»=·linux_dazuko_device_release,
92	» };	100	» };
⋮		⋮
96		104
97	inline·void·xp_init_mutex(struct·xp_mutex·*mutex)	105	inline·void·xp_init_mutex(struct·xp_mutex·*mutex)
98	{	106	{
		107+
		108+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,37))
99	» init_MUTEX(&(mutex->mutex));	109	» init_MUTEX(&(mutex->mutex));
		110+	#else
		111+	» sema_init(&(mutex->mutex),·1);
		112+	#endif
100	}	113	}
101		114
102	inline·void·xp_down(struct·xp_mutex·*mutex)	115	inline·void·xp_down(struct·xp_mutex·*mutex)
⋮		⋮
594	» int·err·=·0;	607	» int·err·=·0;
595	» struct·redirfs_path_info·path_info;	608	» struct·redirfs_path_info·path_info;
596	» redirfs_path·rfs_path;	609	» redirfs_path·rfs_path;
		610+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,39))
597	» struct·nameidata·nd;	611	» struct·nameidata·nd;
		612+	#else
		613+	» struct·path·_path;
		614+	#endif
598		615
599	» switch·(type)	616	» switch·(type)
600	» {	617	» {
⋮		⋮
610	» » » return·-1;	627	» » » return·-1;
611	» }	628	» }
612		629
		630+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,39))
613	» if·(path_lookup(path,·LOOKUP_FOLLOW·\|·LOOKUP_DIRECTORY,·&nd)·!=·0)	631	» if·(path_lookup(path,·LOOKUP_FOLLOW·\|·LOOKUP_DIRECTORY,·&nd)·!=·0)
614	» » return·-1;	632	» » return·-1;
		633+	#else
		634+	» if·(kern_path(path,·LOOKUP_FOLLOW·\|·LOOKUP_DIRECTORY,·&_path)!=0)
		635+	» » return·-1;
		636+	#endif
615		637
		638+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,39))
616	» path_info.dentry·=·nd.path.dentry;	639	» path_info.dentry·=·nd.path.dentry;
617	» path_info.mnt·=·nd.path.mnt;	640	» path_info.mnt·=·nd.path.mnt;
		641+	#else
		642+	» path_info.dentry·=·_path.dentry;
		643+	» path_info.mnt·=·_path.mnt;
		644+	#endif
		645+
618	» rfs_path·=·redirfs_add_path(dazukoflt,·&path_info);	646	» rfs_path·=·redirfs_add_path(dazukoflt,·&path_info);
619	» if·(IS_ERR(rfs_path))·{	647	» if·(IS_ERR(rfs_path))·{
620	» » xp_print("dazuko:·failed·to·set·RedirFS·path,·err=%d\n",·err);	648	» » xp_print("dazuko:·failed·to·set·RedirFS·path,·err=%d\n",·err);
621	» » err·=·-1;	649	» » err·=·-1;
622	» }	650	» }
623		651
		652+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,39))
624	» path_put(&nd.path);	653	» path_put(&nd.path);
		654+	#else
		655+	» path_put(&_path);
		656+	#endif
		657+
625	» redirfs_put_path(rfs_path);	658	» redirfs_put_path(rfs_path);
626		659
627	» return·err;	660	» return·err;
⋮		⋮
702	{	735	{
703	» struct·nameidata·nd;	736	» struct·nameidata·nd;
704		737
		738+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,9,0))
705	» nd.path.dentry·=·args->args.f_open.file->f_dentry;	739	» nd.path.dentry·=·args->args.f_open.file->f_dentry;
706	» nd.path.mnt·=·args->args.f_open.file->f_vfsmnt;	740	» nd.path.mnt·=·args->args.f_open.file->f_vfsmnt;
		741+	#else
		742+	» nd.path.dentry·=·args->args.f_open.file->f_path.dentry;
		743+	» nd.path.mnt·=·args->args.f_open.file->f_path.mnt;
		744+	#endif
707		745
708	» if·(dazuko_sys_generic(args->args.f_open.file->f_dentry->d_inode,·&nd)·!=·0)	746	» if·(dazuko_sys_generic(args->args.f_open.file->f_dentry->d_inode,·&nd)·!=·0)
709	» {	747	» {
⋮		⋮
910	» return·XP_ERROR_INTERRUPT;	948	» return·XP_ERROR_INTERRUPT;
911	}	949	}
912		950
		951+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,36))
913	int·linux_dazuko_device_ioctl(struct·inode·inode,·struct·file·file,·unsigned·int·cmd,·unsigned·long·param)	952	int·linux_dazuko_device_ioctl(struct·inode·inode,·struct·file·file,·unsigned·int·cmd,·unsigned·long·param)
		953+	#else
		954+	long·linux_dazuko_device_ioctl(struct·file·*file,·unsigned·int·cmd,·unsigned·long·param)
		955+	#endif
914	{	956	{
915	» /*·A·daemon·uses·this·function·to·interact·with	957	» /*·A·daemon·uses·this·function·to·interact·with
916	» ·*·the·kernel.·A·daemon·can·set·scanning·parameters,	958	» ·*·the·kernel.·A·daemon·can·set·scanning·parameters,

driver.org/dazuko/dazuko_version.h		driver/dazuko/dazuko_version.h
⋮		⋮
39	#define·DAZUKO_VERSION_MAJOR» » "2"	39	#define·DAZUKO_VERSION_MAJOR» » "2"
40	#define·DAZUKO_VERSION_MINOR» » "3"	40	#define·DAZUKO_VERSION_MINOR» » "3"
41	#define·DAZUKO_VERSION_REVISION» » "9"	41	#define·DAZUKO_VERSION_REVISION» » "9"
42-	#define·DAZUKO_VERSION_RELEASE» » "2"	42+	#define·DAZUKO_VERSION_RELEASE» » "B"
43		43
44	/·this·must·be·defined·for·all·pre-release·versions·/	44	/·this·must·be·defined·for·all·pre-release·versions·/
45	/·#define·DAZUKO_PRERELEASE·/	45	/·#define·DAZUKO_PRERELEASE·/

driver.org/dazuko/dazukoio_core.c		driver/dazuko/dazukoio_core.c
⋮		⋮
49	const·char» *DAZUKO_VERSION_STAMP·=·"\nDazukoVersion="·DAZUKO_VERSION_MAJOR·"."·DAZUKO_VERSION_MINOR·"."·DAZUKO_VERSION_REVISION·"."·DAZUKO_VERSION_RELEASE·"\n";	49	const·char» *DAZUKO_VERSION_STAMP·=·"\nDazukoVersion="·DAZUKO_VERSION_MAJOR·"."·DAZUKO_VERSION_MINOR·"."·DAZUKO_VERSION_REVISION·"."·DAZUKO_VERSION_RELEASE·"\n";
50		50
51	/·version·string·for·display·/	51	/·version·string·for·display·/
52-	const·char» *VERSION_STRING·=·DAZUKO_VERSION_MAJOR·"."·DAZUKO_VERSION_MINOR·"."·DAZUKO_VERSION_REVISION	52+	const·char» *VERSION_STRING·=·DAZUKO_VERSION_MAJOR·"."·DAZUKO_VERSION_MINOR·"."·DAZUKO_VERSION_REVISION·"."·DAZUKO_VERSION_RELEASE
53	#ifdef·DAZUKO_PRERELEASE	53	#ifdef·DAZUKO_PRERELEASE
54	"-pre"·DAZUKO_VERSION_RELEASE	54	"-pre"·DAZUKO_VERSION_RELEASE
55	#endif	55	#endif

driver.org/redirfs/CHANGELOG		driver/redirfs/CHANGELOG
⋮		⋮
		1+	version·0.11·experimental-12A·2015-03-07
		2+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		3+	» ··fixed·build·error·any·kernel
		4+
		5+	version·0.11·experimental-12·2015-03-03
		6+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		7+	» -·support·for·-3.19.x·kernels
		8+
		9+	version·0.11·experimental-11A·2015-02-01
		10+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		11+	» ··Update·rfs_dcache_get_subs_mutex()
		12+	» ··fixed·build·error·kernel·3.2
		13+
		14+	version·0.11·experimental-11·2015-01-14
		15+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		16+	» -·support·for·-3.18.x·kernels
		17+
		18+	version·0.11·experimental-10C·2014-12-03
		19+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		20+	» -·source·cleanup
		21+	» ··Update·rfs_rename/rfs_rename2
		22+
		23+	version·0.11·experimental-10·2014-11-21
		24+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		25+	» -·support·for·-3.17.x·kernels
		26+
		27+	version·0.11·experimental-9·2014-03-23
		28+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		29+	» -·support·for·-3.13.x·kernels
		30+
		31+	version·0.11·experimental-8·2013-09-22
		32+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		33+	» -·bug·fix·error·handling
		34+
		35+	version·0.11·experimental-7·2013-09-07
		36+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		37+	» -·support·for·-3.11.x·kernels
		38+
		39+	version·0.11·experimental-6·2013-08-31
		40+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		41+	» -·source·cleanup
		42+
		43+	version·0.11·experimental-5·2013-07-09
		44+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		45+	» -·support·for·-3.10.x·kernels
		46+
		47+	version·0.11·experimental-4·2013-07-07
		48+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		49+	» -·bug·fix·(rv_int·not·defined)
		50+	» -·Bug·fix·(kernel·panic)
		51+
		52+	version·0.11·experimental-3·2013-06-08
		53+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		54+	» -·bug·fix·(to·many·dput·calls)
		55+
		56+	version·0.11·experimental-2·2013-05-10
		57+	» *·KINTA-JAPAN·<sanu@ruby.plala.or.jp>
		58+	» -·support·for·-3.9.x·kernels
		59+
		60+	version·0.11·experimental·2011-09-05
		61+	» *·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		62+	» -·added·pre_rename·and·post_rename·callback·to·redirfs_filter_operations
		63+	» » -·this·can·be·used·by·filter·to·be·notified·about·files·moved
		64+	» » ··inside·a·filter's·path·within·one·file·system
		65+	» -·support·for·2.6.38+·kernels
		66+	» -·redirfs_get_filename·is·now·just·a·simple·wrapper·around·d_path·and·it
		67+	» ··returns·a·filename·just·for·the·first·mount·point.
		68+
1	version·0.10·2010-05-20	69	version·0.10·2010-05-20
2	» *·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	70	» *·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
3	» -·reflected·changes·in·2.6.34·kernel	71	» -·reflected·changes·in·2.6.34·kernel

driver.org/redirfs/redirfs.h		driver/redirfs/redirfs.h
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
34	#include·<linux/aio.h>	36	#include·<linux/aio.h>
35	#include·<linux/version.h>	37	#include·<linux/version.h>
36		38
37-	#define·REDIRFS_VERSION·"0.10"	39+	#define·REDIRFS_VERSION·"0.11·EXPERIMENTAL-12A"
38		40
39	#define·REDIRFS_PATH_INCLUDE» » 1	41	#define·REDIRFS_PATH_INCLUDE» » 1
40	#define·REDIRFS_PATH_EXCLUDE» » 2	42	#define·REDIRFS_PATH_EXCLUDE» » 2
⋮		⋮
149		151
150	» REDIRFS_DIR_FOP_OPEN,	152	» REDIRFS_DIR_FOP_OPEN,
151	» REDIRFS_DIR_FOP_RELEASE,	153	» REDIRFS_DIR_FOP_RELEASE,
		154+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,11,0))
152	» REDIRFS_DIR_FOP_READDIR,	155	» REDIRFS_DIR_FOP_READDIR,
		156+	#else
		157+	» REDIRFS_DIR_FOP_ITERATE,
		158+	#endif
153	» /·REDIRFS_DIR_FOP_FLUSH,·/	159	» /·REDIRFS_DIR_FOP_FLUSH,·/
154		160
155	» REDIRFS_CHR_FOP_OPEN,	161	» REDIRFS_CHR_FOP_OPEN,
⋮		⋮
236	union·redirfs_op_args·{	242	union·redirfs_op_args·{
237	» struct·{	243	» struct·{
238	» » struct·dentry·*dentry;	244	» » struct·dentry·*dentry;
		245+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
239	» » struct·nameidata·*nd;	246	» » struct·nameidata·*nd;
		247+	#else
		248+	» » unsigned·int·flags;
		249+	#endif
240	» }·d_revalidate;»	250	» }·d_revalidate;»
241		251
242	» /*	252	» /*
⋮		⋮
246	» }·d_hash;	256	» }·d_hash;
247	» */	257	» */
248		258
		259+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,38))
249	» struct·{	260	» struct·{
250	» » struct·dentry·*dentry;	261	» » struct·dentry·*dentry;
251	» » struct·qstr·*name1;	262	» » struct·qstr·*name1;
252	» » struct·qstr·*name2;	263	» » struct·qstr·*name2;
253	» }·d_compare;	264	» }·d_compare;
		265+	#else
		266+	» struct·{
		267+	» » const·struct·dentry·*parent;
		268+	» » const·struct·dentry·*dentry;
		269+
		270+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,11,0))
		271+	» » const·struct·inode·*inode;
		272+	» » const·struct·inode·*d_inode;
		273+	#endif
		274+	» » unsigned·int·tlen;
		275+	» » const·char·*tname;
		276+	» » const·struct·qstr·*name;
		277+	» }·d_compare;
		278+	#endif
254		279
255	» /*	280	» /*
256	» struct·{	281	» struct·{
⋮		⋮
270	» struct·{	295	» struct·{
271	» » struct·inode·*dir;	296	» » struct·inode·*dir;
272	» » struct·dentry·*dentry;	297	» » struct·dentry·*dentry;
		298+	#if·LINUX_VERSION_CODE·<·KERNEL_VERSION(3,3,0)
273	» » int·mode;	299	» » int·mode;
		300+	#else
		301+	» » umode_t·mode;
		302+	#endif
		303+
		304+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
274	» » struct·nameidata·*nd;	305	» » struct·nameidata·*nd;
		306+	#else
		307+	» » bool·flags;
		308+	#endif
275	» }·i_create;	309	» }·i_create;
276		310
277	» struct·{	311	» struct·{
278	» » struct·inode·*dir;	312	» » struct·inode·*dir;
279	» » struct·dentry·*dentry;	313	» » struct·dentry·*dentry;
		314+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
280	» » struct·nameidata·*nd;	315	» » struct·nameidata·*nd;
		316+	#else
		317+	» » unsigned·int·flags;
		318+	#endif
281	» }·i_lookup;	319	» }·i_lookup;
282		320
283	» struct·{	321	» struct·{
⋮		⋮
300	» struct·{	338	» struct·{
301	» » struct·inode·*dir;	339	» » struct·inode·*dir;
302	» » struct·dentry·*dentry;	340	» » struct·dentry·*dentry;
		341+	#if·LINUX_VERSION_CODE·<·KERNEL_VERSION(3,3,0)
303	» » int·mode;	342	» » int·mode;
		343+	#else
		344+	» » umode_t·mode;
		345+	#endif
304	» }·i_mkdir;	346	» }·i_mkdir;
305		347
306	» struct·{	348	» struct·{
⋮		⋮
311	» struct·{	353	» struct·{
312	» » struct·inode·*dir;	354	» » struct·inode·*dir;
313	» » struct·dentry·*dentry;	355	» » struct·dentry·*dentry;
		356+	#if·LINUX_VERSION_CODE·<·KERNEL_VERSION(3,·3,·0)
314	» » int·mode;	357	» » int·mode;
		358+	#else
		359+	» » umode_t·mode;
		360+	#endif
315	» » dev_t·rdev;	361	» » dev_t·rdev;
316	» }·i_mknod;	362	» }·i_mknod;
317		363
⋮		⋮
320	» » struct·dentry·*old_dentry;	366	» » struct·dentry·*old_dentry;
321	» » struct·inode·*new_dir;	367	» » struct·inode·*new_dir;
322	» » struct·dentry·*new_dentry;	368	» » struct·dentry·*new_dentry;
		369+	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(3,15,0))
		370+	» » unsigned·int·flags;
		371+	#endif
323	» }·i_rename;	372	» }·i_rename;
324		373
325	#if·LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,27)	374	#if·LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,27)
⋮		⋮
328	» » int·mask;	377	» » int·mask;
329	» » struct·nameidata·*nd;	378	» » struct·nameidata·*nd;
330	» }·i_permission;	379	» }·i_permission;
		380+	#elif·LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,38)
		381+	» struct·{
		382+	» » struct·inode·*inode;
		383+	» » int·mask;
		384+	» }·i_permission;
		385+	#elif·LINUX_VERSION_CODE·<·KERNEL_VERSION(3,1,0)
		386+	» struct·{
		387+	» » struct·inode·*inode;
		388+	» » int·mask;
		389+	» » unsigned·int·flags;
		390+	» }·i_permission;
331	#else	391	#else
332	» struct·{	392	» struct·{
333	» » struct·inode·*inode;	393	» » struct·inode·*inode;
⋮		⋮
364	» }·f_mmap;	424	» }·f_mmap;
365	» */	425	» */
366		426
		427+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,11,0))
367	» struct·{	428	» struct·{
368	» » struct·file·*file;	429	» » struct·file·*file;
369	» » void·*dirent;	430	» » void·*dirent;
370	» » filldir_t·filldir;	431	» » filldir_t·filldir;
371	» }·f_readdir;	432	» }·f_readdir;
		433+	#else
		434+	» struct·{
		435+	» » struct·file·*file;
		436+	» » struct·dir_context·*dir_context;
		437+	» }·f_iterate;
		438+	#endif
372		439
373	» /*	440	» /*
374	» struct·{	441	» struct·{
⋮		⋮
552	};	619	};
553		620
554	struct·redirfs_filter_operations·{	621	struct·redirfs_filter_operations·{
555-	» ·int·(*activate)(void);	622+	» int·(*activate)(void);
556-	» ·int·(*deactivate)(void);	623+	» int·(*deactivate)(void);
557-	» ·int·(add_path)(struct·redirfs_path_info·);	624+	» int·(add_path)(struct·redirfs_path_info·);
558-	» ·int·(*rem_path)(redirfs_path);	625+	» int·(*rem_path)(redirfs_path);
559-	» ·int·(*unregister)(void);	626+	» int·(*unregister)(void);
560-	» ·int·(*rem_paths)(void);	627+	» int·(*rem_paths)(void);
561-	» ·void·(*move_begin)(void);	628+	» void·(*move_begin)(void);
562-	» ·void·(*move_end)(void);	629+	» void·(*move_end)(void);
563-	» ·int·(dentry_moved)(redirfs_root,·redirfs_root,·struct·dentry·);	630+	» int·(dentry_moved)(redirfs_root,·redirfs_root,·struct·dentry·);
564-	» ·int·(inode_moved)(redirfs_root,·redirfs_root,·struct·inode·);	631+	» int·(inode_moved)(redirfs_root,·redirfs_root,·struct·inode·);
		632+	» enum·redirfs_rv·(pre_rename)(redirfs_context,·struct·redirfs_args·);
		633+	» enum·redirfs_rv·(post_rename)(redirfs_context,·struct·redirfs_args·);
565	};	634	};
566		635
567	struct·redirfs_filter_info·{	636	struct·redirfs_filter_info·{

driver.org/redirfs/rfs.c		driver/redirfs/rfs.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
25		27
26	struct·rfs_info·*rfs_info_none;	28	struct·rfs_info·*rfs_info_none;
27		29
28-	int·rfs_precall_flts(struct·rfs_chain·rchain,·struct·rfs_context·rcont,	30+	int·rfs_precall_flts(struct·rfs_info·rinfo,·struct·rfs_context·rcont,
29	» » struct·redirfs_args·*rargs)	31	» » struct·redirfs_args·*rargs)
30	{	32	{
31	» enum·redirfs_rv·(rop)(redirfs_context,·struct·redirfs_args·);	33	» enum·redirfs_rv·(rop)(redirfs_context,·struct·redirfs_args·);
32	» enum·redirfs_rv·rv;	34	» enum·redirfs_rv·rv;
33		35
		36+	» struct·rfs_chain·*rchain;
		37+
		38+	» rargs->rv.rv_int=0;
		39+
		40+	» if·(!rinfo)
		41+	» » return·0;
		42+
		43+	» rchain·=·rinfo->rchain;
		44+
34	» if·(!rchain)	45	» if·(!rchain)
35	» » return·0;	46	» » return·0;
36		47
⋮		⋮
56	» return·0;	67	» return·0;
57	}	68	}
58		69
59-	void·rfs_postcall_flts(struct·rfs_chain·rchain,·struct·rfs_context·rcont,	70+	void·rfs_postcall_flts(struct·rfs_info·rinfo,·struct·rfs_context·rcont,
60	» » struct·redirfs_args·*rargs)	71	» » struct·redirfs_args·*rargs)
61	{	72	{
62	» enum·redirfs_rv·(rop)(redirfs_context,·struct·redirfs_args·);	73	» enum·redirfs_rv·(rop)(redirfs_context,·struct·redirfs_args·);
63		74
		75+	» struct·rfs_chain·*rchain;
		76+
		77+	» if·(!rinfo)
		78+	» » return;
		79+
		80+	» rchain·=·rinfo->rchain;
		81+
64	» if·(!rchain)	82	» if·(!rchain)
65	» » return;	83	» » return;
66		84
⋮		⋮
104		122
105	» printk(KERN_INFO·"Redirecting·File·System·Framework·Version·"	123	» printk(KERN_INFO·"Redirecting·File·System·Framework·Version·"
106	» » » REDIRFS_VERSION·"·<www.redirfs.org>\n");	124	» » » REDIRFS_VERSION·"·<www.redirfs.org>\n");
		125+	» printk(KERN_INFO·"Midified·by·KINTA-JAPAN\n");
107		126
108	» return·0;	127	» return·0;
109		128
⋮		⋮
122		141
123	MODULE_LICENSE("GPL");	142	MODULE_LICENSE("GPL");
124	MODULE_AUTHOR("Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>");	143	MODULE_AUTHOR("Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>");
		144+	MODULE_AUTHOR("KINTA-JAPAN·<sanu@ruby.plala.or.jp>");
125	MODULE_DESCRIPTION("Redirecting·File·System·Framework·Version·"	145	MODULE_DESCRIPTION("Redirecting·File·System·Framework·Version·"
126-	» » REDIRFS_VERSION·"·<www.redirfs.org>");	146+	» » REDIRFS_VERSION·"·<www.redirfs.org>·<www.bondoffamily-net.com>");
127		147

driver.org/redirfs/rfs.h		driver/redirfs/rfs.h
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
31	#include·<linux/slab.h>	33	#include·<linux/slab.h>
32	#include·"redirfs.h"	34	#include·"redirfs.h"
33		35
		36+	#ifdef·RFS_EXCHANGE_D_CHILD
		37+	#if·(RFS_EXCHANGE_D_CHILD·==·0)
		38+	#define·D_CHILD·d_child
		39+	#define·D_U_D_CHILD·d_u.d_child
		40+	#else
		41+	#define·D_CHILD·d_u.d_child
		42+	#define·D_U_D_CHILD·d_child
		43+	#endif
		44+	#else
		45+	#define·D_CHILD·d_child
		46+	#define·D_U_D_CHILD·d_u.d_child
		47+	#endif
		48+
		49+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
		50+	#else
		51+
		52+	» struct·rfs_nameidata·{
		53+	» » struct·path·path;
		54+	» };
		55+
		56+
		57+	#endif
		58+
		59+
34	#define·RFS_ADD_OP(ops_new,·op)·\	60	#define·RFS_ADD_OP(ops_new,·op)·\
35	» (ops_new.op·=·rfs_##op)	61	» (ops_new.op·=·rfs_##op)
36		62
⋮		⋮
78	#define·rfs_mutex_init(mutex)·init_MUTEX(mutex)	104	#define·rfs_mutex_init(mutex)·init_MUTEX(mutex)
79	#define·rfs_mutex_lock(mutex)·down(mutex)	105	#define·rfs_mutex_lock(mutex)·down(mutex)
80	#define·rfs_mutex_unlock(mutex)·up(mutex)	106	#define·rfs_mutex_unlock(mutex)·up(mutex)
81-	#define·rfs_for_each_d_child(pos,·head)·list_for_each_entry(pos,·head,·d_child)	107+	#define·rfs_for_each_d_child(pos,·head)·list_for_each_entry(pos,·head,·D_CHILD)
		108+
82	inline·static·void·rfs_inode_mutex_lock(struct·inode·*inode)	109	inline·static·void·rfs_inode_mutex_lock(struct·inode·*inode)
83	{	110	{
84	» down(&inode->i_sem);	111	» down(&inode->i_sem);
⋮		⋮
87	{	114	{
88	» up(&inode->i_sem);	115	» up(&inode->i_sem);
89	}	116	}
		117+	#elif·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,18,0))
		118+	#define·rfs_mutex_t·mutex
		119+	#define·RFS_DEFINE_MUTEX(mutex)·DEFINE_MUTEX(mutex)
		120+	#define·rfs_mutex_init(mutex)·mutex_init(mutex)
		121+	#define·rfs_mutex_lock(mutex)·mutex_lock(mutex)
		122+	#define·rfs_mutex_unlock(mutex)·mutex_unlock(mutex)
		123+	#define·rfs_for_each_d_child(pos,·head)·list_for_each_entry(pos,·head,·D_U_D_CHILD)
		124+
		125+	inline·static·void·rfs_inode_mutex_lock(struct·inode·*inode)
		126+	{
		127+	» mutex_lock(&inode->i_mutex);
		128+	}
		129+	inline·static·void·rfs_inode_mutex_unlock(struct·inode·*inode)
		130+	{
		131+	» mutex_unlock(&inode->i_mutex);
		132+	}
90	#else	133	#else
91	#define·rfs_mutex_t·mutex	134	#define·rfs_mutex_t·mutex
92	#define·RFS_DEFINE_MUTEX(mutex)·DEFINE_MUTEX(mutex)	135	#define·RFS_DEFINE_MUTEX(mutex)·DEFINE_MUTEX(mutex)
93	#define·rfs_mutex_init(mutex)·mutex_init(mutex)	136	#define·rfs_mutex_init(mutex)·mutex_init(mutex)
94	#define·rfs_mutex_lock(mutex)·mutex_lock(mutex)	137	#define·rfs_mutex_lock(mutex)·mutex_lock(mutex)
95	#define·rfs_mutex_unlock(mutex)·mutex_unlock(mutex)	138	#define·rfs_mutex_unlock(mutex)·mutex_unlock(mutex)
96-	#define·rfs_for_each_d_child(pos,·head)·list_for_each_entry(pos,·head,·d_u.d_child)	139+	#define·rfs_for_each_d_child(pos,·head)·list_for_each_entry(pos,·head,·D_CHILD)
		140+
97	inline·static·void·rfs_inode_mutex_lock(struct·inode·*inode)	141	inline·static·void·rfs_inode_mutex_lock(struct·inode·*inode)
98	{	142	{
99	» mutex_lock(&inode->i_mutex);	143	» mutex_lock(&inode->i_mutex);
⋮		⋮
303	» int·rdentries_nr;·/·mutex·/	347	» int·rdentries_nr;·/·mutex·/
304	};	348	};
305		349
		350+	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(3,17,0))
		351+	#define·rfs_inode_find(inode)·\
		352+	» (inode·&&·inode->i_op·&&·inode->i_op->rename2·==·rfs_rename2·?·\
		353+	» ·rfs_inode_get(container_of(inode->i_op,·struct·rfs_inode,·op_new))·:·\
		354+	» ·NULL)
		355+	#elif·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(3,15,0))
		356+	#define·rfs_inode_find(inode)·\
		357+	» (inode·&&·inode->i_op·&&·\
		358+	» (inode->i_op->rename·==·rfs_rename·\|\|·inode->i_op->rename2·==·rfs_rename2)·?·\
		359+	» ·rfs_inode_get(container_of(inode->i_op,·struct·rfs_inode,·op_new))·:·\
		360+	» ·NULL)
		361+	#else
306	#define·rfs_inode_find(inode)·\	362	#define·rfs_inode_find(inode)·\
307	» (inode·&&·inode->i_op·&&·inode->i_op->rename·==·rfs_rename·?·\	363	» (inode·&&·inode->i_op·&&·inode->i_op->rename·==·rfs_rename·?·\
308	» ·rfs_inode_get(container_of(inode->i_op,·struct·rfs_inode,·op_new))·:·\	364	» ·rfs_inode_get(container_of(inode->i_op,·struct·rfs_inode,·op_new))·:·\
309	» ·NULL)	365	» ·NULL)
		366+	#endif
310		367
		368+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,17,0))
311	int·rfs_rename(struct·inode·old_dir,·struct·dentry·old_dentry,	369	int·rfs_rename(struct·inode·old_dir,·struct·dentry·old_dentry,
312	» » struct·inode·new_dir,·struct·dentry·new_dentry);	370	» » struct·inode·new_dir,·struct·dentry·new_dentry);
		371+	#endif
		372+
		373+	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(3,15,0))
		374+	int·rfs_rename2(struct·inode·old_dir,·struct·dentry·old_dentry,
		375+	» » struct·inode·new_dir,·struct·dentry·new_dentry,·unsigned·int·flags);
		376+	#endif
		377+
313	struct·rfs_inode·rfs_inode_get(struct·rfs_inode·rinode);	378	struct·rfs_inode·rfs_inode_get(struct·rfs_inode·rinode);
314	void·rfs_inode_put(struct·rfs_inode·*rinode);	379	void·rfs_inode_put(struct·rfs_inode·*rinode);
315	struct·rfs_inode·rfs_inode_add(struct·inode·inode,·struct·rfs_info·*rinfo);	380	struct·rfs_inode·rfs_inode_add(struct·inode·inode,·struct·rfs_info·*rinfo);
⋮		⋮
389	void·rfs_context_init(struct·rfs_context·*rcont,·int·start);	454	void·rfs_context_init(struct·rfs_context·*rcont,·int·start);
390	void·rfs_context_deinit(struct·rfs_context·*rcont);	455	void·rfs_context_deinit(struct·rfs_context·*rcont);
391		456
392-	int·rfs_precall_flts(struct·rfs_chain·rchain,·struct·rfs_context·rcont,	457+	int·rfs_precall_flts(struct·rfs_info·rinfo,·struct·rfs_context·rcont,
393	» » struct·redirfs_args·*rargs);	458	» » struct·redirfs_args·*rargs);
394-	void·rfs_postcall_flts(struct·rfs_chain·rchain,·struct·rfs_context·rcont,	459+	void·rfs_postcall_flts(struct·rfs_info·rinfo,·struct·rfs_context·rcont,
395	» » struct·redirfs_args·*rargs);	460	» » struct·redirfs_args·*rargs);
396		461
397	#define·rfs_kobj_to_rflt(__kobj)·container_of(__kobj,·struct·rfs_flt,·kobj)	462	#define·rfs_kobj_to_rflt(__kobj)·container_of(__kobj,·struct·rfs_flt,·kobj)
⋮		⋮
481	» return·nd->mnt;	546	» return·nd->mnt;
482	}	547	}
483		548
484-	#else	549+	#elif·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
485		550
486	static·inline·void·rfs_nameidata_put(struct·nameidata·*nd)	551	static·inline·void·rfs_nameidata_put(struct·nameidata·*nd)
487	{	552	{
⋮		⋮
498	» return·nd->path.mnt;	563	» return·nd->path.mnt;
499	}	564	}
500		565
		566+	#else
		567+
		568+	static·inline·void·rfs_nameidata_put(struct·rfs_nameidata·*nd)
		569+	{
		570+	» path_put(&nd->path);
		571+	}
		572+
		573+	static·inline·struct·dentry·rfs_nameidata_dentry(struct·rfs_nameidata·nd)
		574+	{
		575+	» return·nd->path.dentry;
		576+	}
		577+
		578+	static·inline·struct·vfsmount·rfs_nameidata_mnt(struct·rfs_nameidata·nd)
		579+	{
		580+	» return·nd->path.mnt;
		581+	}
		582+
501	#endif	583	#endif
502		584
503	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(2,6,30))	585	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(2,6,30))
⋮		⋮
532	}	614	}
533		615
534	#endif	616	#endif
		617+
		618+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,38))
		619+
		620+	static·inline·void·rfs_dcache_lock(struct·dentry·*d)
		621+	{
		622+	» spin_lock(&dcache_lock);
		623+	}
		624+
		625+	static·inline·void·rfs_dcache_unlock(struct·dentry·*d)
		626+	{
		627+	» spin_unlock(&dcache_lock);
		628+	}
		629+
		630+	static·inline·struct·dentry·rfs_dget_locked(struct·dentry·d)
		631+	{
		632+	» return·dget_locked(d);
		633+	}
		634+
		635+	#else
		636+
		637+	static·inline·void·rfs_dcache_lock(struct·dentry·*d)
		638+	{
		639+	» spin_lock(&d->d_lock);
		640+	}
		641+
		642+	static·inline·void·rfs_dcache_unlock(struct·dentry·*d)
		643+	{
		644+	» spin_unlock(&d->d_lock);
		645+	}
		646+
		647+	static·inline·struct·dentry·rfs_dget_locked(struct·dentry·d)
		648+	{
		649+	» return·dget_dlock(d);
		650+	}
		651+
		652+	#endif
		653+
		654+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,39))
		655+
		656+	static·inline·int·rfs_path_lookup(const·char·name,·struct·nameidata·nd)
		657+	{
		658+	» return·path_lookup(name,·LOOKUP_FOLLOW,·nd);
		659+	}
		660+
		661+	#elif·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
		662+
		663+	static·inline·int·rfs_path_lookup(const·char·name,·struct·nameidata·nd)
		664+	{
		665+	» struct·path·path;
		666+	» int·rv;
		667+
		668+	» rv·=·kern_path(name,·LOOKUP_FOLLOW,·&path);
		669+	» if·(rv)
		670+	» » return·rv;
		671+
		672+	» nd->path·=·path;
		673+	» return·0;
		674+	}
		675+
		676+	#else
		677+
		678+	static·inline·int·rfs_path_lookup(const·char·name,·struct·rfs_nameidata·nd)
		679+	{
		680+	» struct·path·path;
		681+	» int·rv;
		682+
		683+	» rv·=·kern_path(name,·LOOKUP_FOLLOW,·&path);
		684+	» if·(rv)
		685+	» » return·rv;
		686+
		687+	» nd->path·=·path;
		688+	» return·0;
		689+	}
		690+
		691+	#endif
		692+
		693+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,36))
		694+
		695+	static·inline·int·rfs_inode_setattr(struct·inode·inode,·const·struct·iattr·attr)
		696+	{
		697+	» return·inode_setattr(inode,·attr);
		698+	}
		699+
		700+	#else
		701+
		702+	static·inline·int·rfs_inode_setattr(struct·inode·inode,·const·struct·iattr·attr)
		703+	{
		704+	» setattr_copy(inode,·attr);
		705+	» mark_inode_dirty(inode);
		706+	» return·0;
		707+	}
		708+
		709+	#endif
535		710
536	#endif	711	#endif
537		712

driver.org/redirfs/rfs_chain.c		driver/redirfs/rfs_chain.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.

driver.org/redirfs/rfs_data.c		driver/redirfs/rfs_data.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
74	» if·(!atomic_dec_and_test(&data->cnt))	76	» if·(!atomic_dec_and_test(&data->cnt))
75	» » return;	77	» » return;
76		78
77-	» data->free(data);
78	» rfs_flt_put(data->filter);	79	» rfs_flt_put(data->filter);
		80+	» data->free(data);
79	}	81	}
80		82
81	static·struct·redirfs_data·rfs_find_data(struct·list_head·head,	83	static·struct·redirfs_data·rfs_find_data(struct·list_head·head,

driver.org/redirfs/rfs_dcache.c		driver/redirfs/rfs_dcache.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
47	» kfree(rdata);	49	» kfree(rdata);
48	}	50	}
49		51
50-	static·struct·rfs_dcache_entry·*rfs_dcache_entry_alloc_locked(
51-	» » struct·dentry·dentry,·struct·list_head·list)
52-	{
53-	» struct·rfs_dcache_entry·*entry;
54-
55-	» entry·=·kzalloc(sizeof(struct·rfs_dcache_entry),·GFP_ATOMIC);
56-	» if·(!entry)
57-	» » return·ERR_PTR(-ENOMEM);
58-
59-	» INIT_LIST_HEAD(&entry->list);
60-	» entry->dentry·=·dget_locked(dentry);
61-	» list_add_tail(&entry->list,·list);
62-
63-	» return·entry;
64-	}
65-
66	static·struct·rfs_dcache_entry·rfs_dcache_entry_alloc(struct·dentry·dentry,	52	static·struct·rfs_dcache_entry·rfs_dcache_entry_alloc(struct·dentry·dentry,
67	» » struct·list_head·*list)	53	» » struct·list_head·*list)
68	{	54	{
⋮		⋮
89	» kfree(entry);	75	» kfree(entry);
90	}	76	}
91		77
92-	static·int·rfs_dcache_get_subs_atomic(struct·dentry·*dir,	78+	static·int·rfs_dcache_get_subs_kernel(struct·dentry·*dir,
93	» » struct·list_head·*sibs)	79	» » struct·list_head·*sibs)
94	{	80	{
95	» struct·rfs_dcache_entry·*sib;	81	» struct·rfs_dcache_entry·*sib;
96	» struct·dentry·*dentry;	82	» struct·dentry·*dentry;
97	» int·rv·=·0;	83	» int·rv·=·0;
98		84
99-	» spin_lock(&dcache_lock);	85+	» rfs_dcache_lock(dir);
100		86
101	» rfs_for_each_d_child(dentry,·&dir->d_subdirs)·{	87	» rfs_for_each_d_child(dentry,·&dir->d_subdirs)·{
		88+	» » if·(!dentry->d_inode)
		89+	» » » continue;
102		90
103-	» » sib·=·rfs_dcache_entry_alloc_locked(dentry,·sibs);	91+	» » if·(!S_ISDIR(dentry->d_inode->i_mode))
104-	» » if·(IS_ERR(sib))·{	92+	» » » continue;
105-	» » » rv·=·PTR_ERR(sib);
106-	» » » break;
107-	» » }
108-	» }
109-
110-	» spin_unlock(&dcache_lock);
111-
112-	» return·rv;
113-	}
114-
115-	static·int·rfs_dcache_get_subs_kernel(struct·dentry·*dir,
116-	» » struct·list_head·*sibs)
117-	{
118-	» LIST_HEAD(pool);
119-	» int·pool_size·=·32;
120-	» int·pool_small;
121-	» struct·rfs_dcache_entry·*sib;
122-	» struct·dentry·*dentry;
123-	» int·i;
124		93
125-	again:	94+	» » if·(dir·==·dentry)
126-	» pool_small·=·0;	95+	» » » continue;
127		96
128-	» for·(i·=·0;·i·<·pool_size;·i++)·{	97+	» » sib·=·rfs_dcache_entry_alloc(dentry,·sibs);
129-	» » sib·=·rfs_dcache_entry_alloc(NULL,·&pool);
130	» » if·(IS_ERR(sib))·{	98	» » if·(IS_ERR(sib))·{
131-	» » » rfs_dcache_entry_free_list(&pool);	99+	» » » rv·=·PTR_ERR(sib);
132-	» » » return·PTR_ERR(sib);	100+	» » » goto·exit;
133-	» » }
134-	» }
135-
136-	» spin_lock(&dcache_lock);
137-
138-	» rfs_for_each_d_child(dentry,·&dir->d_subdirs)·{
139-	» » if·(list_empty(&pool))·{
140-	» » » pool_small·=·1;
141-	» » » break;
142	» » }	101	» » }
143-	» »
144-	» » sib·=·list_entry(pool.next,·struct·rfs_dcache_entry,·list);
145-	» » sib->dentry·=·dget_locked(dentry);
146-	» » list_move(&sib->list,·sibs);
147	» }	102	» }
148		103
149-	» spin_unlock(&dcache_lock);	104+	exit:
150-		105+	» rfs_dcache_unlock(dir);
151-	» rfs_dcache_entry_free_list(&pool);
152-
153-	» if·(pool_small)·{
154-	» » rfs_dcache_entry_free_list(sibs);
155-	» » pool_size·*=·2;
156-	» » goto·again;
157-	» }
158		106
159-	» return·0;	107+	» return·rv;
160	}	108	}
161		109
162	int·rfs_dcache_get_subs(struct·dentry·dir,·struct·list_head·sibs)	110	int·rfs_dcache_get_subs(struct·dentry·dir,·struct·list_head·sibs)
163	{	111	{
164-	» int·rv;	112+	» return·rfs_dcache_get_subs_kernel(dir,·sibs);
165-
166-	» rv·=·rfs_dcache_get_subs_atomic(dir,·sibs);
167-	» if·(!rv)
168-	» » return·rv;
169-
170-	» rfs_dcache_entry_free_list(sibs);
171-	»
172-	» rv·=·rfs_dcache_get_subs_kernel(dir,·sibs);
173-
174-	» return·rv;
175	}	113	}
176		114
177	void·rfs_dcache_entry_free_list(struct·list_head·*head)	115	void·rfs_dcache_entry_free_list(struct·list_head·*head)
⋮		⋮
184	» }	122	» }
185	}	123	}
186		124
187-	static·int·rfs_dcache_get_subs_mutex(struct·dentry·dir,·struct·list_head·sibs)	125+	int·rfs_dcache_get_subs_mutex(struct·dentry·dir,·struct·list_head·sibs)
188	{	126	{
		127+	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(3,13,0))
		128+	» int·lock;
		129+	#endif
		130+
189	» int·rv·=·0;	131	» int·rv·=·0;
190		132
191	» if·(!dir·\|\|·!dir->d_inode)	133	» if·(!dir·\|\|·!dir->d_inode)
192	» » return·0;	134	» » return·0;
193		135
		136+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,13,0))
194	» rfs_inode_mutex_lock(dir->d_inode);	137	» rfs_inode_mutex_lock(dir->d_inode);
195	» rv·=·rfs_dcache_get_subs(dir,·sibs);	138	» rv·=·rfs_dcache_get_subs(dir,·sibs);
196	» rfs_inode_mutex_unlock(dir->d_inode);	139	» rfs_inode_mutex_unlock(dir->d_inode);
		140+	#else
		141+	» lock·=·mutex_trylock(&dir->d_inode->i_mutex);
		142+	» rv·=·rfs_dcache_get_subs(dir,·sibs);
		143+	» if·(lock)
		144+	» » mutex_unlock(&dir->d_inode->i_mutex);
		145+	#endif
197		146
198	» return·rv;	147	» return·rv;
199	}	148	}
⋮		⋮
302	» struct·rfs_dentry·*rdentry·=·NULL;	251	» struct·rfs_dentry·*rdentry·=·NULL;
303	» int·rv·=·0;	252	» int·rv·=·0;
304		253
		254+	» if·(!dentry)
		255+	» » return·-1;
		256+
305	» rdentry·=·rfs_dentry_add(dentry,·rinfo);	257	» rdentry·=·rfs_dentry_add(dentry,·rinfo);
306	» if·(IS_ERR(rdentry))	258	» if·(IS_ERR(rdentry))
307	» » return·PTR_ERR(rdentry);	259	» » return·PTR_ERR(rdentry);

driver.org/redirfs/rfs_dentry.c		driver/redirfs/rfs_dentry.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
175	struct·rfs_info·rfs_dentry_get_rinfo(struct·rfs_dentry·rdentry)	177	struct·rfs_info·rfs_dentry_get_rinfo(struct·rfs_dentry·rdentry)
176	{	178	{
177	» struct·rfs_info·*rinfo;	179	» struct·rfs_info·*rinfo;
		180+	»
		181+	» if·(!rdentry)
		182+	» » return·NULL;
178		183
179	» spin_lock(&rdentry->lock);	184	» spin_lock(&rdentry->lock);
180	» rinfo·=·rfs_info_get(rdentry->rinfo);	185	» rinfo·=·rfs_info_get(rdentry->rinfo);
⋮		⋮
232		237
233	» rdentry·=·rfs_dentry_find(dentry);	238	» rdentry·=·rfs_dentry_find(dentry);
234	» rinfo·=·rfs_dentry_get_rinfo(rdentry);	239	» rinfo·=·rfs_dentry_get_rinfo(rdentry);
		240+
235	» rfs_context_init(&rcont,·0);	241	» rfs_context_init(&rcont,·0);
236		242
237	» if·(S_ISREG(inode->i_mode))	243	» if·(S_ISREG(inode->i_mode))
⋮		⋮
252	» rargs.args.d_iput.dentry·=·dentry;	258	» rargs.args.d_iput.dentry·=·dentry;
253	» rargs.args.d_iput.inode·=·inode;	259	» rargs.args.d_iput.inode·=·inode;
254		260
255-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	261+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
256	» » BUG_ON(rfs_dcache_rinode_del(rdentry,·inode));	262	» » BUG_ON(rfs_dcache_rinode_del(rdentry,·inode));
257		263
258	» » if·(rdentry->op_old·&&·rdentry->op_old->d_iput)	264	» » if·(rdentry->op_old·&&·rdentry->op_old->d_iput)
⋮		⋮
262	» » » iput(inode);	268	» » » iput(inode);
263	» }	269	» }
264		270
265-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	271+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
266	» rfs_context_deinit(&rcont);	272	» rfs_context_deinit(&rcont);
267		273
268	» rfs_dentry_put(rdentry);	274	» rfs_dentry_put(rdentry);
⋮		⋮
278		284
279	» rdentry·=·rfs_dentry_find(dentry);	285	» rdentry·=·rfs_dentry_find(dentry);
280	» rinfo·=·rfs_dentry_get_rinfo(rdentry);	286	» rinfo·=·rfs_dentry_get_rinfo(rdentry);
		287+
281	» rfs_context_init(&rcont,·0);	288	» rfs_context_init(&rcont,·0);
282	» rargs.type.id·=·REDIRFS_NONE_DOP_D_RELEASE;	289	» rargs.type.id·=·REDIRFS_NONE_DOP_D_RELEASE;
283	» rargs.args.d_release.dentry·=·dentry;	290	» rargs.args.d_release.dentry·=·dentry;
284		291
285-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	292+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
286	» » if·(rdentry->op_old·&&·rdentry->op_old->d_release)	293	» » if·(rdentry->op_old·&&·rdentry->op_old->d_release)
287	» » » rdentry->op_old->d_release(rargs.args.d_release.dentry);	294	» » » rdentry->op_old->d_release(rargs.args.d_release.dentry);
288	» }	295	» }
289		296
290-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	297+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
291	» rfs_context_deinit(&rcont);	298	» rfs_context_deinit(&rcont);
292		299
293	» rfs_dentry_del(rdentry);	300	» rfs_dentry_del(rdentry);
⋮		⋮
295	» rfs_info_put(rinfo);	302	» rfs_info_put(rinfo);
296	}	303	}
297		304
298-	static·inline·int·rfs_d_compare_default(struct·qstr·name1,·struct·qstr·name2)	305+	static·inline·int·rfs_d_compare_default(const·struct·qstr·*name1,
		306+	» » const·struct·qstr·*name2)
299	{	307	{
300	» if·(name1->len·!=·name2->len)	308	» if·(name1->len·!=·name2->len)
301	» » return·1;	309	» » return·1;
⋮		⋮
305	» return·0;	313	» return·0;
306	}	314	}
307		315
		316+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,38))
		317+
308	static·int·rfs_d_compare(struct·dentry·dentry,·struct·qstr·name1,	318	static·int·rfs_d_compare(struct·dentry·dentry,·struct·qstr·name1,
309	» » struct·qstr·*name2)	319	» » struct·qstr·*name2)
310	{	320	{
⋮		⋮
315		325
316	» rdentry·=·rfs_dentry_find(dentry);	326	» rdentry·=·rfs_dentry_find(dentry);
317	» rinfo·=·rfs_dentry_get_rinfo(rdentry);	327	» rinfo·=·rfs_dentry_get_rinfo(rdentry);
		328+
318	» rfs_context_init(&rcont,·0);	329	» rfs_context_init(&rcont,·0);
319		330
320	» if·(dentry->d_inode)·{	331	» if·(dentry->d_inode)·{
⋮		⋮
339	» rargs.args.d_compare.name1·=·name1;	350	» rargs.args.d_compare.name1·=·name1;
340	» rargs.args.d_compare.name2·=·name2;	351	» rargs.args.d_compare.name2·=·name2;
341		352
342-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	353+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
343	» » if·(rdentry->op_old·&&·rdentry->op_old->d_compare)	354	» » if·(rdentry->op_old·&&·rdentry->op_old->d_compare)
344	» » » rargs.rv.rv_int·=·rdentry->op_old->d_compare(	355	» » » rargs.rv.rv_int·=·rdentry->op_old->d_compare(
345	» » » » » rargs.args.d_compare.dentry,	356	» » » » » rargs.args.d_compare.dentry,
⋮		⋮
349	» » » rargs.rv.rv_int·=·rfs_d_compare_default(	360	» » » rargs.rv.rv_int·=·rfs_d_compare_default(
350	» » » » » rargs.args.d_compare.name1,	361	» » » » » rargs.args.d_compare.name1,
351	» » » » » rargs.args.d_compare.name2);	362	» » » » » rargs.args.d_compare.name2);
352-	» }	363+	» }·else
		364+	» » rargs.rv.rv_int·=·1;
353		365
354-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	366+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
355	» rfs_context_deinit(&rcont);	367	» rfs_context_deinit(&rcont);
356		368
357	» rfs_dentry_put(rdentry);	369	» rfs_dentry_put(rdentry);
⋮		⋮
360	» return·rargs.rv.rv_int;	372	» return·rargs.rv.rv_int;
361	}	373	}
362		374
		375+	#elif·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,11,0))
		376+
		377+	static·int·rfs_d_compare(const·struct·dentry·parent,·const·struct·inode·inode,
		378+	» » const·struct·dentry·dentry,·const·struct·inode·d_inode,
		379+	» » unsigned·int·tlen,·const·char·*tname,
		380+	» » const·struct·qstr·*name)
		381+	{
		382+	» struct·rfs_dentry·*rdentry;
		383+	» struct·rfs_info·*rinfo;
		384+	» struct·rfs_context·rcont;
		385+	» struct·redirfs_args·rargs;
		386+
		387+	» rdentry·=·rfs_dentry_find(dentry);
		388+	» rinfo·=·rfs_dentry_get_rinfo(rdentry);
		389+
		390+	» rfs_context_init(&rcont,·0);
		391+
		392+	» if·(dentry->d_inode)·{
		393+	» » if·(S_ISREG(dentry->d_inode->i_mode))
		394+	» » » rargs.type.id·=·REDIRFS_REG_DOP_D_COMPARE;
		395+	» » else·if·(S_ISDIR(dentry->d_inode->i_mode))
		396+	» » » rargs.type.id·=·REDIRFS_DIR_DOP_D_COMPARE;
		397+	» » else·if·(S_ISLNK(dentry->d_inode->i_mode))
		398+	» » » rargs.type.id·=·REDIRFS_LNK_DOP_D_COMPARE;
		399+	» » else·if·(S_ISCHR(dentry->d_inode->i_mode))
		400+	» » » rargs.type.id·=·REDIRFS_CHR_DOP_D_COMPARE;
		401+	» » else·if·(S_ISBLK(dentry->d_inode->i_mode))
		402+	» » » rargs.type.id·=·REDIRFS_BLK_DOP_D_COMPARE;
		403+	» » else·if·(S_ISFIFO(dentry->d_inode->i_mode))
		404+	» » » rargs.type.id·=·REDIRFS_FIFO_DOP_D_COMPARE;
		405+	» » else
		406+	» » » rargs.type.id·=·REDIRFS_SOCK_DOP_D_COMPARE;
		407+	» }·else
		408+	» » rargs.type.id·=·REDIRFS_NONE_DOP_D_COMPARE;
		409+
		410+	» rargs.args.d_compare.parent·=·parent;
		411+	» rargs.args.d_compare.inode·=·inode;
		412+	» rargs.args.d_compare.dentry·=·dentry;
		413+	» rargs.args.d_compare.d_inode·=·d_inode;
		414+	» rargs.args.d_compare.tlen·=·tlen;
		415+	» rargs.args.d_compare.tname·=·tname;
		416+	» rargs.args.d_compare.name·=·name;
		417+
		418+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
		419+	» » if·(rdentry->op_old·&&·rdentry->op_old->d_compare)
		420+	» » » rargs.rv.rv_int·=·rdentry->op_old->d_compare(
		421+	» » » » » rargs.args.d_compare.parent,
		422+	» » » » » rargs.args.d_compare.inode,
		423+	» » » » » rargs.args.d_compare.dentry,
		424+	» » » » » rargs.args.d_compare.d_inode,
		425+	» » » » » rargs.args.d_compare.tlen,
		426+	» » » » » rargs.args.d_compare.tname,
		427+	» » » » » rargs.args.d_compare.name);
		428+	» » else
		429+	» » » rargs.rv.rv_int·=·rfs_d_compare_default(
		430+	» » » » » &rargs.args.d_compare.dentry->d_name,
		431+	» » » » » rargs.args.d_compare.name);
		432+	» }·else
		433+	» » rargs.rv.rv_int·=·1;
		434+
		435+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
		436+	» rfs_context_deinit(&rcont);
		437+
		438+	» rfs_dentry_put(rdentry);
		439+	» rfs_info_put(rinfo);
		440+
		441+	» return·rargs.rv.rv_int;
		442+	}
		443+
		444+	#else
		445+
		446+	static·int·rfs_d_compare(const·struct·dentry·parent,·const·struct·dentry·dentry,
		447+	» » unsigned·int·tlen,·const·char·tname,·const·struct·qstr·name)
		448+	{
		449+	» struct·rfs_dentry·*rdentry;
		450+	» struct·rfs_info·*rinfo;
		451+	» struct·rfs_context·rcont;
		452+	» struct·redirfs_args·rargs;
		453+
		454+	» rdentry·=·rfs_dentry_find(dentry);
		455+	» rinfo·=·rfs_dentry_get_rinfo(rdentry);
		456+
		457+	» rfs_context_init(&rcont,·0);
		458+
		459+	» if·(dentry->d_inode)·{
		460+	» » if·(S_ISREG(dentry->d_inode->i_mode))
		461+	» » » rargs.type.id·=·REDIRFS_REG_DOP_D_COMPARE;
		462+	» » else·if·(S_ISDIR(dentry->d_inode->i_mode))
		463+	» » » rargs.type.id·=·REDIRFS_DIR_DOP_D_COMPARE;
		464+	» » else·if·(S_ISLNK(dentry->d_inode->i_mode))
		465+	» » » rargs.type.id·=·REDIRFS_LNK_DOP_D_COMPARE;
		466+	» » else·if·(S_ISCHR(dentry->d_inode->i_mode))
		467+	» » » rargs.type.id·=·REDIRFS_CHR_DOP_D_COMPARE;
		468+	» » else·if·(S_ISBLK(dentry->d_inode->i_mode))
		469+	» » » rargs.type.id·=·REDIRFS_BLK_DOP_D_COMPARE;
		470+	» » else·if·(S_ISFIFO(dentry->d_inode->i_mode))
		471+	» » » rargs.type.id·=·REDIRFS_FIFO_DOP_D_COMPARE;
		472+	» » else
		473+	» » » rargs.type.id·=·REDIRFS_SOCK_DOP_D_COMPARE;
		474+	» }·else
		475+	» » rargs.type.id·=·REDIRFS_NONE_DOP_D_COMPARE;
		476+
		477+	» rargs.args.d_compare.parent·=·parent;
		478+	» rargs.args.d_compare.dentry·=·dentry;
		479+	» rargs.args.d_compare.tlen·=·tlen;
		480+	» rargs.args.d_compare.tname·=·tname;
		481+	» rargs.args.d_compare.name·=·name;
		482+
		483+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
		484+	» » if·(rdentry->op_old·&&·rdentry->op_old->d_compare)
		485+	» » » rargs.rv.rv_int·=·rdentry->op_old->d_compare(
		486+	» » » » » rargs.args.d_compare.parent,
		487+	» » » » » rargs.args.d_compare.dentry,
		488+	» » » » » rargs.args.d_compare.tlen,
		489+	» » » » » rargs.args.d_compare.tname,
		490+	» » » » » rargs.args.d_compare.name);
		491+	» » else
		492+	» » » rargs.rv.rv_int·=·rfs_d_compare_default(
		493+	» » » » » &rargs.args.d_compare.dentry->d_name,
		494+	» » » » » rargs.args.d_compare.name);
		495+	» }·else
		496+	» » rargs.rv.rv_int·=·1;
		497+
		498+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
		499+	» rfs_context_deinit(&rcont);
		500+
		501+	» rfs_dentry_put(rdentry);
		502+	» rfs_info_put(rinfo);
		503+
		504+	» return·rargs.rv.rv_int;
		505+	}
		506+	#endif
		507+
		508+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
363	static·int·rfs_d_revalidate(struct·dentry·dentry,·struct·nameidata·nd)	509	static·int·rfs_d_revalidate(struct·dentry·dentry,·struct·nameidata·nd)
		510+	#else
		511+	static·int·rfs_d_revalidate(struct·dentry·*dentry,·unsigned·int·flags)
		512+	#endif
364	{	513	{
365	» struct·rfs_dentry·*rdentry;	514	» struct·rfs_dentry·*rdentry;
366	» struct·rfs_info·*rinfo;	515	» struct·rfs_info·*rinfo;
⋮		⋮
369		518
370	» rdentry·=·rfs_dentry_find(dentry);	519	» rdentry·=·rfs_dentry_find(dentry);
371	» rinfo·=·rfs_dentry_get_rinfo(rdentry);	520	» rinfo·=·rfs_dentry_get_rinfo(rdentry);
		521+
372	» rfs_context_init(&rcont,·0);	522	» rfs_context_init(&rcont,·0);
373		523
374	» if·(dentry->d_inode)·{	524	» if·(dentry->d_inode)·{
⋮		⋮
390	» » rargs.type.id·=·REDIRFS_NONE_DOP_D_REVALIDATE;	540	» » rargs.type.id·=·REDIRFS_NONE_DOP_D_REVALIDATE;
391		541
392	» rargs.args.d_revalidate.dentry·=·dentry;	542	» rargs.args.d_revalidate.dentry·=·dentry;
		543+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
393	» rargs.args.d_revalidate.nd·=·nd;	544	» rargs.args.d_revalidate.nd·=·nd;
		545+	#else
		546+	» rargs.args.d_revalidate.flags·=·flags;
		547+	#endif
394		548
395-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	549+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
396	» » if·(rdentry->op_old·&&·rdentry->op_old->d_revalidate)	550	» » if·(rdentry->op_old·&&·rdentry->op_old->d_revalidate)
397	» » » rargs.rv.rv_int·=·rdentry->op_old->d_revalidate(	551	» » » rargs.rv.rv_int·=·rdentry->op_old->d_revalidate(
398	» » » » » rargs.args.d_revalidate.dentry,	552	» » » » » rargs.args.d_revalidate.dentry,
		553+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
399	» » » » » rargs.args.d_revalidate.nd);	554	» » » » » rargs.args.d_revalidate.nd);
		555+	#else
		556+	» » » » » rargs.args.d_revalidate.flags);
		557+	#endif
400	» » else	558	» » else
401	» » » rargs.rv.rv_int·=·1;	559	» » » rargs.rv.rv_int·=·1;
402-	» }	560+	» }·else
		561+	» » rargs.rv.rv_int·=·1;
403		562
404-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	563+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
405	» rfs_context_deinit(&rcont);	564	» rfs_context_deinit(&rcont);
406		565
407	» rfs_dentry_put(rdentry);	566	» rfs_dentry_put(rdentry);

driver.org/redirfs/rfs_file.c		driver/redirfs/rfs_file.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
88	» if·(IS_ERR(rfile))	90	» if·(IS_ERR(rfile))
89	» » return·rfile;	91	» » return·rfile;
90		92
		93+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
91	» rfile->rdentry·=·rfs_dentry_find(file->f_dentry);	94	» rfile->rdentry·=·rfs_dentry_find(file->f_dentry);
		95+	#else
		96+	» rfile->rdentry·=·rfs_dentry_find(file->f_path.dentry);
		97+	#endif
		98+
92	» rfs_dentry_add_rfile(rfile->rdentry,·rfile);	99	» rfs_dentry_add_rfile(rfile->rdentry,·rfile);
93	» fops_put(file->f_op);	100	» fops_put(file->f_op);
94	» file->f_op·=·&rfile->op_new;	101	» file->f_op·=·&rfile->op_new;
⋮		⋮
136	» fops_put(file->f_op);	143	» fops_put(file->f_op);
137	» file->f_op·=·fops_get(rinode->fop_old);	144	» file->f_op·=·fops_get(rinode->fop_old);
138		145
		146+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
139	» rdentry·=·rfs_dentry_find(file->f_dentry);	147	» rdentry·=·rfs_dentry_find(file->f_dentry);
		148+	#else
		149+	» rdentry·=·rfs_dentry_find(file->f_path.dentry);
		150+	#endif
		151+
140	» if·(!rdentry)·{	152	» if·(!rdentry)·{
141	» » rfs_inode_put(rinode);	153	» » rfs_inode_put(rinode);
142	» » if·(file->f_op·&&·file->f_op->open)	154	» » if·(file->f_op·&&·file->f_op->open)
⋮		⋮
146	» }	158	» }
147		159
148	» rinfo·=·rfs_dentry_get_rinfo(rdentry);	160	» rinfo·=·rfs_dentry_get_rinfo(rdentry);
		161+
149	» rfs_dentry_put(rdentry);	162	» rfs_dentry_put(rdentry);
150	» rfs_context_init(&rcont,·0);	163	» rfs_context_init(&rcont,·0);
151		164
⋮		⋮
165	» rargs.args.f_open.inode·=·inode;	178	» rargs.args.f_open.inode·=·inode;
166	» rargs.args.f_open.file·=·file;	179	» rargs.args.f_open.file·=·file;
167		180
168-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	181+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
169	» » if·(rinode->fop_old·&&·rinode->fop_old->open)	182	» » if·(rinode->fop_old·&&·rinode->fop_old->open)
170	» » » rargs.rv.rv_int·=·rinode->fop_old->open(	183	» » » rargs.rv.rv_int·=·rinode->fop_old->open(
171	» » » » » rargs.args.f_open.inode,	184	» » » » » rargs.args.f_open.inode,
172	» » » » » rargs.args.f_open.file);	185	» » » » » rargs.args.f_open.file);
173	» » else	186	» » else
174	» » » rargs.rv.rv_int·=·0;	187	» » » rargs.rv.rv_int·=·0;
175-	» }	188+	» }·else
		189+	» » rargs.rv.rv_int·=·-EACCES;
176		190
177	» if·(!rargs.rv.rv_int)·{	191	» if·(!rargs.rv.rv_int)·{
178	» » rfile·=·rfs_file_add(file);	192	» » rfile·=·rfs_file_add(file);
⋮		⋮
181	» » rfs_file_put(rfile);	195	» » rfs_file_put(rfile);
182	» }	196	» }
183		197
184-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	198+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
185	» rfs_context_deinit(&rcont);	199	» rfs_context_deinit(&rcont);
186		200
187	» rfs_inode_put(rinode);	201	» rfs_inode_put(rinode);
⋮		⋮
198		212
199	» rfile·=·rfs_file_find(file);	213	» rfile·=·rfs_file_find(file);
200	» rinfo·=·rfs_dentry_get_rinfo(rfile->rdentry);	214	» rinfo·=·rfs_dentry_get_rinfo(rfile->rdentry);
		215+
201	» rfs_context_init(&rcont,·0);	216	» rfs_context_init(&rcont,·0);
202		217
203	» if·(S_ISREG(inode->i_mode))	218	» if·(S_ISREG(inode->i_mode))
⋮		⋮
216	» rargs.args.f_release.inode·=·inode;	231	» rargs.args.f_release.inode·=·inode;
217	» rargs.args.f_release.file·=·file;	232	» rargs.args.f_release.file·=·file;
218		233
219-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	234+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
220	» » if·(rfile->op_old·&&·rfile->op_old->release)	235	» » if·(rfile->op_old·&&·rfile->op_old->release)
221	» » » rargs.rv.rv_int·=·rfile->op_old->release(	236	» » » rargs.rv.rv_int·=·rfile->op_old->release(
222	» » » » » rargs.args.f_release.inode,	237	» » » » » rargs.args.f_release.inode,
223	» » » » » rargs.args.f_release.file);	238	» » » » » rargs.args.f_release.file);
224	» » else	239	» » else
225	» » » rargs.rv.rv_int·=·0;	240	» » » rargs.rv.rv_int·=·0;
226-	» }	241+	» }·else
		242+	» » rargs.rv.rv_int·=·0;
227		243
228-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	244+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
229	» rfs_context_deinit(&rcont);	245	» rfs_context_deinit(&rcont);
230		246
231	» rfs_file_del(rfile);	247	» rfs_file_del(rfile);
⋮		⋮
234	» return·rargs.rv.rv_int;	250	» return·rargs.rv.rv_int;
235	}	251	}
236		252
		253+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,11,0))
237	static·int·rfs_readdir(struct·file·file,·void·dirent,·filldir_t·filldir)	254	static·int·rfs_readdir(struct·file·file,·void·dirent,·filldir_t·filldir)
		255+	#else
		256+	static·int·rfs_iterate(struct·file·file,·struct·dir_context·dir_context)
		257+	#endif
238	{	258	{
239	» LIST_HEAD(sibs);	259	» LIST_HEAD(sibs);
240	» struct·rfs_dcache_entry·*sib;	260	» struct·rfs_dcache_entry·*sib;
⋮		⋮
246		266
247	» rfile·=·rfs_file_find(file);	267	» rfile·=·rfs_file_find(file);
248	» rinfo·=·rfs_dentry_get_rinfo(rfile->rdentry);	268	» rinfo·=·rfs_dentry_get_rinfo(rfile->rdentry);
		269+
249	» rfs_context_init(&rcont,·0);	270	» rfs_context_init(&rcont,·0);
250		271
		272+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,11,0))
251	» if·(S_ISDIR(file->f_dentry->d_inode->i_mode))	273	» if·(S_ISDIR(file->f_dentry->d_inode->i_mode))
252	» » rargs.type.id·=·REDIRFS_DIR_FOP_READDIR;	274	» » rargs.type.id·=·REDIRFS_DIR_FOP_READDIR;
253-
254	» rargs.args.f_readdir.file·=·file;	275	» rargs.args.f_readdir.file·=·file;
255	» rargs.args.f_readdir.dirent·=·dirent;	276	» rargs.args.f_readdir.dirent·=·dirent;
256	» rargs.args.f_readdir.filldir·=·filldir;	277	» rargs.args.f_readdir.filldir·=·filldir;
		278+	#elif·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
		279+	» if·(S_ISDIR(file->f_dentry->d_inode->i_mode))
		280+	» » rargs.type.id·=·REDIRFS_DIR_FOP_ITERATE;
		281+	» rargs.args.f_iterate.file·=·file;
		282+	» rargs.args.f_iterate.dir_context·=·dir_context;
		283+	#else
		284+	» if·(S_ISDIR(file->f_path.dentry->d_inode->i_mode))
		285+	» » rargs.type.id·=·REDIRFS_DIR_FOP_ITERATE;
		286+	» rargs.args.f_iterate.file·=·file;
		287+	» rargs.args.f_iterate.dir_context·=·dir_context;
		288+	#endif
257		289
258-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	290+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
		291+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,11,0))
259	» » if·(rfile->op_old·&&·rfile->op_old->readdir)·	292	» » if·(rfile->op_old·&&·rfile->op_old->readdir)·
260	» » » rargs.rv.rv_int·=·rfile->op_old->readdir(	293	» » » rargs.rv.rv_int·=·rfile->op_old->readdir(
261	» » » » » rargs.args.f_readdir.file,	294	» » » » » rargs.args.f_readdir.file,
262	» » » » » rargs.args.f_readdir.dirent,	295	» » » » » rargs.args.f_readdir.dirent,
263	» » » » » rargs.args.f_readdir.filldir);	296	» » » » » rargs.args.f_readdir.filldir);
		297+	#else
		298+	» » if·(rfile->op_old·&&·rfile->op_old->iterate)·
		299+	» » » rargs.rv.rv_int·=·rfile->op_old->iterate(
		300+	» » » » » rargs.args.f_iterate.file,
		301+	» » » » » rargs.args.f_iterate.dir_context);
		302+	#endif
264	» » else	303	» » else
265	» » » rargs.rv.rv_int·=·-ENOTDIR;	304	» » » rargs.rv.rv_int·=·-ENOTDIR;
266-	» }	305+	» }·else
		306+	» » rargs.rv.rv_int·=·-ENOTDIR;
267		307
268-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	308+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
269	» rfs_context_deinit(&rcont);	309	» rfs_context_deinit(&rcont);
270		310
271	» if·(rargs.rv.rv_int)	311	» if·(rargs.rv.rv_int)
272	» » goto·exit;	312	» » goto·exit;
273		313
		314+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
274	» if·(rfs_dcache_get_subs(file->f_dentry,·&sibs))·{	315	» if·(rfs_dcache_get_subs(file->f_dentry,·&sibs))·{
275	» » BUG();	316	» » BUG();
276	» » goto·exit;	317	» » goto·exit;
277	» }	318	» }
		319+	#else
		320+	» if·(rfs_dcache_get_subs(file->f_path.dentry,·&sibs))·{
		321+	» » BUG();
		322+	» » goto·exit;
		323+	» }
		324+	#endif
278		325
279	» list_for_each_entry(sib,·&sibs,·list)·{	326	» list_for_each_entry(sib,·&sibs,·list)·{
280	» » rdentry·=·rfs_dentry_find(sib->dentry);	327	» » rdentry·=·rfs_dentry_find(sib->dentry);
⋮		⋮
310		357
311	static·void·rfs_file_set_ops_dir(struct·rfs_file·*rfile)	358	static·void·rfs_file_set_ops_dir(struct·rfs_file·*rfile)
312	{	359	{
		360+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,11,0))
313	» rfile->op_new.readdir·=·rfs_readdir;	361	» rfile->op_new.readdir·=·rfs_readdir;
		362+	#else
		363+	» rfile->op_new.iterate·=·rfs_iterate;
		364+	#endif
314	}	365	}
315		366
316	static·void·rfs_file_set_ops_lnk(struct·rfs_file·*rfile)	367	static·void·rfs_file_set_ops_lnk(struct·rfs_file·*rfile)

driver.org/redirfs/rfs_flt.c		driver/redirfs/rfs_flt.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
134	» rv·=·rfs_flt_sysfs_init(rflt);	136	» rv·=·rfs_flt_sysfs_init(rflt);
135	» if·(rv)·{	137	» if·(rv)·{
136	» » rfs_flt_put(rflt);	138	» » rfs_flt_put(rflt);
		139+	» » rfs_mutex_unlock(&rfs_flt_list_mutex);
137	» » return·ERR_PTR(rv);	140	» » return·ERR_PTR(rv);
138	» }	141	» }
139		142

driver.org/redirfs/rfs_info.c		driver/redirfs/rfs_info.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
124	{	126	{
125	» struct·rfs_dentry·*rdentry;	127	» struct·rfs_dentry·*rdentry;
126		128
		129+	» if·(!rinfo->rroot->dentry)
		130+	» » return·0;
		131+
127	» rdentry·=·rfs_dentry_add(rinfo->rroot->dentry,·rinfo);	132	» rdentry·=·rfs_dentry_add(rinfo->rroot->dentry,·rinfo);
128	» if·(IS_ERR(rdentry))	133	» if·(IS_ERR(rdentry))
129	» » return·PTR_ERR(rdentry);	134	» » return·PTR_ERR(rdentry);
⋮		⋮
203	» rv·=·rfs_dcache_walk(dentry,·rfs_dcache_set,·rdata);	208	» rv·=·rfs_dcache_walk(dentry,·rfs_dcache_set,·rdata);
204		209
205	» if·(rflt->ops·&&·rflt->ops->move_end)	210	» if·(rflt->ops·&&·rflt->ops->move_end)
206-	» » rflt->ops->move_begin();	211+	» » rflt->ops->move_end();
207		212
208	» rfs_dcache_data_free(rdata);	213	» rfs_dcache_data_free(rdata);
209		214

driver.org/redirfs/rfs_inode.c		driver/redirfs/rfs_inode.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
30	» struct·rfs_inode·*rinode;	32	» struct·rfs_inode·*rinode;
31		33
32	» rinode·=·kmem_cache_zalloc(rfs_inode_cache,·GFP_KERNEL);	34	» rinode·=·kmem_cache_zalloc(rfs_inode_cache,·GFP_KERNEL);
33-	» if·(IS_ERR(rinode))	35+	» if·(!rinode)
34	» » return·ERR_PTR(-ENOMEM);	36	» » return·ERR_PTR(-ENOMEM);
35		37
36	» INIT_LIST_HEAD(&rinode->rdentries);	38	» INIT_LIST_HEAD(&rinode->rdentries);
⋮		⋮
48	» » memcpy(&rinode->op_new,·inode->i_op,	50	» » memcpy(&rinode->op_new,·inode->i_op,
49	» » » » sizeof(struct·inode_operations));	51	» » » » sizeof(struct·inode_operations));
50		52
		53+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,17,0))
51	» rinode->op_new.rename·=·rfs_rename;	54	» rinode->op_new.rename·=·rfs_rename;
		55+	#else
		56+	» rinode->op_new.rename·=·NULL;
		57+	#endif
52		58
		59+	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(3,15,0))
		60+	» rinode->op_new.rename2·=·rfs_rename2;
		61+	#endif
53	» return·rinode;	62	» return·rinode;
54	}	63	}
55		64
⋮		⋮
196	struct·rfs_info·rfs_inode_get_rinfo(struct·rfs_inode·rinode)	205	struct·rfs_info·rfs_inode_get_rinfo(struct·rfs_inode·rinode)
197	{	206	{
198	» struct·rfs_info·*rinfo;	207	» struct·rfs_info·*rinfo;
		208+	»
		209+	» if·(!rinode)
		210+	» » return·NULL;
199		211
200	» spin_lock(&rinode->lock);	212	» spin_lock(&rinode->lock);
201	» rinfo·=·rfs_info_get(rinode->rinfo);	213	» rinfo·=·rfs_info_get(rinode->rinfo);
⋮		⋮
280	» kmem_cache_destroy(rfs_inode_cache);	292	» kmem_cache_destroy(rfs_inode_cache);
281	}	293	}
282		294
		295+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
283	static·struct·dentry·rfs_lookup(struct·inode·dir,·struct·dentry·*dentry,	296	static·struct·dentry·rfs_lookup(struct·inode·dir,·struct·dentry·*dentry,
284	» » struct·nameidata·*nd)	297	» » struct·nameidata·*nd)
		298+	#else
		299+	static·struct·dentry·rfs_lookup(struct·inode·dir,·struct·dentry·*dentry,
		300+	» » unsigned·int·flags)
		301+	#endif
285	{	302	{
286	» struct·rfs_inode·*rinode;	303	» struct·rfs_inode·*rinode;
287	» struct·rfs_info·*rinfo;	304	» struct·rfs_info·*rinfo;
⋮		⋮
296		313
297	» rinode·=·rfs_inode_find(dir);	314	» rinode·=·rfs_inode_find(dir);
298	» rinfo·=·rfs_inode_get_rinfo(rinode);	315	» rinfo·=·rfs_inode_get_rinfo(rinode);
		316+
299	» rfs_context_init(&rcont,·0);	317	» rfs_context_init(&rcont,·0);
300		318
301	» rargs.args.i_lookup.dir·=·dir;	319	» rargs.args.i_lookup.dir·=·dir;
302	» rargs.args.i_lookup.dentry·=·dentry;	320	» rargs.args.i_lookup.dentry·=·dentry;
		321+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
303	» rargs.args.i_lookup.nd·=·nd;	322	» rargs.args.i_lookup.nd·=·nd;
		323+	#else
		324+	» rargs.args.i_lookup.flags·=·flags;
		325+	#endif
304		326
305-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	327+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
306	» » if·(rinode->op_old·&&·rinode->op_old->lookup)	328	» » if·(rinode->op_old·&&·rinode->op_old->lookup)
307	» » » rargs.rv.rv_dentry·=·rinode->op_old->lookup(	329	» » » rargs.rv.rv_dentry·=·rinode->op_old->lookup(
308	» » » » » rargs.args.i_lookup.dir,	330	» » » » » rargs.args.i_lookup.dir,
309	» » » » » rargs.args.i_lookup.dentry,	331	» » » » » rargs.args.i_lookup.dentry,
		332+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
310	» » » » » rargs.args.i_lookup.nd);	333	» » » » » rargs.args.i_lookup.nd);
		334+	#else
		335+	» » » » » rargs.args.i_lookup.flags);
		336+	#endif
311	» » else	337	» » else
312	» » » rargs.rv.rv_dentry·=·ERR_PTR(-ENOSYS);	338	» » » rargs.rv.rv_dentry·=·ERR_PTR(-ENOSYS);
313-	» }	339+	» }·else
		340+	» » rargs.rv.rv_dentry·=·ERR_PTR(-ENOSYS);
314		341
315-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	342+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
316	» rfs_context_deinit(&rcont);	343	» rfs_context_deinit(&rcont);
317		344
318	» if·(IS_ERR(rargs.rv.rv_dentry))	345	» if·(IS_ERR(rargs.rv.rv_dentry))
⋮		⋮
329	» return·rargs.rv.rv_dentry;	356	» return·rargs.rv.rv_dentry;
330	}	357	}
331		358
		359+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,3,0))
332	static·int·rfs_mkdir(struct·inode·dir,·struct·dentry·dentry,·int·mode)	360	static·int·rfs_mkdir(struct·inode·dir,·struct·dentry·dentry,·int·mode)
		361+	#else
		362+	static·int·rfs_mkdir(struct·inode·dir,·struct·dentry·dentry,·umode_t·mode)
		363+	#endif
333	{	364	{
334	» struct·rfs_inode·*rinode;	365	» struct·rfs_inode·*rinode;
335	» struct·rfs_info·*rinfo;	366	» struct·rfs_info·*rinfo;
⋮		⋮
338		369
339	» rinode·=·rfs_inode_find(dir);	370	» rinode·=·rfs_inode_find(dir);
340	» rinfo·=·rfs_inode_get_rinfo(rinode);	371	» rinfo·=·rfs_inode_get_rinfo(rinode);
		372+
341	» rfs_context_init(&rcont,·0);	373	» rfs_context_init(&rcont,·0);
342		374
343	» if·(S_ISDIR(dir->i_mode))	375	» if·(S_ISDIR(dir->i_mode))
⋮		⋮
349	» rargs.args.i_mkdir.dentry·=·dentry;	381	» rargs.args.i_mkdir.dentry·=·dentry;
350	» rargs.args.i_mkdir.mode·=·mode;	382	» rargs.args.i_mkdir.mode·=·mode;
351		383
352-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	384+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
353	» » if·(rinode->op_old·&&·rinode->op_old->mkdir)	385	» » if·(rinode->op_old·&&·rinode->op_old->mkdir)
354	» » » rargs.rv.rv_int·=·rinode->op_old->mkdir(	386	» » » rargs.rv.rv_int·=·rinode->op_old->mkdir(
355	» » » » » rargs.args.i_mkdir.dir,	387	» » » » » rargs.args.i_mkdir.dir,
⋮		⋮
357	» » » » » rargs.args.i_mkdir.mode);	389	» » » » » rargs.args.i_mkdir.mode);
358	» » else	390	» » else
359	» » » rargs.rv.rv_int·=·-ENOSYS;	391	» » » rargs.rv.rv_int·=·-ENOSYS;
360-	» }	392+	» }·else
		393+	» » rargs.rv.rv_int·=·-ENOSYS;
361		394
362-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	395+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
363	» rfs_context_deinit(&rcont);	396	» rfs_context_deinit(&rcont);
364		397
365	» if·(!rargs.rv.rv_int)·{	398	» if·(!rargs.rv.rv_int)·{
⋮		⋮
372	» return·rargs.rv.rv_int;	405	» return·rargs.rv.rv_int;
373	}	406	}
374		407
		408+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,3,0))
375	static·int·rfs_create(struct·inode·dir,·struct·dentry·dentry,·int·mode,	409	static·int·rfs_create(struct·inode·dir,·struct·dentry·dentry,·int·mode,
376	» » struct·nameidata·*nd)	410	» » struct·nameidata·*nd)
		411+	#elif·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
		412+	static·int·rfs_create(struct·inode·dir,·struct·dentry·dentry,·umode_t·mode,
		413+	» » struct·nameidata·*nd)
		414+	#else
		415+	static·int·rfs_create(struct·inode·dir,·struct·dentry·dentry,·umode_t·mode,
		416+	» » bool·flags)
		417+	#endif
377	{	418	{
378	» struct·rfs_inode·*rinode;	419	» struct·rfs_inode·*rinode;
379	» struct·rfs_info·*rinfo;	420	» struct·rfs_info·*rinfo;
⋮		⋮
382		423
383	» rinode·=·rfs_inode_find(dir);	424	» rinode·=·rfs_inode_find(dir);
384	» rinfo·=·rfs_inode_get_rinfo(rinode);	425	» rinfo·=·rfs_inode_get_rinfo(rinode);
		426+
385	» rfs_context_init(&rcont,·0);	427	» rfs_context_init(&rcont,·0);
386		428
387	» if·(S_ISDIR(dir->i_mode))	429	» if·(S_ISDIR(dir->i_mode))
⋮		⋮
392	» rargs.args.i_create.dir·=·dir;	434	» rargs.args.i_create.dir·=·dir;
393	» rargs.args.i_create.dentry·=·dentry;	435	» rargs.args.i_create.dentry·=·dentry;
394	» rargs.args.i_create.mode·=·mode;	436	» rargs.args.i_create.mode·=·mode;
		437+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
395	» rargs.args.i_create.nd·=·nd;	438	» rargs.args.i_create.nd·=·nd;
		439+	#else
		440+	» rargs.args.i_create.flags·=·flags;
		441+	#endif
396		442
397-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	443+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
398	» » if·(rinode->op_old·&&·rinode->op_old->create)	444	» » if·(rinode->op_old·&&·rinode->op_old->create)
399	» » » rargs.rv.rv_int·=·rinode->op_old->create(	445	» » » rargs.rv.rv_int·=·rinode->op_old->create(
400	» » » » » rargs.args.i_create.dir,	446	» » » » » rargs.args.i_create.dir,
401	» » » » » rargs.args.i_create.dentry,	447	» » » » » rargs.args.i_create.dentry,
402	» » » » » rargs.args.i_create.mode,	448	» » » » » rargs.args.i_create.mode,
		449+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,6,0))
403	» » » » » rargs.args.i_create.nd);	450	» » » » » rargs.args.i_create.nd);
		451+	#else
		452+	» » » » » rargs.args.i_create.flags);
		453+	#endif
404	» » else	454	» » else
405	» » » rargs.rv.rv_int·=·-ENOSYS;	455	» » » rargs.rv.rv_int·=·-ENOSYS;
406-	» }	456+	» }·else
		457+	» » rargs.rv.rv_int·=·-ENOSYS;
407		458
408-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	459+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
409	» rfs_context_deinit(&rcont);	460	» rfs_context_deinit(&rcont);
410		461
411	» if·(!rargs.rv.rv_int)·{	462	» if·(!rargs.rv.rv_int)·{
⋮		⋮
428		479
429	» rinode·=·rfs_inode_find(dir);	480	» rinode·=·rfs_inode_find(dir);
430	» rinfo·=·rfs_inode_get_rinfo(rinode);	481	» rinfo·=·rfs_inode_get_rinfo(rinode);
		482+
431	» rfs_context_init(&rcont,·0);	483	» rfs_context_init(&rcont,·0);
432		484
433	» if·(S_ISDIR(dir->i_mode))	485	» if·(S_ISDIR(dir->i_mode))
⋮		⋮
439	» rargs.args.i_link.dir·=·dir;	491	» rargs.args.i_link.dir·=·dir;
440	» rargs.args.i_link.dentry·=·dentry;	492	» rargs.args.i_link.dentry·=·dentry;
441		493
442-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	494+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
443	» » if·(rinode->op_old·&&·rinode->op_old->link)	495	» » if·(rinode->op_old·&&·rinode->op_old->link)
444	» » » rargs.rv.rv_int·=·rinode->op_old->link(	496	» » » rargs.rv.rv_int·=·rinode->op_old->link(
445	» » » » » rargs.args.i_link.old_dentry,	497	» » » » » rargs.args.i_link.old_dentry,
⋮		⋮
447	» » » » » rargs.args.i_link.dentry);	499	» » » » » rargs.args.i_link.dentry);
448	» » else	500	» » else
449	» » » rargs.rv.rv_int·=·-ENOSYS;	501	» » » rargs.rv.rv_int·=·-ENOSYS;
450-	» }	502+	» }·else
		503+	» » rargs.rv.rv_int·=·-ENOSYS;
451		504
452-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	505+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
453	» rfs_context_deinit(&rcont);	506	» rfs_context_deinit(&rcont);
454		507
455	» if·(!rargs.rv.rv_int)·{	508	» if·(!rargs.rv.rv_int)·{
⋮		⋮
472		525
473	» rinode·=·rfs_inode_find(dir);	526	» rinode·=·rfs_inode_find(dir);
474	» rinfo·=·rfs_inode_get_rinfo(rinode);	527	» rinfo·=·rfs_inode_get_rinfo(rinode);
		528+
475	» rfs_context_init(&rcont,·0);	529	» rfs_context_init(&rcont,·0);
476		530
477	» if·(S_ISDIR(dir->i_mode))	531	» if·(S_ISDIR(dir->i_mode))
⋮		⋮
483	» rargs.args.i_symlink.dentry·=·dentry;	537	» rargs.args.i_symlink.dentry·=·dentry;
484	» rargs.args.i_symlink.oldname·=·oldname;	538	» rargs.args.i_symlink.oldname·=·oldname;
485		539
486-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	540+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
487	» » if·(rinode->op_old·&&·rinode->op_old->symlink)	541	» » if·(rinode->op_old·&&·rinode->op_old->symlink)
488	» » » rargs.rv.rv_int·=·rinode->op_old->symlink(	542	» » » rargs.rv.rv_int·=·rinode->op_old->symlink(
489	» » » » » rargs.args.i_symlink.dir,	543	» » » » » rargs.args.i_symlink.dir,
⋮		⋮
491	» » » » » rargs.args.i_symlink.oldname);	545	» » » » » rargs.args.i_symlink.oldname);
492	» » else	546	» » else
493	» » » rargs.rv.rv_int·=·-ENOSYS;	547	» » » rargs.rv.rv_int·=·-ENOSYS;
494-	» }	548+	» }·else
		549+	» » rargs.rv.rv_int·=·-ENOSYS;
495		550
496-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	551+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
497	» rfs_context_deinit(&rcont);	552	» rfs_context_deinit(&rcont);
498		553
499	» if·(!rargs.rv.rv_int)·{	554	» if·(!rargs.rv.rv_int)·{
⋮		⋮
506	» return·rargs.rv.rv_int;	561	» return·rargs.rv.rv_int;
507	}	562	}
508		563
		564+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,·3,·0))
509	static·int·rfs_mknod(struct·inode··dir,·struct·dentry·dentry,·int·mode,	565	static·int·rfs_mknod(struct·inode··dir,·struct·dentry·dentry,·int·mode,
510	» » dev_t·rdev)	566	» » dev_t·rdev)
		567+	#else
		568+	static·int·rfs_mknod(struct·inode··dir,·struct·dentry·dentry,·umode_t·mode,
		569+	» » dev_t·rdev)
		570+	#endif
511	{	571	{
512	» struct·rfs_inode·*rinode;	572	» struct·rfs_inode·*rinode;
513	» struct·rfs_info·*rinfo;	573	» struct·rfs_info·*rinfo;
⋮		⋮
516		576
517	» rinode·=·rfs_inode_find(dir);	577	» rinode·=·rfs_inode_find(dir);
518	» rinfo·=·rfs_inode_get_rinfo(rinode);	578	» rinfo·=·rfs_inode_get_rinfo(rinode);
		579+
519	» rfs_context_init(&rcont,·0);	580	» rfs_context_init(&rcont,·0);
520		581
521	» if·(S_ISDIR(dir->i_mode))	582	» if·(S_ISDIR(dir->i_mode))
⋮		⋮
528	» rargs.args.i_mknod.mode·=·mode;	589	» rargs.args.i_mknod.mode·=·mode;
529	» rargs.args.i_mknod.rdev·=·rdev;	590	» rargs.args.i_mknod.rdev·=·rdev;
530		591
531-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	592+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
532	» » if·(rinode->op_old·&&·rinode->op_old->mknod)	593	» » if·(rinode->op_old·&&·rinode->op_old->mknod)
533	» » » rargs.rv.rv_int·=·rinode->op_old->mknod(	594	» » » rargs.rv.rv_int·=·rinode->op_old->mknod(
534	» » » » » rargs.args.i_mknod.dir,	595	» » » » » rargs.args.i_mknod.dir,
⋮		⋮
537	» » » » » rargs.args.i_mknod.rdev);	598	» » » » » rargs.args.i_mknod.rdev);
538	» » else	599	» » else
539	» » » rargs.rv.rv_int·=·-ENOSYS;	600	» » » rargs.rv.rv_int·=·-ENOSYS;
540-	» }	601+	» }·else
		602+	» » rargs.rv.rv_int·=·-ENOSYS;
541		603
542-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	604+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
543	» rfs_context_deinit(&rcont);	605	» rfs_context_deinit(&rcont);
544		606
545	» if·(!rargs.rv.rv_int)·{	607	» if·(!rargs.rv.rv_int)·{
⋮		⋮
561		623
562	» rinode·=·rfs_inode_find(inode);	624	» rinode·=·rfs_inode_find(inode);
563	» rinfo·=·rfs_inode_get_rinfo(rinode);	625	» rinfo·=·rfs_inode_get_rinfo(rinode);
		626+
564	» rfs_context_init(&rcont,·0);	627	» rfs_context_init(&rcont,·0);
565		628
566	» if·(S_ISDIR(inode->i_mode))	629	» if·(S_ISDIR(inode->i_mode))
⋮		⋮
571	» rargs.args.i_unlink.dir·=·inode;	634	» rargs.args.i_unlink.dir·=·inode;
572	» rargs.args.i_unlink.dentry·=·dentry;	635	» rargs.args.i_unlink.dentry·=·dentry;
573		636
574-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	637+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
575	» » if·(rinode->op_old·&&·rinode->op_old->unlink)	638	» » if·(rinode->op_old·&&·rinode->op_old->unlink)
576	» » » rargs.rv.rv_int·=·rinode->op_old->unlink(	639	» » » rargs.rv.rv_int·=·rinode->op_old->unlink(
577	» » » » » rargs.args.i_unlink.dir,	640	» » » » » rargs.args.i_unlink.dir,
578	» » » » » rargs.args.i_unlink.dentry);	641	» » » » » rargs.args.i_unlink.dentry);
579	» » else	642	» » else
580	» » » rargs.rv.rv_int·=·-ENOSYS;	643	» » » rargs.rv.rv_int·=·-ENOSYS;
581-	» }	644+	» }else
		645+	» » rargs.rv.rv_int·=·-ENOSYS;
582		646
583-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	647+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
584	» rfs_context_deinit(&rcont);	648	» rfs_context_deinit(&rcont);
585		649
586	» rfs_inode_put(rinode);	650	» rfs_inode_put(rinode);
⋮		⋮
597		661
598	» rinode·=·rfs_inode_find(inode);	662	» rinode·=·rfs_inode_find(inode);
599	» rinfo·=·rfs_inode_get_rinfo(rinode);	663	» rinfo·=·rfs_inode_get_rinfo(rinode);
		664+
600	» rfs_context_init(&rcont,·0);	665	» rfs_context_init(&rcont,·0);
601		666
602	» if·(S_ISDIR(inode->i_mode))	667	» if·(S_ISDIR(inode->i_mode))
⋮		⋮
607	» rargs.args.i_unlink.dir·=·inode;	672	» rargs.args.i_unlink.dir·=·inode;
608	» rargs.args.i_unlink.dentry·=·dentry;	673	» rargs.args.i_unlink.dentry·=·dentry;
609		674
610-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	675+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
611	» » if·(rinode->op_old·&&·rinode->op_old->rmdir)	676	» » if·(rinode->op_old·&&·rinode->op_old->rmdir)
612	» » » rargs.rv.rv_int·=·rinode->op_old->rmdir(	677	» » » rargs.rv.rv_int·=·rinode->op_old->rmdir(
613	» » » » » rargs.args.i_unlink.dir,	678	» » » » » rargs.args.i_unlink.dir,
614	» » » » » rargs.args.i_unlink.dentry);	679	» » » » » rargs.args.i_unlink.dentry);
615	» » else	680	» » else
616	» » » rargs.rv.rv_int·=·-ENOSYS;	681	» » » rargs.rv.rv_int·=·-ENOSYS;
617-	» }	682+	» }·else
		683+	» » rargs.rv.rv_int·=·-ENOSYS;
618		684
619-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	685+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
620	» rfs_context_deinit(&rcont);	686	» rfs_context_deinit(&rcont);
621		687
622	» rfs_inode_put(rinode);	688	» rfs_inode_put(rinode);
⋮		⋮
624	» return·rargs.rv.rv_int;	690	» return·rargs.rv.rv_int;
625	}	691	}
626		692
627-	#if·LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,27)	693+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,27))
628		694
629	static·int·rfs_permission(struct·inode·inode,·int·mask,·struct·nameidata·nd)	695	static·int·rfs_permission(struct·inode·inode,·int·mask,·struct·nameidata·nd)
630	{	696	{
⋮		⋮
637	» submask·=·mask·&·~MAY_APPEND;	703	» submask·=·mask·&·~MAY_APPEND;
638	» rinode·=·rfs_inode_find(inode);	704	» rinode·=·rfs_inode_find(inode);
639	» rinfo·=·rfs_inode_get_rinfo(rinode);	705	» rinfo·=·rfs_inode_get_rinfo(rinode);
		706+
640	» rfs_context_init(&rcont,·0);	707	» rfs_context_init(&rcont,·0);
641		708
642	» if·(S_ISREG(inode->i_mode))	709	» if·(S_ISREG(inode->i_mode))
⋮		⋮
658	» rargs.args.i_permission.mask·=·mask;	725	» rargs.args.i_permission.mask·=·mask;
659	» rargs.args.i_permission.nd·=·nd;	726	» rargs.args.i_permission.nd·=·nd;
660		727
661-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	728+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
662	» » if·(rinode->op_old·&&·rinode->op_old->permission)	729	» » if·(rinode->op_old·&&·rinode->op_old->permission)
663	» » » rargs.rv.rv_int·=·rinode->op_old->permission(	730	» » » rargs.rv.rv_int·=·rinode->op_old->permission(
664	» » » » » rargs.args.i_permission.inode,	731	» » » » » rargs.args.i_permission.inode,
⋮		⋮
667	» » else	734	» » else
668	» » » rargs.rv.rv_int·=·generic_permission(inode,·submask,	735	» » » rargs.rv.rv_int·=·generic_permission(inode,·submask,
669	» » » » » NULL);	736	» » » » » NULL);
670-	» }	737+	» }·else
		738+	» » rargs.rv.rv_int·=·generic_permission(inode,·submask,
		739+	» » » » NULL);
671		740
672-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	741+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
673	» rfs_context_deinit(&rcont);	742	» rfs_context_deinit(&rcont);
674		743
675	» rfs_inode_put(rinode);	744	» rfs_inode_put(rinode);
⋮		⋮
677	» return·rargs.rv.rv_int;	746	» return·rargs.rv.rv_int;
678	}	747	}
679		748
680-	#else	749+	#elif·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,38))
681		750
682	static·int·rfs_permission(struct·inode·*inode,·int·mask)	751	static·int·rfs_permission(struct·inode·*inode,·int·mask)
683	{	752	{
⋮		⋮
690	» submask·=·mask·&·~MAY_APPEND;	759	» submask·=·mask·&·~MAY_APPEND;
691	» rinode·=·rfs_inode_find(inode);	760	» rinode·=·rfs_inode_find(inode);
692	» rinfo·=·rfs_inode_get_rinfo(rinode);	761	» rinfo·=·rfs_inode_get_rinfo(rinode);
		762+
693	» rfs_context_init(&rcont,·0);	763	» rfs_context_init(&rcont,·0);
694		764
695	» if·(S_ISREG(inode->i_mode))	765	» if·(S_ISREG(inode->i_mode))
⋮		⋮
710	» rargs.args.i_permission.inode·=·inode;	780	» rargs.args.i_permission.inode·=·inode;
711	» rargs.args.i_permission.mask·=·mask;	781	» rargs.args.i_permission.mask·=·mask;
712		782
713-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	783+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
714	» » if·(rinode->op_old·&&·rinode->op_old->permission)	784	» » if·(rinode->op_old·&&·rinode->op_old->permission)
715	» » » rargs.rv.rv_int·=·rinode->op_old->permission(	785	» » » rargs.rv.rv_int·=·rinode->op_old->permission(
716	» » » » » rargs.args.i_permission.inode,	786	» » » » » rargs.args.i_permission.inode,
⋮		⋮
718	» » else	788	» » else
719	» » » rargs.rv.rv_int·=·generic_permission(inode,·submask,	789	» » » rargs.rv.rv_int·=·generic_permission(inode,·submask,
720	» » » » » NULL);	790	» » » » » NULL);
721-	» }	791+	» }·else
		792+	» » rargs.rv.rv_int·=·generic_permission(inode,·submask,
		793+	» » » » NULL);
		794+
		795+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
		796+	» rfs_context_deinit(&rcont);
		797+
		798+	» rfs_inode_put(rinode);
		799+	» rfs_info_put(rinfo);
		800+	» return·rargs.rv.rv_int;
		801+	}
		802+
		803+	#elif·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,1,0))
		804+
		805+	static·int·rfs_permission(struct·inode·*inode,·int·mask,·unsigned·int·flags)
		806+	{
		807+	» struct·rfs_inode·*rinode;
		808+	» struct·rfs_info·*rinfo;
		809+	» struct·rfs_context·rcont;
		810+	» struct·redirfs_args·rargs;
		811+	» int·submask;
		812+
		813+	» submask·=·mask·&·~MAY_APPEND;
		814+	» rinode·=·rfs_inode_find(inode);
		815+	» rinfo·=·rfs_inode_get_rinfo(rinode);
		816+
		817+	» rfs_context_init(&rcont,·0);
		818+
		819+	» if·(S_ISREG(inode->i_mode))
		820+	» » rargs.type.id·=·REDIRFS_REG_IOP_PERMISSION;
		821+	» else·if·(S_ISDIR(inode->i_mode))
		822+	» » rargs.type.id·=·REDIRFS_DIR_IOP_PERMISSION;
		823+	» else·if·(S_ISLNK(inode->i_mode))
		824+	» » rargs.type.id·=·REDIRFS_LNK_IOP_PERMISSION;
		825+	» else·if·(S_ISCHR(inode->i_mode))
		826+	» » rargs.type.id·=·REDIRFS_CHR_IOP_PERMISSION;
		827+	» else·if·(S_ISBLK(inode->i_mode))
		828+	» » rargs.type.id·=·REDIRFS_BLK_IOP_PERMISSION;
		829+	» else·if·(S_ISFIFO(inode->i_mode))
		830+	» » rargs.type.id·=·REDIRFS_FIFO_IOP_PERMISSION;
		831+	» else·
		832+	» » rargs.type.id·=·REDIRFS_SOCK_IOP_PERMISSION;
		833+
		834+	» rargs.args.i_permission.inode·=·inode;
		835+	» rargs.args.i_permission.mask·=·mask;
		836+	» rargs.args.i_permission.flags·=·flags;
		837+
		838+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
		839+	» » if·(rinode->op_old·&&·rinode->op_old->permission)
		840+	» » » rargs.rv.rv_int·=·rinode->op_old->permission(
		841+	» » » » » rargs.args.i_permission.inode,
		842+	» » » » » rargs.args.i_permission.mask,
		843+	» » » » » rargs.args.i_permission.flags);
		844+	» » else
		845+	» » » rargs.rv.rv_int·=·generic_permission(inode,·submask,
		846+	» » » » » flags,·NULL);
		847+	» }·else
		848+	» » rargs.rv.rv_int·=·generic_permission(inode,·submask,
		849+	» » » » flags,·NULL);
		850+
		851+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
		852+	» rfs_context_deinit(&rcont);
		853+
		854+	» rfs_inode_put(rinode);
		855+	» rfs_info_put(rinfo);
		856+	» return·rargs.rv.rv_int;
		857+	}
		858+
		859+	#else
		860+
		861+	static·int·rfs_permission(struct·inode·*inode,·int·mask)
		862+	{
		863+	» struct·rfs_inode·*rinode;
		864+	» struct·rfs_info·*rinfo;
		865+	» struct·rfs_context·rcont;
		866+	» struct·redirfs_args·rargs;
		867+	» int·submask;
		868+
		869+	» submask·=·mask·&·~MAY_APPEND;
		870+	» rinode·=·rfs_inode_find(inode);
		871+	» rinfo·=·rfs_inode_get_rinfo(rinode);
		872+
		873+	» rfs_context_init(&rcont,·0);
		874+
		875+	» if·(S_ISREG(inode->i_mode))
		876+	» » rargs.type.id·=·REDIRFS_REG_IOP_PERMISSION;
		877+	» else·if·(S_ISDIR(inode->i_mode))
		878+	» » rargs.type.id·=·REDIRFS_DIR_IOP_PERMISSION;
		879+	» else·if·(S_ISLNK(inode->i_mode))
		880+	» » rargs.type.id·=·REDIRFS_LNK_IOP_PERMISSION;
		881+	» else·if·(S_ISCHR(inode->i_mode))
		882+	» » rargs.type.id·=·REDIRFS_CHR_IOP_PERMISSION;
		883+	» else·if·(S_ISBLK(inode->i_mode))
		884+	» » rargs.type.id·=·REDIRFS_BLK_IOP_PERMISSION;
		885+	» else·if·(S_ISFIFO(inode->i_mode))
		886+	» » rargs.type.id·=·REDIRFS_FIFO_IOP_PERMISSION;
		887+	» else·
		888+	» » rargs.type.id·=·REDIRFS_SOCK_IOP_PERMISSION;
		889+
		890+	» rargs.args.i_permission.inode·=·inode;
		891+	» rargs.args.i_permission.mask·=·mask;
		892+
		893+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
		894+	» » if·(rinode->op_old·&&·rinode->op_old->permission)
		895+	» » » rargs.rv.rv_int·=·rinode->op_old->permission(
		896+	» » » » » rargs.args.i_permission.inode,
		897+	» » » » » rargs.args.i_permission.mask);
		898+	» » else
		899+	» » » rargs.rv.rv_int·=·generic_permission(inode,·submask);
		900+	» }·else
		901+	» » rargs.rv.rv_int·=·generic_permission(inode,·submask);
722		902
723-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	903+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
724	» rfs_context_deinit(&rcont);	904	» rfs_context_deinit(&rcont);
725		905
726	» rfs_inode_put(rinode);	906	» rfs_inode_put(rinode);
⋮		⋮
739	» if·(rv)	919	» if·(rv)
740	» » return·rv;	920	» » return·rv;
741		921
742-	#if·LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,34)	922+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,34))
743	» if·((iattr->ia_valid·&·ATTR_UID·&&·iattr->ia_uid·!=·inode->i_uid)·\|\|	923	» if·((iattr->ia_valid·&·ATTR_UID·&&·iattr->ia_uid·!=·inode->i_uid)·\|\|
744	» ····(iattr->ia_valid·&·ATTR_GID·&&·iattr->ia_gid·!=·inode->i_gid))	924	» ····(iattr->ia_valid·&·ATTR_GID·&&·iattr->ia_gid·!=·inode->i_gid))
745	» » return·rfs_dq_transfer(inode,·iattr)·?·-EDQUOT·:·0;	925	» » return·rfs_dq_transfer(inode,·iattr)·?·-EDQUOT·:·0;
746	#endif	926	#endif
747		927
748-	» return·inode_setattr(inode,·iattr);	928+	» return·rfs_inode_setattr(inode,·iattr);
749	}	929	}
750		930
751	static·int·rfs_setattr(struct·dentry·dentry,·struct·iattr·iattr)	931	static·int·rfs_setattr(struct·dentry·dentry,·struct·iattr·iattr)
⋮		⋮
757		937
758	» rinode·=·rfs_inode_find(dentry->d_inode);	938	» rinode·=·rfs_inode_find(dentry->d_inode);
759	» rinfo·=·rfs_inode_get_rinfo(rinode);	939	» rinfo·=·rfs_inode_get_rinfo(rinode);
		940+
760	» rfs_context_init(&rcont,·0);	941	» rfs_context_init(&rcont,·0);
761		942
762	» if·(S_ISREG(dentry->d_inode->i_mode))	943	» if·(S_ISREG(dentry->d_inode->i_mode))
⋮		⋮
777	» rargs.args.i_setattr.dentry·=·dentry;	958	» rargs.args.i_setattr.dentry·=·dentry;
778	» rargs.args.i_setattr.iattr·=·iattr;	959	» rargs.args.i_setattr.iattr·=·iattr;
779		960
780-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	961+	» if·(!rfs_precall_flts(rinfo,·&rcont,·&rargs))·{
781	» » if·(rinode->op_old·&&·rinode->op_old->setattr)	962	» » if·(rinode->op_old·&&·rinode->op_old->setattr)
782	» » » rargs.rv.rv_int·=·rinode->op_old->setattr(	963	» » » rargs.rv.rv_int·=·rinode->op_old->setattr(
783	» » » » » rargs.args.i_setattr.dentry,	964	» » » » » rargs.args.i_setattr.dentry,
784	» » » » » rargs.args.i_setattr.iattr);	965	» » » » » rargs.args.i_setattr.iattr);
785	» » else·	966	» » else·
786	» » » rargs.rv.rv_int·=·rfs_setattr_default(dentry,·iattr);	967	» » » rargs.rv.rv_int·=·rfs_setattr_default(dentry,·iattr);
787-	» }	968+	» }·else
		969+	» » rargs.rv.rv_int·=·rfs_setattr_default(dentry,·iattr);
788		970
789-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	971+	» rfs_postcall_flts(rinfo,·&rcont,·&rargs);
790	» rfs_context_deinit(&rcont);	972	» rfs_context_deinit(&rcont);
791		973
792	» rfs_inode_put(rinode);	974	» rfs_inode_put(rinode);
⋮		⋮
794	» return·rargs.rv.rv_int;	976	» return·rargs.rv.rv_int;
795	}	977	}
796		978
		979+	static·int·rfs_precall_flts_rename(struct·rfs_info·*rinfo,
		980+	» » struct·rfs_context·rcont,·struct·redirfs_args·rargs)
		981+	{
		982+	» struct·redirfs_filter_operations·*ops;
		983+	» enum·redirfs_rv·(rop)(redirfs_context,·struct·redirfs_args·);
		984+	» enum·redirfs_rv·rv;
		985+
		986+	» if·(!rinfo)
		987+	» » return·0;
		988+
		989+	» if·(!rinfo->rchain)
		990+	» » return·0;
		991+
		992+	» rargs->type.call·=·REDIRFS_PRECALL;
		993+
		994+	» rcont->idx·=·rcont->idx_start;
		995+
		996+	» for·(;·rcont->idx·<·rinfo->rchain->rflts_nr;·rcont->idx++)·{
		997+	» » if·(!atomic_read(&rinfo->rchain->rflts[rcont->idx]->active))
		998+	» » » continue;
		999+
		1000+	» » ops·=·rinfo->rchain->rflts[rcont->idx]->ops;
		1001+	» » if·(!ops)
		1002+	» » » continue;
		1003+	» » rop·=·ops->pre_rename;
		1004+	» » if·(!rop)
		1005+	» » » continue;
		1006+
		1007+	» » rv·=·rop(rcont,·rargs);
		1008+	» » if·(rv·==·REDIRFS_STOP)
		1009+	» » » return·-1;
		1010+	» }
		1011+
		1012+	» rcont->idx--;
		1013+
		1014+	» return·0;
		1015+	}
		1016+
		1017+	static·void·rfs_postcall_flts_rename(struct·rfs_info·*rinfo,
		1018+	» » struct·rfs_context·rcont,·struct·redirfs_args·rargs)
		1019+	{
		1020+	» struct·redirfs_filter_operations·*ops;
		1021+	» enum·redirfs_rv·(rop)(redirfs_context,·struct·redirfs_args·);
		1022+
		1023+	» if·(!rinfo)
		1024+	» » return;
		1025+
		1026+	» if·(!rinfo->rchain)
		1027+	» » return;
		1028+
		1029+	» rargs->type.call·=·REDIRFS_POSTCALL;
		1030+
		1031+	» for·(;·rcont->idx·>=·rcont->idx_start;·rcont->idx--)·{
		1032+	» » if·(!atomic_read(&rinfo->rchain->rflts[rcont->idx]->active))
		1033+	» » » continue;
		1034+
		1035+	» » ops·=·rinfo->rchain->rflts[rcont->idx]->ops;
		1036+	» » if·(!ops)
		1037+	» » » continue;
		1038+	» » rop·=·ops->post_rename;
		1039+	» » if·(rop)·
		1040+	» » » rop(rcont,·rargs);
		1041+	» }
		1042+
		1043+	» rcont->idx++;
		1044+	}
		1045+
		1046+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,17,0))
797	int·rfs_rename(struct·inode·old_dir,·struct·dentry·old_dentry,	1047	int·rfs_rename(struct·inode·old_dir,·struct·dentry·old_dentry,
798	» » struct·inode·new_dir,·struct·dentry·new_dentry)	1048	» » struct·inode·new_dir,·struct·dentry·new_dentry)
799	{	1049	{
800-	» struct·rfs_inode·*rinode;	1050+	» struct·rfs_inode·*rinode_old;
801-	» struct·rfs_info·*rinfo;	1051+	» struct·rfs_inode·*rinode_new;
802-	» struct·rfs_context·rcont;	1052+	» struct·rfs_info·*rinfo_old;
		1053+	» struct·rfs_info·*rinfo_new;
		1054+	» struct·rfs_context·rcont_old;
		1055+	» struct·rfs_context·rcont_new;
803	» struct·redirfs_args·rargs;	1056	» struct·redirfs_args·rargs;
804		1057
805-	» rinode·=·rfs_inode_find(old_dir);	1058+	» rfs_context_init(&rcont_old,·0);
806-	» rinfo·=·rfs_inode_get_rinfo(rinode);	1059+	» rinode_old·=·rfs_inode_find(old_dir);
807-	» rfs_context_init(&rcont,·0);	1060+	» rinfo_old·=·rfs_inode_get_rinfo(rinode_old);
		1061+
		1062+	» rfs_context_init(&rcont_new,·0);
		1063+
		1064+	» rinode_new·=·rfs_inode_find(new_dir);
		1065+	» rinfo_new·=·rfs_inode_get_rinfo(rinode_new);
808		1066
809	» if·(S_ISDIR(old_dir->i_mode))	1067	» if·(S_ISDIR(old_dir->i_mode))
810	» » rargs.type.id·=·REDIRFS_DIR_IOP_RENAME;	1068	» » rargs.type.id·=·REDIRFS_DIR_IOP_RENAME;
⋮		⋮
815	» rargs.args.i_rename.old_dentry·=·old_dentry;	1073	» rargs.args.i_rename.old_dentry·=·old_dentry;
816	» rargs.args.i_rename.new_dir·=·new_dir;	1074	» rargs.args.i_rename.new_dir·=·new_dir;
817	» rargs.args.i_rename.new_dentry·=·new_dentry;	1075	» rargs.args.i_rename.new_dentry·=·new_dentry;
		1076+	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(3,15,0))
		1077+	» rargs.args.i_rename.flags·=·0;
		1078+	#endif
818		1079
819-	» if·(!rfs_precall_flts(rinfo->rchain,·&rcont,·&rargs))·{	1080+	» if·(rfs_precall_flts(rinfo_old,·&rcont_old,·&rargs))·{
820-	» » if·(rinode->op_old·&&·rinode->op_old->rename)	1081+	» » rargs.rv.rv_int·=·-ENOSYS;
821-	» » » rargs.rv.rv_int·=·rinode->op_old->rename(	1082+	» » goto·skip;
822-	» » » » » rargs.args.i_rename.old_dir,
823-	» » » » » rargs.args.i_rename.old_dentry,
824-	» » » » » rargs.args.i_rename.new_dir,
825-	» » » » » rargs.args.i_rename.new_dentry);
826-	» » else
827-	» » » rargs.rv.rv_int·=·-ENOSYS;
828	» }	1083	» }
829		1084
		1085+	» if·(rfs_precall_flts_rename(rinfo_new,·&rcont_new,·&rargs))·{
		1086+	» » rargs.rv.rv_int·=·-ENOSYS;
		1087+	» » goto·skip;
		1088+	» }
		1089+
		1090+	» if·(rinode_old->op_old·&&·rinode_old->op_old->rename)
		1091+	» » rargs.rv.rv_int·=·rinode_old->op_old->rename(
		1092+	» » » » rargs.args.i_rename.old_dir,
		1093+	» » » » rargs.args.i_rename.old_dentry,
		1094+	» » » » rargs.args.i_rename.new_dir,
		1095+	» » » » rargs.args.i_rename.new_dentry);
		1096+	» else
		1097+	» » rargs.rv.rv_int·=·-ENOSYS;
		1098+	»
		1099+	skip:
830	» if·(!rargs.rv.rv_int)	1100	» if·(!rargs.rv.rv_int)
831	» » rargs.rv.rv_int·=·rfs_fsrename(	1101	» » rargs.rv.rv_int·=·rfs_fsrename(
832	» » » » rargs.args.i_rename.old_dir,	1102	» » » » rargs.args.i_rename.old_dir,
⋮		⋮
834	» » » » rargs.args.i_rename.new_dir,	1104	» » » » rargs.args.i_rename.new_dir,
835	» » » » rargs.args.i_rename.new_dentry);	1105	» » » » rargs.args.i_rename.new_dentry);
836		1106
837-	» rfs_postcall_flts(rinfo->rchain,·&rcont,·&rargs);	1107+	» rfs_postcall_flts_rename(rinfo_new,·&rcont_new,·&rargs);
838-	» rfs_context_deinit(&rcont);	1108+	» rfs_postcall_flts(rinfo_old,·&rcont_old,·&rargs);
839		1109
840-	» rfs_inode_put(rinode);	1110+	» rfs_context_deinit(&rcont_old);
841-	» rfs_info_put(rinfo);	1111+	» rfs_context_deinit(&rcont_new);
		1112+	» rfs_inode_put(rinode_old);
		1113+	» rfs_inode_put(rinode_new);
		1114+	» rfs_info_put(rinfo_old);
		1115+	» rfs_info_put(rinfo_new);
842	» return·rargs.rv.rv_int;	1116	» return·rargs.rv.rv_int;
843	}	1117	}
		1118+	#endif
		1119+
		1120+	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(3,15,0))
		1121+	int·rfs_rename2(struct·inode·old_dir,·struct·dentry·old_dentry,
		1122+	» » struct·inode·new_dir,·struct·dentry·new_dentry,·unsigned·int·flags)
		1123+	{
		1124+	» struct·rfs_inode·*rinode_old;
		1125+	» struct·rfs_inode·*rinode_new;
		1126+	» struct·rfs_info·*rinfo_old;
		1127+	» struct·rfs_info·*rinfo_new;
		1128+	» struct·rfs_context·rcont_old;
		1129+	» struct·rfs_context·rcont_new;
		1130+	» struct·redirfs_args·rargs;
		1131+
		1132+	» rfs_context_init(&rcont_old,·0);
		1133+	» rinode_old·=·rfs_inode_find(old_dir);
		1134+	» rinfo_old·=·rfs_inode_get_rinfo(rinode_old);
		1135+
		1136+	» rfs_context_init(&rcont_new,·0);
		1137+	» rinode_new·=·rfs_inode_find(new_dir);
		1138+	» rinfo_new·=·rfs_inode_get_rinfo(rinode_new);
		1139+
		1140+	» if·(S_ISDIR(old_dir->i_mode))
		1141+	» » rargs.type.id·=·REDIRFS_DIR_IOP_RENAME;
		1142+	» else
		1143+	» » BUG();
844		1144
		1145+	» rargs.args.i_rename.old_dir·=·old_dir;
		1146+	» rargs.args.i_rename.old_dentry·=·old_dentry;
		1147+	» rargs.args.i_rename.new_dir·=·new_dir;
		1148+	» rargs.args.i_rename.new_dentry·=·new_dentry;
		1149+	» rargs.args.i_rename.flags·=·flags;
		1150+
		1151+	» if·(rfs_precall_flts(rinfo_old,·&rcont_old,·&rargs))·{
		1152+	» » rargs.rv.rv_int·=·-ENOSYS;
		1153+	» » goto·skip;
		1154+	» }
		1155+
		1156+	» if·(rfs_precall_flts_rename(rinfo_new,·&rcont_new,·&rargs))·{
		1157+	» » rargs.rv.rv_int·=·-ENOSYS;
		1158+	» » goto·skip;
		1159+	» }
		1160+
		1161+	» if·(rinode_old->op_old·&&·rinode_old->op_old->rename2)
		1162+	» » rargs.rv.rv_int·=·rinode_old->op_old->rename2(
		1163+	» » » » rargs.args.i_rename.old_dir,
		1164+	» » » » rargs.args.i_rename.old_dentry,
		1165+	» » » » rargs.args.i_rename.new_dir,
		1166+	» » » » rargs.args.i_rename.new_dentry,
		1167+	» » » » rargs.args.i_rename.flags);
		1168+	#if·(LINUX_VERSION_CODE·>=·KERNEL_VERSION(3,17,0))
		1169+	» else·if·(rinode_old->op_old·&&·rinode_old->op_old->rename)
		1170+	» » rargs.rv.rv_int·=·rinode_old->op_old->rename(
		1171+	» » » » rargs.args.i_rename.old_dir,
		1172+	» » » » rargs.args.i_rename.old_dentry,
		1173+	» » » » rargs.args.i_rename.new_dir,
		1174+	» » » » rargs.args.i_rename.new_dentry);
		1175+	#endif
		1176+	» else
		1177+	» » rargs.rv.rv_int·=·-ENOSYS;
		1178+
		1179+	skip:
		1180+	» if·(!rargs.rv.rv_int)
		1181+	» » rargs.rv.rv_int·=·rfs_fsrename(
		1182+	» » » » rargs.args.i_rename.old_dir,
		1183+	» » » » rargs.args.i_rename.old_dentry,
		1184+	» » » » rargs.args.i_rename.new_dir,
		1185+	» » » » rargs.args.i_rename.new_dentry);
		1186+
		1187+	» rfs_postcall_flts_rename(rinfo_new,·&rcont_new,·&rargs);
		1188+	» rfs_postcall_flts(rinfo_old,·&rcont_old,·&rargs);
		1189+
		1190+	» rfs_context_deinit(&rcont_old);
		1191+	» rfs_context_deinit(&rcont_new);
		1192+	» rfs_inode_put(rinode_old);
		1193+	» rfs_inode_put(rinode_new);
		1194+	» rfs_info_put(rinfo_old);
		1195+	» rfs_info_put(rinfo_new);
		1196+	» return·rargs.rv.rv_int;
		1197+	}
		1198+	#endif
845		1199
846	static·void·rfs_inode_set_ops_reg(struct·rfs_inode·*rinode)	1200	static·void·rfs_inode_set_ops_reg(struct·rfs_inode·*rinode)
847	{	1201	{

driver.org/redirfs/rfs_ops.c		driver/redirfs/rfs_ops.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
29	» char·*arr;	31	» char·*arr;
30		32
31	» rops·=·kzalloc(sizeof(struct·rfs_ops),·GFP_KERNEL);	33	» rops·=·kzalloc(sizeof(struct·rfs_ops),·GFP_KERNEL);
32-	» arr·=·kzalloc(sizeof(char)·*·REDIRFS_OP_END,·GFP_KERNEL);	34+	» if·(!rops)
		35+	» » return·ERR_PTR(-ENOMEM);
33		36
34-	» if·(!rops·\|\|·!arr)·{	37+	» arr·=·kzalloc(sizeof(char)·*·REDIRFS_OP_END,·GFP_KERNEL);
		38+	» if·(!arr)·{
35	» » kfree(rops);	39	» » kfree(rops);
36-	» » kfree(arr);
37	» » return·ERR_PTR(-ENOMEM);	40	» » return·ERR_PTR(-ENOMEM);
38	» }	41	» }
39		42

driver.org/redirfs/rfs_path.c		driver/redirfs/rfs_path.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
143	» struct·rfs_path·*rpath·=·NULL;	145	» struct·rfs_path·*rpath·=·NULL;
144	» int·i·=·0;	146	» int·i·=·0;
145		147
		148+	mainloop:
146	» while·(i·<·INT_MAX)·{	149	» while·(i·<·INT_MAX)·{
147	» » list_for_each_entry(rpath,·&rfs_path_list,·list)·{	150	» » list_for_each_entry(rpath,·&rfs_path_list,·list)·{
148	» » » if·(rpath->id·==·i)·{	151	» » » if·(rpath->id·==·i)·{
149	» » » » i++;	152	» » » » i++;
150-	» » » » continue;	153+	» » » » goto·mainloop;
151	» » » }	154	» » » }
152	» » }	155	» » }
153	» » return·i;	156	» » return·i;
⋮		⋮
642	» return·len;	645	» return·len;
643	}	646	}
644		647
		648+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(2,6,25))
		649+
645	int·redirfs_get_filename(struct·vfsmount·mnt,·struct·dentry·dentry,·char·*buf,	650	int·redirfs_get_filename(struct·vfsmount·mnt,·struct·dentry·dentry,·char·*buf,
646	» » int·size)	651	» » int·size)
647	{	652	{
648-	» struct·dentry·*dtmp·=·NULL;	653+	» char·*fn;
649-	» struct·dentry·*dmnt·=·NULL;	654+	» size_t·len;
650-	» struct·vfsmount·*mtmp·=·NULL;
651-	» struct·vfsmount·*mmnt·=·NULL;
652-	» char·*end;
653-	» int·len;
654-
655-	» end·=·buf·+·size;
656-	» len·=·size;
657-
658-	» if·(size·<·2)
659-	» » return·-ENAMETOOLONG;
660-
661-	» *--end·=·'\0';
662-	» size--;
663-	again:
664-	» spin_lock(&dcache_lock);
665-
666-	» while·(dentry·!=·mnt->mnt_root)·{
667-	» » size·-=·dentry->d_name.len·+·1;·/·dentry·name·+·slash·/
668-	» » if·(size·<·0)·{
669-	» » » spin_unlock(&dcache_lock);
670-	» » » return·-ENAMETOOLONG;
671-	» » }
672		655
673-	» » end·-=·dentry->d_name.len;	656+	» fn·=·d_path(dentry,·mnt,·buf,·size);
674-	» » memcpy(end,·dentry->d_name.name,·dentry->d_name.len);	657+	» if·(IS_ERR(fn))
675-	» » *--end·=·'/';	658+	» » return·PTR_ERR(fn);
676-	» » dentry·=·dentry->d_parent;	659+
677-	» }	660+	» len·=·strlen(fn);
678-		661+	» memmove(buf,·fn,·len);
679-	» dtmp·=·dmnt;	662+	» buf[len]·=·0;
680-	» mtmp·=·mmnt;	663+	» return·0;
681-	» dmnt·=·dget(dentry);	664+	}
682-	» mmnt·=·mntget(mnt);
683-	» spin_unlock(&dcache_lock);
684-	» dput(dtmp);
685-	» mntput(mtmp);
686-
687-	» if·(rfs_follow_up(&mmnt,·&dmnt))·{
688-	» » dentry·=·dmnt;
689-	» » mnt·=·mmnt;
690-	» » goto·again;
691-	» }
692		665
693-	» dput(dmnt);	666+	#else
694-	» mntput(mmnt);
695-	»
696-	» if·(*end·!=·'/')·{
697-	» » *--end·=·'/';
698-	» » size--;
699-	» }
700		667
701-	» memmove(buf,·end,·len·-·size);	668+	int·redirfs_get_filename(struct·vfsmount·mnt,·struct·dentry·dentry,·char·*buf,
		669+	» » int·size)
		670+	{
		671+	» struct·path·path;
		672+	» char·*fn;»
		673+	» size_t·len;
		674+
		675+	» path.mnt·=·mnt;
		676+	» path.dentry·=·dentry;
		677+	» fn·=·d_path(&path,·buf,·size);
		678+	» if·(IS_ERR(fn))
		679+	» » return·PTR_ERR(fn);
		680+
		681+	» len·=·strlen(fn);
		682+	» memmove(buf,·fn,·len);
		683+	» buf[len]·=·0;
702	» return·0;	684	» return·0;
703	}	685	}
704		686
		687+	#endif
		688+
705	static·int·rfs_fsrename_rem_rroot(struct·rfs_root·*rroot,	689	static·int·rfs_fsrename_rem_rroot(struct·rfs_root·*rroot,
706	» » struct·rfs_chain·*rchain)	690	» » struct·rfs_chain·*rchain)
707	{	691	{
⋮		⋮
952		936
953	» if·(rroot_src·==·rroot_dst)·	937	» if·(rroot_src·==·rroot_dst)·
954	» » goto·exit;	938	» » goto·exit;
955-		939+	»
956	» rv·=·rfs_fsrename_rem(rroot_src,·rroot_dst,·old_dentry);	940	» rv·=·rfs_fsrename_rem(rroot_src,·rroot_dst,·old_dentry);
957	» if·(rv)	941	» if·(rv)
958	» » goto·exit;	942	» » goto·exit;

driver.org/redirfs/rfs_root.c		driver/redirfs/rfs_root.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.

driver.org/redirfs/rfs_sysfs.c		driver/redirfs/rfs_sysfs.c
⋮		⋮
1	/*	1	/*
2	·*·RedirFS:·Redirecting·File·System	2	·*·RedirFS:·Redirecting·File·System
3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>	3	·*·Written·by·Frantisek·Hrbata·<frantisek.hrbata@redirfs.org>
		4+	·*·Midified·by·KINTA-JAPAN·<sanu@ruby.plala.or.jo>
4	·*	5	·*
5	·*·Copyright·2008·-·2010·Frantisek·Hrbata	6	·*·Copyright·2008·-·2010·Frantisek·Hrbata
		7+	·*·Copyright·2013·-·2015·KINTA-JAPAN
6	·*·All·rights·reserved.	8	·*·All·rights·reserved.
7	·*	9	·*
8	·*·This·file·is·part·of·RedirFS.	10	·*·This·file·is·part·of·RedirFS.
⋮		⋮
142	» struct·rfs_flt·*rflt·=·filter;	144	» struct·rfs_flt·*rflt·=·filter;
143	» struct·rfs_path·*rpath;	145	» struct·rfs_path·*rpath;
144	» struct·redirfs_path_info·info;	146	» struct·redirfs_path_info·info;
		147+
		148+	#if·(LINUX_VERSION_CODE·<·KERNEL_VERSION(3,19,0))
145	» struct·nameidata·nd;	149	» struct·nameidata·nd;
		150+	#else
		151+	» struct·rfs_nameidata·nd;
		152+	#endif
		153+
146	» char·*path;	154	» char·*path;
147	» char·type;	155	» char·type;
148	» int·rv;	156	» int·rv;
⋮		⋮
167	» » return·-EINVAL;	175	» » return·-EINVAL;
168	» }	176	» }
169		177
170-	» rv·=·path_lookup(path,·LOOKUP_FOLLOW,·&nd);	178+	» rv·=·rfs_path_lookup(path,·&nd);
171	» if·(rv)·{	179	» if·(rv)·{
172	» » kfree(path);	180	» » kfree(path);
173	» » return·rv;	181	» » return·rv;