blob: bd3df1ca3c9b7f955571c056f86f98e97beda7b9 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Dave Kleikamp63f83c92006-10-02 09:55:27 -05007 * the Free Software Foundation; either version 2 of the License, or
Linus Torvalds1da177e2005-04-16 15:20:36 -07008 * (at your option) any later version.
Dave Kleikamp63f83c92006-10-02 09:55:27 -05009 *
Linus Torvalds1da177e2005-04-16 15:20:36 -070010 * 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
Dave Kleikamp63f83c92006-10-02 09:55:27 -050016 * along with this program; if not, write to the Free Software
Linus Torvalds1da177e2005-04-16 15:20:36 -070017 * 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>
Christoph Hellwiga9185b42010-03-05 09:21:37 +010025#include <linux/writeback.h>
Kent Overstreeta27bb332013-05-07 16:19:08 -070026#include <linux/aio.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070027#include "jfs_incore.h"
Dave Kleikamp1868f4a2005-05-04 15:29:35 -050028#include "jfs_inode.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070029#include "jfs_filsys.h"
30#include "jfs_imap.h"
31#include "jfs_extent.h"
32#include "jfs_unicode.h"
33#include "jfs_debug.h"
34
35
David Howellseab1df72008-02-07 00:15:43 -080036struct inode *jfs_iget(struct super_block *sb, unsigned long ino)
Linus Torvalds1da177e2005-04-16 15:20:36 -070037{
David Howellseab1df72008-02-07 00:15:43 -080038 struct inode *inode;
39 int ret;
40
41 inode = iget_locked(sb, ino);
42 if (!inode)
43 return ERR_PTR(-ENOMEM);
44 if (!(inode->i_state & I_NEW))
45 return inode;
46
47 ret = diRead(inode);
48 if (ret < 0) {
49 iget_failed(inode);
50 return ERR_PTR(ret);
Linus Torvalds1da177e2005-04-16 15:20:36 -070051 }
52
53 if (S_ISREG(inode->i_mode)) {
54 inode->i_op = &jfs_file_inode_operations;
55 inode->i_fop = &jfs_file_operations;
56 inode->i_mapping->a_ops = &jfs_aops;
57 } else if (S_ISDIR(inode->i_mode)) {
58 inode->i_op = &jfs_dir_inode_operations;
59 inode->i_fop = &jfs_dir_operations;
60 } else if (S_ISLNK(inode->i_mode)) {
61 if (inode->i_size >= IDATASIZE) {
62 inode->i_op = &page_symlink_inode_operations;
63 inode->i_mapping->a_ops = &jfs_aops;
Dave Kleikampd69e83d2008-12-16 10:21:34 -060064 } else {
Dmitry Monakhovc7f2e1f2010-04-16 08:05:50 -050065 inode->i_op = &jfs_fast_symlink_inode_operations;
Dave Kleikampd69e83d2008-12-16 10:21:34 -060066 /*
67 * The inline data should be null-terminated, but
68 * don't let on-disk corruption crash the kernel
69 */
70 JFS_IP(inode)->i_inline[inode->i_size] = '\0';
71 }
Linus Torvalds1da177e2005-04-16 15:20:36 -070072 } else {
73 inode->i_op = &jfs_file_inode_operations;
74 init_special_inode(inode, inode->i_mode, inode->i_rdev);
75 }
David Howellseab1df72008-02-07 00:15:43 -080076 unlock_new_inode(inode);
77 return inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -070078}
79
80/*
81 * Workhorse of both fsync & write_inode
82 */
83int jfs_commit_inode(struct inode *inode, int wait)
84{
85 int rc = 0;
86 tid_t tid;
87 static int noisy = 5;
88
89 jfs_info("In jfs_commit_inode, inode = 0x%p", inode);
90
91 /*
92 * Don't commit if inode has been committed since last being
93 * marked dirty, or if it has been deleted.
94 */
95 if (inode->i_nlink == 0 || !test_cflag(COMMIT_Dirty, inode))
96 return 0;
97
98 if (isReadOnly(inode)) {
99 /* kernel allows writes to devices on read-only
100 * partitions and may think inode is dirty
101 */
102 if (!special_file(inode->i_mode) && noisy) {
103 jfs_err("jfs_commit_inode(0x%p) called on "
104 "read-only volume", inode);
105 jfs_err("Is remount racy?");
106 noisy--;
107 }
108 return 0;
109 }
110
111 tid = txBegin(inode->i_sb, COMMIT_INODE);
Ingo Molnar1de87442006-01-24 15:22:50 -0600112 mutex_lock(&JFS_IP(inode)->commit_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
114 /*
Ingo Molnar1de87442006-01-24 15:22:50 -0600115 * Retest inode state after taking commit_mutex
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 */
117 if (inode->i_nlink && test_cflag(COMMIT_Dirty, inode))
118 rc = txCommit(tid, 1, &inode, wait ? COMMIT_SYNC : 0);
119
120 txEnd(tid);
Ingo Molnar1de87442006-01-24 15:22:50 -0600121 mutex_unlock(&JFS_IP(inode)->commit_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122 return rc;
123}
124
Christoph Hellwiga9185b42010-03-05 09:21:37 +0100125int jfs_write_inode(struct inode *inode, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126{
Christoph Hellwiga9185b42010-03-05 09:21:37 +0100127 int wait = wbc->sync_mode == WB_SYNC_ALL;
128
Dave Kleikamp73aaa222013-05-01 11:08:38 -0500129 if (inode->i_nlink == 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 return 0;
131 /*
132 * If COMMIT_DIRTY is not set, the inode isn't really dirty.
133 * It has been committed since the last change, but was still
134 * on the dirty inode list.
135 */
136 if (!test_cflag(COMMIT_Dirty, inode)) {
137 /* Make sure committed changes hit the disk */
138 jfs_flush_journal(JFS_SBI(inode->i_sb)->log, wait);
139 return 0;
140 }
141
142 if (jfs_commit_inode(inode, wait)) {
143 jfs_err("jfs_write_inode: jfs_commit_inode failed!");
144 return -EIO;
145 } else
146 return 0;
147}
148
Al Viro62aff862010-06-07 00:28:54 -0400149void jfs_evict_inode(struct inode *inode)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700150{
Al Viro62aff862010-06-07 00:28:54 -0400151 jfs_info("In jfs_evict_inode, inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152
Al Viro62aff862010-06-07 00:28:54 -0400153 if (!inode->i_nlink && !is_bad_inode(inode)) {
Christoph Hellwig871a2932010-03-03 09:05:07 -0500154 dquot_initialize(inode);
Christoph Hellwig907f4552010-03-03 09:05:06 -0500155
Al Viro62aff862010-06-07 00:28:54 -0400156 if (JFS_IP(inode)->fileset == FILESYSTEM_I) {
Johannes Weiner91b0abe2014-04-03 14:47:49 -0700157 truncate_inode_pages_final(&inode->i_data);
Al Viro62aff862010-06-07 00:28:54 -0400158
159 if (test_cflag(COMMIT_Freewmap, inode))
160 jfs_free_zero_link(inode);
161
162 diFree(inode);
163
164 /*
165 * Free the inode from the quota allocation.
166 */
167 dquot_initialize(inode);
168 dquot_free_inode(inode);
169 }
170 } else {
Johannes Weiner91b0abe2014-04-03 14:47:49 -0700171 truncate_inode_pages_final(&inode->i_data);
Dave Kleikampb1b5d7f2005-08-30 14:28:56 -0500172 }
Jan Karadbd57682012-05-03 14:48:02 +0200173 clear_inode(inode);
Al Viro62aff862010-06-07 00:28:54 -0400174 dquot_drop(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175}
176
Christoph Hellwigaa385722011-05-27 06:53:02 -0400177void jfs_dirty_inode(struct inode *inode, int flags)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178{
179 static int noisy = 5;
180
181 if (isReadOnly(inode)) {
182 if (!special_file(inode->i_mode) && noisy) {
183 /* kernel allows writes to devices on read-only
184 * partitions and may try to mark inode dirty
185 */
186 jfs_err("jfs_dirty_inode called on read-only volume");
187 jfs_err("Is remount racy?");
188 noisy--;
189 }
190 return;
191 }
192
193 set_cflag(COMMIT_Dirty, inode);
194}
195
Dave Kleikamp115ff502006-07-26 14:52:13 -0500196int jfs_get_block(struct inode *ip, sector_t lblock,
197 struct buffer_head *bh_result, int create)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198{
199 s64 lblock64 = lblock;
200 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 xad_t xad;
202 s64 xaddr;
203 int xflag;
Dave Kleikamp115ff502006-07-26 14:52:13 -0500204 s32 xlen = bh_result->b_size >> ip->i_blkbits;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205
206 /*
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 * Take appropriate lock on inode
208 */
Dave Kleikamp7fab4792005-05-02 12:25:02 -0600209 if (create)
Dave Kleikamp82d5b9a2007-01-09 14:14:48 -0600210 IWRITE_LOCK(ip, RDWRLOCK_NORMAL);
Dave Kleikamp7fab4792005-05-02 12:25:02 -0600211 else
Dave Kleikamp82d5b9a2007-01-09 14:14:48 -0600212 IREAD_LOCK(ip, RDWRLOCK_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213
214 if (((lblock64 << ip->i_sb->s_blocksize_bits) < ip->i_size) &&
Dave Kleikamp115ff502006-07-26 14:52:13 -0500215 (!xtLookup(ip, lblock64, xlen, &xflag, &xaddr, &xlen, 0)) &&
Dave Kleikamp66284652005-05-02 12:25:13 -0600216 xaddr) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 if (xflag & XAD_NOTRECORDED) {
218 if (!create)
219 /*
220 * Allocated but not recorded, read treats
221 * this as a hole
222 */
223 goto unlock;
224#ifdef _JFS_4K
225 XADoffset(&xad, lblock64);
226 XADlength(&xad, xlen);
227 XADaddress(&xad, xaddr);
228#else /* _JFS_4K */
229 /*
230 * As long as block size = 4K, this isn't a problem.
231 * We should mark the whole page not ABNR, but how
232 * will we know to mark the other blocks BH_New?
233 */
234 BUG();
235#endif /* _JFS_4K */
236 rc = extRecord(ip, &xad);
237 if (rc)
238 goto unlock;
239 set_buffer_new(bh_result);
240 }
241
242 map_bh(bh_result, ip->i_sb, xaddr);
243 bh_result->b_size = xlen << ip->i_blkbits;
244 goto unlock;
245 }
246 if (!create)
247 goto unlock;
248
249 /*
250 * Allocate a new block
251 */
252#ifdef _JFS_4K
253 if ((rc = extHint(ip, lblock64 << ip->i_sb->s_blocksize_bits, &xad)))
254 goto unlock;
Richard Knutsson4d817152006-09-30 23:27:14 -0700255 rc = extAlloc(ip, xlen, lblock64, &xad, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 if (rc)
257 goto unlock;
258
259 set_buffer_new(bh_result);
260 map_bh(bh_result, ip->i_sb, addressXAD(&xad));
261 bh_result->b_size = lengthXAD(&xad) << ip->i_blkbits;
262
263#else /* _JFS_4K */
264 /*
265 * We need to do whatever it takes to keep all but the last buffers
266 * in 4K pages - see jfs_write.c
267 */
268 BUG();
269#endif /* _JFS_4K */
270
271 unlock:
272 /*
273 * Release lock on inode
274 */
Dave Kleikamp7fab4792005-05-02 12:25:02 -0600275 if (create)
276 IWRITE_UNLOCK(ip);
277 else
278 IREAD_UNLOCK(ip);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 return rc;
280}
281
Linus Torvalds1da177e2005-04-16 15:20:36 -0700282static int jfs_writepage(struct page *page, struct writeback_control *wbc)
283{
Nick Piggind5c5f842007-10-16 01:25:22 -0700284 return block_write_full_page(page, jfs_get_block, wbc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700285}
286
287static int jfs_writepages(struct address_space *mapping,
288 struct writeback_control *wbc)
289{
290 return mpage_writepages(mapping, wbc, jfs_get_block);
291}
292
293static int jfs_readpage(struct file *file, struct page *page)
294{
295 return mpage_readpage(page, jfs_get_block);
296}
297
298static int jfs_readpages(struct file *file, struct address_space *mapping,
299 struct list_head *pages, unsigned nr_pages)
300{
301 return mpage_readpages(mapping, pages, nr_pages, jfs_get_block);
302}
303
Marco Stornelli86dd07d2012-12-15 11:54:25 +0100304static void jfs_write_failed(struct address_space *mapping, loff_t to)
305{
306 struct inode *inode = mapping->host;
307
308 if (to > inode->i_size) {
Kirill A. Shutemov7caef262013-09-12 15:13:56 -0700309 truncate_pagecache(inode, inode->i_size);
Marco Stornelli86dd07d2012-12-15 11:54:25 +0100310 jfs_truncate(inode);
311 }
312}
313
Nick Piggind5c5f842007-10-16 01:25:22 -0700314static int jfs_write_begin(struct file *file, struct address_space *mapping,
315 loff_t pos, unsigned len, unsigned flags,
316 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700317{
Christoph Hellwigea0f04e2010-06-04 11:29:54 +0200318 int ret;
319
320 ret = nobh_write_begin(mapping, pos, len, flags, pagep, fsdata,
Nick Piggind5c5f842007-10-16 01:25:22 -0700321 jfs_get_block);
Marco Stornelli86dd07d2012-12-15 11:54:25 +0100322 if (unlikely(ret))
323 jfs_write_failed(mapping, pos + len);
Christoph Hellwigea0f04e2010-06-04 11:29:54 +0200324
325 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326}
327
328static sector_t jfs_bmap(struct address_space *mapping, sector_t block)
329{
330 return generic_block_bmap(mapping, block, jfs_get_block);
331}
332
333static ssize_t jfs_direct_IO(int rw, struct kiocb *iocb,
Al Virod8d3d942014-03-04 21:27:34 -0500334 struct iov_iter *iter, loff_t offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700335{
336 struct file *file = iocb->ki_filp;
Marco Stornelli86dd07d2012-12-15 11:54:25 +0100337 struct address_space *mapping = file->f_mapping;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700338 struct inode *inode = file->f_mapping->host;
Al Viroa6cbcd42014-03-04 22:38:00 -0500339 size_t count = iov_iter_count(iter);
Christoph Hellwigeafdc7d2010-06-04 11:29:53 +0200340 ssize_t ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341
Al Viro31b14032014-03-05 01:33:16 -0500342 ret = blockdev_direct_IO(rw, iocb, inode, iter, offset, jfs_get_block);
Christoph Hellwigeafdc7d2010-06-04 11:29:53 +0200343
344 /*
345 * In case of error extending write may have instantiated a few
346 * blocks outside i_size. Trim these off again.
347 */
348 if (unlikely((rw & WRITE) && ret < 0)) {
349 loff_t isize = i_size_read(inode);
Al Viroa6cbcd42014-03-04 22:38:00 -0500350 loff_t end = offset + count;
Christoph Hellwigeafdc7d2010-06-04 11:29:53 +0200351
352 if (end > isize)
Marco Stornelli86dd07d2012-12-15 11:54:25 +0100353 jfs_write_failed(mapping, end);
Christoph Hellwigeafdc7d2010-06-04 11:29:53 +0200354 }
355
356 return ret;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700357}
358
Christoph Hellwigf5e54d62006-06-28 04:26:44 -0700359const struct address_space_operations jfs_aops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 .readpage = jfs_readpage,
361 .readpages = jfs_readpages,
362 .writepage = jfs_writepage,
363 .writepages = jfs_writepages,
Nick Piggind5c5f842007-10-16 01:25:22 -0700364 .write_begin = jfs_write_begin,
Nick Piggin03158cd2007-10-16 01:25:25 -0700365 .write_end = nobh_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 .bmap = jfs_bmap,
367 .direct_IO = jfs_direct_IO,
368};
369
370/*
371 * Guts of jfs_truncate. Called with locks already held. Can be called
372 * with directory for truncating directory index table.
373 */
374void jfs_truncate_nolock(struct inode *ip, loff_t length)
375{
376 loff_t newsize;
377 tid_t tid;
378
379 ASSERT(length >= 0);
380
381 if (test_cflag(COMMIT_Nolink, ip)) {
382 xtTruncate(0, ip, length, COMMIT_WMAP);
383 return;
384 }
385
386 do {
387 tid = txBegin(ip->i_sb, 0);
388
389 /*
Ingo Molnar1de87442006-01-24 15:22:50 -0600390 * The commit_mutex cannot be taken before txBegin.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700391 * txBegin may block and there is a chance the inode
392 * could be marked dirty and need to be committed
393 * before txBegin unblocks
394 */
Ingo Molnar1de87442006-01-24 15:22:50 -0600395 mutex_lock(&JFS_IP(ip)->commit_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700396
397 newsize = xtTruncate(tid, ip, length,
398 COMMIT_TRUNCATE | COMMIT_PWMAP);
399 if (newsize < 0) {
400 txEnd(tid);
Ingo Molnar1de87442006-01-24 15:22:50 -0600401 mutex_unlock(&JFS_IP(ip)->commit_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700402 break;
403 }
404
405 ip->i_mtime = ip->i_ctime = CURRENT_TIME;
406 mark_inode_dirty(ip);
407
408 txCommit(tid, 1, &ip, 0);
409 txEnd(tid);
Ingo Molnar1de87442006-01-24 15:22:50 -0600410 mutex_unlock(&JFS_IP(ip)->commit_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700411 } while (newsize > length); /* Truncate isn't always atomic */
412}
413
414void jfs_truncate(struct inode *ip)
415{
416 jfs_info("jfs_truncate: size = 0x%lx", (ulong) ip->i_size);
417
Nick Piggin03158cd2007-10-16 01:25:25 -0700418 nobh_truncate_page(ip->i_mapping, ip->i_size, jfs_get_block);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419
Dave Kleikamp82d5b9a2007-01-09 14:14:48 -0600420 IWRITE_LOCK(ip, RDWRLOCK_NORMAL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421 jfs_truncate_nolock(ip, ip->i_size);
422 IWRITE_UNLOCK(ip);
423}