Attachment #83856 for bug #127073

Lines 64-70 Link Here

(-)unionfs-1.1.3.old/copyup.c (+16 lines)
64	name_list_orig = name_list;	64	name_list_orig = name_list;
65	while (*name_list) {	65	while (*name_list) {
66	ssize_t size;	66	ssize_t size;
		67	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		68	mutex_lock(&old_hidden_dentry->d_inode->i_mutex);
		69	#else
67	down(&old_hidden_dentry->d_inode->i_sem);	70	down(&old_hidden_dentry->d_inode->i_sem);
		71	#endif
68	err = security_inode_getxattr(old_hidden_dentry, name_list);	72	err = security_inode_getxattr(old_hidden_dentry, name_list);
69	if (err)	73	if (err)
70	size = err;	74	size = err;
Lines 73-79 Link Here
73	old_hidden_dentry->d_inode->i_op->	77	old_hidden_dentry->d_inode->i_op->
74	getxattr(old_hidden_dentry, name_list, attr_value,	78	getxattr(old_hidden_dentry, name_list, attr_value,
75	XATTR_SIZE_MAX);	79	XATTR_SIZE_MAX);
		80	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		81	mutex_unlock(&old_hidden_dentry->d_inode->i_mutex);
		82	#else
76	up(&old_hidden_dentry->d_inode->i_sem);	83	up(&old_hidden_dentry->d_inode->i_sem);
		84	#endif
77	if (size < 0) {	85	if (size < 0) {
78	err = size;	86	err = size;
79	goto out;	87	goto out;
Lines 84-90 Link Here
84	goto out;	92	goto out;
85	}	93	}
86		94
		95	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		96	mutex_lock(&new_hidden_dentry->d_inode->i_mutex);
		97	#else
87	down(&new_hidden_dentry->d_inode->i_sem);	98	down(&new_hidden_dentry->d_inode->i_sem);
		99	#endif
88		100
89	err =	101	err =
90	security_inode_setxattr(old_hidden_dentry, name_list,	102	security_inode_setxattr(old_hidden_dentry, name_list,
Lines 101-107 Link Here
101	attr_value, size,	113	attr_value, size,
102	0);	114	0);
103	}	115	}
		116	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		117	mutex_unlock(&new_hidden_dentry->d_inode->i_mutex);
		118	#else
104	up(&new_hidden_dentry->d_inode->i_sem);	119	up(&new_hidden_dentry->d_inode->i_sem);
		120	#endif
105		121
106	if (err < 0)	122	if (err < 0)
107	goto out;	123	goto out;

Lines 108-114 Link Here

(-)unionfs-1.1.3.old/dentry.c (+9 lines)
108	interpose_flag = INTERPOSE_REVAL_NEG;	108	interpose_flag = INTERPOSE_REVAL_NEG;
109	if (positive) {	109	if (positive) {
110	interpose_flag = INTERPOSE_REVAL;	110	interpose_flag = INTERPOSE_REVAL;
		111	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		112	mutex_lock(&dentry->d_inode->i_mutex);
		113	#else
111	down(&dentry->d_inode->i_sem);	114	down(&dentry->d_inode->i_sem);
		115	#endif
		116
112	bstart = ibstart(dentry->d_inode);	117	bstart = ibstart(dentry->d_inode);
113	bend = ibend(dentry->d_inode);	118	bend = ibend(dentry->d_inode);
114	if (bstart >= 0) {	119	if (bstart >= 0) {
Lines 126-132 Link Here
126	itohi_ptr(dentry->d_inode) = NULL;	131	itohi_ptr(dentry->d_inode) = NULL;
127	ibstart(dentry->d_inode) = -1;	132	ibstart(dentry->d_inode) = -1;
128	ibend(dentry->d_inode) = -1;	133	ibend(dentry->d_inode) = -1;
		134	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		135	mutex_unlock(&dentry->d_inode->i_mutex);
		136	#else
129	up(&dentry->d_inode->i_sem);	137	up(&dentry->d_inode->i_sem);
		138	#endif
130	}	139	}
131		140
132	result = unionfs_lookup_backend(dentry, interpose_flag);	141	result = unionfs_lookup_backend(dentry, interpose_flag);

Lines 78-88 Link Here

(-)unionfs-1.1.3.old/dirhelper.c (-1 / +9 lines)
78	continue;	78	continue;
79	}	79	}
80		80
		81	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		82	mutex_lock(&hidden_dir_dentry->d_inode->i_mutex);
		83	#else
81	down(&hidden_dir_dentry->d_inode->i_sem);	84	down(&hidden_dir_dentry->d_inode->i_sem);
		85	#endif
82	err =	86	err =
83	vfs_unlink(hidden_dir_dentry->d_inode,	87	vfs_unlink(hidden_dir_dentry->d_inode,
84	hidden_dentry);	88	hidden_dentry);
85	up(&hidden_dir_dentry->d_inode->i_sem);	89	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		90	mutex_unlock(&hidden_dir_dentry->d_inode->i_mutex);
		91	#else
		92	down(&hidden_dir_dentry->d_inode->i_sem);
		93	#endif
86	DPUT(hidden_dentry);	94	DPUT(hidden_dentry);
87		95
88	if (err && !IS_COPYUP_ERR(err))	96	if (err && !IS_COPYUP_ERR(err))

Lines 264-273 Link Here

(-)unionfs-1.1.3.old/file.c (+8 lines)
264	if (!hidden_file->f_op \|\| !hidden_file->f_op->fsync)	264	if (!hidden_file->f_op \|\| !hidden_file->f_op->fsync)
265	goto out;	265	goto out;
266		266
		267	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		268	mutex_lock(&hidden_file->f_dentry->d_inode->i_mutex);
		269	#else
267	down(&hidden_file->f_dentry->d_inode->i_sem);	270	down(&hidden_file->f_dentry->d_inode->i_sem);
		271	#endif
268	err = hidden_file->f_op->fsync(hidden_file, hidden_file->f_dentry,	272	err = hidden_file->f_op->fsync(hidden_file, hidden_file->f_dentry,
269	datasync);	273	datasync);
		274	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		275	mutex_unlock(&hidden_file->f_dentry->d_inode->i_mutex);
		276	#else
270	up(&hidden_file->f_dentry->d_inode->i_sem);	277	up(&hidden_file->f_dentry->d_inode->i_sem);
		278	#endif
271		279
272	out:	280	out:
273	print_exit_status(err);	281	print_exit_status(err);

Lines 81-87 Link Here

(-)unionfs-1.1.3.old/inode.c (+18 lines)
81	struct dentry *hidden_dir_dentry;	81	struct dentry *hidden_dir_dentry;
82	struct iattr newattrs;	82	struct iattr newattrs;
83		83
		84	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		85	mutex_lock(&whiteout_dentry->d_inode->i_mutex);
		86	#else
84	down(&whiteout_dentry->d_inode->i_sem);	87	down(&whiteout_dentry->d_inode->i_sem);
		88	#endif
85	newattrs.ia_valid = ATTR_CTIME \| ATTR_MODE \| ATTR_ATIME	89	newattrs.ia_valid = ATTR_CTIME \| ATTR_MODE \| ATTR_ATIME
86	\| ATTR_MTIME \| ATTR_UID \| ATTR_GID \| ATTR_FORCE	90	\| ATTR_MTIME \| ATTR_UID \| ATTR_GID \| ATTR_FORCE
87	\| ATTR_KILL_SUID \| ATTR_KILL_SGID;	91	\| ATTR_KILL_SUID \| ATTR_KILL_SGID;
Lines 97-103 Link Here
97		101
98	err = notify_change(whiteout_dentry, &newattrs);	102	err = notify_change(whiteout_dentry, &newattrs);
99		103
		104	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		105	mutex_unlock(&whiteout_dentry->d_inode->i_mutex);
		106	#else
100	up(&whiteout_dentry->d_inode->i_sem);	107	up(&whiteout_dentry->d_inode->i_sem);
		108	#endif
101		109
102	if (err)	110	if (err)
103	printk(KERN_WARNING	111	printk(KERN_WARNING
Lines 594-603 Link Here
594	err = PTR_ERR(whiteout_dentry);	602	err = PTR_ERR(whiteout_dentry);
595	goto out;	603	goto out;
596	}	604	}
		605	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		606	mutex_lock(&hidden_dentry->d_inode->i_mutex);
		607	#else
597	down(&hidden_dentry->d_inode->i_sem);	608	down(&hidden_dentry->d_inode->i_sem);
		609	#endif
		610
598	err = vfs_create(hidden_dentry->d_inode,	611	err = vfs_create(hidden_dentry->d_inode,
599	whiteout_dentry, 0600, NULL);	612	whiteout_dentry, 0600, NULL);
		613	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		614	mutex_unlock(&hidden_dentry->d_inode->i_mutex);
		615	#else
600	up(&hidden_dentry->d_inode->i_sem);	616	up(&hidden_dentry->d_inode->i_sem);
		617	#endif
		618
601	DPUT(whiteout_dentry);	619	DPUT(whiteout_dentry);
602		620
603	if (err) {	621	if (err) {

Lines 103-109 Link Here

(-)unionfs-1.1.3.old/main.c (+9 lines)
103	}	103	}
104	}	104	}
105		105
		106	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		107	mutex_lock(&inode->i_mutex);
		108	#else
106	down(&inode->i_sem);	109	down(&inode->i_sem);
		110	#endif
		111
107	if (atomic_read(&inode->i_count) > 1)	112	if (atomic_read(&inode->i_count) > 1)
108	goto skip;	113	goto skip;
109		114
Lines 172-178 Link Here
172		177
173	fist_print_dentry("Leaving unionfs_interpose", dentry);	178	fist_print_dentry("Leaving unionfs_interpose", dentry);
174	fist_print_inode("Leaving unionfs_interpose", inode);	179	fist_print_inode("Leaving unionfs_interpose", inode);
		180	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		181	mutex_unlock(&inode->i_mutex);
		182	#else
175	up(&inode->i_sem);	183	up(&inode->i_sem);
		184	#endif
176		185
177	out:	186	out:
178	print_exit_status(err);	187	print_exit_status(err);

Lines 776-788 Link Here

(-)unionfs-1.1.3.old/unionfs.h (+9 lines)
776	{	776	{
777	struct dentry *dir = DGET(dentry->d_parent);	777	struct dentry *dir = DGET(dentry->d_parent);
778		778
		779	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		780	mutex_lock(&dir->d_inode->i_mutex);
		781	#else
779	down(&dir->d_inode->i_sem);	782	down(&dir->d_inode->i_sem);
		783	#endif
		784
780	return dir;	785	return dir;
781	}	786	}
782		787
783	static inline void unlock_dir(struct dentry *dir)	788	static inline void unlock_dir(struct dentry *dir)
784	{	789	{
		790	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		791	mutex_unlock(&dir->d_inode->i_mutex);
		792	#else
785	up(&dir->d_inode->i_sem);	793	up(&dir->d_inode->i_sem);
		794	#endif
786	DPUT(dir);	795	DPUT(dir);
787	}	796	}
788		797

Lines 77-90 Link Here

(-)unionfs-1.1.3.old/xattr.c (+32 lines)
77		77
78	encoded_value = (char *)value;	78	encoded_value = (char *)value;
79		79
		80	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		81	mutex_lock(&hidden_dentry->d_inode->i_mutex);
		82	#else
80	down(&hidden_dentry->d_inode->i_sem);	83	down(&hidden_dentry->d_inode->i_sem);
		84	#endif
81	/* lock_kernel() already done by caller. */	85	/* lock_kernel() already done by caller. */
82	err =	86	err =
83	hidden_dentry->d_inode->i_op->getxattr(hidden_dentry,	87	hidden_dentry->d_inode->i_op->getxattr(hidden_dentry,
84	encoded_name,	88	encoded_name,
85	encoded_value, size);	89	encoded_value, size);
86	/* unlock_kernel() will be done by caller. */	90	/* unlock_kernel() will be done by caller. */
		91	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		92	mutex_unlock(&hidden_dentry->d_inode->i_mutex);
		93	#else
87	up(&hidden_dentry->d_inode->i_sem);	94	up(&hidden_dentry->d_inode->i_sem);
		95	#endif
88		96
89	}	97	}
90		98
Lines 112-123 Link Here
112	name, (unsigned long)size, flags);	120	name, (unsigned long)size, flags);
113		121
114	if (hidden_dentry->d_inode->i_op->setxattr) {	122	if (hidden_dentry->d_inode->i_op->setxattr) {
		123	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		124	mutex_lock(&hidden_dentry->d_inode->i_mutex);
		125	#else
115	down(&hidden_dentry->d_inode->i_sem);	126	down(&hidden_dentry->d_inode->i_sem);
		127	#endif
116	/* lock_kernel() already done by caller. */	128	/* lock_kernel() already done by caller. */
117	err = hidden_dentry->d_inode->i_op->	129	err = hidden_dentry->d_inode->i_op->
118	setxattr(hidden_dentry, name, value, size, flags);	130	setxattr(hidden_dentry, name, value, size, flags);
119	/* unlock_kernel() will be done by caller. */	131	/* unlock_kernel() will be done by caller. */
		132	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		133	mutex_unlock(&hidden_dentry->d_inode->i_mutex);
		134	#else
120	up(&hidden_dentry->d_inode->i_sem);	135	up(&hidden_dentry->d_inode->i_sem);
		136	#endif
121	}	137	}
122		138
123	unlock_dentry(dentry);	139	unlock_dentry(dentry);
Lines 143-155 Link Here
143	if (hidden_dentry->d_inode->i_op->removexattr) {	159	if (hidden_dentry->d_inode->i_op->removexattr) {
144	encoded_name = (char *)name;	160	encoded_name = (char *)name;
145		161
		162	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		163	mutex_lock(&hidden_dentry->d_inode->i_mutex);
		164	#else
146	down(&hidden_dentry->d_inode->i_sem);	165	down(&hidden_dentry->d_inode->i_sem);
		166	#endif
147	/* lock_kernel() already done by caller. */	167	/* lock_kernel() already done by caller. */
148	err =	168	err =
149	hidden_dentry->d_inode->i_op->removexattr(hidden_dentry,	169	hidden_dentry->d_inode->i_op->removexattr(hidden_dentry,
150	encoded_name);	170	encoded_name);
151	/* unlock_kernel() will be done by caller. */	171	/* unlock_kernel() will be done by caller. */
		172	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		173	mutex_unlock(&hidden_dentry->d_inode->i_mutex);
		174	#else
152	up(&hidden_dentry->d_inode->i_sem);	175	up(&hidden_dentry->d_inode->i_sem);
		176	#endif
153	}	177	}
154		178
155	unlock_dentry(dentry);	179	unlock_dentry(dentry);
Lines 173-185 Link Here
173		197
174	if (hidden_dentry->d_inode->i_op->listxattr) {	198	if (hidden_dentry->d_inode->i_op->listxattr) {
175	encoded_list = list;	199	encoded_list = list;
		200	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		201	mutex_lock(&hidden_dentry->d_inode->i_mutex);
		202	#else
176	down(&hidden_dentry->d_inode->i_sem);	203	down(&hidden_dentry->d_inode->i_sem);
		204	#endif
177	/* lock_kernel() already done by caller. */	205	/* lock_kernel() already done by caller. */
178	err =	206	err =
179	hidden_dentry->d_inode->i_op->listxattr(hidden_dentry,	207	hidden_dentry->d_inode->i_op->listxattr(hidden_dentry,
180	encoded_list, size);	208	encoded_list, size);
181	/* unlock_kernel() will be done by caller. */	209	/* unlock_kernel() will be done by caller. */
		210	#if LINUX_VERSION_CODE > KERNEL_VERSION(2,6,15)
		211	mutex_unlock(&hidden_dentry->d_inode->i_mutex);
		212	#else
182	up(&hidden_dentry->d_inode->i_sem);	213	up(&hidden_dentry->d_inode->i_sem);
		214	#endif
183	}	215	}
184		216
185	unlock_dentry(dentry);	217	unlock_dentry(dentry);

Return to bug 127073