blob: c26d046adaaace43d9ffdfeae82a404819f0ec1f [file] [log] [blame]
Mark Fashehccd979b2005-12-15 14:31:24 -08001/* -*- mode: c; c-basic-offset: 8; -*-
2 * vim: noexpandtab sw=8 ts=8 sts=0:
3 *
4 * Copyright (C) 2002, 2004 Oracle. All rights reserved.
5 *
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public
17 * License along with this program; if not, write to the
18 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 * Boston, MA 021110-1307, USA.
20 */
21
22#include <linux/fs.h>
23#include <linux/slab.h>
24#include <linux/highmem.h>
25#include <linux/pagemap.h>
26#include <asm/byteorder.h>
Mark Fasheh9517bac2007-02-09 20:24:12 -080027#include <linux/swap.h>
Mark Fasheh6af67d82007-03-06 17:24:46 -080028#include <linux/pipe_fs_i.h>
Mark Fasheh628a24f2007-10-30 12:08:32 -070029#include <linux/mpage.h>
Jan Karaa90714c2008-10-09 19:38:40 +020030#include <linux/quotaops.h>
Joseph Qi24c40b32015-02-16 16:00:00 -080031#include <linux/blkdev.h>
Christoph Hellwige2e40f22015-02-22 08:58:50 -080032#include <linux/uio.h>
Mark Fashehccd979b2005-12-15 14:31:24 -080033
Mark Fashehccd979b2005-12-15 14:31:24 -080034#include <cluster/masklog.h>
35
36#include "ocfs2.h"
37
38#include "alloc.h"
39#include "aops.h"
40#include "dlmglue.h"
41#include "extent_map.h"
42#include "file.h"
43#include "inode.h"
44#include "journal.h"
Mark Fasheh9517bac2007-02-09 20:24:12 -080045#include "suballoc.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080046#include "super.h"
47#include "symlink.h"
Tao Ma293b2f72009-08-25 08:02:48 +080048#include "refcounttree.h"
Tao Ma95581562011-02-22 21:33:59 +080049#include "ocfs2_trace.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080050
51#include "buffer_head_io.h"
Joseph Qi24c40b32015-02-16 16:00:00 -080052#include "dir.h"
53#include "namei.h"
54#include "sysfile.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080055
56static int ocfs2_symlink_get_block(struct inode *inode, sector_t iblock,
57 struct buffer_head *bh_result, int create)
58{
59 int err = -EIO;
60 int status;
61 struct ocfs2_dinode *fe = NULL;
62 struct buffer_head *bh = NULL;
63 struct buffer_head *buffer_cache_bh = NULL;
64 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
65 void *kaddr;
66
Tao Ma95581562011-02-22 21:33:59 +080067 trace_ocfs2_symlink_get_block(
68 (unsigned long long)OCFS2_I(inode)->ip_blkno,
69 (unsigned long long)iblock, bh_result, create);
Mark Fashehccd979b2005-12-15 14:31:24 -080070
71 BUG_ON(ocfs2_inode_is_fast_symlink(inode));
72
73 if ((iblock << inode->i_sb->s_blocksize_bits) > PATH_MAX + 1) {
74 mlog(ML_ERROR, "block offset > PATH_MAX: %llu",
75 (unsigned long long)iblock);
76 goto bail;
77 }
78
Joel Beckerb657c952008-11-13 14:49:11 -080079 status = ocfs2_read_inode_block(inode, &bh);
Mark Fashehccd979b2005-12-15 14:31:24 -080080 if (status < 0) {
81 mlog_errno(status);
82 goto bail;
83 }
84 fe = (struct ocfs2_dinode *) bh->b_data;
85
Mark Fashehccd979b2005-12-15 14:31:24 -080086 if ((u64)iblock >= ocfs2_clusters_to_blocks(inode->i_sb,
87 le32_to_cpu(fe->i_clusters))) {
Rui Xiang7391a292013-11-12 15:06:54 -080088 err = -ENOMEM;
Mark Fashehccd979b2005-12-15 14:31:24 -080089 mlog(ML_ERROR, "block offset is outside the allocated size: "
90 "%llu\n", (unsigned long long)iblock);
91 goto bail;
92 }
93
94 /* We don't use the page cache to create symlink data, so if
95 * need be, copy it over from the buffer cache. */
96 if (!buffer_uptodate(bh_result) && ocfs2_inode_is_new(inode)) {
97 u64 blkno = le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) +
98 iblock;
99 buffer_cache_bh = sb_getblk(osb->sb, blkno);
100 if (!buffer_cache_bh) {
Rui Xiang7391a292013-11-12 15:06:54 -0800101 err = -ENOMEM;
Mark Fashehccd979b2005-12-15 14:31:24 -0800102 mlog(ML_ERROR, "couldn't getblock for symlink!\n");
103 goto bail;
104 }
105
106 /* we haven't locked out transactions, so a commit
107 * could've happened. Since we've got a reference on
108 * the bh, even if it commits while we're doing the
109 * copy, the data is still good. */
110 if (buffer_jbd(buffer_cache_bh)
111 && ocfs2_inode_is_new(inode)) {
Cong Wangc4bc8dc2011-11-25 23:14:34 +0800112 kaddr = kmap_atomic(bh_result->b_page);
Mark Fashehccd979b2005-12-15 14:31:24 -0800113 if (!kaddr) {
114 mlog(ML_ERROR, "couldn't kmap!\n");
115 goto bail;
116 }
117 memcpy(kaddr + (bh_result->b_size * iblock),
118 buffer_cache_bh->b_data,
119 bh_result->b_size);
Cong Wangc4bc8dc2011-11-25 23:14:34 +0800120 kunmap_atomic(kaddr);
Mark Fashehccd979b2005-12-15 14:31:24 -0800121 set_buffer_uptodate(bh_result);
122 }
123 brelse(buffer_cache_bh);
124 }
125
126 map_bh(bh_result, inode->i_sb,
127 le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) + iblock);
128
129 err = 0;
130
131bail:
Mark Fasheha81cb882008-10-07 14:25:16 -0700132 brelse(bh);
Mark Fashehccd979b2005-12-15 14:31:24 -0800133
Mark Fashehccd979b2005-12-15 14:31:24 -0800134 return err;
135}
136
alex chen78a65502017-11-15 17:31:44 -0800137static int ocfs2_lock_get_block(struct inode *inode, sector_t iblock,
138 struct buffer_head *bh_result, int create)
139{
140 int ret = 0;
141 struct ocfs2_inode_info *oi = OCFS2_I(inode);
142
143 down_read(&oi->ip_alloc_sem);
144 ret = ocfs2_get_block(inode, iblock, bh_result, create);
145 up_read(&oi->ip_alloc_sem);
146
147 return ret;
148}
149
Tao Ma6f70fa52009-08-25 08:05:12 +0800150int ocfs2_get_block(struct inode *inode, sector_t iblock,
151 struct buffer_head *bh_result, int create)
Mark Fashehccd979b2005-12-15 14:31:24 -0800152{
153 int err = 0;
Mark Fasheh49cb8d22007-03-09 16:21:46 -0800154 unsigned int ext_flags;
Mark Fasheh628a24f2007-10-30 12:08:32 -0700155 u64 max_blocks = bh_result->b_size >> inode->i_blkbits;
156 u64 p_blkno, count, past_eof;
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800157 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Mark Fashehccd979b2005-12-15 14:31:24 -0800158
Tao Ma95581562011-02-22 21:33:59 +0800159 trace_ocfs2_get_block((unsigned long long)OCFS2_I(inode)->ip_blkno,
160 (unsigned long long)iblock, bh_result, create);
Mark Fashehccd979b2005-12-15 14:31:24 -0800161
162 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE)
163 mlog(ML_NOTICE, "get_block on system inode 0x%p (%lu)\n",
164 inode, inode->i_ino);
165
166 if (S_ISLNK(inode->i_mode)) {
167 /* this always does I/O for some reason. */
168 err = ocfs2_symlink_get_block(inode, iblock, bh_result, create);
169 goto bail;
170 }
171
Mark Fasheh628a24f2007-10-30 12:08:32 -0700172 err = ocfs2_extent_map_get_blocks(inode, iblock, &p_blkno, &count,
Mark Fasheh49cb8d22007-03-09 16:21:46 -0800173 &ext_flags);
Mark Fashehccd979b2005-12-15 14:31:24 -0800174 if (err) {
175 mlog(ML_ERROR, "Error %d from get_blocks(0x%p, %llu, 1, "
Mark Fashehb06970532006-03-03 10:24:33 -0800176 "%llu, NULL)\n", err, inode, (unsigned long long)iblock,
177 (unsigned long long)p_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800178 goto bail;
179 }
180
Mark Fasheh628a24f2007-10-30 12:08:32 -0700181 if (max_blocks < count)
182 count = max_blocks;
183
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800184 /*
185 * ocfs2 never allocates in this function - the only time we
186 * need to use BH_New is when we're extending i_size on a file
187 * system which doesn't support holes, in which case BH_New
Christoph Hellwigebdec242010-10-06 10:47:23 +0200188 * allows __block_write_begin() to zero.
Coly Lic0420ad2008-06-30 18:45:45 +0800189 *
190 * If we see this on a sparse file system, then a truncate has
191 * raced us and removed the cluster. In this case, we clear
192 * the buffers dirty and uptodate bits and let the buffer code
193 * ignore it as a hole.
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800194 */
Coly Lic0420ad2008-06-30 18:45:45 +0800195 if (create && p_blkno == 0 && ocfs2_sparse_alloc(osb)) {
196 clear_buffer_dirty(bh_result);
197 clear_buffer_uptodate(bh_result);
198 goto bail;
199 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800200
Mark Fasheh49cb8d22007-03-09 16:21:46 -0800201 /* Treat the unwritten extent as a hole for zeroing purposes. */
202 if (p_blkno && !(ext_flags & OCFS2_EXT_UNWRITTEN))
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800203 map_bh(bh_result, inode->i_sb, p_blkno);
204
Mark Fasheh628a24f2007-10-30 12:08:32 -0700205 bh_result->b_size = count << inode->i_blkbits;
206
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800207 if (!ocfs2_sparse_alloc(osb)) {
208 if (p_blkno == 0) {
209 err = -EIO;
210 mlog(ML_ERROR,
211 "iblock = %llu p_blkno = %llu blkno=(%llu)\n",
212 (unsigned long long)iblock,
213 (unsigned long long)p_blkno,
214 (unsigned long long)OCFS2_I(inode)->ip_blkno);
215 mlog(ML_ERROR, "Size %llu, clusters %u\n", (unsigned long long)i_size_read(inode), OCFS2_I(inode)->ip_clusters);
216 dump_stack();
Wengang Wang1f4cea32009-07-13 11:38:58 +0800217 goto bail;
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800218 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800219 }
220
Joel Becker56934862010-07-01 15:13:31 -0700221 past_eof = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));
Tao Ma95581562011-02-22 21:33:59 +0800222
223 trace_ocfs2_get_block_end((unsigned long long)OCFS2_I(inode)->ip_blkno,
224 (unsigned long long)past_eof);
Joel Becker56934862010-07-01 15:13:31 -0700225 if (create && (iblock >= past_eof))
226 set_buffer_new(bh_result);
227
Mark Fashehccd979b2005-12-15 14:31:24 -0800228bail:
229 if (err < 0)
230 err = -EIO;
231
Mark Fashehccd979b2005-12-15 14:31:24 -0800232 return err;
233}
234
Mark Fasheh1afc32b2007-09-07 14:46:51 -0700235int ocfs2_read_inline_data(struct inode *inode, struct page *page,
236 struct buffer_head *di_bh)
Mark Fasheh6798d352007-09-07 14:05:51 -0700237{
238 void *kaddr;
Jan Karad2849fb2007-12-19 15:24:09 +0100239 loff_t size;
Mark Fasheh6798d352007-09-07 14:05:51 -0700240 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
241
242 if (!(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL)) {
Joe Perches7ecef142015-09-04 15:44:51 -0700243 ocfs2_error(inode->i_sb, "Inode %llu lost inline data flag\n",
Mark Fasheh6798d352007-09-07 14:05:51 -0700244 (unsigned long long)OCFS2_I(inode)->ip_blkno);
245 return -EROFS;
246 }
247
248 size = i_size_read(inode);
249
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300250 if (size > PAGE_SIZE ||
Tiger Yangd9ae49d2009-03-05 11:06:15 +0800251 size > ocfs2_max_inline_data_with_xattr(inode->i_sb, di)) {
Mark Fasheh6798d352007-09-07 14:05:51 -0700252 ocfs2_error(inode->i_sb,
Joe Perches7ecef142015-09-04 15:44:51 -0700253 "Inode %llu has with inline data has bad size: %Lu\n",
Jan Karad2849fb2007-12-19 15:24:09 +0100254 (unsigned long long)OCFS2_I(inode)->ip_blkno,
255 (unsigned long long)size);
Mark Fasheh6798d352007-09-07 14:05:51 -0700256 return -EROFS;
257 }
258
Cong Wangc4bc8dc2011-11-25 23:14:34 +0800259 kaddr = kmap_atomic(page);
Mark Fasheh6798d352007-09-07 14:05:51 -0700260 if (size)
261 memcpy(kaddr, di->id2.i_data.id_data, size);
262 /* Clear the remaining part of the page */
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300263 memset(kaddr + size, 0, PAGE_SIZE - size);
Mark Fasheh6798d352007-09-07 14:05:51 -0700264 flush_dcache_page(page);
Cong Wangc4bc8dc2011-11-25 23:14:34 +0800265 kunmap_atomic(kaddr);
Mark Fasheh6798d352007-09-07 14:05:51 -0700266
267 SetPageUptodate(page);
268
269 return 0;
270}
271
272static int ocfs2_readpage_inline(struct inode *inode, struct page *page)
273{
274 int ret;
275 struct buffer_head *di_bh = NULL;
Mark Fasheh6798d352007-09-07 14:05:51 -0700276
277 BUG_ON(!PageLocked(page));
Julia Lawall86c838b2008-02-26 21:45:56 +0100278 BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL));
Mark Fasheh6798d352007-09-07 14:05:51 -0700279
Joel Beckerb657c952008-11-13 14:49:11 -0800280 ret = ocfs2_read_inode_block(inode, &di_bh);
Mark Fasheh6798d352007-09-07 14:05:51 -0700281 if (ret) {
282 mlog_errno(ret);
283 goto out;
284 }
285
286 ret = ocfs2_read_inline_data(inode, page, di_bh);
287out:
288 unlock_page(page);
289
290 brelse(di_bh);
291 return ret;
292}
293
Mark Fashehccd979b2005-12-15 14:31:24 -0800294static int ocfs2_readpage(struct file *file, struct page *page)
295{
296 struct inode *inode = page->mapping->host;
Mark Fasheh6798d352007-09-07 14:05:51 -0700297 struct ocfs2_inode_info *oi = OCFS2_I(inode);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300298 loff_t start = (loff_t)page->index << PAGE_SHIFT;
Mark Fashehccd979b2005-12-15 14:31:24 -0800299 int ret, unlock = 1;
300
Tao Ma95581562011-02-22 21:33:59 +0800301 trace_ocfs2_readpage((unsigned long long)oi->ip_blkno,
302 (page ? page->index : 0));
Mark Fashehccd979b2005-12-15 14:31:24 -0800303
Mark Fashehe63aecb62007-10-18 15:30:42 -0700304 ret = ocfs2_inode_lock_with_page(inode, NULL, 0, page);
Mark Fashehccd979b2005-12-15 14:31:24 -0800305 if (ret != 0) {
306 if (ret == AOP_TRUNCATED_PAGE)
307 unlock = 0;
308 mlog_errno(ret);
309 goto out;
310 }
311
Mark Fasheh6798d352007-09-07 14:05:51 -0700312 if (down_read_trylock(&oi->ip_alloc_sem) == 0) {
Jan Karac7e25e62011-06-23 22:51:47 +0200313 /*
314 * Unlock the page and cycle ip_alloc_sem so that we don't
315 * busyloop waiting for ip_alloc_sem to unlock
316 */
Mark Fashehe9dfc0b2007-05-14 11:38:51 -0700317 ret = AOP_TRUNCATED_PAGE;
Jan Karac7e25e62011-06-23 22:51:47 +0200318 unlock_page(page);
319 unlock = 0;
320 down_read(&oi->ip_alloc_sem);
321 up_read(&oi->ip_alloc_sem);
Mark Fashehe63aecb62007-10-18 15:30:42 -0700322 goto out_inode_unlock;
Mark Fashehe9dfc0b2007-05-14 11:38:51 -0700323 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800324
325 /*
326 * i_size might have just been updated as we grabed the meta lock. We
327 * might now be discovering a truncate that hit on another node.
328 * block_read_full_page->get_block freaks out if it is asked to read
329 * beyond the end of a file, so we check here. Callers
Nick Piggin54cb8822007-07-19 01:46:59 -0700330 * (generic_file_read, vm_ops->fault) are clever enough to check i_size
Mark Fashehccd979b2005-12-15 14:31:24 -0800331 * and notice that the page they just read isn't needed.
332 *
333 * XXX sys_readahead() seems to get that wrong?
334 */
335 if (start >= i_size_read(inode)) {
Christoph Lametereebd2aa2008-02-04 22:28:29 -0800336 zero_user(page, 0, PAGE_SIZE);
Mark Fashehccd979b2005-12-15 14:31:24 -0800337 SetPageUptodate(page);
338 ret = 0;
339 goto out_alloc;
340 }
341
Mark Fasheh6798d352007-09-07 14:05:51 -0700342 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
343 ret = ocfs2_readpage_inline(inode, page);
344 else
345 ret = block_read_full_page(page, ocfs2_get_block);
Mark Fashehccd979b2005-12-15 14:31:24 -0800346 unlock = 0;
347
Mark Fashehccd979b2005-12-15 14:31:24 -0800348out_alloc:
349 up_read(&OCFS2_I(inode)->ip_alloc_sem);
Mark Fashehe63aecb62007-10-18 15:30:42 -0700350out_inode_unlock:
351 ocfs2_inode_unlock(inode, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -0800352out:
353 if (unlock)
354 unlock_page(page);
Mark Fashehccd979b2005-12-15 14:31:24 -0800355 return ret;
356}
357
Mark Fasheh628a24f2007-10-30 12:08:32 -0700358/*
359 * This is used only for read-ahead. Failures or difficult to handle
360 * situations are safe to ignore.
361 *
362 * Right now, we don't bother with BH_Boundary - in-inode extent lists
363 * are quite large (243 extents on 4k blocks), so most inodes don't
364 * grow out to a tree. If need be, detecting boundary extents could
365 * trivially be added in a future version of ocfs2_get_block().
366 */
367static int ocfs2_readpages(struct file *filp, struct address_space *mapping,
368 struct list_head *pages, unsigned nr_pages)
369{
370 int ret, err = -EIO;
371 struct inode *inode = mapping->host;
372 struct ocfs2_inode_info *oi = OCFS2_I(inode);
373 loff_t start;
374 struct page *last;
375
376 /*
377 * Use the nonblocking flag for the dlm code to avoid page
378 * lock inversion, but don't bother with retrying.
379 */
380 ret = ocfs2_inode_lock_full(inode, NULL, 0, OCFS2_LOCK_NONBLOCK);
381 if (ret)
382 return err;
383
384 if (down_read_trylock(&oi->ip_alloc_sem) == 0) {
385 ocfs2_inode_unlock(inode, 0);
386 return err;
387 }
388
389 /*
390 * Don't bother with inline-data. There isn't anything
391 * to read-ahead in that case anyway...
392 */
393 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
394 goto out_unlock;
395
396 /*
397 * Check whether a remote node truncated this file - we just
398 * drop out in that case as it's not worth handling here.
399 */
400 last = list_entry(pages->prev, struct page, lru);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300401 start = (loff_t)last->index << PAGE_SHIFT;
Mark Fasheh628a24f2007-10-30 12:08:32 -0700402 if (start >= i_size_read(inode))
403 goto out_unlock;
404
405 err = mpage_readpages(mapping, pages, nr_pages, ocfs2_get_block);
406
407out_unlock:
408 up_read(&oi->ip_alloc_sem);
409 ocfs2_inode_unlock(inode, 0);
410
411 return err;
412}
413
Mark Fashehccd979b2005-12-15 14:31:24 -0800414/* Note: Because we don't support holes, our allocation has
415 * already happened (allocation writes zeros to the file data)
416 * so we don't have to worry about ordered writes in
417 * ocfs2_writepage.
418 *
419 * ->writepage is called during the process of invalidating the page cache
420 * during blocked lock processing. It can't block on any cluster locks
421 * to during block mapping. It's relying on the fact that the block
422 * mapping can't have disappeared under the dirty pages that it is
423 * being asked to write back.
424 */
425static int ocfs2_writepage(struct page *page, struct writeback_control *wbc)
426{
Tao Ma95581562011-02-22 21:33:59 +0800427 trace_ocfs2_writepage(
428 (unsigned long long)OCFS2_I(page->mapping->host)->ip_blkno,
429 page->index);
Mark Fashehccd979b2005-12-15 14:31:24 -0800430
Tao Ma95581562011-02-22 21:33:59 +0800431 return block_write_full_page(page, ocfs2_get_block, wbc);
Mark Fashehccd979b2005-12-15 14:31:24 -0800432}
433
Mark Fashehccd979b2005-12-15 14:31:24 -0800434/* Taken from ext3. We don't necessarily need the full blown
435 * functionality yet, but IMHO it's better to cut and paste the whole
436 * thing so we can avoid introducing our own bugs (and easily pick up
437 * their fixes when they happen) --Mark */
Mark Fasheh60b11392007-02-16 11:46:50 -0800438int walk_page_buffers( handle_t *handle,
439 struct buffer_head *head,
440 unsigned from,
441 unsigned to,
442 int *partial,
443 int (*fn)( handle_t *handle,
444 struct buffer_head *bh))
Mark Fashehccd979b2005-12-15 14:31:24 -0800445{
446 struct buffer_head *bh;
447 unsigned block_start, block_end;
448 unsigned blocksize = head->b_size;
449 int err, ret = 0;
450 struct buffer_head *next;
451
452 for ( bh = head, block_start = 0;
453 ret == 0 && (bh != head || !block_start);
454 block_start = block_end, bh = next)
455 {
456 next = bh->b_this_page;
457 block_end = block_start + blocksize;
458 if (block_end <= from || block_start >= to) {
459 if (partial && !buffer_uptodate(bh))
460 *partial = 1;
461 continue;
462 }
463 err = (*fn)(handle, bh);
464 if (!ret)
465 ret = err;
466 }
467 return ret;
468}
469
Mark Fashehccd979b2005-12-15 14:31:24 -0800470static sector_t ocfs2_bmap(struct address_space *mapping, sector_t block)
471{
472 sector_t status;
473 u64 p_blkno = 0;
474 int err = 0;
475 struct inode *inode = mapping->host;
476
Tao Ma95581562011-02-22 21:33:59 +0800477 trace_ocfs2_bmap((unsigned long long)OCFS2_I(inode)->ip_blkno,
478 (unsigned long long)block);
Mark Fashehccd979b2005-12-15 14:31:24 -0800479
480 /* We don't need to lock journal system files, since they aren't
481 * accessed concurrently from multiple nodes.
482 */
483 if (!INODE_JOURNAL(inode)) {
Mark Fashehe63aecb62007-10-18 15:30:42 -0700484 err = ocfs2_inode_lock(inode, NULL, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -0800485 if (err) {
486 if (err != -ENOENT)
487 mlog_errno(err);
488 goto bail;
489 }
490 down_read(&OCFS2_I(inode)->ip_alloc_sem);
491 }
492
Mark Fasheh6798d352007-09-07 14:05:51 -0700493 if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL))
494 err = ocfs2_extent_map_get_blocks(inode, block, &p_blkno, NULL,
495 NULL);
Mark Fashehccd979b2005-12-15 14:31:24 -0800496
497 if (!INODE_JOURNAL(inode)) {
498 up_read(&OCFS2_I(inode)->ip_alloc_sem);
Mark Fashehe63aecb62007-10-18 15:30:42 -0700499 ocfs2_inode_unlock(inode, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -0800500 }
501
502 if (err) {
503 mlog(ML_ERROR, "get_blocks() failed, block = %llu\n",
504 (unsigned long long)block);
505 mlog_errno(err);
506 goto bail;
507 }
508
Mark Fashehccd979b2005-12-15 14:31:24 -0800509bail:
510 status = err ? 0 : p_blkno;
511
Mark Fashehccd979b2005-12-15 14:31:24 -0800512 return status;
513}
514
Joel Becker03f981c2007-01-04 14:54:41 -0800515static int ocfs2_releasepage(struct page *page, gfp_t wait)
516{
Joel Becker03f981c2007-01-04 14:54:41 -0800517 if (!page_has_buffers(page))
518 return 0;
Jan Kara41ecc342013-11-12 15:07:08 -0800519 return try_to_free_buffers(page);
Joel Becker03f981c2007-01-04 14:54:41 -0800520}
521
Mark Fasheh9517bac2007-02-09 20:24:12 -0800522static void ocfs2_figure_cluster_boundaries(struct ocfs2_super *osb,
523 u32 cpos,
524 unsigned int *start,
525 unsigned int *end)
526{
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300527 unsigned int cluster_start = 0, cluster_end = PAGE_SIZE;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800528
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300529 if (unlikely(PAGE_SHIFT > osb->s_clustersize_bits)) {
Mark Fasheh9517bac2007-02-09 20:24:12 -0800530 unsigned int cpp;
531
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300532 cpp = 1 << (PAGE_SHIFT - osb->s_clustersize_bits);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800533
534 cluster_start = cpos % cpp;
535 cluster_start = cluster_start << osb->s_clustersize_bits;
536
537 cluster_end = cluster_start + osb->s_clustersize;
538 }
539
540 BUG_ON(cluster_start > PAGE_SIZE);
541 BUG_ON(cluster_end > PAGE_SIZE);
542
543 if (start)
544 *start = cluster_start;
545 if (end)
546 *end = cluster_end;
547}
548
549/*
550 * 'from' and 'to' are the region in the page to avoid zeroing.
551 *
552 * If pagesize > clustersize, this function will avoid zeroing outside
553 * of the cluster boundary.
554 *
555 * from == to == 0 is code for "zero the entire cluster region"
556 */
557static void ocfs2_clear_page_regions(struct page *page,
558 struct ocfs2_super *osb, u32 cpos,
559 unsigned from, unsigned to)
560{
561 void *kaddr;
562 unsigned int cluster_start, cluster_end;
563
564 ocfs2_figure_cluster_boundaries(osb, cpos, &cluster_start, &cluster_end);
565
Cong Wangc4bc8dc2011-11-25 23:14:34 +0800566 kaddr = kmap_atomic(page);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800567
568 if (from || to) {
569 if (from > cluster_start)
570 memset(kaddr + cluster_start, 0, from - cluster_start);
571 if (to < cluster_end)
572 memset(kaddr + to, 0, cluster_end - to);
573 } else {
574 memset(kaddr + cluster_start, 0, cluster_end - cluster_start);
575 }
576
Cong Wangc4bc8dc2011-11-25 23:14:34 +0800577 kunmap_atomic(kaddr);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800578}
579
580/*
Mark Fasheh4e9563f2007-11-01 11:37:48 -0700581 * Nonsparse file systems fully allocate before we get to the write
582 * code. This prevents ocfs2_write() from tagging the write as an
583 * allocating one, which means ocfs2_map_page_blocks() might try to
584 * read-in the blocks at the tail of our file. Avoid reading them by
585 * testing i_size against each block offset.
586 */
587static int ocfs2_should_read_blk(struct inode *inode, struct page *page,
588 unsigned int block_start)
589{
590 u64 offset = page_offset(page) + block_start;
591
592 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
593 return 1;
594
595 if (i_size_read(inode) > offset)
596 return 1;
597
598 return 0;
599}
600
601/*
Christoph Hellwigebdec242010-10-06 10:47:23 +0200602 * Some of this taken from __block_write_begin(). We already have our
Mark Fasheh9517bac2007-02-09 20:24:12 -0800603 * mapping by now though, and the entire write will be allocating or
604 * it won't, so not much need to use BH_New.
605 *
606 * This will also skip zeroing, which is handled externally.
607 */
Mark Fasheh60b11392007-02-16 11:46:50 -0800608int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
609 struct inode *inode, unsigned int from,
610 unsigned int to, int new)
Mark Fasheh9517bac2007-02-09 20:24:12 -0800611{
612 int ret = 0;
613 struct buffer_head *head, *bh, *wait[2], **wait_bh = wait;
614 unsigned int block_end, block_start;
Fabian Frederick61604a22017-02-27 14:28:32 -0800615 unsigned int bsize = i_blocksize(inode);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800616
617 if (!page_has_buffers(page))
618 create_empty_buffers(page, bsize, 0);
619
620 head = page_buffers(page);
621 for (bh = head, block_start = 0; bh != head || !block_start;
622 bh = bh->b_this_page, block_start += bsize) {
623 block_end = block_start + bsize;
624
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700625 clear_buffer_new(bh);
626
Mark Fasheh9517bac2007-02-09 20:24:12 -0800627 /*
628 * Ignore blocks outside of our i/o range -
629 * they may belong to unallocated clusters.
630 */
Mark Fasheh60b11392007-02-16 11:46:50 -0800631 if (block_start >= to || block_end <= from) {
Mark Fasheh9517bac2007-02-09 20:24:12 -0800632 if (PageUptodate(page))
633 set_buffer_uptodate(bh);
634 continue;
635 }
636
637 /*
638 * For an allocating write with cluster size >= page
639 * size, we always write the entire page.
640 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700641 if (new)
642 set_buffer_new(bh);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800643
644 if (!buffer_mapped(bh)) {
645 map_bh(bh, inode->i_sb, *p_blkno);
646 unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr);
647 }
648
649 if (PageUptodate(page)) {
650 if (!buffer_uptodate(bh))
651 set_buffer_uptodate(bh);
652 } else if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
Mark Fashehbce99762007-06-18 11:12:36 -0700653 !buffer_new(bh) &&
Mark Fasheh4e9563f2007-11-01 11:37:48 -0700654 ocfs2_should_read_blk(inode, page, block_start) &&
Mark Fashehbce99762007-06-18 11:12:36 -0700655 (block_start < from || block_end > to)) {
Mike Christiedfec8a12016-06-05 14:31:44 -0500656 ll_rw_block(REQ_OP_READ, 0, 1, &bh);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800657 *wait_bh++=bh;
658 }
659
660 *p_blkno = *p_blkno + 1;
661 }
662
663 /*
664 * If we issued read requests - let them complete.
665 */
666 while(wait_bh > wait) {
667 wait_on_buffer(*--wait_bh);
668 if (!buffer_uptodate(*wait_bh))
669 ret = -EIO;
670 }
671
672 if (ret == 0 || !new)
673 return ret;
674
675 /*
676 * If we get -EIO above, zero out any newly allocated blocks
677 * to avoid exposing stale data.
678 */
679 bh = head;
680 block_start = 0;
681 do {
Mark Fasheh9517bac2007-02-09 20:24:12 -0800682 block_end = block_start + bsize;
683 if (block_end <= from)
684 goto next_bh;
685 if (block_start >= to)
686 break;
687
Christoph Lametereebd2aa2008-02-04 22:28:29 -0800688 zero_user(page, block_start, bh->b_size);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800689 set_buffer_uptodate(bh);
690 mark_buffer_dirty(bh);
691
692next_bh:
693 block_start = block_end;
694 bh = bh->b_this_page;
695 } while (bh != head);
696
697 return ret;
698}
699
Kirill A. Shutemovea1754a2016-04-01 15:29:48 +0300700#if (PAGE_SIZE >= OCFS2_MAX_CLUSTERSIZE)
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700701#define OCFS2_MAX_CTXT_PAGES 1
702#else
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300703#define OCFS2_MAX_CTXT_PAGES (OCFS2_MAX_CLUSTERSIZE / PAGE_SIZE)
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700704#endif
Mark Fasheh6af67d82007-03-06 17:24:46 -0800705
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300706#define OCFS2_MAX_CLUSTERS_PER_PAGE (PAGE_SIZE / OCFS2_MIN_CLUSTERSIZE)
Mark Fasheh6af67d82007-03-06 17:24:46 -0800707
Ryan Ding4506cfb2016-03-25 14:21:06 -0700708struct ocfs2_unwritten_extent {
709 struct list_head ue_node;
710 struct list_head ue_ip_node;
711 u32 ue_cpos;
712 u32 ue_phys;
713};
714
Mark Fasheh6af67d82007-03-06 17:24:46 -0800715/*
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700716 * Describe the state of a single cluster to be written to.
Mark Fasheh9517bac2007-02-09 20:24:12 -0800717 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700718struct ocfs2_write_cluster_desc {
719 u32 c_cpos;
720 u32 c_phys;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800721 /*
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700722 * Give this a unique field because c_phys eventually gets
723 * filled.
Mark Fasheh9517bac2007-02-09 20:24:12 -0800724 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700725 unsigned c_new;
Ryan Dingb46637d2016-03-25 14:20:55 -0700726 unsigned c_clear_unwritten;
Sunil Mushrane7432672009-08-06 16:12:58 -0700727 unsigned c_needs_zero;
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700728};
Mark Fasheh9517bac2007-02-09 20:24:12 -0800729
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700730struct ocfs2_write_ctxt {
731 /* Logical cluster position / len of write */
732 u32 w_cpos;
733 u32 w_clen;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800734
Sunil Mushrane7432672009-08-06 16:12:58 -0700735 /* First cluster allocated in a nonsparse extend */
736 u32 w_first_new_cpos;
737
Ryan Dingc1ad1e32016-03-25 14:20:52 -0700738 /* Type of caller. Must be one of buffer, mmap, direct. */
739 ocfs2_write_type_t w_type;
740
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700741 struct ocfs2_write_cluster_desc w_desc[OCFS2_MAX_CLUSTERS_PER_PAGE];
Mark Fasheh9517bac2007-02-09 20:24:12 -0800742
743 /*
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700744 * This is true if page_size > cluster_size.
Mark Fasheh9517bac2007-02-09 20:24:12 -0800745 *
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700746 * It triggers a set of special cases during write which might
747 * have to deal with allocating writes to partial pages.
Mark Fasheh9517bac2007-02-09 20:24:12 -0800748 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700749 unsigned int w_large_pages;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800750
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700751 /*
752 * Pages involved in this write.
753 *
754 * w_target_page is the page being written to by the user.
755 *
756 * w_pages is an array of pages which always contains
757 * w_target_page, and in the case of an allocating write with
758 * page_size < cluster size, it will contain zero'd and mapped
759 * pages adjacent to w_target_page which need to be written
760 * out in so that future reads from that region will get
761 * zero's.
762 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700763 unsigned int w_num_pages;
Goldwyn Rodrigues83fd9c72010-06-10 17:21:36 -0500764 struct page *w_pages[OCFS2_MAX_CTXT_PAGES];
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700765 struct page *w_target_page;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800766
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700767 /*
Wengang Wang5cffff92011-07-24 10:36:54 -0700768 * w_target_locked is used for page_mkwrite path indicating no unlocking
769 * against w_target_page in ocfs2_write_end_nolock.
770 */
771 unsigned int w_target_locked:1;
772
773 /*
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700774 * ocfs2_write_end() uses this to know what the real range to
775 * write in the target should be.
776 */
777 unsigned int w_target_from;
778 unsigned int w_target_to;
779
780 /*
781 * We could use journal_current_handle() but this is cleaner,
782 * IMHO -Mark
783 */
784 handle_t *w_handle;
785
786 struct buffer_head *w_di_bh;
Mark Fashehb27b7cb2007-06-18 11:22:56 -0700787
788 struct ocfs2_cached_dealloc_ctxt w_dealloc;
Ryan Ding4506cfb2016-03-25 14:21:06 -0700789
790 struct list_head w_unwritten_list;
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700791};
792
Mark Fasheh1d410a62007-09-07 14:20:45 -0700793void ocfs2_unlock_and_free_pages(struct page **pages, int num_pages)
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700794{
795 int i;
796
Mark Fasheh1d410a62007-09-07 14:20:45 -0700797 for(i = 0; i < num_pages; i++) {
798 if (pages[i]) {
799 unlock_page(pages[i]);
800 mark_page_accessed(pages[i]);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300801 put_page(pages[i]);
Mark Fasheh1d410a62007-09-07 14:20:45 -0700802 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700803 }
Mark Fasheh1d410a62007-09-07 14:20:45 -0700804}
805
Junxiao Bi136f49b2014-12-18 16:17:37 -0800806static void ocfs2_unlock_pages(struct ocfs2_write_ctxt *wc)
Mark Fasheh1d410a62007-09-07 14:20:45 -0700807{
Wengang Wang5cffff92011-07-24 10:36:54 -0700808 int i;
809
810 /*
811 * w_target_locked is only set to true in the page_mkwrite() case.
812 * The intent is to allow us to lock the target page from write_begin()
813 * to write_end(). The caller must hold a ref on w_target_page.
814 */
815 if (wc->w_target_locked) {
816 BUG_ON(!wc->w_target_page);
817 for (i = 0; i < wc->w_num_pages; i++) {
818 if (wc->w_target_page == wc->w_pages[i]) {
819 wc->w_pages[i] = NULL;
820 break;
821 }
822 }
823 mark_page_accessed(wc->w_target_page);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300824 put_page(wc->w_target_page);
Wengang Wang5cffff92011-07-24 10:36:54 -0700825 }
Mark Fasheh1d410a62007-09-07 14:20:45 -0700826 ocfs2_unlock_and_free_pages(wc->w_pages, wc->w_num_pages);
Junxiao Bi136f49b2014-12-18 16:17:37 -0800827}
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700828
Ryan Ding4506cfb2016-03-25 14:21:06 -0700829static void ocfs2_free_unwritten_list(struct inode *inode,
830 struct list_head *head)
Junxiao Bi136f49b2014-12-18 16:17:37 -0800831{
Ryan Ding4506cfb2016-03-25 14:21:06 -0700832 struct ocfs2_inode_info *oi = OCFS2_I(inode);
Ryan Dingc15471f2016-03-25 14:21:09 -0700833 struct ocfs2_unwritten_extent *ue = NULL, *tmp = NULL;
Ryan Ding4506cfb2016-03-25 14:21:06 -0700834
Ryan Dingc15471f2016-03-25 14:21:09 -0700835 list_for_each_entry_safe(ue, tmp, head, ue_node) {
836 list_del(&ue->ue_node);
Ryan Ding4506cfb2016-03-25 14:21:06 -0700837 spin_lock(&oi->ip_lock);
Ryan Dingc15471f2016-03-25 14:21:09 -0700838 list_del(&ue->ue_ip_node);
Ryan Ding4506cfb2016-03-25 14:21:06 -0700839 spin_unlock(&oi->ip_lock);
Ryan Dingc15471f2016-03-25 14:21:09 -0700840 kfree(ue);
Ryan Ding4506cfb2016-03-25 14:21:06 -0700841 }
842}
843
844static void ocfs2_free_write_ctxt(struct inode *inode,
845 struct ocfs2_write_ctxt *wc)
846{
847 ocfs2_free_unwritten_list(inode, &wc->w_unwritten_list);
Junxiao Bi136f49b2014-12-18 16:17:37 -0800848 ocfs2_unlock_pages(wc);
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700849 brelse(wc->w_di_bh);
850 kfree(wc);
851}
852
853static int ocfs2_alloc_write_ctxt(struct ocfs2_write_ctxt **wcp,
854 struct ocfs2_super *osb, loff_t pos,
Ryan Dingc1ad1e32016-03-25 14:20:52 -0700855 unsigned len, ocfs2_write_type_t type,
856 struct buffer_head *di_bh)
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700857{
tao.ma@oracle.com30b85482007-09-06 08:02:25 +0800858 u32 cend;
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700859 struct ocfs2_write_ctxt *wc;
860
861 wc = kzalloc(sizeof(struct ocfs2_write_ctxt), GFP_NOFS);
862 if (!wc)
863 return -ENOMEM;
864
865 wc->w_cpos = pos >> osb->s_clustersize_bits;
Sunil Mushrane7432672009-08-06 16:12:58 -0700866 wc->w_first_new_cpos = UINT_MAX;
tao.ma@oracle.com30b85482007-09-06 08:02:25 +0800867 cend = (pos + len - 1) >> osb->s_clustersize_bits;
868 wc->w_clen = cend - wc->w_cpos + 1;
Mark Fasheh607d44a2007-05-09 15:14:45 -0700869 get_bh(di_bh);
870 wc->w_di_bh = di_bh;
Ryan Dingc1ad1e32016-03-25 14:20:52 -0700871 wc->w_type = type;
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700872
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300873 if (unlikely(PAGE_SHIFT > osb->s_clustersize_bits))
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700874 wc->w_large_pages = 1;
875 else
876 wc->w_large_pages = 0;
877
Mark Fashehb27b7cb2007-06-18 11:22:56 -0700878 ocfs2_init_dealloc_ctxt(&wc->w_dealloc);
Ryan Ding4506cfb2016-03-25 14:21:06 -0700879 INIT_LIST_HEAD(&wc->w_unwritten_list);
Mark Fashehb27b7cb2007-06-18 11:22:56 -0700880
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700881 *wcp = wc;
882
883 return 0;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800884}
885
886/*
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700887 * If a page has any new buffers, zero them out here, and mark them uptodate
888 * and dirty so they'll be written out (in order to prevent uninitialised
889 * block data from leaking). And clear the new bit.
Mark Fasheh9517bac2007-02-09 20:24:12 -0800890 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700891static void ocfs2_zero_new_buffers(struct page *page, unsigned from, unsigned to)
Mark Fasheh9517bac2007-02-09 20:24:12 -0800892{
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700893 unsigned int block_start, block_end;
894 struct buffer_head *head, *bh;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800895
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700896 BUG_ON(!PageLocked(page));
897 if (!page_has_buffers(page))
898 return;
899
900 bh = head = page_buffers(page);
901 block_start = 0;
902 do {
903 block_end = block_start + bh->b_size;
904
905 if (buffer_new(bh)) {
906 if (block_end > from && block_start < to) {
907 if (!PageUptodate(page)) {
908 unsigned start, end;
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700909
910 start = max(from, block_start);
911 end = min(to, block_end);
912
Christoph Lametereebd2aa2008-02-04 22:28:29 -0800913 zero_user_segment(page, start, end);
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700914 set_buffer_uptodate(bh);
915 }
916
917 clear_buffer_new(bh);
918 mark_buffer_dirty(bh);
919 }
920 }
921
922 block_start = block_end;
923 bh = bh->b_this_page;
924 } while (bh != head);
925}
926
927/*
928 * Only called when we have a failure during allocating write to write
929 * zero's to the newly allocated region.
930 */
931static void ocfs2_write_failure(struct inode *inode,
932 struct ocfs2_write_ctxt *wc,
933 loff_t user_pos, unsigned user_len)
934{
935 int i;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300936 unsigned from = user_pos & (PAGE_SIZE - 1),
Mark Fasheh5c26a7b2007-09-18 17:49:29 -0700937 to = user_pos + user_len;
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700938 struct page *tmppage;
939
Ryan Ding65c4db82016-03-25 14:20:58 -0700940 if (wc->w_target_page)
941 ocfs2_zero_new_buffers(wc->w_target_page, from, to);
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700942
943 for(i = 0; i < wc->w_num_pages; i++) {
944 tmppage = wc->w_pages[i];
945
Ryan Ding65c4db82016-03-25 14:20:58 -0700946 if (tmppage && page_has_buffers(tmppage)) {
Mark Fasheh53ef99c2008-11-18 16:53:43 -0800947 if (ocfs2_should_order_data(inode))
Joel Becker2b4e30f2008-09-03 20:03:41 -0700948 ocfs2_jbd2_file_inode(wc->w_handle, inode);
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700949
Sunil Mushran961cecb2008-07-16 17:22:22 -0700950 block_commit_write(tmppage, from, to);
951 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700952 }
953}
954
955static int ocfs2_prepare_page_for_write(struct inode *inode, u64 *p_blkno,
956 struct ocfs2_write_ctxt *wc,
957 struct page *page, u32 cpos,
958 loff_t user_pos, unsigned user_len,
959 int new)
960{
961 int ret;
962 unsigned int map_from = 0, map_to = 0;
963 unsigned int cluster_start, cluster_end;
964 unsigned int user_data_from = 0, user_data_to = 0;
965
966 ocfs2_figure_cluster_boundaries(OCFS2_SB(inode->i_sb), cpos,
Mark Fasheh9517bac2007-02-09 20:24:12 -0800967 &cluster_start, &cluster_end);
968
Goldwyn Rodrigues272b62c2011-02-17 09:44:40 -0600969 /* treat the write as new if the a hole/lseek spanned across
970 * the page boundary.
971 */
972 new = new | ((i_size_read(inode) <= page_offset(page)) &&
973 (page_offset(page) <= user_pos));
974
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700975 if (page == wc->w_target_page) {
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +0300976 map_from = user_pos & (PAGE_SIZE - 1);
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700977 map_to = map_from + user_len;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800978
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700979 if (new)
980 ret = ocfs2_map_page_blocks(page, p_blkno, inode,
981 cluster_start, cluster_end,
982 new);
983 else
984 ret = ocfs2_map_page_blocks(page, p_blkno, inode,
985 map_from, map_to, new);
986 if (ret) {
Mark Fasheh9517bac2007-02-09 20:24:12 -0800987 mlog_errno(ret);
988 goto out;
989 }
990
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700991 user_data_from = map_from;
992 user_data_to = map_to;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800993 if (new) {
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700994 map_from = cluster_start;
995 map_to = cluster_end;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800996 }
997 } else {
998 /*
999 * If we haven't allocated the new page yet, we
1000 * shouldn't be writing it out without copying user
1001 * data. This is likely a math error from the caller.
1002 */
1003 BUG_ON(!new);
1004
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001005 map_from = cluster_start;
1006 map_to = cluster_end;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001007
1008 ret = ocfs2_map_page_blocks(page, p_blkno, inode,
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001009 cluster_start, cluster_end, new);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001010 if (ret) {
1011 mlog_errno(ret);
1012 goto out;
1013 }
1014 }
1015
1016 /*
1017 * Parts of newly allocated pages need to be zero'd.
1018 *
1019 * Above, we have also rewritten 'to' and 'from' - as far as
1020 * the rest of the function is concerned, the entire cluster
1021 * range inside of a page needs to be written.
1022 *
1023 * We can skip this if the page is up to date - it's already
1024 * been zero'd from being read in as a hole.
1025 */
1026 if (new && !PageUptodate(page))
1027 ocfs2_clear_page_regions(page, OCFS2_SB(inode->i_sb),
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001028 cpos, user_data_from, user_data_to);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001029
1030 flush_dcache_page(page);
1031
Mark Fasheh9517bac2007-02-09 20:24:12 -08001032out:
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001033 return ret;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001034}
1035
1036/*
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001037 * This function will only grab one clusters worth of pages.
Mark Fasheh9517bac2007-02-09 20:24:12 -08001038 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001039static int ocfs2_grab_pages_for_write(struct address_space *mapping,
1040 struct ocfs2_write_ctxt *wc,
Joel Becker693c2412010-07-02 17:20:27 -07001041 u32 cpos, loff_t user_pos,
1042 unsigned user_len, int new,
Mark Fasheh7307de82007-05-09 15:16:19 -07001043 struct page *mmap_page)
Mark Fasheh9517bac2007-02-09 20:24:12 -08001044{
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001045 int ret = 0, i;
Joel Becker693c2412010-07-02 17:20:27 -07001046 unsigned long start, target_index, end_index, index;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001047 struct inode *inode = mapping->host;
Joel Becker693c2412010-07-02 17:20:27 -07001048 loff_t last_byte;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001049
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001050 target_index = user_pos >> PAGE_SHIFT;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001051
1052 /*
1053 * Figure out how many pages we'll be manipulating here. For
Mark Fasheh60b11392007-02-16 11:46:50 -08001054 * non allocating write, we just change the one
Joel Becker693c2412010-07-02 17:20:27 -07001055 * page. Otherwise, we'll need a whole clusters worth. If we're
1056 * writing past i_size, we only need enough pages to cover the
1057 * last page of the write.
Mark Fasheh9517bac2007-02-09 20:24:12 -08001058 */
Mark Fasheh9517bac2007-02-09 20:24:12 -08001059 if (new) {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001060 wc->w_num_pages = ocfs2_pages_per_cluster(inode->i_sb);
1061 start = ocfs2_align_clusters_to_page_index(inode->i_sb, cpos);
Joel Becker693c2412010-07-02 17:20:27 -07001062 /*
1063 * We need the index *past* the last page we could possibly
1064 * touch. This is the page past the end of the write or
1065 * i_size, whichever is greater.
1066 */
1067 last_byte = max(user_pos + user_len, i_size_read(inode));
1068 BUG_ON(last_byte < 1);
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001069 end_index = ((last_byte - 1) >> PAGE_SHIFT) + 1;
Joel Becker693c2412010-07-02 17:20:27 -07001070 if ((start + wc->w_num_pages) > end_index)
1071 wc->w_num_pages = end_index - start;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001072 } else {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001073 wc->w_num_pages = 1;
1074 start = target_index;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001075 }
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001076 end_index = (user_pos + user_len - 1) >> PAGE_SHIFT;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001077
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001078 for(i = 0; i < wc->w_num_pages; i++) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08001079 index = start + i;
1080
Ryan Ding65c4db82016-03-25 14:20:58 -07001081 if (index >= target_index && index <= end_index &&
1082 wc->w_type == OCFS2_WRITE_MMAP) {
Mark Fasheh7307de82007-05-09 15:16:19 -07001083 /*
1084 * ocfs2_pagemkwrite() is a little different
1085 * and wants us to directly use the page
1086 * passed in.
1087 */
1088 lock_page(mmap_page);
1089
Wengang Wang5cffff92011-07-24 10:36:54 -07001090 /* Exit and let the caller retry */
Mark Fasheh7307de82007-05-09 15:16:19 -07001091 if (mmap_page->mapping != mapping) {
Wengang Wang5cffff92011-07-24 10:36:54 -07001092 WARN_ON(mmap_page->mapping);
Mark Fasheh7307de82007-05-09 15:16:19 -07001093 unlock_page(mmap_page);
Wengang Wang5cffff92011-07-24 10:36:54 -07001094 ret = -EAGAIN;
Mark Fasheh7307de82007-05-09 15:16:19 -07001095 goto out;
1096 }
1097
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001098 get_page(mmap_page);
Mark Fasheh7307de82007-05-09 15:16:19 -07001099 wc->w_pages[i] = mmap_page;
Wengang Wang5cffff92011-07-24 10:36:54 -07001100 wc->w_target_locked = true;
Ryan Ding65c4db82016-03-25 14:20:58 -07001101 } else if (index >= target_index && index <= end_index &&
1102 wc->w_type == OCFS2_WRITE_DIRECT) {
1103 /* Direct write has no mapping page. */
1104 wc->w_pages[i] = NULL;
1105 continue;
Mark Fasheh7307de82007-05-09 15:16:19 -07001106 } else {
1107 wc->w_pages[i] = find_or_create_page(mapping, index,
1108 GFP_NOFS);
1109 if (!wc->w_pages[i]) {
1110 ret = -ENOMEM;
1111 mlog_errno(ret);
1112 goto out;
1113 }
Mark Fasheh9517bac2007-02-09 20:24:12 -08001114 }
Jan Kara12695292013-02-21 16:42:57 -08001115 wait_for_stable_page(wc->w_pages[i]);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001116
1117 if (index == target_index)
1118 wc->w_target_page = wc->w_pages[i];
Mark Fasheh9517bac2007-02-09 20:24:12 -08001119 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001120out:
Wengang Wang5cffff92011-07-24 10:36:54 -07001121 if (ret)
1122 wc->w_target_locked = false;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001123 return ret;
1124}
1125
1126/*
1127 * Prepare a single cluster for write one cluster into the file.
1128 */
1129static int ocfs2_write_cluster(struct address_space *mapping,
Ryan Ding2de6a3c2016-03-25 14:21:03 -07001130 u32 *phys, unsigned int new,
Ryan Dingb46637d2016-03-25 14:20:55 -07001131 unsigned int clear_unwritten,
Sunil Mushrane7432672009-08-06 16:12:58 -07001132 unsigned int should_zero,
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001133 struct ocfs2_alloc_context *data_ac,
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001134 struct ocfs2_alloc_context *meta_ac,
1135 struct ocfs2_write_ctxt *wc, u32 cpos,
1136 loff_t user_pos, unsigned user_len)
1137{
Ryan Dingb46637d2016-03-25 14:20:55 -07001138 int ret, i;
Ryan Ding2de6a3c2016-03-25 14:21:03 -07001139 u64 p_blkno;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001140 struct inode *inode = mapping->host;
Joel Beckerf99b9b72008-08-20 19:36:33 -07001141 struct ocfs2_extent_tree et;
Ryan Ding2de6a3c2016-03-25 14:21:03 -07001142 int bpc = ocfs2_clusters_to_blocks(inode->i_sb, 1);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001143
Mark Fasheh9517bac2007-02-09 20:24:12 -08001144 if (new) {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001145 u32 tmp_pos;
1146
Mark Fasheh9517bac2007-02-09 20:24:12 -08001147 /*
1148 * This is safe to call with the page locks - it won't take
1149 * any additional semaphores or cluster locks.
1150 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001151 tmp_pos = cpos;
Tao Ma0eb8d472008-08-18 17:38:45 +08001152 ret = ocfs2_add_inode_data(OCFS2_SB(inode->i_sb), inode,
Ryan Dingb46637d2016-03-25 14:20:55 -07001153 &tmp_pos, 1, !clear_unwritten,
1154 wc->w_di_bh, wc->w_handle,
1155 data_ac, meta_ac, NULL);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001156 /*
1157 * This shouldn't happen because we must have already
1158 * calculated the correct meta data allocation required. The
1159 * internal tree allocation code should know how to increase
1160 * transaction credits itself.
1161 *
1162 * If need be, we could handle -EAGAIN for a
1163 * RESTART_TRANS here.
1164 */
1165 mlog_bug_on_msg(ret == -EAGAIN,
1166 "Inode %llu: EAGAIN return during allocation.\n",
1167 (unsigned long long)OCFS2_I(inode)->ip_blkno);
1168 if (ret < 0) {
1169 mlog_errno(ret);
1170 goto out;
1171 }
Ryan Dingb46637d2016-03-25 14:20:55 -07001172 } else if (clear_unwritten) {
Joel Becker5e404e92009-02-13 03:54:22 -08001173 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode),
1174 wc->w_di_bh);
Joel Beckerf99b9b72008-08-20 19:36:33 -07001175 ret = ocfs2_mark_extent_written(inode, &et,
Ryan Ding2de6a3c2016-03-25 14:21:03 -07001176 wc->w_handle, cpos, 1, *phys,
Joel Beckerf99b9b72008-08-20 19:36:33 -07001177 meta_ac, &wc->w_dealloc);
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001178 if (ret < 0) {
1179 mlog_errno(ret);
1180 goto out;
1181 }
Mark Fasheh9517bac2007-02-09 20:24:12 -08001182 }
1183
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001184 /*
1185 * The only reason this should fail is due to an inability to
1186 * find the extent added.
1187 */
Ryan Ding2de6a3c2016-03-25 14:21:03 -07001188 ret = ocfs2_get_clusters(inode, cpos, phys, NULL, NULL);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001189 if (ret < 0) {
jiangyiwen61fb9ea2014-12-10 15:42:02 -08001190 mlog(ML_ERROR, "Get physical blkno failed for inode %llu, "
Ryan Ding2de6a3c2016-03-25 14:21:03 -07001191 "at logical cluster %u",
1192 (unsigned long long)OCFS2_I(inode)->ip_blkno, cpos);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001193 goto out;
1194 }
1195
Ryan Ding2de6a3c2016-03-25 14:21:03 -07001196 BUG_ON(*phys == 0);
1197
1198 p_blkno = ocfs2_clusters_to_blocks(inode->i_sb, *phys);
1199 if (!should_zero)
1200 p_blkno += (user_pos >> inode->i_sb->s_blocksize_bits) & (u64)(bpc - 1);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001201
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001202 for(i = 0; i < wc->w_num_pages; i++) {
1203 int tmpret;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001204
Ryan Ding65c4db82016-03-25 14:20:58 -07001205 /* This is the direct io target page. */
1206 if (wc->w_pages[i] == NULL) {
1207 p_blkno++;
1208 continue;
1209 }
1210
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001211 tmpret = ocfs2_prepare_page_for_write(inode, &p_blkno, wc,
1212 wc->w_pages[i], cpos,
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001213 user_pos, user_len,
1214 should_zero);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001215 if (tmpret) {
1216 mlog_errno(tmpret);
1217 if (ret == 0)
Wengang Wangcbfa9632009-07-13 11:38:23 +08001218 ret = tmpret;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001219 }
Mark Fasheh9517bac2007-02-09 20:24:12 -08001220 }
1221
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001222 /*
1223 * We only have cleanup to do in case of allocating write.
1224 */
1225 if (ret && new)
1226 ocfs2_write_failure(inode, wc, user_pos, user_len);
1227
Mark Fasheh9517bac2007-02-09 20:24:12 -08001228out:
Mark Fasheh9517bac2007-02-09 20:24:12 -08001229
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001230 return ret;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001231}
1232
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001233static int ocfs2_write_cluster_by_desc(struct address_space *mapping,
1234 struct ocfs2_alloc_context *data_ac,
1235 struct ocfs2_alloc_context *meta_ac,
1236 struct ocfs2_write_ctxt *wc,
1237 loff_t pos, unsigned len)
1238{
1239 int ret, i;
Mark Fashehdb562462007-09-17 09:06:29 -07001240 loff_t cluster_off;
1241 unsigned int local_len = len;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001242 struct ocfs2_write_cluster_desc *desc;
Mark Fashehdb562462007-09-17 09:06:29 -07001243 struct ocfs2_super *osb = OCFS2_SB(mapping->host->i_sb);
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001244
1245 for (i = 0; i < wc->w_clen; i++) {
1246 desc = &wc->w_desc[i];
1247
Mark Fashehdb562462007-09-17 09:06:29 -07001248 /*
1249 * We have to make sure that the total write passed in
1250 * doesn't extend past a single cluster.
1251 */
1252 local_len = len;
1253 cluster_off = pos & (osb->s_clustersize - 1);
1254 if ((cluster_off + local_len) > osb->s_clustersize)
1255 local_len = osb->s_clustersize - cluster_off;
1256
Ryan Ding2de6a3c2016-03-25 14:21:03 -07001257 ret = ocfs2_write_cluster(mapping, &desc->c_phys,
Ryan Dingb46637d2016-03-25 14:20:55 -07001258 desc->c_new,
1259 desc->c_clear_unwritten,
Sunil Mushrane7432672009-08-06 16:12:58 -07001260 desc->c_needs_zero,
1261 data_ac, meta_ac,
Mark Fashehdb562462007-09-17 09:06:29 -07001262 wc, desc->c_cpos, pos, local_len);
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001263 if (ret) {
1264 mlog_errno(ret);
1265 goto out;
1266 }
Mark Fashehdb562462007-09-17 09:06:29 -07001267
1268 len -= local_len;
1269 pos += local_len;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001270 }
1271
1272 ret = 0;
1273out:
1274 return ret;
1275}
1276
Mark Fasheh9517bac2007-02-09 20:24:12 -08001277/*
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001278 * ocfs2_write_end() wants to know which parts of the target page it
1279 * should complete the write on. It's easiest to compute them ahead of
1280 * time when a more complete view of the write is available.
Mark Fasheh9517bac2007-02-09 20:24:12 -08001281 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001282static void ocfs2_set_target_boundaries(struct ocfs2_super *osb,
1283 struct ocfs2_write_ctxt *wc,
1284 loff_t pos, unsigned len, int alloc)
Mark Fasheh9517bac2007-02-09 20:24:12 -08001285{
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001286 struct ocfs2_write_cluster_desc *desc;
1287
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001288 wc->w_target_from = pos & (PAGE_SIZE - 1);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001289 wc->w_target_to = wc->w_target_from + len;
1290
1291 if (alloc == 0)
1292 return;
1293
1294 /*
1295 * Allocating write - we may have different boundaries based
1296 * on page size and cluster size.
1297 *
1298 * NOTE: We can no longer compute one value from the other as
1299 * the actual write length and user provided length may be
1300 * different.
1301 */
1302
1303 if (wc->w_large_pages) {
1304 /*
1305 * We only care about the 1st and last cluster within
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001306 * our range and whether they should be zero'd or not. Either
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001307 * value may be extended out to the start/end of a
1308 * newly allocated cluster.
1309 */
1310 desc = &wc->w_desc[0];
Sunil Mushrane7432672009-08-06 16:12:58 -07001311 if (desc->c_needs_zero)
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001312 ocfs2_figure_cluster_boundaries(osb,
1313 desc->c_cpos,
1314 &wc->w_target_from,
1315 NULL);
1316
1317 desc = &wc->w_desc[wc->w_clen - 1];
Sunil Mushrane7432672009-08-06 16:12:58 -07001318 if (desc->c_needs_zero)
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001319 ocfs2_figure_cluster_boundaries(osb,
1320 desc->c_cpos,
1321 NULL,
1322 &wc->w_target_to);
1323 } else {
1324 wc->w_target_from = 0;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001325 wc->w_target_to = PAGE_SIZE;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001326 }
1327}
1328
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001329/*
Ryan Ding4506cfb2016-03-25 14:21:06 -07001330 * Check if this extent is marked UNWRITTEN by direct io. If so, we need not to
1331 * do the zero work. And should not to clear UNWRITTEN since it will be cleared
1332 * by the direct io procedure.
1333 * If this is a new extent that allocated by direct io, we should mark it in
1334 * the ip_unwritten_list.
1335 */
1336static int ocfs2_unwritten_check(struct inode *inode,
1337 struct ocfs2_write_ctxt *wc,
1338 struct ocfs2_write_cluster_desc *desc)
1339{
1340 struct ocfs2_inode_info *oi = OCFS2_I(inode);
Ryan Dingc15471f2016-03-25 14:21:09 -07001341 struct ocfs2_unwritten_extent *ue = NULL, *new = NULL;
Ryan Ding4506cfb2016-03-25 14:21:06 -07001342 int ret = 0;
1343
1344 if (!desc->c_needs_zero)
1345 return 0;
1346
1347retry:
1348 spin_lock(&oi->ip_lock);
1349 /* Needs not to zero no metter buffer or direct. The one who is zero
1350 * the cluster is doing zero. And he will clear unwritten after all
1351 * cluster io finished. */
Ryan Dingc15471f2016-03-25 14:21:09 -07001352 list_for_each_entry(ue, &oi->ip_unwritten_list, ue_ip_node) {
1353 if (desc->c_cpos == ue->ue_cpos) {
Ryan Ding4506cfb2016-03-25 14:21:06 -07001354 BUG_ON(desc->c_new);
1355 desc->c_needs_zero = 0;
1356 desc->c_clear_unwritten = 0;
1357 goto unlock;
1358 }
1359 }
1360
1361 if (wc->w_type != OCFS2_WRITE_DIRECT)
1362 goto unlock;
1363
1364 if (new == NULL) {
1365 spin_unlock(&oi->ip_lock);
1366 new = kmalloc(sizeof(struct ocfs2_unwritten_extent),
1367 GFP_NOFS);
1368 if (new == NULL) {
1369 ret = -ENOMEM;
1370 goto out;
1371 }
1372 goto retry;
1373 }
1374 /* This direct write will doing zero. */
1375 new->ue_cpos = desc->c_cpos;
1376 new->ue_phys = desc->c_phys;
1377 desc->c_clear_unwritten = 0;
1378 list_add_tail(&new->ue_ip_node, &oi->ip_unwritten_list);
1379 list_add_tail(&new->ue_node, &wc->w_unwritten_list);
1380 new = NULL;
1381unlock:
1382 spin_unlock(&oi->ip_lock);
1383out:
1384 if (new)
1385 kfree(new);
1386 return ret;
1387}
1388
1389/*
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001390 * Populate each single-cluster write descriptor in the write context
1391 * with information about the i/o to be done.
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001392 *
1393 * Returns the number of clusters that will have to be allocated, as
1394 * well as a worst case estimate of the number of extent records that
1395 * would have to be created during a write to an unwritten region.
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001396 */
1397static int ocfs2_populate_write_desc(struct inode *inode,
1398 struct ocfs2_write_ctxt *wc,
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001399 unsigned int *clusters_to_alloc,
1400 unsigned int *extents_to_split)
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001401{
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001402 int ret;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001403 struct ocfs2_write_cluster_desc *desc;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001404 unsigned int num_clusters = 0;
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001405 unsigned int ext_flags = 0;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001406 u32 phys = 0;
1407 int i;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001408
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001409 *clusters_to_alloc = 0;
1410 *extents_to_split = 0;
1411
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001412 for (i = 0; i < wc->w_clen; i++) {
1413 desc = &wc->w_desc[i];
1414 desc->c_cpos = wc->w_cpos + i;
1415
1416 if (num_clusters == 0) {
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001417 /*
1418 * Need to look up the next extent record.
1419 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001420 ret = ocfs2_get_clusters(inode, desc->c_cpos, &phys,
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001421 &num_clusters, &ext_flags);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001422 if (ret) {
1423 mlog_errno(ret);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001424 goto out;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001425 }
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001426
Tao Ma293b2f72009-08-25 08:02:48 +08001427 /* We should already CoW the refcountd extent. */
1428 BUG_ON(ext_flags & OCFS2_EXT_REFCOUNTED);
1429
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001430 /*
1431 * Assume worst case - that we're writing in
1432 * the middle of the extent.
1433 *
1434 * We can assume that the write proceeds from
1435 * left to right, in which case the extent
1436 * insert code is smart enough to coalesce the
1437 * next splits into the previous records created.
1438 */
1439 if (ext_flags & OCFS2_EXT_UNWRITTEN)
1440 *extents_to_split = *extents_to_split + 2;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001441 } else if (phys) {
1442 /*
1443 * Only increment phys if it doesn't describe
1444 * a hole.
1445 */
1446 phys++;
1447 }
1448
Sunil Mushrane7432672009-08-06 16:12:58 -07001449 /*
1450 * If w_first_new_cpos is < UINT_MAX, we have a non-sparse
1451 * file that got extended. w_first_new_cpos tells us
1452 * where the newly allocated clusters are so we can
1453 * zero them.
1454 */
1455 if (desc->c_cpos >= wc->w_first_new_cpos) {
1456 BUG_ON(phys == 0);
1457 desc->c_needs_zero = 1;
1458 }
1459
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001460 desc->c_phys = phys;
1461 if (phys == 0) {
1462 desc->c_new = 1;
Sunil Mushrane7432672009-08-06 16:12:58 -07001463 desc->c_needs_zero = 1;
Ryan Dingb46637d2016-03-25 14:20:55 -07001464 desc->c_clear_unwritten = 1;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001465 *clusters_to_alloc = *clusters_to_alloc + 1;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001466 }
Sunil Mushrane7432672009-08-06 16:12:58 -07001467
1468 if (ext_flags & OCFS2_EXT_UNWRITTEN) {
Ryan Dingb46637d2016-03-25 14:20:55 -07001469 desc->c_clear_unwritten = 1;
Sunil Mushrane7432672009-08-06 16:12:58 -07001470 desc->c_needs_zero = 1;
1471 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001472
Ryan Ding4506cfb2016-03-25 14:21:06 -07001473 ret = ocfs2_unwritten_check(inode, wc, desc);
1474 if (ret) {
1475 mlog_errno(ret);
1476 goto out;
1477 }
1478
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001479 num_clusters--;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001480 }
1481
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001482 ret = 0;
1483out:
1484 return ret;
1485}
1486
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001487static int ocfs2_write_begin_inline(struct address_space *mapping,
1488 struct inode *inode,
1489 struct ocfs2_write_ctxt *wc)
1490{
1491 int ret;
1492 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1493 struct page *page;
1494 handle_t *handle;
1495 struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1496
Junxiao Bif775da22014-10-09 15:25:15 -07001497 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1498 if (IS_ERR(handle)) {
1499 ret = PTR_ERR(handle);
1500 mlog_errno(ret);
1501 goto out;
1502 }
1503
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001504 page = find_or_create_page(mapping, 0, GFP_NOFS);
1505 if (!page) {
Junxiao Bif775da22014-10-09 15:25:15 -07001506 ocfs2_commit_trans(osb, handle);
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001507 ret = -ENOMEM;
1508 mlog_errno(ret);
1509 goto out;
1510 }
1511 /*
1512 * If we don't set w_num_pages then this page won't get unlocked
1513 * and freed on cleanup of the write context.
1514 */
1515 wc->w_pages[0] = wc->w_target_page = page;
1516 wc->w_num_pages = 1;
1517
Joel Becker0cf2f762009-02-12 16:41:25 -08001518 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), wc->w_di_bh,
Joel Becker13723d02008-10-17 19:25:01 -07001519 OCFS2_JOURNAL_ACCESS_WRITE);
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001520 if (ret) {
1521 ocfs2_commit_trans(osb, handle);
1522
1523 mlog_errno(ret);
1524 goto out;
1525 }
1526
1527 if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL))
1528 ocfs2_set_inode_data_inline(inode, di);
1529
1530 if (!PageUptodate(page)) {
1531 ret = ocfs2_read_inline_data(inode, page, wc->w_di_bh);
1532 if (ret) {
1533 ocfs2_commit_trans(osb, handle);
1534
1535 goto out;
1536 }
1537 }
1538
1539 wc->w_handle = handle;
1540out:
1541 return ret;
1542}
1543
1544int ocfs2_size_fits_inline_data(struct buffer_head *di_bh, u64 new_size)
1545{
1546 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
1547
Mark Fasheh0d8a4e02007-11-20 11:48:41 -08001548 if (new_size <= le16_to_cpu(di->id2.i_data.id_count))
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001549 return 1;
1550 return 0;
1551}
1552
1553static int ocfs2_try_to_write_inline_data(struct address_space *mapping,
1554 struct inode *inode, loff_t pos,
1555 unsigned len, struct page *mmap_page,
1556 struct ocfs2_write_ctxt *wc)
1557{
1558 int ret, written = 0;
1559 loff_t end = pos + len;
1560 struct ocfs2_inode_info *oi = OCFS2_I(inode);
Tiger Yangd9ae49d2009-03-05 11:06:15 +08001561 struct ocfs2_dinode *di = NULL;
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001562
Tao Ma95581562011-02-22 21:33:59 +08001563 trace_ocfs2_try_to_write_inline_data((unsigned long long)oi->ip_blkno,
1564 len, (unsigned long long)pos,
1565 oi->ip_dyn_features);
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001566
1567 /*
1568 * Handle inodes which already have inline data 1st.
1569 */
1570 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1571 if (mmap_page == NULL &&
1572 ocfs2_size_fits_inline_data(wc->w_di_bh, end))
1573 goto do_inline_write;
1574
1575 /*
1576 * The write won't fit - we have to give this inode an
1577 * inline extent list now.
1578 */
1579 ret = ocfs2_convert_inline_data_to_extents(inode, wc->w_di_bh);
1580 if (ret)
1581 mlog_errno(ret);
1582 goto out;
1583 }
1584
1585 /*
1586 * Check whether the inode can accept inline data.
1587 */
1588 if (oi->ip_clusters != 0 || i_size_read(inode) != 0)
1589 return 0;
1590
1591 /*
1592 * Check whether the write can fit.
1593 */
Tiger Yangd9ae49d2009-03-05 11:06:15 +08001594 di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1595 if (mmap_page ||
1596 end > ocfs2_max_inline_data_with_xattr(inode->i_sb, di))
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001597 return 0;
1598
1599do_inline_write:
1600 ret = ocfs2_write_begin_inline(mapping, inode, wc);
1601 if (ret) {
1602 mlog_errno(ret);
1603 goto out;
1604 }
1605
1606 /*
1607 * This signals to the caller that the data can be written
1608 * inline.
1609 */
1610 written = 1;
1611out:
1612 return written ? written : ret;
1613}
1614
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001615/*
1616 * This function only does anything for file systems which can't
1617 * handle sparse files.
1618 *
1619 * What we want to do here is fill in any hole between the current end
1620 * of allocation and the end of our write. That way the rest of the
1621 * write path can treat it as an non-allocating write, which has no
1622 * special case code for sparse/nonsparse files.
1623 */
Joel Becker56934862010-07-01 15:13:31 -07001624static int ocfs2_expand_nonsparse_inode(struct inode *inode,
1625 struct buffer_head *di_bh,
1626 loff_t pos, unsigned len,
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001627 struct ocfs2_write_ctxt *wc)
1628{
1629 int ret;
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001630 loff_t newsize = pos + len;
1631
Joel Becker56934862010-07-01 15:13:31 -07001632 BUG_ON(ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)));
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001633
1634 if (newsize <= i_size_read(inode))
1635 return 0;
1636
Joel Becker56934862010-07-01 15:13:31 -07001637 ret = ocfs2_extend_no_holes(inode, di_bh, newsize, pos);
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001638 if (ret)
1639 mlog_errno(ret);
1640
Ryan Ding46e62552016-03-25 14:21:01 -07001641 /* There is no wc if this is call from direct. */
1642 if (wc)
1643 wc->w_first_new_cpos =
1644 ocfs2_clusters_for_bytes(inode->i_sb, i_size_read(inode));
Sunil Mushrane7432672009-08-06 16:12:58 -07001645
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001646 return ret;
1647}
1648
Joel Becker56934862010-07-01 15:13:31 -07001649static int ocfs2_zero_tail(struct inode *inode, struct buffer_head *di_bh,
1650 loff_t pos)
1651{
1652 int ret = 0;
1653
1654 BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)));
1655 if (pos > i_size_read(inode))
1656 ret = ocfs2_zero_extend(inode, di_bh, pos);
1657
1658 return ret;
1659}
1660
Ryan Dingc1ad1e32016-03-25 14:20:52 -07001661int ocfs2_write_begin_nolock(struct address_space *mapping,
1662 loff_t pos, unsigned len, ocfs2_write_type_t type,
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001663 struct page **pagep, void **fsdata,
1664 struct buffer_head *di_bh, struct page *mmap_page)
1665{
Sunil Mushrane7432672009-08-06 16:12:58 -07001666 int ret, cluster_of_pages, credits = OCFS2_INODE_UPDATE_CREDITS;
Tao Ma50308d82010-11-04 15:14:11 +08001667 unsigned int clusters_to_alloc, extents_to_split, clusters_need = 0;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001668 struct ocfs2_write_ctxt *wc;
1669 struct inode *inode = mapping->host;
1670 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1671 struct ocfs2_dinode *di;
1672 struct ocfs2_alloc_context *data_ac = NULL;
1673 struct ocfs2_alloc_context *meta_ac = NULL;
1674 handle_t *handle;
Joel Beckerf99b9b72008-08-20 19:36:33 -07001675 struct ocfs2_extent_tree et;
Tao Ma50308d82010-11-04 15:14:11 +08001676 int try_free = 1, ret1;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001677
Tao Ma50308d82010-11-04 15:14:11 +08001678try_again:
Ryan Dingc1ad1e32016-03-25 14:20:52 -07001679 ret = ocfs2_alloc_write_ctxt(&wc, osb, pos, len, type, di_bh);
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001680 if (ret) {
1681 mlog_errno(ret);
1682 return ret;
1683 }
1684
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001685 if (ocfs2_supports_inline_data(osb)) {
1686 ret = ocfs2_try_to_write_inline_data(mapping, inode, pos, len,
1687 mmap_page, wc);
1688 if (ret == 1) {
1689 ret = 0;
1690 goto success;
1691 }
1692 if (ret < 0) {
1693 mlog_errno(ret);
1694 goto out;
1695 }
1696 }
1697
Ryan Ding46e62552016-03-25 14:21:01 -07001698 /* Direct io change i_size late, should not zero tail here. */
1699 if (type != OCFS2_WRITE_DIRECT) {
1700 if (ocfs2_sparse_alloc(osb))
1701 ret = ocfs2_zero_tail(inode, di_bh, pos);
1702 else
1703 ret = ocfs2_expand_nonsparse_inode(inode, di_bh, pos,
1704 len, wc);
1705 if (ret) {
1706 mlog_errno(ret);
1707 goto out;
1708 }
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001709 }
1710
Tao Ma293b2f72009-08-25 08:02:48 +08001711 ret = ocfs2_check_range_for_refcount(inode, pos, len);
1712 if (ret < 0) {
1713 mlog_errno(ret);
1714 goto out;
1715 } else if (ret == 1) {
Tao Ma50308d82010-11-04 15:14:11 +08001716 clusters_need = wc->w_clen;
Tiger Yangc7dd3392013-08-13 16:00:58 -07001717 ret = ocfs2_refcount_cow(inode, di_bh,
Tao Ma37f8a2b2009-08-26 09:47:28 +08001718 wc->w_cpos, wc->w_clen, UINT_MAX);
Tao Ma293b2f72009-08-25 08:02:48 +08001719 if (ret) {
1720 mlog_errno(ret);
1721 goto out;
1722 }
1723 }
1724
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001725 ret = ocfs2_populate_write_desc(inode, wc, &clusters_to_alloc,
1726 &extents_to_split);
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001727 if (ret) {
1728 mlog_errno(ret);
1729 goto out;
1730 }
Tao Ma50308d82010-11-04 15:14:11 +08001731 clusters_need += clusters_to_alloc;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001732
1733 di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1734
Tao Ma95581562011-02-22 21:33:59 +08001735 trace_ocfs2_write_begin_nolock(
1736 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1737 (long long)i_size_read(inode),
1738 le32_to_cpu(di->i_clusters),
Ryan Dingc1ad1e32016-03-25 14:20:52 -07001739 pos, len, type, mmap_page,
Tao Ma95581562011-02-22 21:33:59 +08001740 clusters_to_alloc, extents_to_split);
1741
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001742 /*
1743 * We set w_target_from, w_target_to here so that
1744 * ocfs2_write_end() knows which range in the target page to
1745 * write out. An allocation requires that we write the entire
1746 * cluster range.
1747 */
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001748 if (clusters_to_alloc || extents_to_split) {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001749 /*
1750 * XXX: We are stretching the limits of
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001751 * ocfs2_lock_allocators(). It greatly over-estimates
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001752 * the work to be done.
1753 */
Joel Becker5e404e92009-02-13 03:54:22 -08001754 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode),
1755 wc->w_di_bh);
Joel Beckerf99b9b72008-08-20 19:36:33 -07001756 ret = ocfs2_lock_allocators(inode, &et,
Tao Ma231b87d2008-08-18 17:38:42 +08001757 clusters_to_alloc, extents_to_split,
Joel Beckerf99b9b72008-08-20 19:36:33 -07001758 &data_ac, &meta_ac);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001759 if (ret) {
1760 mlog_errno(ret);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001761 goto out;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001762 }
1763
Mark Fasheh4fe370a2009-12-07 13:15:40 -08001764 if (data_ac)
1765 data_ac->ac_resv = &OCFS2_I(inode)->ip_la_data_resv;
1766
Tao Ma811f9332008-08-18 17:38:43 +08001767 credits = ocfs2_calc_extend_credits(inode->i_sb,
Goldwyn Rodrigues06f9da62013-11-12 15:06:52 -08001768 &di->id2.i_list);
Ryan Ding46e62552016-03-25 14:21:01 -07001769 } else if (type == OCFS2_WRITE_DIRECT)
1770 /* direct write needs not to start trans if no extents alloc. */
1771 goto success;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001772
Sunil Mushrane7432672009-08-06 16:12:58 -07001773 /*
1774 * We have to zero sparse allocated clusters, unwritten extent clusters,
1775 * and non-sparse clusters we just extended. For non-sparse writes,
1776 * we know zeros will only be needed in the first and/or last cluster.
1777 */
Ryan Ding4506cfb2016-03-25 14:21:06 -07001778 if (wc->w_clen && (wc->w_desc[0].c_needs_zero ||
1779 wc->w_desc[wc->w_clen - 1].c_needs_zero))
Sunil Mushrane7432672009-08-06 16:12:58 -07001780 cluster_of_pages = 1;
1781 else
1782 cluster_of_pages = 0;
1783
1784 ocfs2_set_target_boundaries(osb, wc, pos, len, cluster_of_pages);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001785
Mark Fasheh9517bac2007-02-09 20:24:12 -08001786 handle = ocfs2_start_trans(osb, credits);
1787 if (IS_ERR(handle)) {
1788 ret = PTR_ERR(handle);
1789 mlog_errno(ret);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001790 goto out;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001791 }
1792
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001793 wc->w_handle = handle;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001794
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001795 if (clusters_to_alloc) {
1796 ret = dquot_alloc_space_nodirty(inode,
1797 ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc));
1798 if (ret)
1799 goto out_commit;
Jan Karaa90714c2008-10-09 19:38:40 +02001800 }
yangwenfang7f27ec92015-09-04 15:44:45 -07001801
Joel Becker0cf2f762009-02-12 16:41:25 -08001802 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), wc->w_di_bh,
Joel Becker13723d02008-10-17 19:25:01 -07001803 OCFS2_JOURNAL_ACCESS_WRITE);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001804 if (ret) {
1805 mlog_errno(ret);
Jan Karaa90714c2008-10-09 19:38:40 +02001806 goto out_quota;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001807 }
1808
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001809 /*
1810 * Fill our page array first. That way we've grabbed enough so
1811 * that we can zero and flush if we error after adding the
1812 * extent.
1813 */
Joel Becker693c2412010-07-02 17:20:27 -07001814 ret = ocfs2_grab_pages_for_write(mapping, wc, wc->w_cpos, pos, len,
Sunil Mushrane7432672009-08-06 16:12:58 -07001815 cluster_of_pages, mmap_page);
Wengang Wang5cffff92011-07-24 10:36:54 -07001816 if (ret && ret != -EAGAIN) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08001817 mlog_errno(ret);
Jan Karaa90714c2008-10-09 19:38:40 +02001818 goto out_quota;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001819 }
Mark Fasheh9517bac2007-02-09 20:24:12 -08001820
Wengang Wang5cffff92011-07-24 10:36:54 -07001821 /*
1822 * ocfs2_grab_pages_for_write() returns -EAGAIN if it could not lock
1823 * the target page. In this case, we exit with no error and no target
1824 * page. This will trigger the caller, page_mkwrite(), to re-try
1825 * the operation.
1826 */
1827 if (ret == -EAGAIN) {
1828 BUG_ON(wc->w_target_page);
1829 ret = 0;
1830 goto out_quota;
1831 }
1832
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001833 ret = ocfs2_write_cluster_by_desc(mapping, data_ac, meta_ac, wc, pos,
1834 len);
1835 if (ret) {
1836 mlog_errno(ret);
Jan Karaa90714c2008-10-09 19:38:40 +02001837 goto out_quota;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001838 }
1839
1840 if (data_ac)
1841 ocfs2_free_alloc_context(data_ac);
1842 if (meta_ac)
1843 ocfs2_free_alloc_context(meta_ac);
1844
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001845success:
Ryan Ding65c4db82016-03-25 14:20:58 -07001846 if (pagep)
1847 *pagep = wc->w_target_page;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001848 *fsdata = wc;
1849 return 0;
Jan Karaa90714c2008-10-09 19:38:40 +02001850out_quota:
1851 if (clusters_to_alloc)
Christoph Hellwig5dd40562010-03-03 09:05:00 -05001852 dquot_free_space(inode,
Jan Karaa90714c2008-10-09 19:38:40 +02001853 ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc));
Mark Fasheh9517bac2007-02-09 20:24:12 -08001854out_commit:
1855 ocfs2_commit_trans(osb, handle);
1856
Mark Fasheh9517bac2007-02-09 20:24:12 -08001857out:
Eric Renc33f0782016-09-30 15:11:32 -07001858 /*
1859 * The mmapped page won't be unlocked in ocfs2_free_write_ctxt(),
1860 * even in case of error here like ENOSPC and ENOMEM. So, we need
1861 * to unlock the target page manually to prevent deadlocks when
1862 * retrying again on ENOSPC, or when returning non-VM_FAULT_LOCKED
1863 * to VM code.
1864 */
1865 if (wc->w_target_locked)
1866 unlock_page(mmap_page);
1867
Ryan Ding4506cfb2016-03-25 14:21:06 -07001868 ocfs2_free_write_ctxt(inode, wc);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001869
Xue jiufeib1214e42013-11-12 15:07:06 -08001870 if (data_ac) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08001871 ocfs2_free_alloc_context(data_ac);
Xue jiufeib1214e42013-11-12 15:07:06 -08001872 data_ac = NULL;
1873 }
1874 if (meta_ac) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08001875 ocfs2_free_alloc_context(meta_ac);
Xue jiufeib1214e42013-11-12 15:07:06 -08001876 meta_ac = NULL;
1877 }
Tao Ma50308d82010-11-04 15:14:11 +08001878
1879 if (ret == -ENOSPC && try_free) {
1880 /*
1881 * Try to free some truncate log so that we can have enough
1882 * clusters to allocate.
1883 */
1884 try_free = 0;
1885
1886 ret1 = ocfs2_try_to_free_truncate_log(osb, clusters_need);
1887 if (ret1 == 1)
1888 goto try_again;
1889
1890 if (ret1 < 0)
1891 mlog_errno(ret1);
1892 }
1893
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001894 return ret;
1895}
Mark Fasheh9517bac2007-02-09 20:24:12 -08001896
Nick Pigginb6af1bc2007-10-16 01:25:24 -07001897static int ocfs2_write_begin(struct file *file, struct address_space *mapping,
1898 loff_t pos, unsigned len, unsigned flags,
1899 struct page **pagep, void **fsdata)
Mark Fasheh607d44a2007-05-09 15:14:45 -07001900{
1901 int ret;
1902 struct buffer_head *di_bh = NULL;
1903 struct inode *inode = mapping->host;
1904
Mark Fashehe63aecb62007-10-18 15:30:42 -07001905 ret = ocfs2_inode_lock(inode, &di_bh, 1);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001906 if (ret) {
1907 mlog_errno(ret);
1908 return ret;
1909 }
1910
1911 /*
1912 * Take alloc sem here to prevent concurrent lookups. That way
1913 * the mapping, zeroing and tree manipulation within
1914 * ocfs2_write() will be safe against ->readpage(). This
1915 * should also serve to lock out allocation from a shared
1916 * writeable region.
1917 */
1918 down_write(&OCFS2_I(inode)->ip_alloc_sem);
1919
Ryan Dingc1ad1e32016-03-25 14:20:52 -07001920 ret = ocfs2_write_begin_nolock(mapping, pos, len, OCFS2_WRITE_BUFFER,
1921 pagep, fsdata, di_bh, NULL);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001922 if (ret) {
1923 mlog_errno(ret);
Mark Fashehc934a922007-10-18 15:23:46 -07001924 goto out_fail;
Mark Fasheh607d44a2007-05-09 15:14:45 -07001925 }
1926
1927 brelse(di_bh);
1928
1929 return 0;
1930
Mark Fasheh607d44a2007-05-09 15:14:45 -07001931out_fail:
1932 up_write(&OCFS2_I(inode)->ip_alloc_sem);
1933
1934 brelse(di_bh);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001935 ocfs2_inode_unlock(inode, 1);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001936
1937 return ret;
1938}
1939
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001940static void ocfs2_write_end_inline(struct inode *inode, loff_t pos,
1941 unsigned len, unsigned *copied,
1942 struct ocfs2_dinode *di,
1943 struct ocfs2_write_ctxt *wc)
1944{
1945 void *kaddr;
1946
1947 if (unlikely(*copied < len)) {
1948 if (!PageUptodate(wc->w_target_page)) {
1949 *copied = 0;
1950 return;
1951 }
1952 }
1953
Cong Wangc4bc8dc2011-11-25 23:14:34 +08001954 kaddr = kmap_atomic(wc->w_target_page);
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001955 memcpy(di->id2.i_data.id_data + pos, kaddr + pos, *copied);
Cong Wangc4bc8dc2011-11-25 23:14:34 +08001956 kunmap_atomic(kaddr);
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001957
Tao Ma95581562011-02-22 21:33:59 +08001958 trace_ocfs2_write_end_inline(
1959 (unsigned long long)OCFS2_I(inode)->ip_blkno,
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001960 (unsigned long long)pos, *copied,
1961 le16_to_cpu(di->id2.i_data.id_count),
1962 le16_to_cpu(di->i_dyn_features));
1963}
1964
Mark Fasheh7307de82007-05-09 15:16:19 -07001965int ocfs2_write_end_nolock(struct address_space *mapping,
1966 loff_t pos, unsigned len, unsigned copied,
1967 struct page *page, void *fsdata)
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001968{
yangwenfang7f27ec92015-09-04 15:44:45 -07001969 int i, ret;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03001970 unsigned from, to, start = pos & (PAGE_SIZE - 1);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001971 struct inode *inode = mapping->host;
1972 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1973 struct ocfs2_write_ctxt *wc = fsdata;
1974 struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1975 handle_t *handle = wc->w_handle;
1976 struct page *tmppage;
1977
Ryan Ding4506cfb2016-03-25 14:21:06 -07001978 BUG_ON(!list_empty(&wc->w_unwritten_list));
1979
Ryan Ding46e62552016-03-25 14:21:01 -07001980 if (handle) {
1981 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode),
1982 wc->w_di_bh, OCFS2_JOURNAL_ACCESS_WRITE);
1983 if (ret) {
1984 copied = ret;
1985 mlog_errno(ret);
1986 goto out;
1987 }
yangwenfang7f27ec92015-09-04 15:44:45 -07001988 }
1989
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001990 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1991 ocfs2_write_end_inline(inode, pos, len, &copied, di, wc);
1992 goto out_write_size;
1993 }
1994
Ryan Ding65c4db82016-03-25 14:20:58 -07001995 if (unlikely(copied < len) && wc->w_target_page) {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001996 if (!PageUptodate(wc->w_target_page))
1997 copied = 0;
1998
1999 ocfs2_zero_new_buffers(wc->w_target_page, start+copied,
2000 start+len);
2001 }
Ryan Ding65c4db82016-03-25 14:20:58 -07002002 if (wc->w_target_page)
2003 flush_dcache_page(wc->w_target_page);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07002004
2005 for(i = 0; i < wc->w_num_pages; i++) {
2006 tmppage = wc->w_pages[i];
2007
Ryan Ding65c4db82016-03-25 14:20:58 -07002008 /* This is the direct io target page. */
2009 if (tmppage == NULL)
2010 continue;
2011
Mark Fasheh3a307ff2007-05-08 17:47:32 -07002012 if (tmppage == wc->w_target_page) {
2013 from = wc->w_target_from;
2014 to = wc->w_target_to;
2015
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002016 BUG_ON(from > PAGE_SIZE ||
2017 to > PAGE_SIZE ||
Mark Fasheh3a307ff2007-05-08 17:47:32 -07002018 to < from);
2019 } else {
2020 /*
2021 * Pages adjacent to the target (if any) imply
2022 * a hole-filling write in which case we want
2023 * to flush their entire range.
2024 */
2025 from = 0;
Kirill A. Shutemov09cbfea2016-04-01 15:29:47 +03002026 to = PAGE_SIZE;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07002027 }
2028
Sunil Mushran961cecb2008-07-16 17:22:22 -07002029 if (page_has_buffers(tmppage)) {
Ryan Ding46e62552016-03-25 14:21:01 -07002030 if (handle && ocfs2_should_order_data(inode))
2031 ocfs2_jbd2_file_inode(handle, inode);
Sunil Mushran961cecb2008-07-16 17:22:22 -07002032 block_commit_write(tmppage, from, to);
2033 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -07002034 }
2035
Mark Fasheh1afc32b2007-09-07 14:46:51 -07002036out_write_size:
Ryan Ding46e62552016-03-25 14:21:01 -07002037 /* Direct io do not update i_size here. */
2038 if (wc->w_type != OCFS2_WRITE_DIRECT) {
2039 pos += copied;
2040 if (pos > i_size_read(inode)) {
2041 i_size_write(inode, pos);
2042 mark_inode_dirty(inode);
2043 }
2044 inode->i_blocks = ocfs2_inode_sector_count(inode);
2045 di->i_size = cpu_to_le64((u64)i_size_read(inode));
Deepa Dinamani078cd822016-09-14 07:48:04 -07002046 inode->i_mtime = inode->i_ctime = current_time(inode);
Ryan Ding46e62552016-03-25 14:21:01 -07002047 di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec);
2048 di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
2049 ocfs2_update_inode_fsync_trans(handle, inode, 1);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07002050 }
Ryan Ding46e62552016-03-25 14:21:01 -07002051 if (handle)
2052 ocfs2_journal_dirty(handle, wc->w_di_bh);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07002053
yangwenfang7f27ec92015-09-04 15:44:45 -07002054out:
Junxiao Bi136f49b2014-12-18 16:17:37 -08002055 /* unlock pages before dealloc since it needs acquiring j_trans_barrier
2056 * lock, or it will cause a deadlock since journal commit threads holds
2057 * this lock and will ask for the page lock when flushing the data.
2058 * put it here to preserve the unlock order.
2059 */
2060 ocfs2_unlock_pages(wc);
2061
Ryan Ding46e62552016-03-25 14:21:01 -07002062 if (handle)
2063 ocfs2_commit_trans(osb, handle);
Mark Fasheh59a5e412007-06-22 15:52:36 -07002064
Mark Fashehb27b7cb2007-06-18 11:22:56 -07002065 ocfs2_run_deallocs(osb, &wc->w_dealloc);
2066
Junxiao Bi136f49b2014-12-18 16:17:37 -08002067 brelse(wc->w_di_bh);
2068 kfree(wc);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07002069
2070 return copied;
Mark Fasheh9517bac2007-02-09 20:24:12 -08002071}
2072
Nick Pigginb6af1bc2007-10-16 01:25:24 -07002073static int ocfs2_write_end(struct file *file, struct address_space *mapping,
2074 loff_t pos, unsigned len, unsigned copied,
2075 struct page *page, void *fsdata)
Mark Fasheh607d44a2007-05-09 15:14:45 -07002076{
2077 int ret;
2078 struct inode *inode = mapping->host;
2079
2080 ret = ocfs2_write_end_nolock(mapping, pos, len, copied, page, fsdata);
2081
Mark Fasheh607d44a2007-05-09 15:14:45 -07002082 up_write(&OCFS2_I(inode)->ip_alloc_sem);
Mark Fashehe63aecb62007-10-18 15:30:42 -07002083 ocfs2_inode_unlock(inode, 1);
Mark Fasheh607d44a2007-05-09 15:14:45 -07002084
2085 return ret;
2086}
2087
Ryan Dingc15471f2016-03-25 14:21:09 -07002088struct ocfs2_dio_write_ctxt {
2089 struct list_head dw_zero_list;
2090 unsigned dw_zero_count;
2091 int dw_orphaned;
2092 pid_t dw_writer_pid;
2093};
2094
2095static struct ocfs2_dio_write_ctxt *
2096ocfs2_dio_alloc_write_ctx(struct buffer_head *bh, int *alloc)
2097{
2098 struct ocfs2_dio_write_ctxt *dwc = NULL;
2099
2100 if (bh->b_private)
2101 return bh->b_private;
2102
2103 dwc = kmalloc(sizeof(struct ocfs2_dio_write_ctxt), GFP_NOFS);
2104 if (dwc == NULL)
2105 return NULL;
2106 INIT_LIST_HEAD(&dwc->dw_zero_list);
2107 dwc->dw_zero_count = 0;
2108 dwc->dw_orphaned = 0;
2109 dwc->dw_writer_pid = task_pid_nr(current);
2110 bh->b_private = dwc;
2111 *alloc = 1;
2112
2113 return dwc;
2114}
2115
2116static void ocfs2_dio_free_write_ctx(struct inode *inode,
2117 struct ocfs2_dio_write_ctxt *dwc)
2118{
2119 ocfs2_free_unwritten_list(inode, &dwc->dw_zero_list);
2120 kfree(dwc);
2121}
2122
2123/*
2124 * TODO: Make this into a generic get_blocks function.
2125 *
2126 * From do_direct_io in direct-io.c:
2127 * "So what we do is to permit the ->get_blocks function to populate
2128 * bh.b_size with the size of IO which is permitted at this offset and
2129 * this i_blkbits."
2130 *
2131 * This function is called directly from get_more_blocks in direct-io.c.
2132 *
2133 * called like this: dio->get_blocks(dio->inode, fs_startblk,
2134 * fs_count, map_bh, dio->rw == WRITE);
2135 */
alex chen78a65502017-11-15 17:31:44 -08002136static int ocfs2_dio_wr_get_block(struct inode *inode, sector_t iblock,
Ryan Dingc15471f2016-03-25 14:21:09 -07002137 struct buffer_head *bh_result, int create)
2138{
2139 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Ryan Dinga86a72a2016-03-25 14:21:18 -07002140 struct ocfs2_inode_info *oi = OCFS2_I(inode);
Ryan Dingc15471f2016-03-25 14:21:09 -07002141 struct ocfs2_write_ctxt *wc;
2142 struct ocfs2_write_cluster_desc *desc = NULL;
2143 struct ocfs2_dio_write_ctxt *dwc = NULL;
2144 struct buffer_head *di_bh = NULL;
2145 u64 p_blkno;
2146 loff_t pos = iblock << inode->i_sb->s_blocksize_bits;
2147 unsigned len, total_len = bh_result->b_size;
2148 int ret = 0, first_get_block = 0;
2149
2150 len = osb->s_clustersize - (pos & (osb->s_clustersize - 1));
2151 len = min(total_len, len);
2152
2153 mlog(0, "get block of %lu at %llu:%u req %u\n",
2154 inode->i_ino, pos, len, total_len);
2155
Ryan Dingce170822016-03-25 14:21:20 -07002156 /*
2157 * Because we need to change file size in ocfs2_dio_end_io_write(), or
2158 * we may need to add it to orphan dir. So can not fall to fast path
2159 * while file size will be changed.
2160 */
2161 if (pos + total_len <= i_size_read(inode)) {
alex chen78a65502017-11-15 17:31:44 -08002162
Ryan Dingce170822016-03-25 14:21:20 -07002163 /* This is the fast path for re-write. */
alex chen78a65502017-11-15 17:31:44 -08002164 ret = ocfs2_lock_get_block(inode, iblock, bh_result, create);
Ryan Dingce170822016-03-25 14:21:20 -07002165 if (buffer_mapped(bh_result) &&
2166 !buffer_new(bh_result) &&
2167 ret == 0)
2168 goto out;
Ryan Dingc15471f2016-03-25 14:21:09 -07002169
Ryan Dingce170822016-03-25 14:21:20 -07002170 /* Clear state set by ocfs2_get_block. */
2171 bh_result->b_state = 0;
2172 }
Ryan Dingc15471f2016-03-25 14:21:09 -07002173
2174 dwc = ocfs2_dio_alloc_write_ctx(bh_result, &first_get_block);
2175 if (unlikely(dwc == NULL)) {
2176 ret = -ENOMEM;
2177 mlog_errno(ret);
2178 goto out;
2179 }
2180
2181 if (ocfs2_clusters_for_bytes(inode->i_sb, pos + total_len) >
2182 ocfs2_clusters_for_bytes(inode->i_sb, i_size_read(inode)) &&
2183 !dwc->dw_orphaned) {
2184 /*
2185 * when we are going to alloc extents beyond file size, add the
2186 * inode to orphan dir, so we can recall those spaces when
2187 * system crashed during write.
2188 */
2189 ret = ocfs2_add_inode_to_orphan(osb, inode);
2190 if (ret < 0) {
2191 mlog_errno(ret);
2192 goto out;
2193 }
2194 dwc->dw_orphaned = 1;
2195 }
2196
2197 ret = ocfs2_inode_lock(inode, &di_bh, 1);
2198 if (ret) {
2199 mlog_errno(ret);
2200 goto out;
2201 }
2202
Ryan Dinga86a72a2016-03-25 14:21:18 -07002203 down_write(&oi->ip_alloc_sem);
2204
Ryan Dingc15471f2016-03-25 14:21:09 -07002205 if (first_get_block) {
2206 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
2207 ret = ocfs2_zero_tail(inode, di_bh, pos);
2208 else
2209 ret = ocfs2_expand_nonsparse_inode(inode, di_bh, pos,
2210 total_len, NULL);
2211 if (ret < 0) {
2212 mlog_errno(ret);
2213 goto unlock;
2214 }
2215 }
2216
2217 ret = ocfs2_write_begin_nolock(inode->i_mapping, pos, len,
2218 OCFS2_WRITE_DIRECT, NULL,
2219 (void **)&wc, di_bh, NULL);
2220 if (ret) {
2221 mlog_errno(ret);
2222 goto unlock;
2223 }
2224
2225 desc = &wc->w_desc[0];
2226
2227 p_blkno = ocfs2_clusters_to_blocks(inode->i_sb, desc->c_phys);
2228 BUG_ON(p_blkno == 0);
2229 p_blkno += iblock & (u64)(ocfs2_clusters_to_blocks(inode->i_sb, 1) - 1);
2230
2231 map_bh(bh_result, inode->i_sb, p_blkno);
2232 bh_result->b_size = len;
2233 if (desc->c_needs_zero)
2234 set_buffer_new(bh_result);
2235
2236 /* May sleep in end_io. It should not happen in a irq context. So defer
2237 * it to dio work queue. */
2238 set_buffer_defer_completion(bh_result);
2239
2240 if (!list_empty(&wc->w_unwritten_list)) {
2241 struct ocfs2_unwritten_extent *ue = NULL;
2242
2243 ue = list_first_entry(&wc->w_unwritten_list,
2244 struct ocfs2_unwritten_extent,
2245 ue_node);
2246 BUG_ON(ue->ue_cpos != desc->c_cpos);
2247 /* The physical address may be 0, fill it. */
2248 ue->ue_phys = desc->c_phys;
2249
2250 list_splice_tail_init(&wc->w_unwritten_list, &dwc->dw_zero_list);
2251 dwc->dw_zero_count++;
2252 }
2253
2254 ret = ocfs2_write_end_nolock(inode->i_mapping, pos, len, len, NULL, wc);
2255 BUG_ON(ret != len);
2256 ret = 0;
2257unlock:
Ryan Dinga86a72a2016-03-25 14:21:18 -07002258 up_write(&oi->ip_alloc_sem);
Ryan Dingc15471f2016-03-25 14:21:09 -07002259 ocfs2_inode_unlock(inode, 1);
2260 brelse(di_bh);
2261out:
2262 if (ret < 0)
2263 ret = -EIO;
2264 return ret;
2265}
2266
2267static void ocfs2_dio_end_io_write(struct inode *inode,
2268 struct ocfs2_dio_write_ctxt *dwc,
2269 loff_t offset,
2270 ssize_t bytes)
2271{
2272 struct ocfs2_cached_dealloc_ctxt dealloc;
2273 struct ocfs2_extent_tree et;
2274 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Ryan Dinga86a72a2016-03-25 14:21:18 -07002275 struct ocfs2_inode_info *oi = OCFS2_I(inode);
Ryan Dingc15471f2016-03-25 14:21:09 -07002276 struct ocfs2_unwritten_extent *ue = NULL;
2277 struct buffer_head *di_bh = NULL;
2278 struct ocfs2_dinode *di;
2279 struct ocfs2_alloc_context *data_ac = NULL;
2280 struct ocfs2_alloc_context *meta_ac = NULL;
2281 handle_t *handle = NULL;
2282 loff_t end = offset + bytes;
2283 int ret = 0, credits = 0, locked = 0;
2284
2285 ocfs2_init_dealloc_ctxt(&dealloc);
2286
2287 /* We do clear unwritten, delete orphan, change i_size here. If neither
2288 * of these happen, we can skip all this. */
2289 if (list_empty(&dwc->dw_zero_list) &&
2290 end <= i_size_read(inode) &&
2291 !dwc->dw_orphaned)
2292 goto out;
2293
Ryan Dingc15471f2016-03-25 14:21:09 -07002294 /* ocfs2_file_write_iter will get i_mutex, so we need not lock if we
2295 * are in that context. */
2296 if (dwc->dw_writer_pid != task_pid_nr(current)) {
Al Viro7b9743e2016-04-12 00:41:01 -04002297 inode_lock(inode);
Ryan Dingc15471f2016-03-25 14:21:09 -07002298 locked = 1;
2299 }
2300
Ryan Dinga86a72a2016-03-25 14:21:18 -07002301 ret = ocfs2_inode_lock(inode, &di_bh, 1);
2302 if (ret < 0) {
2303 mlog_errno(ret);
2304 goto out;
2305 }
2306
2307 down_write(&oi->ip_alloc_sem);
2308
Ryan Dingc15471f2016-03-25 14:21:09 -07002309 /* Delete orphan before acquire i_mutex. */
2310 if (dwc->dw_orphaned) {
2311 BUG_ON(dwc->dw_writer_pid != task_pid_nr(current));
2312
2313 end = end > i_size_read(inode) ? end : 0;
2314
2315 ret = ocfs2_del_inode_from_orphan(osb, inode, di_bh,
2316 !!end, end);
2317 if (ret < 0)
2318 mlog_errno(ret);
2319 }
2320
2321 di = (struct ocfs2_dinode *)di_bh;
2322
2323 ocfs2_init_dinode_extent_tree(&et, INODE_CACHE(inode), di_bh);
2324
2325 ret = ocfs2_lock_allocators(inode, &et, 0, dwc->dw_zero_count*2,
2326 &data_ac, &meta_ac);
Ryan Ding28888682016-03-25 14:21:23 -07002327 if (ret) {
2328 mlog_errno(ret);
2329 goto unlock;
2330 }
Ryan Dingc15471f2016-03-25 14:21:09 -07002331
2332 credits = ocfs2_calc_extend_credits(inode->i_sb, &di->id2.i_list);
2333
2334 handle = ocfs2_start_trans(osb, credits);
2335 if (IS_ERR(handle)) {
2336 ret = PTR_ERR(handle);
2337 mlog_errno(ret);
2338 goto unlock;
2339 }
2340 ret = ocfs2_journal_access_di(handle, INODE_CACHE(inode), di_bh,
2341 OCFS2_JOURNAL_ACCESS_WRITE);
2342 if (ret) {
2343 mlog_errno(ret);
2344 goto commit;
2345 }
2346
2347 list_for_each_entry(ue, &dwc->dw_zero_list, ue_node) {
2348 ret = ocfs2_mark_extent_written(inode, &et, handle,
2349 ue->ue_cpos, 1,
2350 ue->ue_phys,
2351 meta_ac, &dealloc);
2352 if (ret < 0) {
2353 mlog_errno(ret);
2354 break;
2355 }
2356 }
2357
2358 if (end > i_size_read(inode)) {
2359 ret = ocfs2_set_inode_size(handle, inode, di_bh, end);
2360 if (ret < 0)
2361 mlog_errno(ret);
2362 }
2363commit:
2364 ocfs2_commit_trans(osb, handle);
2365unlock:
Ryan Dinga86a72a2016-03-25 14:21:18 -07002366 up_write(&oi->ip_alloc_sem);
Ryan Dingc15471f2016-03-25 14:21:09 -07002367 ocfs2_inode_unlock(inode, 1);
2368 brelse(di_bh);
2369out:
Ryan Dingc15471f2016-03-25 14:21:09 -07002370 if (data_ac)
2371 ocfs2_free_alloc_context(data_ac);
2372 if (meta_ac)
2373 ocfs2_free_alloc_context(meta_ac);
Ryan Ding28888682016-03-25 14:21:23 -07002374 ocfs2_run_deallocs(osb, &dealloc);
2375 if (locked)
Al Viro7b9743e2016-04-12 00:41:01 -04002376 inode_unlock(inode);
Ryan Ding28888682016-03-25 14:21:23 -07002377 ocfs2_dio_free_write_ctx(inode, dwc);
Ryan Dingc15471f2016-03-25 14:21:09 -07002378}
2379
2380/*
2381 * ocfs2_dio_end_io is called by the dio core when a dio is finished. We're
2382 * particularly interested in the aio/dio case. We use the rw_lock DLM lock
2383 * to protect io on one node from truncation on another.
2384 */
2385static int ocfs2_dio_end_io(struct kiocb *iocb,
2386 loff_t offset,
2387 ssize_t bytes,
2388 void *private)
2389{
2390 struct inode *inode = file_inode(iocb->ki_filp);
2391 int level;
2392
2393 if (bytes <= 0)
2394 return 0;
2395
2396 /* this io's submitter should not have unlocked this before we could */
2397 BUG_ON(!ocfs2_iocb_is_rw_locked(iocb));
2398
Ryan Dingc15471f2016-03-25 14:21:09 -07002399 if (private)
2400 ocfs2_dio_end_io_write(inode, private, offset, bytes);
2401
2402 ocfs2_iocb_clear_rw_locked(iocb);
2403
2404 level = ocfs2_iocb_rw_locked_level(iocb);
2405 ocfs2_rw_unlock(inode, level);
2406 return 0;
2407}
2408
Christoph Hellwigc8b8e322016-04-07 08:51:58 -07002409static ssize_t ocfs2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
Ryan Dingc15471f2016-03-25 14:21:09 -07002410{
2411 struct file *file = iocb->ki_filp;
Al Viro93c76a32015-12-04 23:45:44 -05002412 struct inode *inode = file->f_mapping->host;
Ryan Dingc15471f2016-03-25 14:21:09 -07002413 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Ryan Dingc15471f2016-03-25 14:21:09 -07002414 get_block_t *get_block;
2415
2416 /*
2417 * Fallback to buffered I/O if we see an inode without
2418 * extents.
2419 */
2420 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
2421 return 0;
2422
2423 /* Fallback to buffered I/O if we do not support append dio. */
Christoph Hellwigc8b8e322016-04-07 08:51:58 -07002424 if (iocb->ki_pos + iter->count > i_size_read(inode) &&
2425 !ocfs2_supports_append_dio(osb))
Ryan Dingc15471f2016-03-25 14:21:09 -07002426 return 0;
2427
2428 if (iov_iter_rw(iter) == READ)
alex chen78a65502017-11-15 17:31:44 -08002429 get_block = ocfs2_lock_get_block;
Ryan Dingc15471f2016-03-25 14:21:09 -07002430 else
alex chen78a65502017-11-15 17:31:44 -08002431 get_block = ocfs2_dio_wr_get_block;
Ryan Dingc15471f2016-03-25 14:21:09 -07002432
2433 return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev,
Christoph Hellwigc8b8e322016-04-07 08:51:58 -07002434 iter, get_block,
Ryan Dingc15471f2016-03-25 14:21:09 -07002435 ocfs2_dio_end_io, NULL, 0);
2436}
2437
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002438const struct address_space_operations ocfs2_aops = {
Hisashi Hifumi1fca3a02009-03-05 17:22:21 +09002439 .readpage = ocfs2_readpage,
2440 .readpages = ocfs2_readpages,
2441 .writepage = ocfs2_writepage,
2442 .write_begin = ocfs2_write_begin,
2443 .write_end = ocfs2_write_end,
2444 .bmap = ocfs2_bmap,
Hisashi Hifumi1fca3a02009-03-05 17:22:21 +09002445 .direct_IO = ocfs2_direct_IO,
Jan Kara41ecc342013-11-12 15:07:08 -08002446 .invalidatepage = block_invalidatepage,
Hisashi Hifumi1fca3a02009-03-05 17:22:21 +09002447 .releasepage = ocfs2_releasepage,
2448 .migratepage = buffer_migrate_page,
2449 .is_partially_uptodate = block_is_partially_uptodate,
Andi Kleenaa261f52009-09-16 11:50:16 +02002450 .error_remove_page = generic_error_remove_page,
Mark Fashehccd979b2005-12-15 14:31:24 -08002451};