Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit eab1df71a0ef6d333b9b826deaa0d0eb4b4f69dc

Authored by David Howells 2008-02-07 16:15:43 +0800

Committed by Linus Torvalds 2008-02-08 00:42:28 +0800

Exists in master and in 7 other branches

iget: stop JFS from using iget() and read_inode()

Stop the JFS filesystem from using iget() and read_inode().  Replace
jfs_read_inode() with jfs_iget(), and call that instead of iget().  jfs_iget()
then uses iget_locked() directly and returns a proper error code instead of an
inode in the event of an error.

jfs_fill_super() returns any error incurred when getting the root inode
instead of EINVAL.

Signed-off-by: David Howells <dhowells@redhat.com>
Acked-by: Dave Kleikamp <shaggy@linux.vnet.ibm.com>
Acked-by: Christoph Hellwig <hch@lst.de>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

Showing 4 changed files with 40 additions and 31 deletions Inline Diff

fs/jfs/inode.c
fs/jfs/jfs_inode.h
fs/jfs/namei.c
fs/jfs/super.c

fs/jfs/inode.c

Diff comments View file @ eab1df7

1	/*	1	/*
2	* Copyright (C) International Business Machines Corp., 2000-2004	2	* Copyright (C) International Business Machines Corp., 2000-2004
3	* Portions Copyright (C) Christoph Hellwig, 2001-2002	3	* Portions Copyright (C) Christoph Hellwig, 2001-2002
4	*	4	*
5	* This program is free software; you can redistribute it and/or modify	5	* This program is free software; you can redistribute it and/or modify
6	* it under the terms of the GNU General Public License as published by	6	* it under the terms of the GNU General Public License as published by
7	* the Free Software Foundation; either version 2 of the License, or	7	* the Free Software Foundation; either version 2 of the License, or
8	* (at your option) any later version.	8	* (at your option) any later version.
9	*	9	*
10	* This program is distributed in the hope that it will be useful,	10	* This program is distributed in the hope that it will be useful,
11	* but WITHOUT ANY WARRANTY; without even the implied warranty of	11	* but WITHOUT ANY WARRANTY; without even the implied warranty of
12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See	12	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
13	* the GNU General Public License for more details.	13	* the GNU General Public License for more details.
14	*	14	*
15	* You should have received a copy of the GNU General Public License	15	* You should have received a copy of the GNU General Public License
16	* along with this program; if not, write to the Free Software	16	* along with this program; if not, write to the Free Software
17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	17	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
18	*/	18	*/
19		19
20	#include <linux/fs.h>	20	#include <linux/fs.h>
21	#include <linux/mpage.h>	21	#include <linux/mpage.h>
22	#include <linux/buffer_head.h>	22	#include <linux/buffer_head.h>
23	#include <linux/pagemap.h>	23	#include <linux/pagemap.h>
24	#include <linux/quotaops.h>	24	#include <linux/quotaops.h>
25	#include "jfs_incore.h"	25	#include "jfs_incore.h"
26	#include "jfs_inode.h"	26	#include "jfs_inode.h"
27	#include "jfs_filsys.h"	27	#include "jfs_filsys.h"
28	#include "jfs_imap.h"	28	#include "jfs_imap.h"
29	#include "jfs_extent.h"	29	#include "jfs_extent.h"
30	#include "jfs_unicode.h"	30	#include "jfs_unicode.h"
31	#include "jfs_debug.h"	31	#include "jfs_debug.h"
32		32
33		33
34	void jfs_read_inode(struct inode *inode)	34	struct inode jfs_iget(struct super_block sb, unsigned long ino)
35	{	35	{
36	if (diRead(inode)) {	36	struct inode *inode;
37	make_bad_inode(inode);	37	int ret;
38	return;	38
		39	inode = iget_locked(sb, ino);
		40	if (!inode)
		41	return ERR_PTR(-ENOMEM);
		42	if (!(inode->i_state & I_NEW))
		43	return inode;
		44
		45	ret = diRead(inode);
		46	if (ret < 0) {
		47	iget_failed(inode);
		48	return ERR_PTR(ret);
39	}	49	}
40		50
41	if (S_ISREG(inode->i_mode)) {	51	if (S_ISREG(inode->i_mode)) {
42	inode->i_op = &jfs_file_inode_operations;	52	inode->i_op = &jfs_file_inode_operations;
43	inode->i_fop = &jfs_file_operations;	53	inode->i_fop = &jfs_file_operations;
44	inode->i_mapping->a_ops = &jfs_aops;	54	inode->i_mapping->a_ops = &jfs_aops;
45	} else if (S_ISDIR(inode->i_mode)) {	55	} else if (S_ISDIR(inode->i_mode)) {
46	inode->i_op = &jfs_dir_inode_operations;	56	inode->i_op = &jfs_dir_inode_operations;
47	inode->i_fop = &jfs_dir_operations;	57	inode->i_fop = &jfs_dir_operations;
48	} else if (S_ISLNK(inode->i_mode)) {	58	} else if (S_ISLNK(inode->i_mode)) {
49	if (inode->i_size >= IDATASIZE) {	59	if (inode->i_size >= IDATASIZE) {
50	inode->i_op = &page_symlink_inode_operations;	60	inode->i_op = &page_symlink_inode_operations;
51	inode->i_mapping->a_ops = &jfs_aops;	61	inode->i_mapping->a_ops = &jfs_aops;
52	} else	62	} else
53	inode->i_op = &jfs_symlink_inode_operations;	63	inode->i_op = &jfs_symlink_inode_operations;
54	} else {	64	} else {
55	inode->i_op = &jfs_file_inode_operations;	65	inode->i_op = &jfs_file_inode_operations;
56	init_special_inode(inode, inode->i_mode, inode->i_rdev);	66	init_special_inode(inode, inode->i_mode, inode->i_rdev);
57	}	67	}
		68	unlock_new_inode(inode);
		69	return inode;
58	}	70	}
59		71
60	/*	72	/*
61	* Workhorse of both fsync & write_inode	73	* Workhorse of both fsync & write_inode
62	*/	74	*/
63	int jfs_commit_inode(struct inode *inode, int wait)	75	int jfs_commit_inode(struct inode *inode, int wait)
64	{	76	{
65	int rc = 0;	77	int rc = 0;
66	tid_t tid;	78	tid_t tid;
67	static int noisy = 5;	79	static int noisy = 5;
68		80
69	jfs_info("In jfs_commit_inode, inode = 0x%p", inode);	81	jfs_info("In jfs_commit_inode, inode = 0x%p", inode);
70		82
71	/*	83	/*
72	* Don't commit if inode has been committed since last being	84	* Don't commit if inode has been committed since last being
73	* marked dirty, or if it has been deleted.	85	* marked dirty, or if it has been deleted.
74	*/	86	*/
75	if (inode->i_nlink == 0 \|\| !test_cflag(COMMIT_Dirty, inode))	87	if (inode->i_nlink == 0 \|\| !test_cflag(COMMIT_Dirty, inode))
76	return 0;	88	return 0;
77		89
78	if (isReadOnly(inode)) {	90	if (isReadOnly(inode)) {
79	/* kernel allows writes to devices on read-only	91	/* kernel allows writes to devices on read-only
80	* partitions and may think inode is dirty	92	* partitions and may think inode is dirty
81	*/	93	*/
82	if (!special_file(inode->i_mode) && noisy) {	94	if (!special_file(inode->i_mode) && noisy) {
83	jfs_err("jfs_commit_inode(0x%p) called on "	95	jfs_err("jfs_commit_inode(0x%p) called on "
84	"read-only volume", inode);	96	"read-only volume", inode);
85	jfs_err("Is remount racy?");	97	jfs_err("Is remount racy?");
86	noisy--;	98	noisy--;
87	}	99	}
88	return 0;	100	return 0;
89	}	101	}
90		102
91	tid = txBegin(inode->i_sb, COMMIT_INODE);	103	tid = txBegin(inode->i_sb, COMMIT_INODE);
92	mutex_lock(&JFS_IP(inode)->commit_mutex);	104	mutex_lock(&JFS_IP(inode)->commit_mutex);
93		105
94	/*	106	/*
95	* Retest inode state after taking commit_mutex	107	* Retest inode state after taking commit_mutex
96	*/	108	*/
97	if (inode->i_nlink && test_cflag(COMMIT_Dirty, inode))	109	if (inode->i_nlink && test_cflag(COMMIT_Dirty, inode))
98	rc = txCommit(tid, 1, &inode, wait ? COMMIT_SYNC : 0);	110	rc = txCommit(tid, 1, &inode, wait ? COMMIT_SYNC : 0);
99		111
100	txEnd(tid);	112	txEnd(tid);
101	mutex_unlock(&JFS_IP(inode)->commit_mutex);	113	mutex_unlock(&JFS_IP(inode)->commit_mutex);
102	return rc;	114	return rc;
103	}	115	}
104		116
105	int jfs_write_inode(struct inode *inode, int wait)	117	int jfs_write_inode(struct inode *inode, int wait)
106	{	118	{
107	if (test_cflag(COMMIT_Nolink, inode))	119	if (test_cflag(COMMIT_Nolink, inode))
108	return 0;	120	return 0;
109	/*	121	/*
110	* If COMMIT_DIRTY is not set, the inode isn't really dirty.	122	* If COMMIT_DIRTY is not set, the inode isn't really dirty.
111	* It has been committed since the last change, but was still	123	* It has been committed since the last change, but was still
112	* on the dirty inode list.	124	* on the dirty inode list.
113	*/	125	*/
114	if (!test_cflag(COMMIT_Dirty, inode)) {	126	if (!test_cflag(COMMIT_Dirty, inode)) {
115	/* Make sure committed changes hit the disk */	127	/* Make sure committed changes hit the disk */
116	jfs_flush_journal(JFS_SBI(inode->i_sb)->log, wait);	128	jfs_flush_journal(JFS_SBI(inode->i_sb)->log, wait);
117	return 0;	129	return 0;
118	}	130	}
119		131
120	if (jfs_commit_inode(inode, wait)) {	132	if (jfs_commit_inode(inode, wait)) {
121	jfs_err("jfs_write_inode: jfs_commit_inode failed!");	133	jfs_err("jfs_write_inode: jfs_commit_inode failed!");
122	return -EIO;	134	return -EIO;
123	} else	135	} else
124	return 0;	136	return 0;
125	}	137	}
126		138
127	void jfs_delete_inode(struct inode *inode)	139	void jfs_delete_inode(struct inode *inode)
128	{	140	{
129	jfs_info("In jfs_delete_inode, inode = 0x%p", inode);	141	jfs_info("In jfs_delete_inode, inode = 0x%p", inode);
130		142
131	if (!is_bad_inode(inode) &&	143	if (!is_bad_inode(inode) &&
132	(JFS_IP(inode)->fileset == FILESYSTEM_I)) {	144	(JFS_IP(inode)->fileset == FILESYSTEM_I)) {
133	truncate_inode_pages(&inode->i_data, 0);	145	truncate_inode_pages(&inode->i_data, 0);
134		146
135	if (test_cflag(COMMIT_Freewmap, inode))	147	if (test_cflag(COMMIT_Freewmap, inode))
136	jfs_free_zero_link(inode);	148	jfs_free_zero_link(inode);
137		149
138	diFree(inode);	150	diFree(inode);
139		151
140	/*	152	/*
141	* Free the inode from the quota allocation.	153	* Free the inode from the quota allocation.
142	*/	154	*/
143	DQUOT_INIT(inode);	155	DQUOT_INIT(inode);
144	DQUOT_FREE_INODE(inode);	156	DQUOT_FREE_INODE(inode);
145	DQUOT_DROP(inode);	157	DQUOT_DROP(inode);
146	}	158	}
147		159
148	clear_inode(inode);	160	clear_inode(inode);
149	}	161	}
150		162
151	void jfs_dirty_inode(struct inode *inode)	163	void jfs_dirty_inode(struct inode *inode)
152	{	164	{
153	static int noisy = 5;	165	static int noisy = 5;
154		166
155	if (isReadOnly(inode)) {	167	if (isReadOnly(inode)) {
156	if (!special_file(inode->i_mode) && noisy) {	168	if (!special_file(inode->i_mode) && noisy) {
157	/* kernel allows writes to devices on read-only	169	/* kernel allows writes to devices on read-only
158	* partitions and may try to mark inode dirty	170	* partitions and may try to mark inode dirty
159	*/	171	*/
160	jfs_err("jfs_dirty_inode called on read-only volume");	172	jfs_err("jfs_dirty_inode called on read-only volume");
161	jfs_err("Is remount racy?");	173	jfs_err("Is remount racy?");
162	noisy--;	174	noisy--;
163	}	175	}
164	return;	176	return;
165	}	177	}
166		178
167	set_cflag(COMMIT_Dirty, inode);	179	set_cflag(COMMIT_Dirty, inode);
168	}	180	}
169		181
170	int jfs_get_block(struct inode *ip, sector_t lblock,	182	int jfs_get_block(struct inode *ip, sector_t lblock,
171	struct buffer_head *bh_result, int create)	183	struct buffer_head *bh_result, int create)
172	{	184	{
173	s64 lblock64 = lblock;	185	s64 lblock64 = lblock;
174	int rc = 0;	186	int rc = 0;
175	xad_t xad;	187	xad_t xad;
176	s64 xaddr;	188	s64 xaddr;
177	int xflag;	189	int xflag;
178	s32 xlen = bh_result->b_size >> ip->i_blkbits;	190	s32 xlen = bh_result->b_size >> ip->i_blkbits;
179		191
180	/*	192	/*
181	* Take appropriate lock on inode	193	* Take appropriate lock on inode
182	*/	194	*/
183	if (create)	195	if (create)
184	IWRITE_LOCK(ip, RDWRLOCK_NORMAL);	196	IWRITE_LOCK(ip, RDWRLOCK_NORMAL);
185	else	197	else
186	IREAD_LOCK(ip, RDWRLOCK_NORMAL);	198	IREAD_LOCK(ip, RDWRLOCK_NORMAL);
187		199
188	if (((lblock64 << ip->i_sb->s_blocksize_bits) < ip->i_size) &&	200	if (((lblock64 << ip->i_sb->s_blocksize_bits) < ip->i_size) &&
189	(!xtLookup(ip, lblock64, xlen, &xflag, &xaddr, &xlen, 0)) &&	201	(!xtLookup(ip, lblock64, xlen, &xflag, &xaddr, &xlen, 0)) &&
190	xaddr) {	202	xaddr) {
191	if (xflag & XAD_NOTRECORDED) {	203	if (xflag & XAD_NOTRECORDED) {
192	if (!create)	204	if (!create)
193	/*	205	/*
194	* Allocated but not recorded, read treats	206	* Allocated but not recorded, read treats
195	* this as a hole	207	* this as a hole
196	*/	208	*/
197	goto unlock;	209	goto unlock;
198	#ifdef _JFS_4K	210	#ifdef _JFS_4K
199	XADoffset(&xad, lblock64);	211	XADoffset(&xad, lblock64);
200	XADlength(&xad, xlen);	212	XADlength(&xad, xlen);
201	XADaddress(&xad, xaddr);	213	XADaddress(&xad, xaddr);
202	#else /* _JFS_4K */	214	#else /* _JFS_4K */
203	/*	215	/*
204	* As long as block size = 4K, this isn't a problem.	216	* As long as block size = 4K, this isn't a problem.
205	* We should mark the whole page not ABNR, but how	217	* We should mark the whole page not ABNR, but how
206	* will we know to mark the other blocks BH_New?	218	* will we know to mark the other blocks BH_New?
207	*/	219	*/
208	BUG();	220	BUG();
209	#endif /* _JFS_4K */	221	#endif /* _JFS_4K */
210	rc = extRecord(ip, &xad);	222	rc = extRecord(ip, &xad);
211	if (rc)	223	if (rc)
212	goto unlock;	224	goto unlock;
213	set_buffer_new(bh_result);	225	set_buffer_new(bh_result);
214	}	226	}
215		227
216	map_bh(bh_result, ip->i_sb, xaddr);	228	map_bh(bh_result, ip->i_sb, xaddr);
217	bh_result->b_size = xlen << ip->i_blkbits;	229	bh_result->b_size = xlen << ip->i_blkbits;
218	goto unlock;	230	goto unlock;
219	}	231	}
220	if (!create)	232	if (!create)
221	goto unlock;	233	goto unlock;
222		234
223	/*	235	/*
224	* Allocate a new block	236	* Allocate a new block
225	*/	237	*/
226	#ifdef _JFS_4K	238	#ifdef _JFS_4K
227	if ((rc = extHint(ip, lblock64 << ip->i_sb->s_blocksize_bits, &xad)))	239	if ((rc = extHint(ip, lblock64 << ip->i_sb->s_blocksize_bits, &xad)))
228	goto unlock;	240	goto unlock;
229	rc = extAlloc(ip, xlen, lblock64, &xad, false);	241	rc = extAlloc(ip, xlen, lblock64, &xad, false);
230	if (rc)	242	if (rc)
231	goto unlock;	243	goto unlock;
232		244
233	set_buffer_new(bh_result);	245	set_buffer_new(bh_result);
234	map_bh(bh_result, ip->i_sb, addressXAD(&xad));	246	map_bh(bh_result, ip->i_sb, addressXAD(&xad));
235	bh_result->b_size = lengthXAD(&xad) << ip->i_blkbits;	247	bh_result->b_size = lengthXAD(&xad) << ip->i_blkbits;
236		248
237	#else /* _JFS_4K */	249	#else /* _JFS_4K */
238	/*	250	/*
239	* We need to do whatever it takes to keep all but the last buffers	251	* We need to do whatever it takes to keep all but the last buffers
240	* in 4K pages - see jfs_write.c	252	* in 4K pages - see jfs_write.c
241	*/	253	*/
242	BUG();	254	BUG();
243	#endif /* _JFS_4K */	255	#endif /* _JFS_4K */
244		256
245	unlock:	257	unlock:
246	/*	258	/*
247	* Release lock on inode	259	* Release lock on inode
248	*/	260	*/
249	if (create)	261	if (create)
250	IWRITE_UNLOCK(ip);	262	IWRITE_UNLOCK(ip);
251	else	263	else
252	IREAD_UNLOCK(ip);	264	IREAD_UNLOCK(ip);
253	return rc;	265	return rc;
254	}	266	}
255		267
256	static int jfs_writepage(struct page page, struct writeback_control wbc)	268	static int jfs_writepage(struct page page, struct writeback_control wbc)
257	{	269	{
258	return block_write_full_page(page, jfs_get_block, wbc);	270	return block_write_full_page(page, jfs_get_block, wbc);
259	}	271	}
260		272
261	static int jfs_writepages(struct address_space *mapping,	273	static int jfs_writepages(struct address_space *mapping,
262	struct writeback_control *wbc)	274	struct writeback_control *wbc)
263	{	275	{
264	return mpage_writepages(mapping, wbc, jfs_get_block);	276	return mpage_writepages(mapping, wbc, jfs_get_block);
265	}	277	}
266		278
267	static int jfs_readpage(struct file file, struct page page)	279	static int jfs_readpage(struct file file, struct page page)
268	{	280	{
269	return mpage_readpage(page, jfs_get_block);	281	return mpage_readpage(page, jfs_get_block);
270	}	282	}
271		283
272	static int jfs_readpages(struct file file, struct address_space mapping,	284	static int jfs_readpages(struct file file, struct address_space mapping,
273	struct list_head *pages, unsigned nr_pages)	285	struct list_head *pages, unsigned nr_pages)
274	{	286	{
275	return mpage_readpages(mapping, pages, nr_pages, jfs_get_block);	287	return mpage_readpages(mapping, pages, nr_pages, jfs_get_block);
276	}	288	}
277		289
278	static int jfs_write_begin(struct file file, struct address_space mapping,	290	static int jfs_write_begin(struct file file, struct address_space mapping,
279	loff_t pos, unsigned len, unsigned flags,	291	loff_t pos, unsigned len, unsigned flags,
280	struct page pagep, void fsdata)	292	struct page pagep, void fsdata)
281	{	293	{
282	return nobh_write_begin(file, mapping, pos, len, flags, pagep, fsdata,	294	return nobh_write_begin(file, mapping, pos, len, flags, pagep, fsdata,
283	jfs_get_block);	295	jfs_get_block);
284	}	296	}
285		297
286	static sector_t jfs_bmap(struct address_space *mapping, sector_t block)	298	static sector_t jfs_bmap(struct address_space *mapping, sector_t block)
287	{	299	{
288	return generic_block_bmap(mapping, block, jfs_get_block);	300	return generic_block_bmap(mapping, block, jfs_get_block);
289	}	301	}
290		302
291	static ssize_t jfs_direct_IO(int rw, struct kiocb *iocb,	303	static ssize_t jfs_direct_IO(int rw, struct kiocb *iocb,
292	const struct iovec *iov, loff_t offset, unsigned long nr_segs)	304	const struct iovec *iov, loff_t offset, unsigned long nr_segs)
293	{	305	{
294	struct file *file = iocb->ki_filp;	306	struct file *file = iocb->ki_filp;
295	struct inode *inode = file->f_mapping->host;	307	struct inode *inode = file->f_mapping->host;
296		308
297	return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,	309	return blockdev_direct_IO(rw, iocb, inode, inode->i_sb->s_bdev, iov,
298	offset, nr_segs, jfs_get_block, NULL);	310	offset, nr_segs, jfs_get_block, NULL);
299	}	311	}
300		312
301	const struct address_space_operations jfs_aops = {	313	const struct address_space_operations jfs_aops = {
302	.readpage = jfs_readpage,	314	.readpage = jfs_readpage,
303	.readpages = jfs_readpages,	315	.readpages = jfs_readpages,
304	.writepage = jfs_writepage,	316	.writepage = jfs_writepage,
305	.writepages = jfs_writepages,	317	.writepages = jfs_writepages,
306	.sync_page = block_sync_page,	318	.sync_page = block_sync_page,
307	.write_begin = jfs_write_begin,	319	.write_begin = jfs_write_begin,
308	.write_end = nobh_write_end,	320	.write_end = nobh_write_end,
309	.bmap = jfs_bmap,	321	.bmap = jfs_bmap,
310	.direct_IO = jfs_direct_IO,	322	.direct_IO = jfs_direct_IO,
311	};	323	};
312		324
313	/*	325	/*
314	* Guts of jfs_truncate. Called with locks already held. Can be called	326	* Guts of jfs_truncate. Called with locks already held. Can be called
315	* with directory for truncating directory index table.	327	* with directory for truncating directory index table.
316	*/	328	*/
317	void jfs_truncate_nolock(struct inode *ip, loff_t length)	329	void jfs_truncate_nolock(struct inode *ip, loff_t length)
318	{	330	{
319	loff_t newsize;	331	loff_t newsize;
320	tid_t tid;	332	tid_t tid;
321		333
322	ASSERT(length >= 0);	334	ASSERT(length >= 0);
323		335
324	if (test_cflag(COMMIT_Nolink, ip)) {	336	if (test_cflag(COMMIT_Nolink, ip)) {
325	xtTruncate(0, ip, length, COMMIT_WMAP);	337	xtTruncate(0, ip, length, COMMIT_WMAP);
326	return;	338	return;
327	}	339	}
328		340
329	do {	341	do {
330	tid = txBegin(ip->i_sb, 0);	342	tid = txBegin(ip->i_sb, 0);
331		343
332	/*	344	/*
333	* The commit_mutex cannot be taken before txBegin.	345	* The commit_mutex cannot be taken before txBegin.
334	* txBegin may block and there is a chance the inode	346	* txBegin may block and there is a chance the inode
335	* could be marked dirty and need to be committed	347	* could be marked dirty and need to be committed
336	* before txBegin unblocks	348	* before txBegin unblocks
337	*/	349	*/
338	mutex_lock(&JFS_IP(ip)->commit_mutex);	350	mutex_lock(&JFS_IP(ip)->commit_mutex);
339		351
340	newsize = xtTruncate(tid, ip, length,	352	newsize = xtTruncate(tid, ip, length,
341	COMMIT_TRUNCATE \| COMMIT_PWMAP);	353	COMMIT_TRUNCATE \| COMMIT_PWMAP);
342	if (newsize < 0) {	354	if (newsize < 0) {
343	txEnd(tid);	355	txEnd(tid);
344	mutex_unlock(&JFS_IP(ip)->commit_mutex);	356	mutex_unlock(&JFS_IP(ip)->commit_mutex);
345	break;	357	break;
346	}	358	}
347		359
348	ip->i_mtime = ip->i_ctime = CURRENT_TIME;	360	ip->i_mtime = ip->i_ctime = CURRENT_TIME;
349	mark_inode_dirty(ip);	361	mark_inode_dirty(ip);
350		362
351	txCommit(tid, 1, &ip, 0);	363	txCommit(tid, 1, &ip, 0);
352	txEnd(tid);	364	txEnd(tid);
353	mutex_unlock(&JFS_IP(ip)->commit_mutex);	365	mutex_unlock(&JFS_IP(ip)->commit_mutex);
354	} while (newsize > length); /* Truncate isn't always atomic */	366	} while (newsize > length); /* Truncate isn't always atomic */
355	}	367	}
356		368
357	void jfs_truncate(struct inode *ip)	369	void jfs_truncate(struct inode *ip)
358	{	370	{
359	jfs_info("jfs_truncate: size = 0x%lx", (ulong) ip->i_size);	371	jfs_info("jfs_truncate: size = 0x%lx", (ulong) ip->i_size);
360		372
361	nobh_truncate_page(ip->i_mapping, ip->i_size, jfs_get_block);	373	nobh_truncate_page(ip->i_mapping, ip->i_size, jfs_get_block);
362		374
363	IWRITE_LOCK(ip, RDWRLOCK_NORMAL);	375	IWRITE_LOCK(ip, RDWRLOCK_NORMAL);
364	jfs_truncate_nolock(ip, ip->i_size);	376	jfs_truncate_nolock(ip, ip->i_size);
365	IWRITE_UNLOCK(ip);	377	IWRITE_UNLOCK(ip);
366	}	378	}
367		379

fs/jfs/jfs_inode.h

Diff comments View file @ eab1df7

fs/jfs/namei.c

Diff comments View file @ eab1df7

 /*
  *   Copyright (C) International Business Machines Corp., 2000-2004
  *   Portions Copyright (C) Christoph Hellwig, 2001-2002
  *
  *   This program is free software;  you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  *   the GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program;  if not, write to the Free Software
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 #include <linux/fs.h>
 #include <linux/ctype.h>
 #include <linux/quotaops.h>
 #include <linux/exportfs.h>
 #include "jfs_incore.h"
 #include "jfs_superblock.h"
 #include "jfs_inode.h"
 #include "jfs_dinode.h"
 #include "jfs_dmap.h"
 #include "jfs_unicode.h"
 #include "jfs_metapage.h"
 #include "jfs_xattr.h"
 #include "jfs_acl.h"
 #include "jfs_debug.h"
 /*
  * forward references
  */
 struct dentry_operations jfs_ci_dentry_operations;
 static s64 commitZeroLink(tid_t, struct inode *);
 /*
  * NAME:	free_ea_wmap(inode)
  *
  * FUNCTION:	free uncommitted extended attributes from working map
  *
  */
 static inline void free_ea_wmap(struct inode *inode)
 {
 	dxd_t *ea = &JFS_IP(inode)->ea;
 	if (ea->flag & DXD_EXTENT) {
 		/* free EA pages from cache */
 		invalidate_dxd_metapages(inode, *ea);
 		dbFree(inode, addressDXD(ea), lengthDXD(ea));
 	}
 	ea->flag = 0;
 }
 /*
  * NAME:	jfs_create(dip, dentry, mode)
  *
  * FUNCTION:	create a regular file in the parent directory <dip>
  *		with name = <from dentry> and mode = <mode>
  *
  * PARAMETER:	dip	- parent directory vnode
  *		dentry	- dentry of new file
  *		mode	- create mode (rwxrwxrwx).
  *		nd- nd struct
  *
  * RETURN:	Errors from subroutines
  *
  */
 static int jfs_create(struct inode *dip, struct dentry *dentry, int mode,
 		struct nameidata *nd)
 {
 	int rc = 0;
 	tid_t tid;		/* transaction id */
 	struct inode *ip = NULL;	/* child directory inode */
 	ino_t ino;
 	struct component_name dname;	/* child directory name */
 	struct btstack btstack;
 	struct inode *iplist[2];
 	struct tblock *tblk;
 	jfs_info("jfs_create: dip:0x%p name:%s", dip, dentry->d_name.name);
 	/*
 	 * search parent directory for entry/freespace
 	 * (dtSearch() returns parent directory page pinned)
 	 */
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out1;
 	/*
 	 * Either iAlloc() or txBegin() may block.  Deadlock can occur if we
 	 * block there while holding dtree page, so we allocate the inode &
 	 * begin the transaction before we search the directory.
 	 */
 	ip = ialloc(dip, mode);
 	if (IS_ERR(ip)) {
 		rc = PTR_ERR(ip);
 		goto out2;
 	}
 	tid = txBegin(dip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	rc = jfs_init_acl(tid, ip, dip);
 	if (rc)
 		goto out3;
 	rc = jfs_init_security(tid, ip, dip);
 	if (rc) {
 		txAbort(tid, 0);
 		goto out3;
 	}
 	if ((rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE))) {
 		jfs_err("jfs_create: dtSearch returned %d", rc);
 		txAbort(tid, 0);
 		goto out3;
 	}
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_CREATE;
 	tblk->ino = ip->i_ino;
 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
 	iplist[0] = dip;
 	iplist[1] = ip;
 	/*
 	 * initialize the child XAD tree root in-line in inode
 	 */
 	xtInitRoot(tid, ip);
 	/*
 	 * create entry in parent directory for child directory
 	 * (dtInsert() releases parent directory page)
 	 */
 	ino = ip->i_ino;
 	if ((rc = dtInsert(tid, dip, &dname, &ino, &btstack))) {
 		if (rc == -EIO) {
 			jfs_err("jfs_create: dtInsert returned -EIO");
 			txAbort(tid, 1);	/* Marks Filesystem dirty */
 		} else
 			txAbort(tid, 0);	/* Filesystem full */
 		goto out3;
 	}
 	ip->i_op = &jfs_file_inode_operations;
 	ip->i_fop = &jfs_file_operations;
 	ip->i_mapping->a_ops = &jfs_aops;
 	insert_inode_hash(ip);
 	mark_inode_dirty(ip);
 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dip);
 	rc = txCommit(tid, 2, &iplist[0], 0);
       out3:
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
 	if (rc) {
 		free_ea_wmap(ip);
 		ip->i_nlink = 0;
 		iput(ip);
 	} else
 		d_instantiate(dentry, ip);
       out2:
 	free_UCSname(&dname);
       out1:
 	jfs_info("jfs_create: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_mkdir(dip, dentry, mode)
  *
  * FUNCTION:	create a child directory in the parent directory <dip>
  *		with name = <from dentry> and mode = <mode>
  *
  * PARAMETER:	dip	- parent directory vnode
  *		dentry	- dentry of child directory
  *		mode	- create mode (rwxrwxrwx).
  *
  * RETURN:	Errors from subroutines
  *
  * note:
  * EACCESS: user needs search+write permission on the parent directory
  */
 static int jfs_mkdir(struct inode *dip, struct dentry *dentry, int mode)
 {
 	int rc = 0;
 	tid_t tid;		/* transaction id */
 	struct inode *ip = NULL;	/* child directory inode */
 	ino_t ino;
 	struct component_name dname;	/* child directory name */
 	struct btstack btstack;
 	struct inode *iplist[2];
 	struct tblock *tblk;
 	jfs_info("jfs_mkdir: dip:0x%p name:%s", dip, dentry->d_name.name);
 	/* link count overflow on parent directory ? */
 	if (dip->i_nlink == JFS_LINK_MAX) {
 		rc = -EMLINK;
 		goto out1;
 	}
 	/*
 	 * search parent directory for entry/freespace
 	 * (dtSearch() returns parent directory page pinned)
 	 */
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out1;
 	/*
 	 * Either iAlloc() or txBegin() may block.  Deadlock can occur if we
 	 * block there while holding dtree page, so we allocate the inode &
 	 * begin the transaction before we search the directory.
 	 */
 	ip = ialloc(dip, S_IFDIR | mode);
 	if (IS_ERR(ip)) {
 		rc = PTR_ERR(ip);
 		goto out2;
 	}
 	tid = txBegin(dip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	rc = jfs_init_acl(tid, ip, dip);
 	if (rc)
 		goto out3;
 	rc = jfs_init_security(tid, ip, dip);
 	if (rc) {
 		txAbort(tid, 0);
 		goto out3;
 	}
 	if ((rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE))) {
 		jfs_err("jfs_mkdir: dtSearch returned %d", rc);
 		txAbort(tid, 0);
 		goto out3;
 	}
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_CREATE;
 	tblk->ino = ip->i_ino;
 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
 	iplist[0] = dip;
 	iplist[1] = ip;
 	/*
 	 * initialize the child directory in-line in inode
 	 */
 	dtInitRoot(tid, ip, dip->i_ino);
 	/*
 	 * create entry in parent directory for child directory
 	 * (dtInsert() releases parent directory page)
 	 */
 	ino = ip->i_ino;
 	if ((rc = dtInsert(tid, dip, &dname, &ino, &btstack))) {
 		if (rc == -EIO) {
 			jfs_err("jfs_mkdir: dtInsert returned -EIO");
 			txAbort(tid, 1);	/* Marks Filesystem dirty */
 		} else
 			txAbort(tid, 0);	/* Filesystem full */
 		goto out3;
 	}
 	ip->i_nlink = 2;	/* for '.' */
 	ip->i_op = &jfs_dir_inode_operations;
 	ip->i_fop = &jfs_dir_operations;
 	insert_inode_hash(ip);
 	mark_inode_dirty(ip);
 	/* update parent directory inode */
 	inc_nlink(dip);		/* for '..' from child directory */
 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dip);
 	rc = txCommit(tid, 2, &iplist[0], 0);
       out3:
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
 	if (rc) {
 		free_ea_wmap(ip);
 		ip->i_nlink = 0;
 		iput(ip);
 	} else
 		d_instantiate(dentry, ip);
       out2:
 	free_UCSname(&dname);
       out1:
 	jfs_info("jfs_mkdir: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_rmdir(dip, dentry)
  *
  * FUNCTION:	remove a link to child directory
  *
  * PARAMETER:	dip	- parent inode
  *		dentry	- child directory dentry
  *
  * RETURN:	-EINVAL	- if name is . or ..
  *		-EINVAL - if . or .. exist but are invalid.
  *		errors from subroutines
  *
  * note:
  * if other threads have the directory open when the last link
  * is removed, the "." and ".." entries, if present, are removed before
  * rmdir() returns and no new entries may be created in the directory,
  * but the directory is not removed until the last reference to
  * the directory is released (cf.unlink() of regular file).
  */
 static int jfs_rmdir(struct inode *dip, struct dentry *dentry)
 {
 	int rc;
 	tid_t tid;		/* transaction id */
 	struct inode *ip = dentry->d_inode;
 	ino_t ino;
 	struct component_name dname;
 	struct inode *iplist[2];
 	struct tblock *tblk;
 	jfs_info("jfs_rmdir: dip:0x%p name:%s", dip, dentry->d_name.name);
 	/* Init inode for quota operations. */
 	DQUOT_INIT(ip);
 	/* directory must be empty to be removed */
 	if (!dtEmpty(ip)) {
 		rc = -ENOTEMPTY;
 		goto out;
 	}
 	if ((rc = get_UCSname(&dname, dentry))) {
 		goto out;
 	}
 	tid = txBegin(dip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	iplist[0] = dip;
 	iplist[1] = ip;
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_DELETE;
 	tblk->u.ip = ip;
 	/*
 	 * delete the entry of target directory from parent directory
 	 */
 	ino = ip->i_ino;
 	if ((rc = dtDelete(tid, dip, &dname, &ino, JFS_REMOVE))) {
 		jfs_err("jfs_rmdir: dtDelete returned %d", rc);
 		if (rc == -EIO)
 			txAbort(tid, 1);
 		txEnd(tid);
 		mutex_unlock(&JFS_IP(ip)->commit_mutex);
 		mutex_unlock(&JFS_IP(dip)->commit_mutex);
 		goto out2;
 	}
 	/* update parent directory's link count corresponding
 	 * to ".." entry of the target directory deleted
 	 */
 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
 	inode_dec_link_count(dip);
 	/*
 	 * OS/2 could have created EA and/or ACL
 	 */
 	/* free EA from both persistent and working map */
 	if (JFS_IP(ip)->ea.flag & DXD_EXTENT) {
 		/* free EA pages */
 		txEA(tid, ip, &JFS_IP(ip)->ea, NULL);
 	}
 	JFS_IP(ip)->ea.flag = 0;
 	/* free ACL from both persistent and working map */
 	if (JFS_IP(ip)->acl.flag & DXD_EXTENT) {
 		/* free ACL pages */
 		txEA(tid, ip, &JFS_IP(ip)->acl, NULL);
 	}
 	JFS_IP(ip)->acl.flag = 0;
 	/* mark the target directory as deleted */
 	clear_nlink(ip);
 	mark_inode_dirty(ip);
 	rc = txCommit(tid, 2, &iplist[0], 0);
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
 	/*
 	 * Truncating the directory index table is not guaranteed.  It
 	 * may need to be done iteratively
 	 */
 	if (test_cflag(COMMIT_Stale, dip)) {
 		if (dip->i_size > 1)
 			jfs_truncate_nolock(dip, 0);
 		clear_cflag(COMMIT_Stale, dip);
 	}
       out2:
 	free_UCSname(&dname);
       out:
 	jfs_info("jfs_rmdir: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_unlink(dip, dentry)
  *
  * FUNCTION:	remove a link to object <vp> named by <name>
  *		from parent directory <dvp>
  *
  * PARAMETER:	dip	- inode of parent directory
  *		dentry	- dentry of object to be removed
  *
  * RETURN:	errors from subroutines
  *
  * note:
  * temporary file: if one or more processes have the file open
  * when the last link is removed, the link will be removed before
  * unlink() returns, but the removal of the file contents will be
  * postponed until all references to the files are closed.
  *
  * JFS does NOT support unlink() on directories.
  *
  */
 static int jfs_unlink(struct inode *dip, struct dentry *dentry)
 {
 	int rc;
 	tid_t tid;		/* transaction id */
 	struct inode *ip = dentry->d_inode;
 	ino_t ino;
 	struct component_name dname;	/* object name */
 	struct inode *iplist[2];
 	struct tblock *tblk;
 	s64 new_size = 0;
 	int commit_flag;
 	jfs_info("jfs_unlink: dip:0x%p name:%s", dip, dentry->d_name.name);
 	/* Init inode for quota operations. */
 	DQUOT_INIT(ip);
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out;
 	IWRITE_LOCK(ip, RDWRLOCK_NORMAL);
 	tid = txBegin(dip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	iplist[0] = dip;
 	iplist[1] = ip;
 	/*
 	 * delete the entry of target file from parent directory
 	 */
 	ino = ip->i_ino;
 	if ((rc = dtDelete(tid, dip, &dname, &ino, JFS_REMOVE))) {
 		jfs_err("jfs_unlink: dtDelete returned %d", rc);
 		if (rc == -EIO)
 			txAbort(tid, 1);	/* Marks FS Dirty */
 		txEnd(tid);
 		mutex_unlock(&JFS_IP(ip)->commit_mutex);
 		mutex_unlock(&JFS_IP(dip)->commit_mutex);
 		IWRITE_UNLOCK(ip);
 		goto out1;
 	}
 	ASSERT(ip->i_nlink);
 	ip->i_ctime = dip->i_ctime = dip->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dip);
 	/* update target's inode */
 	inode_dec_link_count(ip);
 	/*
 	 *	commit zero link count object
 	 */
 	if (ip->i_nlink == 0) {
 		assert(!test_cflag(COMMIT_Nolink, ip));
 		/* free block resources */
 		if ((new_size = commitZeroLink(tid, ip)) < 0) {
 			txAbort(tid, 1);	/* Marks FS Dirty */
 			txEnd(tid);
 			mutex_unlock(&JFS_IP(ip)->commit_mutex);
 			mutex_unlock(&JFS_IP(dip)->commit_mutex);
 			IWRITE_UNLOCK(ip);
 			rc = new_size;
 			goto out1;
 		}
 		tblk = tid_to_tblock(tid);
 		tblk->xflag |= COMMIT_DELETE;
 		tblk->u.ip = ip;
 	}
 	/*
 	 * Incomplete truncate of file data can
 	 * result in timing problems unless we synchronously commit the
 	 * transaction.
 	 */
 	if (new_size)
 		commit_flag = COMMIT_SYNC;
 	else
 		commit_flag = 0;
 	/*
 	 * If xtTruncate was incomplete, commit synchronously to avoid
 	 * timing complications
 	 */
 	rc = txCommit(tid, 2, &iplist[0], commit_flag);
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
 	while (new_size && (rc == 0)) {
 		tid = txBegin(dip->i_sb, 0);
 		mutex_lock(&JFS_IP(ip)->commit_mutex);
 		new_size = xtTruncate_pmap(tid, ip, new_size);
 		if (new_size < 0) {
 			txAbort(tid, 1);	/* Marks FS Dirty */
 			rc = new_size;
 		} else
 			rc = txCommit(tid, 2, &iplist[0], COMMIT_SYNC);
 		txEnd(tid);
 		mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	}
 	if (ip->i_nlink == 0)
 		set_cflag(COMMIT_Nolink, ip);
 	IWRITE_UNLOCK(ip);
 	/*
 	 * Truncating the directory index table is not guaranteed.  It
 	 * may need to be done iteratively
 	 */
 	if (test_cflag(COMMIT_Stale, dip)) {
 		if (dip->i_size > 1)
 			jfs_truncate_nolock(dip, 0);
 		clear_cflag(COMMIT_Stale, dip);
 	}
       out1:
 	free_UCSname(&dname);
       out:
 	jfs_info("jfs_unlink: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	commitZeroLink()
  *
  * FUNCTION:	for non-directory, called by jfs_remove(),
  *		truncate a regular file, directory or symbolic
  *		link to zero length. return 0 if type is not
  *		one of these.
  *
  *		if the file is currently associated with a VM segment
  *		only permanent disk and inode map resources are freed,
  *		and neither the inode nor indirect blocks are modified
  *		so that the resources can be later freed in the work
  *		map by ctrunc1.
  *		if there is no VM segment on entry, the resources are
  *		freed in both work and permanent map.
  *		(? for temporary file - memory object is cached even
  *		after no reference:
  *		reference count > 0 -   )
  *
  * PARAMETERS:	cd	- pointer to commit data structure.
  *			  current inode is the one to truncate.
  *
  * RETURN:	Errors from subroutines
  */
 static s64 commitZeroLink(tid_t tid, struct inode *ip)
 {
 	int filetype;
 	struct tblock *tblk;
 	jfs_info("commitZeroLink: tid = %d, ip = 0x%p", tid, ip);
 	filetype = ip->i_mode & S_IFMT;
 	switch (filetype) {
 	case S_IFREG:
 		break;
 	case S_IFLNK:
 		/* fast symbolic link */
 		if (ip->i_size < IDATASIZE) {
 			ip->i_size = 0;
 			return 0;
 		}
 		break;
 	default:
 		assert(filetype != S_IFDIR);
 		return 0;
 	}
 	set_cflag(COMMIT_Freewmap, ip);
 	/* mark transaction of block map update type */
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_PMAP;
 	/*
 	 * free EA
 	 */
 	if (JFS_IP(ip)->ea.flag & DXD_EXTENT)
 		/* acquire maplock on EA to be freed from block map */
 		txEA(tid, ip, &JFS_IP(ip)->ea, NULL);
 	/*
 	 * free ACL
 	 */
 	if (JFS_IP(ip)->acl.flag & DXD_EXTENT)
 		/* acquire maplock on EA to be freed from block map */
 		txEA(tid, ip, &JFS_IP(ip)->acl, NULL);
 	/*
 	 * free xtree/data (truncate to zero length):
 	 * free xtree/data pages from cache if COMMIT_PWMAP,
 	 * free xtree/data blocks from persistent block map, and
 	 * free xtree/data blocks from working block map if COMMIT_PWMAP;
 	 */
 	if (ip->i_size)
 		return xtTruncate_pmap(tid, ip, 0);
 	return 0;
 }
 /*
  * NAME:	jfs_free_zero_link()
  *
  * FUNCTION:	for non-directory, called by iClose(),
  *		free resources of a file from cache and WORKING map
  *		for a file previously committed with zero link count
  *		while associated with a pager object,
  *
  * PARAMETER:	ip	- pointer to inode of file.
  */
 void jfs_free_zero_link(struct inode *ip)
 {
 	int type;
 	jfs_info("jfs_free_zero_link: ip = 0x%p", ip);
 	/* return if not reg or symbolic link or if size is
 	 * already ok.
 	 */
 	type = ip->i_mode & S_IFMT;
 	switch (type) {
 	case S_IFREG:
 		break;
 	case S_IFLNK:
 		/* if its contained in inode nothing to do */
 		if (ip->i_size < IDATASIZE)
 			return;
 		break;
 	default:
 		return;
 	}
 	/*
 	 * free EA
 	 */
 	if (JFS_IP(ip)->ea.flag & DXD_EXTENT) {
 		s64 xaddr = addressDXD(&JFS_IP(ip)->ea);
 		int xlen = lengthDXD(&JFS_IP(ip)->ea);
 		struct maplock maplock;	/* maplock for COMMIT_WMAP */
 		struct pxd_lock *pxdlock;	/* maplock for COMMIT_WMAP */
 		/* free EA pages from cache */
 		invalidate_dxd_metapages(ip, JFS_IP(ip)->ea);
 		/* free EA extent from working block map */
 		maplock.index = 1;
 		pxdlock = (struct pxd_lock *) & maplock;
 		pxdlock->flag = mlckFREEPXD;
 		PXDaddress(&pxdlock->pxd, xaddr);
 		PXDlength(&pxdlock->pxd, xlen);
 		txFreeMap(ip, pxdlock, NULL, COMMIT_WMAP);
 	}
 	/*
 	 * free ACL
 	 */
 	if (JFS_IP(ip)->acl.flag & DXD_EXTENT) {
 		s64 xaddr = addressDXD(&JFS_IP(ip)->acl);
 		int xlen = lengthDXD(&JFS_IP(ip)->acl);
 		struct maplock maplock;	/* maplock for COMMIT_WMAP */
 		struct pxd_lock *pxdlock;	/* maplock for COMMIT_WMAP */
 		invalidate_dxd_metapages(ip, JFS_IP(ip)->acl);
 		/* free ACL extent from working block map */
 		maplock.index = 1;
 		pxdlock = (struct pxd_lock *) & maplock;
 		pxdlock->flag = mlckFREEPXD;
 		PXDaddress(&pxdlock->pxd, xaddr);
 		PXDlength(&pxdlock->pxd, xlen);
 		txFreeMap(ip, pxdlock, NULL, COMMIT_WMAP);
 	}
 	/*
 	 * free xtree/data (truncate to zero length):
 	 * free xtree/data pages from cache, and
 	 * free xtree/data blocks from working block map;
 	 */
 	if (ip->i_size)
 		xtTruncate(0, ip, 0, COMMIT_WMAP);
 }
 /*
  * NAME:	jfs_link(vp, dvp, name, crp)
  *
  * FUNCTION:	create a link to <vp> by the name = <name>
  *		in the parent directory <dvp>
  *
  * PARAMETER:	vp	- target object
  *		dvp	- parent directory of new link
  *		name	- name of new link to target object
  *		crp	- credential
  *
  * RETURN:	Errors from subroutines
  *
  * note:
  * JFS does NOT support link() on directories (to prevent circular
  * path in the directory hierarchy);
  * EPERM: the target object is a directory, and either the caller
  * does not have appropriate privileges or the implementation prohibits
  * using link() on directories [XPG4.2].
  *
  * JFS does NOT support links between file systems:
  * EXDEV: target object and new link are on different file systems and
  * implementation does not support links between file systems [XPG4.2].
  */
 static int jfs_link(struct dentry *old_dentry,
 	     struct inode *dir, struct dentry *dentry)
 {
 	int rc;
 	tid_t tid;
 	struct inode *ip = old_dentry->d_inode;
 	ino_t ino;
 	struct component_name dname;
 	struct btstack btstack;
 	struct inode *iplist[2];
 	jfs_info("jfs_link: %s %s", old_dentry->d_name.name,
 		 dentry->d_name.name);
 	if (ip->i_nlink == JFS_LINK_MAX)
 		return -EMLINK;
 	if (ip->i_nlink == 0)
 		return -ENOENT;
 	tid = txBegin(ip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dir)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	/*
 	 * scan parent directory for entry/freespace
 	 */
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out;
 	if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE)))
 		goto free_dname;
 	/*
 	 * create entry for new link in parent directory
 	 */
 	ino = ip->i_ino;
 	if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack)))
 		goto free_dname;
 	/* update object inode */
 	inc_nlink(ip);		/* for new link */
 	ip->i_ctime = CURRENT_TIME;
 	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dir);
 	atomic_inc(&ip->i_count);
 	iplist[0] = ip;
 	iplist[1] = dir;
 	rc = txCommit(tid, 2, &iplist[0], 0);
 	if (rc) {
 		ip->i_nlink--; /* never instantiated */
 		iput(ip);
 	} else
 		d_instantiate(dentry, ip);
       free_dname:
 	free_UCSname(&dname);
       out:
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dir)->commit_mutex);
 	jfs_info("jfs_link: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_symlink(dip, dentry, name)
  *
  * FUNCTION:	creates a symbolic link to <symlink> by name <name>
  *			in directory <dip>
  *
  * PARAMETER:	dip	- parent directory vnode
  *		dentry	- dentry of symbolic link
  *		name	- the path name of the existing object
  *			  that will be the source of the link
  *
  * RETURN:	errors from subroutines
  *
  * note:
  * ENAMETOOLONG: pathname resolution of a symbolic link produced
  * an intermediate result whose length exceeds PATH_MAX [XPG4.2]
 */
 static int jfs_symlink(struct inode *dip, struct dentry *dentry,
 		const char *name)
 {
 	int rc;
 	tid_t tid;
 	ino_t ino = 0;
 	struct component_name dname;
 	int ssize;		/* source pathname size */
 	struct btstack btstack;
 	struct inode *ip = dentry->d_inode;
 	unchar *i_fastsymlink;
 	s64 xlen = 0;
 	int bmask = 0, xsize;
 	s64 extent = 0, xaddr;
 	struct metapage *mp;
 	struct super_block *sb;
 	struct tblock *tblk;
 	struct inode *iplist[2];
 	jfs_info("jfs_symlink: dip:0x%p name:%s", dip, name);
 	ssize = strlen(name) + 1;
 	/*
 	 * search parent directory for entry/freespace
 	 * (dtSearch() returns parent directory page pinned)
 	 */
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out1;
 	/*
 	 * allocate on-disk/in-memory inode for symbolic link:
 	 * (iAlloc() returns new, locked inode)
 	 */
 	ip = ialloc(dip, S_IFLNK | 0777);
 	if (IS_ERR(ip)) {
 		rc = PTR_ERR(ip);
 		goto out2;
 	}
 	tid = txBegin(dip->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dip)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	rc = jfs_init_security(tid, ip, dip);
 	if (rc)
 		goto out3;
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_CREATE;
 	tblk->ino = ip->i_ino;
 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
 	/* fix symlink access permission
 	 * (dir_create() ANDs in the u.u_cmask,
 	 * but symlinks really need to be 777 access)
 	 */
 	ip->i_mode |= 0777;
 	/*
 	 * write symbolic link target path name
 	 */
 	xtInitRoot(tid, ip);
 	/*
 	 * write source path name inline in on-disk inode (fast symbolic link)
 	 */
 	if (ssize <= IDATASIZE) {
 		ip->i_op = &jfs_symlink_inode_operations;
 		i_fastsymlink = JFS_IP(ip)->i_inline;
 		memcpy(i_fastsymlink, name, ssize);
 		ip->i_size = ssize - 1;
 		/*
 		 * if symlink is > 128 bytes, we don't have the space to
 		 * store inline extended attributes
 		 */
 		if (ssize > sizeof (JFS_IP(ip)->i_inline))
 			JFS_IP(ip)->mode2 &= ~INLINEEA;
 		jfs_info("jfs_symlink: fast symlink added  ssize:%d name:%s ",
 			 ssize, name);
 	}
 	/*
 	 * write source path name in a single extent
 	 */
 	else {
 		jfs_info("jfs_symlink: allocate extent ip:0x%p", ip);
 		ip->i_op = &page_symlink_inode_operations;
 		ip->i_mapping->a_ops = &jfs_aops;
 		/*
 		 * even though the data of symlink object (source
 		 * path name) is treated as non-journaled user data,
 		 * it is read/written thru buffer cache for performance.
 		 */
 		sb = ip->i_sb;
 		bmask = JFS_SBI(sb)->bsize - 1;
 		xsize = (ssize + bmask) & ~bmask;
 		xaddr = 0;
 		xlen = xsize >> JFS_SBI(sb)->l2bsize;
 		if ((rc = xtInsert(tid, ip, 0, 0, xlen, &xaddr, 0))) {
 			txAbort(tid, 0);
 			goto out3;
 		}
 		extent = xaddr;
 		ip->i_size = ssize - 1;
 		while (ssize) {
 			/* This is kind of silly since PATH_MAX == 4K */
 			int copy_size = min(ssize, PSIZE);
 			mp = get_metapage(ip, xaddr, PSIZE, 1);
 			if (mp == NULL) {
 				xtTruncate(tid, ip, 0, COMMIT_PWMAP);
 				rc = -EIO;
 				txAbort(tid, 0);
 				goto out3;
 			}
 			memcpy(mp->data, name, copy_size);
 			flush_metapage(mp);
 			ssize -= copy_size;
 			name += copy_size;
 			xaddr += JFS_SBI(sb)->nbperpage;
 		}
 	}
 	/*
 	 * create entry for symbolic link in parent directory
 	 */
 	rc = dtSearch(dip, &dname, &ino, &btstack, JFS_CREATE);
 	if (rc == 0) {
 		ino = ip->i_ino;
 		rc = dtInsert(tid, dip, &dname, &ino, &btstack);
 	}
 	if (rc) {
 		if (xlen)
 			xtTruncate(tid, ip, 0, COMMIT_PWMAP);
 		txAbort(tid, 0);
 		/* discard new inode */
 		goto out3;
 	}
 	insert_inode_hash(ip);
 	mark_inode_dirty(ip);
 	dip->i_ctime = dip->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dip);
 	/*
 	 * commit update of parent directory and link object
 	 */
 	iplist[0] = dip;
 	iplist[1] = ip;
 	rc = txCommit(tid, 2, &iplist[0], 0);
       out3:
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dip)->commit_mutex);
 	if (rc) {
 		free_ea_wmap(ip);
 		ip->i_nlink = 0;
 		iput(ip);
 	} else
 		d_instantiate(dentry, ip);
       out2:
 	free_UCSname(&dname);
       out1:
 	jfs_info("jfs_symlink: rc:%d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_rename
  *
  * FUNCTION:	rename a file or directory
  */
 static int jfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 	       struct inode *new_dir, struct dentry *new_dentry)
 {
 	struct btstack btstack;
 	ino_t ino;
 	struct component_name new_dname;
 	struct inode *new_ip;
 	struct component_name old_dname;
 	struct inode *old_ip;
 	int rc;
 	tid_t tid;
 	struct tlock *tlck;
 	struct dt_lock *dtlck;
 	struct lv *lv;
 	int ipcount;
 	struct inode *iplist[4];
 	struct tblock *tblk;
 	s64 new_size = 0;
 	int commit_flag;
 	jfs_info("jfs_rename: %s %s", old_dentry->d_name.name,
 		 new_dentry->d_name.name);
 	old_ip = old_dentry->d_inode;
 	new_ip = new_dentry->d_inode;
 	if ((rc = get_UCSname(&old_dname, old_dentry)))
 		goto out1;
 	if ((rc = get_UCSname(&new_dname, new_dentry)))
 		goto out2;
 	/*
 	 * Make sure source inode number is what we think it is
 	 */
 	rc = dtSearch(old_dir, &old_dname, &ino, &btstack, JFS_LOOKUP);
 	if (rc || (ino != old_ip->i_ino)) {
 		rc = -ENOENT;
 		goto out3;
 	}
 	/*
 	 * Make sure dest inode number (if any) is what we think it is
 	 */
 	rc = dtSearch(new_dir, &new_dname, &ino, &btstack, JFS_LOOKUP);
 	if (!rc) {
 		if ((!new_ip) || (ino != new_ip->i_ino)) {
 			rc = -ESTALE;
 			goto out3;
 		}
 	} else if (rc != -ENOENT)
 		goto out3;
 	else if (new_ip) {
 		/* no entry exists, but one was expected */
 		rc = -ESTALE;
 		goto out3;
 	}
 	if (S_ISDIR(old_ip->i_mode)) {
 		if (new_ip) {
 			if (!dtEmpty(new_ip)) {
 				rc = -ENOTEMPTY;
 				goto out3;
 			}
 		} else if ((new_dir != old_dir) &&
 			   (new_dir->i_nlink == JFS_LINK_MAX)) {
 			rc = -EMLINK;
 			goto out3;
 		}
 	} else if (new_ip) {
 		IWRITE_LOCK(new_ip, RDWRLOCK_NORMAL);
 		/* Init inode for quota operations. */
 		DQUOT_INIT(new_ip);
 	}
 	/*
 	 * The real work starts here
 	 */
 	tid = txBegin(new_dir->i_sb, 0);
 	/*
 	 * How do we know the locking is safe from deadlocks?
 	 * The vfs does the hard part for us.  Any time we are taking nested
 	 * commit_mutexes, the vfs already has i_mutex held on the parent.
 	 * Here, the vfs has already taken i_mutex on both old_dir and new_dir.
 	 */
 	mutex_lock_nested(&JFS_IP(new_dir)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(old_ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	if (old_dir != new_dir)
 		mutex_lock_nested(&JFS_IP(old_dir)->commit_mutex,
 				  COMMIT_MUTEX_SECOND_PARENT);
 	if (new_ip) {
 		mutex_lock_nested(&JFS_IP(new_ip)->commit_mutex,
 				  COMMIT_MUTEX_VICTIM);
 		/*
 		 * Change existing directory entry to new inode number
 		 */
 		ino = new_ip->i_ino;
 		rc = dtModify(tid, new_dir, &new_dname, &ino,
 			      old_ip->i_ino, JFS_RENAME);
 		if (rc)
 			goto out4;
 		drop_nlink(new_ip);
 		if (S_ISDIR(new_ip->i_mode)) {
 			drop_nlink(new_ip);
 			if (new_ip->i_nlink) {
 				mutex_unlock(&JFS_IP(new_ip)->commit_mutex);
 				if (old_dir != new_dir)
 					mutex_unlock(&JFS_IP(old_dir)->commit_mutex);
 				mutex_unlock(&JFS_IP(old_ip)->commit_mutex);
 				mutex_unlock(&JFS_IP(new_dir)->commit_mutex);
 				if (!S_ISDIR(old_ip->i_mode) && new_ip)
 					IWRITE_UNLOCK(new_ip);
 				jfs_error(new_ip->i_sb,
 					  "jfs_rename: new_ip->i_nlink != 0");
 				return -EIO;
 			}
 			tblk = tid_to_tblock(tid);
 			tblk->xflag |= COMMIT_DELETE;
 			tblk->u.ip = new_ip;
 		} else if (new_ip->i_nlink == 0) {
 			assert(!test_cflag(COMMIT_Nolink, new_ip));
 			/* free block resources */
 			if ((new_size = commitZeroLink(tid, new_ip)) < 0) {
 				txAbort(tid, 1);	/* Marks FS Dirty */
 				rc = new_size;
 				goto out4;
 			}
 			tblk = tid_to_tblock(tid);
 			tblk->xflag |= COMMIT_DELETE;
 			tblk->u.ip = new_ip;
 		} else {
 			new_ip->i_ctime = CURRENT_TIME;
 			mark_inode_dirty(new_ip);
 		}
 	} else {
 		/*
 		 * Add new directory entry
 		 */
 		rc = dtSearch(new_dir, &new_dname, &ino, &btstack,
 			      JFS_CREATE);
 		if (rc) {
 			jfs_err("jfs_rename didn't expect dtSearch to fail "
 				"w/rc = %d", rc);
 			goto out4;
 		}
 		ino = old_ip->i_ino;
 		rc = dtInsert(tid, new_dir, &new_dname, &ino, &btstack);
 		if (rc) {
 			if (rc == -EIO)
 				jfs_err("jfs_rename: dtInsert returned -EIO");
 			goto out4;
 		}
 		if (S_ISDIR(old_ip->i_mode))
 			inc_nlink(new_dir);
 	}
 	/*
 	 * Remove old directory entry
 	 */
 	ino = old_ip->i_ino;
 	rc = dtDelete(tid, old_dir, &old_dname, &ino, JFS_REMOVE);
 	if (rc) {
 		jfs_err("jfs_rename did not expect dtDelete to return rc = %d",
 			rc);
 		txAbort(tid, 1);	/* Marks Filesystem dirty */
 		goto out4;
 	}
 	if (S_ISDIR(old_ip->i_mode)) {
 		drop_nlink(old_dir);
 		if (old_dir != new_dir) {
 			/*
 			 * Change inode number of parent for moved directory
 			 */
 			JFS_IP(old_ip)->i_dtroot.header.idotdot =
 				cpu_to_le32(new_dir->i_ino);
 			/* Linelock header of dtree */
 			tlck = txLock(tid, old_ip,
 				    (struct metapage *) &JFS_IP(old_ip)->bxflag,
 				      tlckDTREE | tlckBTROOT | tlckRELINK);
 			dtlck = (struct dt_lock *) & tlck->lock;
 			ASSERT(dtlck->index == 0);
 			lv = & dtlck->lv[0];
 			lv->offset = 0;
 			lv->length = 1;
 			dtlck->index++;
 		}
 	}
 	/*
 	 * Update ctime on changed/moved inodes & mark dirty
 	 */
 	old_ip->i_ctime = CURRENT_TIME;
 	mark_inode_dirty(old_ip);
 	new_dir->i_ctime = new_dir->i_mtime = current_fs_time(new_dir->i_sb);
 	mark_inode_dirty(new_dir);
 	/* Build list of inodes modified by this transaction */
 	ipcount = 0;
 	iplist[ipcount++] = old_ip;
 	if (new_ip)
 		iplist[ipcount++] = new_ip;
 	iplist[ipcount++] = old_dir;
 	if (old_dir != new_dir) {
 		iplist[ipcount++] = new_dir;
 		old_dir->i_ctime = old_dir->i_mtime = CURRENT_TIME;
 		mark_inode_dirty(old_dir);
 	}
 	/*
 	 * Incomplete truncate of file data can
 	 * result in timing problems unless we synchronously commit the
 	 * transaction.
 	 */
 	if (new_size)
 		commit_flag = COMMIT_SYNC;
 	else
 		commit_flag = 0;
 	rc = txCommit(tid, ipcount, iplist, commit_flag);
       out4:
 	txEnd(tid);
 	if (new_ip)
 		mutex_unlock(&JFS_IP(new_ip)->commit_mutex);
 	if (old_dir != new_dir)
 		mutex_unlock(&JFS_IP(old_dir)->commit_mutex);
 	mutex_unlock(&JFS_IP(old_ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(new_dir)->commit_mutex);
 	while (new_size && (rc == 0)) {
 		tid = txBegin(new_ip->i_sb, 0);
 		mutex_lock(&JFS_IP(new_ip)->commit_mutex);
 		new_size = xtTruncate_pmap(tid, new_ip, new_size);
 		if (new_size < 0) {
 			txAbort(tid, 1);
 			rc = new_size;
 		} else
 			rc = txCommit(tid, 1, &new_ip, COMMIT_SYNC);
 		txEnd(tid);
 		mutex_unlock(&JFS_IP(new_ip)->commit_mutex);
 	}
 	if (new_ip && (new_ip->i_nlink == 0))
 		set_cflag(COMMIT_Nolink, new_ip);
       out3:
 	free_UCSname(&new_dname);
       out2:
 	free_UCSname(&old_dname);
       out1:
 	if (new_ip && !S_ISDIR(new_ip->i_mode))
 		IWRITE_UNLOCK(new_ip);
 	/*
 	 * Truncating the directory index table is not guaranteed.  It
 	 * may need to be done iteratively
 	 */
 	if (test_cflag(COMMIT_Stale, old_dir)) {
 		if (old_dir->i_size > 1)
 			jfs_truncate_nolock(old_dir, 0);
 		clear_cflag(COMMIT_Stale, old_dir);
 	}
 	jfs_info("jfs_rename: returning %d", rc);
 	return rc;
 }
 /*
  * NAME:	jfs_mknod
  *
  * FUNCTION:	Create a special file (device)
  */
 static int jfs_mknod(struct inode *dir, struct dentry *dentry,
 		int mode, dev_t rdev)
 {
 	struct jfs_inode_info *jfs_ip;
 	struct btstack btstack;
 	struct component_name dname;
 	ino_t ino;
 	struct inode *ip;
 	struct inode *iplist[2];
 	int rc;
 	tid_t tid;
 	struct tblock *tblk;
 	if (!new_valid_dev(rdev))
 		return -EINVAL;
 	jfs_info("jfs_mknod: %s", dentry->d_name.name);
 	if ((rc = get_UCSname(&dname, dentry)))
 		goto out;
 	ip = ialloc(dir, mode);
 	if (IS_ERR(ip)) {
 		rc = PTR_ERR(ip);
 		goto out1;
 	}
 	jfs_ip = JFS_IP(ip);
 	tid = txBegin(dir->i_sb, 0);
 	mutex_lock_nested(&JFS_IP(dir)->commit_mutex, COMMIT_MUTEX_PARENT);
 	mutex_lock_nested(&JFS_IP(ip)->commit_mutex, COMMIT_MUTEX_CHILD);
 	rc = jfs_init_acl(tid, ip, dir);
 	if (rc)
 		goto out3;
 	rc = jfs_init_security(tid, ip, dir);
 	if (rc) {
 		txAbort(tid, 0);
 		goto out3;
 	}
 	if ((rc = dtSearch(dir, &dname, &ino, &btstack, JFS_CREATE))) {
 		txAbort(tid, 0);
 		goto out3;
 	}
 	tblk = tid_to_tblock(tid);
 	tblk->xflag |= COMMIT_CREATE;
 	tblk->ino = ip->i_ino;
 	tblk->u.ixpxd = JFS_IP(ip)->ixpxd;
 	ino = ip->i_ino;
 	if ((rc = dtInsert(tid, dir, &dname, &ino, &btstack))) {
 		txAbort(tid, 0);
 		goto out3;
 	}
 	ip->i_op = &jfs_file_inode_operations;
 	jfs_ip->dev = new_encode_dev(rdev);
 	init_special_inode(ip, ip->i_mode, rdev);
 	insert_inode_hash(ip);
 	mark_inode_dirty(ip);
 	dir->i_ctime = dir->i_mtime = CURRENT_TIME;
 	mark_inode_dirty(dir);
 	iplist[0] = dir;
 	iplist[1] = ip;
 	rc = txCommit(tid, 2, iplist, 0);
       out3:
 	txEnd(tid);
 	mutex_unlock(&JFS_IP(ip)->commit_mutex);
 	mutex_unlock(&JFS_IP(dir)->commit_mutex);
 	if (rc) {
 		free_ea_wmap(ip);
 		ip->i_nlink = 0;
 		iput(ip);
 	} else
 		d_instantiate(dentry, ip);
       out1:
 	free_UCSname(&dname);
       out:
 	jfs_info("jfs_mknod: returning %d", rc);
 	return rc;
 }
 static struct dentry *jfs_lookup(struct inode *dip, struct dentry *dentry, struct nameidata *nd)
 {
 	struct btstack btstack;
 	ino_t inum;
 	struct inode *ip;
 	struct component_name key;
 	const char *name = dentry->d_name.name;
 	int len = dentry->d_name.len;
 	int rc;
 	jfs_info("jfs_lookup: name = %s", name);
 	if (JFS_SBI(dip->i_sb)->mntflag & JFS_OS2)
 		dentry->d_op = &jfs_ci_dentry_operations;
 	if ((name[0] == '.') && (len == 1))
 		inum = dip->i_ino;
 	else if (strcmp(name, "..") == 0)
 		inum = PARENT(dip);
 	else {
 		if ((rc = get_UCSname(&key, dentry)))
 			return ERR_PTR(rc);
 		rc = dtSearch(dip, &key, &inum, &btstack, JFS_LOOKUP);
 		free_UCSname(&key);
 		if (rc == -ENOENT) {
 			d_add(dentry, NULL);
 			return ERR_PTR(0);
 		} else if (rc) {
 			jfs_err("jfs_lookup: dtSearch returned %d", rc);
 			return ERR_PTR(rc);
 		}
 	}
-	ip = iget(dip->i_sb, inum);
+	ip = jfs_iget(dip->i_sb, inum);
-	if (ip == NULL || is_bad_inode(ip)) {
+	if (IS_ERR(ip)) {
 		jfs_err("jfs_lookup: iget failed on inum %d", (uint) inum);
-		if (ip)
+		return ERR_CAST(ip);
-			iput(ip);
-		return ERR_PTR(-EACCES);
 	}
 	dentry = d_splice_alias(ip, dentry);
 	if (dentry && (JFS_SBI(dip->i_sb)->mntflag & JFS_OS2))
 		dentry->d_op = &jfs_ci_dentry_operations;
 	return dentry;
 }
 static struct inode *jfs_nfs_get_inode(struct super_block *sb,
 		u64 ino, u32 generation)
 {
 	struct inode *inode;
 	if (ino == 0)
 		return ERR_PTR(-ESTALE);
-	inode = iget(sb, ino);
+	inode = jfs_iget(sb, ino);
-	if (inode == NULL)
+	if (IS_ERR(inode))
-		return ERR_PTR(-ENOMEM);
+		return ERR_CAST(inode);
-	if (is_bad_inode(inode) ||
+	if (generation && inode->i_generation != generation) {
-	    (generation && inode->i_generation != generation)) {
 		iput(inode);
 		return ERR_PTR(-ESTALE);
 	}
 	return inode;
 }
 struct dentry *jfs_fh_to_dentry(struct super_block *sb, struct fid *fid,
 		int fh_len, int fh_type)
 {
 	return generic_fh_to_dentry(sb, fid, fh_len, fh_type,
 				    jfs_nfs_get_inode);
 }
 struct dentry *jfs_fh_to_parent(struct super_block *sb, struct fid *fid,
 		int fh_len, int fh_type)
 {
 	return generic_fh_to_parent(sb, fid, fh_len, fh_type,
 				    jfs_nfs_get_inode);
 }
 struct dentry *jfs_get_parent(struct dentry *dentry)
 {
 	struct super_block *sb = dentry->d_inode->i_sb;
 	struct dentry *parent = ERR_PTR(-ENOENT);
 	struct inode *inode;
 	unsigned long parent_ino;
 	parent_ino =
 		le32_to_cpu(JFS_IP(dentry->d_inode)->i_dtroot.header.idotdot);
-	inode = iget(sb, parent_ino);
+	inode = jfs_iget(sb, parent_ino);
-	if (inode) {
+	if (IS_ERR(inode)) {
-		if (is_bad_inode(inode)) {
+		parent = ERR_CAST(inode);
+	} else {
+		parent = d_alloc_anon(inode);
+		if (!parent) {
+			parent = ERR_PTR(-ENOMEM);
 			iput(inode);
-			parent = ERR_PTR(-EACCES);
-		} else {
-			parent = d_alloc_anon(inode);
-			if (!parent) {
-				parent = ERR_PTR(-ENOMEM);
-				iput(inode);
-			}
 		}
 	}
 	return parent;
 }
 const struct inode_operations jfs_dir_inode_operations = {
 	.create		= jfs_create,
 	.lookup		= jfs_lookup,
 	.link		= jfs_link,
 	.unlink		= jfs_unlink,
 	.symlink	= jfs_symlink,
 	.mkdir		= jfs_mkdir,
 	.rmdir		= jfs_rmdir,
 	.mknod		= jfs_mknod,
 	.rename		= jfs_rename,
 	.setxattr	= jfs_setxattr,
 	.getxattr	= jfs_getxattr,
 	.listxattr	= jfs_listxattr,
 	.removexattr	= jfs_removexattr,
 #ifdef CONFIG_JFS_POSIX_ACL
 	.setattr	= jfs_setattr,
 	.permission	= jfs_permission,
 #endif
 };
 const struct file_operations jfs_dir_operations = {
 	.read		= generic_read_dir,
 	.readdir	= jfs_readdir,
 	.fsync		= jfs_fsync,
 	.ioctl		= jfs_ioctl,
 };
 static int jfs_ci_hash(struct dentry *dir, struct qstr *this)
 {
 	unsigned long hash;
 	int i;
 	hash = init_name_hash();
 	for (i=0; i < this->len; i++)
 		hash = partial_name_hash(tolower(this->name[i]), hash);
 	this->hash = end_name_hash(hash);
 	return 0;
 }
 static int jfs_ci_compare(struct dentry *dir, struct qstr *a, struct qstr *b)
 {
 	int i, result = 1;
 	if (a->len != b->len)
 		goto out;
 	for (i=0; i < a->len; i++) {
 		if (tolower(a->name[i]) != tolower(b->name[i]))
 			goto out;
 	}
 	result = 0;
 	/*
 	 * We want creates to preserve case.  A negative dentry, a, that
 	 * has a different case than b may cause a new entry to be created
 	 * with the wrong case.  Since we can't tell if a comes from a negative
 	 * dentry, we blindly replace it with b.  This should be harmless if
 	 * a is not a negative dentry.
 	 */
 	memcpy((unsigned char *)a->name, b->name, a->len);
 out:
 	return result;
 }
 struct dentry_operations jfs_ci_dentry_operations =
 {

fs/jfs/super.c

Diff comments View file @ eab1df7

 /*
  *   Copyright (C) International Business Machines Corp., 2000-2004
  *   Portions Copyright (C) Christoph Hellwig, 2001-2002
  *
  *   This program is free software;  you can redistribute it and/or modify
  *   it under the terms of the GNU General Public License as published by
  *   the Free Software Foundation; either version 2 of the License, or
  *   (at your option) any later version.
  *
  *   This program is distributed in the hope that it will be useful,
  *   but WITHOUT ANY WARRANTY;  without even the implied warranty of
  *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  *   the GNU General Public License for more details.
  *
  *   You should have received a copy of the GNU General Public License
  *   along with this program;  if not, write to the Free Software
  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  */
 #include <linux/fs.h>
 #include <linux/module.h>
 #include <linux/parser.h>
 #include <linux/completion.h>
 #include <linux/vfs.h>
 #include <linux/mount.h>
 #include <linux/moduleparam.h>
 #include <linux/kthread.h>
 #include <linux/posix_acl.h>
 #include <linux/buffer_head.h>
 #include <linux/exportfs.h>
 #include <asm/uaccess.h>
 #include <linux/seq_file.h>
 #include "jfs_incore.h"
 #include "jfs_filsys.h"
 #include "jfs_inode.h"
 #include "jfs_metapage.h"
 #include "jfs_superblock.h"
 #include "jfs_dmap.h"
 #include "jfs_imap.h"
 #include "jfs_acl.h"
 #include "jfs_debug.h"
 MODULE_DESCRIPTION("The Journaled Filesystem (JFS)");
 MODULE_AUTHOR("Steve Best/Dave Kleikamp/Barry Arndt, IBM");
 MODULE_LICENSE("GPL");
 static struct kmem_cache * jfs_inode_cachep;
 static const struct super_operations jfs_super_operations;
 static const struct export_operations jfs_export_operations;
 static struct file_system_type jfs_fs_type;
 #define MAX_COMMIT_THREADS 64
 static int commit_threads = 0;
 module_param(commit_threads, int, 0);
 MODULE_PARM_DESC(commit_threads, "Number of commit threads");
 static struct task_struct *jfsCommitThread[MAX_COMMIT_THREADS];
 struct task_struct *jfsIOthread;
 struct task_struct *jfsSyncThread;
 #ifdef CONFIG_JFS_DEBUG
 int jfsloglevel = JFS_LOGLEVEL_WARN;
 module_param(jfsloglevel, int, 0644);
 MODULE_PARM_DESC(jfsloglevel, "Specify JFS loglevel (0, 1 or 2)");
 #endif
 static void jfs_handle_error(struct super_block *sb)
 {
 	struct jfs_sb_info *sbi = JFS_SBI(sb);
 	if (sb->s_flags & MS_RDONLY)
 		return;
 	updateSuper(sb, FM_DIRTY);
 	if (sbi->flag & JFS_ERR_PANIC)
 		panic("JFS (device %s): panic forced after error\n",
 			sb->s_id);
 	else if (sbi->flag & JFS_ERR_REMOUNT_RO) {
 		jfs_err("ERROR: (device %s): remounting filesystem "
 			"as read-only\n",
 			sb->s_id);
 		sb->s_flags |= MS_RDONLY;
 	}
 	/* nothing is done for continue beyond marking the superblock dirty */
 }
 void jfs_error(struct super_block *sb, const char * function, ...)
 {
 	static char error_buf[256];
 	va_list args;
 	va_start(args, function);
 	vsnprintf(error_buf, sizeof(error_buf), function, args);
 	va_end(args);
 	printk(KERN_ERR "ERROR: (device %s): %s\n", sb->s_id, error_buf);
 	jfs_handle_error(sb);
 }
 static struct inode *jfs_alloc_inode(struct super_block *sb)
 {
 	struct jfs_inode_info *jfs_inode;
 	jfs_inode = kmem_cache_alloc(jfs_inode_cachep, GFP_NOFS);
 	if (!jfs_inode)
 		return NULL;
 	return &jfs_inode->vfs_inode;
 }
 static void jfs_destroy_inode(struct inode *inode)
 {
 	struct jfs_inode_info *ji = JFS_IP(inode);
 	BUG_ON(!list_empty(&ji->anon_inode_list));
 	spin_lock_irq(&ji->ag_lock);
 	if (ji->active_ag != -1) {
 		struct bmap *bmap = JFS_SBI(inode->i_sb)->bmap;
 		atomic_dec(&bmap->db_active[ji->active_ag]);
 		ji->active_ag = -1;
 	}
 	spin_unlock_irq(&ji->ag_lock);
 #ifdef CONFIG_JFS_POSIX_ACL
 	if (ji->i_acl != JFS_ACL_NOT_CACHED) {
 		posix_acl_release(ji->i_acl);
 		ji->i_acl = JFS_ACL_NOT_CACHED;
 	}
 	if (ji->i_default_acl != JFS_ACL_NOT_CACHED) {
 		posix_acl_release(ji->i_default_acl);
 		ji->i_default_acl = JFS_ACL_NOT_CACHED;
 	}
 #endif
 	kmem_cache_free(jfs_inode_cachep, ji);
 }
 static int jfs_statfs(struct dentry *dentry, struct kstatfs *buf)
 {
 	struct jfs_sb_info *sbi = JFS_SBI(dentry->d_sb);
 	s64 maxinodes;
 	struct inomap *imap = JFS_IP(sbi->ipimap)->i_imap;
 	jfs_info("In jfs_statfs");
 	buf->f_type = JFS_SUPER_MAGIC;
 	buf->f_bsize = sbi->bsize;
 	buf->f_blocks = sbi->bmap->db_mapsize;
 	buf->f_bfree = sbi->bmap->db_nfree;
 	buf->f_bavail = sbi->bmap->db_nfree;
 	/*
 	 * If we really return the number of allocated & free inodes, some
 	 * applications will fail because they won't see enough free inodes.
 	 * We'll try to calculate some guess as to how may inodes we can
 	 * really allocate
 	 *
 	 * buf->f_files = atomic_read(&imap->im_numinos);
 	 * buf->f_ffree = atomic_read(&imap->im_numfree);
 	 */
 	maxinodes = min((s64) atomic_read(&imap->im_numinos) +
 			((sbi->bmap->db_nfree >> imap->im_l2nbperiext)
 			 << L2INOSPEREXT), (s64) 0xffffffffLL);
 	buf->f_files = maxinodes;
 	buf->f_ffree = maxinodes - (atomic_read(&imap->im_numinos) -
 				    atomic_read(&imap->im_numfree));
 	buf->f_namelen = JFS_NAME_MAX;
 	return 0;
 }
 static void jfs_put_super(struct super_block *sb)
 {
 	struct jfs_sb_info *sbi = JFS_SBI(sb);
 	int rc;
 	jfs_info("In jfs_put_super");
 	rc = jfs_umount(sb);
 	if (rc)
 		jfs_err("jfs_umount failed with return code %d", rc);
 	if (sbi->nls_tab)
 		unload_nls(sbi->nls_tab);
 	sbi->nls_tab = NULL;
 	truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
 	iput(sbi->direct_inode);
 	sbi->direct_inode = NULL;
 	kfree(sbi);
 }
 enum {
 	Opt_integrity, Opt_nointegrity, Opt_iocharset, Opt_resize,
 	Opt_resize_nosize, Opt_errors, Opt_ignore, Opt_err, Opt_quota,
 	Opt_usrquota, Opt_grpquota, Opt_uid, Opt_gid, Opt_umask
 };
 static match_table_t tokens = {
 	{Opt_integrity, "integrity"},
 	{Opt_nointegrity, "nointegrity"},
 	{Opt_iocharset, "iocharset=%s"},
 	{Opt_resize, "resize=%u"},
 	{Opt_resize_nosize, "resize"},
 	{Opt_errors, "errors=%s"},
 	{Opt_ignore, "noquota"},
 	{Opt_ignore, "quota"},
 	{Opt_usrquota, "usrquota"},
 	{Opt_grpquota, "grpquota"},
 	{Opt_uid, "uid=%u"},
 	{Opt_gid, "gid=%u"},
 	{Opt_umask, "umask=%u"},
 	{Opt_err, NULL}
 };
 static int parse_options(char *options, struct super_block *sb, s64 *newLVSize,
 			 int *flag)
 {
 	void *nls_map = (void *)-1;	/* -1: no change;  NULL: none */
 	char *p;
 	struct jfs_sb_info *sbi = JFS_SBI(sb);
 	*newLVSize = 0;
 	if (!options)
 		return 1;
 	while ((p = strsep(&options, ",")) != NULL) {
 		substring_t args[MAX_OPT_ARGS];
 		int token;
 		if (!*p)
 			continue;
 		token = match_token(p, tokens, args);
 		switch (token) {
 		case Opt_integrity:
 			*flag &= ~JFS_NOINTEGRITY;
 			break;
 		case Opt_nointegrity:
 			*flag |= JFS_NOINTEGRITY;
 			break;
 		case Opt_ignore:
 			/* Silently ignore the quota options */
 			/* Don't do anything ;-) */
 			break;
 		case Opt_iocharset:
 			if (nls_map && nls_map != (void *) -1)
 				unload_nls(nls_map);
 			if (!strcmp(args[0].from, "none"))
 				nls_map = NULL;
 			else {
 				nls_map = load_nls(args[0].from);
 				if (!nls_map) {
 					printk(KERN_ERR
 					       "JFS: charset not found\n");
 					goto cleanup;
 				}
 			}
 			break;
 		case Opt_resize:
 		{
 			char *resize = args[0].from;
 			*newLVSize = simple_strtoull(resize, &resize, 0);
 			break;
 		}
 		case Opt_resize_nosize:
 		{
 			*newLVSize = sb->s_bdev->bd_inode->i_size >>
 				sb->s_blocksize_bits;
 			if (*newLVSize == 0)
 				printk(KERN_ERR
 				       "JFS: Cannot determine volume size\n");
 			break;
 		}
 		case Opt_errors:
 		{
 			char *errors = args[0].from;
 			if (!errors || !*errors)
 				goto cleanup;
 			if (!strcmp(errors, "continue")) {
 				*flag &= ~JFS_ERR_REMOUNT_RO;
 				*flag &= ~JFS_ERR_PANIC;
 				*flag |= JFS_ERR_CONTINUE;
 			} else if (!strcmp(errors, "remount-ro")) {
 				*flag &= ~JFS_ERR_CONTINUE;
 				*flag &= ~JFS_ERR_PANIC;
 				*flag |= JFS_ERR_REMOUNT_RO;
 			} else if (!strcmp(errors, "panic")) {
 				*flag &= ~JFS_ERR_CONTINUE;
 				*flag &= ~JFS_ERR_REMOUNT_RO;
 				*flag |= JFS_ERR_PANIC;
 			} else {
 				printk(KERN_ERR
 				       "JFS: %s is an invalid error handler\n",
 				       errors);
 				goto cleanup;
 			}
 			break;
 		}
 #ifdef CONFIG_QUOTA
 		case Opt_quota:
 		case Opt_usrquota:
 			*flag |= JFS_USRQUOTA;
 			break;
 		case Opt_grpquota:
 			*flag |= JFS_GRPQUOTA;
 			break;
 #else
 		case Opt_usrquota:
 		case Opt_grpquota:
 		case Opt_quota:
 			printk(KERN_ERR
 			       "JFS: quota operations not supported\n");
 			break;
 #endif
 		case Opt_uid:
 		{
 			char *uid = args[0].from;
 			sbi->uid = simple_strtoul(uid, &uid, 0);
 			break;
 		}
 		case Opt_gid:
 		{
 			char *gid = args[0].from;
 			sbi->gid = simple_strtoul(gid, &gid, 0);
 			break;
 		}
 		case Opt_umask:
 		{
 			char *umask = args[0].from;
 			sbi->umask = simple_strtoul(umask, &umask, 8);
 			if (sbi->umask & ~0777) {
 				printk(KERN_ERR
 				       "JFS: Invalid value of umask\n");
 				goto cleanup;
 			}
 			break;
 		}
 		default:
 			printk("jfs: Unrecognized mount option \"%s\" "
 					" or missing value\n", p);
 			goto cleanup;
 		}
 	}
 	if (nls_map != (void *) -1) {
 		/* Discard old (if remount) */
 		if (sbi->nls_tab)
 			unload_nls(sbi->nls_tab);
 		sbi->nls_tab = nls_map;
 	}
 	return 1;
 cleanup:
 	if (nls_map && nls_map != (void *) -1)
 		unload_nls(nls_map);
 	return 0;
 }
 static int jfs_remount(struct super_block *sb, int *flags, char *data)
 {
 	s64 newLVSize = 0;
 	int rc = 0;
 	int flag = JFS_SBI(sb)->flag;
 	if (!parse_options(data, sb, &newLVSize, &flag)) {
 		return -EINVAL;
 	}
 	if (newLVSize) {
 		if (sb->s_flags & MS_RDONLY) {
 			printk(KERN_ERR
 		  "JFS: resize requires volume to be mounted read-write\n");
 			return -EROFS;
 		}
 		rc = jfs_extendfs(sb, newLVSize, 0);
 		if (rc)
 			return rc;
 	}
 	if ((sb->s_flags & MS_RDONLY) && !(*flags & MS_RDONLY)) {
 		/*
 		 * Invalidate any previously read metadata.  fsck may have
 		 * changed the on-disk data since we mounted r/o
 		 */
 		truncate_inode_pages(JFS_SBI(sb)->direct_inode->i_mapping, 0);
 		JFS_SBI(sb)->flag = flag;
 		return jfs_mount_rw(sb, 1);
 	}
 	if ((!(sb->s_flags & MS_RDONLY)) && (*flags & MS_RDONLY)) {
 		rc = jfs_umount_rw(sb);
 		JFS_SBI(sb)->flag = flag;
 		return rc;
 	}
 	if ((JFS_SBI(sb)->flag & JFS_NOINTEGRITY) != (flag & JFS_NOINTEGRITY))
 		if (!(sb->s_flags & MS_RDONLY)) {
 			rc = jfs_umount_rw(sb);
 			if (rc)
 				return rc;
 			JFS_SBI(sb)->flag = flag;
 			return jfs_mount_rw(sb, 1);
 		}
 	JFS_SBI(sb)->flag = flag;
 	return 0;
 }
 static int jfs_fill_super(struct super_block *sb, void *data, int silent)
 {
 	struct jfs_sb_info *sbi;
 	struct inode *inode;
 	int rc;
 	s64 newLVSize = 0;
-	int flag;
+	int flag, ret = -EINVAL;
 	jfs_info("In jfs_read_super: s_flags=0x%lx", sb->s_flags);
 	if (!new_valid_dev(sb->s_bdev->bd_dev))
 		return -EOVERFLOW;
 	sbi = kzalloc(sizeof (struct jfs_sb_info), GFP_KERNEL);
 	if (!sbi)
 		return -ENOMEM;
 	sb->s_fs_info = sbi;
 	sbi->sb = sb;
 	sbi->uid = sbi->gid = sbi->umask = -1;
 	/* initialize the mount flag and determine the default error handler */
 	flag = JFS_ERR_REMOUNT_RO;
 	if (!parse_options((char *) data, sb, &newLVSize, &flag)) {
 		kfree(sbi);
 		return -EINVAL;
 	}
 	sbi->flag = flag;
 #ifdef CONFIG_JFS_POSIX_ACL
 	sb->s_flags |= MS_POSIXACL;
 #endif
 	if (newLVSize) {
 		printk(KERN_ERR "resize option for remount only\n");
 		return -EINVAL;
 	}
 	/*
 	 * Initialize blocksize to 4K.
 	 */
 	sb_set_blocksize(sb, PSIZE);
 	/*
 	 * Set method vectors.
 	 */
 	sb->s_op = &jfs_super_operations;
 	sb->s_export_op = &jfs_export_operations;
 	/*
 	 * Initialize direct-mapping inode/address-space
 	 */
 	inode = new_inode(sb);
-	if (inode == NULL)
+	if (inode == NULL) {
+		ret = -ENOMEM;
 		goto out_kfree;
+	}
 	inode->i_ino = 0;
 	inode->i_nlink = 1;
 	inode->i_size = sb->s_bdev->bd_inode->i_size;
 	inode->i_mapping->a_ops = &jfs_metapage_aops;
 	insert_inode_hash(inode);
 	mapping_set_gfp_mask(inode->i_mapping, GFP_NOFS);
 	sbi->direct_inode = inode;
 	rc = jfs_mount(sb);
 	if (rc) {
 		if (!silent) {
 			jfs_err("jfs_mount failed w/return code = %d", rc);
 		}
 		goto out_mount_failed;
 	}
 	if (sb->s_flags & MS_RDONLY)
 		sbi->log = NULL;
 	else {
 		rc = jfs_mount_rw(sb, 0);
 		if (rc) {
 			if (!silent) {
 				jfs_err("jfs_mount_rw failed, return code = %d",
 					rc);
 			}
 			goto out_no_rw;
 		}
 	}
 	sb->s_magic = JFS_SUPER_MAGIC;
-	inode = iget(sb, ROOT_I);
+	inode = jfs_iget(sb, ROOT_I);
-	if (!inode || is_bad_inode(inode))
+	if (IS_ERR(inode)) {
+		ret = PTR_ERR(inode);
 		goto out_no_root;
+	}
 	sb->s_root = d_alloc_root(inode);
 	if (!sb->s_root)
 		goto out_no_root;
 	if (sbi->mntflag & JFS_OS2)
 		sb->s_root->d_op = &jfs_ci_dentry_operations;
 	/* logical blocks are represented by 40 bits in pxd_t, etc. */
 	sb->s_maxbytes = ((u64) sb->s_blocksize) << 40;
 #if BITS_PER_LONG == 32
 	/*
 	 * Page cache is indexed by long.
 	 * I would use MAX_LFS_FILESIZE, but it's only half as big
 	 */
 	sb->s_maxbytes = min(((u64) PAGE_CACHE_SIZE << 32) - 1, sb->s_maxbytes);
 #endif
 	sb->s_time_gran = 1;
 	return 0;
 out_no_root:
 	jfs_err("jfs_read_super: get root inode failed");
 	if (inode)
 		iput(inode);
 out_no_rw:
 	rc = jfs_umount(sb);
 	if (rc) {
 		jfs_err("jfs_umount failed with return code %d", rc);
 	}
 out_mount_failed:
 	filemap_write_and_wait(sbi->direct_inode->i_mapping);
 	truncate_inode_pages(sbi->direct_inode->i_mapping, 0);
 	make_bad_inode(sbi->direct_inode);
 	iput(sbi->direct_inode);
 	sbi->direct_inode = NULL;
 out_kfree:
 	if (sbi->nls_tab)
 		unload_nls(sbi->nls_tab);
 	kfree(sbi);
-	return -EINVAL;
+	return ret;
 }
 static void jfs_write_super_lockfs(struct super_block *sb)
 {
 	struct jfs_sb_info *sbi = JFS_SBI(sb);
 	struct jfs_log *log = sbi->log;
 	if (!(sb->s_flags & MS_RDONLY)) {
 		txQuiesce(sb);
 		lmLogShutdown(log);
 		updateSuper(sb, FM_CLEAN);
 	}
 }
 static void jfs_unlockfs(struct super_block *sb)
 {
 	struct jfs_sb_info *sbi = JFS_SBI(sb);
 	struct jfs_log *log = sbi->log;
 	int rc = 0;
 	if (!(sb->s_flags & MS_RDONLY)) {
 		updateSuper(sb, FM_MOUNT);
 		if ((rc = lmLogInit(log)))
 			jfs_err("jfs_unlock failed with return code %d", rc);
 		else
 			txResume(sb);
 	}
 }
 static int jfs_get_sb(struct file_system_type *fs_type,
 	int flags, const char *dev_name, void *data, struct vfsmount *mnt)
 {
 	return get_sb_bdev(fs_type, flags, dev_name, data, jfs_fill_super,
 			   mnt);
 }
 static int jfs_sync_fs(struct super_block *sb, int wait)
 {
 	struct jfs_log *log = JFS_SBI(sb)->log;
 	/* log == NULL indicates read-only mount */
 	if (log) {
 		jfs_flush_journal(log, wait);
 		jfs_syncpt(log, 0);
 	}
 	return 0;
 }
 static int jfs_show_options(struct seq_file *seq, struct vfsmount *vfs)
 {
 	struct jfs_sb_info *sbi = JFS_SBI(vfs->mnt_sb);
 	if (sbi->uid != -1)
 		seq_printf(seq, ",uid=%d", sbi->uid);
 	if (sbi->gid != -1)
 		seq_printf(seq, ",gid=%d", sbi->gid);
 	if (sbi->umask != -1)
 		seq_printf(seq, ",umask=%03o", sbi->umask);
 	if (sbi->flag & JFS_NOINTEGRITY)
 		seq_puts(seq, ",nointegrity");
 	if (sbi->nls_tab)
 		seq_printf(seq, ",iocharset=%s", sbi->nls_tab->charset);
 	if (sbi->flag & JFS_ERR_CONTINUE)
 		seq_printf(seq, ",errors=continue");
 	if (sbi->flag & JFS_ERR_PANIC)
 		seq_printf(seq, ",errors=panic");
 #ifdef CONFIG_QUOTA
 	if (sbi->flag & JFS_USRQUOTA)
 		seq_puts(seq, ",usrquota");
 	if (sbi->flag & JFS_GRPQUOTA)
 		seq_puts(seq, ",grpquota");
 #endif
 	return 0;
 }
 #ifdef CONFIG_QUOTA
 /* Read data from quotafile - avoid pagecache and such because we cannot afford
  * acquiring the locks... As quota files are never truncated and quota code
  * itself serializes the operations (and noone else should touch the files)
  * we don't have to be afraid of races */
 static ssize_t jfs_quota_read(struct super_block *sb, int type, char *data,
 			      size_t len, loff_t off)
 {
 	struct inode *inode = sb_dqopt(sb)->files[type];
 	sector_t blk = off >> sb->s_blocksize_bits;
 	int err = 0;
 	int offset = off & (sb->s_blocksize - 1);
 	int tocopy;
 	size_t toread;
 	struct buffer_head tmp_bh;
 	struct buffer_head *bh;
 	loff_t i_size = i_size_read(inode);
 	if (off > i_size)
 		return 0;
 	if (off+len > i_size)
 		len = i_size-off;
 	toread = len;
 	while (toread > 0) {
 		tocopy = sb->s_blocksize - offset < toread ?
 				sb->s_blocksize - offset : toread;
 		tmp_bh.b_state = 0;
 		tmp_bh.b_size = 1 << inode->i_blkbits;
 		err = jfs_get_block(inode, blk, &tmp_bh, 0);
 		if (err)
 			return err;
 		if (!buffer_mapped(&tmp_bh))	/* A hole? */
 			memset(data, 0, tocopy);
 		else {
 			bh = sb_bread(sb, tmp_bh.b_blocknr);
 			if (!bh)
 				return -EIO;
 			memcpy(data, bh->b_data+offset, tocopy);
 			brelse(bh);
 		}
 		offset = 0;
 		toread -= tocopy;
 		data += tocopy;
 		blk++;
 	}
 	return len;
 }
 /* Write to quotafile */
 static ssize_t jfs_quota_write(struct super_block *sb, int type,
 			       const char *data, size_t len, loff_t off)
 {
 	struct inode *inode = sb_dqopt(sb)->files[type];
 	sector_t blk = off >> sb->s_blocksize_bits;
 	int err = 0;
 	int offset = off & (sb->s_blocksize - 1);
 	int tocopy;
 	size_t towrite = len;
 	struct buffer_head tmp_bh;
 	struct buffer_head *bh;
 	mutex_lock(&inode->i_mutex);
 	while (towrite > 0) {
 		tocopy = sb->s_blocksize - offset < towrite ?
 				sb->s_blocksize - offset : towrite;
 		tmp_bh.b_state = 0;
 		tmp_bh.b_size = 1 << inode->i_blkbits;
 		err = jfs_get_block(inode, blk, &tmp_bh, 1);
 		if (err)
 			goto out;
 		if (offset || tocopy != sb->s_blocksize)
 			bh = sb_bread(sb, tmp_bh.b_blocknr);
 		else
 			bh = sb_getblk(sb, tmp_bh.b_blocknr);
 		if (!bh) {
 			err = -EIO;
 			goto out;
 		}
 		lock_buffer(bh);
 		memcpy(bh->b_data+offset, data, tocopy);
 		flush_dcache_page(bh->b_page);
 		set_buffer_uptodate(bh);
 		mark_buffer_dirty(bh);
 		unlock_buffer(bh);
 		brelse(bh);
 		offset = 0;
 		towrite -= tocopy;
 		data += tocopy;
 		blk++;
 	}
 out:
 	if (len == towrite)
 		return err;
 	if (inode->i_size < off+len-towrite)
 		i_size_write(inode, off+len-towrite);
 	inode->i_version++;
 	inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 	mark_inode_dirty(inode);
 	mutex_unlock(&inode->i_mutex);
 	return len - towrite;
 }
 #endif
 static const struct super_operations jfs_super_operations = {
 	.alloc_inode	= jfs_alloc_inode,
 	.destroy_inode	= jfs_destroy_inode,
-	.read_inode	= jfs_read_inode,
 	.dirty_inode	= jfs_dirty_inode,
 	.write_inode	= jfs_write_inode,
 	.delete_inode	= jfs_delete_inode,
 	.put_super	= jfs_put_super,
 	.sync_fs	= jfs_sync_fs,
 	.write_super_lockfs = jfs_write_super_lockfs,
 	.unlockfs       = jfs_unlockfs,
 	.statfs		= jfs_statfs,
 	.remount_fs	= jfs_remount,
 	.show_options	= jfs_show_options,
 #ifdef CONFIG_QUOTA
 	.quota_read	= jfs_quota_read,
 	.quota_write	= jfs_quota_write,
 #endif
 };
 static const struct export_operations jfs_export_operations = {
 	.fh_to_dentry	= jfs_fh_to_dentry,
 	.fh_to_parent	= jfs_fh_to_parent,
 	.get_parent	= jfs_get_parent,
 };
 static struct file_system_type jfs_fs_type = {
 	.owner		= THIS_MODULE,
 	.name		= "jfs",
 	.get_sb		= jfs_get_sb,
 	.kill_sb	= kill_block_super,
 	.fs_flags	= FS_REQUIRES_DEV,
 };
 static void init_once(struct kmem_cache *cachep, void *foo)
 {
 	struct jfs_inode_info *jfs_ip = (struct jfs_inode_info *) foo;
 	memset(jfs_ip, 0, sizeof(struct jfs_inode_info));
 	INIT_LIST_HEAD(&jfs_ip->anon_inode_list);
 	init_rwsem(&jfs_ip->rdwrlock);
 	mutex_init(&jfs_ip->commit_mutex);
 	init_rwsem(&jfs_ip->xattr_sem);
 	spin_lock_init(&jfs_ip->ag_lock);
 	jfs_ip->active_ag = -1;
 #ifdef CONFIG_JFS_POSIX_ACL
 	jfs_ip->i_acl = JFS_ACL_NOT_CACHED;
 	jfs_ip->i_default_acl = JFS_ACL_NOT_CACHED;
 #endif
 	inode_init_once(&jfs_ip->vfs_inode);
 }
 static int __init init_jfs_fs(void)
 {
 	int i;
 	int rc;
 	jfs_inode_cachep =
 	    kmem_cache_create("jfs_ip", sizeof(struct jfs_inode_info), 0,
 			    SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD,
 			    init_once);
 	if (jfs_inode_cachep == NULL)
 		return -ENOMEM;
 	/*
 	 * Metapage initialization
 	 */
 	rc = metapage_init();
 	if (rc) {
 		jfs_err("metapage_init failed w/rc = %d", rc);
 		goto free_slab;
 	}
 	/*
 	 * Transaction Manager initialization
 	 */
 	rc = txInit();
 	if (rc) {
 		jfs_err("txInit failed w/rc = %d", rc);
 		goto free_metapage;
 	}
 	/*
 	 * I/O completion thread (endio)
 	 */
 	jfsIOthread = kthread_run(jfsIOWait, NULL, "jfsIO");
 	if (IS_ERR(jfsIOthread)) {
 		rc = PTR_ERR(jfsIOthread);
 		jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
 		goto end_txmngr;
 	}
 	if (commit_threads < 1)
 		commit_threads = num_online_cpus();
 	if (commit_threads > MAX_COMMIT_THREADS)
 		commit_threads = MAX_COMMIT_THREADS;
 	for (i = 0; i < commit_threads; i++) {
 		jfsCommitThread[i] = kthread_run(jfs_lazycommit, NULL, "jfsCommit");
 		if (IS_ERR(jfsCommitThread[i])) {
 			rc = PTR_ERR(jfsCommitThread[i]);
 			jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
 			commit_threads = i;
 			goto kill_committask;
 		}
 	}
 	jfsSyncThread = kthread_run(jfs_sync, NULL, "jfsSync");
 	if (IS_ERR(jfsSyncThread)) {
 		rc = PTR_ERR(jfsSyncThread);
 		jfs_err("init_jfs_fs: fork failed w/rc = %d", rc);
 		goto kill_committask;
 	}
 #ifdef PROC_FS_JFS
 	jfs_proc_init();
 #endif
 	return register_filesystem(&jfs_fs_type);
 kill_committask:
 	for (i = 0; i < commit_threads; i++)
 		kthread_stop(jfsCommitThread[i]);
 	kthread_stop(jfsIOthread);
 end_txmngr:
 	txExit();
 free_metapage:
 	metapage_exit();
 free_slab:
 	kmem_cache_destroy(jfs_inode_cachep);
 	return rc;
 }
 static void __exit exit_jfs_fs(void)
 {
 	int i;
 	jfs_info("exit_jfs_fs called");
 	txExit();
 	metapage_exit();
 	kthread_stop(jfsIOthread);
 	for (i = 0; i < commit_threads; i++)
 		kthread_stop(jfsCommitThread[i]);
 	kthread_stop(jfsSyncThread);
 #ifdef PROC_FS_JFS
 	jfs_proc_clean();
 #endif
 	unregister_filesystem(&jfs_fs_type);
 	kmem_cache_destroy(jfs_inode_cachep);
 }
 module_init(init_jfs_fs)
 module_exit(exit_jfs_fs)