blob: 5653fa42930b6afbe29b5dce9e88511c502c8e54 [file] [log] [blame]
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001/*
Mingming Cao617ba132006-10-11 01:20:53 -07002 * linux/fs/ext4/inode.c
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003 *
4 * Copyright (C) 1992, 1993, 1994, 1995
5 * Remy Card (card@masi.ibp.fr)
6 * Laboratoire MASI - Institut Blaise Pascal
7 * Universite Pierre et Marie Curie (Paris VI)
8 *
9 * from
10 *
11 * linux/fs/minix/inode.c
12 *
13 * Copyright (C) 1991, 1992 Linus Torvalds
14 *
Dave Kleikampac27a0e2006-10-11 01:20:50 -070015 * 64-bit file support on 64-bit platforms by Jakub Jelinek
16 * (jj@sunsite.ms.mff.cuni.cz)
17 *
Mingming Cao617ba132006-10-11 01:20:53 -070018 * Assorted race fixes, rewrite of ext4_get_block() by Al Viro, 2000
Dave Kleikampac27a0e2006-10-11 01:20:50 -070019 */
20
Dave Kleikampac27a0e2006-10-11 01:20:50 -070021#include <linux/fs.h>
22#include <linux/time.h>
Mingming Caodab291a2006-10-11 01:21:01 -070023#include <linux/jbd2.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070024#include <linux/highuid.h>
25#include <linux/pagemap.h>
26#include <linux/quotaops.h>
27#include <linux/string.h>
28#include <linux/buffer_head.h>
29#include <linux/writeback.h>
Alex Tomas64769242008-07-11 19:27:31 -040030#include <linux/pagevec.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070031#include <linux/mpage.h>
Duane Griffine83c1392008-12-19 20:47:15 +000032#include <linux/namei.h>
Dave Kleikampac27a0e2006-10-11 01:20:50 -070033#include <linux/uio.h>
34#include <linux/bio.h>
Mingming Cao4c0425f2009-09-28 15:48:41 -040035#include <linux/workqueue.h>
Jiaying Zhang744692d2010-03-04 16:14:02 -050036#include <linux/kernel.h>
Andrew Morton6db26ff2011-01-12 16:59:13 -080037#include <linux/printk.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090038#include <linux/slab.h>
Theodore Ts'oa8901d32010-12-17 10:40:47 -050039#include <linux/ratelimit.h>
Kent Overstreeta27bb332013-05-07 16:19:08 -070040#include <linux/aio.h>
Theodore Ts'o00a1a052014-03-30 10:20:01 -040041#include <linux/bitops.h>
Theodore Ts'o9bffad12009-06-17 11:48:11 -040042
Christoph Hellwig3dcf5452008-04-29 18:13:32 -040043#include "ext4_jbd2.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070044#include "xattr.h"
45#include "acl.h"
Theodore Ts'o9f125d62011-06-27 19:16:04 -040046#include "truncate.h"
Dave Kleikampac27a0e2006-10-11 01:20:50 -070047
Theodore Ts'o9bffad12009-06-17 11:48:11 -040048#include <trace/events/ext4.h>
49
Aneesh Kumar K.Va1d6cc52008-08-19 21:55:02 -040050#define MPAGE_DA_EXTENT_TAIL 0x01
51
Darrick J. Wong814525f2012-04-29 18:31:10 -040052static __u32 ext4_inode_csum(struct inode *inode, struct ext4_inode *raw,
53 struct ext4_inode_info *ei)
54{
55 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
56 __u16 csum_lo;
57 __u16 csum_hi = 0;
58 __u32 csum;
59
Dmitry Monakhov171a7f22013-04-09 23:56:48 -040060 csum_lo = le16_to_cpu(raw->i_checksum_lo);
Darrick J. Wong814525f2012-04-29 18:31:10 -040061 raw->i_checksum_lo = 0;
62 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
63 EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi)) {
Dmitry Monakhov171a7f22013-04-09 23:56:48 -040064 csum_hi = le16_to_cpu(raw->i_checksum_hi);
Darrick J. Wong814525f2012-04-29 18:31:10 -040065 raw->i_checksum_hi = 0;
66 }
67
68 csum = ext4_chksum(sbi, ei->i_csum_seed, (__u8 *)raw,
69 EXT4_INODE_SIZE(inode->i_sb));
70
Dmitry Monakhov171a7f22013-04-09 23:56:48 -040071 raw->i_checksum_lo = cpu_to_le16(csum_lo);
Darrick J. Wong814525f2012-04-29 18:31:10 -040072 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
73 EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))
Dmitry Monakhov171a7f22013-04-09 23:56:48 -040074 raw->i_checksum_hi = cpu_to_le16(csum_hi);
Darrick J. Wong814525f2012-04-29 18:31:10 -040075
76 return csum;
77}
78
79static int ext4_inode_csum_verify(struct inode *inode, struct ext4_inode *raw,
80 struct ext4_inode_info *ei)
81{
82 __u32 provided, calculated;
83
84 if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
85 cpu_to_le32(EXT4_OS_LINUX) ||
Dmitry Monakhov9aa5d322014-10-13 03:36:16 -040086 !ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wong814525f2012-04-29 18:31:10 -040087 return 1;
88
89 provided = le16_to_cpu(raw->i_checksum_lo);
90 calculated = ext4_inode_csum(inode, raw, ei);
91 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
92 EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))
93 provided |= ((__u32)le16_to_cpu(raw->i_checksum_hi)) << 16;
94 else
95 calculated &= 0xFFFF;
96
97 return provided == calculated;
98}
99
100static void ext4_inode_csum_set(struct inode *inode, struct ext4_inode *raw,
101 struct ext4_inode_info *ei)
102{
103 __u32 csum;
104
105 if (EXT4_SB(inode->i_sb)->s_es->s_creator_os !=
106 cpu_to_le32(EXT4_OS_LINUX) ||
Dmitry Monakhov9aa5d322014-10-13 03:36:16 -0400107 !ext4_has_metadata_csum(inode->i_sb))
Darrick J. Wong814525f2012-04-29 18:31:10 -0400108 return;
109
110 csum = ext4_inode_csum(inode, raw, ei);
111 raw->i_checksum_lo = cpu_to_le16(csum & 0xFFFF);
112 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE &&
113 EXT4_FITS_IN_INODE(raw, ei, i_checksum_hi))
114 raw->i_checksum_hi = cpu_to_le16(csum >> 16);
115}
116
Jan Kara678aaf42008-07-11 19:27:31 -0400117static inline int ext4_begin_ordered_truncate(struct inode *inode,
118 loff_t new_size)
119{
Theodore Ts'o7ff9c072010-11-08 13:51:33 -0500120 trace_ext4_begin_ordered_truncate(inode, new_size);
Theodore Ts'o8aefcd52011-01-10 12:29:43 -0500121 /*
122 * If jinode is zero, then we never opened the file for
123 * writing, so there's no need to call
124 * jbd2_journal_begin_ordered_truncate() since there's no
125 * outstanding writes we need to flush.
126 */
127 if (!EXT4_I(inode)->jinode)
128 return 0;
129 return jbd2_journal_begin_ordered_truncate(EXT4_JOURNAL(inode),
130 EXT4_I(inode)->jinode,
131 new_size);
Jan Kara678aaf42008-07-11 19:27:31 -0400132}
133
Lukas Czernerd47992f2013-05-21 23:17:23 -0400134static void ext4_invalidatepage(struct page *page, unsigned int offset,
135 unsigned int length);
Theodore Ts'ocb20d512010-10-27 21:30:09 -0400136static int __ext4_journalled_writepage(struct page *page, unsigned int len);
137static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh);
Jan Karafffb2732013-06-04 13:01:11 -0400138static int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
139 int pextents);
Alex Tomas64769242008-07-11 19:27:31 -0400140
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700141/*
142 * Test whether an inode is a fast symlink.
143 */
Mingming Cao617ba132006-10-11 01:20:53 -0700144static int ext4_inode_is_fast_symlink(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700145{
Yongqiang Yang65eddb52014-01-06 14:06:18 -0500146 int ea_blocks = EXT4_I(inode)->i_file_acl ?
147 EXT4_CLUSTER_SIZE(inode->i_sb) >> 9 : 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700148
Zheng Liubd9db172014-06-02 10:48:22 -0400149 if (ext4_has_inline_data(inode))
150 return 0;
151
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700152 return (S_ISLNK(inode->i_mode) && inode->i_blocks - ea_blocks == 0);
153}
154
155/*
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700156 * Restart the transaction associated with *handle. This does a commit,
157 * so before we call here everything must be consistently dirtied against
158 * this transaction.
159 */
Aneesh Kumar K.Vfa5d1112009-11-02 18:50:49 -0500160int ext4_truncate_restart_trans(handle_t *handle, struct inode *inode,
Jan Kara487caee2009-08-17 22:17:20 -0400161 int nblocks)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700162{
Jan Kara487caee2009-08-17 22:17:20 -0400163 int ret;
164
165 /*
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400166 * Drop i_data_sem to avoid deadlock with ext4_map_blocks. At this
Jan Kara487caee2009-08-17 22:17:20 -0400167 * moment, get_block can be called only for blocks inside i_size since
168 * page cache has been already dropped and writes are blocked by
169 * i_mutex. So we can safely drop the i_data_sem here.
170 */
Frank Mayhar03901312009-01-07 00:06:22 -0500171 BUG_ON(EXT4_JOURNAL(inode) == NULL);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700172 jbd_debug(2, "restarting handle %p\n", handle);
Jan Kara487caee2009-08-17 22:17:20 -0400173 up_write(&EXT4_I(inode)->i_data_sem);
Amir Goldstein8e8eaab2011-02-27 23:32:12 -0500174 ret = ext4_journal_restart(handle, nblocks);
Jan Kara487caee2009-08-17 22:17:20 -0400175 down_write(&EXT4_I(inode)->i_data_sem);
Aneesh Kumar K.Vfa5d1112009-11-02 18:50:49 -0500176 ext4_discard_preallocations(inode);
Jan Kara487caee2009-08-17 22:17:20 -0400177
178 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700179}
180
181/*
182 * Called at the last iput() if i_nlink is zero.
183 */
Al Viro0930fcc2010-06-07 13:16:22 -0400184void ext4_evict_inode(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700185{
186 handle_t *handle;
Theodore Ts'obc965ab2008-08-02 21:10:38 -0400187 int err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700188
Theodore Ts'o7ff9c072010-11-08 13:51:33 -0500189 trace_ext4_evict_inode(inode);
Jiaying Zhang2581fdc2011-08-13 12:17:13 -0400190
Al Viro0930fcc2010-06-07 13:16:22 -0400191 if (inode->i_nlink) {
Jan Kara2d859db2011-07-26 09:07:11 -0400192 /*
193 * When journalling data dirty buffers are tracked only in the
194 * journal. So although mm thinks everything is clean and
195 * ready for reaping the inode might still have some pages to
196 * write in the running transaction or waiting to be
197 * checkpointed. Thus calling jbd2_journal_invalidatepage()
198 * (via truncate_inode_pages()) to discard these buffers can
199 * cause data loss. Also even if we did not discard these
200 * buffers, we would have no way to find them after the inode
201 * is reaped and thus user could see stale data if he tries to
202 * read them before the transaction is checkpointed. So be
203 * careful and force everything to disk here... We use
204 * ei->i_datasync_tid to store the newest transaction
205 * containing inode's data.
206 *
207 * Note that directories do not have this problem because they
208 * don't use page cache.
209 */
210 if (ext4_should_journal_data(inode) &&
Theodore Ts'o2b405bf2013-03-20 09:42:11 -0400211 (S_ISLNK(inode->i_mode) || S_ISREG(inode->i_mode)) &&
212 inode->i_ino != EXT4_JOURNAL_INO) {
Jan Kara2d859db2011-07-26 09:07:11 -0400213 journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
214 tid_t commit_tid = EXT4_I(inode)->i_datasync_tid;
215
Theodore Ts'od76a3a772013-04-03 22:02:52 -0400216 jbd2_complete_transaction(journal, commit_tid);
Jan Kara2d859db2011-07-26 09:07:11 -0400217 filemap_write_and_wait(&inode->i_data);
218 }
Johannes Weiner91b0abe2014-04-03 14:47:49 -0700219 truncate_inode_pages_final(&inode->i_data);
Jan Kara5dc23bd2013-06-04 14:46:12 -0400220
221 WARN_ON(atomic_read(&EXT4_I(inode)->i_ioend_count));
Al Viro0930fcc2010-06-07 13:16:22 -0400222 goto no_delete;
223 }
224
Theodore Ts'oe2bfb082014-10-05 22:47:07 -0400225 if (is_bad_inode(inode))
226 goto no_delete;
227 dquot_initialize(inode);
Christoph Hellwig907f4552010-03-03 09:05:06 -0500228
Jan Kara678aaf42008-07-11 19:27:31 -0400229 if (ext4_should_order_data(inode))
230 ext4_begin_ordered_truncate(inode, 0);
Johannes Weiner91b0abe2014-04-03 14:47:49 -0700231 truncate_inode_pages_final(&inode->i_data);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700232
Jan Kara5dc23bd2013-06-04 14:46:12 -0400233 WARN_ON(atomic_read(&EXT4_I(inode)->i_ioend_count));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700234
Jan Kara8e8ad8a2012-06-12 16:20:38 +0200235 /*
236 * Protect us against freezing - iput() caller didn't have to have any
237 * protection against it
238 */
239 sb_start_intwrite(inode->i_sb);
Theodore Ts'o9924a922013-02-08 21:59:22 -0500240 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE,
241 ext4_blocks_for_truncate(inode)+3);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700242 if (IS_ERR(handle)) {
Theodore Ts'obc965ab2008-08-02 21:10:38 -0400243 ext4_std_error(inode->i_sb, PTR_ERR(handle));
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700244 /*
245 * If we're going to skip the normal cleanup, we still need to
246 * make sure that the in-core orphan linked list is properly
247 * cleaned up.
248 */
Mingming Cao617ba132006-10-11 01:20:53 -0700249 ext4_orphan_del(NULL, inode);
Jan Kara8e8ad8a2012-06-12 16:20:38 +0200250 sb_end_intwrite(inode->i_sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700251 goto no_delete;
252 }
253
254 if (IS_SYNC(inode))
Frank Mayhar03901312009-01-07 00:06:22 -0500255 ext4_handle_sync(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700256 inode->i_size = 0;
Theodore Ts'obc965ab2008-08-02 21:10:38 -0400257 err = ext4_mark_inode_dirty(handle, inode);
258 if (err) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500259 ext4_warning(inode->i_sb,
Theodore Ts'obc965ab2008-08-02 21:10:38 -0400260 "couldn't mark inode dirty (err %d)", err);
261 goto stop_handle;
262 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700263 if (inode->i_blocks)
Mingming Cao617ba132006-10-11 01:20:53 -0700264 ext4_truncate(inode);
Theodore Ts'obc965ab2008-08-02 21:10:38 -0400265
266 /*
267 * ext4_ext_truncate() doesn't reserve any slop when it
268 * restarts journal transactions; therefore there may not be
269 * enough credits left in the handle to remove the inode from
270 * the orphan list and set the dtime field.
271 */
Frank Mayhar03901312009-01-07 00:06:22 -0500272 if (!ext4_handle_has_enough_credits(handle, 3)) {
Theodore Ts'obc965ab2008-08-02 21:10:38 -0400273 err = ext4_journal_extend(handle, 3);
274 if (err > 0)
275 err = ext4_journal_restart(handle, 3);
276 if (err != 0) {
Eric Sandeen12062dd2010-02-15 14:19:27 -0500277 ext4_warning(inode->i_sb,
Theodore Ts'obc965ab2008-08-02 21:10:38 -0400278 "couldn't extend journal (err %d)", err);
279 stop_handle:
280 ext4_journal_stop(handle);
Theodore Ts'o45388212010-07-29 15:06:10 -0400281 ext4_orphan_del(NULL, inode);
Jan Kara8e8ad8a2012-06-12 16:20:38 +0200282 sb_end_intwrite(inode->i_sb);
Theodore Ts'obc965ab2008-08-02 21:10:38 -0400283 goto no_delete;
284 }
285 }
286
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700287 /*
Mingming Cao617ba132006-10-11 01:20:53 -0700288 * Kill off the orphan record which ext4_truncate created.
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700289 * AKPM: I think this can be inside the above `if'.
Mingming Cao617ba132006-10-11 01:20:53 -0700290 * Note that ext4_orphan_del() has to be able to cope with the
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700291 * deletion of a non-existent orphan - this is because we don't
Mingming Cao617ba132006-10-11 01:20:53 -0700292 * know if ext4_truncate() actually created an orphan record.
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700293 * (Well, we could do this if we need to, but heck - it works)
294 */
Mingming Cao617ba132006-10-11 01:20:53 -0700295 ext4_orphan_del(handle, inode);
296 EXT4_I(inode)->i_dtime = get_seconds();
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700297
298 /*
299 * One subtle ordering requirement: if anything has gone wrong
300 * (transaction abort, IO errors, whatever), then we can still
301 * do these next steps (the fs will already have been marked as
302 * having errors), but we can't free the inode if the mark_dirty
303 * fails.
304 */
Mingming Cao617ba132006-10-11 01:20:53 -0700305 if (ext4_mark_inode_dirty(handle, inode))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700306 /* If that failed, just do the required in-core inode clear. */
Al Viro0930fcc2010-06-07 13:16:22 -0400307 ext4_clear_inode(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700308 else
Mingming Cao617ba132006-10-11 01:20:53 -0700309 ext4_free_inode(handle, inode);
310 ext4_journal_stop(handle);
Jan Kara8e8ad8a2012-06-12 16:20:38 +0200311 sb_end_intwrite(inode->i_sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700312 return;
313no_delete:
Al Viro0930fcc2010-06-07 13:16:22 -0400314 ext4_clear_inode(inode); /* We must guarantee clearing of inode... */
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700315}
316
Dmitry Monakhova9e7f442009-12-14 15:21:14 +0300317#ifdef CONFIG_QUOTA
318qsize_t *ext4_get_reserved_space(struct inode *inode)
Mingming Cao60e58e02009-01-22 18:13:05 +0100319{
Dmitry Monakhova9e7f442009-12-14 15:21:14 +0300320 return &EXT4_I(inode)->i_reserved_quota;
Mingming Cao60e58e02009-01-22 18:13:05 +0100321}
Dmitry Monakhova9e7f442009-12-14 15:21:14 +0300322#endif
Theodore Ts'o9d0be502010-01-01 02:41:30 -0500323
Aneesh Kumar K.V12219ae2008-07-17 16:12:08 -0400324/*
Theodore Ts'o0637c6f2009-12-30 14:20:45 -0500325 * Called with i_data_sem down, which is important since we can call
326 * ext4_discard_preallocations() from here.
327 */
Aneesh Kumar K.V5f634d02010-01-25 04:00:31 -0500328void ext4_da_update_reserve_space(struct inode *inode,
329 int used, int quota_claim)
Aneesh Kumar K.V12219ae2008-07-17 16:12:08 -0400330{
331 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Theodore Ts'o0637c6f2009-12-30 14:20:45 -0500332 struct ext4_inode_info *ei = EXT4_I(inode);
Aneesh Kumar K.V12219ae2008-07-17 16:12:08 -0400333
Theodore Ts'o0637c6f2009-12-30 14:20:45 -0500334 spin_lock(&ei->i_block_reservation_lock);
Aditya Kalid8990242011-09-09 19:18:51 -0400335 trace_ext4_da_update_reserve_space(inode, used, quota_claim);
Theodore Ts'o0637c6f2009-12-30 14:20:45 -0500336 if (unlikely(used > ei->i_reserved_data_blocks)) {
Theodore Ts'o8de5c322013-02-14 15:11:41 -0500337 ext4_warning(inode->i_sb, "%s: ino %lu, used %d "
Theodore Ts'o1084f252012-03-19 23:13:43 -0400338 "with only %d reserved data blocks",
Theodore Ts'o0637c6f2009-12-30 14:20:45 -0500339 __func__, inode->i_ino, used,
340 ei->i_reserved_data_blocks);
341 WARN_ON(1);
342 used = ei->i_reserved_data_blocks;
Aneesh Kumar K.V6bc6e632008-10-10 09:39:00 -0400343 }
Aneesh Kumar K.V12219ae2008-07-17 16:12:08 -0400344
Theodore Ts'o0637c6f2009-12-30 14:20:45 -0500345 /* Update per-inode reservations */
346 ei->i_reserved_data_blocks -= used;
Theodore Ts'o71d4f7d2014-07-15 06:02:38 -0400347 percpu_counter_sub(&sbi->s_dirtyclusters_counter, used);
Theodore Ts'o0637c6f2009-12-30 14:20:45 -0500348
Aneesh Kumar K.V12219ae2008-07-17 16:12:08 -0400349 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
Mingming Cao60e58e02009-01-22 18:13:05 +0100350
Eric Sandeen72b8ab92010-05-16 11:00:00 -0400351 /* Update quota subsystem for data blocks */
352 if (quota_claim)
Aditya Kali7b415bf2011-09-09 19:04:51 -0400353 dquot_claim_block(inode, EXT4_C2B(sbi, used));
Eric Sandeen72b8ab92010-05-16 11:00:00 -0400354 else {
Aneesh Kumar K.V5f634d02010-01-25 04:00:31 -0500355 /*
356 * We did fallocate with an offset that is already delayed
357 * allocated. So on delayed allocated writeback we should
Eric Sandeen72b8ab92010-05-16 11:00:00 -0400358 * not re-claim the quota for fallocated blocks.
Aneesh Kumar K.V5f634d02010-01-25 04:00:31 -0500359 */
Aditya Kali7b415bf2011-09-09 19:04:51 -0400360 dquot_release_reservation_block(inode, EXT4_C2B(sbi, used));
Aneesh Kumar K.V5f634d02010-01-25 04:00:31 -0500361 }
Aneesh Kumar K.Vd6014302009-03-27 22:36:43 -0400362
363 /*
364 * If we have done all the pending block allocations and if
365 * there aren't any writers on the inode, we can discard the
366 * inode's preallocations.
367 */
Theodore Ts'o0637c6f2009-12-30 14:20:45 -0500368 if ((ei->i_reserved_data_blocks == 0) &&
369 (atomic_read(&inode->i_writecount) == 0))
Aneesh Kumar K.Vd6014302009-03-27 22:36:43 -0400370 ext4_discard_preallocations(inode);
Aneesh Kumar K.V12219ae2008-07-17 16:12:08 -0400371}
372
Theodore Ts'oe29136f2010-06-29 12:54:28 -0400373static int __check_block_validity(struct inode *inode, const char *func,
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400374 unsigned int line,
375 struct ext4_map_blocks *map)
Theodore Ts'o6fd058f2009-05-17 15:38:01 -0400376{
Theodore Ts'o24676da2010-05-16 21:00:00 -0400377 if (!ext4_data_block_valid(EXT4_SB(inode->i_sb), map->m_pblk,
378 map->m_len)) {
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400379 ext4_error_inode(inode, func, line, map->m_pblk,
380 "lblock %lu mapped to illegal pblock "
381 "(length %d)", (unsigned long) map->m_lblk,
382 map->m_len);
Theodore Ts'o6fd058f2009-05-17 15:38:01 -0400383 return -EIO;
384 }
385 return 0;
386}
387
Theodore Ts'oe29136f2010-06-29 12:54:28 -0400388#define check_block_validity(inode, map) \
Theodore Ts'oc398eda2010-07-27 11:56:40 -0400389 __check_block_validity((inode), __func__, __LINE__, (map))
Theodore Ts'oe29136f2010-06-29 12:54:28 -0400390
Dmitry Monakhov921f2662013-03-10 21:01:03 -0400391#ifdef ES_AGGRESSIVE_TEST
392static void ext4_map_blocks_es_recheck(handle_t *handle,
393 struct inode *inode,
394 struct ext4_map_blocks *es_map,
395 struct ext4_map_blocks *map,
396 int flags)
397{
398 int retval;
399
400 map->m_flags = 0;
401 /*
402 * There is a race window that the result is not the same.
403 * e.g. xfstests #223 when dioread_nolock enables. The reason
404 * is that we lookup a block mapping in extent status tree with
405 * out taking i_data_sem. So at the time the unwritten extent
406 * could be converted.
407 */
408 if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
Lukas Czernerc8b459f2014-05-12 12:55:07 -0400409 down_read(&EXT4_I(inode)->i_data_sem);
Dmitry Monakhov921f2662013-03-10 21:01:03 -0400410 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
411 retval = ext4_ext_map_blocks(handle, inode, map, flags &
412 EXT4_GET_BLOCKS_KEEP_SIZE);
413 } else {
414 retval = ext4_ind_map_blocks(handle, inode, map, flags &
415 EXT4_GET_BLOCKS_KEEP_SIZE);
416 }
417 if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
418 up_read((&EXT4_I(inode)->i_data_sem));
Dmitry Monakhov921f2662013-03-10 21:01:03 -0400419
420 /*
421 * We don't check m_len because extent will be collpased in status
422 * tree. So the m_len might not equal.
423 */
424 if (es_map->m_lblk != map->m_lblk ||
425 es_map->m_flags != map->m_flags ||
426 es_map->m_pblk != map->m_pblk) {
Theodore Ts'obdafe422013-07-13 00:40:31 -0400427 printk("ES cache assertion failed for inode: %lu "
Dmitry Monakhov921f2662013-03-10 21:01:03 -0400428 "es_cached ex [%d/%d/%llu/%x] != "
429 "found ex [%d/%d/%llu/%x] retval %d flags %x\n",
430 inode->i_ino, es_map->m_lblk, es_map->m_len,
431 es_map->m_pblk, es_map->m_flags, map->m_lblk,
432 map->m_len, map->m_pblk, map->m_flags,
433 retval, flags);
434 }
435}
436#endif /* ES_AGGRESSIVE_TEST */
437
Theodore Ts'o55138e02009-09-29 13:31:31 -0400438/*
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400439 * The ext4_map_blocks() function tries to look up the requested blocks,
Theodore Ts'o2b2d6d02008-07-26 16:15:44 -0400440 * and returns if the blocks are already mapped.
Mingming Caof5ab0d12008-02-25 15:29:55 -0500441 *
Mingming Caof5ab0d12008-02-25 15:29:55 -0500442 * Otherwise it takes the write lock of the i_data_sem and allocate blocks
443 * and store the allocated blocks in the result buffer head and mark it
444 * mapped.
445 *
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400446 * If file type is extents based, it will call ext4_ext_map_blocks(),
447 * Otherwise, call with ext4_ind_map_blocks() to handle indirect mapping
Mingming Caof5ab0d12008-02-25 15:29:55 -0500448 * based files
449 *
Lukas Czerner556615d2014-04-20 23:45:47 -0400450 * On success, it returns the number of blocks being mapped or allocated.
451 * if create==0 and the blocks are pre-allocated and unwritten block,
Mingming Caof5ab0d12008-02-25 15:29:55 -0500452 * the result buffer head is unmapped. If the create ==1, it will make sure
453 * the buffer head is mapped.
454 *
455 * It returns 0 if plain look up failed (blocks have not been allocated), in
Tao Madf3ab172011-10-08 15:53:49 -0400456 * that case, buffer head is unmapped
Mingming Caof5ab0d12008-02-25 15:29:55 -0500457 *
458 * It returns the error in case of allocation failure.
459 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400460int ext4_map_blocks(handle_t *handle, struct inode *inode,
461 struct ext4_map_blocks *map, int flags)
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -0500462{
Zheng Liud100eef2013-02-18 00:29:59 -0500463 struct extent_status es;
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -0500464 int retval;
Lukas Czernerb8a86842014-03-18 18:05:35 -0400465 int ret = 0;
Dmitry Monakhov921f2662013-03-10 21:01:03 -0400466#ifdef ES_AGGRESSIVE_TEST
467 struct ext4_map_blocks orig_map;
468
469 memcpy(&orig_map, map, sizeof(*map));
470#endif
Mingming Caof5ab0d12008-02-25 15:29:55 -0500471
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400472 map->m_flags = 0;
473 ext_debug("ext4_map_blocks(): inode %lu, flag %d, max_blocks %u,"
474 "logical block %lu\n", inode->i_ino, flags, map->m_len,
475 (unsigned long) map->m_lblk);
Zheng Liud100eef2013-02-18 00:29:59 -0500476
Theodore Ts'oe861b5e2014-02-20 12:54:05 -0500477 /*
478 * ext4_map_blocks returns an int, and m_len is an unsigned int
479 */
480 if (unlikely(map->m_len > INT_MAX))
481 map->m_len = INT_MAX;
482
Kazuya Mio4adb6ab2014-04-07 10:53:28 -0400483 /* We can handle the block number less than EXT_MAX_BLOCKS */
484 if (unlikely(map->m_lblk >= EXT_MAX_BLOCKS))
485 return -EIO;
486
Zheng Liud100eef2013-02-18 00:29:59 -0500487 /* Lookup extent status tree firstly */
488 if (ext4_es_lookup_extent(inode, map->m_lblk, &es)) {
489 if (ext4_es_is_written(&es) || ext4_es_is_unwritten(&es)) {
490 map->m_pblk = ext4_es_pblock(&es) +
491 map->m_lblk - es.es_lblk;
492 map->m_flags |= ext4_es_is_written(&es) ?
493 EXT4_MAP_MAPPED : EXT4_MAP_UNWRITTEN;
494 retval = es.es_len - (map->m_lblk - es.es_lblk);
495 if (retval > map->m_len)
496 retval = map->m_len;
497 map->m_len = retval;
498 } else if (ext4_es_is_delayed(&es) || ext4_es_is_hole(&es)) {
499 retval = 0;
500 } else {
501 BUG_ON(1);
502 }
Dmitry Monakhov921f2662013-03-10 21:01:03 -0400503#ifdef ES_AGGRESSIVE_TEST
504 ext4_map_blocks_es_recheck(handle, inode, map,
505 &orig_map, flags);
506#endif
Zheng Liud100eef2013-02-18 00:29:59 -0500507 goto found;
508 }
509
Aneesh Kumar K.V4df3d262008-01-28 23:58:29 -0500510 /*
Theodore Ts'ob920c752009-05-14 00:54:29 -0400511 * Try to see if we can get the block without requesting a new
512 * file system block.
Aneesh Kumar K.V4df3d262008-01-28 23:58:29 -0500513 */
Zheng Liu729f52c2012-07-09 16:29:29 -0400514 if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
Lukas Czernerc8b459f2014-05-12 12:55:07 -0400515 down_read(&EXT4_I(inode)->i_data_sem);
Dmitry Monakhov12e9b892010-05-16 22:00:00 -0400516 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
Dmitry Monakhova4e5d882011-10-25 08:15:12 -0400517 retval = ext4_ext_map_blocks(handle, inode, map, flags &
518 EXT4_GET_BLOCKS_KEEP_SIZE);
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -0500519 } else {
Dmitry Monakhova4e5d882011-10-25 08:15:12 -0400520 retval = ext4_ind_map_blocks(handle, inode, map, flags &
521 EXT4_GET_BLOCKS_KEEP_SIZE);
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -0500522 }
Zheng Liuf7fec032013-02-18 00:28:47 -0500523 if (retval > 0) {
Theodore Ts'o3be78c72013-08-16 21:22:41 -0400524 unsigned int status;
Zheng Liuf7fec032013-02-18 00:28:47 -0500525
Zheng Liu44fb851d2013-07-29 12:51:42 -0400526 if (unlikely(retval != map->m_len)) {
527 ext4_warning(inode->i_sb,
528 "ES len assertion failed for inode "
529 "%lu: retval %d != map->m_len %d",
530 inode->i_ino, retval, map->m_len);
531 WARN_ON(1);
Dmitry Monakhov921f2662013-03-10 21:01:03 -0400532 }
Dmitry Monakhov921f2662013-03-10 21:01:03 -0400533
Zheng Liuf7fec032013-02-18 00:28:47 -0500534 status = map->m_flags & EXT4_MAP_UNWRITTEN ?
535 EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
536 if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) &&
537 ext4_find_delalloc_range(inode, map->m_lblk,
538 map->m_lblk + map->m_len - 1))
539 status |= EXTENT_STATUS_DELAYED;
540 ret = ext4_es_insert_extent(inode, map->m_lblk,
541 map->m_len, map->m_pblk, status);
542 if (ret < 0)
543 retval = ret;
544 }
Zheng Liu729f52c2012-07-09 16:29:29 -0400545 if (!(flags & EXT4_GET_BLOCKS_NO_LOCK))
546 up_read((&EXT4_I(inode)->i_data_sem));
Mingming Caof5ab0d12008-02-25 15:29:55 -0500547
Zheng Liud100eef2013-02-18 00:29:59 -0500548found:
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400549 if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
Lukas Czernerb8a86842014-03-18 18:05:35 -0400550 ret = check_block_validity(inode, map);
Theodore Ts'o6fd058f2009-05-17 15:38:01 -0400551 if (ret != 0)
552 return ret;
553 }
554
Mingming Caof5ab0d12008-02-25 15:29:55 -0500555 /* If it is only a block(s) look up */
Theodore Ts'oc2177052009-05-14 00:58:52 -0400556 if ((flags & EXT4_GET_BLOCKS_CREATE) == 0)
Aneesh Kumar K.V4df3d262008-01-28 23:58:29 -0500557 return retval;
558
559 /*
Mingming Caof5ab0d12008-02-25 15:29:55 -0500560 * Returns if the blocks have already allocated
561 *
562 * Note that if blocks have been preallocated
Tao Madf3ab172011-10-08 15:53:49 -0400563 * ext4_ext_get_block() returns the create = 0
Mingming Caof5ab0d12008-02-25 15:29:55 -0500564 * with buffer head unmapped.
565 */
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400566 if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED)
Lukas Czernerb8a86842014-03-18 18:05:35 -0400567 /*
568 * If we need to convert extent to unwritten
569 * we continue and do the actual work in
570 * ext4_ext_map_blocks()
571 */
572 if (!(flags & EXT4_GET_BLOCKS_CONVERT_UNWRITTEN))
573 return retval;
Mingming Caof5ab0d12008-02-25 15:29:55 -0500574
575 /*
Zheng Liua25a4e12013-02-18 00:28:04 -0500576 * Here we clear m_flags because after allocating an new extent,
577 * it will be set again.
Aneesh Kumar K.V2a8964d2009-05-14 17:05:39 -0400578 */
Zheng Liua25a4e12013-02-18 00:28:04 -0500579 map->m_flags &= ~EXT4_MAP_FLAGS;
Aneesh Kumar K.V2a8964d2009-05-14 17:05:39 -0400580
581 /*
Lukas Czerner556615d2014-04-20 23:45:47 -0400582 * New blocks allocate and/or writing to unwritten extent
Mingming Caof5ab0d12008-02-25 15:29:55 -0500583 * will possibly result in updating i_data, so we take
Seunghun Leed91bd2c2014-09-01 22:15:30 -0400584 * the write lock of i_data_sem, and call get_block()
Mingming Caof5ab0d12008-02-25 15:29:55 -0500585 * with create == 1 flag.
Aneesh Kumar K.V4df3d262008-01-28 23:58:29 -0500586 */
Lukas Czernerc8b459f2014-05-12 12:55:07 -0400587 down_write(&EXT4_I(inode)->i_data_sem);
Mingming Caod2a17632008-07-14 17:52:37 -0400588
589 /*
Aneesh Kumar K.V4df3d262008-01-28 23:58:29 -0500590 * We need to check for EXT4 here because migrate
591 * could have changed the inode type in between
592 */
Dmitry Monakhov12e9b892010-05-16 22:00:00 -0400593 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400594 retval = ext4_ext_map_blocks(handle, inode, map, flags);
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -0500595 } else {
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400596 retval = ext4_ind_map_blocks(handle, inode, map, flags);
Aneesh Kumar K.V267e4db2008-04-29 08:11:12 -0400597
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400598 if (retval > 0 && map->m_flags & EXT4_MAP_NEW) {
Aneesh Kumar K.V267e4db2008-04-29 08:11:12 -0400599 /*
600 * We allocated new blocks which will result in
601 * i_data's format changing. Force the migrate
602 * to fail by clearing migrate flags
603 */
Theodore Ts'o19f5fb72010-01-24 14:34:07 -0500604 ext4_clear_inode_state(inode, EXT4_STATE_EXT_MIGRATE);
Aneesh Kumar K.V267e4db2008-04-29 08:11:12 -0400605 }
Mingming Caod2a17632008-07-14 17:52:37 -0400606
Aneesh Kumar K.V5f634d02010-01-25 04:00:31 -0500607 /*
608 * Update reserved blocks/metadata blocks after successful
609 * block allocation which had been deferred till now. We don't
610 * support fallocate for non extent files. So we can update
611 * reserve space here.
612 */
613 if ((retval > 0) &&
Aneesh Kumar K.V1296cc82010-01-15 01:27:59 -0500614 (flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE))
Aneesh Kumar K.V5f634d02010-01-25 04:00:31 -0500615 ext4_da_update_reserve_space(inode, retval, 1);
616 }
Theodore Ts'o2ac3b6e2009-05-14 13:57:08 -0400617
Zheng Liuf7fec032013-02-18 00:28:47 -0500618 if (retval > 0) {
Theodore Ts'o3be78c72013-08-16 21:22:41 -0400619 unsigned int status;
Zheng Liuf7fec032013-02-18 00:28:47 -0500620
Zheng Liu44fb851d2013-07-29 12:51:42 -0400621 if (unlikely(retval != map->m_len)) {
622 ext4_warning(inode->i_sb,
623 "ES len assertion failed for inode "
624 "%lu: retval %d != map->m_len %d",
625 inode->i_ino, retval, map->m_len);
626 WARN_ON(1);
Dmitry Monakhov921f2662013-03-10 21:01:03 -0400627 }
Dmitry Monakhov921f2662013-03-10 21:01:03 -0400628
Zheng Liuadb23552013-03-10 21:13:05 -0400629 /*
630 * If the extent has been zeroed out, we don't need to update
631 * extent status tree.
632 */
633 if ((flags & EXT4_GET_BLOCKS_PRE_IO) &&
634 ext4_es_lookup_extent(inode, map->m_lblk, &es)) {
635 if (ext4_es_is_written(&es))
636 goto has_zeroout;
637 }
Zheng Liuf7fec032013-02-18 00:28:47 -0500638 status = map->m_flags & EXT4_MAP_UNWRITTEN ?
639 EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
640 if (!(flags & EXT4_GET_BLOCKS_DELALLOC_RESERVE) &&
641 ext4_find_delalloc_range(inode, map->m_lblk,
642 map->m_lblk + map->m_len - 1))
643 status |= EXTENT_STATUS_DELAYED;
644 ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
645 map->m_pblk, status);
646 if (ret < 0)
647 retval = ret;
Aditya Kali5356f262011-09-09 19:20:51 -0400648 }
649
Zheng Liuadb23552013-03-10 21:13:05 -0400650has_zeroout:
Aneesh Kumar K.V4df3d262008-01-28 23:58:29 -0500651 up_write((&EXT4_I(inode)->i_data_sem));
Theodore Ts'oe35fd662010-05-16 19:00:00 -0400652 if (retval > 0 && map->m_flags & EXT4_MAP_MAPPED) {
Lukas Czernerb8a86842014-03-18 18:05:35 -0400653 ret = check_block_validity(inode, map);
Theodore Ts'o6fd058f2009-05-17 15:38:01 -0400654 if (ret != 0)
655 return ret;
656 }
Aneesh Kumar K.V0e855ac2008-01-28 23:58:26 -0500657 return retval;
658}
659
Mingming Caof3bd1f32008-08-19 22:16:03 -0400660/* Maximum number of blocks we map for direct IO at once. */
661#define DIO_MAX_BLOCKS 4096
662
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400663static int _ext4_get_block(struct inode *inode, sector_t iblock,
664 struct buffer_head *bh, int flags)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700665{
Dmitriy Monakhov3e4fdaf2007-02-10 01:46:35 -0800666 handle_t *handle = ext4_journal_current_handle();
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400667 struct ext4_map_blocks map;
Jan Kara7fb54092008-02-10 01:08:38 -0500668 int ret = 0, started = 0;
Mingming Caof3bd1f32008-08-19 22:16:03 -0400669 int dio_credits;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700670
Tao Ma46c7f252012-12-10 14:04:52 -0500671 if (ext4_has_inline_data(inode))
672 return -ERANGE;
673
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400674 map.m_lblk = iblock;
675 map.m_len = bh->b_size >> inode->i_blkbits;
676
Anatol Pomozov8b0f1652012-11-08 15:07:16 -0500677 if (flags && !(flags & EXT4_GET_BLOCKS_NO_LOCK) && !handle) {
Jan Kara7fb54092008-02-10 01:08:38 -0500678 /* Direct IO write... */
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400679 if (map.m_len > DIO_MAX_BLOCKS)
680 map.m_len = DIO_MAX_BLOCKS;
681 dio_credits = ext4_chunk_trans_blocks(inode, map.m_len);
Theodore Ts'o9924a922013-02-08 21:59:22 -0500682 handle = ext4_journal_start(inode, EXT4_HT_MAP_BLOCKS,
683 dio_credits);
Jan Kara7fb54092008-02-10 01:08:38 -0500684 if (IS_ERR(handle)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700685 ret = PTR_ERR(handle);
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400686 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700687 }
Jan Kara7fb54092008-02-10 01:08:38 -0500688 started = 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700689 }
690
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400691 ret = ext4_map_blocks(handle, inode, &map, flags);
Jan Kara7fb54092008-02-10 01:08:38 -0500692 if (ret > 0) {
Christoph Hellwig7b7a8662013-09-04 15:04:39 +0200693 ext4_io_end_t *io_end = ext4_inode_aio(inode);
694
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400695 map_bh(bh, inode->i_sb, map.m_pblk);
696 bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
Christoph Hellwig7b7a8662013-09-04 15:04:39 +0200697 if (io_end && io_end->flag & EXT4_IO_END_UNWRITTEN)
698 set_buffer_defer_completion(bh);
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400699 bh->b_size = inode->i_sb->s_blocksize * map.m_len;
Jan Kara7fb54092008-02-10 01:08:38 -0500700 ret = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700701 }
Jan Kara7fb54092008-02-10 01:08:38 -0500702 if (started)
703 ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700704 return ret;
705}
706
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400707int ext4_get_block(struct inode *inode, sector_t iblock,
708 struct buffer_head *bh, int create)
709{
710 return _ext4_get_block(inode, iblock, bh,
711 create ? EXT4_GET_BLOCKS_CREATE : 0);
712}
713
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700714/*
715 * `handle' can be NULL if create is zero
716 */
Mingming Cao617ba132006-10-11 01:20:53 -0700717struct buffer_head *ext4_getblk(handle_t *handle, struct inode *inode,
Theodore Ts'o10560082014-08-29 20:51:32 -0400718 ext4_lblk_t block, int create)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700719{
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400720 struct ext4_map_blocks map;
721 struct buffer_head *bh;
Theodore Ts'o10560082014-08-29 20:51:32 -0400722 int err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700723
724 J_ASSERT(handle != NULL || create == 0);
725
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400726 map.m_lblk = block;
727 map.m_len = 1;
728 err = ext4_map_blocks(handle, inode, &map,
729 create ? EXT4_GET_BLOCKS_CREATE : 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700730
Theodore Ts'o10560082014-08-29 20:51:32 -0400731 if (err == 0)
732 return create ? ERR_PTR(-ENOSPC) : NULL;
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400733 if (err < 0)
Theodore Ts'o10560082014-08-29 20:51:32 -0400734 return ERR_PTR(err);
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400735
736 bh = sb_getblk(inode->i_sb, map.m_pblk);
Theodore Ts'o10560082014-08-29 20:51:32 -0400737 if (unlikely(!bh))
738 return ERR_PTR(-ENOMEM);
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400739 if (map.m_flags & EXT4_MAP_NEW) {
740 J_ASSERT(create != 0);
741 J_ASSERT(handle != NULL);
742
743 /*
744 * Now that we do not always journal data, we should
745 * keep in mind whether this should always journal the
746 * new buffer as metadata. For now, regular file
747 * writes use ext4_get_block instead, so it's not a
748 * problem.
749 */
750 lock_buffer(bh);
751 BUFFER_TRACE(bh, "call get_create_access");
Theodore Ts'o10560082014-08-29 20:51:32 -0400752 err = ext4_journal_get_create_access(handle, bh);
753 if (unlikely(err)) {
754 unlock_buffer(bh);
755 goto errout;
756 }
757 if (!buffer_uptodate(bh)) {
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400758 memset(bh->b_data, 0, inode->i_sb->s_blocksize);
759 set_buffer_uptodate(bh);
760 }
761 unlock_buffer(bh);
762 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
763 err = ext4_handle_dirty_metadata(handle, inode, bh);
Theodore Ts'o10560082014-08-29 20:51:32 -0400764 if (unlikely(err))
765 goto errout;
766 } else
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400767 BUFFER_TRACE(bh, "not a new buffer");
Theodore Ts'o2ed88682010-05-16 20:00:00 -0400768 return bh;
Theodore Ts'o10560082014-08-29 20:51:32 -0400769errout:
770 brelse(bh);
771 return ERR_PTR(err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700772}
773
Mingming Cao617ba132006-10-11 01:20:53 -0700774struct buffer_head *ext4_bread(handle_t *handle, struct inode *inode,
Theodore Ts'o1c215022014-08-29 20:52:15 -0400775 ext4_lblk_t block, int create)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700776{
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400777 struct buffer_head *bh;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700778
Theodore Ts'o10560082014-08-29 20:51:32 -0400779 bh = ext4_getblk(handle, inode, block, create);
Theodore Ts'o1c215022014-08-29 20:52:15 -0400780 if (IS_ERR(bh))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700781 return bh;
Theodore Ts'o1c215022014-08-29 20:52:15 -0400782 if (!bh || buffer_uptodate(bh))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700783 return bh;
Christoph Hellwig65299a32011-08-23 14:50:29 +0200784 ll_rw_block(READ | REQ_META | REQ_PRIO, 1, &bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700785 wait_on_buffer(bh);
786 if (buffer_uptodate(bh))
787 return bh;
788 put_bh(bh);
Theodore Ts'o1c215022014-08-29 20:52:15 -0400789 return ERR_PTR(-EIO);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700790}
791
Tao Maf19d5872012-12-10 14:05:51 -0500792int ext4_walk_page_buffers(handle_t *handle,
793 struct buffer_head *head,
794 unsigned from,
795 unsigned to,
796 int *partial,
797 int (*fn)(handle_t *handle,
798 struct buffer_head *bh))
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700799{
800 struct buffer_head *bh;
801 unsigned block_start, block_end;
802 unsigned blocksize = head->b_size;
803 int err, ret = 0;
804 struct buffer_head *next;
805
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400806 for (bh = head, block_start = 0;
807 ret == 0 && (bh != head || !block_start);
Theodore Ts'ode9a55b2009-06-14 17:45:34 -0400808 block_start = block_end, bh = next) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700809 next = bh->b_this_page;
810 block_end = block_start + blocksize;
811 if (block_end <= from || block_start >= to) {
812 if (partial && !buffer_uptodate(bh))
813 *partial = 1;
814 continue;
815 }
816 err = (*fn)(handle, bh);
817 if (!ret)
818 ret = err;
819 }
820 return ret;
821}
822
823/*
824 * To preserve ordering, it is essential that the hole instantiation and
825 * the data write be encapsulated in a single transaction. We cannot
Mingming Cao617ba132006-10-11 01:20:53 -0700826 * close off a transaction and start a new one between the ext4_get_block()
Mingming Caodab291a2006-10-11 01:21:01 -0700827 * and the commit_write(). So doing the jbd2_journal_start at the start of
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700828 * prepare_write() is the right place.
829 *
Jan Kara36ade452013-01-28 09:30:52 -0500830 * Also, this function can nest inside ext4_writepage(). In that case, we
831 * *know* that ext4_writepage() has generated enough buffer credits to do the
832 * whole page. So we won't block on the journal in that case, which is good,
833 * because the caller may be PF_MEMALLOC.
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700834 *
Mingming Cao617ba132006-10-11 01:20:53 -0700835 * By accident, ext4 can be reentered when a transaction is open via
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700836 * quota file writes. If we were to commit the transaction while thus
837 * reentered, there can be a deadlock - we would be holding a quota
838 * lock, and the commit would never complete if another thread had a
839 * transaction open and was blocking on the quota lock - a ranking
840 * violation.
841 *
Mingming Caodab291a2006-10-11 01:21:01 -0700842 * So what we do is to rely on the fact that jbd2_journal_stop/journal_start
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700843 * will _not_ run commit under these circumstances because handle->h_ref
844 * is elevated. We'll still have enough credits for the tiny quotafile
845 * write.
846 */
Tao Maf19d5872012-12-10 14:05:51 -0500847int do_journal_get_write_access(handle_t *handle,
848 struct buffer_head *bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700849{
Jan Kara56d35a42010-08-05 14:41:42 -0400850 int dirty = buffer_dirty(bh);
851 int ret;
852
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700853 if (!buffer_mapped(bh) || buffer_freed(bh))
854 return 0;
Jan Kara56d35a42010-08-05 14:41:42 -0400855 /*
Christoph Hellwigebdec242010-10-06 10:47:23 +0200856 * __block_write_begin() could have dirtied some buffers. Clean
Jan Kara56d35a42010-08-05 14:41:42 -0400857 * the dirty bit as jbd2_journal_get_write_access() could complain
858 * otherwise about fs integrity issues. Setting of the dirty bit
Christoph Hellwigebdec242010-10-06 10:47:23 +0200859 * by __block_write_begin() isn't a real problem here as we clear
Jan Kara56d35a42010-08-05 14:41:42 -0400860 * the bit before releasing a page lock and thus writeback cannot
861 * ever write the buffer.
862 */
863 if (dirty)
864 clear_buffer_dirty(bh);
liang xie5d601252014-05-12 22:06:43 -0400865 BUFFER_TRACE(bh, "get write access");
Jan Kara56d35a42010-08-05 14:41:42 -0400866 ret = ext4_journal_get_write_access(handle, bh);
867 if (!ret && dirty)
868 ret = ext4_handle_dirty_metadata(handle, NULL, bh);
869 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700870}
871
Anatol Pomozov8b0f1652012-11-08 15:07:16 -0500872static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
873 struct buffer_head *bh_result, int create);
Nick Pigginbfc1af62007-10-16 01:25:05 -0700874static int ext4_write_begin(struct file *file, struct address_space *mapping,
Theodore Ts'ode9a55b2009-06-14 17:45:34 -0400875 loff_t pos, unsigned len, unsigned flags,
876 struct page **pagep, void **fsdata)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700877{
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400878 struct inode *inode = mapping->host;
Aneesh Kumar K.V1938a152009-06-05 01:00:26 -0400879 int ret, needed_blocks;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700880 handle_t *handle;
881 int retries = 0;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400882 struct page *page;
Theodore Ts'ode9a55b2009-06-14 17:45:34 -0400883 pgoff_t index;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400884 unsigned from, to;
Nick Pigginbfc1af62007-10-16 01:25:05 -0700885
Theodore Ts'o9bffad12009-06-17 11:48:11 -0400886 trace_ext4_write_begin(inode, pos, len, flags);
Aneesh Kumar K.V1938a152009-06-05 01:00:26 -0400887 /*
888 * Reserve one block more for addition to orphan list in case
889 * we allocate blocks but write fails for some reason
890 */
891 needed_blocks = ext4_writepage_trans_blocks(inode) + 1;
Theodore Ts'ode9a55b2009-06-14 17:45:34 -0400892 index = pos >> PAGE_CACHE_SHIFT;
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400893 from = pos & (PAGE_CACHE_SIZE - 1);
894 to = from + len;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700895
Tao Maf19d5872012-12-10 14:05:51 -0500896 if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
897 ret = ext4_try_to_write_inline_data(mapping, inode, pos, len,
898 flags, pagep);
899 if (ret < 0)
Theodore Ts'o47564bf2013-02-09 09:24:14 -0500900 return ret;
901 if (ret == 1)
902 return 0;
Tao Maf19d5872012-12-10 14:05:51 -0500903 }
904
Theodore Ts'o47564bf2013-02-09 09:24:14 -0500905 /*
906 * grab_cache_page_write_begin() can take a long time if the
907 * system is thrashing due to memory pressure, or if the page
908 * is being written back. So grab it first before we start
909 * the transaction handle. This also allows us to allocate
910 * the page (if needed) without using GFP_NOFS.
911 */
912retry_grab:
Nick Piggin54566b22009-01-04 12:00:53 -0800913 page = grab_cache_page_write_begin(mapping, index, flags);
Theodore Ts'o47564bf2013-02-09 09:24:14 -0500914 if (!page)
915 return -ENOMEM;
916 unlock_page(page);
917
918retry_journal:
Theodore Ts'o9924a922013-02-08 21:59:22 -0500919 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE, needed_blocks);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700920 if (IS_ERR(handle)) {
Theodore Ts'o47564bf2013-02-09 09:24:14 -0500921 page_cache_release(page);
922 return PTR_ERR(handle);
Jan Karacf108bc2008-07-11 19:27:31 -0400923 }
Tao Maf19d5872012-12-10 14:05:51 -0500924
Theodore Ts'o47564bf2013-02-09 09:24:14 -0500925 lock_page(page);
926 if (page->mapping != mapping) {
927 /* The page got truncated from under us */
928 unlock_page(page);
929 page_cache_release(page);
Jan Karacf108bc2008-07-11 19:27:31 -0400930 ext4_journal_stop(handle);
Theodore Ts'o47564bf2013-02-09 09:24:14 -0500931 goto retry_grab;
Jan Karacf108bc2008-07-11 19:27:31 -0400932 }
Dmitry Monakhov7afe5aa2013-08-28 14:30:47 -0400933 /* In case writeback began while the page was unlocked */
934 wait_for_stable_page(page);
Jan Karacf108bc2008-07-11 19:27:31 -0400935
Jiaying Zhang744692d2010-03-04 16:14:02 -0500936 if (ext4_should_dioread_nolock(inode))
Christoph Hellwig6e1db882010-06-04 11:29:57 +0200937 ret = __block_write_begin(page, pos, len, ext4_get_block_write);
Jiaying Zhang744692d2010-03-04 16:14:02 -0500938 else
Christoph Hellwig6e1db882010-06-04 11:29:57 +0200939 ret = __block_write_begin(page, pos, len, ext4_get_block);
Nick Pigginbfc1af62007-10-16 01:25:05 -0700940
941 if (!ret && ext4_should_journal_data(inode)) {
Tao Maf19d5872012-12-10 14:05:51 -0500942 ret = ext4_walk_page_buffers(handle, page_buffers(page),
943 from, to, NULL,
944 do_journal_get_write_access);
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700945 }
Nick Pigginbfc1af62007-10-16 01:25:05 -0700946
947 if (ret) {
Theodore Ts'oaf5bc922008-09-08 22:25:24 -0400948 unlock_page(page);
Aneesh Kumar K.Vae4d5372008-09-13 13:10:25 -0400949 /*
Christoph Hellwig6e1db882010-06-04 11:29:57 +0200950 * __block_write_begin may have instantiated a few blocks
Aneesh Kumar K.Vae4d5372008-09-13 13:10:25 -0400951 * outside i_size. Trim these off again. Don't need
952 * i_size_read because we hold i_mutex.
Aneesh Kumar K.V1938a152009-06-05 01:00:26 -0400953 *
954 * Add inode to orphan list in case we crash before
955 * truncate finishes
Aneesh Kumar K.Vae4d5372008-09-13 13:10:25 -0400956 */
Jan Karaffacfa72009-07-13 16:22:22 -0400957 if (pos + len > inode->i_size && ext4_can_truncate(inode))
Aneesh Kumar K.V1938a152009-06-05 01:00:26 -0400958 ext4_orphan_add(handle, inode);
959
960 ext4_journal_stop(handle);
961 if (pos + len > inode->i_size) {
Jan Karab9a42072009-12-08 21:24:33 -0500962 ext4_truncate_failed_write(inode);
Theodore Ts'ode9a55b2009-06-14 17:45:34 -0400963 /*
Jan Karaffacfa72009-07-13 16:22:22 -0400964 * If truncate failed early the inode might
Aneesh Kumar K.V1938a152009-06-05 01:00:26 -0400965 * still be on the orphan list; we need to
966 * make sure the inode is removed from the
967 * orphan list in that case.
968 */
969 if (inode->i_nlink)
970 ext4_orphan_del(NULL, inode);
971 }
Nick Pigginbfc1af62007-10-16 01:25:05 -0700972
Theodore Ts'o47564bf2013-02-09 09:24:14 -0500973 if (ret == -ENOSPC &&
974 ext4_should_retry_alloc(inode->i_sb, &retries))
975 goto retry_journal;
976 page_cache_release(page);
977 return ret;
978 }
979 *pagep = page;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700980 return ret;
981}
982
Nick Pigginbfc1af62007-10-16 01:25:05 -0700983/* For write_end() in data=journal mode */
984static int write_end_fn(handle_t *handle, struct buffer_head *bh)
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700985{
Theodore Ts'o13fca322013-04-21 16:45:54 -0400986 int ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700987 if (!buffer_mapped(bh) || buffer_freed(bh))
988 return 0;
989 set_buffer_uptodate(bh);
Theodore Ts'o13fca322013-04-21 16:45:54 -0400990 ret = ext4_handle_dirty_metadata(handle, NULL, bh);
991 clear_buffer_meta(bh);
992 clear_buffer_prio(bh);
993 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -0700994}
995
Zheng Liueed43332013-04-03 12:41:17 -0400996/*
997 * We need to pick up the new inode size which generic_commit_write gave us
998 * `file' can be NULL - eg, when called from page_symlink().
999 *
1000 * ext4 never places buffers on inode->i_mapping->private_list. metadata
1001 * buffers are managed internally.
1002 */
1003static int ext4_write_end(struct file *file,
1004 struct address_space *mapping,
1005 loff_t pos, unsigned len, unsigned copied,
1006 struct page *page, void *fsdata)
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001007{
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001008 handle_t *handle = ext4_journal_current_handle();
Zheng Liueed43332013-04-03 12:41:17 -04001009 struct inode *inode = mapping->host;
1010 int ret = 0, ret2;
1011 int i_size_changed = 0;
1012
1013 trace_ext4_write_end(inode, pos, len, copied);
1014 if (ext4_test_inode_state(inode, EXT4_STATE_ORDERED_MODE)) {
1015 ret = ext4_jbd2_file_inode(handle, inode);
1016 if (ret) {
1017 unlock_page(page);
1018 page_cache_release(page);
1019 goto errout;
1020 }
1021 }
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001022
Theodore Ts'o42c832d2013-07-01 08:12:39 -04001023 if (ext4_has_inline_data(inode)) {
1024 ret = ext4_write_inline_data_end(inode, pos, len,
1025 copied, page);
1026 if (ret < 0)
1027 goto errout;
1028 copied = ret;
1029 } else
Tao Maf19d5872012-12-10 14:05:51 -05001030 copied = block_write_end(file, mapping, pos,
1031 len, copied, page, fsdata);
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001032 /*
Dmitry Monakhov4631dbf2014-08-23 17:48:28 -04001033 * it's important to update i_size while still holding page lock:
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001034 * page writeout could otherwise come in and zero beyond i_size.
1035 */
Dmitry Monakhov4631dbf2014-08-23 17:48:28 -04001036 i_size_changed = ext4_update_inode_size(inode, pos + copied);
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001037 unlock_page(page);
1038 page_cache_release(page);
1039
1040 /*
1041 * Don't mark the inode dirty under page lock. First, it unnecessarily
1042 * makes the holding time of page lock longer. Second, it forces lock
1043 * ordering of page lock and transaction start for journaling
1044 * filesystems.
1045 */
1046 if (i_size_changed)
1047 ext4_mark_inode_dirty(handle, inode);
1048
Jan Karaffacfa72009-07-13 16:22:22 -04001049 if (pos + len > inode->i_size && ext4_can_truncate(inode))
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001050 /* if we have allocated more blocks and copied
1051 * less. We will have blocks allocated outside
1052 * inode->i_size. So truncate them
1053 */
1054 ext4_orphan_add(handle, inode);
Theodore Ts'o74d553a2013-04-03 12:39:17 -04001055errout:
Mingming Cao617ba132006-10-11 01:20:53 -07001056 ret2 = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001057 if (!ret)
1058 ret = ret2;
Nick Pigginbfc1af62007-10-16 01:25:05 -07001059
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001060 if (pos + len > inode->i_size) {
Jan Karab9a42072009-12-08 21:24:33 -05001061 ext4_truncate_failed_write(inode);
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04001062 /*
Jan Karaffacfa72009-07-13 16:22:22 -04001063 * If truncate failed early the inode might still be
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001064 * on the orphan list; we need to make sure the inode
1065 * is removed from the orphan list in that case.
1066 */
1067 if (inode->i_nlink)
1068 ext4_orphan_del(NULL, inode);
1069 }
1070
Nick Pigginbfc1af62007-10-16 01:25:05 -07001071 return ret ? ret : copied;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001072}
1073
Nick Pigginbfc1af62007-10-16 01:25:05 -07001074static int ext4_journalled_write_end(struct file *file,
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04001075 struct address_space *mapping,
1076 loff_t pos, unsigned len, unsigned copied,
1077 struct page *page, void *fsdata)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001078{
Mingming Cao617ba132006-10-11 01:20:53 -07001079 handle_t *handle = ext4_journal_current_handle();
Nick Pigginbfc1af62007-10-16 01:25:05 -07001080 struct inode *inode = mapping->host;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001081 int ret = 0, ret2;
1082 int partial = 0;
Nick Pigginbfc1af62007-10-16 01:25:05 -07001083 unsigned from, to;
Dmitry Monakhov4631dbf2014-08-23 17:48:28 -04001084 int size_changed = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001085
Theodore Ts'o9bffad12009-06-17 11:48:11 -04001086 trace_ext4_journalled_write_end(inode, pos, len, copied);
Nick Pigginbfc1af62007-10-16 01:25:05 -07001087 from = pos & (PAGE_CACHE_SIZE - 1);
1088 to = from + len;
1089
Curt Wohlgemuth441c8502011-08-13 11:25:18 -04001090 BUG_ON(!ext4_handle_valid(handle));
1091
Tao Ma3fdcfb62012-12-10 14:05:57 -05001092 if (ext4_has_inline_data(inode))
1093 copied = ext4_write_inline_data_end(inode, pos, len,
1094 copied, page);
1095 else {
1096 if (copied < len) {
1097 if (!PageUptodate(page))
1098 copied = 0;
1099 page_zero_new_buffers(page, from+copied, to);
1100 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001101
Tao Ma3fdcfb62012-12-10 14:05:57 -05001102 ret = ext4_walk_page_buffers(handle, page_buffers(page), from,
1103 to, &partial, write_end_fn);
1104 if (!partial)
1105 SetPageUptodate(page);
1106 }
Dmitry Monakhov4631dbf2014-08-23 17:48:28 -04001107 size_changed = ext4_update_inode_size(inode, pos + copied);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001108 ext4_set_inode_state(inode, EXT4_STATE_JDATA);
Jan Kara2d859db2011-07-26 09:07:11 -04001109 EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
Dmitry Monakhov4631dbf2014-08-23 17:48:28 -04001110 unlock_page(page);
1111 page_cache_release(page);
1112
1113 if (size_changed) {
Mingming Cao617ba132006-10-11 01:20:53 -07001114 ret2 = ext4_mark_inode_dirty(handle, inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001115 if (!ret)
1116 ret = ret2;
1117 }
Nick Pigginbfc1af62007-10-16 01:25:05 -07001118
Jan Karaffacfa72009-07-13 16:22:22 -04001119 if (pos + len > inode->i_size && ext4_can_truncate(inode))
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001120 /* if we have allocated more blocks and copied
1121 * less. We will have blocks allocated outside
1122 * inode->i_size. So truncate them
1123 */
1124 ext4_orphan_add(handle, inode);
1125
Mingming Cao617ba132006-10-11 01:20:53 -07001126 ret2 = ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001127 if (!ret)
1128 ret = ret2;
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001129 if (pos + len > inode->i_size) {
Jan Karab9a42072009-12-08 21:24:33 -05001130 ext4_truncate_failed_write(inode);
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04001131 /*
Jan Karaffacfa72009-07-13 16:22:22 -04001132 * If truncate failed early the inode might still be
Aneesh Kumar K.Vf8514082009-06-05 00:56:49 -04001133 * on the orphan list; we need to make sure the inode
1134 * is removed from the orphan list in that case.
1135 */
1136 if (inode->i_nlink)
1137 ext4_orphan_del(NULL, inode);
1138 }
Nick Pigginbfc1af62007-10-16 01:25:05 -07001139
1140 return ret ? ret : copied;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001141}
Mingming Caod2a17632008-07-14 17:52:37 -04001142
Theodore Ts'o9d0be502010-01-01 02:41:30 -05001143/*
Aditya Kali7b415bf2011-09-09 19:04:51 -04001144 * Reserve a single cluster located at lblock
Theodore Ts'o9d0be502010-01-01 02:41:30 -05001145 */
Theodore Ts'o01f49d02011-01-10 12:13:03 -05001146static int ext4_da_reserve_space(struct inode *inode, ext4_lblk_t lblock)
Mingming Caod2a17632008-07-14 17:52:37 -04001147{
Mingming Cao60e58e02009-01-22 18:13:05 +01001148 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Theodore Ts'o0637c6f2009-12-30 14:20:45 -05001149 struct ext4_inode_info *ei = EXT4_I(inode);
Aditya Kali7b415bf2011-09-09 19:04:51 -04001150 unsigned int md_needed;
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001151 int ret;
Mingming Caod2a17632008-07-14 17:52:37 -04001152
Mingming Cao60e58e02009-01-22 18:13:05 +01001153 /*
Eric Sandeen72b8ab92010-05-16 11:00:00 -04001154 * We will charge metadata quota at writeout time; this saves
1155 * us from metadata over-estimation, though we may go over by
1156 * a small amount in the end. Here we just reserve for data.
Mingming Cao60e58e02009-01-22 18:13:05 +01001157 */
Aditya Kali7b415bf2011-09-09 19:04:51 -04001158 ret = dquot_reserve_block(inode, EXT4_C2B(sbi, 1));
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001159 if (ret)
1160 return ret;
Theodore Ts'o03179fe2012-07-23 00:00:20 -04001161
1162 /*
1163 * recalculate the amount of metadata blocks to reserve
1164 * in order to allocate nrblocks
1165 * worse case is one extent per block
1166 */
Theodore Ts'o03179fe2012-07-23 00:00:20 -04001167 spin_lock(&ei->i_block_reservation_lock);
1168 /*
1169 * ext4_calc_metadata_amount() has side effects, which we have
1170 * to be prepared undo if we fail to claim space.
1171 */
Theodore Ts'o71d4f7d2014-07-15 06:02:38 -04001172 md_needed = 0;
1173 trace_ext4_da_reserve_space(inode, 0);
Theodore Ts'o03179fe2012-07-23 00:00:20 -04001174
Theodore Ts'o71d4f7d2014-07-15 06:02:38 -04001175 if (ext4_claim_free_clusters(sbi, 1, 0)) {
Theodore Ts'o03179fe2012-07-23 00:00:20 -04001176 spin_unlock(&ei->i_block_reservation_lock);
Theodore Ts'o03179fe2012-07-23 00:00:20 -04001177 dquot_release_reservation_block(inode, EXT4_C2B(sbi, 1));
Mingming Caod2a17632008-07-14 17:52:37 -04001178 return -ENOSPC;
1179 }
Theodore Ts'o9d0be502010-01-01 02:41:30 -05001180 ei->i_reserved_data_blocks++;
Theodore Ts'o0637c6f2009-12-30 14:20:45 -05001181 spin_unlock(&ei->i_block_reservation_lock);
Dmitry Monakhov39bc6802009-12-10 16:36:27 +00001182
Mingming Caod2a17632008-07-14 17:52:37 -04001183 return 0; /* success */
1184}
1185
Aneesh Kumar K.V12219ae2008-07-17 16:12:08 -04001186static void ext4_da_release_space(struct inode *inode, int to_free)
Mingming Caod2a17632008-07-14 17:52:37 -04001187{
1188 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Theodore Ts'o0637c6f2009-12-30 14:20:45 -05001189 struct ext4_inode_info *ei = EXT4_I(inode);
Mingming Caod2a17632008-07-14 17:52:37 -04001190
Mingming Caocd213222008-08-19 22:16:59 -04001191 if (!to_free)
1192 return; /* Nothing to release, exit */
1193
Mingming Caod2a17632008-07-14 17:52:37 -04001194 spin_lock(&EXT4_I(inode)->i_block_reservation_lock);
Mingming Caocd213222008-08-19 22:16:59 -04001195
Li Zefan5a58ec82010-05-17 02:00:00 -04001196 trace_ext4_da_release_space(inode, to_free);
Theodore Ts'o0637c6f2009-12-30 14:20:45 -05001197 if (unlikely(to_free > ei->i_reserved_data_blocks)) {
Mingming Caocd213222008-08-19 22:16:59 -04001198 /*
Theodore Ts'o0637c6f2009-12-30 14:20:45 -05001199 * if there aren't enough reserved blocks, then the
1200 * counter is messed up somewhere. Since this
1201 * function is called from invalidate page, it's
1202 * harmless to return without any action.
Mingming Caocd213222008-08-19 22:16:59 -04001203 */
Theodore Ts'o8de5c322013-02-14 15:11:41 -05001204 ext4_warning(inode->i_sb, "ext4_da_release_space: "
Theodore Ts'o0637c6f2009-12-30 14:20:45 -05001205 "ino %lu, to_free %d with only %d reserved "
Theodore Ts'o1084f252012-03-19 23:13:43 -04001206 "data blocks", inode->i_ino, to_free,
Theodore Ts'o0637c6f2009-12-30 14:20:45 -05001207 ei->i_reserved_data_blocks);
1208 WARN_ON(1);
1209 to_free = ei->i_reserved_data_blocks;
1210 }
1211 ei->i_reserved_data_blocks -= to_free;
1212
Eric Sandeen72b8ab92010-05-16 11:00:00 -04001213 /* update fs dirty data blocks counter */
Theodore Ts'o57042652011-09-09 18:56:51 -04001214 percpu_counter_sub(&sbi->s_dirtyclusters_counter, to_free);
Mingming Caod2a17632008-07-14 17:52:37 -04001215
Mingming Caod2a17632008-07-14 17:52:37 -04001216 spin_unlock(&EXT4_I(inode)->i_block_reservation_lock);
Mingming Cao60e58e02009-01-22 18:13:05 +01001217
Aditya Kali7b415bf2011-09-09 19:04:51 -04001218 dquot_release_reservation_block(inode, EXT4_C2B(sbi, to_free));
Mingming Caod2a17632008-07-14 17:52:37 -04001219}
1220
1221static void ext4_da_page_release_reservation(struct page *page,
Lukas Czernerca99fdd2013-05-21 23:25:01 -04001222 unsigned int offset,
1223 unsigned int length)
Mingming Caod2a17632008-07-14 17:52:37 -04001224{
1225 int to_release = 0;
1226 struct buffer_head *head, *bh;
1227 unsigned int curr_off = 0;
Aditya Kali7b415bf2011-09-09 19:04:51 -04001228 struct inode *inode = page->mapping->host;
1229 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Lukas Czernerca99fdd2013-05-21 23:25:01 -04001230 unsigned int stop = offset + length;
Aditya Kali7b415bf2011-09-09 19:04:51 -04001231 int num_clusters;
Zheng Liu51865fd2012-11-08 21:57:32 -05001232 ext4_fsblk_t lblk;
Mingming Caod2a17632008-07-14 17:52:37 -04001233
Lukas Czernerca99fdd2013-05-21 23:25:01 -04001234 BUG_ON(stop > PAGE_CACHE_SIZE || stop < length);
1235
Mingming Caod2a17632008-07-14 17:52:37 -04001236 head = page_buffers(page);
1237 bh = head;
1238 do {
1239 unsigned int next_off = curr_off + bh->b_size;
1240
Lukas Czernerca99fdd2013-05-21 23:25:01 -04001241 if (next_off > stop)
1242 break;
1243
Mingming Caod2a17632008-07-14 17:52:37 -04001244 if ((offset <= curr_off) && (buffer_delay(bh))) {
1245 to_release++;
1246 clear_buffer_delay(bh);
1247 }
1248 curr_off = next_off;
1249 } while ((bh = bh->b_this_page) != head);
Aditya Kali7b415bf2011-09-09 19:04:51 -04001250
Zheng Liu51865fd2012-11-08 21:57:32 -05001251 if (to_release) {
1252 lblk = page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
1253 ext4_es_remove_extent(inode, lblk, to_release);
1254 }
1255
Aditya Kali7b415bf2011-09-09 19:04:51 -04001256 /* If we have released all the blocks belonging to a cluster, then we
1257 * need to release the reserved space for that cluster. */
1258 num_clusters = EXT4_NUM_B2C(sbi, to_release);
1259 while (num_clusters > 0) {
Aditya Kali7b415bf2011-09-09 19:04:51 -04001260 lblk = (page->index << (PAGE_CACHE_SHIFT - inode->i_blkbits)) +
1261 ((num_clusters - 1) << sbi->s_cluster_bits);
1262 if (sbi->s_cluster_ratio == 1 ||
Zheng Liu7d1b1fb2012-11-08 21:57:35 -05001263 !ext4_find_delalloc_cluster(inode, lblk))
Aditya Kali7b415bf2011-09-09 19:04:51 -04001264 ext4_da_release_space(inode, 1);
1265
1266 num_clusters--;
1267 }
Mingming Caod2a17632008-07-14 17:52:37 -04001268}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07001269
1270/*
Alex Tomas64769242008-07-11 19:27:31 -04001271 * Delayed allocation stuff
1272 */
1273
Jan Kara4e7ea812013-06-04 13:17:40 -04001274struct mpage_da_data {
1275 struct inode *inode;
1276 struct writeback_control *wbc;
Jan Kara6b523df2013-06-04 13:21:11 -04001277
Jan Kara4e7ea812013-06-04 13:17:40 -04001278 pgoff_t first_page; /* The first page to write */
1279 pgoff_t next_page; /* Current page to examine */
1280 pgoff_t last_page; /* Last page to examine */
Aneesh Kumar K.V791b7f02009-01-05 21:50:43 -05001281 /*
Jan Kara4e7ea812013-06-04 13:17:40 -04001282 * Extent to map - this can be after first_page because that can be
1283 * fully mapped. We somewhat abuse m_flags to store whether the extent
1284 * is delalloc or unwritten.
Aneesh Kumar K.V791b7f02009-01-05 21:50:43 -05001285 */
Jan Kara4e7ea812013-06-04 13:17:40 -04001286 struct ext4_map_blocks map;
1287 struct ext4_io_submit io_submit; /* IO submission data */
1288};
Alex Tomas64769242008-07-11 19:27:31 -04001289
Jan Kara4e7ea812013-06-04 13:17:40 -04001290static void mpage_release_unused_pages(struct mpage_da_data *mpd,
1291 bool invalidate)
Aneesh Kumar K.Vc4a0c462008-08-19 21:08:18 -04001292{
1293 int nr_pages, i;
1294 pgoff_t index, end;
1295 struct pagevec pvec;
1296 struct inode *inode = mpd->inode;
1297 struct address_space *mapping = inode->i_mapping;
Jan Kara4e7ea812013-06-04 13:17:40 -04001298
1299 /* This is necessary when next_page == 0. */
1300 if (mpd->first_page >= mpd->next_page)
1301 return;
Aneesh Kumar K.Vc4a0c462008-08-19 21:08:18 -04001302
Curt Wohlgemuthc7f59382011-02-26 12:27:52 -05001303 index = mpd->first_page;
1304 end = mpd->next_page - 1;
Jan Kara4e7ea812013-06-04 13:17:40 -04001305 if (invalidate) {
1306 ext4_lblk_t start, last;
1307 start = index << (PAGE_CACHE_SHIFT - inode->i_blkbits);
1308 last = end << (PAGE_CACHE_SHIFT - inode->i_blkbits);
1309 ext4_es_remove_extent(inode, start, last - start + 1);
1310 }
Zheng Liu51865fd2012-11-08 21:57:32 -05001311
Eric Sandeen66bea922012-11-14 22:22:05 -05001312 pagevec_init(&pvec, 0);
Aneesh Kumar K.Vc4a0c462008-08-19 21:08:18 -04001313 while (index <= end) {
1314 nr_pages = pagevec_lookup(&pvec, mapping, index, PAGEVEC_SIZE);
1315 if (nr_pages == 0)
1316 break;
1317 for (i = 0; i < nr_pages; i++) {
1318 struct page *page = pvec.pages[i];
Jan Kara9b1d09982010-03-03 16:19:32 -05001319 if (page->index > end)
Aneesh Kumar K.Vc4a0c462008-08-19 21:08:18 -04001320 break;
Aneesh Kumar K.Vc4a0c462008-08-19 21:08:18 -04001321 BUG_ON(!PageLocked(page));
1322 BUG_ON(PageWriteback(page));
Jan Kara4e7ea812013-06-04 13:17:40 -04001323 if (invalidate) {
1324 block_invalidatepage(page, 0, PAGE_CACHE_SIZE);
1325 ClearPageUptodate(page);
1326 }
Aneesh Kumar K.Vc4a0c462008-08-19 21:08:18 -04001327 unlock_page(page);
1328 }
Jan Kara9b1d09982010-03-03 16:19:32 -05001329 index = pvec.pages[nr_pages - 1]->index + 1;
1330 pagevec_release(&pvec);
Aneesh Kumar K.Vc4a0c462008-08-19 21:08:18 -04001331 }
Aneesh Kumar K.Vc4a0c462008-08-19 21:08:18 -04001332}
1333
Aneesh Kumar K.Vdf222912008-09-08 23:05:34 -04001334static void ext4_print_free_blocks(struct inode *inode)
1335{
1336 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
Theodore Ts'o92b97812012-03-19 23:41:49 -04001337 struct super_block *sb = inode->i_sb;
Lukas Czernerf78ee70d2013-04-03 23:33:30 -04001338 struct ext4_inode_info *ei = EXT4_I(inode);
Theodore Ts'o92b97812012-03-19 23:41:49 -04001339
1340 ext4_msg(sb, KERN_CRIT, "Total free blocks count %lld",
Theodore Ts'o5dee5432011-09-09 19:10:51 -04001341 EXT4_C2B(EXT4_SB(inode->i_sb),
Lukas Czernerf78ee70d2013-04-03 23:33:30 -04001342 ext4_count_free_clusters(sb)));
Theodore Ts'o92b97812012-03-19 23:41:49 -04001343 ext4_msg(sb, KERN_CRIT, "Free/Dirty block details");
1344 ext4_msg(sb, KERN_CRIT, "free_blocks=%lld",
Lukas Czernerf78ee70d2013-04-03 23:33:30 -04001345 (long long) EXT4_C2B(EXT4_SB(sb),
Theodore Ts'o57042652011-09-09 18:56:51 -04001346 percpu_counter_sum(&sbi->s_freeclusters_counter)));
Theodore Ts'o92b97812012-03-19 23:41:49 -04001347 ext4_msg(sb, KERN_CRIT, "dirty_blocks=%lld",
Lukas Czernerf78ee70d2013-04-03 23:33:30 -04001348 (long long) EXT4_C2B(EXT4_SB(sb),
Aditya Kali7b415bf2011-09-09 19:04:51 -04001349 percpu_counter_sum(&sbi->s_dirtyclusters_counter)));
Theodore Ts'o92b97812012-03-19 23:41:49 -04001350 ext4_msg(sb, KERN_CRIT, "Block reservation details");
1351 ext4_msg(sb, KERN_CRIT, "i_reserved_data_blocks=%u",
Lukas Czernerf78ee70d2013-04-03 23:33:30 -04001352 ei->i_reserved_data_blocks);
Aneesh Kumar K.Vdf222912008-09-08 23:05:34 -04001353 return;
1354}
1355
Aneesh Kumar K.Vc364b222009-06-14 17:57:10 -04001356static int ext4_bh_delay_or_unwritten(handle_t *handle, struct buffer_head *bh)
Aneesh Kumar K.V29fa89d2009-05-12 16:30:27 -04001357{
Aneesh Kumar K.Vc364b222009-06-14 17:57:10 -04001358 return (buffer_delay(bh) || buffer_unwritten(bh)) && buffer_dirty(bh);
Aneesh Kumar K.V29fa89d2009-05-12 16:30:27 -04001359}
1360
Alex Tomas64769242008-07-11 19:27:31 -04001361/*
Aditya Kali5356f262011-09-09 19:20:51 -04001362 * This function is grabs code from the very beginning of
1363 * ext4_map_blocks, but assumes that the caller is from delayed write
1364 * time. This function looks up the requested blocks and sets the
1365 * buffer delay bit under the protection of i_data_sem.
1366 */
1367static int ext4_da_map_blocks(struct inode *inode, sector_t iblock,
1368 struct ext4_map_blocks *map,
1369 struct buffer_head *bh)
1370{
Zheng Liud100eef2013-02-18 00:29:59 -05001371 struct extent_status es;
Aditya Kali5356f262011-09-09 19:20:51 -04001372 int retval;
1373 sector_t invalid_block = ~((sector_t) 0xffff);
Dmitry Monakhov921f2662013-03-10 21:01:03 -04001374#ifdef ES_AGGRESSIVE_TEST
1375 struct ext4_map_blocks orig_map;
1376
1377 memcpy(&orig_map, map, sizeof(*map));
1378#endif
Aditya Kali5356f262011-09-09 19:20:51 -04001379
1380 if (invalid_block < ext4_blocks_count(EXT4_SB(inode->i_sb)->s_es))
1381 invalid_block = ~0;
1382
1383 map->m_flags = 0;
1384 ext_debug("ext4_da_map_blocks(): inode %lu, max_blocks %u,"
1385 "logical block %lu\n", inode->i_ino, map->m_len,
1386 (unsigned long) map->m_lblk);
Zheng Liud100eef2013-02-18 00:29:59 -05001387
1388 /* Lookup extent status tree firstly */
1389 if (ext4_es_lookup_extent(inode, iblock, &es)) {
Zheng Liud100eef2013-02-18 00:29:59 -05001390 if (ext4_es_is_hole(&es)) {
1391 retval = 0;
Lukas Czernerc8b459f2014-05-12 12:55:07 -04001392 down_read(&EXT4_I(inode)->i_data_sem);
Zheng Liud100eef2013-02-18 00:29:59 -05001393 goto add_delayed;
1394 }
1395
1396 /*
1397 * Delayed extent could be allocated by fallocate.
1398 * So we need to check it.
1399 */
1400 if (ext4_es_is_delayed(&es) && !ext4_es_is_unwritten(&es)) {
1401 map_bh(bh, inode->i_sb, invalid_block);
1402 set_buffer_new(bh);
1403 set_buffer_delay(bh);
1404 return 0;
1405 }
1406
1407 map->m_pblk = ext4_es_pblock(&es) + iblock - es.es_lblk;
1408 retval = es.es_len - (iblock - es.es_lblk);
1409 if (retval > map->m_len)
1410 retval = map->m_len;
1411 map->m_len = retval;
1412 if (ext4_es_is_written(&es))
1413 map->m_flags |= EXT4_MAP_MAPPED;
1414 else if (ext4_es_is_unwritten(&es))
1415 map->m_flags |= EXT4_MAP_UNWRITTEN;
1416 else
1417 BUG_ON(1);
1418
Dmitry Monakhov921f2662013-03-10 21:01:03 -04001419#ifdef ES_AGGRESSIVE_TEST
1420 ext4_map_blocks_es_recheck(NULL, inode, map, &orig_map, 0);
1421#endif
Zheng Liud100eef2013-02-18 00:29:59 -05001422 return retval;
1423 }
1424
Aditya Kali5356f262011-09-09 19:20:51 -04001425 /*
1426 * Try to see if we can get the block without requesting a new
1427 * file system block.
1428 */
Lukas Czernerc8b459f2014-05-12 12:55:07 -04001429 down_read(&EXT4_I(inode)->i_data_sem);
Jan Karacbd75842014-11-25 11:41:49 -05001430 if (ext4_has_inline_data(inode))
Tao Ma9c3569b2012-12-10 14:05:57 -05001431 retval = 0;
Jan Karacbd75842014-11-25 11:41:49 -05001432 else if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
Zheng Liu2f8e0a72014-11-25 11:44:37 -05001433 retval = ext4_ext_map_blocks(NULL, inode, map, 0);
Aditya Kali5356f262011-09-09 19:20:51 -04001434 else
Zheng Liu2f8e0a72014-11-25 11:44:37 -05001435 retval = ext4_ind_map_blocks(NULL, inode, map, 0);
Aditya Kali5356f262011-09-09 19:20:51 -04001436
Zheng Liud100eef2013-02-18 00:29:59 -05001437add_delayed:
Aditya Kali5356f262011-09-09 19:20:51 -04001438 if (retval == 0) {
Zheng Liuf7fec032013-02-18 00:28:47 -05001439 int ret;
Aditya Kali5356f262011-09-09 19:20:51 -04001440 /*
1441 * XXX: __block_prepare_write() unmaps passed block,
1442 * is it OK?
1443 */
Lukas Czerner386ad672013-03-10 22:50:00 -04001444 /*
1445 * If the block was allocated from previously allocated cluster,
1446 * then we don't need to reserve it again. However we still need
1447 * to reserve metadata for every block we're going to write.
1448 */
Jan Karacbd75842014-11-25 11:41:49 -05001449 if (EXT4_SB(inode->i_sb)->s_cluster_ratio <= 1 ||
1450 !ext4_find_delalloc_cluster(inode, map->m_lblk)) {
Zheng Liuf7fec032013-02-18 00:28:47 -05001451 ret = ext4_da_reserve_space(inode, iblock);
1452 if (ret) {
Aditya Kali5356f262011-09-09 19:20:51 -04001453 /* not enough space to reserve */
Zheng Liuf7fec032013-02-18 00:28:47 -05001454 retval = ret;
Aditya Kali5356f262011-09-09 19:20:51 -04001455 goto out_unlock;
Zheng Liuf7fec032013-02-18 00:28:47 -05001456 }
Aditya Kali5356f262011-09-09 19:20:51 -04001457 }
1458
Zheng Liuf7fec032013-02-18 00:28:47 -05001459 ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
1460 ~0, EXTENT_STATUS_DELAYED);
1461 if (ret) {
1462 retval = ret;
Zheng Liu51865fd2012-11-08 21:57:32 -05001463 goto out_unlock;
Zheng Liuf7fec032013-02-18 00:28:47 -05001464 }
Zheng Liu51865fd2012-11-08 21:57:32 -05001465
Aditya Kali5356f262011-09-09 19:20:51 -04001466 map_bh(bh, inode->i_sb, invalid_block);
1467 set_buffer_new(bh);
1468 set_buffer_delay(bh);
Zheng Liuf7fec032013-02-18 00:28:47 -05001469 } else if (retval > 0) {
1470 int ret;
Theodore Ts'o3be78c72013-08-16 21:22:41 -04001471 unsigned int status;
Zheng Liuf7fec032013-02-18 00:28:47 -05001472
Zheng Liu44fb851d2013-07-29 12:51:42 -04001473 if (unlikely(retval != map->m_len)) {
1474 ext4_warning(inode->i_sb,
1475 "ES len assertion failed for inode "
1476 "%lu: retval %d != map->m_len %d",
1477 inode->i_ino, retval, map->m_len);
1478 WARN_ON(1);
Dmitry Monakhov921f2662013-03-10 21:01:03 -04001479 }
Dmitry Monakhov921f2662013-03-10 21:01:03 -04001480
Zheng Liuf7fec032013-02-18 00:28:47 -05001481 status = map->m_flags & EXT4_MAP_UNWRITTEN ?
1482 EXTENT_STATUS_UNWRITTEN : EXTENT_STATUS_WRITTEN;
1483 ret = ext4_es_insert_extent(inode, map->m_lblk, map->m_len,
1484 map->m_pblk, status);
1485 if (ret != 0)
1486 retval = ret;
Aditya Kali5356f262011-09-09 19:20:51 -04001487 }
1488
1489out_unlock:
1490 up_read((&EXT4_I(inode)->i_data_sem));
1491
1492 return retval;
1493}
1494
1495/*
Seunghun Leed91bd2c2014-09-01 22:15:30 -04001496 * This is a special get_block_t callback which is used by
Theodore Ts'ob920c752009-05-14 00:54:29 -04001497 * ext4_da_write_begin(). It will either return mapped block or
1498 * reserve space for a single block.
Aneesh Kumar K.V29fa89d2009-05-12 16:30:27 -04001499 *
1500 * For delayed buffer_head we have BH_Mapped, BH_New, BH_Delay set.
1501 * We also have b_blocknr = -1 and b_bdev initialized properly
1502 *
1503 * For unwritten buffer_head we have BH_Mapped, BH_New, BH_Unwritten set.
1504 * We also have b_blocknr = physicalblock mapping unwritten extent and b_bdev
1505 * initialized properly.
Alex Tomas64769242008-07-11 19:27:31 -04001506 */
Tao Ma9c3569b2012-12-10 14:05:57 -05001507int ext4_da_get_block_prep(struct inode *inode, sector_t iblock,
1508 struct buffer_head *bh, int create)
Alex Tomas64769242008-07-11 19:27:31 -04001509{
Theodore Ts'o2ed88682010-05-16 20:00:00 -04001510 struct ext4_map_blocks map;
Alex Tomas64769242008-07-11 19:27:31 -04001511 int ret = 0;
1512
1513 BUG_ON(create == 0);
Theodore Ts'o2ed88682010-05-16 20:00:00 -04001514 BUG_ON(bh->b_size != inode->i_sb->s_blocksize);
1515
1516 map.m_lblk = iblock;
1517 map.m_len = 1;
Alex Tomas64769242008-07-11 19:27:31 -04001518
1519 /*
1520 * first, we need to know whether the block is allocated already
1521 * preallocated blocks are unmapped but should treated
1522 * the same as allocated blocks.
1523 */
Aditya Kali5356f262011-09-09 19:20:51 -04001524 ret = ext4_da_map_blocks(inode, iblock, &map, bh);
1525 if (ret <= 0)
Theodore Ts'o2ed88682010-05-16 20:00:00 -04001526 return ret;
Alex Tomas64769242008-07-11 19:27:31 -04001527
Theodore Ts'o2ed88682010-05-16 20:00:00 -04001528 map_bh(bh, inode->i_sb, map.m_pblk);
1529 bh->b_state = (bh->b_state & ~EXT4_MAP_FLAGS) | map.m_flags;
1530
1531 if (buffer_unwritten(bh)) {
1532 /* A delayed write to unwritten bh should be marked
1533 * new and mapped. Mapped ensures that we don't do
1534 * get_block multiple times when we write to the same
1535 * offset and new ensures that we do proper zero out
1536 * for partial write.
1537 */
1538 set_buffer_new(bh);
Theodore Ts'oc8205632011-04-10 22:30:07 -04001539 set_buffer_mapped(bh);
Theodore Ts'o2ed88682010-05-16 20:00:00 -04001540 }
1541 return 0;
Alex Tomas64769242008-07-11 19:27:31 -04001542}
Mingming Cao61628a32008-07-11 19:27:31 -04001543
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001544static int bget_one(handle_t *handle, struct buffer_head *bh)
1545{
1546 get_bh(bh);
1547 return 0;
1548}
1549
1550static int bput_one(handle_t *handle, struct buffer_head *bh)
1551{
1552 put_bh(bh);
1553 return 0;
1554}
1555
1556static int __ext4_journalled_writepage(struct page *page,
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001557 unsigned int len)
1558{
1559 struct address_space *mapping = page->mapping;
1560 struct inode *inode = mapping->host;
Tao Ma3fdcfb62012-12-10 14:05:57 -05001561 struct buffer_head *page_bufs = NULL;
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001562 handle_t *handle = NULL;
Tao Ma3fdcfb62012-12-10 14:05:57 -05001563 int ret = 0, err = 0;
1564 int inline_data = ext4_has_inline_data(inode);
1565 struct buffer_head *inode_bh = NULL;
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001566
Theodore Ts'ocb20d512010-10-27 21:30:09 -04001567 ClearPageChecked(page);
Tao Ma3fdcfb62012-12-10 14:05:57 -05001568
1569 if (inline_data) {
1570 BUG_ON(page->index != 0);
1571 BUG_ON(len > ext4_get_max_inline_size(inode));
1572 inode_bh = ext4_journalled_write_inline_data(inode, len, page);
1573 if (inode_bh == NULL)
1574 goto out;
1575 } else {
1576 page_bufs = page_buffers(page);
1577 if (!page_bufs) {
1578 BUG();
1579 goto out;
1580 }
1581 ext4_walk_page_buffers(handle, page_bufs, 0, len,
1582 NULL, bget_one);
1583 }
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001584 /* As soon as we unlock the page, it can go away, but we have
1585 * references to buffers so we are safe */
1586 unlock_page(page);
1587
Theodore Ts'o9924a922013-02-08 21:59:22 -05001588 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
1589 ext4_writepage_trans_blocks(inode));
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001590 if (IS_ERR(handle)) {
1591 ret = PTR_ERR(handle);
1592 goto out;
1593 }
1594
Curt Wohlgemuth441c8502011-08-13 11:25:18 -04001595 BUG_ON(!ext4_handle_valid(handle));
1596
Tao Ma3fdcfb62012-12-10 14:05:57 -05001597 if (inline_data) {
liang xie5d601252014-05-12 22:06:43 -04001598 BUFFER_TRACE(inode_bh, "get write access");
Tao Ma3fdcfb62012-12-10 14:05:57 -05001599 ret = ext4_journal_get_write_access(handle, inode_bh);
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001600
Tao Ma3fdcfb62012-12-10 14:05:57 -05001601 err = ext4_handle_dirty_metadata(handle, inode, inode_bh);
1602
1603 } else {
1604 ret = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL,
1605 do_journal_get_write_access);
1606
1607 err = ext4_walk_page_buffers(handle, page_bufs, 0, len, NULL,
1608 write_end_fn);
1609 }
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001610 if (ret == 0)
1611 ret = err;
Jan Kara2d859db2011-07-26 09:07:11 -04001612 EXT4_I(inode)->i_datasync_tid = handle->h_transaction->t_tid;
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001613 err = ext4_journal_stop(handle);
1614 if (!ret)
1615 ret = err;
1616
Tao Ma3fdcfb62012-12-10 14:05:57 -05001617 if (!ext4_has_inline_data(inode))
Theodore Ts'o8c9367f2014-01-07 13:08:03 -05001618 ext4_walk_page_buffers(NULL, page_bufs, 0, len,
Tao Ma3fdcfb62012-12-10 14:05:57 -05001619 NULL, bput_one);
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05001620 ext4_set_inode_state(inode, EXT4_STATE_JDATA);
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001621out:
Tao Ma3fdcfb62012-12-10 14:05:57 -05001622 brelse(inode_bh);
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001623 return ret;
1624}
1625
Mingming Cao61628a32008-07-11 19:27:31 -04001626/*
Aneesh Kumar K.V43ce1d22009-06-14 17:58:45 -04001627 * Note that we don't need to start a transaction unless we're journaling data
1628 * because we should have holes filled from ext4_page_mkwrite(). We even don't
1629 * need to file the inode to the transaction's list in ordered mode because if
1630 * we are writing back data added by write(), the inode is already there and if
Lucas De Marchi25985ed2011-03-30 22:57:33 -03001631 * we are writing back data modified via mmap(), no one guarantees in which
Aneesh Kumar K.V43ce1d22009-06-14 17:58:45 -04001632 * transaction the data will hit the disk. In case we are journaling data, we
1633 * cannot start transaction directly because transaction start ranks above page
1634 * lock so we have to do some magic.
1635 *
Theodore Ts'ob920c752009-05-14 00:54:29 -04001636 * This function can get called via...
Theodore Ts'o20970ba2013-06-06 14:00:46 -04001637 * - ext4_writepages after taking page lock (have journal handle)
Theodore Ts'ob920c752009-05-14 00:54:29 -04001638 * - journal_submit_inode_data_buffers (no journal handle)
Artem Bityutskiyf6463b02012-07-25 18:12:04 +03001639 * - shrink_page_list via the kswapd/direct reclaim (no journal handle)
Theodore Ts'ob920c752009-05-14 00:54:29 -04001640 * - grab_page_cache when doing write_begin (have journal handle)
Aneesh Kumar K.V43ce1d22009-06-14 17:58:45 -04001641 *
1642 * We don't do any block allocation in this function. If we have page with
1643 * multiple blocks we need to write those buffer_heads that are mapped. This
1644 * is important for mmaped based write. So if we do with blocksize 1K
1645 * truncate(f, 1024);
1646 * a = mmap(f, 0, 4096);
1647 * a[0] = 'a';
1648 * truncate(f, 4096);
1649 * we have in the page first buffer_head mapped via page_mkwrite call back
Paul Bolle90802ed2011-12-05 13:00:34 +01001650 * but other buffer_heads would be unmapped but dirty (dirty done via the
Aneesh Kumar K.V43ce1d22009-06-14 17:58:45 -04001651 * do_wp_page). So writepage should write the first block. If we modify
1652 * the mmap area beyond 1024 we will again get a page_fault and the
1653 * page_mkwrite callback will do the block allocation and mark the
1654 * buffer_heads mapped.
1655 *
1656 * We redirty the page if we have any buffer_heads that is either delay or
1657 * unwritten in the page.
1658 *
1659 * We can get recursively called as show below.
1660 *
1661 * ext4_writepage() -> kmalloc() -> __alloc_pages() -> page_launder() ->
1662 * ext4_writepage()
1663 *
1664 * But since we don't do any block allocation we should not deadlock.
1665 * Page also have the dirty flag cleared so we don't get recurive page_lock.
Mingming Cao61628a32008-07-11 19:27:31 -04001666 */
Aneesh Kumar K.V43ce1d22009-06-14 17:58:45 -04001667static int ext4_writepage(struct page *page,
Aneesh Kumar K.V62e086b2009-06-14 17:59:34 -04001668 struct writeback_control *wbc)
Alex Tomas64769242008-07-11 19:27:31 -04001669{
Jan Karaf8bec372013-01-28 12:55:08 -05001670 int ret = 0;
Mingming Cao61628a32008-07-11 19:27:31 -04001671 loff_t size;
Theodore Ts'o498e5f22008-11-05 00:14:04 -05001672 unsigned int len;
Jiaying Zhang744692d2010-03-04 16:14:02 -05001673 struct buffer_head *page_bufs = NULL;
Mingming Cao61628a32008-07-11 19:27:31 -04001674 struct inode *inode = page->mapping->host;
Jan Kara36ade452013-01-28 09:30:52 -05001675 struct ext4_io_submit io_submit;
Namjae Jeon1c8349a2014-05-12 08:12:25 -04001676 bool keep_towrite = false;
Alex Tomas64769242008-07-11 19:27:31 -04001677
Lukas Czernera9c667f2011-06-06 09:51:52 -04001678 trace_ext4_writepage(page);
Aneesh Kumar K.Vf0e6c982008-07-11 19:27:31 -04001679 size = i_size_read(inode);
1680 if (page->index == size >> PAGE_CACHE_SHIFT)
1681 len = size & ~PAGE_CACHE_MASK;
1682 else
1683 len = PAGE_CACHE_SIZE;
Alex Tomas64769242008-07-11 19:27:31 -04001684
Theodore Ts'oa42afc52010-10-27 21:30:09 -04001685 page_bufs = page_buffers(page);
Aneesh Kumar K.Vc364b222009-06-14 17:57:10 -04001686 /*
Jan Karafe386132013-01-28 21:06:42 -05001687 * We cannot do block allocation or other extent handling in this
1688 * function. If there are buffers needing that, we have to redirty
1689 * the page. But we may reach here when we do a journal commit via
1690 * journal_submit_inode_data_buffers() and in that case we must write
1691 * allocated buffers to achieve data=ordered mode guarantees.
Aneesh Kumar K.Vcd1aac32008-07-11 19:27:31 -04001692 */
Tao Maf19d5872012-12-10 14:05:51 -05001693 if (ext4_walk_page_buffers(NULL, page_bufs, 0, len, NULL,
1694 ext4_bh_delay_or_unwritten)) {
Jan Karaf8bec372013-01-28 12:55:08 -05001695 redirty_page_for_writepage(wbc, page);
Jan Karafe386132013-01-28 21:06:42 -05001696 if (current->flags & PF_MEMALLOC) {
1697 /*
1698 * For memory cleaning there's no point in writing only
1699 * some buffers. So just bail out. Warn if we came here
1700 * from direct reclaim.
1701 */
1702 WARN_ON_ONCE((current->flags & (PF_MEMALLOC|PF_KSWAPD))
1703 == PF_MEMALLOC);
Aneesh Kumar K.Vf0e6c982008-07-11 19:27:31 -04001704 unlock_page(page);
1705 return 0;
1706 }
Namjae Jeon1c8349a2014-05-12 08:12:25 -04001707 keep_towrite = true;
Theodore Ts'oa42afc52010-10-27 21:30:09 -04001708 }
Alex Tomas64769242008-07-11 19:27:31 -04001709
Theodore Ts'ocb20d512010-10-27 21:30:09 -04001710 if (PageChecked(page) && ext4_should_journal_data(inode))
Aneesh Kumar K.V43ce1d22009-06-14 17:58:45 -04001711 /*
1712 * It's mmapped pagecache. Add buffers and journal it. There
1713 * doesn't seem much point in redirtying the page here.
1714 */
Wu Fengguang3f0ca302009-11-24 11:15:44 -05001715 return __ext4_journalled_writepage(page, len);
Aneesh Kumar K.V43ce1d22009-06-14 17:58:45 -04001716
Jan Kara97a851e2013-06-04 11:58:58 -04001717 ext4_io_submit_init(&io_submit, wbc);
1718 io_submit.io_end = ext4_init_io_end(inode, GFP_NOFS);
1719 if (!io_submit.io_end) {
1720 redirty_page_for_writepage(wbc, page);
1721 unlock_page(page);
1722 return -ENOMEM;
1723 }
Namjae Jeon1c8349a2014-05-12 08:12:25 -04001724 ret = ext4_bio_write_page(&io_submit, page, len, wbc, keep_towrite);
Jan Kara36ade452013-01-28 09:30:52 -05001725 ext4_io_submit(&io_submit);
Jan Kara97a851e2013-06-04 11:58:58 -04001726 /* Drop io_end reference we got from init */
1727 ext4_put_io_end_defer(io_submit.io_end);
Alex Tomas64769242008-07-11 19:27:31 -04001728 return ret;
1729}
1730
Jan Kara5f1132b2013-08-17 10:02:33 -04001731static int mpage_submit_page(struct mpage_da_data *mpd, struct page *page)
1732{
1733 int len;
1734 loff_t size = i_size_read(mpd->inode);
1735 int err;
1736
1737 BUG_ON(page->index != mpd->first_page);
1738 if (page->index == size >> PAGE_CACHE_SHIFT)
1739 len = size & ~PAGE_CACHE_MASK;
1740 else
1741 len = PAGE_CACHE_SIZE;
1742 clear_page_dirty_for_io(page);
Namjae Jeon1c8349a2014-05-12 08:12:25 -04001743 err = ext4_bio_write_page(&mpd->io_submit, page, len, mpd->wbc, false);
Jan Kara5f1132b2013-08-17 10:02:33 -04001744 if (!err)
1745 mpd->wbc->nr_to_write--;
1746 mpd->first_page++;
1747
1748 return err;
1749}
1750
Jan Kara4e7ea812013-06-04 13:17:40 -04001751#define BH_FLAGS ((1 << BH_Unwritten) | (1 << BH_Delay))
1752
Mingming Cao61628a32008-07-11 19:27:31 -04001753/*
Jan Karafffb2732013-06-04 13:01:11 -04001754 * mballoc gives us at most this number of blocks...
1755 * XXX: That seems to be only a limitation of ext4_mb_normalize_request().
Anatol Pomozov70261f52013-08-28 14:40:12 -04001756 * The rest of mballoc seems to handle chunks up to full group size.
Mingming Cao61628a32008-07-11 19:27:31 -04001757 */
Jan Karafffb2732013-06-04 13:01:11 -04001758#define MAX_WRITEPAGES_EXTENT_LEN 2048
Mingming Cao525f4ed2008-08-19 22:15:58 -04001759
Jan Karafffb2732013-06-04 13:01:11 -04001760/*
Jan Kara4e7ea812013-06-04 13:17:40 -04001761 * mpage_add_bh_to_extent - try to add bh to extent of blocks to map
1762 *
1763 * @mpd - extent of blocks
1764 * @lblk - logical number of the block in the file
Jan Kara09930042013-08-17 09:57:56 -04001765 * @bh - buffer head we want to add to the extent
Jan Kara4e7ea812013-06-04 13:17:40 -04001766 *
Jan Kara09930042013-08-17 09:57:56 -04001767 * The function is used to collect contig. blocks in the same state. If the
1768 * buffer doesn't require mapping for writeback and we haven't started the
1769 * extent of buffers to map yet, the function returns 'true' immediately - the
1770 * caller can write the buffer right away. Otherwise the function returns true
1771 * if the block has been added to the extent, false if the block couldn't be
1772 * added.
Jan Kara4e7ea812013-06-04 13:17:40 -04001773 */
Jan Kara09930042013-08-17 09:57:56 -04001774static bool mpage_add_bh_to_extent(struct mpage_da_data *mpd, ext4_lblk_t lblk,
1775 struct buffer_head *bh)
Jan Kara4e7ea812013-06-04 13:17:40 -04001776{
1777 struct ext4_map_blocks *map = &mpd->map;
1778
Jan Kara09930042013-08-17 09:57:56 -04001779 /* Buffer that doesn't need mapping for writeback? */
1780 if (!buffer_dirty(bh) || !buffer_mapped(bh) ||
1781 (!buffer_delay(bh) && !buffer_unwritten(bh))) {
1782 /* So far no extent to map => we write the buffer right away */
1783 if (map->m_len == 0)
1784 return true;
1785 return false;
1786 }
Jan Kara4e7ea812013-06-04 13:17:40 -04001787
1788 /* First block in the extent? */
1789 if (map->m_len == 0) {
1790 map->m_lblk = lblk;
1791 map->m_len = 1;
Jan Kara09930042013-08-17 09:57:56 -04001792 map->m_flags = bh->b_state & BH_FLAGS;
1793 return true;
Jan Kara4e7ea812013-06-04 13:17:40 -04001794 }
1795
Jan Kara09930042013-08-17 09:57:56 -04001796 /* Don't go larger than mballoc is willing to allocate */
1797 if (map->m_len >= MAX_WRITEPAGES_EXTENT_LEN)
1798 return false;
1799
Jan Kara4e7ea812013-06-04 13:17:40 -04001800 /* Can we merge the block to our big extent? */
1801 if (lblk == map->m_lblk + map->m_len &&
Jan Kara09930042013-08-17 09:57:56 -04001802 (bh->b_state & BH_FLAGS) == map->m_flags) {
Jan Kara4e7ea812013-06-04 13:17:40 -04001803 map->m_len++;
Jan Kara09930042013-08-17 09:57:56 -04001804 return true;
Jan Kara4e7ea812013-06-04 13:17:40 -04001805 }
Jan Kara09930042013-08-17 09:57:56 -04001806 return false;
Jan Kara4e7ea812013-06-04 13:17:40 -04001807}
1808
Jan Kara5f1132b2013-08-17 10:02:33 -04001809/*
1810 * mpage_process_page_bufs - submit page buffers for IO or add them to extent
1811 *
1812 * @mpd - extent of blocks for mapping
1813 * @head - the first buffer in the page
1814 * @bh - buffer we should start processing from
1815 * @lblk - logical number of the block in the file corresponding to @bh
1816 *
1817 * Walk through page buffers from @bh upto @head (exclusive) and either submit
1818 * the page for IO if all buffers in this page were mapped and there's no
1819 * accumulated extent of buffers to map or add buffers in the page to the
1820 * extent of buffers to map. The function returns 1 if the caller can continue
1821 * by processing the next page, 0 if it should stop adding buffers to the
1822 * extent to map because we cannot extend it anymore. It can also return value
1823 * < 0 in case of error during IO submission.
1824 */
1825static int mpage_process_page_bufs(struct mpage_da_data *mpd,
1826 struct buffer_head *head,
1827 struct buffer_head *bh,
1828 ext4_lblk_t lblk)
Jan Kara4e7ea812013-06-04 13:17:40 -04001829{
1830 struct inode *inode = mpd->inode;
Jan Kara5f1132b2013-08-17 10:02:33 -04001831 int err;
Jan Kara4e7ea812013-06-04 13:17:40 -04001832 ext4_lblk_t blocks = (i_size_read(inode) + (1 << inode->i_blkbits) - 1)
1833 >> inode->i_blkbits;
1834
1835 do {
1836 BUG_ON(buffer_locked(bh));
1837
Jan Kara09930042013-08-17 09:57:56 -04001838 if (lblk >= blocks || !mpage_add_bh_to_extent(mpd, lblk, bh)) {
Jan Kara4e7ea812013-06-04 13:17:40 -04001839 /* Found extent to map? */
1840 if (mpd->map.m_len)
Jan Kara5f1132b2013-08-17 10:02:33 -04001841 return 0;
Jan Kara09930042013-08-17 09:57:56 -04001842 /* Everything mapped so far and we hit EOF */
Jan Kara5f1132b2013-08-17 10:02:33 -04001843 break;
Jan Kara4e7ea812013-06-04 13:17:40 -04001844 }
Jan Kara4e7ea812013-06-04 13:17:40 -04001845 } while (lblk++, (bh = bh->b_this_page) != head);
Jan Kara5f1132b2013-08-17 10:02:33 -04001846 /* So far everything mapped? Submit the page for IO. */
1847 if (mpd->map.m_len == 0) {
1848 err = mpage_submit_page(mpd, head->b_page);
1849 if (err < 0)
1850 return err;
1851 }
1852 return lblk < blocks;
Jan Kara4e7ea812013-06-04 13:17:40 -04001853}
1854
1855/*
1856 * mpage_map_buffers - update buffers corresponding to changed extent and
1857 * submit fully mapped pages for IO
1858 *
1859 * @mpd - description of extent to map, on return next extent to map
1860 *
1861 * Scan buffers corresponding to changed extent (we expect corresponding pages
1862 * to be already locked) and update buffer state according to new extent state.
1863 * We map delalloc buffers to their physical location, clear unwritten bits,
Lukas Czerner556615d2014-04-20 23:45:47 -04001864 * and mark buffers as uninit when we perform writes to unwritten extents
Jan Kara4e7ea812013-06-04 13:17:40 -04001865 * and do extent conversion after IO is finished. If the last page is not fully
1866 * mapped, we update @map to the next extent in the last page that needs
1867 * mapping. Otherwise we submit the page for IO.
1868 */
1869static int mpage_map_and_submit_buffers(struct mpage_da_data *mpd)
1870{
1871 struct pagevec pvec;
1872 int nr_pages, i;
1873 struct inode *inode = mpd->inode;
1874 struct buffer_head *head, *bh;
1875 int bpp_bits = PAGE_CACHE_SHIFT - inode->i_blkbits;
Jan Kara4e7ea812013-06-04 13:17:40 -04001876 pgoff_t start, end;
1877 ext4_lblk_t lblk;
1878 sector_t pblock;
1879 int err;
1880
1881 start = mpd->map.m_lblk >> bpp_bits;
1882 end = (mpd->map.m_lblk + mpd->map.m_len - 1) >> bpp_bits;
1883 lblk = start << bpp_bits;
1884 pblock = mpd->map.m_pblk;
1885
1886 pagevec_init(&pvec, 0);
1887 while (start <= end) {
1888 nr_pages = pagevec_lookup(&pvec, inode->i_mapping, start,
1889 PAGEVEC_SIZE);
1890 if (nr_pages == 0)
1891 break;
1892 for (i = 0; i < nr_pages; i++) {
1893 struct page *page = pvec.pages[i];
1894
1895 if (page->index > end)
1896 break;
Anatol Pomozov70261f52013-08-28 14:40:12 -04001897 /* Up to 'end' pages must be contiguous */
Jan Kara4e7ea812013-06-04 13:17:40 -04001898 BUG_ON(page->index != start);
1899 bh = head = page_buffers(page);
1900 do {
1901 if (lblk < mpd->map.m_lblk)
1902 continue;
1903 if (lblk >= mpd->map.m_lblk + mpd->map.m_len) {
1904 /*
1905 * Buffer after end of mapped extent.
1906 * Find next buffer in the page to map.
1907 */
1908 mpd->map.m_len = 0;
1909 mpd->map.m_flags = 0;
Jan Kara5f1132b2013-08-17 10:02:33 -04001910 /*
1911 * FIXME: If dioread_nolock supports
1912 * blocksize < pagesize, we need to make
1913 * sure we add size mapped so far to
1914 * io_end->size as the following call
1915 * can submit the page for IO.
1916 */
1917 err = mpage_process_page_bufs(mpd, head,
1918 bh, lblk);
Jan Kara4e7ea812013-06-04 13:17:40 -04001919 pagevec_release(&pvec);
Jan Kara5f1132b2013-08-17 10:02:33 -04001920 if (err > 0)
1921 err = 0;
1922 return err;
Jan Kara4e7ea812013-06-04 13:17:40 -04001923 }
1924 if (buffer_delay(bh)) {
1925 clear_buffer_delay(bh);
1926 bh->b_blocknr = pblock++;
1927 }
Jan Kara4e7ea812013-06-04 13:17:40 -04001928 clear_buffer_unwritten(bh);
Jan Kara5f1132b2013-08-17 10:02:33 -04001929 } while (lblk++, (bh = bh->b_this_page) != head);
Jan Kara4e7ea812013-06-04 13:17:40 -04001930
1931 /*
1932 * FIXME: This is going to break if dioread_nolock
1933 * supports blocksize < pagesize as we will try to
1934 * convert potentially unmapped parts of inode.
1935 */
1936 mpd->io_submit.io_end->size += PAGE_CACHE_SIZE;
1937 /* Page fully mapped - let IO run! */
1938 err = mpage_submit_page(mpd, page);
1939 if (err < 0) {
1940 pagevec_release(&pvec);
1941 return err;
1942 }
1943 start++;
1944 }
1945 pagevec_release(&pvec);
1946 }
1947 /* Extent fully mapped and matches with page boundary. We are done. */
1948 mpd->map.m_len = 0;
1949 mpd->map.m_flags = 0;
1950 return 0;
1951}
1952
1953static int mpage_map_one_extent(handle_t *handle, struct mpage_da_data *mpd)
1954{
1955 struct inode *inode = mpd->inode;
1956 struct ext4_map_blocks *map = &mpd->map;
1957 int get_blocks_flags;
Lukas Czerner090f32e2014-04-20 23:44:47 -04001958 int err, dioread_nolock;
Jan Kara4e7ea812013-06-04 13:17:40 -04001959
1960 trace_ext4_da_write_pages_extent(inode, map);
1961 /*
1962 * Call ext4_map_blocks() to allocate any delayed allocation blocks, or
Lukas Czerner556615d2014-04-20 23:45:47 -04001963 * to convert an unwritten extent to be initialized (in the case
Jan Kara4e7ea812013-06-04 13:17:40 -04001964 * where we have written into one or more preallocated blocks). It is
1965 * possible that we're going to need more metadata blocks than
1966 * previously reserved. However we must not fail because we're in
1967 * writeback and there is nothing we can do about it so it might result
1968 * in data loss. So use reserved blocks to allocate metadata if
1969 * possible.
1970 *
Theodore Ts'o754cfed2014-09-04 18:08:22 -04001971 * We pass in the magic EXT4_GET_BLOCKS_DELALLOC_RESERVE if
1972 * the blocks in question are delalloc blocks. This indicates
1973 * that the blocks and quotas has already been checked when
1974 * the data was copied into the page cache.
Jan Kara4e7ea812013-06-04 13:17:40 -04001975 */
1976 get_blocks_flags = EXT4_GET_BLOCKS_CREATE |
1977 EXT4_GET_BLOCKS_METADATA_NOFAIL;
Lukas Czerner090f32e2014-04-20 23:44:47 -04001978 dioread_nolock = ext4_should_dioread_nolock(inode);
1979 if (dioread_nolock)
Jan Kara4e7ea812013-06-04 13:17:40 -04001980 get_blocks_flags |= EXT4_GET_BLOCKS_IO_CREATE_EXT;
1981 if (map->m_flags & (1 << BH_Delay))
1982 get_blocks_flags |= EXT4_GET_BLOCKS_DELALLOC_RESERVE;
1983
1984 err = ext4_map_blocks(handle, inode, map, get_blocks_flags);
1985 if (err < 0)
1986 return err;
Lukas Czerner090f32e2014-04-20 23:44:47 -04001987 if (dioread_nolock && (map->m_flags & EXT4_MAP_UNWRITTEN)) {
Jan Kara6b523df2013-06-04 13:21:11 -04001988 if (!mpd->io_submit.io_end->handle &&
1989 ext4_handle_valid(handle)) {
1990 mpd->io_submit.io_end->handle = handle->h_rsv_handle;
1991 handle->h_rsv_handle = NULL;
1992 }
Jan Kara3613d222013-06-04 13:19:34 -04001993 ext4_set_io_unwritten_flag(inode, mpd->io_submit.io_end);
Jan Kara6b523df2013-06-04 13:21:11 -04001994 }
Jan Kara4e7ea812013-06-04 13:17:40 -04001995
1996 BUG_ON(map->m_len == 0);
1997 if (map->m_flags & EXT4_MAP_NEW) {
1998 struct block_device *bdev = inode->i_sb->s_bdev;
1999 int i;
2000
2001 for (i = 0; i < map->m_len; i++)
2002 unmap_underlying_metadata(bdev, map->m_pblk + i);
2003 }
2004 return 0;
2005}
2006
2007/*
2008 * mpage_map_and_submit_extent - map extent starting at mpd->lblk of length
2009 * mpd->len and submit pages underlying it for IO
2010 *
2011 * @handle - handle for journal operations
2012 * @mpd - extent to map
Jan Kara7534e852013-10-16 08:26:08 -04002013 * @give_up_on_write - we set this to true iff there is a fatal error and there
2014 * is no hope of writing the data. The caller should discard
2015 * dirty pages to avoid infinite loops.
Jan Kara4e7ea812013-06-04 13:17:40 -04002016 *
2017 * The function maps extent starting at mpd->lblk of length mpd->len. If it is
2018 * delayed, blocks are allocated, if it is unwritten, we may need to convert
2019 * them to initialized or split the described range from larger unwritten
2020 * extent. Note that we need not map all the described range since allocation
2021 * can return less blocks or the range is covered by more unwritten extents. We
2022 * cannot map more because we are limited by reserved transaction credits. On
2023 * the other hand we always make sure that the last touched page is fully
2024 * mapped so that it can be written out (and thus forward progress is
2025 * guaranteed). After mapping we submit all mapped pages for IO.
2026 */
2027static int mpage_map_and_submit_extent(handle_t *handle,
Theodore Ts'ocb530542013-07-01 08:12:40 -04002028 struct mpage_da_data *mpd,
2029 bool *give_up_on_write)
Jan Kara4e7ea812013-06-04 13:17:40 -04002030{
2031 struct inode *inode = mpd->inode;
2032 struct ext4_map_blocks *map = &mpd->map;
2033 int err;
2034 loff_t disksize;
Dmitry Monakhov66031202014-08-27 18:40:03 -04002035 int progress = 0;
Jan Kara4e7ea812013-06-04 13:17:40 -04002036
2037 mpd->io_submit.io_end->offset =
2038 ((loff_t)map->m_lblk) << inode->i_blkbits;
Jan Kara27d7c4e2013-07-05 21:57:22 -04002039 do {
Jan Kara4e7ea812013-06-04 13:17:40 -04002040 err = mpage_map_one_extent(handle, mpd);
2041 if (err < 0) {
2042 struct super_block *sb = inode->i_sb;
2043
Theodore Ts'ocb530542013-07-01 08:12:40 -04002044 if (EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED)
2045 goto invalidate_dirty_pages;
Jan Kara4e7ea812013-06-04 13:17:40 -04002046 /*
Theodore Ts'ocb530542013-07-01 08:12:40 -04002047 * Let the uper layers retry transient errors.
2048 * In the case of ENOSPC, if ext4_count_free_blocks()
2049 * is non-zero, a commit should free up blocks.
Jan Kara4e7ea812013-06-04 13:17:40 -04002050 */
Theodore Ts'ocb530542013-07-01 08:12:40 -04002051 if ((err == -ENOMEM) ||
Dmitry Monakhov66031202014-08-27 18:40:03 -04002052 (err == -ENOSPC && ext4_count_free_clusters(sb))) {
2053 if (progress)
2054 goto update_disksize;
Theodore Ts'ocb530542013-07-01 08:12:40 -04002055 return err;
Dmitry Monakhov66031202014-08-27 18:40:03 -04002056 }
Theodore Ts'ocb530542013-07-01 08:12:40 -04002057 ext4_msg(sb, KERN_CRIT,
2058 "Delayed block allocation failed for "
2059 "inode %lu at logical offset %llu with"
2060 " max blocks %u with error %d",
2061 inode->i_ino,
2062 (unsigned long long)map->m_lblk,
2063 (unsigned)map->m_len, -err);
2064 ext4_msg(sb, KERN_CRIT,
2065 "This should not happen!! Data will "
2066 "be lost\n");
2067 if (err == -ENOSPC)
2068 ext4_print_free_blocks(inode);
2069 invalidate_dirty_pages:
2070 *give_up_on_write = true;
Jan Kara4e7ea812013-06-04 13:17:40 -04002071 return err;
2072 }
Dmitry Monakhov66031202014-08-27 18:40:03 -04002073 progress = 1;
Jan Kara4e7ea812013-06-04 13:17:40 -04002074 /*
2075 * Update buffer state, submit mapped pages, and get us new
2076 * extent to map
2077 */
2078 err = mpage_map_and_submit_buffers(mpd);
2079 if (err < 0)
Dmitry Monakhov66031202014-08-27 18:40:03 -04002080 goto update_disksize;
Jan Kara27d7c4e2013-07-05 21:57:22 -04002081 } while (map->m_len);
Jan Kara4e7ea812013-06-04 13:17:40 -04002082
Dmitry Monakhov66031202014-08-27 18:40:03 -04002083update_disksize:
Theodore Ts'o622cad12014-04-11 10:35:17 -04002084 /*
2085 * Update on-disk size after IO is submitted. Races with
2086 * truncate are avoided by checking i_size under i_data_sem.
2087 */
Jan Kara4e7ea812013-06-04 13:17:40 -04002088 disksize = ((loff_t)mpd->first_page) << PAGE_CACHE_SHIFT;
Jan Kara4e7ea812013-06-04 13:17:40 -04002089 if (disksize > EXT4_I(inode)->i_disksize) {
2090 int err2;
Theodore Ts'o622cad12014-04-11 10:35:17 -04002091 loff_t i_size;
Jan Kara4e7ea812013-06-04 13:17:40 -04002092
Theodore Ts'o622cad12014-04-11 10:35:17 -04002093 down_write(&EXT4_I(inode)->i_data_sem);
2094 i_size = i_size_read(inode);
2095 if (disksize > i_size)
2096 disksize = i_size;
2097 if (disksize > EXT4_I(inode)->i_disksize)
2098 EXT4_I(inode)->i_disksize = disksize;
Jan Kara4e7ea812013-06-04 13:17:40 -04002099 err2 = ext4_mark_inode_dirty(handle, inode);
Theodore Ts'o622cad12014-04-11 10:35:17 -04002100 up_write(&EXT4_I(inode)->i_data_sem);
Jan Kara4e7ea812013-06-04 13:17:40 -04002101 if (err2)
2102 ext4_error(inode->i_sb,
2103 "Failed to mark inode %lu dirty",
2104 inode->i_ino);
2105 if (!err)
2106 err = err2;
2107 }
2108 return err;
2109}
2110
2111/*
Jan Karafffb2732013-06-04 13:01:11 -04002112 * Calculate the total number of credits to reserve for one writepages
Theodore Ts'o20970ba2013-06-06 14:00:46 -04002113 * iteration. This is called from ext4_writepages(). We map an extent of
Anatol Pomozov70261f52013-08-28 14:40:12 -04002114 * up to MAX_WRITEPAGES_EXTENT_LEN blocks and then we go on and finish mapping
Jan Karafffb2732013-06-04 13:01:11 -04002115 * the last partial page. So in total we can map MAX_WRITEPAGES_EXTENT_LEN +
2116 * bpp - 1 blocks in bpp different extents.
2117 */
Mingming Cao525f4ed2008-08-19 22:15:58 -04002118static int ext4_da_writepages_trans_blocks(struct inode *inode)
2119{
Jan Karafffb2732013-06-04 13:01:11 -04002120 int bpp = ext4_journal_blocks_per_page(inode);
Mingming Cao525f4ed2008-08-19 22:15:58 -04002121
Jan Karafffb2732013-06-04 13:01:11 -04002122 return ext4_meta_trans_blocks(inode,
2123 MAX_WRITEPAGES_EXTENT_LEN + bpp - 1, bpp);
Mingming Cao525f4ed2008-08-19 22:15:58 -04002124}
Mingming Cao61628a32008-07-11 19:27:31 -04002125
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002126/*
Jan Kara4e7ea812013-06-04 13:17:40 -04002127 * mpage_prepare_extent_to_map - find & lock contiguous range of dirty pages
2128 * and underlying extent to map
2129 *
2130 * @mpd - where to look for pages
2131 *
2132 * Walk dirty pages in the mapping. If they are fully mapped, submit them for
2133 * IO immediately. When we find a page which isn't mapped we start accumulating
2134 * extent of buffers underlying these pages that needs mapping (formed by
2135 * either delayed or unwritten buffers). We also lock the pages containing
2136 * these buffers. The extent found is returned in @mpd structure (starting at
2137 * mpd->lblk with length mpd->len blocks).
2138 *
2139 * Note that this function can attach bios to one io_end structure which are
2140 * neither logically nor physically contiguous. Although it may seem as an
2141 * unnecessary complication, it is actually inevitable in blocksize < pagesize
2142 * case as we need to track IO to all buffers underlying a page in one io_end.
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002143 */
Jan Kara4e7ea812013-06-04 13:17:40 -04002144static int mpage_prepare_extent_to_map(struct mpage_da_data *mpd)
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002145{
Jan Kara4e7ea812013-06-04 13:17:40 -04002146 struct address_space *mapping = mpd->inode->i_mapping;
2147 struct pagevec pvec;
2148 unsigned int nr_pages;
Ming Leiaeac5892013-10-17 18:56:16 -04002149 long left = mpd->wbc->nr_to_write;
Jan Kara4e7ea812013-06-04 13:17:40 -04002150 pgoff_t index = mpd->first_page;
2151 pgoff_t end = mpd->last_page;
2152 int tag;
2153 int i, err = 0;
2154 int blkbits = mpd->inode->i_blkbits;
2155 ext4_lblk_t lblk;
2156 struct buffer_head *head;
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002157
Jan Kara4e7ea812013-06-04 13:17:40 -04002158 if (mpd->wbc->sync_mode == WB_SYNC_ALL || mpd->wbc->tagged_writepages)
Eric Sandeen5b41d922010-10-27 21:30:13 -04002159 tag = PAGECACHE_TAG_TOWRITE;
2160 else
2161 tag = PAGECACHE_TAG_DIRTY;
2162
Jan Kara4e7ea812013-06-04 13:17:40 -04002163 pagevec_init(&pvec, 0);
2164 mpd->map.m_len = 0;
2165 mpd->next_page = index;
Theodore Ts'o4f01b022011-02-26 14:07:37 -05002166 while (index <= end) {
Eric Sandeen5b41d922010-10-27 21:30:13 -04002167 nr_pages = pagevec_lookup_tag(&pvec, mapping, &index, tag,
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002168 min(end - index, (pgoff_t)PAGEVEC_SIZE-1) + 1);
2169 if (nr_pages == 0)
Jan Kara4e7ea812013-06-04 13:17:40 -04002170 goto out;
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002171
2172 for (i = 0; i < nr_pages; i++) {
2173 struct page *page = pvec.pages[i];
2174
2175 /*
2176 * At this point, the page may be truncated or
2177 * invalidated (changing page->mapping to NULL), or
2178 * even swizzled back from swapper_space to tmpfs file
2179 * mapping. However, page->index will not change
2180 * because we have a reference on the page.
2181 */
Theodore Ts'o4f01b022011-02-26 14:07:37 -05002182 if (page->index > end)
2183 goto out;
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002184
Ming Leiaeac5892013-10-17 18:56:16 -04002185 /*
2186 * Accumulated enough dirty pages? This doesn't apply
2187 * to WB_SYNC_ALL mode. For integrity sync we have to
2188 * keep going because someone may be concurrently
2189 * dirtying pages, and we might have synced a lot of
2190 * newly appeared dirty pages, but have not synced all
2191 * of the old dirty pages.
2192 */
2193 if (mpd->wbc->sync_mode == WB_SYNC_NONE && left <= 0)
2194 goto out;
2195
Jan Kara4e7ea812013-06-04 13:17:40 -04002196 /* If we can't merge this page, we are done. */
2197 if (mpd->map.m_len > 0 && mpd->next_page != page->index)
2198 goto out;
Theodore Ts'o78aaced2011-02-26 14:09:14 -05002199
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002200 lock_page(page);
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002201 /*
Jan Kara4e7ea812013-06-04 13:17:40 -04002202 * If the page is no longer dirty, or its mapping no
2203 * longer corresponds to inode we are writing (which
2204 * means it has been truncated or invalidated), or the
2205 * page is already under writeback and we are not doing
2206 * a data integrity writeback, skip the page
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002207 */
Theodore Ts'o4f01b022011-02-26 14:07:37 -05002208 if (!PageDirty(page) ||
2209 (PageWriteback(page) &&
Jan Kara4e7ea812013-06-04 13:17:40 -04002210 (mpd->wbc->sync_mode == WB_SYNC_NONE)) ||
Theodore Ts'o4f01b022011-02-26 14:07:37 -05002211 unlikely(page->mapping != mapping)) {
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002212 unlock_page(page);
2213 continue;
2214 }
2215
Darrick J. Wong7cb1a532011-05-18 13:53:20 -04002216 wait_on_page_writeback(page);
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002217 BUG_ON(PageWriteback(page));
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002218
Jan Kara4e7ea812013-06-04 13:17:40 -04002219 if (mpd->map.m_len == 0)
Theodore Ts'o8eb9e5c2011-02-26 14:07:31 -05002220 mpd->first_page = page->index;
Theodore Ts'o8eb9e5c2011-02-26 14:07:31 -05002221 mpd->next_page = page->index + 1;
Jan Karaf8bec372013-01-28 12:55:08 -05002222 /* Add all dirty buffers to mpd */
Jan Kara4e7ea812013-06-04 13:17:40 -04002223 lblk = ((ext4_lblk_t)page->index) <<
2224 (PAGE_CACHE_SHIFT - blkbits);
Jan Karaf8bec372013-01-28 12:55:08 -05002225 head = page_buffers(page);
Jan Kara5f1132b2013-08-17 10:02:33 -04002226 err = mpage_process_page_bufs(mpd, head, head, lblk);
2227 if (err <= 0)
Jan Kara4e7ea812013-06-04 13:17:40 -04002228 goto out;
Jan Kara5f1132b2013-08-17 10:02:33 -04002229 err = 0;
Ming Leiaeac5892013-10-17 18:56:16 -04002230 left--;
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002231 }
2232 pagevec_release(&pvec);
2233 cond_resched();
2234 }
Theodore Ts'o4f01b022011-02-26 14:07:37 -05002235 return 0;
Theodore Ts'o8eb9e5c2011-02-26 14:07:31 -05002236out:
2237 pagevec_release(&pvec);
Jan Kara4e7ea812013-06-04 13:17:40 -04002238 return err;
Theodore Ts'o8e48dcf2010-05-16 18:00:00 -04002239}
2240
Theodore Ts'o20970ba2013-06-06 14:00:46 -04002241static int __writepage(struct page *page, struct writeback_control *wbc,
2242 void *data)
2243{
2244 struct address_space *mapping = data;
2245 int ret = ext4_writepage(page, wbc);
2246 mapping_set_error(mapping, ret);
2247 return ret;
2248}
2249
2250static int ext4_writepages(struct address_space *mapping,
2251 struct writeback_control *wbc)
Alex Tomas64769242008-07-11 19:27:31 -04002252{
Jan Kara4e7ea812013-06-04 13:17:40 -04002253 pgoff_t writeback_index = 0;
2254 long nr_to_write = wbc->nr_to_write;
Aneesh Kumar K.V22208de2008-10-16 10:10:36 -04002255 int range_whole = 0;
Jan Kara4e7ea812013-06-04 13:17:40 -04002256 int cycled = 1;
Mingming Cao61628a32008-07-11 19:27:31 -04002257 handle_t *handle = NULL;
Aneesh Kumar K.Vdf222912008-09-08 23:05:34 -04002258 struct mpage_da_data mpd;
Aneesh Kumar K.V5e745b02008-08-18 18:00:57 -04002259 struct inode *inode = mapping->host;
Jan Kara6b523df2013-06-04 13:21:11 -04002260 int needed_blocks, rsv_blocks = 0, ret = 0;
Aneesh Kumar K.V5e745b02008-08-18 18:00:57 -04002261 struct ext4_sb_info *sbi = EXT4_SB(mapping->host->i_sb);
Jan Kara4e7ea812013-06-04 13:17:40 -04002262 bool done;
Shaohua Li1bce63d2011-10-18 10:55:51 -04002263 struct blk_plug plug;
Theodore Ts'ocb530542013-07-01 08:12:40 -04002264 bool give_up_on_write = false;
Mingming Cao61628a32008-07-11 19:27:31 -04002265
Theodore Ts'o20970ba2013-06-06 14:00:46 -04002266 trace_ext4_writepages(inode, wbc);
Theodore Ts'oba80b102009-01-03 20:03:21 -05002267
Mingming Cao61628a32008-07-11 19:27:31 -04002268 /*
2269 * No pages to write? This is mainly a kludge to avoid starting
2270 * a transaction for special inodes like journal inode on last iput()
2271 * because that could violate lock ordering on umount
2272 */
Aneesh Kumar K.Va1d6cc52008-08-19 21:55:02 -04002273 if (!mapping->nrpages || !mapping_tagged(mapping, PAGECACHE_TAG_DIRTY))
Ming Leibbf023c2013-10-30 07:27:16 -04002274 goto out_writepages;
Theodore Ts'o2a21e372008-11-05 09:22:24 -05002275
Theodore Ts'o20970ba2013-06-06 14:00:46 -04002276 if (ext4_should_journal_data(inode)) {
2277 struct blk_plug plug;
Theodore Ts'o20970ba2013-06-06 14:00:46 -04002278
2279 blk_start_plug(&plug);
2280 ret = write_cache_pages(mapping, wbc, __writepage, mapping);
2281 blk_finish_plug(&plug);
Ming Leibbf023c2013-10-30 07:27:16 -04002282 goto out_writepages;
Theodore Ts'o20970ba2013-06-06 14:00:46 -04002283 }
2284
Theodore Ts'o2a21e372008-11-05 09:22:24 -05002285 /*
2286 * If the filesystem has aborted, it is read-only, so return
2287 * right away instead of dumping stack traces later on that
2288 * will obscure the real source of the problem. We test
Theodore Ts'o4ab2f152009-06-13 10:09:36 -04002289 * EXT4_MF_FS_ABORTED instead of sb->s_flag's MS_RDONLY because
Theodore Ts'o2a21e372008-11-05 09:22:24 -05002290 * the latter could be true if the filesystem is mounted
Theodore Ts'o20970ba2013-06-06 14:00:46 -04002291 * read-only, and in that case, ext4_writepages should
Theodore Ts'o2a21e372008-11-05 09:22:24 -05002292 * *never* be called, so if that ever happens, we would want
2293 * the stack trace.
2294 */
Ming Leibbf023c2013-10-30 07:27:16 -04002295 if (unlikely(sbi->s_mount_flags & EXT4_MF_FS_ABORTED)) {
2296 ret = -EROFS;
2297 goto out_writepages;
2298 }
Theodore Ts'o2a21e372008-11-05 09:22:24 -05002299
Jan Kara6b523df2013-06-04 13:21:11 -04002300 if (ext4_should_dioread_nolock(inode)) {
2301 /*
Anatol Pomozov70261f52013-08-28 14:40:12 -04002302 * We may need to convert up to one extent per block in
Jan Kara6b523df2013-06-04 13:21:11 -04002303 * the page and we may dirty the inode.
2304 */
2305 rsv_blocks = 1 + (PAGE_CACHE_SIZE >> inode->i_blkbits);
2306 }
2307
Jan Kara4e7ea812013-06-04 13:17:40 -04002308 /*
2309 * If we have inline data and arrive here, it means that
2310 * we will soon create the block for the 1st page, so
2311 * we'd better clear the inline data here.
2312 */
2313 if (ext4_has_inline_data(inode)) {
2314 /* Just inode will be modified... */
2315 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
2316 if (IS_ERR(handle)) {
2317 ret = PTR_ERR(handle);
2318 goto out_writepages;
2319 }
2320 BUG_ON(ext4_test_inode_state(inode,
2321 EXT4_STATE_MAY_INLINE_DATA));
2322 ext4_destroy_inline_data(handle, inode);
2323 ext4_journal_stop(handle);
2324 }
2325
Aneesh Kumar K.V22208de2008-10-16 10:10:36 -04002326 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2327 range_whole = 1;
Mingming Cao61628a32008-07-11 19:27:31 -04002328
Aneesh Kumar K.V2acf2c22009-02-14 10:42:58 -05002329 if (wbc->range_cyclic) {
Jan Kara4e7ea812013-06-04 13:17:40 -04002330 writeback_index = mapping->writeback_index;
2331 if (writeback_index)
Aneesh Kumar K.V2acf2c22009-02-14 10:42:58 -05002332 cycled = 0;
Jan Kara4e7ea812013-06-04 13:17:40 -04002333 mpd.first_page = writeback_index;
2334 mpd.last_page = -1;
Eric Sandeen5b41d922010-10-27 21:30:13 -04002335 } else {
Jan Kara4e7ea812013-06-04 13:17:40 -04002336 mpd.first_page = wbc->range_start >> PAGE_CACHE_SHIFT;
2337 mpd.last_page = wbc->range_end >> PAGE_CACHE_SHIFT;
Eric Sandeen5b41d922010-10-27 21:30:13 -04002338 }
Aneesh Kumar K.Va1d6cc52008-08-19 21:55:02 -04002339
Jan Kara4e7ea812013-06-04 13:17:40 -04002340 mpd.inode = inode;
2341 mpd.wbc = wbc;
2342 ext4_io_submit_init(&mpd.io_submit, wbc);
Aneesh Kumar K.V2acf2c22009-02-14 10:42:58 -05002343retry:
Wu Fengguang6e6938b2010-06-06 10:38:15 -06002344 if (wbc->sync_mode == WB_SYNC_ALL || wbc->tagged_writepages)
Jan Kara4e7ea812013-06-04 13:17:40 -04002345 tag_pages_for_writeback(mapping, mpd.first_page, mpd.last_page);
2346 done = false;
Shaohua Li1bce63d2011-10-18 10:55:51 -04002347 blk_start_plug(&plug);
Jan Kara4e7ea812013-06-04 13:17:40 -04002348 while (!done && mpd.first_page <= mpd.last_page) {
2349 /* For each extent of pages we use new io_end */
2350 mpd.io_submit.io_end = ext4_init_io_end(inode, GFP_KERNEL);
2351 if (!mpd.io_submit.io_end) {
2352 ret = -ENOMEM;
2353 break;
2354 }
Aneesh Kumar K.Va1d6cc52008-08-19 21:55:02 -04002355
2356 /*
Jan Kara4e7ea812013-06-04 13:17:40 -04002357 * We have two constraints: We find one extent to map and we
2358 * must always write out whole page (makes a difference when
2359 * blocksize < pagesize) so that we don't block on IO when we
2360 * try to write out the rest of the page. Journalled mode is
2361 * not supported by delalloc.
Aneesh Kumar K.Va1d6cc52008-08-19 21:55:02 -04002362 */
2363 BUG_ON(ext4_should_journal_data(inode));
Mingming Cao525f4ed2008-08-19 22:15:58 -04002364 needed_blocks = ext4_da_writepages_trans_blocks(inode);
Aneesh Kumar K.Va1d6cc52008-08-19 21:55:02 -04002365
Jan Kara4e7ea812013-06-04 13:17:40 -04002366 /* start a new transaction */
Jan Kara6b523df2013-06-04 13:21:11 -04002367 handle = ext4_journal_start_with_reserve(inode,
2368 EXT4_HT_WRITE_PAGE, needed_blocks, rsv_blocks);
Mingming Cao61628a32008-07-11 19:27:31 -04002369 if (IS_ERR(handle)) {
2370 ret = PTR_ERR(handle);
Theodore Ts'o16939182009-09-26 17:43:59 -04002371 ext4_msg(inode->i_sb, KERN_CRIT, "%s: jbd2_start: "
Curt Wohlgemuthfbe845d2010-05-16 13:00:00 -04002372 "%ld pages, ino %lu; err %d", __func__,
Aneesh Kumar K.Va1d6cc52008-08-19 21:55:02 -04002373 wbc->nr_to_write, inode->i_ino, ret);
Jan Kara4e7ea812013-06-04 13:17:40 -04002374 /* Release allocated io_end */
2375 ext4_put_io_end(mpd.io_submit.io_end);
2376 break;
Mingming Cao61628a32008-07-11 19:27:31 -04002377 }
Theodore Ts'of63e6002009-02-23 16:42:39 -05002378
Jan Kara4e7ea812013-06-04 13:17:40 -04002379 trace_ext4_da_write_pages(inode, mpd.first_page, mpd.wbc);
2380 ret = mpage_prepare_extent_to_map(&mpd);
2381 if (!ret) {
2382 if (mpd.map.m_len)
Theodore Ts'ocb530542013-07-01 08:12:40 -04002383 ret = mpage_map_and_submit_extent(handle, &mpd,
2384 &give_up_on_write);
Jan Kara4e7ea812013-06-04 13:17:40 -04002385 else {
2386 /*
2387 * We scanned the whole range (or exhausted
2388 * nr_to_write), submitted what was mapped and
2389 * didn't find anything needing mapping. We are
2390 * done.
2391 */
2392 done = true;
2393 }
Theodore Ts'of63e6002009-02-23 16:42:39 -05002394 }
Mingming Cao61628a32008-07-11 19:27:31 -04002395 ext4_journal_stop(handle);
Jan Kara4e7ea812013-06-04 13:17:40 -04002396 /* Submit prepared bio */
2397 ext4_io_submit(&mpd.io_submit);
2398 /* Unlock pages we didn't use */
Theodore Ts'ocb530542013-07-01 08:12:40 -04002399 mpage_release_unused_pages(&mpd, give_up_on_write);
Jan Kara4e7ea812013-06-04 13:17:40 -04002400 /* Drop our io_end reference we got from init */
2401 ext4_put_io_end(mpd.io_submit.io_end);
Aneesh Kumar K.Vdf222912008-09-08 23:05:34 -04002402
Jan Kara4e7ea812013-06-04 13:17:40 -04002403 if (ret == -ENOSPC && sbi->s_journal) {
2404 /*
2405 * Commit the transaction which would
Aneesh Kumar K.V22208de2008-10-16 10:10:36 -04002406 * free blocks released in the transaction
2407 * and try again
2408 */
Aneesh Kumar K.Vdf222912008-09-08 23:05:34 -04002409 jbd2_journal_force_commit_nested(sbi->s_journal);
Aneesh Kumar K.V22208de2008-10-16 10:10:36 -04002410 ret = 0;
Jan Kara4e7ea812013-06-04 13:17:40 -04002411 continue;
2412 }
2413 /* Fatal error - ENOMEM, EIO... */
2414 if (ret)
Mingming Cao61628a32008-07-11 19:27:31 -04002415 break;
Mingming Cao61628a32008-07-11 19:27:31 -04002416 }
Shaohua Li1bce63d2011-10-18 10:55:51 -04002417 blk_finish_plug(&plug);
Jan Kara9c12a832013-09-16 08:24:26 -04002418 if (!ret && !cycled && wbc->nr_to_write > 0) {
Aneesh Kumar K.V2acf2c22009-02-14 10:42:58 -05002419 cycled = 1;
Jan Kara4e7ea812013-06-04 13:17:40 -04002420 mpd.last_page = writeback_index - 1;
2421 mpd.first_page = 0;
Aneesh Kumar K.V2acf2c22009-02-14 10:42:58 -05002422 goto retry;
2423 }
Mingming Cao61628a32008-07-11 19:27:31 -04002424
Aneesh Kumar K.V22208de2008-10-16 10:10:36 -04002425 /* Update index */
Aneesh Kumar K.V22208de2008-10-16 10:10:36 -04002426 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2427 /*
Jan Kara4e7ea812013-06-04 13:17:40 -04002428 * Set the writeback_index so that range_cyclic
Aneesh Kumar K.V22208de2008-10-16 10:10:36 -04002429 * mode will write it back later
2430 */
Jan Kara4e7ea812013-06-04 13:17:40 -04002431 mapping->writeback_index = mpd.first_page;
Aneesh Kumar K.Va1d6cc52008-08-19 21:55:02 -04002432
Mingming Cao61628a32008-07-11 19:27:31 -04002433out_writepages:
Theodore Ts'o20970ba2013-06-06 14:00:46 -04002434 trace_ext4_writepages_result(inode, wbc, ret,
2435 nr_to_write - wbc->nr_to_write);
Mingming Cao61628a32008-07-11 19:27:31 -04002436 return ret;
Alex Tomas64769242008-07-11 19:27:31 -04002437}
2438
Aneesh Kumar K.V79f0be82008-10-08 23:13:30 -04002439static int ext4_nonda_switch(struct super_block *sb)
2440{
Eric Whitney5c1ff332013-04-09 09:27:31 -04002441 s64 free_clusters, dirty_clusters;
Aneesh Kumar K.V79f0be82008-10-08 23:13:30 -04002442 struct ext4_sb_info *sbi = EXT4_SB(sb);
2443
2444 /*
2445 * switch to non delalloc mode if we are running low
2446 * on free block. The free block accounting via percpu
Eric Dumazet179f7eb2009-01-06 14:41:04 -08002447 * counters can get slightly wrong with percpu_counter_batch getting
Aneesh Kumar K.V79f0be82008-10-08 23:13:30 -04002448 * accumulated on each CPU without updating global counters
2449 * Delalloc need an accurate free block accounting. So switch
2450 * to non delalloc when we are near to error range.
2451 */
Eric Whitney5c1ff332013-04-09 09:27:31 -04002452 free_clusters =
2453 percpu_counter_read_positive(&sbi->s_freeclusters_counter);
2454 dirty_clusters =
2455 percpu_counter_read_positive(&sbi->s_dirtyclusters_counter);
Theodore Ts'o00d4e732012-09-19 22:42:36 -04002456 /*
2457 * Start pushing delalloc when 1/2 of free blocks are dirty.
2458 */
Eric Whitney5c1ff332013-04-09 09:27:31 -04002459 if (dirty_clusters && (free_clusters < 2 * dirty_clusters))
Miao Xie10ee27a2013-01-10 13:47:57 +08002460 try_to_writeback_inodes_sb(sb, WB_REASON_FS_FREE_SPACE);
Theodore Ts'o00d4e732012-09-19 22:42:36 -04002461
Eric Whitney5c1ff332013-04-09 09:27:31 -04002462 if (2 * free_clusters < 3 * dirty_clusters ||
2463 free_clusters < (dirty_clusters + EXT4_FREECLUSTERS_WATERMARK)) {
Aneesh Kumar K.V79f0be82008-10-08 23:13:30 -04002464 /*
Eric Sandeenc8afb442009-12-23 07:58:12 -05002465 * free block count is less than 150% of dirty blocks
2466 * or free blocks is less than watermark
Aneesh Kumar K.V79f0be82008-10-08 23:13:30 -04002467 */
2468 return 1;
2469 }
2470 return 0;
2471}
2472
Eric Sandeen0ff89472014-10-11 19:51:17 -04002473/* We always reserve for an inode update; the superblock could be there too */
2474static int ext4_da_write_credits(struct inode *inode, loff_t pos, unsigned len)
2475{
2476 if (likely(EXT4_HAS_RO_COMPAT_FEATURE(inode->i_sb,
2477 EXT4_FEATURE_RO_COMPAT_LARGE_FILE)))
2478 return 1;
2479
2480 if (pos + len <= 0x7fffffffULL)
2481 return 1;
2482
2483 /* We might need to update the superblock to set LARGE_FILE */
2484 return 2;
2485}
2486
Alex Tomas64769242008-07-11 19:27:31 -04002487static int ext4_da_write_begin(struct file *file, struct address_space *mapping,
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04002488 loff_t pos, unsigned len, unsigned flags,
2489 struct page **pagep, void **fsdata)
Alex Tomas64769242008-07-11 19:27:31 -04002490{
Eric Sandeen72b8ab92010-05-16 11:00:00 -04002491 int ret, retries = 0;
Alex Tomas64769242008-07-11 19:27:31 -04002492 struct page *page;
2493 pgoff_t index;
Alex Tomas64769242008-07-11 19:27:31 -04002494 struct inode *inode = mapping->host;
2495 handle_t *handle;
2496
2497 index = pos >> PAGE_CACHE_SHIFT;
Aneesh Kumar K.V79f0be82008-10-08 23:13:30 -04002498
2499 if (ext4_nonda_switch(inode->i_sb)) {
2500 *fsdata = (void *)FALL_BACK_TO_NONDELALLOC;
2501 return ext4_write_begin(file, mapping, pos,
2502 len, flags, pagep, fsdata);
2503 }
2504 *fsdata = (void *)0;
Theodore Ts'o9bffad12009-06-17 11:48:11 -04002505 trace_ext4_da_write_begin(inode, pos, len, flags);
Tao Ma9c3569b2012-12-10 14:05:57 -05002506
2507 if (ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA)) {
2508 ret = ext4_da_write_inline_data_begin(mapping, inode,
2509 pos, len, flags,
2510 pagep, fsdata);
2511 if (ret < 0)
Theodore Ts'o47564bf2013-02-09 09:24:14 -05002512 return ret;
2513 if (ret == 1)
2514 return 0;
Tao Ma9c3569b2012-12-10 14:05:57 -05002515 }
2516
Theodore Ts'o47564bf2013-02-09 09:24:14 -05002517 /*
2518 * grab_cache_page_write_begin() can take a long time if the
2519 * system is thrashing due to memory pressure, or if the page
2520 * is being written back. So grab it first before we start
2521 * the transaction handle. This also allows us to allocate
2522 * the page (if needed) without using GFP_NOFS.
2523 */
2524retry_grab:
2525 page = grab_cache_page_write_begin(mapping, index, flags);
2526 if (!page)
2527 return -ENOMEM;
2528 unlock_page(page);
2529
Alex Tomas64769242008-07-11 19:27:31 -04002530 /*
2531 * With delayed allocation, we don't log the i_disksize update
2532 * if there is delayed block allocation. But we still need
2533 * to journalling the i_disksize update if writes to the end
2534 * of file which has an already mapped buffer.
2535 */
Theodore Ts'o47564bf2013-02-09 09:24:14 -05002536retry_journal:
Eric Sandeen0ff89472014-10-11 19:51:17 -04002537 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
2538 ext4_da_write_credits(inode, pos, len));
Alex Tomas64769242008-07-11 19:27:31 -04002539 if (IS_ERR(handle)) {
Theodore Ts'o47564bf2013-02-09 09:24:14 -05002540 page_cache_release(page);
2541 return PTR_ERR(handle);
Alex Tomas64769242008-07-11 19:27:31 -04002542 }
2543
Theodore Ts'o47564bf2013-02-09 09:24:14 -05002544 lock_page(page);
2545 if (page->mapping != mapping) {
2546 /* The page got truncated from under us */
2547 unlock_page(page);
2548 page_cache_release(page);
Eric Sandeend5a0d4f2008-08-02 18:51:06 -04002549 ext4_journal_stop(handle);
Theodore Ts'o47564bf2013-02-09 09:24:14 -05002550 goto retry_grab;
Eric Sandeend5a0d4f2008-08-02 18:51:06 -04002551 }
Theodore Ts'o47564bf2013-02-09 09:24:14 -05002552 /* In case writeback began while the page was unlocked */
Dmitry Monakhov7afe5aa2013-08-28 14:30:47 -04002553 wait_for_stable_page(page);
Alex Tomas64769242008-07-11 19:27:31 -04002554
Christoph Hellwig6e1db882010-06-04 11:29:57 +02002555 ret = __block_write_begin(page, pos, len, ext4_da_get_block_prep);
Alex Tomas64769242008-07-11 19:27:31 -04002556 if (ret < 0) {
2557 unlock_page(page);
2558 ext4_journal_stop(handle);
Aneesh Kumar K.Vae4d5372008-09-13 13:10:25 -04002559 /*
2560 * block_write_begin may have instantiated a few blocks
2561 * outside i_size. Trim these off again. Don't need
2562 * i_size_read because we hold i_mutex.
2563 */
2564 if (pos + len > inode->i_size)
Jan Karab9a42072009-12-08 21:24:33 -05002565 ext4_truncate_failed_write(inode);
Theodore Ts'o47564bf2013-02-09 09:24:14 -05002566
2567 if (ret == -ENOSPC &&
2568 ext4_should_retry_alloc(inode->i_sb, &retries))
2569 goto retry_journal;
2570
2571 page_cache_release(page);
2572 return ret;
Alex Tomas64769242008-07-11 19:27:31 -04002573 }
2574
Theodore Ts'o47564bf2013-02-09 09:24:14 -05002575 *pagep = page;
Alex Tomas64769242008-07-11 19:27:31 -04002576 return ret;
2577}
2578
Mingming Cao632eaea2008-07-11 19:27:31 -04002579/*
2580 * Check if we should update i_disksize
2581 * when write to the end of file but not require block allocation
2582 */
2583static int ext4_da_should_update_i_disksize(struct page *page,
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04002584 unsigned long offset)
Mingming Cao632eaea2008-07-11 19:27:31 -04002585{
2586 struct buffer_head *bh;
2587 struct inode *inode = page->mapping->host;
2588 unsigned int idx;
2589 int i;
2590
2591 bh = page_buffers(page);
2592 idx = offset >> inode->i_blkbits;
2593
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002594 for (i = 0; i < idx; i++)
Mingming Cao632eaea2008-07-11 19:27:31 -04002595 bh = bh->b_this_page;
2596
Aneesh Kumar K.V29fa89d2009-05-12 16:30:27 -04002597 if (!buffer_mapped(bh) || (buffer_delay(bh)) || buffer_unwritten(bh))
Mingming Cao632eaea2008-07-11 19:27:31 -04002598 return 0;
2599 return 1;
2600}
2601
Alex Tomas64769242008-07-11 19:27:31 -04002602static int ext4_da_write_end(struct file *file,
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04002603 struct address_space *mapping,
2604 loff_t pos, unsigned len, unsigned copied,
2605 struct page *page, void *fsdata)
Alex Tomas64769242008-07-11 19:27:31 -04002606{
2607 struct inode *inode = mapping->host;
2608 int ret = 0, ret2;
2609 handle_t *handle = ext4_journal_current_handle();
2610 loff_t new_i_size;
Mingming Cao632eaea2008-07-11 19:27:31 -04002611 unsigned long start, end;
Aneesh Kumar K.V79f0be82008-10-08 23:13:30 -04002612 int write_mode = (int)(unsigned long)fsdata;
2613
Theodore Ts'o74d553a2013-04-03 12:39:17 -04002614 if (write_mode == FALL_BACK_TO_NONDELALLOC)
2615 return ext4_write_end(file, mapping, pos,
2616 len, copied, page, fsdata);
Mingming Cao632eaea2008-07-11 19:27:31 -04002617
Theodore Ts'o9bffad12009-06-17 11:48:11 -04002618 trace_ext4_da_write_end(inode, pos, len, copied);
Mingming Cao632eaea2008-07-11 19:27:31 -04002619 start = pos & (PAGE_CACHE_SIZE - 1);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002620 end = start + copied - 1;
Alex Tomas64769242008-07-11 19:27:31 -04002621
2622 /*
2623 * generic_write_end() will run mark_inode_dirty() if i_size
2624 * changes. So let's piggyback the i_disksize mark_inode_dirty
2625 * into that.
2626 */
Alex Tomas64769242008-07-11 19:27:31 -04002627 new_i_size = pos + copied;
Andrea Arcangeliea51d132011-12-13 21:41:15 -05002628 if (copied && new_i_size > EXT4_I(inode)->i_disksize) {
Tao Ma9c3569b2012-12-10 14:05:57 -05002629 if (ext4_has_inline_data(inode) ||
2630 ext4_da_should_update_i_disksize(page, end)) {
Dmitry Monakhovee124d22014-08-30 23:34:06 -04002631 ext4_update_i_disksize(inode, new_i_size);
Aneesh Kumar K.Vcf17fea2008-09-13 13:06:18 -04002632 /* We need to mark inode dirty even if
2633 * new_i_size is less that inode->i_size
2634 * bu greater than i_disksize.(hint delalloc)
2635 */
2636 ext4_mark_inode_dirty(handle, inode);
Alex Tomas64769242008-07-11 19:27:31 -04002637 }
Mingming Cao632eaea2008-07-11 19:27:31 -04002638 }
Tao Ma9c3569b2012-12-10 14:05:57 -05002639
2640 if (write_mode != CONVERT_INLINE_DATA &&
2641 ext4_test_inode_state(inode, EXT4_STATE_MAY_INLINE_DATA) &&
2642 ext4_has_inline_data(inode))
2643 ret2 = ext4_da_write_inline_data_end(inode, pos, len, copied,
2644 page);
2645 else
2646 ret2 = generic_write_end(file, mapping, pos, len, copied,
Alex Tomas64769242008-07-11 19:27:31 -04002647 page, fsdata);
Tao Ma9c3569b2012-12-10 14:05:57 -05002648
Alex Tomas64769242008-07-11 19:27:31 -04002649 copied = ret2;
2650 if (ret2 < 0)
2651 ret = ret2;
2652 ret2 = ext4_journal_stop(handle);
2653 if (!ret)
2654 ret = ret2;
2655
2656 return ret ? ret : copied;
2657}
2658
Lukas Czernerd47992f2013-05-21 23:17:23 -04002659static void ext4_da_invalidatepage(struct page *page, unsigned int offset,
2660 unsigned int length)
Alex Tomas64769242008-07-11 19:27:31 -04002661{
Alex Tomas64769242008-07-11 19:27:31 -04002662 /*
2663 * Drop reserved blocks
2664 */
2665 BUG_ON(!PageLocked(page));
2666 if (!page_has_buffers(page))
2667 goto out;
2668
Lukas Czernerca99fdd2013-05-21 23:25:01 -04002669 ext4_da_page_release_reservation(page, offset, length);
Alex Tomas64769242008-07-11 19:27:31 -04002670
2671out:
Lukas Czernerd47992f2013-05-21 23:17:23 -04002672 ext4_invalidatepage(page, offset, length);
Alex Tomas64769242008-07-11 19:27:31 -04002673
2674 return;
2675}
2676
Theodore Ts'occd25062009-02-26 01:04:07 -05002677/*
2678 * Force all delayed allocation blocks to be allocated for a given inode.
2679 */
2680int ext4_alloc_da_blocks(struct inode *inode)
2681{
Theodore Ts'ofb40ba02009-09-16 19:30:40 -04002682 trace_ext4_alloc_da_blocks(inode);
2683
Theodore Ts'o71d4f7d2014-07-15 06:02:38 -04002684 if (!EXT4_I(inode)->i_reserved_data_blocks)
Theodore Ts'occd25062009-02-26 01:04:07 -05002685 return 0;
2686
2687 /*
2688 * We do something simple for now. The filemap_flush() will
2689 * also start triggering a write of the data blocks, which is
2690 * not strictly speaking necessary (and for users of
2691 * laptop_mode, not even desirable). However, to do otherwise
2692 * would require replicating code paths in:
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04002693 *
Theodore Ts'o20970ba2013-06-06 14:00:46 -04002694 * ext4_writepages() ->
Theodore Ts'occd25062009-02-26 01:04:07 -05002695 * write_cache_pages() ---> (via passed in callback function)
2696 * __mpage_da_writepage() -->
2697 * mpage_add_bh_to_extent()
2698 * mpage_da_map_blocks()
2699 *
2700 * The problem is that write_cache_pages(), located in
2701 * mm/page-writeback.c, marks pages clean in preparation for
2702 * doing I/O, which is not desirable if we're not planning on
2703 * doing I/O at all.
2704 *
2705 * We could call write_cache_pages(), and then redirty all of
Wu Fengguang380cf092010-11-11 19:23:29 +08002706 * the pages by calling redirty_page_for_writepage() but that
Theodore Ts'occd25062009-02-26 01:04:07 -05002707 * would be ugly in the extreme. So instead we would need to
2708 * replicate parts of the code in the above functions,
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002709 * simplifying them because we wouldn't actually intend to
Theodore Ts'occd25062009-02-26 01:04:07 -05002710 * write out the pages, but rather only collect contiguous
2711 * logical block extents, call the multi-block allocator, and
2712 * then update the buffer heads with the block allocations.
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04002713 *
Theodore Ts'occd25062009-02-26 01:04:07 -05002714 * For now, though, we'll cheat by calling filemap_flush(),
2715 * which will map the blocks, and start the I/O, but not
2716 * actually wait for the I/O to complete.
2717 */
2718 return filemap_flush(inode->i_mapping);
2719}
Alex Tomas64769242008-07-11 19:27:31 -04002720
2721/*
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002722 * bmap() is special. It gets used by applications such as lilo and by
2723 * the swapper to find the on-disk block of a specific piece of data.
2724 *
2725 * Naturally, this is dangerous if the block concerned is still in the
Mingming Cao617ba132006-10-11 01:20:53 -07002726 * journal. If somebody makes a swapfile on an ext4 data-journaling
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002727 * filesystem and enables swap, then they may get a nasty shock when the
2728 * data getting swapped to that swapfile suddenly gets overwritten by
2729 * the original zero's written out previously to the journal and
2730 * awaiting writeback in the kernel's buffer cache.
2731 *
2732 * So, if we see any bmap calls here on a modified, data-journaled file,
2733 * take extra steps to flush any blocks which might be in the cache.
2734 */
Mingming Cao617ba132006-10-11 01:20:53 -07002735static sector_t ext4_bmap(struct address_space *mapping, sector_t block)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002736{
2737 struct inode *inode = mapping->host;
2738 journal_t *journal;
2739 int err;
2740
Tao Ma46c7f252012-12-10 14:04:52 -05002741 /*
2742 * We can get here for an inline file via the FIBMAP ioctl
2743 */
2744 if (ext4_has_inline_data(inode))
2745 return 0;
2746
Alex Tomas64769242008-07-11 19:27:31 -04002747 if (mapping_tagged(mapping, PAGECACHE_TAG_DIRTY) &&
2748 test_opt(inode->i_sb, DELALLOC)) {
2749 /*
2750 * With delalloc we want to sync the file
2751 * so that we can make sure we allocate
2752 * blocks for file
2753 */
2754 filemap_write_and_wait(mapping);
2755 }
2756
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05002757 if (EXT4_JOURNAL(inode) &&
2758 ext4_test_inode_state(inode, EXT4_STATE_JDATA)) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002759 /*
2760 * This is a REALLY heavyweight approach, but the use of
2761 * bmap on dirty files is expected to be extremely rare:
2762 * only if we run lilo or swapon on a freshly made file
2763 * do we expect this to happen.
2764 *
2765 * (bmap requires CAP_SYS_RAWIO so this does not
2766 * represent an unprivileged user DOS attack --- we'd be
2767 * in trouble if mortal users could trigger this path at
2768 * will.)
2769 *
Mingming Cao617ba132006-10-11 01:20:53 -07002770 * NB. EXT4_STATE_JDATA is not set on files other than
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002771 * regular files. If somebody wants to bmap a directory
2772 * or symlink and gets confused because the buffer
2773 * hasn't yet been flushed to disk, they deserve
2774 * everything they get.
2775 */
2776
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05002777 ext4_clear_inode_state(inode, EXT4_STATE_JDATA);
Mingming Cao617ba132006-10-11 01:20:53 -07002778 journal = EXT4_JOURNAL(inode);
Mingming Caodab291a2006-10-11 01:21:01 -07002779 jbd2_journal_lock_updates(journal);
2780 err = jbd2_journal_flush(journal);
2781 jbd2_journal_unlock_updates(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002782
2783 if (err)
2784 return 0;
2785 }
2786
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04002787 return generic_block_bmap(mapping, block, ext4_get_block);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002788}
2789
Mingming Cao617ba132006-10-11 01:20:53 -07002790static int ext4_readpage(struct file *file, struct page *page)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002791{
Tao Ma46c7f252012-12-10 14:04:52 -05002792 int ret = -EAGAIN;
2793 struct inode *inode = page->mapping->host;
2794
Jiaying Zhang0562e0b2011-03-21 21:38:05 -04002795 trace_ext4_readpage(page);
Tao Ma46c7f252012-12-10 14:04:52 -05002796
2797 if (ext4_has_inline_data(inode))
2798 ret = ext4_readpage_inline(inode, page);
2799
2800 if (ret == -EAGAIN)
2801 return mpage_readpage(page, ext4_get_block);
2802
2803 return ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002804}
2805
2806static int
Mingming Cao617ba132006-10-11 01:20:53 -07002807ext4_readpages(struct file *file, struct address_space *mapping,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002808 struct list_head *pages, unsigned nr_pages)
2809{
Tao Ma46c7f252012-12-10 14:04:52 -05002810 struct inode *inode = mapping->host;
2811
2812 /* If the file has inline data, no need to do readpages. */
2813 if (ext4_has_inline_data(inode))
2814 return 0;
2815
Mingming Cao617ba132006-10-11 01:20:53 -07002816 return mpage_readpages(mapping, pages, nr_pages, ext4_get_block);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002817}
2818
Lukas Czernerd47992f2013-05-21 23:17:23 -04002819static void ext4_invalidatepage(struct page *page, unsigned int offset,
2820 unsigned int length)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002821{
Lukas Czernerca99fdd2013-05-21 23:25:01 -04002822 trace_ext4_invalidatepage(page, offset, length);
Jiaying Zhang0562e0b2011-03-21 21:38:05 -04002823
Jan Kara4520fb32012-12-25 13:28:54 -05002824 /* No journalling happens on data buffers when this function is used */
2825 WARN_ON(page_has_buffers(page) && buffer_jbd(page_buffers(page)));
2826
Lukas Czernerca99fdd2013-05-21 23:25:01 -04002827 block_invalidatepage(page, offset, length);
Jan Kara4520fb32012-12-25 13:28:54 -05002828}
2829
Jan Kara53e87262012-12-25 13:29:52 -05002830static int __ext4_journalled_invalidatepage(struct page *page,
Lukas Czernerca99fdd2013-05-21 23:25:01 -04002831 unsigned int offset,
2832 unsigned int length)
Jan Kara4520fb32012-12-25 13:28:54 -05002833{
2834 journal_t *journal = EXT4_JOURNAL(page->mapping->host);
2835
Lukas Czernerca99fdd2013-05-21 23:25:01 -04002836 trace_ext4_journalled_invalidatepage(page, offset, length);
Jan Kara4520fb32012-12-25 13:28:54 -05002837
Jiaying Zhang744692d2010-03-04 16:14:02 -05002838 /*
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002839 * If it's a full truncate we just forget about the pending dirtying
2840 */
Lukas Czernerca99fdd2013-05-21 23:25:01 -04002841 if (offset == 0 && length == PAGE_CACHE_SIZE)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002842 ClearPageChecked(page);
2843
Lukas Czernerca99fdd2013-05-21 23:25:01 -04002844 return jbd2_journal_invalidatepage(journal, page, offset, length);
Jan Kara53e87262012-12-25 13:29:52 -05002845}
2846
2847/* Wrapper for aops... */
2848static void ext4_journalled_invalidatepage(struct page *page,
Lukas Czernerd47992f2013-05-21 23:17:23 -04002849 unsigned int offset,
2850 unsigned int length)
Jan Kara53e87262012-12-25 13:29:52 -05002851{
Lukas Czernerca99fdd2013-05-21 23:25:01 -04002852 WARN_ON(__ext4_journalled_invalidatepage(page, offset, length) < 0);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002853}
2854
Mingming Cao617ba132006-10-11 01:20:53 -07002855static int ext4_releasepage(struct page *page, gfp_t wait)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002856{
Mingming Cao617ba132006-10-11 01:20:53 -07002857 journal_t *journal = EXT4_JOURNAL(page->mapping->host);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002858
Jiaying Zhang0562e0b2011-03-21 21:38:05 -04002859 trace_ext4_releasepage(page);
2860
Jan Karae1c36592013-03-10 22:19:00 -04002861 /* Page has dirty journalled data -> cannot release */
2862 if (PageChecked(page))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002863 return 0;
Frank Mayhar03901312009-01-07 00:06:22 -05002864 if (journal)
2865 return jbd2_journal_try_to_free_buffers(journal, page, wait);
2866 else
2867 return try_to_free_buffers(page);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07002868}
2869
2870/*
Theodore Ts'o2ed88682010-05-16 20:00:00 -04002871 * ext4_get_block used when preparing for a DIO write or buffer write.
2872 * We allocate an uinitialized extent if blocks haven't been allocated.
2873 * The extent will be converted to initialized after the IO is complete.
2874 */
Tao Maf19d5872012-12-10 14:05:51 -05002875int ext4_get_block_write(struct inode *inode, sector_t iblock,
Mingming Cao4c0425f2009-09-28 15:48:41 -04002876 struct buffer_head *bh_result, int create)
2877{
Jiaying Zhangc7064ef2010-03-02 13:28:44 -05002878 ext4_debug("ext4_get_block_write: inode %lu, create flag %d\n",
Mingming Cao8d5d02e2009-09-28 15:48:29 -04002879 inode->i_ino, create);
Theodore Ts'o2ed88682010-05-16 20:00:00 -04002880 return _ext4_get_block(inode, iblock, bh_result,
2881 EXT4_GET_BLOCKS_IO_CREATE_EXT);
Mingming Cao4c0425f2009-09-28 15:48:41 -04002882}
2883
Zheng Liu729f52c2012-07-09 16:29:29 -04002884static int ext4_get_block_write_nolock(struct inode *inode, sector_t iblock,
Anatol Pomozov8b0f1652012-11-08 15:07:16 -05002885 struct buffer_head *bh_result, int create)
Zheng Liu729f52c2012-07-09 16:29:29 -04002886{
Anatol Pomozov8b0f1652012-11-08 15:07:16 -05002887 ext4_debug("ext4_get_block_write_nolock: inode %lu, create flag %d\n",
2888 inode->i_ino, create);
2889 return _ext4_get_block(inode, iblock, bh_result,
2890 EXT4_GET_BLOCKS_NO_LOCK);
Zheng Liu729f52c2012-07-09 16:29:29 -04002891}
2892
Mingming Cao4c0425f2009-09-28 15:48:41 -04002893static void ext4_end_io_dio(struct kiocb *iocb, loff_t offset,
Christoph Hellwig7b7a8662013-09-04 15:04:39 +02002894 ssize_t size, void *private)
Mingming Cao4c0425f2009-09-28 15:48:41 -04002895{
2896 ext4_io_end_t *io_end = iocb->private;
Mingming Cao4c0425f2009-09-28 15:48:41 -04002897
Jan Kara97a851e2013-06-04 11:58:58 -04002898 /* if not async direct IO just return */
Christoph Hellwig7b7a8662013-09-04 15:04:39 +02002899 if (!io_end)
Jan Kara97a851e2013-06-04 11:58:58 -04002900 return;
Mingming4b70df12009-11-03 14:44:54 -05002901
Zheng Liu88635ca2011-12-28 19:00:25 -05002902 ext_debug("ext4_end_io_dio(): io_end 0x%p "
Joe Perchesace36ad2012-03-19 23:11:43 -04002903 "for inode %lu, iocb 0x%p, offset %llu, size %zd\n",
Mingming Cao8d5d02e2009-09-28 15:48:29 -04002904 iocb->private, io_end->inode->i_ino, iocb, offset,
2905 size);
Mingming Cao8d5d02e2009-09-28 15:48:29 -04002906
Theodore Ts'ob5a7e972011-12-12 10:53:02 -05002907 iocb->private = NULL;
Mingming Cao4c0425f2009-09-28 15:48:41 -04002908 io_end->offset = offset;
2909 io_end->size = size;
Christoph Hellwig7b7a8662013-09-04 15:04:39 +02002910 ext4_put_io_end(io_end);
Mingming Cao4c0425f2009-09-28 15:48:41 -04002911}
Jiaying Zhangc7064ef2010-03-02 13:28:44 -05002912
Mingming Cao4c0425f2009-09-28 15:48:41 -04002913/*
2914 * For ext4 extent files, ext4 will do direct-io write to holes,
2915 * preallocated extents, and those write extend the file, no need to
2916 * fall back to buffered IO.
2917 *
Lukas Czerner556615d2014-04-20 23:45:47 -04002918 * For holes, we fallocate those blocks, mark them as unwritten
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002919 * If those blocks were preallocated, we mark sure they are split, but
Lukas Czerner556615d2014-04-20 23:45:47 -04002920 * still keep the range to write as unwritten.
Mingming Cao4c0425f2009-09-28 15:48:41 -04002921 *
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002922 * The unwritten extents will be converted to written when DIO is completed.
Mingming Cao8d5d02e2009-09-28 15:48:29 -04002923 * For async direct IO, since the IO may still pending when return, we
Lucas De Marchi25985ed2011-03-30 22:57:33 -03002924 * set up an end_io call back function, which will do the conversion
Mingming Cao8d5d02e2009-09-28 15:48:29 -04002925 * when async direct IO completed.
Mingming Cao4c0425f2009-09-28 15:48:41 -04002926 *
2927 * If the O_DIRECT write will extend the file then add this inode to the
2928 * orphan list. So recovery will truncate it back to the original size
2929 * if the machine crashes during the write.
2930 *
2931 */
2932static ssize_t ext4_ext_direct_IO(int rw, struct kiocb *iocb,
Al Viro16b1f052014-03-04 22:14:00 -05002933 struct iov_iter *iter, loff_t offset)
Mingming Cao4c0425f2009-09-28 15:48:41 -04002934{
2935 struct file *file = iocb->ki_filp;
2936 struct inode *inode = file->f_mapping->host;
2937 ssize_t ret;
Al Viroa6cbcd42014-03-04 22:38:00 -05002938 size_t count = iov_iter_count(iter);
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002939 int overwrite = 0;
2940 get_block_t *get_block_func = NULL;
2941 int dio_flags = 0;
Mingming Cao4c0425f2009-09-28 15:48:41 -04002942 loff_t final_size = offset + count;
Jan Kara97a851e2013-06-04 11:58:58 -04002943 ext4_io_end_t *io_end = NULL;
Zheng Liu729f52c2012-07-09 16:29:29 -04002944
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002945 /* Use the old path for reads and writes beyond i_size. */
2946 if (rw != WRITE || final_size > inode->i_size)
Al Viro16b1f052014-03-04 22:14:00 -05002947 return ext4_ind_direct_IO(rw, iocb, iter, offset);
Zheng Liu4bd809d2012-07-22 20:19:31 -04002948
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002949 BUG_ON(iocb->private == NULL);
Zheng Liu4bd809d2012-07-22 20:19:31 -04002950
Jan Karae8340392013-06-04 14:27:38 -04002951 /*
2952 * Make all waiters for direct IO properly wait also for extent
2953 * conversion. This also disallows race between truncate() and
2954 * overwrite DIO as i_dio_count needs to be incremented under i_mutex.
2955 */
2956 if (rw == WRITE)
2957 atomic_inc(&inode->i_dio_count);
2958
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002959 /* If we do a overwrite dio, i_mutex locking can be released */
2960 overwrite = *((int *)iocb->private);
Zheng Liu4bd809d2012-07-22 20:19:31 -04002961
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002962 if (overwrite) {
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002963 down_read(&EXT4_I(inode)->i_data_sem);
2964 mutex_unlock(&inode->i_mutex);
Mingming Cao4c0425f2009-09-28 15:48:41 -04002965 }
Mingming Cao8d5d02e2009-09-28 15:48:29 -04002966
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002967 /*
2968 * We could direct write to holes and fallocate.
2969 *
2970 * Allocated blocks to fill the hole are marked as
Lukas Czerner556615d2014-04-20 23:45:47 -04002971 * unwritten to prevent parallel buffered read to expose
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002972 * the stale data before DIO complete the data IO.
2973 *
2974 * As to previously fallocated extents, ext4 get_block will
2975 * just simply mark the buffer mapped but still keep the
Lukas Czerner556615d2014-04-20 23:45:47 -04002976 * extents unwritten.
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002977 *
2978 * For non AIO case, we will convert those unwritten extents
2979 * to written after return back from blockdev_direct_IO.
2980 *
2981 * For async DIO, the conversion needs to be deferred when the
2982 * IO is completed. The ext4 end_io callback function will be
2983 * called to take care of the conversion work. Here for async
2984 * case, we allocate an io_end structure to hook to the iocb.
2985 */
2986 iocb->private = NULL;
2987 ext4_inode_aio_set(inode, NULL);
2988 if (!is_sync_kiocb(iocb)) {
Jan Kara97a851e2013-06-04 11:58:58 -04002989 io_end = ext4_init_io_end(inode, GFP_NOFS);
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002990 if (!io_end) {
2991 ret = -ENOMEM;
2992 goto retake_lock;
2993 }
Jan Kara97a851e2013-06-04 11:58:58 -04002994 /*
2995 * Grab reference for DIO. Will be dropped in ext4_end_io_dio()
2996 */
2997 iocb->private = ext4_get_io_end(io_end);
Theodore Ts'o69c499d2012-11-29 21:13:48 -05002998 /*
2999 * we save the io structure for current async direct
3000 * IO, so that later ext4_map_blocks() could flag the
3001 * io structure whether there is a unwritten extents
3002 * needs to be converted when IO is completed.
3003 */
3004 ext4_inode_aio_set(inode, io_end);
3005 }
3006
3007 if (overwrite) {
3008 get_block_func = ext4_get_block_write_nolock;
3009 } else {
3010 get_block_func = ext4_get_block_write;
3011 dio_flags = DIO_LOCKING;
3012 }
3013 ret = __blockdev_direct_IO(rw, iocb, inode,
Al Viro31b14032014-03-05 01:33:16 -05003014 inode->i_sb->s_bdev, iter,
3015 offset,
Theodore Ts'o69c499d2012-11-29 21:13:48 -05003016 get_block_func,
3017 ext4_end_io_dio,
3018 NULL,
3019 dio_flags);
3020
Theodore Ts'oa5499842013-05-11 19:07:42 -04003021 /*
Jan Kara97a851e2013-06-04 11:58:58 -04003022 * Put our reference to io_end. This can free the io_end structure e.g.
3023 * in sync IO case or in case of error. It can even perform extent
3024 * conversion if all bios we submitted finished before we got here.
3025 * Note that in that case iocb->private can be already set to NULL
3026 * here.
Theodore Ts'oa5499842013-05-11 19:07:42 -04003027 */
Jan Kara97a851e2013-06-04 11:58:58 -04003028 if (io_end) {
3029 ext4_inode_aio_set(inode, NULL);
3030 ext4_put_io_end(io_end);
3031 /*
3032 * When no IO was submitted ext4_end_io_dio() was not
3033 * called so we have to put iocb's reference.
3034 */
3035 if (ret <= 0 && ret != -EIOCBQUEUED && iocb->private) {
3036 WARN_ON(iocb->private != io_end);
3037 WARN_ON(io_end->flag & EXT4_IO_END_UNWRITTEN);
Jan Kara97a851e2013-06-04 11:58:58 -04003038 ext4_put_io_end(io_end);
3039 iocb->private = NULL;
3040 }
3041 }
3042 if (ret > 0 && !overwrite && ext4_test_inode_state(inode,
Theodore Ts'o69c499d2012-11-29 21:13:48 -05003043 EXT4_STATE_DIO_UNWRITTEN)) {
3044 int err;
3045 /*
3046 * for non AIO case, since the IO is already
3047 * completed, we could do the conversion right here
3048 */
Jan Kara6b523df2013-06-04 13:21:11 -04003049 err = ext4_convert_unwritten_extents(NULL, inode,
Theodore Ts'o69c499d2012-11-29 21:13:48 -05003050 offset, ret);
3051 if (err < 0)
3052 ret = err;
3053 ext4_clear_inode_state(inode, EXT4_STATE_DIO_UNWRITTEN);
3054 }
3055
3056retake_lock:
Jan Karae8340392013-06-04 14:27:38 -04003057 if (rw == WRITE)
3058 inode_dio_done(inode);
Theodore Ts'o69c499d2012-11-29 21:13:48 -05003059 /* take i_mutex locking again if we do a ovewrite dio */
3060 if (overwrite) {
Theodore Ts'o69c499d2012-11-29 21:13:48 -05003061 up_read(&EXT4_I(inode)->i_data_sem);
3062 mutex_lock(&inode->i_mutex);
3063 }
3064
3065 return ret;
Mingming Cao4c0425f2009-09-28 15:48:41 -04003066}
3067
3068static ssize_t ext4_direct_IO(int rw, struct kiocb *iocb,
Al Virod8d3d942014-03-04 21:27:34 -05003069 struct iov_iter *iter, loff_t offset)
Mingming Cao4c0425f2009-09-28 15:48:41 -04003070{
3071 struct file *file = iocb->ki_filp;
3072 struct inode *inode = file->f_mapping->host;
Al Viroa6cbcd42014-03-04 22:38:00 -05003073 size_t count = iov_iter_count(iter);
Jiaying Zhang0562e0b2011-03-21 21:38:05 -04003074 ssize_t ret;
Mingming Cao4c0425f2009-09-28 15:48:41 -04003075
Theodore Ts'o84ebd792011-08-31 11:56:51 -04003076 /*
3077 * If we are doing data journalling we don't support O_DIRECT
3078 */
3079 if (ext4_should_journal_data(inode))
3080 return 0;
3081
Tao Ma46c7f252012-12-10 14:04:52 -05003082 /* Let buffer I/O handle the inline data case. */
3083 if (ext4_has_inline_data(inode))
3084 return 0;
3085
Al Viroa6cbcd42014-03-04 22:38:00 -05003086 trace_ext4_direct_IO_enter(inode, offset, count, rw);
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04003087 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
Al Viro16b1f052014-03-04 22:14:00 -05003088 ret = ext4_ext_direct_IO(rw, iocb, iter, offset);
Jiaying Zhang0562e0b2011-03-21 21:38:05 -04003089 else
Al Viro16b1f052014-03-04 22:14:00 -05003090 ret = ext4_ind_direct_IO(rw, iocb, iter, offset);
Al Viroa6cbcd42014-03-04 22:38:00 -05003091 trace_ext4_direct_IO_exit(inode, offset, count, rw, ret);
Jiaying Zhang0562e0b2011-03-21 21:38:05 -04003092 return ret;
Mingming Cao4c0425f2009-09-28 15:48:41 -04003093}
3094
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003095/*
Mingming Cao617ba132006-10-11 01:20:53 -07003096 * Pages can be marked dirty completely asynchronously from ext4's journalling
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003097 * activity. By filemap_sync_pte(), try_to_unmap_one(), etc. We cannot do
3098 * much here because ->set_page_dirty is called under VFS locks. The page is
3099 * not necessarily locked.
3100 *
3101 * We cannot just dirty the page and leave attached buffers clean, because the
3102 * buffers' dirty state is "definitive". We cannot just set the buffers dirty
3103 * or jbddirty because all the journalling code will explode.
3104 *
3105 * So what we do is to mark the page "pending dirty" and next time writepage
3106 * is called, propagate that into the buffers appropriately.
3107 */
Mingming Cao617ba132006-10-11 01:20:53 -07003108static int ext4_journalled_set_page_dirty(struct page *page)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003109{
3110 SetPageChecked(page);
3111 return __set_page_dirty_nobuffers(page);
3112}
3113
Theodore Ts'o74d553a2013-04-03 12:39:17 -04003114static const struct address_space_operations ext4_aops = {
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07003115 .readpage = ext4_readpage,
3116 .readpages = ext4_readpages,
Aneesh Kumar K.V43ce1d22009-06-14 17:58:45 -04003117 .writepage = ext4_writepage,
Theodore Ts'o20970ba2013-06-06 14:00:46 -04003118 .writepages = ext4_writepages,
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07003119 .write_begin = ext4_write_begin,
Theodore Ts'o74d553a2013-04-03 12:39:17 -04003120 .write_end = ext4_write_end,
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07003121 .bmap = ext4_bmap,
3122 .invalidatepage = ext4_invalidatepage,
3123 .releasepage = ext4_releasepage,
3124 .direct_IO = ext4_direct_IO,
3125 .migratepage = buffer_migrate_page,
3126 .is_partially_uptodate = block_is_partially_uptodate,
Andi Kleenaa261f52009-09-16 11:50:16 +02003127 .error_remove_page = generic_error_remove_page,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003128};
3129
Mingming Cao617ba132006-10-11 01:20:53 -07003130static const struct address_space_operations ext4_journalled_aops = {
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07003131 .readpage = ext4_readpage,
3132 .readpages = ext4_readpages,
Aneesh Kumar K.V43ce1d22009-06-14 17:58:45 -04003133 .writepage = ext4_writepage,
Theodore Ts'o20970ba2013-06-06 14:00:46 -04003134 .writepages = ext4_writepages,
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07003135 .write_begin = ext4_write_begin,
3136 .write_end = ext4_journalled_write_end,
3137 .set_page_dirty = ext4_journalled_set_page_dirty,
3138 .bmap = ext4_bmap,
Jan Kara4520fb32012-12-25 13:28:54 -05003139 .invalidatepage = ext4_journalled_invalidatepage,
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07003140 .releasepage = ext4_releasepage,
Theodore Ts'o84ebd792011-08-31 11:56:51 -04003141 .direct_IO = ext4_direct_IO,
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07003142 .is_partially_uptodate = block_is_partially_uptodate,
Andi Kleenaa261f52009-09-16 11:50:16 +02003143 .error_remove_page = generic_error_remove_page,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003144};
3145
Alex Tomas64769242008-07-11 19:27:31 -04003146static const struct address_space_operations ext4_da_aops = {
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07003147 .readpage = ext4_readpage,
3148 .readpages = ext4_readpages,
Aneesh Kumar K.V43ce1d22009-06-14 17:58:45 -04003149 .writepage = ext4_writepage,
Theodore Ts'o20970ba2013-06-06 14:00:46 -04003150 .writepages = ext4_writepages,
Hisashi Hifumi8ab22b92008-07-28 15:46:36 -07003151 .write_begin = ext4_da_write_begin,
3152 .write_end = ext4_da_write_end,
3153 .bmap = ext4_bmap,
3154 .invalidatepage = ext4_da_invalidatepage,
3155 .releasepage = ext4_releasepage,
3156 .direct_IO = ext4_direct_IO,
3157 .migratepage = buffer_migrate_page,
3158 .is_partially_uptodate = block_is_partially_uptodate,
Andi Kleenaa261f52009-09-16 11:50:16 +02003159 .error_remove_page = generic_error_remove_page,
Alex Tomas64769242008-07-11 19:27:31 -04003160};
3161
Mingming Cao617ba132006-10-11 01:20:53 -07003162void ext4_set_aops(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003163{
Lukas Czerner3d2b1582012-02-20 17:53:00 -05003164 switch (ext4_inode_journal_mode(inode)) {
3165 case EXT4_INODE_ORDERED_DATA_MODE:
Theodore Ts'o74d553a2013-04-03 12:39:17 -04003166 ext4_set_inode_state(inode, EXT4_STATE_ORDERED_MODE);
Lukas Czerner3d2b1582012-02-20 17:53:00 -05003167 break;
3168 case EXT4_INODE_WRITEBACK_DATA_MODE:
Theodore Ts'o74d553a2013-04-03 12:39:17 -04003169 ext4_clear_inode_state(inode, EXT4_STATE_ORDERED_MODE);
Lukas Czerner3d2b1582012-02-20 17:53:00 -05003170 break;
3171 case EXT4_INODE_JOURNAL_DATA_MODE:
Mingming Cao617ba132006-10-11 01:20:53 -07003172 inode->i_mapping->a_ops = &ext4_journalled_aops;
Theodore Ts'o74d553a2013-04-03 12:39:17 -04003173 return;
Lukas Czerner3d2b1582012-02-20 17:53:00 -05003174 default:
3175 BUG();
3176 }
Theodore Ts'o74d553a2013-04-03 12:39:17 -04003177 if (test_opt(inode->i_sb, DELALLOC))
3178 inode->i_mapping->a_ops = &ext4_da_aops;
3179 else
3180 inode->i_mapping->a_ops = &ext4_aops;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003181}
3182
Lukas Czernerd863dc32013-05-27 23:32:35 -04003183/*
Lukas Czernerd863dc32013-05-27 23:32:35 -04003184 * ext4_block_zero_page_range() zeros out a mapping of length 'length'
3185 * starting from file offset 'from'. The range to be zero'd must
3186 * be contained with in one block. If the specified range exceeds
3187 * the end of the block it will be shortened to end of the block
3188 * that cooresponds to 'from'
3189 */
Matthew Wilcox94350ab2014-03-24 15:09:16 -04003190static int ext4_block_zero_page_range(handle_t *handle,
Lukas Czernerd863dc32013-05-27 23:32:35 -04003191 struct address_space *mapping, loff_t from, loff_t length)
3192{
3193 ext4_fsblk_t index = from >> PAGE_CACHE_SHIFT;
3194 unsigned offset = from & (PAGE_CACHE_SIZE-1);
3195 unsigned blocksize, max, pos;
3196 ext4_lblk_t iblock;
3197 struct inode *inode = mapping->host;
3198 struct buffer_head *bh;
3199 struct page *page;
3200 int err = 0;
3201
3202 page = find_or_create_page(mapping, from >> PAGE_CACHE_SHIFT,
3203 mapping_gfp_mask(mapping) & ~__GFP_FS);
3204 if (!page)
3205 return -ENOMEM;
3206
3207 blocksize = inode->i_sb->s_blocksize;
3208 max = blocksize - (offset & (blocksize - 1));
3209
3210 /*
3211 * correct length if it does not fall between
3212 * 'from' and the end of the block
3213 */
3214 if (length > max || length < 0)
3215 length = max;
3216
3217 iblock = index << (PAGE_CACHE_SHIFT - inode->i_sb->s_blocksize_bits);
3218
3219 if (!page_has_buffers(page))
3220 create_empty_buffers(page, blocksize, 0);
3221
3222 /* Find the buffer that contains "offset" */
3223 bh = page_buffers(page);
3224 pos = blocksize;
3225 while (offset >= pos) {
3226 bh = bh->b_this_page;
3227 iblock++;
3228 pos += blocksize;
3229 }
Lukas Czernerd863dc32013-05-27 23:32:35 -04003230 if (buffer_freed(bh)) {
3231 BUFFER_TRACE(bh, "freed: skip");
3232 goto unlock;
3233 }
Lukas Czernerd863dc32013-05-27 23:32:35 -04003234 if (!buffer_mapped(bh)) {
3235 BUFFER_TRACE(bh, "unmapped");
3236 ext4_get_block(inode, iblock, bh, 0);
3237 /* unmapped? It's a hole - nothing to do */
3238 if (!buffer_mapped(bh)) {
3239 BUFFER_TRACE(bh, "still unmapped");
3240 goto unlock;
3241 }
3242 }
3243
3244 /* Ok, it's mapped. Make sure it's up-to-date */
3245 if (PageUptodate(page))
3246 set_buffer_uptodate(bh);
3247
3248 if (!buffer_uptodate(bh)) {
3249 err = -EIO;
3250 ll_rw_block(READ, 1, &bh);
3251 wait_on_buffer(bh);
3252 /* Uhhuh. Read error. Complain and punt. */
3253 if (!buffer_uptodate(bh))
3254 goto unlock;
3255 }
Lukas Czernerd863dc32013-05-27 23:32:35 -04003256 if (ext4_should_journal_data(inode)) {
3257 BUFFER_TRACE(bh, "get write access");
3258 err = ext4_journal_get_write_access(handle, bh);
3259 if (err)
3260 goto unlock;
3261 }
Lukas Czernerd863dc32013-05-27 23:32:35 -04003262 zero_user(page, offset, length);
Lukas Czernerd863dc32013-05-27 23:32:35 -04003263 BUFFER_TRACE(bh, "zeroed end of block");
3264
Lukas Czernerd863dc32013-05-27 23:32:35 -04003265 if (ext4_should_journal_data(inode)) {
3266 err = ext4_handle_dirty_metadata(handle, inode, bh);
Lukas Czerner0713ed02013-05-27 23:32:35 -04003267 } else {
jon ernst353eefd2013-07-01 08:12:39 -04003268 err = 0;
Lukas Czernerd863dc32013-05-27 23:32:35 -04003269 mark_buffer_dirty(bh);
Lukas Czerner0713ed02013-05-27 23:32:35 -04003270 if (ext4_test_inode_state(inode, EXT4_STATE_ORDERED_MODE))
3271 err = ext4_jbd2_file_inode(handle, inode);
3272 }
Lukas Czernerd863dc32013-05-27 23:32:35 -04003273
3274unlock:
3275 unlock_page(page);
3276 page_cache_release(page);
3277 return err;
3278}
3279
Matthew Wilcox94350ab2014-03-24 15:09:16 -04003280/*
3281 * ext4_block_truncate_page() zeroes out a mapping from file offset `from'
3282 * up to the end of the block which corresponds to `from'.
3283 * This required during truncate. We need to physically zero the tail end
3284 * of that block so it doesn't yield old data if the file is later grown.
3285 */
Stephen Hemmingerc1978552014-05-12 10:50:23 -04003286static int ext4_block_truncate_page(handle_t *handle,
Matthew Wilcox94350ab2014-03-24 15:09:16 -04003287 struct address_space *mapping, loff_t from)
3288{
3289 unsigned offset = from & (PAGE_CACHE_SIZE-1);
3290 unsigned length;
3291 unsigned blocksize;
3292 struct inode *inode = mapping->host;
3293
3294 blocksize = inode->i_sb->s_blocksize;
3295 length = blocksize - (offset & (blocksize - 1));
3296
3297 return ext4_block_zero_page_range(handle, mapping, from, length);
3298}
3299
Lukas Czernera87dd182013-05-27 23:32:35 -04003300int ext4_zero_partial_blocks(handle_t *handle, struct inode *inode,
3301 loff_t lstart, loff_t length)
3302{
3303 struct super_block *sb = inode->i_sb;
3304 struct address_space *mapping = inode->i_mapping;
Lukas Czernere1be3a92013-07-01 08:12:39 -04003305 unsigned partial_start, partial_end;
Lukas Czernera87dd182013-05-27 23:32:35 -04003306 ext4_fsblk_t start, end;
3307 loff_t byte_end = (lstart + length - 1);
3308 int err = 0;
3309
Lukas Czernere1be3a92013-07-01 08:12:39 -04003310 partial_start = lstart & (sb->s_blocksize - 1);
3311 partial_end = byte_end & (sb->s_blocksize - 1);
3312
Lukas Czernera87dd182013-05-27 23:32:35 -04003313 start = lstart >> sb->s_blocksize_bits;
3314 end = byte_end >> sb->s_blocksize_bits;
3315
3316 /* Handle partial zero within the single block */
Lukas Czernere1be3a92013-07-01 08:12:39 -04003317 if (start == end &&
3318 (partial_start || (partial_end != sb->s_blocksize - 1))) {
Lukas Czernera87dd182013-05-27 23:32:35 -04003319 err = ext4_block_zero_page_range(handle, mapping,
3320 lstart, length);
3321 return err;
3322 }
3323 /* Handle partial zero out on the start of the range */
Lukas Czernere1be3a92013-07-01 08:12:39 -04003324 if (partial_start) {
Lukas Czernera87dd182013-05-27 23:32:35 -04003325 err = ext4_block_zero_page_range(handle, mapping,
3326 lstart, sb->s_blocksize);
3327 if (err)
3328 return err;
3329 }
3330 /* Handle partial zero out on the end of the range */
Lukas Czernere1be3a92013-07-01 08:12:39 -04003331 if (partial_end != sb->s_blocksize - 1)
Lukas Czernera87dd182013-05-27 23:32:35 -04003332 err = ext4_block_zero_page_range(handle, mapping,
Lukas Czernere1be3a92013-07-01 08:12:39 -04003333 byte_end - partial_end,
3334 partial_end + 1);
Lukas Czernera87dd182013-05-27 23:32:35 -04003335 return err;
3336}
3337
Duane Griffin91ef4ca2008-07-11 19:27:31 -04003338int ext4_can_truncate(struct inode *inode)
3339{
Duane Griffin91ef4ca2008-07-11 19:27:31 -04003340 if (S_ISREG(inode->i_mode))
3341 return 1;
3342 if (S_ISDIR(inode->i_mode))
3343 return 1;
3344 if (S_ISLNK(inode->i_mode))
3345 return !ext4_inode_is_fast_symlink(inode);
3346 return 0;
3347}
3348
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003349/*
Allison Hendersona4bb6b62011-05-25 07:41:50 -04003350 * ext4_punch_hole: punches a hole in a file by releaseing the blocks
3351 * associated with the given offset and length
3352 *
3353 * @inode: File inode
3354 * @offset: The offset where the hole will begin
3355 * @len: The length of the hole
3356 *
Anatol Pomozov4907cb72012-09-01 10:31:09 -07003357 * Returns: 0 on success or negative on failure
Allison Hendersona4bb6b62011-05-25 07:41:50 -04003358 */
3359
Ashish Sangwanaeb28172013-07-01 08:12:38 -04003360int ext4_punch_hole(struct inode *inode, loff_t offset, loff_t length)
Allison Hendersona4bb6b62011-05-25 07:41:50 -04003361{
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003362 struct super_block *sb = inode->i_sb;
3363 ext4_lblk_t first_block, stop_block;
3364 struct address_space *mapping = inode->i_mapping;
Lukas Czernera87dd182013-05-27 23:32:35 -04003365 loff_t first_block_offset, last_block_offset;
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003366 handle_t *handle;
3367 unsigned int credits;
3368 int ret = 0;
3369
Allison Hendersona4bb6b62011-05-25 07:41:50 -04003370 if (!S_ISREG(inode->i_mode))
Allison Henderson73355192012-03-21 22:23:31 -04003371 return -EOPNOTSUPP;
Allison Hendersona4bb6b62011-05-25 07:41:50 -04003372
Lukas Czernerb8a86842014-03-18 18:05:35 -04003373 trace_ext4_punch_hole(inode, offset, length, 0);
Zheng Liuaaddea82013-01-16 20:21:26 -05003374
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003375 /*
3376 * Write out all dirty pages to avoid race conditions
3377 * Then release them.
3378 */
3379 if (mapping->nrpages && mapping_tagged(mapping, PAGECACHE_TAG_DIRTY)) {
3380 ret = filemap_write_and_wait_range(mapping, offset,
3381 offset + length - 1);
3382 if (ret)
3383 return ret;
3384 }
3385
3386 mutex_lock(&inode->i_mutex);
Lukas Czerner9ef06ce2014-04-12 09:47:00 -04003387
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003388 /* No need to punch hole beyond i_size */
3389 if (offset >= inode->i_size)
3390 goto out_mutex;
3391
3392 /*
3393 * If the hole extends beyond i_size, set the hole
3394 * to end after the page that contains i_size
3395 */
3396 if (offset + length > inode->i_size) {
3397 length = inode->i_size +
3398 PAGE_CACHE_SIZE - (inode->i_size & (PAGE_CACHE_SIZE - 1)) -
3399 offset;
3400 }
3401
Jan Karaa3612932013-08-16 21:19:41 -04003402 if (offset & (sb->s_blocksize - 1) ||
3403 (offset + length) & (sb->s_blocksize - 1)) {
3404 /*
3405 * Attach jinode to inode for jbd2 if we do any zeroing of
3406 * partial block
3407 */
3408 ret = ext4_inode_attach_jinode(inode);
3409 if (ret < 0)
3410 goto out_mutex;
3411
3412 }
3413
Lukas Czernera87dd182013-05-27 23:32:35 -04003414 first_block_offset = round_up(offset, sb->s_blocksize);
3415 last_block_offset = round_down((offset + length), sb->s_blocksize) - 1;
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003416
Lukas Czernera87dd182013-05-27 23:32:35 -04003417 /* Now release the pages and zero block aligned part of pages*/
3418 if (last_block_offset > first_block_offset)
3419 truncate_pagecache_range(inode, first_block_offset,
3420 last_block_offset);
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003421
3422 /* Wait all existing dio workers, newcomers will block on i_mutex */
3423 ext4_inode_block_unlocked_dio(inode);
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003424 inode_dio_wait(inode);
3425
3426 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3427 credits = ext4_writepage_trans_blocks(inode);
3428 else
3429 credits = ext4_blocks_for_truncate(inode);
3430 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
3431 if (IS_ERR(handle)) {
3432 ret = PTR_ERR(handle);
3433 ext4_std_error(sb, ret);
3434 goto out_dio;
3435 }
3436
Lukas Czernera87dd182013-05-27 23:32:35 -04003437 ret = ext4_zero_partial_blocks(handle, inode, offset,
3438 length);
3439 if (ret)
3440 goto out_stop;
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003441
3442 first_block = (offset + sb->s_blocksize - 1) >>
3443 EXT4_BLOCK_SIZE_BITS(sb);
3444 stop_block = (offset + length) >> EXT4_BLOCK_SIZE_BITS(sb);
3445
3446 /* If there are no blocks to remove, return now */
3447 if (first_block >= stop_block)
3448 goto out_stop;
3449
3450 down_write(&EXT4_I(inode)->i_data_sem);
3451 ext4_discard_preallocations(inode);
3452
3453 ret = ext4_es_remove_extent(inode, first_block,
3454 stop_block - first_block);
3455 if (ret) {
3456 up_write(&EXT4_I(inode)->i_data_sem);
3457 goto out_stop;
3458 }
3459
3460 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3461 ret = ext4_ext_remove_space(inode, first_block,
3462 stop_block - 1);
3463 else
Lukas Czerner4f579ae2014-07-15 06:03:38 -04003464 ret = ext4_ind_remove_space(handle, inode, first_block,
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003465 stop_block);
3466
Theodore Ts'o819c4922013-04-03 12:47:17 -04003467 up_write(&EXT4_I(inode)->i_data_sem);
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003468 if (IS_SYNC(inode))
3469 ext4_handle_sync(handle);
Maxim Patlasove251f9b2014-02-20 16:58:05 -05003470
3471 /* Now release the pages again to reduce race window */
3472 if (last_block_offset > first_block_offset)
3473 truncate_pagecache_range(inode, first_block_offset,
3474 last_block_offset);
3475
Theodore Ts'o26a4c0c2013-04-03 12:45:17 -04003476 inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
3477 ext4_mark_inode_dirty(handle, inode);
3478out_stop:
3479 ext4_journal_stop(handle);
3480out_dio:
3481 ext4_inode_resume_unlocked_dio(inode);
3482out_mutex:
3483 mutex_unlock(&inode->i_mutex);
3484 return ret;
Allison Hendersona4bb6b62011-05-25 07:41:50 -04003485}
3486
Jan Karaa3612932013-08-16 21:19:41 -04003487int ext4_inode_attach_jinode(struct inode *inode)
3488{
3489 struct ext4_inode_info *ei = EXT4_I(inode);
3490 struct jbd2_inode *jinode;
3491
3492 if (ei->jinode || !EXT4_SB(inode->i_sb)->s_journal)
3493 return 0;
3494
3495 jinode = jbd2_alloc_inode(GFP_KERNEL);
3496 spin_lock(&inode->i_lock);
3497 if (!ei->jinode) {
3498 if (!jinode) {
3499 spin_unlock(&inode->i_lock);
3500 return -ENOMEM;
3501 }
3502 ei->jinode = jinode;
3503 jbd2_journal_init_jbd_inode(ei->jinode, inode);
3504 jinode = NULL;
3505 }
3506 spin_unlock(&inode->i_lock);
3507 if (unlikely(jinode != NULL))
3508 jbd2_free_inode(jinode);
3509 return 0;
3510}
3511
Allison Hendersona4bb6b62011-05-25 07:41:50 -04003512/*
Mingming Cao617ba132006-10-11 01:20:53 -07003513 * ext4_truncate()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003514 *
Mingming Cao617ba132006-10-11 01:20:53 -07003515 * We block out ext4_get_block() block instantiations across the entire
3516 * transaction, and VFS/VM ensures that ext4_truncate() cannot run
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003517 * simultaneously on behalf of the same inode.
3518 *
Justin P. Mattock42b2aa82011-11-28 20:31:00 -08003519 * As we work through the truncate and commit bits of it to the journal there
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003520 * is one core, guiding principle: the file's tree must always be consistent on
3521 * disk. We must be able to restart the truncate after a crash.
3522 *
3523 * The file's tree may be transiently inconsistent in memory (although it
3524 * probably isn't), but whenever we close off and commit a journal transaction,
3525 * the contents of (the filesystem + the journal) must be consistent and
3526 * restartable. It's pretty simple, really: bottom up, right to left (although
3527 * left-to-right works OK too).
3528 *
3529 * Note that at recovery time, journal replay occurs *before* the restart of
3530 * truncate against the orphan inode list.
3531 *
3532 * The committed inode has the new, desired i_size (which is the same as
Mingming Cao617ba132006-10-11 01:20:53 -07003533 * i_disksize in this case). After a crash, ext4_orphan_cleanup() will see
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003534 * that this inode's truncate did not complete and it will again call
Mingming Cao617ba132006-10-11 01:20:53 -07003535 * ext4_truncate() to have another go. So there will be instantiated blocks
3536 * to the right of the truncation point in a crashed ext4 filesystem. But
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003537 * that's fine - as long as they are linked from the inode, the post-crash
Mingming Cao617ba132006-10-11 01:20:53 -07003538 * ext4_truncate() run will find them and release them.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003539 */
Mingming Cao617ba132006-10-11 01:20:53 -07003540void ext4_truncate(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003541{
Theodore Ts'o819c4922013-04-03 12:47:17 -04003542 struct ext4_inode_info *ei = EXT4_I(inode);
3543 unsigned int credits;
3544 handle_t *handle;
3545 struct address_space *mapping = inode->i_mapping;
Theodore Ts'o819c4922013-04-03 12:47:17 -04003546
Theodore Ts'o19b5ef62013-04-03 21:58:52 -04003547 /*
3548 * There is a possibility that we're either freeing the inode
Matthew Wilcoxe04027e2014-03-24 15:15:07 -04003549 * or it's a completely new inode. In those cases we might not
Theodore Ts'o19b5ef62013-04-03 21:58:52 -04003550 * have i_mutex locked because it's not necessary.
3551 */
3552 if (!(inode->i_state & (I_NEW|I_FREEING)))
3553 WARN_ON(!mutex_is_locked(&inode->i_mutex));
Jiaying Zhang0562e0b2011-03-21 21:38:05 -04003554 trace_ext4_truncate_enter(inode);
3555
Duane Griffin91ef4ca2008-07-11 19:27:31 -04003556 if (!ext4_can_truncate(inode))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003557 return;
3558
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04003559 ext4_clear_inode_flag(inode, EXT4_INODE_EOFBLOCKS);
Jiaying Zhangc8d46e42010-02-24 09:52:53 -05003560
Theodore Ts'o5534fb52009-09-17 09:34:16 -04003561 if (inode->i_size == 0 && !test_opt(inode->i_sb, NO_AUTO_DA_ALLOC))
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05003562 ext4_set_inode_state(inode, EXT4_STATE_DA_ALLOC_CLOSE);
Theodore Ts'o7d8f9f72009-02-24 08:21:14 -05003563
Tao Maaef1c852012-12-10 14:06:02 -05003564 if (ext4_has_inline_data(inode)) {
3565 int has_inline = 1;
3566
3567 ext4_inline_data_truncate(inode, &has_inline);
3568 if (has_inline)
3569 return;
3570 }
3571
Jan Karaa3612932013-08-16 21:19:41 -04003572 /* If we zero-out tail of the page, we have to create jinode for jbd2 */
3573 if (inode->i_size & (inode->i_sb->s_blocksize - 1)) {
3574 if (ext4_inode_attach_jinode(inode) < 0)
3575 return;
3576 }
3577
Amir Goldsteinff9893d2011-06-27 16:36:31 -04003578 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
Theodore Ts'o819c4922013-04-03 12:47:17 -04003579 credits = ext4_writepage_trans_blocks(inode);
Amir Goldsteinff9893d2011-06-27 16:36:31 -04003580 else
Theodore Ts'o819c4922013-04-03 12:47:17 -04003581 credits = ext4_blocks_for_truncate(inode);
3582
3583 handle = ext4_journal_start(inode, EXT4_HT_TRUNCATE, credits);
3584 if (IS_ERR(handle)) {
3585 ext4_std_error(inode->i_sb, PTR_ERR(handle));
3586 return;
3587 }
3588
Lukas Czernereb3544c2013-05-27 23:32:35 -04003589 if (inode->i_size & (inode->i_sb->s_blocksize - 1))
3590 ext4_block_truncate_page(handle, mapping, inode->i_size);
Theodore Ts'o819c4922013-04-03 12:47:17 -04003591
3592 /*
3593 * We add the inode to the orphan list, so that if this
3594 * truncate spans multiple transactions, and we crash, we will
3595 * resume the truncate when the filesystem recovers. It also
3596 * marks the inode dirty, to catch the new size.
3597 *
3598 * Implication: the file must always be in a sane, consistent
3599 * truncatable state while each transaction commits.
3600 */
3601 if (ext4_orphan_add(handle, inode))
3602 goto out_stop;
3603
3604 down_write(&EXT4_I(inode)->i_data_sem);
3605
3606 ext4_discard_preallocations(inode);
3607
3608 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))
3609 ext4_ext_truncate(handle, inode);
3610 else
3611 ext4_ind_truncate(handle, inode);
3612
3613 up_write(&ei->i_data_sem);
3614
3615 if (IS_SYNC(inode))
3616 ext4_handle_sync(handle);
3617
3618out_stop:
3619 /*
3620 * If this was a simple ftruncate() and the file will remain alive,
3621 * then we need to clear up the orphan record which we created above.
3622 * However, if this was a real unlink then we were called by
Wang Shilong58d86a52014-11-25 16:17:29 -05003623 * ext4_evict_inode(), and we allow that function to clean up the
Theodore Ts'o819c4922013-04-03 12:47:17 -04003624 * orphan info for us.
3625 */
3626 if (inode->i_nlink)
3627 ext4_orphan_del(handle, inode);
3628
3629 inode->i_mtime = inode->i_ctime = ext4_current_time(inode);
3630 ext4_mark_inode_dirty(handle, inode);
3631 ext4_journal_stop(handle);
Alex Tomasa86c6182006-10-11 01:21:03 -07003632
Jiaying Zhang0562e0b2011-03-21 21:38:05 -04003633 trace_ext4_truncate_exit(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003634}
3635
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003636/*
Mingming Cao617ba132006-10-11 01:20:53 -07003637 * ext4_get_inode_loc returns with an extra refcount against the inode's
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003638 * underlying buffer_head on success. If 'in_mem' is true, we have all
3639 * data in memory that is needed to recreate the on-disk version of this
3640 * inode.
3641 */
Mingming Cao617ba132006-10-11 01:20:53 -07003642static int __ext4_get_inode_loc(struct inode *inode,
3643 struct ext4_iloc *iloc, int in_mem)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003644{
Theodore Ts'o240799c2008-10-09 23:53:47 -04003645 struct ext4_group_desc *gdp;
3646 struct buffer_head *bh;
3647 struct super_block *sb = inode->i_sb;
3648 ext4_fsblk_t block;
3649 int inodes_per_block, inode_offset;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003650
Aneesh Kumar K.V3a06d772008-11-22 15:04:59 -05003651 iloc->bh = NULL;
Theodore Ts'o240799c2008-10-09 23:53:47 -04003652 if (!ext4_valid_inum(sb, inode->i_ino))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003653 return -EIO;
3654
Theodore Ts'o240799c2008-10-09 23:53:47 -04003655 iloc->block_group = (inode->i_ino - 1) / EXT4_INODES_PER_GROUP(sb);
3656 gdp = ext4_get_group_desc(sb, iloc->block_group, NULL);
3657 if (!gdp)
3658 return -EIO;
3659
3660 /*
3661 * Figure out the offset within the block group inode table
3662 */
Tao Ma00d09882011-05-09 10:26:41 -04003663 inodes_per_block = EXT4_SB(sb)->s_inodes_per_block;
Theodore Ts'o240799c2008-10-09 23:53:47 -04003664 inode_offset = ((inode->i_ino - 1) %
3665 EXT4_INODES_PER_GROUP(sb));
3666 block = ext4_inode_table(sb, gdp) + (inode_offset / inodes_per_block);
3667 iloc->offset = (inode_offset % inodes_per_block) * EXT4_INODE_SIZE(sb);
3668
3669 bh = sb_getblk(sb, block);
Wang Shilongaebf0242013-01-12 16:28:47 -05003670 if (unlikely(!bh))
Theodore Ts'o860d21e2013-01-12 16:19:36 -05003671 return -ENOMEM;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003672 if (!buffer_uptodate(bh)) {
3673 lock_buffer(bh);
Hidehiro Kawai9c83a922008-07-26 16:39:26 -04003674
3675 /*
3676 * If the buffer has the write error flag, we have failed
3677 * to write out another inode in the same block. In this
3678 * case, we don't have to read the block because we may
3679 * read the old inode data successfully.
3680 */
3681 if (buffer_write_io_error(bh) && !buffer_uptodate(bh))
3682 set_buffer_uptodate(bh);
3683
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003684 if (buffer_uptodate(bh)) {
3685 /* someone brought it uptodate while we waited */
3686 unlock_buffer(bh);
3687 goto has_buffer;
3688 }
3689
3690 /*
3691 * If we have all information of the inode in memory and this
3692 * is the only valid inode in the block, we need not read the
3693 * block.
3694 */
3695 if (in_mem) {
3696 struct buffer_head *bitmap_bh;
Theodore Ts'o240799c2008-10-09 23:53:47 -04003697 int i, start;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003698
Theodore Ts'o240799c2008-10-09 23:53:47 -04003699 start = inode_offset & ~(inodes_per_block - 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003700
3701 /* Is the inode bitmap in cache? */
Theodore Ts'o240799c2008-10-09 23:53:47 -04003702 bitmap_bh = sb_getblk(sb, ext4_inode_bitmap(sb, gdp));
Wang Shilongaebf0242013-01-12 16:28:47 -05003703 if (unlikely(!bitmap_bh))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003704 goto make_io;
3705
3706 /*
3707 * If the inode bitmap isn't in cache then the
3708 * optimisation may end up performing two reads instead
3709 * of one, so skip it.
3710 */
3711 if (!buffer_uptodate(bitmap_bh)) {
3712 brelse(bitmap_bh);
3713 goto make_io;
3714 }
Theodore Ts'o240799c2008-10-09 23:53:47 -04003715 for (i = start; i < start + inodes_per_block; i++) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003716 if (i == inode_offset)
3717 continue;
Mingming Cao617ba132006-10-11 01:20:53 -07003718 if (ext4_test_bit(i, bitmap_bh->b_data))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003719 break;
3720 }
3721 brelse(bitmap_bh);
Theodore Ts'o240799c2008-10-09 23:53:47 -04003722 if (i == start + inodes_per_block) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003723 /* all other inodes are free, so skip I/O */
3724 memset(bh->b_data, 0, bh->b_size);
3725 set_buffer_uptodate(bh);
3726 unlock_buffer(bh);
3727 goto has_buffer;
3728 }
3729 }
3730
3731make_io:
3732 /*
Theodore Ts'o240799c2008-10-09 23:53:47 -04003733 * If we need to do any I/O, try to pre-readahead extra
3734 * blocks from the inode table.
3735 */
3736 if (EXT4_SB(sb)->s_inode_readahead_blks) {
3737 ext4_fsblk_t b, end, table;
3738 unsigned num;
Theodore Ts'o0d606e22013-04-23 08:59:35 -04003739 __u32 ra_blks = EXT4_SB(sb)->s_inode_readahead_blks;
Theodore Ts'o240799c2008-10-09 23:53:47 -04003740
3741 table = ext4_inode_table(sb, gdp);
Theodore Ts'ob713a5e2009-03-31 09:11:14 -04003742 /* s_inode_readahead_blks is always a power of 2 */
Theodore Ts'o0d606e22013-04-23 08:59:35 -04003743 b = block & ~((ext4_fsblk_t) ra_blks - 1);
Theodore Ts'o240799c2008-10-09 23:53:47 -04003744 if (table > b)
3745 b = table;
Theodore Ts'o0d606e22013-04-23 08:59:35 -04003746 end = b + ra_blks;
Theodore Ts'o240799c2008-10-09 23:53:47 -04003747 num = EXT4_INODES_PER_GROUP(sb);
Darrick J. Wongfeb0ab32012-04-29 18:45:10 -04003748 if (ext4_has_group_desc_csum(sb))
Aneesh Kumar K.V560671a2009-01-05 22:20:24 -05003749 num -= ext4_itable_unused_count(sb, gdp);
Theodore Ts'o240799c2008-10-09 23:53:47 -04003750 table += num / inodes_per_block;
3751 if (end > table)
3752 end = table;
3753 while (b <= end)
3754 sb_breadahead(sb, b++);
3755 }
3756
3757 /*
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003758 * There are other valid inodes in the buffer, this inode
3759 * has in-inode xattrs, or we don't have this inode in memory.
3760 * Read the block from disk.
3761 */
Jiaying Zhang0562e0b2011-03-21 21:38:05 -04003762 trace_ext4_load_inode(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003763 get_bh(bh);
3764 bh->b_end_io = end_buffer_read_sync;
Christoph Hellwig65299a32011-08-23 14:50:29 +02003765 submit_bh(READ | REQ_META | REQ_PRIO, bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003766 wait_on_buffer(bh);
3767 if (!buffer_uptodate(bh)) {
Theodore Ts'oc398eda2010-07-27 11:56:40 -04003768 EXT4_ERROR_INODE_BLOCK(inode, block,
3769 "unable to read itable block");
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003770 brelse(bh);
3771 return -EIO;
3772 }
3773 }
3774has_buffer:
3775 iloc->bh = bh;
3776 return 0;
3777}
3778
Mingming Cao617ba132006-10-11 01:20:53 -07003779int ext4_get_inode_loc(struct inode *inode, struct ext4_iloc *iloc)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003780{
3781 /* We have all inode data except xattrs in memory here. */
Mingming Cao617ba132006-10-11 01:20:53 -07003782 return __ext4_get_inode_loc(inode, iloc,
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05003783 !ext4_test_inode_state(inode, EXT4_STATE_XATTR));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003784}
3785
Mingming Cao617ba132006-10-11 01:20:53 -07003786void ext4_set_inode_flags(struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003787{
Mingming Cao617ba132006-10-11 01:20:53 -07003788 unsigned int flags = EXT4_I(inode)->i_flags;
Theodore Ts'o00a1a052014-03-30 10:20:01 -04003789 unsigned int new_fl = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003790
Mingming Cao617ba132006-10-11 01:20:53 -07003791 if (flags & EXT4_SYNC_FL)
Theodore Ts'o00a1a052014-03-30 10:20:01 -04003792 new_fl |= S_SYNC;
Mingming Cao617ba132006-10-11 01:20:53 -07003793 if (flags & EXT4_APPEND_FL)
Theodore Ts'o00a1a052014-03-30 10:20:01 -04003794 new_fl |= S_APPEND;
Mingming Cao617ba132006-10-11 01:20:53 -07003795 if (flags & EXT4_IMMUTABLE_FL)
Theodore Ts'o00a1a052014-03-30 10:20:01 -04003796 new_fl |= S_IMMUTABLE;
Mingming Cao617ba132006-10-11 01:20:53 -07003797 if (flags & EXT4_NOATIME_FL)
Theodore Ts'o00a1a052014-03-30 10:20:01 -04003798 new_fl |= S_NOATIME;
Mingming Cao617ba132006-10-11 01:20:53 -07003799 if (flags & EXT4_DIRSYNC_FL)
Theodore Ts'o00a1a052014-03-30 10:20:01 -04003800 new_fl |= S_DIRSYNC;
Theodore Ts'o5f16f322014-03-24 14:43:12 -04003801 inode_set_flags(inode, new_fl,
3802 S_SYNC|S_APPEND|S_IMMUTABLE|S_NOATIME|S_DIRSYNC);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003803}
3804
Jan Karaff9ddf72007-07-18 09:24:20 -04003805/* Propagate flags from i_flags to EXT4_I(inode)->i_flags */
3806void ext4_get_inode_flags(struct ext4_inode_info *ei)
3807{
Dmitry Monakhov84a8dce2010-06-05 11:51:27 -04003808 unsigned int vfs_fl;
3809 unsigned long old_fl, new_fl;
Jan Karaff9ddf72007-07-18 09:24:20 -04003810
Dmitry Monakhov84a8dce2010-06-05 11:51:27 -04003811 do {
3812 vfs_fl = ei->vfs_inode.i_flags;
3813 old_fl = ei->i_flags;
3814 new_fl = old_fl & ~(EXT4_SYNC_FL|EXT4_APPEND_FL|
3815 EXT4_IMMUTABLE_FL|EXT4_NOATIME_FL|
3816 EXT4_DIRSYNC_FL);
3817 if (vfs_fl & S_SYNC)
3818 new_fl |= EXT4_SYNC_FL;
3819 if (vfs_fl & S_APPEND)
3820 new_fl |= EXT4_APPEND_FL;
3821 if (vfs_fl & S_IMMUTABLE)
3822 new_fl |= EXT4_IMMUTABLE_FL;
3823 if (vfs_fl & S_NOATIME)
3824 new_fl |= EXT4_NOATIME_FL;
3825 if (vfs_fl & S_DIRSYNC)
3826 new_fl |= EXT4_DIRSYNC_FL;
3827 } while (cmpxchg(&ei->i_flags, old_fl, new_fl) != old_fl);
Jan Karaff9ddf72007-07-18 09:24:20 -04003828}
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04003829
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05003830static blkcnt_t ext4_inode_blocks(struct ext4_inode *raw_inode,
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04003831 struct ext4_inode_info *ei)
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05003832{
3833 blkcnt_t i_blocks ;
Aneesh Kumar K.V8180a562008-01-28 23:58:27 -05003834 struct inode *inode = &(ei->vfs_inode);
3835 struct super_block *sb = inode->i_sb;
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05003836
3837 if (EXT4_HAS_RO_COMPAT_FEATURE(sb,
3838 EXT4_FEATURE_RO_COMPAT_HUGE_FILE)) {
3839 /* we are using combined 48 bit field */
3840 i_blocks = ((u64)le16_to_cpu(raw_inode->i_blocks_high)) << 32 |
3841 le32_to_cpu(raw_inode->i_blocks_lo);
Theodore Ts'o07a03822010-06-14 09:54:48 -04003842 if (ext4_test_inode_flag(inode, EXT4_INODE_HUGE_FILE)) {
Aneesh Kumar K.V8180a562008-01-28 23:58:27 -05003843 /* i_blocks represent file system block size */
3844 return i_blocks << (inode->i_blkbits - 9);
3845 } else {
3846 return i_blocks;
3847 }
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05003848 } else {
3849 return le32_to_cpu(raw_inode->i_blocks_lo);
3850 }
3851}
Jan Karaff9ddf72007-07-18 09:24:20 -04003852
Tao Ma152a7b02012-12-02 11:13:24 -05003853static inline void ext4_iget_extra_inode(struct inode *inode,
3854 struct ext4_inode *raw_inode,
3855 struct ext4_inode_info *ei)
3856{
3857 __le32 *magic = (void *)raw_inode +
3858 EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize;
Tao Ma67cf5b02012-12-10 14:04:46 -05003859 if (*magic == cpu_to_le32(EXT4_XATTR_MAGIC)) {
Tao Ma152a7b02012-12-02 11:13:24 -05003860 ext4_set_inode_state(inode, EXT4_STATE_XATTR);
Tao Ma67cf5b02012-12-10 14:04:46 -05003861 ext4_find_inline_data_nolock(inode);
Tao Maf19d5872012-12-10 14:05:51 -05003862 } else
3863 EXT4_I(inode)->i_inline_off = 0;
Tao Ma152a7b02012-12-02 11:13:24 -05003864}
3865
David Howells1d1fe1e2008-02-07 00:15:37 -08003866struct inode *ext4_iget(struct super_block *sb, unsigned long ino)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003867{
Mingming Cao617ba132006-10-11 01:20:53 -07003868 struct ext4_iloc iloc;
3869 struct ext4_inode *raw_inode;
David Howells1d1fe1e2008-02-07 00:15:37 -08003870 struct ext4_inode_info *ei;
David Howells1d1fe1e2008-02-07 00:15:37 -08003871 struct inode *inode;
Jan Karab436b9b2009-12-08 23:51:10 -05003872 journal_t *journal = EXT4_SB(sb)->s_journal;
David Howells1d1fe1e2008-02-07 00:15:37 -08003873 long ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003874 int block;
Eric W. Biederman08cefc72012-02-07 15:41:49 -08003875 uid_t i_uid;
3876 gid_t i_gid;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003877
David Howells1d1fe1e2008-02-07 00:15:37 -08003878 inode = iget_locked(sb, ino);
3879 if (!inode)
3880 return ERR_PTR(-ENOMEM);
3881 if (!(inode->i_state & I_NEW))
3882 return inode;
3883
3884 ei = EXT4_I(inode);
Peter Huewe7dc57612011-02-21 21:01:42 -05003885 iloc.bh = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003886
David Howells1d1fe1e2008-02-07 00:15:37 -08003887 ret = __ext4_get_inode_loc(inode, &iloc, 0);
3888 if (ret < 0)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003889 goto bad_inode;
Mingming Cao617ba132006-10-11 01:20:53 -07003890 raw_inode = ext4_raw_inode(&iloc);
Darrick J. Wong814525f2012-04-29 18:31:10 -04003891
3892 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
3893 ei->i_extra_isize = le16_to_cpu(raw_inode->i_extra_isize);
3894 if (EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize >
3895 EXT4_INODE_SIZE(inode->i_sb)) {
3896 EXT4_ERROR_INODE(inode, "bad extra_isize (%u != %u)",
3897 EXT4_GOOD_OLD_INODE_SIZE + ei->i_extra_isize,
3898 EXT4_INODE_SIZE(inode->i_sb));
3899 ret = -EIO;
3900 goto bad_inode;
3901 }
3902 } else
3903 ei->i_extra_isize = 0;
3904
3905 /* Precompute checksum seed for inode metadata */
Dmitry Monakhov9aa5d322014-10-13 03:36:16 -04003906 if (ext4_has_metadata_csum(sb)) {
Darrick J. Wong814525f2012-04-29 18:31:10 -04003907 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
3908 __u32 csum;
3909 __le32 inum = cpu_to_le32(inode->i_ino);
3910 __le32 gen = raw_inode->i_generation;
3911 csum = ext4_chksum(sbi, sbi->s_csum_seed, (__u8 *)&inum,
3912 sizeof(inum));
3913 ei->i_csum_seed = ext4_chksum(sbi, csum, (__u8 *)&gen,
3914 sizeof(gen));
3915 }
3916
3917 if (!ext4_inode_csum_verify(inode, raw_inode, ei)) {
3918 EXT4_ERROR_INODE(inode, "checksum invalid");
3919 ret = -EIO;
3920 goto bad_inode;
3921 }
3922
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003923 inode->i_mode = le16_to_cpu(raw_inode->i_mode);
Eric W. Biederman08cefc72012-02-07 15:41:49 -08003924 i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
3925 i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04003926 if (!(test_opt(inode->i_sb, NO_UID32))) {
Eric W. Biederman08cefc72012-02-07 15:41:49 -08003927 i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
3928 i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003929 }
Eric W. Biederman08cefc72012-02-07 15:41:49 -08003930 i_uid_write(inode, i_uid);
3931 i_gid_write(inode, i_gid);
Miklos Szeredibfe86842011-10-28 14:13:29 +02003932 set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003933
Theodore Ts'o353eb832011-01-10 12:18:25 -05003934 ext4_clear_state_flags(ei); /* Only relevant on 32-bit archs */
Tao Ma67cf5b02012-12-10 14:04:46 -05003935 ei->i_inline_off = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003936 ei->i_dir_start_lookup = 0;
3937 ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
3938 /* We now have enough fields to check if the inode was active or not.
3939 * This is needed because nfsd might try to access dead inodes
3940 * the test is that same one that e2fsck uses
3941 * NeilBrown 1999oct15
3942 */
3943 if (inode->i_nlink == 0) {
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -04003944 if ((inode->i_mode == 0 ||
3945 !(EXT4_SB(inode->i_sb)->s_mount_state & EXT4_ORPHAN_FS)) &&
3946 ino != EXT4_BOOT_LOADER_INO) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003947 /* this inode is deleted */
David Howells1d1fe1e2008-02-07 00:15:37 -08003948 ret = -ESTALE;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003949 goto bad_inode;
3950 }
3951 /* The only unlinked inodes we let through here have
3952 * valid i_mode and are being read by the orphan
3953 * recovery code: that's fine, we're about to complete
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -04003954 * the process of deleting those.
3955 * OR it is the EXT4_BOOT_LOADER_INO which is
3956 * not initialized on a new filesystem. */
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003957 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003958 ei->i_flags = le32_to_cpu(raw_inode->i_flags);
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05003959 inode->i_blocks = ext4_inode_blocks(raw_inode, ei);
Aneesh Kumar K.V7973c0c2008-01-28 23:58:27 -05003960 ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl_lo);
Theodore Ts'oa9e81742009-04-24 16:11:18 -04003961 if (EXT4_HAS_INCOMPAT_FEATURE(sb, EXT4_FEATURE_INCOMPAT_64BIT))
Badari Pulavartya1ddeb72006-10-11 01:21:09 -07003962 ei->i_file_acl |=
3963 ((__u64)le16_to_cpu(raw_inode->i_file_acl_high)) << 32;
Aneesh Kumar K.Va48380f2008-01-28 23:58:27 -05003964 inode->i_size = ext4_isize(raw_inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003965 ei->i_disksize = inode->i_size;
Dmitry Monakhova9e7f442009-12-14 15:21:14 +03003966#ifdef CONFIG_QUOTA
3967 ei->i_reserved_quota = 0;
3968#endif
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003969 inode->i_generation = le32_to_cpu(raw_inode->i_generation);
3970 ei->i_block_group = iloc.block_group;
Theodore Ts'oa4912122009-03-12 12:18:34 -04003971 ei->i_last_alloc_group = ~0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003972 /*
3973 * NOTE! The in-memory inode i_data array is in little-endian order
3974 * even on big-endian machines: we do NOT byteswap the block numbers!
3975 */
Mingming Cao617ba132006-10-11 01:20:53 -07003976 for (block = 0; block < EXT4_N_BLOCKS; block++)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07003977 ei->i_data[block] = raw_inode->i_block[block];
3978 INIT_LIST_HEAD(&ei->i_orphan);
3979
Jan Karab436b9b2009-12-08 23:51:10 -05003980 /*
3981 * Set transaction id's of transactions that have to be committed
3982 * to finish f[data]sync. We set them to currently running transaction
3983 * as we cannot be sure that the inode or some of its metadata isn't
3984 * part of the transaction - the inode could have been reclaimed and
3985 * now it is reread from disk.
3986 */
3987 if (journal) {
3988 transaction_t *transaction;
3989 tid_t tid;
3990
Theodore Ts'oa931da62010-08-03 21:35:12 -04003991 read_lock(&journal->j_state_lock);
Jan Karab436b9b2009-12-08 23:51:10 -05003992 if (journal->j_running_transaction)
3993 transaction = journal->j_running_transaction;
3994 else
3995 transaction = journal->j_committing_transaction;
3996 if (transaction)
3997 tid = transaction->t_tid;
3998 else
3999 tid = journal->j_commit_sequence;
Theodore Ts'oa931da62010-08-03 21:35:12 -04004000 read_unlock(&journal->j_state_lock);
Jan Karab436b9b2009-12-08 23:51:10 -05004001 ei->i_sync_tid = tid;
4002 ei->i_datasync_tid = tid;
4003 }
4004
Eric Sandeen0040d982008-02-05 22:36:43 -05004005 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004006 if (ei->i_extra_isize == 0) {
4007 /* The extra space is currently unused. Use it. */
Mingming Cao617ba132006-10-11 01:20:53 -07004008 ei->i_extra_isize = sizeof(struct ext4_inode) -
4009 EXT4_GOOD_OLD_INODE_SIZE;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004010 } else {
Tao Ma152a7b02012-12-02 11:13:24 -05004011 ext4_iget_extra_inode(inode, raw_inode, ei);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004012 }
Darrick J. Wong814525f2012-04-29 18:31:10 -04004013 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004014
Kalpak Shahef7f3832007-07-18 09:15:20 -04004015 EXT4_INODE_GET_XTIME(i_ctime, inode, raw_inode);
4016 EXT4_INODE_GET_XTIME(i_mtime, inode, raw_inode);
4017 EXT4_INODE_GET_XTIME(i_atime, inode, raw_inode);
4018 EXT4_EINODE_GET_XTIME(i_crtime, ei, raw_inode);
4019
Theodore Ts'oed3654e2014-03-24 14:09:06 -04004020 if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) {
Theodore Ts'oc4f65702014-03-20 00:32:57 -04004021 inode->i_version = le32_to_cpu(raw_inode->i_disk_version);
4022 if (EXT4_INODE_SIZE(inode->i_sb) > EXT4_GOOD_OLD_INODE_SIZE) {
4023 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
4024 inode->i_version |=
4025 (__u64)(le32_to_cpu(raw_inode->i_version_hi)) << 32;
4026 }
Jean Noel Cordenner25ec56b2008-01-28 23:58:27 -05004027 }
4028
Theodore Ts'oc4b5a612009-04-24 18:45:35 -04004029 ret = 0;
Theodore Ts'o485c26e2009-04-24 13:43:20 -04004030 if (ei->i_file_acl &&
Theodore Ts'o10329882009-11-15 15:29:56 -05004031 !ext4_data_block_valid(EXT4_SB(sb), ei->i_file_acl, 1)) {
Theodore Ts'o24676da2010-05-16 21:00:00 -04004032 EXT4_ERROR_INODE(inode, "bad extended attribute block %llu",
4033 ei->i_file_acl);
Theodore Ts'o485c26e2009-04-24 13:43:20 -04004034 ret = -EIO;
4035 goto bad_inode;
Tao Maf19d5872012-12-10 14:05:51 -05004036 } else if (!ext4_has_inline_data(inode)) {
4037 if (ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)) {
4038 if ((S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
4039 (S_ISLNK(inode->i_mode) &&
4040 !ext4_inode_is_fast_symlink(inode))))
4041 /* Validate extent which is part of inode */
4042 ret = ext4_ext_check_inode(inode);
4043 } else if (S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
4044 (S_ISLNK(inode->i_mode) &&
4045 !ext4_inode_is_fast_symlink(inode))) {
4046 /* Validate block references which are part of inode */
4047 ret = ext4_ind_check_inode(inode);
4048 }
Thiemo Nagelfe2c8192009-03-31 08:36:10 -04004049 }
Theodore Ts'o567f3e92009-11-14 08:19:05 -05004050 if (ret)
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04004051 goto bad_inode;
Aneesh Kumar K.V7a262f72009-03-27 16:39:58 -04004052
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004053 if (S_ISREG(inode->i_mode)) {
Mingming Cao617ba132006-10-11 01:20:53 -07004054 inode->i_op = &ext4_file_inode_operations;
4055 inode->i_fop = &ext4_file_operations;
4056 ext4_set_aops(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004057 } else if (S_ISDIR(inode->i_mode)) {
Mingming Cao617ba132006-10-11 01:20:53 -07004058 inode->i_op = &ext4_dir_inode_operations;
4059 inode->i_fop = &ext4_dir_operations;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004060 } else if (S_ISLNK(inode->i_mode)) {
Duane Griffine83c1392008-12-19 20:47:15 +00004061 if (ext4_inode_is_fast_symlink(inode)) {
Mingming Cao617ba132006-10-11 01:20:53 -07004062 inode->i_op = &ext4_fast_symlink_inode_operations;
Duane Griffine83c1392008-12-19 20:47:15 +00004063 nd_terminate_link(ei->i_data, inode->i_size,
4064 sizeof(ei->i_data) - 1);
4065 } else {
Mingming Cao617ba132006-10-11 01:20:53 -07004066 inode->i_op = &ext4_symlink_inode_operations;
4067 ext4_set_aops(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004068 }
Theodore Ts'o563bdd62009-03-26 00:06:19 -04004069 } else if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode) ||
4070 S_ISFIFO(inode->i_mode) || S_ISSOCK(inode->i_mode)) {
Mingming Cao617ba132006-10-11 01:20:53 -07004071 inode->i_op = &ext4_special_inode_operations;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004072 if (raw_inode->i_block[0])
4073 init_special_inode(inode, inode->i_mode,
4074 old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
4075 else
4076 init_special_inode(inode, inode->i_mode,
4077 new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
Dr. Tilmann Bubeck393d1d12013-04-08 12:54:05 -04004078 } else if (ino == EXT4_BOOT_LOADER_INO) {
4079 make_bad_inode(inode);
Theodore Ts'o563bdd62009-03-26 00:06:19 -04004080 } else {
Theodore Ts'o563bdd62009-03-26 00:06:19 -04004081 ret = -EIO;
Theodore Ts'o24676da2010-05-16 21:00:00 -04004082 EXT4_ERROR_INODE(inode, "bogus i_mode (%o)", inode->i_mode);
Theodore Ts'o563bdd62009-03-26 00:06:19 -04004083 goto bad_inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004084 }
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04004085 brelse(iloc.bh);
Mingming Cao617ba132006-10-11 01:20:53 -07004086 ext4_set_inode_flags(inode);
David Howells1d1fe1e2008-02-07 00:15:37 -08004087 unlock_new_inode(inode);
4088 return inode;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004089
4090bad_inode:
Theodore Ts'o567f3e92009-11-14 08:19:05 -05004091 brelse(iloc.bh);
David Howells1d1fe1e2008-02-07 00:15:37 -08004092 iget_failed(inode);
4093 return ERR_PTR(ret);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004094}
4095
Theodore Ts'of4bb2982014-10-05 22:56:00 -04004096struct inode *ext4_iget_normal(struct super_block *sb, unsigned long ino)
4097{
4098 if (ino < EXT4_FIRST_INO(sb) && ino != EXT4_ROOT_INO)
4099 return ERR_PTR(-EIO);
4100 return ext4_iget(sb, ino);
4101}
4102
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05004103static int ext4_inode_blocks_set(handle_t *handle,
4104 struct ext4_inode *raw_inode,
4105 struct ext4_inode_info *ei)
4106{
4107 struct inode *inode = &(ei->vfs_inode);
4108 u64 i_blocks = inode->i_blocks;
4109 struct super_block *sb = inode->i_sb;
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05004110
4111 if (i_blocks <= ~0U) {
4112 /*
Anatol Pomozov4907cb72012-09-01 10:31:09 -07004113 * i_blocks can be represented in a 32 bit variable
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05004114 * as multiple of 512 bytes
4115 */
Aneesh Kumar K.V8180a562008-01-28 23:58:27 -05004116 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05004117 raw_inode->i_blocks_high = 0;
Dmitry Monakhov84a8dce2010-06-05 11:51:27 -04004118 ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
Theodore Ts'of287a1a2008-10-16 22:50:48 -04004119 return 0;
4120 }
4121 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb, EXT4_FEATURE_RO_COMPAT_HUGE_FILE))
4122 return -EFBIG;
4123
4124 if (i_blocks <= 0xffffffffffffULL) {
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05004125 /*
4126 * i_blocks can be represented in a 48 bit variable
4127 * as multiple of 512 bytes
4128 */
Aneesh Kumar K.V8180a562008-01-28 23:58:27 -05004129 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05004130 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
Dmitry Monakhov84a8dce2010-06-05 11:51:27 -04004131 ext4_clear_inode_flag(inode, EXT4_INODE_HUGE_FILE);
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05004132 } else {
Dmitry Monakhov84a8dce2010-06-05 11:51:27 -04004133 ext4_set_inode_flag(inode, EXT4_INODE_HUGE_FILE);
Aneesh Kumar K.V8180a562008-01-28 23:58:27 -05004134 /* i_block is stored in file system block size */
4135 i_blocks = i_blocks >> (inode->i_blkbits - 9);
4136 raw_inode->i_blocks_lo = cpu_to_le32(i_blocks);
4137 raw_inode->i_blocks_high = cpu_to_le16(i_blocks >> 32);
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05004138 }
Theodore Ts'of287a1a2008-10-16 22:50:48 -04004139 return 0;
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05004140}
4141
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004142/*
4143 * Post the struct inode info into an on-disk inode location in the
4144 * buffer-cache. This gobbles the caller's reference to the
4145 * buffer_head in the inode location struct.
4146 *
4147 * The caller must have write access to iloc->bh.
4148 */
Mingming Cao617ba132006-10-11 01:20:53 -07004149static int ext4_do_update_inode(handle_t *handle,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004150 struct inode *inode,
Frank Mayhar830156c2009-09-29 10:07:47 -04004151 struct ext4_iloc *iloc)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004152{
Mingming Cao617ba132006-10-11 01:20:53 -07004153 struct ext4_inode *raw_inode = ext4_raw_inode(iloc);
4154 struct ext4_inode_info *ei = EXT4_I(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004155 struct buffer_head *bh = iloc->bh;
Theodore Ts'o202ee5d2014-04-21 14:37:55 -04004156 struct super_block *sb = inode->i_sb;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004157 int err = 0, rc, block;
Theodore Ts'o202ee5d2014-04-21 14:37:55 -04004158 int need_datasync = 0, set_large_file = 0;
Eric W. Biederman08cefc72012-02-07 15:41:49 -08004159 uid_t i_uid;
4160 gid_t i_gid;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004161
Theodore Ts'o202ee5d2014-04-21 14:37:55 -04004162 spin_lock(&ei->i_raw_lock);
4163
4164 /* For fields not tracked in the in-memory inode,
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004165 * initialise them to zero for new inodes. */
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05004166 if (ext4_test_inode_state(inode, EXT4_STATE_NEW))
Mingming Cao617ba132006-10-11 01:20:53 -07004167 memset(raw_inode, 0, EXT4_SB(inode->i_sb)->s_inode_size);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004168
Jan Karaff9ddf72007-07-18 09:24:20 -04004169 ext4_get_inode_flags(ei);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004170 raw_inode->i_mode = cpu_to_le16(inode->i_mode);
Eric W. Biederman08cefc72012-02-07 15:41:49 -08004171 i_uid = i_uid_read(inode);
4172 i_gid = i_gid_read(inode);
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04004173 if (!(test_opt(inode->i_sb, NO_UID32))) {
Eric W. Biederman08cefc72012-02-07 15:41:49 -08004174 raw_inode->i_uid_low = cpu_to_le16(low_16_bits(i_uid));
4175 raw_inode->i_gid_low = cpu_to_le16(low_16_bits(i_gid));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004176/*
4177 * Fix up interoperability with old kernels. Otherwise, old inodes get
4178 * re-used with the upper 16 bits of the uid/gid intact
4179 */
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04004180 if (!ei->i_dtime) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004181 raw_inode->i_uid_high =
Eric W. Biederman08cefc72012-02-07 15:41:49 -08004182 cpu_to_le16(high_16_bits(i_uid));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004183 raw_inode->i_gid_high =
Eric W. Biederman08cefc72012-02-07 15:41:49 -08004184 cpu_to_le16(high_16_bits(i_gid));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004185 } else {
4186 raw_inode->i_uid_high = 0;
4187 raw_inode->i_gid_high = 0;
4188 }
4189 } else {
Eric W. Biederman08cefc72012-02-07 15:41:49 -08004190 raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(i_uid));
4191 raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(i_gid));
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004192 raw_inode->i_uid_high = 0;
4193 raw_inode->i_gid_high = 0;
4194 }
4195 raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
Kalpak Shahef7f3832007-07-18 09:15:20 -04004196
4197 EXT4_INODE_SET_XTIME(i_ctime, inode, raw_inode);
4198 EXT4_INODE_SET_XTIME(i_mtime, inode, raw_inode);
4199 EXT4_INODE_SET_XTIME(i_atime, inode, raw_inode);
4200 EXT4_EINODE_SET_XTIME(i_crtime, ei, raw_inode);
4201
Li Xibce92d52014-10-01 22:11:06 -04004202 err = ext4_inode_blocks_set(handle, raw_inode, ei);
4203 if (err) {
Theodore Ts'o202ee5d2014-04-21 14:37:55 -04004204 spin_unlock(&ei->i_raw_lock);
Aneesh Kumar K.V0fc1b452008-01-28 23:58:26 -05004205 goto out_brelse;
Theodore Ts'o202ee5d2014-04-21 14:37:55 -04004206 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004207 raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
Theodore Ts'o353eb832011-01-10 12:18:25 -05004208 raw_inode->i_flags = cpu_to_le32(ei->i_flags & 0xFFFFFFFF);
Theodore Ts'oed3654e2014-03-24 14:09:06 -04004209 if (likely(!test_opt2(inode->i_sb, HURD_COMPAT)))
Badari Pulavartya1ddeb72006-10-11 01:21:09 -07004210 raw_inode->i_file_acl_high =
4211 cpu_to_le16(ei->i_file_acl >> 32);
Aneesh Kumar K.V7973c0c2008-01-28 23:58:27 -05004212 raw_inode->i_file_acl_lo = cpu_to_le32(ei->i_file_acl);
Jan Karab71fc072012-09-26 21:52:20 -04004213 if (ei->i_disksize != ext4_isize(raw_inode)) {
4214 ext4_isize_set(raw_inode, ei->i_disksize);
4215 need_datasync = 1;
4216 }
Aneesh Kumar K.Va48380f2008-01-28 23:58:27 -05004217 if (ei->i_disksize > 0x7fffffffULL) {
Aneesh Kumar K.Va48380f2008-01-28 23:58:27 -05004218 if (!EXT4_HAS_RO_COMPAT_FEATURE(sb,
4219 EXT4_FEATURE_RO_COMPAT_LARGE_FILE) ||
4220 EXT4_SB(sb)->s_es->s_rev_level ==
Theodore Ts'o202ee5d2014-04-21 14:37:55 -04004221 cpu_to_le32(EXT4_GOOD_OLD_REV))
4222 set_large_file = 1;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004223 }
4224 raw_inode->i_generation = cpu_to_le32(inode->i_generation);
4225 if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
4226 if (old_valid_dev(inode->i_rdev)) {
4227 raw_inode->i_block[0] =
4228 cpu_to_le32(old_encode_dev(inode->i_rdev));
4229 raw_inode->i_block[1] = 0;
4230 } else {
4231 raw_inode->i_block[0] = 0;
4232 raw_inode->i_block[1] =
4233 cpu_to_le32(new_encode_dev(inode->i_rdev));
4234 raw_inode->i_block[2] = 0;
4235 }
Tao Maf19d5872012-12-10 14:05:51 -05004236 } else if (!ext4_has_inline_data(inode)) {
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04004237 for (block = 0; block < EXT4_N_BLOCKS; block++)
4238 raw_inode->i_block[block] = ei->i_data[block];
Tao Maf19d5872012-12-10 14:05:51 -05004239 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004240
Theodore Ts'oed3654e2014-03-24 14:09:06 -04004241 if (likely(!test_opt2(inode->i_sb, HURD_COMPAT))) {
Theodore Ts'oc4f65702014-03-20 00:32:57 -04004242 raw_inode->i_disk_version = cpu_to_le32(inode->i_version);
4243 if (ei->i_extra_isize) {
4244 if (EXT4_FITS_IN_INODE(raw_inode, ei, i_version_hi))
4245 raw_inode->i_version_hi =
4246 cpu_to_le32(inode->i_version >> 32);
4247 raw_inode->i_extra_isize =
4248 cpu_to_le16(ei->i_extra_isize);
4249 }
Jean Noel Cordenner25ec56b2008-01-28 23:58:27 -05004250 }
4251
Darrick J. Wong814525f2012-04-29 18:31:10 -04004252 ext4_inode_csum_set(inode, raw_inode, ei);
4253
Theodore Ts'o202ee5d2014-04-21 14:37:55 -04004254 spin_unlock(&ei->i_raw_lock);
4255
Frank Mayhar830156c2009-09-29 10:07:47 -04004256 BUFFER_TRACE(bh, "call ext4_handle_dirty_metadata");
Curt Wohlgemuth73b50c12010-02-16 15:06:29 -05004257 rc = ext4_handle_dirty_metadata(handle, NULL, bh);
Frank Mayhar830156c2009-09-29 10:07:47 -04004258 if (!err)
4259 err = rc;
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05004260 ext4_clear_inode_state(inode, EXT4_STATE_NEW);
Theodore Ts'o202ee5d2014-04-21 14:37:55 -04004261 if (set_large_file) {
liang xie5d601252014-05-12 22:06:43 -04004262 BUFFER_TRACE(EXT4_SB(sb)->s_sbh, "get write access");
Theodore Ts'o202ee5d2014-04-21 14:37:55 -04004263 err = ext4_journal_get_write_access(handle, EXT4_SB(sb)->s_sbh);
4264 if (err)
4265 goto out_brelse;
4266 ext4_update_dynamic_rev(sb);
4267 EXT4_SET_RO_COMPAT_FEATURE(sb,
4268 EXT4_FEATURE_RO_COMPAT_LARGE_FILE);
4269 ext4_handle_sync(handle);
4270 err = ext4_handle_dirty_super(handle, sb);
4271 }
Jan Karab71fc072012-09-26 21:52:20 -04004272 ext4_update_inode_fsync_trans(handle, inode, need_datasync);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004273out_brelse:
Theodore Ts'oaf5bc922008-09-08 22:25:24 -04004274 brelse(bh);
Mingming Cao617ba132006-10-11 01:20:53 -07004275 ext4_std_error(inode->i_sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004276 return err;
4277}
4278
4279/*
Mingming Cao617ba132006-10-11 01:20:53 -07004280 * ext4_write_inode()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004281 *
4282 * We are called from a few places:
4283 *
Theodore Ts'o87f7e412014-04-08 11:38:28 -04004284 * - Within generic_file_aio_write() -> generic_write_sync() for O_SYNC files.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004285 * Here, there will be no transaction running. We wait for any running
Anatol Pomozov4907cb72012-09-01 10:31:09 -07004286 * transaction to commit.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004287 *
Theodore Ts'o87f7e412014-04-08 11:38:28 -04004288 * - Within flush work (sys_sync(), kupdate and such).
4289 * We wait on commit, if told to.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004290 *
Theodore Ts'o87f7e412014-04-08 11:38:28 -04004291 * - Within iput_final() -> write_inode_now()
4292 * We wait on commit, if told to.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004293 *
4294 * In all cases it is actually safe for us to return without doing anything,
4295 * because the inode has been copied into a raw inode buffer in
Theodore Ts'o87f7e412014-04-08 11:38:28 -04004296 * ext4_mark_inode_dirty(). This is a correctness thing for WB_SYNC_ALL
4297 * writeback.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004298 *
4299 * Note that we are absolutely dependent upon all inode dirtiers doing the
4300 * right thing: they *must* call mark_inode_dirty() after dirtying info in
4301 * which we are interested.
4302 *
4303 * It would be a bug for them to not do this. The code:
4304 *
4305 * mark_inode_dirty(inode)
4306 * stuff();
4307 * inode->i_size = expr;
4308 *
Theodore Ts'o87f7e412014-04-08 11:38:28 -04004309 * is in error because write_inode() could occur while `stuff()' is running,
4310 * and the new i_size will be lost. Plus the inode will no longer be on the
4311 * superblock's dirty inode list.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004312 */
Christoph Hellwiga9185b42010-03-05 09:21:37 +01004313int ext4_write_inode(struct inode *inode, struct writeback_control *wbc)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004314{
Frank Mayhar91ac6f42009-09-09 22:33:47 -04004315 int err;
4316
Theodore Ts'o87f7e412014-04-08 11:38:28 -04004317 if (WARN_ON_ONCE(current->flags & PF_MEMALLOC))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004318 return 0;
4319
Frank Mayhar91ac6f42009-09-09 22:33:47 -04004320 if (EXT4_SB(inode->i_sb)->s_journal) {
4321 if (ext4_journal_current_handle()) {
4322 jbd_debug(1, "called recursively, non-PF_MEMALLOC!\n");
4323 dump_stack();
4324 return -EIO;
4325 }
4326
Jan Kara10542c22014-03-04 10:50:50 -05004327 /*
4328 * No need to force transaction in WB_SYNC_NONE mode. Also
4329 * ext4_sync_fs() will force the commit after everything is
4330 * written.
4331 */
4332 if (wbc->sync_mode != WB_SYNC_ALL || wbc->for_sync)
Frank Mayhar91ac6f42009-09-09 22:33:47 -04004333 return 0;
4334
4335 err = ext4_force_commit(inode->i_sb);
4336 } else {
4337 struct ext4_iloc iloc;
4338
Curt Wohlgemuth8b472d72010-04-03 16:45:06 -04004339 err = __ext4_get_inode_loc(inode, &iloc, 0);
Frank Mayhar91ac6f42009-09-09 22:33:47 -04004340 if (err)
4341 return err;
Jan Kara10542c22014-03-04 10:50:50 -05004342 /*
4343 * sync(2) will flush the whole buffer cache. No need to do
4344 * it here separately for each inode.
4345 */
4346 if (wbc->sync_mode == WB_SYNC_ALL && !wbc->for_sync)
Frank Mayhar830156c2009-09-29 10:07:47 -04004347 sync_dirty_buffer(iloc.bh);
4348 if (buffer_req(iloc.bh) && !buffer_uptodate(iloc.bh)) {
Theodore Ts'oc398eda2010-07-27 11:56:40 -04004349 EXT4_ERROR_INODE_BLOCK(inode, iloc.bh->b_blocknr,
4350 "IO error syncing inode");
Frank Mayhar830156c2009-09-29 10:07:47 -04004351 err = -EIO;
4352 }
Curt Wohlgemuthfd2dd9f2010-04-03 17:44:16 -04004353 brelse(iloc.bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004354 }
Frank Mayhar91ac6f42009-09-09 22:33:47 -04004355 return err;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004356}
4357
4358/*
Jan Kara53e87262012-12-25 13:29:52 -05004359 * In data=journal mode ext4_journalled_invalidatepage() may fail to invalidate
4360 * buffers that are attached to a page stradding i_size and are undergoing
4361 * commit. In that case we have to wait for commit to finish and try again.
4362 */
4363static void ext4_wait_for_tail_page_commit(struct inode *inode)
4364{
4365 struct page *page;
4366 unsigned offset;
4367 journal_t *journal = EXT4_SB(inode->i_sb)->s_journal;
4368 tid_t commit_tid = 0;
4369 int ret;
4370
4371 offset = inode->i_size & (PAGE_CACHE_SIZE - 1);
4372 /*
4373 * All buffers in the last page remain valid? Then there's nothing to
4374 * do. We do the check mainly to optimize the common PAGE_CACHE_SIZE ==
4375 * blocksize case
4376 */
4377 if (offset > PAGE_CACHE_SIZE - (1 << inode->i_blkbits))
4378 return;
4379 while (1) {
4380 page = find_lock_page(inode->i_mapping,
4381 inode->i_size >> PAGE_CACHE_SHIFT);
4382 if (!page)
4383 return;
Lukas Czernerca99fdd2013-05-21 23:25:01 -04004384 ret = __ext4_journalled_invalidatepage(page, offset,
4385 PAGE_CACHE_SIZE - offset);
Jan Kara53e87262012-12-25 13:29:52 -05004386 unlock_page(page);
4387 page_cache_release(page);
4388 if (ret != -EBUSY)
4389 return;
4390 commit_tid = 0;
4391 read_lock(&journal->j_state_lock);
4392 if (journal->j_committing_transaction)
4393 commit_tid = journal->j_committing_transaction->t_tid;
4394 read_unlock(&journal->j_state_lock);
4395 if (commit_tid)
4396 jbd2_log_wait_commit(journal, commit_tid);
4397 }
4398}
4399
4400/*
Mingming Cao617ba132006-10-11 01:20:53 -07004401 * ext4_setattr()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004402 *
4403 * Called from notify_change.
4404 *
4405 * We want to trap VFS attempts to truncate the file as soon as
4406 * possible. In particular, we want to make sure that when the VFS
4407 * shrinks i_size, we put the inode on the orphan list and modify
4408 * i_disksize immediately, so that during the subsequent flushing of
4409 * dirty pages and freeing of disk blocks, we can guarantee that any
4410 * commit will leave the blocks being flushed in an unused state on
4411 * disk. (On recovery, the inode will get truncated and the blocks will
4412 * be freed, so we have a strong guarantee that no future commit will
4413 * leave these blocks visible to the user.)
4414 *
Jan Kara678aaf42008-07-11 19:27:31 -04004415 * Another thing we have to assure is that if we are in ordered mode
4416 * and inode is still attached to the committing transaction, we must
4417 * we start writeout of all the dirty pages which are being truncated.
4418 * This way we are sure that all the data written in the previous
4419 * transaction are already on disk (truncate waits for pages under
4420 * writeback).
4421 *
4422 * Called with inode->i_mutex down.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004423 */
Mingming Cao617ba132006-10-11 01:20:53 -07004424int ext4_setattr(struct dentry *dentry, struct iattr *attr)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004425{
4426 struct inode *inode = dentry->d_inode;
4427 int error, rc = 0;
Dmitry Monakhov3d287de2010-10-27 22:08:46 -04004428 int orphan = 0;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004429 const unsigned int ia_valid = attr->ia_valid;
4430
4431 error = inode_change_ok(inode, attr);
4432 if (error)
4433 return error;
4434
Dmitry Monakhov12755622010-04-08 22:04:20 +04004435 if (is_quota_modification(inode, attr))
Christoph Hellwig871a2932010-03-03 09:05:07 -05004436 dquot_initialize(inode);
Eric W. Biederman08cefc72012-02-07 15:41:49 -08004437 if ((ia_valid & ATTR_UID && !uid_eq(attr->ia_uid, inode->i_uid)) ||
4438 (ia_valid & ATTR_GID && !gid_eq(attr->ia_gid, inode->i_gid))) {
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004439 handle_t *handle;
4440
4441 /* (user+group)*(old+new) structure, inode write (sb,
4442 * inode block, ? - but truncate inode update has it) */
Theodore Ts'o9924a922013-02-08 21:59:22 -05004443 handle = ext4_journal_start(inode, EXT4_HT_QUOTA,
4444 (EXT4_MAXQUOTAS_INIT_BLOCKS(inode->i_sb) +
4445 EXT4_MAXQUOTAS_DEL_BLOCKS(inode->i_sb)) + 3);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004446 if (IS_ERR(handle)) {
4447 error = PTR_ERR(handle);
4448 goto err_out;
4449 }
Christoph Hellwigb43fa822010-03-03 09:05:03 -05004450 error = dquot_transfer(inode, attr);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004451 if (error) {
Mingming Cao617ba132006-10-11 01:20:53 -07004452 ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004453 return error;
4454 }
4455 /* Update corresponding info in inode so that everything is in
4456 * one transaction */
4457 if (attr->ia_valid & ATTR_UID)
4458 inode->i_uid = attr->ia_uid;
4459 if (attr->ia_valid & ATTR_GID)
4460 inode->i_gid = attr->ia_gid;
Mingming Cao617ba132006-10-11 01:20:53 -07004461 error = ext4_mark_inode_dirty(handle, inode);
4462 ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004463 }
4464
Jan Kara52083862013-08-17 10:07:17 -04004465 if (attr->ia_valid & ATTR_SIZE && attr->ia_size != inode->i_size) {
4466 handle_t *handle;
Christoph Hellwig562c72a2011-06-24 14:29:45 -04004467
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04004468 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS))) {
Eric Sandeene2b46572008-01-28 23:58:27 -05004469 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4470
Theodore Ts'o0c095c72010-07-27 11:56:06 -04004471 if (attr->ia_size > sbi->s_bitmap_maxbytes)
4472 return -EFBIG;
Eric Sandeene2b46572008-01-28 23:58:27 -05004473 }
Christoph Hellwigdff6efc2013-11-19 07:17:07 -08004474
4475 if (IS_I_VERSION(inode) && attr->ia_size != inode->i_size)
4476 inode_inc_iversion(inode);
4477
Jan Kara52083862013-08-17 10:07:17 -04004478 if (S_ISREG(inode->i_mode) &&
4479 (attr->ia_size < inode->i_size)) {
4480 if (ext4_should_order_data(inode)) {
4481 error = ext4_begin_ordered_truncate(inode,
Jan Kara678aaf42008-07-11 19:27:31 -04004482 attr->ia_size);
Jan Kara52083862013-08-17 10:07:17 -04004483 if (error)
Jan Kara678aaf42008-07-11 19:27:31 -04004484 goto err_out;
Jan Kara52083862013-08-17 10:07:17 -04004485 }
4486 handle = ext4_journal_start(inode, EXT4_HT_INODE, 3);
4487 if (IS_ERR(handle)) {
4488 error = PTR_ERR(handle);
4489 goto err_out;
4490 }
4491 if (ext4_handle_valid(handle)) {
4492 error = ext4_orphan_add(handle, inode);
4493 orphan = 1;
4494 }
Jan Kara90e775b2013-08-17 10:09:31 -04004495 down_write(&EXT4_I(inode)->i_data_sem);
Jan Kara52083862013-08-17 10:07:17 -04004496 EXT4_I(inode)->i_disksize = attr->ia_size;
4497 rc = ext4_mark_inode_dirty(handle, inode);
4498 if (!error)
4499 error = rc;
Jan Kara90e775b2013-08-17 10:09:31 -04004500 /*
4501 * We have to update i_size under i_data_sem together
4502 * with i_disksize to avoid races with writeback code
4503 * running ext4_wb_update_i_disksize().
4504 */
4505 if (!error)
4506 i_size_write(inode, attr->ia_size);
4507 up_write(&EXT4_I(inode)->i_data_sem);
Jan Kara52083862013-08-17 10:07:17 -04004508 ext4_journal_stop(handle);
4509 if (error) {
4510 ext4_orphan_del(NULL, inode);
Jan Kara678aaf42008-07-11 19:27:31 -04004511 goto err_out;
4512 }
Jan Karad6320cb2014-10-01 21:49:46 -04004513 } else {
4514 loff_t oldsize = inode->i_size;
4515
Jan Kara90e775b2013-08-17 10:09:31 -04004516 i_size_write(inode, attr->ia_size);
Jan Karad6320cb2014-10-01 21:49:46 -04004517 pagecache_isize_extended(inode, oldsize, inode->i_size);
4518 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004519
Jan Kara52083862013-08-17 10:07:17 -04004520 /*
4521 * Blocks are going to be removed from the inode. Wait
4522 * for dio in flight. Temporarily disable
4523 * dioread_nolock to prevent livelock.
4524 */
4525 if (orphan) {
4526 if (!ext4_should_journal_data(inode)) {
4527 ext4_inode_block_unlocked_dio(inode);
4528 inode_dio_wait(inode);
4529 ext4_inode_resume_unlocked_dio(inode);
4530 } else
4531 ext4_wait_for_tail_page_commit(inode);
Dmitry Monakhov1c9114f2012-09-29 00:55:23 -04004532 }
Jan Kara52083862013-08-17 10:07:17 -04004533 /*
4534 * Truncate pagecache after we've waited for commit
4535 * in data=journal mode to make pages freeable.
4536 */
Kirill A. Shutemov7caef262013-09-12 15:13:56 -07004537 truncate_pagecache(inode, inode->i_size);
Theodore Ts'o072bd7e2011-05-23 15:13:02 -04004538 }
Jan Kara52083862013-08-17 10:07:17 -04004539 /*
4540 * We want to call ext4_truncate() even if attr->ia_size ==
4541 * inode->i_size for cases like truncation of fallocated space
4542 */
4543 if (attr->ia_valid & ATTR_SIZE)
4544 ext4_truncate(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004545
Christoph Hellwig10257742010-06-04 11:30:02 +02004546 if (!rc) {
4547 setattr_copy(inode, attr);
4548 mark_inode_dirty(inode);
4549 }
4550
4551 /*
4552 * If the call to ext4_truncate failed to get a transaction handle at
4553 * all, we need to clean up the in-core orphan list manually.
4554 */
Dmitry Monakhov3d287de2010-10-27 22:08:46 -04004555 if (orphan && inode->i_nlink)
Mingming Cao617ba132006-10-11 01:20:53 -07004556 ext4_orphan_del(NULL, inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004557
4558 if (!rc && (ia_valid & ATTR_MODE))
Christoph Hellwig64e178a2013-12-20 05:16:44 -08004559 rc = posix_acl_chmod(inode, inode->i_mode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004560
4561err_out:
Mingming Cao617ba132006-10-11 01:20:53 -07004562 ext4_std_error(inode->i_sb, error);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004563 if (!error)
4564 error = rc;
4565 return error;
4566}
4567
Mingming Cao3e3398a2008-07-11 19:27:31 -04004568int ext4_getattr(struct vfsmount *mnt, struct dentry *dentry,
4569 struct kstat *stat)
4570{
4571 struct inode *inode;
Jan Kara8af8eec2013-05-31 19:39:56 -04004572 unsigned long long delalloc_blocks;
Mingming Cao3e3398a2008-07-11 19:27:31 -04004573
4574 inode = dentry->d_inode;
4575 generic_fillattr(inode, stat);
4576
4577 /*
Andreas Dilger9206c562013-11-11 22:38:12 -05004578 * If there is inline data in the inode, the inode will normally not
4579 * have data blocks allocated (it may have an external xattr block).
4580 * Report at least one sector for such files, so tools like tar, rsync,
4581 * others doen't incorrectly think the file is completely sparse.
4582 */
4583 if (unlikely(ext4_has_inline_data(inode)))
4584 stat->blocks += (stat->size + 511) >> 9;
4585
4586 /*
Mingming Cao3e3398a2008-07-11 19:27:31 -04004587 * We can't update i_blocks if the block allocation is delayed
4588 * otherwise in the case of system crash before the real block
4589 * allocation is done, we will have i_blocks inconsistent with
4590 * on-disk file blocks.
4591 * We always keep i_blocks updated together with real
4592 * allocation. But to not confuse with user, stat
4593 * will return the blocks that include the delayed allocation
4594 * blocks for this file.
4595 */
Tao Ma96607552012-05-31 22:54:16 -04004596 delalloc_blocks = EXT4_C2B(EXT4_SB(inode->i_sb),
Andreas Dilger9206c562013-11-11 22:38:12 -05004597 EXT4_I(inode)->i_reserved_data_blocks);
4598 stat->blocks += delalloc_blocks << (inode->i_sb->s_blocksize_bits - 9);
Mingming Cao3e3398a2008-07-11 19:27:31 -04004599 return 0;
4600}
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004601
Jan Karafffb2732013-06-04 13:01:11 -04004602static int ext4_index_trans_blocks(struct inode *inode, int lblocks,
4603 int pextents)
Mingming Caoa02908f2008-08-19 22:16:07 -04004604{
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04004605 if (!(ext4_test_inode_flag(inode, EXT4_INODE_EXTENTS)))
Jan Karafffb2732013-06-04 13:01:11 -04004606 return ext4_ind_trans_blocks(inode, lblocks);
4607 return ext4_ext_index_trans_blocks(inode, pextents);
Mingming Caoa02908f2008-08-19 22:16:07 -04004608}
Theodore Ts'oac51d832008-11-06 16:49:36 -05004609
Mingming Caoa02908f2008-08-19 22:16:07 -04004610/*
4611 * Account for index blocks, block groups bitmaps and block group
4612 * descriptor blocks if modify datablocks and index blocks
4613 * worse case, the indexs blocks spread over different block groups
4614 *
4615 * If datablocks are discontiguous, they are possible to spread over
Anatol Pomozov4907cb72012-09-01 10:31:09 -07004616 * different block groups too. If they are contiguous, with flexbg,
Mingming Caoa02908f2008-08-19 22:16:07 -04004617 * they could still across block group boundary.
4618 *
4619 * Also account for superblock, inode, quota and xattr blocks
4620 */
Jan Karafffb2732013-06-04 13:01:11 -04004621static int ext4_meta_trans_blocks(struct inode *inode, int lblocks,
4622 int pextents)
Mingming Caoa02908f2008-08-19 22:16:07 -04004623{
Theodore Ts'o8df96752009-05-01 08:50:38 -04004624 ext4_group_t groups, ngroups = ext4_get_groups_count(inode->i_sb);
4625 int gdpblocks;
Mingming Caoa02908f2008-08-19 22:16:07 -04004626 int idxblocks;
4627 int ret = 0;
4628
4629 /*
Jan Karafffb2732013-06-04 13:01:11 -04004630 * How many index blocks need to touch to map @lblocks logical blocks
4631 * to @pextents physical extents?
Mingming Caoa02908f2008-08-19 22:16:07 -04004632 */
Jan Karafffb2732013-06-04 13:01:11 -04004633 idxblocks = ext4_index_trans_blocks(inode, lblocks, pextents);
Mingming Caoa02908f2008-08-19 22:16:07 -04004634
4635 ret = idxblocks;
4636
4637 /*
4638 * Now let's see how many group bitmaps and group descriptors need
4639 * to account
4640 */
Jan Karafffb2732013-06-04 13:01:11 -04004641 groups = idxblocks + pextents;
Mingming Caoa02908f2008-08-19 22:16:07 -04004642 gdpblocks = groups;
Theodore Ts'o8df96752009-05-01 08:50:38 -04004643 if (groups > ngroups)
4644 groups = ngroups;
Mingming Caoa02908f2008-08-19 22:16:07 -04004645 if (groups > EXT4_SB(inode->i_sb)->s_gdb_count)
4646 gdpblocks = EXT4_SB(inode->i_sb)->s_gdb_count;
4647
4648 /* bitmaps and block group descriptor blocks */
4649 ret += groups + gdpblocks;
4650
4651 /* Blocks for super block, inode, quota and xattr blocks */
4652 ret += EXT4_META_TRANS_BLOCKS(inode->i_sb);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004653
4654 return ret;
4655}
4656
4657/*
Lucas De Marchi25985ed2011-03-30 22:57:33 -03004658 * Calculate the total number of credits to reserve to fit
Mingming Caof3bd1f32008-08-19 22:16:03 -04004659 * the modification of a single pages into a single transaction,
4660 * which may include multiple chunks of block allocations.
Mingming Caoa02908f2008-08-19 22:16:07 -04004661 *
Mingming Cao525f4ed2008-08-19 22:15:58 -04004662 * This could be called via ext4_write_begin()
Mingming Caoa02908f2008-08-19 22:16:07 -04004663 *
Mingming Cao525f4ed2008-08-19 22:15:58 -04004664 * We need to consider the worse case, when
Mingming Caoa02908f2008-08-19 22:16:07 -04004665 * one new block per extent.
Mingming Caoa02908f2008-08-19 22:16:07 -04004666 */
4667int ext4_writepage_trans_blocks(struct inode *inode)
4668{
4669 int bpp = ext4_journal_blocks_per_page(inode);
4670 int ret;
4671
Jan Karafffb2732013-06-04 13:01:11 -04004672 ret = ext4_meta_trans_blocks(inode, bpp, bpp);
Mingming Caoa02908f2008-08-19 22:16:07 -04004673
4674 /* Account for data blocks for journalled mode */
4675 if (ext4_should_journal_data(inode))
4676 ret += bpp;
4677 return ret;
4678}
Mingming Caof3bd1f32008-08-19 22:16:03 -04004679
4680/*
4681 * Calculate the journal credits for a chunk of data modification.
4682 *
4683 * This is called from DIO, fallocate or whoever calling
Eric Sandeen79e83032010-07-27 11:56:07 -04004684 * ext4_map_blocks() to map/allocate a chunk of contiguous disk blocks.
Mingming Caof3bd1f32008-08-19 22:16:03 -04004685 *
4686 * journal buffers for data blocks are not included here, as DIO
4687 * and fallocate do no need to journal data buffers.
4688 */
4689int ext4_chunk_trans_blocks(struct inode *inode, int nrblocks)
4690{
4691 return ext4_meta_trans_blocks(inode, nrblocks, 1);
4692}
4693
Mingming Caoa02908f2008-08-19 22:16:07 -04004694/*
Mingming Cao617ba132006-10-11 01:20:53 -07004695 * The caller must have previously called ext4_reserve_inode_write().
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004696 * Give this, we know that the caller already has write access to iloc->bh.
4697 */
Mingming Cao617ba132006-10-11 01:20:53 -07004698int ext4_mark_iloc_dirty(handle_t *handle,
Theodore Ts'ode9a55b2009-06-14 17:45:34 -04004699 struct inode *inode, struct ext4_iloc *iloc)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004700{
4701 int err = 0;
4702
Theodore Ts'oc64db502012-03-02 12:23:11 -05004703 if (IS_I_VERSION(inode))
Jean Noel Cordenner25ec56b2008-01-28 23:58:27 -05004704 inode_inc_iversion(inode);
4705
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004706 /* the do_update_inode consumes one bh->b_count */
4707 get_bh(iloc->bh);
4708
Mingming Caodab291a2006-10-11 01:21:01 -07004709 /* ext4_do_update_inode() does jbd2_journal_dirty_metadata */
Frank Mayhar830156c2009-09-29 10:07:47 -04004710 err = ext4_do_update_inode(handle, inode, iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004711 put_bh(iloc->bh);
4712 return err;
4713}
4714
4715/*
4716 * On success, We end up with an outstanding reference count against
4717 * iloc->bh. This _must_ be cleaned up later.
4718 */
4719
4720int
Mingming Cao617ba132006-10-11 01:20:53 -07004721ext4_reserve_inode_write(handle_t *handle, struct inode *inode,
4722 struct ext4_iloc *iloc)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004723{
Frank Mayhar03901312009-01-07 00:06:22 -05004724 int err;
4725
4726 err = ext4_get_inode_loc(inode, iloc);
4727 if (!err) {
4728 BUFFER_TRACE(iloc->bh, "get_write_access");
4729 err = ext4_journal_get_write_access(handle, iloc->bh);
4730 if (err) {
4731 brelse(iloc->bh);
4732 iloc->bh = NULL;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004733 }
4734 }
Mingming Cao617ba132006-10-11 01:20:53 -07004735 ext4_std_error(inode->i_sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004736 return err;
4737}
4738
4739/*
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04004740 * Expand an inode by new_extra_isize bytes.
4741 * Returns 0 on success or negative error number on failure.
4742 */
Aneesh Kumar K.V1d03ec92008-01-28 23:58:27 -05004743static int ext4_expand_extra_isize(struct inode *inode,
4744 unsigned int new_extra_isize,
4745 struct ext4_iloc iloc,
4746 handle_t *handle)
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04004747{
4748 struct ext4_inode *raw_inode;
4749 struct ext4_xattr_ibody_header *header;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04004750
4751 if (EXT4_I(inode)->i_extra_isize >= new_extra_isize)
4752 return 0;
4753
4754 raw_inode = ext4_raw_inode(&iloc);
4755
4756 header = IHDR(inode, raw_inode);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04004757
4758 /* No extended attributes present */
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05004759 if (!ext4_test_inode_state(inode, EXT4_STATE_XATTR) ||
4760 header->h_magic != cpu_to_le32(EXT4_XATTR_MAGIC)) {
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04004761 memset((void *)raw_inode + EXT4_GOOD_OLD_INODE_SIZE, 0,
4762 new_extra_isize);
4763 EXT4_I(inode)->i_extra_isize = new_extra_isize;
4764 return 0;
4765 }
4766
4767 /* try to expand with EAs present */
4768 return ext4_expand_extra_isize_ea(inode, new_extra_isize,
4769 raw_inode, handle);
4770}
4771
4772/*
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004773 * What we do here is to mark the in-core inode as clean with respect to inode
4774 * dirtiness (it may still be data-dirty).
4775 * This means that the in-core inode may be reaped by prune_icache
4776 * without having to perform any I/O. This is a very good thing,
4777 * because *any* task may call prune_icache - even ones which
4778 * have a transaction open against a different journal.
4779 *
4780 * Is this cheating? Not really. Sure, we haven't written the
4781 * inode out, but prune_icache isn't a user-visible syncing function.
4782 * Whenever the user wants stuff synced (sys_sync, sys_msync, sys_fsync)
4783 * we start and wait on commits.
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004784 */
Mingming Cao617ba132006-10-11 01:20:53 -07004785int ext4_mark_inode_dirty(handle_t *handle, struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004786{
Mingming Cao617ba132006-10-11 01:20:53 -07004787 struct ext4_iloc iloc;
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04004788 struct ext4_sb_info *sbi = EXT4_SB(inode->i_sb);
4789 static unsigned int mnt_count;
4790 int err, ret;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004791
4792 might_sleep();
Theodore Ts'o7ff9c072010-11-08 13:51:33 -05004793 trace_ext4_mark_inode_dirty(inode, _RET_IP_);
Mingming Cao617ba132006-10-11 01:20:53 -07004794 err = ext4_reserve_inode_write(handle, inode, &iloc);
Frank Mayhar03901312009-01-07 00:06:22 -05004795 if (ext4_handle_valid(handle) &&
4796 EXT4_I(inode)->i_extra_isize < sbi->s_want_extra_isize &&
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05004797 !ext4_test_inode_state(inode, EXT4_STATE_NO_EXPAND)) {
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04004798 /*
4799 * We need extra buffer credits since we may write into EA block
4800 * with this same handle. If journal_extend fails, then it will
4801 * only result in a minor loss of functionality for that inode.
4802 * If this is felt to be critical, then e2fsck should be run to
4803 * force a large enough s_min_extra_isize.
4804 */
4805 if ((jbd2_journal_extend(handle,
4806 EXT4_DATA_TRANS_BLOCKS(inode->i_sb))) == 0) {
4807 ret = ext4_expand_extra_isize(inode,
4808 sbi->s_want_extra_isize,
4809 iloc, handle);
4810 if (ret) {
Theodore Ts'o19f5fb72010-01-24 14:34:07 -05004811 ext4_set_inode_state(inode,
4812 EXT4_STATE_NO_EXPAND);
Aneesh Kumar K.Vc1bddad2007-10-16 18:38:25 -04004813 if (mnt_count !=
4814 le16_to_cpu(sbi->s_es->s_mnt_count)) {
Eric Sandeen12062dd2010-02-15 14:19:27 -05004815 ext4_warning(inode->i_sb,
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04004816 "Unable to expand inode %lu. Delete"
4817 " some EAs or run e2fsck.",
4818 inode->i_ino);
Aneesh Kumar K.Vc1bddad2007-10-16 18:38:25 -04004819 mnt_count =
4820 le16_to_cpu(sbi->s_es->s_mnt_count);
Kalpak Shah6dd4ee72007-07-18 09:19:57 -04004821 }
4822 }
4823 }
4824 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004825 if (!err)
Mingming Cao617ba132006-10-11 01:20:53 -07004826 err = ext4_mark_iloc_dirty(handle, inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004827 return err;
4828}
4829
4830/*
Mingming Cao617ba132006-10-11 01:20:53 -07004831 * ext4_dirty_inode() is called from __mark_inode_dirty()
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004832 *
4833 * We're really interested in the case where a file is being extended.
4834 * i_size has been changed by generic_commit_write() and we thus need
4835 * to include the updated inode in the current transaction.
4836 *
Christoph Hellwig5dd40562010-03-03 09:05:00 -05004837 * Also, dquot_alloc_block() will always dirty the inode when blocks
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004838 * are allocated to the file.
4839 *
4840 * If the inode is marked synchronous, we don't honour that here - doing
4841 * so would cause a commit on atime updates, which we don't bother doing.
4842 * We handle synchronous inodes at the highest possible level.
4843 */
Christoph Hellwigaa385722011-05-27 06:53:02 -04004844void ext4_dirty_inode(struct inode *inode, int flags)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004845{
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004846 handle_t *handle;
4847
Theodore Ts'o9924a922013-02-08 21:59:22 -05004848 handle = ext4_journal_start(inode, EXT4_HT_INODE, 2);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004849 if (IS_ERR(handle))
4850 goto out;
Curt Wohlgemuthf3dc2722009-09-29 16:06:01 -04004851
Curt Wohlgemuthf3dc2722009-09-29 16:06:01 -04004852 ext4_mark_inode_dirty(handle, inode);
4853
Mingming Cao617ba132006-10-11 01:20:53 -07004854 ext4_journal_stop(handle);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004855out:
4856 return;
4857}
4858
4859#if 0
4860/*
4861 * Bind an inode's backing buffer_head into this transaction, to prevent
4862 * it from being flushed to disk early. Unlike
Mingming Cao617ba132006-10-11 01:20:53 -07004863 * ext4_reserve_inode_write, this leaves behind no bh reference and
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004864 * returns no iloc structure, so the caller needs to repeat the iloc
4865 * lookup to mark the inode dirty later.
4866 */
Mingming Cao617ba132006-10-11 01:20:53 -07004867static int ext4_pin_inode(handle_t *handle, struct inode *inode)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004868{
Mingming Cao617ba132006-10-11 01:20:53 -07004869 struct ext4_iloc iloc;
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004870
4871 int err = 0;
4872 if (handle) {
Mingming Cao617ba132006-10-11 01:20:53 -07004873 err = ext4_get_inode_loc(inode, &iloc);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004874 if (!err) {
4875 BUFFER_TRACE(iloc.bh, "get_write_access");
Mingming Caodab291a2006-10-11 01:21:01 -07004876 err = jbd2_journal_get_write_access(handle, iloc.bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004877 if (!err)
Frank Mayhar03901312009-01-07 00:06:22 -05004878 err = ext4_handle_dirty_metadata(handle,
Curt Wohlgemuth73b50c12010-02-16 15:06:29 -05004879 NULL,
Frank Mayhar03901312009-01-07 00:06:22 -05004880 iloc.bh);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004881 brelse(iloc.bh);
4882 }
4883 }
Mingming Cao617ba132006-10-11 01:20:53 -07004884 ext4_std_error(inode->i_sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004885 return err;
4886}
4887#endif
4888
Mingming Cao617ba132006-10-11 01:20:53 -07004889int ext4_change_inode_journal_flag(struct inode *inode, int val)
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004890{
4891 journal_t *journal;
4892 handle_t *handle;
4893 int err;
4894
4895 /*
4896 * We have to be very careful here: changing a data block's
4897 * journaling status dynamically is dangerous. If we write a
4898 * data block to the journal, change the status and then delete
4899 * that block, we risk forgetting to revoke the old log record
4900 * from the journal and so a subsequent replay can corrupt data.
4901 * So, first we make sure that the journal is empty and that
4902 * nobody is changing anything.
4903 */
4904
Mingming Cao617ba132006-10-11 01:20:53 -07004905 journal = EXT4_JOURNAL(inode);
Frank Mayhar03901312009-01-07 00:06:22 -05004906 if (!journal)
4907 return 0;
Dave Hansend6995942007-07-18 08:33:51 -04004908 if (is_journal_aborted(journal))
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004909 return -EROFS;
Yongqiang Yang2aff57b2011-12-28 12:02:13 -05004910 /* We have to allocate physical blocks for delalloc blocks
4911 * before flushing journal. otherwise delalloc blocks can not
4912 * be allocated any more. even more truncate on delalloc blocks
4913 * could trigger BUG by flushing delalloc blocks in journal.
4914 * There is no delalloc block in non-journal data mode.
4915 */
4916 if (val && test_opt(inode->i_sb, DELALLOC)) {
4917 err = ext4_alloc_da_blocks(inode);
4918 if (err < 0)
4919 return err;
4920 }
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004921
Dmitry Monakhov17335dc2012-09-29 00:41:21 -04004922 /* Wait for all existing dio workers */
4923 ext4_inode_block_unlocked_dio(inode);
4924 inode_dio_wait(inode);
4925
Mingming Caodab291a2006-10-11 01:21:01 -07004926 jbd2_journal_lock_updates(journal);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004927
4928 /*
4929 * OK, there are no updates running now, and all cached data is
4930 * synced to disk. We are now in a completely consistent state
4931 * which doesn't have anything in the journal, and we know that
4932 * no filesystem updates are running, so it is safe to modify
4933 * the inode's in-core data-journaling state flag now.
4934 */
4935
4936 if (val)
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04004937 ext4_set_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
Yongqiang Yang5872dda2011-12-28 13:55:51 -05004938 else {
Jan Kara4f879ca2014-10-30 10:53:17 -04004939 err = jbd2_journal_flush(journal);
4940 if (err < 0) {
4941 jbd2_journal_unlock_updates(journal);
4942 ext4_inode_resume_unlocked_dio(inode);
4943 return err;
4944 }
Dmitry Monakhov12e9b892010-05-16 22:00:00 -04004945 ext4_clear_inode_flag(inode, EXT4_INODE_JOURNAL_DATA);
Yongqiang Yang5872dda2011-12-28 13:55:51 -05004946 }
Mingming Cao617ba132006-10-11 01:20:53 -07004947 ext4_set_aops(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004948
Mingming Caodab291a2006-10-11 01:21:01 -07004949 jbd2_journal_unlock_updates(journal);
Dmitry Monakhov17335dc2012-09-29 00:41:21 -04004950 ext4_inode_resume_unlocked_dio(inode);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004951
4952 /* Finally we can mark the inode as dirty. */
4953
Theodore Ts'o9924a922013-02-08 21:59:22 -05004954 handle = ext4_journal_start(inode, EXT4_HT_INODE, 1);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004955 if (IS_ERR(handle))
4956 return PTR_ERR(handle);
4957
Mingming Cao617ba132006-10-11 01:20:53 -07004958 err = ext4_mark_inode_dirty(handle, inode);
Frank Mayhar03901312009-01-07 00:06:22 -05004959 ext4_handle_sync(handle);
Mingming Cao617ba132006-10-11 01:20:53 -07004960 ext4_journal_stop(handle);
4961 ext4_std_error(inode->i_sb, err);
Dave Kleikampac27a0e2006-10-11 01:20:50 -07004962
4963 return err;
4964}
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04004965
4966static int ext4_bh_unmapped(handle_t *handle, struct buffer_head *bh)
4967{
4968 return !buffer_mapped(bh);
4969}
4970
Nick Pigginc2ec1752009-03-31 15:23:21 -07004971int ext4_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04004972{
Nick Pigginc2ec1752009-03-31 15:23:21 -07004973 struct page *page = vmf->page;
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04004974 loff_t size;
4975 unsigned long len;
Jan Kara9ea7df52011-06-24 14:29:41 -04004976 int ret;
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04004977 struct file *file = vma->vm_file;
Al Viro496ad9a2013-01-23 17:07:38 -05004978 struct inode *inode = file_inode(file);
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04004979 struct address_space *mapping = inode->i_mapping;
Jan Kara9ea7df52011-06-24 14:29:41 -04004980 handle_t *handle;
4981 get_block_t *get_block;
4982 int retries = 0;
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04004983
Jan Kara8e8ad8a2012-06-12 16:20:38 +02004984 sb_start_pagefault(inode->i_sb);
Theodore Ts'o041bbb6d2012-09-30 23:04:56 -04004985 file_update_time(vma->vm_file);
Jan Kara9ea7df52011-06-24 14:29:41 -04004986 /* Delalloc case is easy... */
4987 if (test_opt(inode->i_sb, DELALLOC) &&
4988 !ext4_should_journal_data(inode) &&
4989 !ext4_nonda_switch(inode->i_sb)) {
4990 do {
4991 ret = __block_page_mkwrite(vma, vmf,
4992 ext4_da_get_block_prep);
4993 } while (ret == -ENOSPC &&
4994 ext4_should_retry_alloc(inode->i_sb, &retries));
4995 goto out_ret;
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04004996 }
Darrick J. Wong0e499892011-05-18 13:55:20 -04004997
4998 lock_page(page);
Jan Kara9ea7df52011-06-24 14:29:41 -04004999 size = i_size_read(inode);
5000 /* Page got truncated from under us? */
5001 if (page->mapping != mapping || page_offset(page) > size) {
5002 unlock_page(page);
5003 ret = VM_FAULT_NOPAGE;
5004 goto out;
Darrick J. Wong0e499892011-05-18 13:55:20 -04005005 }
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04005006
5007 if (page->index == size >> PAGE_CACHE_SHIFT)
5008 len = size & ~PAGE_CACHE_MASK;
5009 else
5010 len = PAGE_CACHE_SIZE;
Aneesh Kumar K.Va827eaf2009-09-09 22:36:03 -04005011 /*
Jan Kara9ea7df52011-06-24 14:29:41 -04005012 * Return if we have all the buffers mapped. This avoids the need to do
5013 * journal_start/journal_stop which can block and take a long time
Aneesh Kumar K.Va827eaf2009-09-09 22:36:03 -04005014 */
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04005015 if (page_has_buffers(page)) {
Tao Maf19d5872012-12-10 14:05:51 -05005016 if (!ext4_walk_page_buffers(NULL, page_buffers(page),
5017 0, len, NULL,
5018 ext4_bh_unmapped)) {
Jan Kara9ea7df52011-06-24 14:29:41 -04005019 /* Wait so that we don't change page under IO */
Darrick J. Wong1d1d1a72013-02-21 16:42:51 -08005020 wait_for_stable_page(page);
Jan Kara9ea7df52011-06-24 14:29:41 -04005021 ret = VM_FAULT_LOCKED;
5022 goto out;
Aneesh Kumar K.Va827eaf2009-09-09 22:36:03 -04005023 }
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04005024 }
Aneesh Kumar K.Va827eaf2009-09-09 22:36:03 -04005025 unlock_page(page);
Jan Kara9ea7df52011-06-24 14:29:41 -04005026 /* OK, we need to fill the hole... */
5027 if (ext4_should_dioread_nolock(inode))
5028 get_block = ext4_get_block_write;
5029 else
5030 get_block = ext4_get_block;
5031retry_alloc:
Theodore Ts'o9924a922013-02-08 21:59:22 -05005032 handle = ext4_journal_start(inode, EXT4_HT_WRITE_PAGE,
5033 ext4_writepage_trans_blocks(inode));
Jan Kara9ea7df52011-06-24 14:29:41 -04005034 if (IS_ERR(handle)) {
Nick Pigginc2ec1752009-03-31 15:23:21 -07005035 ret = VM_FAULT_SIGBUS;
Jan Kara9ea7df52011-06-24 14:29:41 -04005036 goto out;
5037 }
5038 ret = __block_page_mkwrite(vma, vmf, get_block);
5039 if (!ret && ext4_should_journal_data(inode)) {
Tao Maf19d5872012-12-10 14:05:51 -05005040 if (ext4_walk_page_buffers(handle, page_buffers(page), 0,
Jan Kara9ea7df52011-06-24 14:29:41 -04005041 PAGE_CACHE_SIZE, NULL, do_journal_get_write_access)) {
5042 unlock_page(page);
5043 ret = VM_FAULT_SIGBUS;
Yongqiang Yangfcbb5512011-10-26 05:00:19 -04005044 ext4_journal_stop(handle);
Jan Kara9ea7df52011-06-24 14:29:41 -04005045 goto out;
5046 }
5047 ext4_set_inode_state(inode, EXT4_STATE_JDATA);
5048 }
5049 ext4_journal_stop(handle);
5050 if (ret == -ENOSPC && ext4_should_retry_alloc(inode->i_sb, &retries))
5051 goto retry_alloc;
5052out_ret:
5053 ret = block_page_mkwrite_return(ret);
5054out:
Jan Kara8e8ad8a2012-06-12 16:20:38 +02005055 sb_end_pagefault(inode->i_sb);
Aneesh Kumar K.V2e9ee852008-07-11 19:27:31 -04005056 return ret;
5057}