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