blob: a067a6cffb01b43c43809d0ceefd4eb3aca28557 [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>
Mark Fashehccd979b2005-12-15 14:31:24 -080031
32#define MLOG_MASK_PREFIX ML_FILE_IO
33#include <cluster/masklog.h>
34
35#include "ocfs2.h"
36
37#include "alloc.h"
38#include "aops.h"
39#include "dlmglue.h"
40#include "extent_map.h"
41#include "file.h"
42#include "inode.h"
43#include "journal.h"
Mark Fasheh9517bac2007-02-09 20:24:12 -080044#include "suballoc.h"
Mark Fashehccd979b2005-12-15 14:31:24 -080045#include "super.h"
46#include "symlink.h"
47
48#include "buffer_head_io.h"
49
50static int ocfs2_symlink_get_block(struct inode *inode, sector_t iblock,
51 struct buffer_head *bh_result, int create)
52{
53 int err = -EIO;
54 int status;
55 struct ocfs2_dinode *fe = NULL;
56 struct buffer_head *bh = NULL;
57 struct buffer_head *buffer_cache_bh = NULL;
58 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
59 void *kaddr;
60
61 mlog_entry("(0x%p, %llu, 0x%p, %d)\n", inode,
62 (unsigned long long)iblock, bh_result, create);
63
64 BUG_ON(ocfs2_inode_is_fast_symlink(inode));
65
66 if ((iblock << inode->i_sb->s_blocksize_bits) > PATH_MAX + 1) {
67 mlog(ML_ERROR, "block offset > PATH_MAX: %llu",
68 (unsigned long long)iblock);
69 goto bail;
70 }
71
Joel Beckerb657c952008-11-13 14:49:11 -080072 status = ocfs2_read_inode_block(inode, &bh);
Mark Fashehccd979b2005-12-15 14:31:24 -080073 if (status < 0) {
74 mlog_errno(status);
75 goto bail;
76 }
77 fe = (struct ocfs2_dinode *) bh->b_data;
78
Mark Fashehccd979b2005-12-15 14:31:24 -080079 if ((u64)iblock >= ocfs2_clusters_to_blocks(inode->i_sb,
80 le32_to_cpu(fe->i_clusters))) {
81 mlog(ML_ERROR, "block offset is outside the allocated size: "
82 "%llu\n", (unsigned long long)iblock);
83 goto bail;
84 }
85
86 /* We don't use the page cache to create symlink data, so if
87 * need be, copy it over from the buffer cache. */
88 if (!buffer_uptodate(bh_result) && ocfs2_inode_is_new(inode)) {
89 u64 blkno = le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) +
90 iblock;
91 buffer_cache_bh = sb_getblk(osb->sb, blkno);
92 if (!buffer_cache_bh) {
93 mlog(ML_ERROR, "couldn't getblock for symlink!\n");
94 goto bail;
95 }
96
97 /* we haven't locked out transactions, so a commit
98 * could've happened. Since we've got a reference on
99 * the bh, even if it commits while we're doing the
100 * copy, the data is still good. */
101 if (buffer_jbd(buffer_cache_bh)
102 && ocfs2_inode_is_new(inode)) {
103 kaddr = kmap_atomic(bh_result->b_page, KM_USER0);
104 if (!kaddr) {
105 mlog(ML_ERROR, "couldn't kmap!\n");
106 goto bail;
107 }
108 memcpy(kaddr + (bh_result->b_size * iblock),
109 buffer_cache_bh->b_data,
110 bh_result->b_size);
111 kunmap_atomic(kaddr, KM_USER0);
112 set_buffer_uptodate(bh_result);
113 }
114 brelse(buffer_cache_bh);
115 }
116
117 map_bh(bh_result, inode->i_sb,
118 le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) + iblock);
119
120 err = 0;
121
122bail:
Mark Fasheha81cb882008-10-07 14:25:16 -0700123 brelse(bh);
Mark Fashehccd979b2005-12-15 14:31:24 -0800124
125 mlog_exit(err);
126 return err;
127}
128
129static int ocfs2_get_block(struct inode *inode, sector_t iblock,
130 struct buffer_head *bh_result, int create)
131{
132 int err = 0;
Mark Fasheh49cb8d22007-03-09 16:21:46 -0800133 unsigned int ext_flags;
Mark Fasheh628a24f2007-10-30 12:08:32 -0700134 u64 max_blocks = bh_result->b_size >> inode->i_blkbits;
135 u64 p_blkno, count, past_eof;
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800136 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Mark Fashehccd979b2005-12-15 14:31:24 -0800137
138 mlog_entry("(0x%p, %llu, 0x%p, %d)\n", inode,
139 (unsigned long long)iblock, bh_result, create);
140
141 if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE)
142 mlog(ML_NOTICE, "get_block on system inode 0x%p (%lu)\n",
143 inode, inode->i_ino);
144
145 if (S_ISLNK(inode->i_mode)) {
146 /* this always does I/O for some reason. */
147 err = ocfs2_symlink_get_block(inode, iblock, bh_result, create);
148 goto bail;
149 }
150
Mark Fasheh628a24f2007-10-30 12:08:32 -0700151 err = ocfs2_extent_map_get_blocks(inode, iblock, &p_blkno, &count,
Mark Fasheh49cb8d22007-03-09 16:21:46 -0800152 &ext_flags);
Mark Fashehccd979b2005-12-15 14:31:24 -0800153 if (err) {
154 mlog(ML_ERROR, "Error %d from get_blocks(0x%p, %llu, 1, "
Mark Fashehb0697052006-03-03 10:24:33 -0800155 "%llu, NULL)\n", err, inode, (unsigned long long)iblock,
156 (unsigned long long)p_blkno);
Mark Fashehccd979b2005-12-15 14:31:24 -0800157 goto bail;
158 }
159
Mark Fasheh628a24f2007-10-30 12:08:32 -0700160 if (max_blocks < count)
161 count = max_blocks;
162
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800163 /*
164 * ocfs2 never allocates in this function - the only time we
165 * need to use BH_New is when we're extending i_size on a file
166 * system which doesn't support holes, in which case BH_New
167 * allows block_prepare_write() to zero.
Coly Lic0420ad2008-06-30 18:45:45 +0800168 *
169 * If we see this on a sparse file system, then a truncate has
170 * raced us and removed the cluster. In this case, we clear
171 * the buffers dirty and uptodate bits and let the buffer code
172 * ignore it as a hole.
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800173 */
Coly Lic0420ad2008-06-30 18:45:45 +0800174 if (create && p_blkno == 0 && ocfs2_sparse_alloc(osb)) {
175 clear_buffer_dirty(bh_result);
176 clear_buffer_uptodate(bh_result);
177 goto bail;
178 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800179
Mark Fasheh49cb8d22007-03-09 16:21:46 -0800180 /* Treat the unwritten extent as a hole for zeroing purposes. */
181 if (p_blkno && !(ext_flags & OCFS2_EXT_UNWRITTEN))
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800182 map_bh(bh_result, inode->i_sb, p_blkno);
183
Mark Fasheh628a24f2007-10-30 12:08:32 -0700184 bh_result->b_size = count << inode->i_blkbits;
185
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800186 if (!ocfs2_sparse_alloc(osb)) {
187 if (p_blkno == 0) {
188 err = -EIO;
189 mlog(ML_ERROR,
190 "iblock = %llu p_blkno = %llu blkno=(%llu)\n",
191 (unsigned long long)iblock,
192 (unsigned long long)p_blkno,
193 (unsigned long long)OCFS2_I(inode)->ip_blkno);
194 mlog(ML_ERROR, "Size %llu, clusters %u\n", (unsigned long long)i_size_read(inode), OCFS2_I(inode)->ip_clusters);
195 dump_stack();
196 }
197
198 past_eof = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));
199 mlog(0, "Inode %lu, past_eof = %llu\n", inode->i_ino,
200 (unsigned long long)past_eof);
201
202 if (create && (iblock >= past_eof))
203 set_buffer_new(bh_result);
Mark Fashehccd979b2005-12-15 14:31:24 -0800204 }
205
Mark Fashehccd979b2005-12-15 14:31:24 -0800206bail:
207 if (err < 0)
208 err = -EIO;
209
210 mlog_exit(err);
211 return err;
212}
213
Mark Fasheh1afc32b2007-09-07 14:46:51 -0700214int ocfs2_read_inline_data(struct inode *inode, struct page *page,
215 struct buffer_head *di_bh)
Mark Fasheh6798d352007-09-07 14:05:51 -0700216{
217 void *kaddr;
Jan Karad2849fb2007-12-19 15:24:09 +0100218 loff_t size;
Mark Fasheh6798d352007-09-07 14:05:51 -0700219 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
220
221 if (!(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL)) {
222 ocfs2_error(inode->i_sb, "Inode %llu lost inline data flag",
223 (unsigned long long)OCFS2_I(inode)->ip_blkno);
224 return -EROFS;
225 }
226
227 size = i_size_read(inode);
228
229 if (size > PAGE_CACHE_SIZE ||
230 size > ocfs2_max_inline_data(inode->i_sb)) {
231 ocfs2_error(inode->i_sb,
Jan Karad2849fb2007-12-19 15:24:09 +0100232 "Inode %llu has with inline data has bad size: %Lu",
233 (unsigned long long)OCFS2_I(inode)->ip_blkno,
234 (unsigned long long)size);
Mark Fasheh6798d352007-09-07 14:05:51 -0700235 return -EROFS;
236 }
237
238 kaddr = kmap_atomic(page, KM_USER0);
239 if (size)
240 memcpy(kaddr, di->id2.i_data.id_data, size);
241 /* Clear the remaining part of the page */
242 memset(kaddr + size, 0, PAGE_CACHE_SIZE - size);
243 flush_dcache_page(page);
244 kunmap_atomic(kaddr, KM_USER0);
245
246 SetPageUptodate(page);
247
248 return 0;
249}
250
251static int ocfs2_readpage_inline(struct inode *inode, struct page *page)
252{
253 int ret;
254 struct buffer_head *di_bh = NULL;
Mark Fasheh6798d352007-09-07 14:05:51 -0700255
256 BUG_ON(!PageLocked(page));
Julia Lawall86c838b2008-02-26 21:45:56 +0100257 BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL));
Mark Fasheh6798d352007-09-07 14:05:51 -0700258
Joel Beckerb657c952008-11-13 14:49:11 -0800259 ret = ocfs2_read_inode_block(inode, &di_bh);
Mark Fasheh6798d352007-09-07 14:05:51 -0700260 if (ret) {
261 mlog_errno(ret);
262 goto out;
263 }
264
265 ret = ocfs2_read_inline_data(inode, page, di_bh);
266out:
267 unlock_page(page);
268
269 brelse(di_bh);
270 return ret;
271}
272
Mark Fashehccd979b2005-12-15 14:31:24 -0800273static int ocfs2_readpage(struct file *file, struct page *page)
274{
275 struct inode *inode = page->mapping->host;
Mark Fasheh6798d352007-09-07 14:05:51 -0700276 struct ocfs2_inode_info *oi = OCFS2_I(inode);
Mark Fashehccd979b2005-12-15 14:31:24 -0800277 loff_t start = (loff_t)page->index << PAGE_CACHE_SHIFT;
278 int ret, unlock = 1;
279
280 mlog_entry("(0x%p, %lu)\n", file, (page ? page->index : 0));
281
Mark Fashehe63aecb62007-10-18 15:30:42 -0700282 ret = ocfs2_inode_lock_with_page(inode, NULL, 0, page);
Mark Fashehccd979b2005-12-15 14:31:24 -0800283 if (ret != 0) {
284 if (ret == AOP_TRUNCATED_PAGE)
285 unlock = 0;
286 mlog_errno(ret);
287 goto out;
288 }
289
Mark Fasheh6798d352007-09-07 14:05:51 -0700290 if (down_read_trylock(&oi->ip_alloc_sem) == 0) {
Mark Fashehe9dfc0b2007-05-14 11:38:51 -0700291 ret = AOP_TRUNCATED_PAGE;
Mark Fashehe63aecb62007-10-18 15:30:42 -0700292 goto out_inode_unlock;
Mark Fashehe9dfc0b2007-05-14 11:38:51 -0700293 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800294
295 /*
296 * i_size might have just been updated as we grabed the meta lock. We
297 * might now be discovering a truncate that hit on another node.
298 * block_read_full_page->get_block freaks out if it is asked to read
299 * beyond the end of a file, so we check here. Callers
Nick Piggin54cb8822007-07-19 01:46:59 -0700300 * (generic_file_read, vm_ops->fault) are clever enough to check i_size
Mark Fashehccd979b2005-12-15 14:31:24 -0800301 * and notice that the page they just read isn't needed.
302 *
303 * XXX sys_readahead() seems to get that wrong?
304 */
305 if (start >= i_size_read(inode)) {
Christoph Lametereebd2aa2008-02-04 22:28:29 -0800306 zero_user(page, 0, PAGE_SIZE);
Mark Fashehccd979b2005-12-15 14:31:24 -0800307 SetPageUptodate(page);
308 ret = 0;
309 goto out_alloc;
310 }
311
Mark Fasheh6798d352007-09-07 14:05:51 -0700312 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
313 ret = ocfs2_readpage_inline(inode, page);
314 else
315 ret = block_read_full_page(page, ocfs2_get_block);
Mark Fashehccd979b2005-12-15 14:31:24 -0800316 unlock = 0;
317
Mark Fashehccd979b2005-12-15 14:31:24 -0800318out_alloc:
319 up_read(&OCFS2_I(inode)->ip_alloc_sem);
Mark Fashehe63aecb62007-10-18 15:30:42 -0700320out_inode_unlock:
321 ocfs2_inode_unlock(inode, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -0800322out:
323 if (unlock)
324 unlock_page(page);
325 mlog_exit(ret);
326 return ret;
327}
328
Mark Fasheh628a24f2007-10-30 12:08:32 -0700329/*
330 * This is used only for read-ahead. Failures or difficult to handle
331 * situations are safe to ignore.
332 *
333 * Right now, we don't bother with BH_Boundary - in-inode extent lists
334 * are quite large (243 extents on 4k blocks), so most inodes don't
335 * grow out to a tree. If need be, detecting boundary extents could
336 * trivially be added in a future version of ocfs2_get_block().
337 */
338static int ocfs2_readpages(struct file *filp, struct address_space *mapping,
339 struct list_head *pages, unsigned nr_pages)
340{
341 int ret, err = -EIO;
342 struct inode *inode = mapping->host;
343 struct ocfs2_inode_info *oi = OCFS2_I(inode);
344 loff_t start;
345 struct page *last;
346
347 /*
348 * Use the nonblocking flag for the dlm code to avoid page
349 * lock inversion, but don't bother with retrying.
350 */
351 ret = ocfs2_inode_lock_full(inode, NULL, 0, OCFS2_LOCK_NONBLOCK);
352 if (ret)
353 return err;
354
355 if (down_read_trylock(&oi->ip_alloc_sem) == 0) {
356 ocfs2_inode_unlock(inode, 0);
357 return err;
358 }
359
360 /*
361 * Don't bother with inline-data. There isn't anything
362 * to read-ahead in that case anyway...
363 */
364 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
365 goto out_unlock;
366
367 /*
368 * Check whether a remote node truncated this file - we just
369 * drop out in that case as it's not worth handling here.
370 */
371 last = list_entry(pages->prev, struct page, lru);
372 start = (loff_t)last->index << PAGE_CACHE_SHIFT;
373 if (start >= i_size_read(inode))
374 goto out_unlock;
375
376 err = mpage_readpages(mapping, pages, nr_pages, ocfs2_get_block);
377
378out_unlock:
379 up_read(&oi->ip_alloc_sem);
380 ocfs2_inode_unlock(inode, 0);
381
382 return err;
383}
384
Mark Fashehccd979b2005-12-15 14:31:24 -0800385/* Note: Because we don't support holes, our allocation has
386 * already happened (allocation writes zeros to the file data)
387 * so we don't have to worry about ordered writes in
388 * ocfs2_writepage.
389 *
390 * ->writepage is called during the process of invalidating the page cache
391 * during blocked lock processing. It can't block on any cluster locks
392 * to during block mapping. It's relying on the fact that the block
393 * mapping can't have disappeared under the dirty pages that it is
394 * being asked to write back.
395 */
396static int ocfs2_writepage(struct page *page, struct writeback_control *wbc)
397{
398 int ret;
399
400 mlog_entry("(0x%p)\n", page);
401
402 ret = block_write_full_page(page, ocfs2_get_block, wbc);
403
404 mlog_exit(ret);
405
406 return ret;
407}
408
Mark Fasheh50691202007-02-09 20:52:53 -0800409/*
410 * This is called from ocfs2_write_zero_page() which has handled it's
411 * own cluster locking and has ensured allocation exists for those
412 * blocks to be written.
413 */
Mark Fasheh53013cb2006-05-05 19:04:03 -0700414int ocfs2_prepare_write_nolock(struct inode *inode, struct page *page,
415 unsigned from, unsigned to)
416{
417 int ret;
418
Mark Fasheh53013cb2006-05-05 19:04:03 -0700419 ret = block_prepare_write(page, from, to, ocfs2_get_block);
420
Mark Fasheh53013cb2006-05-05 19:04:03 -0700421 return ret;
422}
423
Mark Fashehccd979b2005-12-15 14:31:24 -0800424/* Taken from ext3. We don't necessarily need the full blown
425 * functionality yet, but IMHO it's better to cut and paste the whole
426 * thing so we can avoid introducing our own bugs (and easily pick up
427 * their fixes when they happen) --Mark */
Mark Fasheh60b11392007-02-16 11:46:50 -0800428int walk_page_buffers( handle_t *handle,
429 struct buffer_head *head,
430 unsigned from,
431 unsigned to,
432 int *partial,
433 int (*fn)( handle_t *handle,
434 struct buffer_head *bh))
Mark Fashehccd979b2005-12-15 14:31:24 -0800435{
436 struct buffer_head *bh;
437 unsigned block_start, block_end;
438 unsigned blocksize = head->b_size;
439 int err, ret = 0;
440 struct buffer_head *next;
441
442 for ( bh = head, block_start = 0;
443 ret == 0 && (bh != head || !block_start);
444 block_start = block_end, bh = next)
445 {
446 next = bh->b_this_page;
447 block_end = block_start + blocksize;
448 if (block_end <= from || block_start >= to) {
449 if (partial && !buffer_uptodate(bh))
450 *partial = 1;
451 continue;
452 }
453 err = (*fn)(handle, bh);
454 if (!ret)
455 ret = err;
456 }
457 return ret;
458}
459
Mark Fasheh1fabe142006-10-09 18:11:45 -0700460handle_t *ocfs2_start_walk_page_trans(struct inode *inode,
Mark Fashehccd979b2005-12-15 14:31:24 -0800461 struct page *page,
462 unsigned from,
463 unsigned to)
464{
465 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
Julia Lawall58dadcd2008-03-28 14:43:10 -0700466 handle_t *handle;
Mark Fashehccd979b2005-12-15 14:31:24 -0800467 int ret = 0;
468
Mark Fasheh65eff9c2006-10-09 17:26:22 -0700469 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
Julia Lawall58dadcd2008-03-28 14:43:10 -0700470 if (IS_ERR(handle)) {
Mark Fashehccd979b2005-12-15 14:31:24 -0800471 ret = -ENOMEM;
472 mlog_errno(ret);
473 goto out;
474 }
475
476 if (ocfs2_should_order_data(inode)) {
Joel Becker2b4e30f2008-09-03 20:03:41 -0700477 ret = ocfs2_jbd2_file_inode(handle, inode);
Joel Becker2b4e30f2008-09-03 20:03:41 -0700478 if (ret < 0)
Mark Fashehccd979b2005-12-15 14:31:24 -0800479 mlog_errno(ret);
480 }
481out:
482 if (ret) {
Julia Lawall58dadcd2008-03-28 14:43:10 -0700483 if (!IS_ERR(handle))
Mark Fasheh02dc1af2006-10-09 16:48:10 -0700484 ocfs2_commit_trans(osb, handle);
Mark Fashehccd979b2005-12-15 14:31:24 -0800485 handle = ERR_PTR(ret);
486 }
487 return handle;
488}
489
Mark Fashehccd979b2005-12-15 14:31:24 -0800490static sector_t ocfs2_bmap(struct address_space *mapping, sector_t block)
491{
492 sector_t status;
493 u64 p_blkno = 0;
494 int err = 0;
495 struct inode *inode = mapping->host;
496
497 mlog_entry("(block = %llu)\n", (unsigned long long)block);
498
499 /* We don't need to lock journal system files, since they aren't
500 * accessed concurrently from multiple nodes.
501 */
502 if (!INODE_JOURNAL(inode)) {
Mark Fashehe63aecb62007-10-18 15:30:42 -0700503 err = ocfs2_inode_lock(inode, NULL, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -0800504 if (err) {
505 if (err != -ENOENT)
506 mlog_errno(err);
507 goto bail;
508 }
509 down_read(&OCFS2_I(inode)->ip_alloc_sem);
510 }
511
Mark Fasheh6798d352007-09-07 14:05:51 -0700512 if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL))
513 err = ocfs2_extent_map_get_blocks(inode, block, &p_blkno, NULL,
514 NULL);
Mark Fashehccd979b2005-12-15 14:31:24 -0800515
516 if (!INODE_JOURNAL(inode)) {
517 up_read(&OCFS2_I(inode)->ip_alloc_sem);
Mark Fashehe63aecb62007-10-18 15:30:42 -0700518 ocfs2_inode_unlock(inode, 0);
Mark Fashehccd979b2005-12-15 14:31:24 -0800519 }
520
521 if (err) {
522 mlog(ML_ERROR, "get_blocks() failed, block = %llu\n",
523 (unsigned long long)block);
524 mlog_errno(err);
525 goto bail;
526 }
527
Mark Fashehccd979b2005-12-15 14:31:24 -0800528bail:
529 status = err ? 0 : p_blkno;
530
531 mlog_exit((int)status);
532
533 return status;
534}
535
536/*
537 * TODO: Make this into a generic get_blocks function.
538 *
539 * From do_direct_io in direct-io.c:
540 * "So what we do is to permit the ->get_blocks function to populate
541 * bh.b_size with the size of IO which is permitted at this offset and
542 * this i_blkbits."
543 *
544 * This function is called directly from get_more_blocks in direct-io.c.
545 *
546 * called like this: dio->get_blocks(dio->inode, fs_startblk,
547 * fs_count, map_bh, dio->rw == WRITE);
548 */
549static int ocfs2_direct_IO_get_blocks(struct inode *inode, sector_t iblock,
Mark Fashehccd979b2005-12-15 14:31:24 -0800550 struct buffer_head *bh_result, int create)
551{
552 int ret;
Mark Fasheh4f902c32007-03-09 16:26:50 -0800553 u64 p_blkno, inode_blocks, contig_blocks;
Mark Fasheh49cb8d22007-03-09 16:21:46 -0800554 unsigned int ext_flags;
Florin Malita184d7d22006-06-03 19:30:10 -0400555 unsigned char blocksize_bits = inode->i_sb->s_blocksize_bits;
Badari Pulavarty1d8fa7a2006-03-26 01:38:02 -0800556 unsigned long max_blocks = bh_result->b_size >> inode->i_blkbits;
Mark Fashehccd979b2005-12-15 14:31:24 -0800557
Mark Fashehccd979b2005-12-15 14:31:24 -0800558 /* This function won't even be called if the request isn't all
559 * nicely aligned and of the right size, so there's no need
560 * for us to check any of that. */
561
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800562 inode_blocks = ocfs2_blocks_for_bytes(inode->i_sb, i_size_read(inode));
Mark Fasheh564f8a32006-12-14 13:01:05 -0800563
564 /*
565 * Any write past EOF is not allowed because we'd be extending.
566 */
567 if (create && (iblock + max_blocks) > inode_blocks) {
Mark Fashehccd979b2005-12-15 14:31:24 -0800568 ret = -EIO;
569 goto bail;
570 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800571
572 /* This figures out the size of the next contiguous block, and
573 * our logical offset */
Mark Fasheh363041a2007-01-17 12:31:35 -0800574 ret = ocfs2_extent_map_get_blocks(inode, iblock, &p_blkno,
Mark Fasheh49cb8d22007-03-09 16:21:46 -0800575 &contig_blocks, &ext_flags);
Mark Fashehccd979b2005-12-15 14:31:24 -0800576 if (ret) {
577 mlog(ML_ERROR, "get_blocks() failed iblock=%llu\n",
578 (unsigned long long)iblock);
579 ret = -EIO;
580 goto bail;
581 }
582
Tao Ma0e116222008-09-03 01:57:14 +0800583 if (!ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)) && !p_blkno && create) {
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800584 ocfs2_error(inode->i_sb,
585 "Inode %llu has a hole at block %llu\n",
586 (unsigned long long)OCFS2_I(inode)->ip_blkno,
587 (unsigned long long)iblock);
588 ret = -EROFS;
589 goto bail;
590 }
591
592 /*
593 * get_more_blocks() expects us to describe a hole by clearing
594 * the mapped bit on bh_result().
Mark Fasheh49cb8d22007-03-09 16:21:46 -0800595 *
596 * Consider an unwritten extent as a hole.
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800597 */
Mark Fasheh49cb8d22007-03-09 16:21:46 -0800598 if (p_blkno && !(ext_flags & OCFS2_EXT_UNWRITTEN))
Mark Fasheh25baf2d2007-02-14 15:30:30 -0800599 map_bh(bh_result, inode->i_sb, p_blkno);
600 else {
601 /*
602 * ocfs2_prepare_inode_for_write() should have caught
603 * the case where we'd be filling a hole and triggered
604 * a buffered write instead.
605 */
606 if (create) {
607 ret = -EIO;
608 mlog_errno(ret);
609 goto bail;
610 }
611
612 clear_buffer_mapped(bh_result);
613 }
Mark Fashehccd979b2005-12-15 14:31:24 -0800614
615 /* make sure we don't map more than max_blocks blocks here as
616 that's all the kernel will handle at this point. */
617 if (max_blocks < contig_blocks)
618 contig_blocks = max_blocks;
619 bh_result->b_size = contig_blocks << blocksize_bits;
620bail:
621 return ret;
622}
623
624/*
625 * ocfs2_dio_end_io is called by the dio core when a dio is finished. We're
626 * particularly interested in the aio/dio case. Like the core uses
627 * i_alloc_sem, we use the rw_lock DLM lock to protect io on one node from
628 * truncation on another.
629 */
630static void ocfs2_dio_end_io(struct kiocb *iocb,
631 loff_t offset,
632 ssize_t bytes,
633 void *private)
634{
Josef Sipekd28c9172006-12-08 02:37:25 -0800635 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
Mark Fasheh7cdfc3a2007-04-16 17:28:51 -0700636 int level;
Mark Fashehccd979b2005-12-15 14:31:24 -0800637
638 /* this io's submitter should not have unlocked this before we could */
639 BUG_ON(!ocfs2_iocb_is_rw_locked(iocb));
Mark Fasheh7cdfc3a2007-04-16 17:28:51 -0700640
Mark Fashehccd979b2005-12-15 14:31:24 -0800641 ocfs2_iocb_clear_rw_locked(iocb);
Mark Fasheh7cdfc3a2007-04-16 17:28:51 -0700642
643 level = ocfs2_iocb_rw_locked_level(iocb);
644 if (!level)
645 up_read(&inode->i_alloc_sem);
646 ocfs2_rw_unlock(inode, level);
Mark Fashehccd979b2005-12-15 14:31:24 -0800647}
648
Joel Becker03f981c2007-01-04 14:54:41 -0800649/*
650 * ocfs2_invalidatepage() and ocfs2_releasepage() are shamelessly stolen
651 * from ext3. PageChecked() bits have been removed as OCFS2 does not
652 * do journalled data.
653 */
654static void ocfs2_invalidatepage(struct page *page, unsigned long offset)
655{
656 journal_t *journal = OCFS2_SB(page->mapping->host->i_sb)->journal->j_journal;
657
Joel Becker2b4e30f2008-09-03 20:03:41 -0700658 jbd2_journal_invalidatepage(journal, page, offset);
Joel Becker03f981c2007-01-04 14:54:41 -0800659}
660
661static int ocfs2_releasepage(struct page *page, gfp_t wait)
662{
663 journal_t *journal = OCFS2_SB(page->mapping->host->i_sb)->journal->j_journal;
664
665 if (!page_has_buffers(page))
666 return 0;
Joel Becker2b4e30f2008-09-03 20:03:41 -0700667 return jbd2_journal_try_to_free_buffers(journal, page, wait);
Joel Becker03f981c2007-01-04 14:54:41 -0800668}
669
Mark Fashehccd979b2005-12-15 14:31:24 -0800670static ssize_t ocfs2_direct_IO(int rw,
671 struct kiocb *iocb,
672 const struct iovec *iov,
673 loff_t offset,
674 unsigned long nr_segs)
675{
676 struct file *file = iocb->ki_filp;
Josef Sipekd28c9172006-12-08 02:37:25 -0800677 struct inode *inode = file->f_path.dentry->d_inode->i_mapping->host;
Mark Fashehccd979b2005-12-15 14:31:24 -0800678 int ret;
679
680 mlog_entry_void();
Mark Fasheh53013cb2006-05-05 19:04:03 -0700681
Mark Fasheh6798d352007-09-07 14:05:51 -0700682 /*
683 * Fallback to buffered I/O if we see an inode without
684 * extents.
685 */
686 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
687 return 0;
688
Mark Fashehccd979b2005-12-15 14:31:24 -0800689 ret = blockdev_direct_IO_no_locking(rw, iocb, inode,
690 inode->i_sb->s_bdev, iov, offset,
691 nr_segs,
692 ocfs2_direct_IO_get_blocks,
693 ocfs2_dio_end_io);
Mark Fashehc934a922007-10-18 15:23:46 -0700694
Mark Fashehccd979b2005-12-15 14:31:24 -0800695 mlog_exit(ret);
696 return ret;
697}
698
Mark Fasheh9517bac2007-02-09 20:24:12 -0800699static void ocfs2_figure_cluster_boundaries(struct ocfs2_super *osb,
700 u32 cpos,
701 unsigned int *start,
702 unsigned int *end)
703{
704 unsigned int cluster_start = 0, cluster_end = PAGE_CACHE_SIZE;
705
706 if (unlikely(PAGE_CACHE_SHIFT > osb->s_clustersize_bits)) {
707 unsigned int cpp;
708
709 cpp = 1 << (PAGE_CACHE_SHIFT - osb->s_clustersize_bits);
710
711 cluster_start = cpos % cpp;
712 cluster_start = cluster_start << osb->s_clustersize_bits;
713
714 cluster_end = cluster_start + osb->s_clustersize;
715 }
716
717 BUG_ON(cluster_start > PAGE_SIZE);
718 BUG_ON(cluster_end > PAGE_SIZE);
719
720 if (start)
721 *start = cluster_start;
722 if (end)
723 *end = cluster_end;
724}
725
726/*
727 * 'from' and 'to' are the region in the page to avoid zeroing.
728 *
729 * If pagesize > clustersize, this function will avoid zeroing outside
730 * of the cluster boundary.
731 *
732 * from == to == 0 is code for "zero the entire cluster region"
733 */
734static void ocfs2_clear_page_regions(struct page *page,
735 struct ocfs2_super *osb, u32 cpos,
736 unsigned from, unsigned to)
737{
738 void *kaddr;
739 unsigned int cluster_start, cluster_end;
740
741 ocfs2_figure_cluster_boundaries(osb, cpos, &cluster_start, &cluster_end);
742
743 kaddr = kmap_atomic(page, KM_USER0);
744
745 if (from || to) {
746 if (from > cluster_start)
747 memset(kaddr + cluster_start, 0, from - cluster_start);
748 if (to < cluster_end)
749 memset(kaddr + to, 0, cluster_end - to);
750 } else {
751 memset(kaddr + cluster_start, 0, cluster_end - cluster_start);
752 }
753
754 kunmap_atomic(kaddr, KM_USER0);
755}
756
757/*
Mark Fasheh4e9563f2007-11-01 11:37:48 -0700758 * Nonsparse file systems fully allocate before we get to the write
759 * code. This prevents ocfs2_write() from tagging the write as an
760 * allocating one, which means ocfs2_map_page_blocks() might try to
761 * read-in the blocks at the tail of our file. Avoid reading them by
762 * testing i_size against each block offset.
763 */
764static int ocfs2_should_read_blk(struct inode *inode, struct page *page,
765 unsigned int block_start)
766{
767 u64 offset = page_offset(page) + block_start;
768
769 if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
770 return 1;
771
772 if (i_size_read(inode) > offset)
773 return 1;
774
775 return 0;
776}
777
778/*
Mark Fasheh9517bac2007-02-09 20:24:12 -0800779 * Some of this taken from block_prepare_write(). We already have our
780 * mapping by now though, and the entire write will be allocating or
781 * it won't, so not much need to use BH_New.
782 *
783 * This will also skip zeroing, which is handled externally.
784 */
Mark Fasheh60b11392007-02-16 11:46:50 -0800785int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
786 struct inode *inode, unsigned int from,
787 unsigned int to, int new)
Mark Fasheh9517bac2007-02-09 20:24:12 -0800788{
789 int ret = 0;
790 struct buffer_head *head, *bh, *wait[2], **wait_bh = wait;
791 unsigned int block_end, block_start;
792 unsigned int bsize = 1 << inode->i_blkbits;
793
794 if (!page_has_buffers(page))
795 create_empty_buffers(page, bsize, 0);
796
797 head = page_buffers(page);
798 for (bh = head, block_start = 0; bh != head || !block_start;
799 bh = bh->b_this_page, block_start += bsize) {
800 block_end = block_start + bsize;
801
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700802 clear_buffer_new(bh);
803
Mark Fasheh9517bac2007-02-09 20:24:12 -0800804 /*
805 * Ignore blocks outside of our i/o range -
806 * they may belong to unallocated clusters.
807 */
Mark Fasheh60b11392007-02-16 11:46:50 -0800808 if (block_start >= to || block_end <= from) {
Mark Fasheh9517bac2007-02-09 20:24:12 -0800809 if (PageUptodate(page))
810 set_buffer_uptodate(bh);
811 continue;
812 }
813
814 /*
815 * For an allocating write with cluster size >= page
816 * size, we always write the entire page.
817 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700818 if (new)
819 set_buffer_new(bh);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800820
821 if (!buffer_mapped(bh)) {
822 map_bh(bh, inode->i_sb, *p_blkno);
823 unmap_underlying_metadata(bh->b_bdev, bh->b_blocknr);
824 }
825
826 if (PageUptodate(page)) {
827 if (!buffer_uptodate(bh))
828 set_buffer_uptodate(bh);
829 } else if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
Mark Fashehbce99762007-06-18 11:12:36 -0700830 !buffer_new(bh) &&
Mark Fasheh4e9563f2007-11-01 11:37:48 -0700831 ocfs2_should_read_blk(inode, page, block_start) &&
Mark Fashehbce99762007-06-18 11:12:36 -0700832 (block_start < from || block_end > to)) {
Mark Fasheh9517bac2007-02-09 20:24:12 -0800833 ll_rw_block(READ, 1, &bh);
834 *wait_bh++=bh;
835 }
836
837 *p_blkno = *p_blkno + 1;
838 }
839
840 /*
841 * If we issued read requests - let them complete.
842 */
843 while(wait_bh > wait) {
844 wait_on_buffer(*--wait_bh);
845 if (!buffer_uptodate(*wait_bh))
846 ret = -EIO;
847 }
848
849 if (ret == 0 || !new)
850 return ret;
851
852 /*
853 * If we get -EIO above, zero out any newly allocated blocks
854 * to avoid exposing stale data.
855 */
856 bh = head;
857 block_start = 0;
858 do {
Mark Fasheh9517bac2007-02-09 20:24:12 -0800859 block_end = block_start + bsize;
860 if (block_end <= from)
861 goto next_bh;
862 if (block_start >= to)
863 break;
864
Christoph Lametereebd2aa2008-02-04 22:28:29 -0800865 zero_user(page, block_start, bh->b_size);
Mark Fasheh9517bac2007-02-09 20:24:12 -0800866 set_buffer_uptodate(bh);
867 mark_buffer_dirty(bh);
868
869next_bh:
870 block_start = block_end;
871 bh = bh->b_this_page;
872 } while (bh != head);
873
874 return ret;
875}
876
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700877#if (PAGE_CACHE_SIZE >= OCFS2_MAX_CLUSTERSIZE)
878#define OCFS2_MAX_CTXT_PAGES 1
879#else
880#define OCFS2_MAX_CTXT_PAGES (OCFS2_MAX_CLUSTERSIZE / PAGE_CACHE_SIZE)
881#endif
Mark Fasheh6af67d82007-03-06 17:24:46 -0800882
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700883#define OCFS2_MAX_CLUSTERS_PER_PAGE (PAGE_CACHE_SIZE / OCFS2_MIN_CLUSTERSIZE)
Mark Fasheh6af67d82007-03-06 17:24:46 -0800884
885/*
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700886 * Describe the state of a single cluster to be written to.
Mark Fasheh9517bac2007-02-09 20:24:12 -0800887 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700888struct ocfs2_write_cluster_desc {
889 u32 c_cpos;
890 u32 c_phys;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800891 /*
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700892 * Give this a unique field because c_phys eventually gets
893 * filled.
Mark Fasheh9517bac2007-02-09 20:24:12 -0800894 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700895 unsigned c_new;
Mark Fashehb27b7cb2007-06-18 11:22:56 -0700896 unsigned c_unwritten;
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700897};
Mark Fasheh9517bac2007-02-09 20:24:12 -0800898
Mark Fashehb27b7cb2007-06-18 11:22:56 -0700899static inline int ocfs2_should_zero_cluster(struct ocfs2_write_cluster_desc *d)
900{
901 return d->c_new || d->c_unwritten;
902}
903
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700904struct ocfs2_write_ctxt {
905 /* Logical cluster position / len of write */
906 u32 w_cpos;
907 u32 w_clen;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800908
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700909 struct ocfs2_write_cluster_desc w_desc[OCFS2_MAX_CLUSTERS_PER_PAGE];
Mark Fasheh9517bac2007-02-09 20:24:12 -0800910
911 /*
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700912 * This is true if page_size > cluster_size.
Mark Fasheh9517bac2007-02-09 20:24:12 -0800913 *
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700914 * It triggers a set of special cases during write which might
915 * have to deal with allocating writes to partial pages.
Mark Fasheh9517bac2007-02-09 20:24:12 -0800916 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700917 unsigned int w_large_pages;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800918
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700919 /*
920 * Pages involved in this write.
921 *
922 * w_target_page is the page being written to by the user.
923 *
924 * w_pages is an array of pages which always contains
925 * w_target_page, and in the case of an allocating write with
926 * page_size < cluster size, it will contain zero'd and mapped
927 * pages adjacent to w_target_page which need to be written
928 * out in so that future reads from that region will get
929 * zero's.
930 */
931 struct page *w_pages[OCFS2_MAX_CTXT_PAGES];
932 unsigned int w_num_pages;
933 struct page *w_target_page;
Mark Fasheh9517bac2007-02-09 20:24:12 -0800934
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700935 /*
936 * ocfs2_write_end() uses this to know what the real range to
937 * write in the target should be.
938 */
939 unsigned int w_target_from;
940 unsigned int w_target_to;
941
942 /*
943 * We could use journal_current_handle() but this is cleaner,
944 * IMHO -Mark
945 */
946 handle_t *w_handle;
947
948 struct buffer_head *w_di_bh;
Mark Fashehb27b7cb2007-06-18 11:22:56 -0700949
950 struct ocfs2_cached_dealloc_ctxt w_dealloc;
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700951};
952
Mark Fasheh1d410a62007-09-07 14:20:45 -0700953void ocfs2_unlock_and_free_pages(struct page **pages, int num_pages)
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700954{
955 int i;
956
Mark Fasheh1d410a62007-09-07 14:20:45 -0700957 for(i = 0; i < num_pages; i++) {
958 if (pages[i]) {
959 unlock_page(pages[i]);
960 mark_page_accessed(pages[i]);
961 page_cache_release(pages[i]);
962 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700963 }
Mark Fasheh1d410a62007-09-07 14:20:45 -0700964}
965
966static void ocfs2_free_write_ctxt(struct ocfs2_write_ctxt *wc)
967{
968 ocfs2_unlock_and_free_pages(wc->w_pages, wc->w_num_pages);
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700969
970 brelse(wc->w_di_bh);
971 kfree(wc);
972}
973
974static int ocfs2_alloc_write_ctxt(struct ocfs2_write_ctxt **wcp,
975 struct ocfs2_super *osb, loff_t pos,
Mark Fasheh607d44a2007-05-09 15:14:45 -0700976 unsigned len, struct buffer_head *di_bh)
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700977{
tao.ma@oracle.com30b85482007-09-06 08:02:25 +0800978 u32 cend;
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700979 struct ocfs2_write_ctxt *wc;
980
981 wc = kzalloc(sizeof(struct ocfs2_write_ctxt), GFP_NOFS);
982 if (!wc)
983 return -ENOMEM;
984
985 wc->w_cpos = pos >> osb->s_clustersize_bits;
tao.ma@oracle.com30b85482007-09-06 08:02:25 +0800986 cend = (pos + len - 1) >> osb->s_clustersize_bits;
987 wc->w_clen = cend - wc->w_cpos + 1;
Mark Fasheh607d44a2007-05-09 15:14:45 -0700988 get_bh(di_bh);
989 wc->w_di_bh = di_bh;
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700990
991 if (unlikely(PAGE_CACHE_SHIFT > osb->s_clustersize_bits))
992 wc->w_large_pages = 1;
993 else
994 wc->w_large_pages = 0;
995
Mark Fashehb27b7cb2007-06-18 11:22:56 -0700996 ocfs2_init_dealloc_ctxt(&wc->w_dealloc);
997
Mark Fasheh3a307ff2007-05-08 17:47:32 -0700998 *wcp = wc;
999
1000 return 0;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001001}
1002
1003/*
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001004 * If a page has any new buffers, zero them out here, and mark them uptodate
1005 * and dirty so they'll be written out (in order to prevent uninitialised
1006 * block data from leaking). And clear the new bit.
Mark Fasheh9517bac2007-02-09 20:24:12 -08001007 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001008static void ocfs2_zero_new_buffers(struct page *page, unsigned from, unsigned to)
Mark Fasheh9517bac2007-02-09 20:24:12 -08001009{
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001010 unsigned int block_start, block_end;
1011 struct buffer_head *head, *bh;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001012
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001013 BUG_ON(!PageLocked(page));
1014 if (!page_has_buffers(page))
1015 return;
1016
1017 bh = head = page_buffers(page);
1018 block_start = 0;
1019 do {
1020 block_end = block_start + bh->b_size;
1021
1022 if (buffer_new(bh)) {
1023 if (block_end > from && block_start < to) {
1024 if (!PageUptodate(page)) {
1025 unsigned start, end;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001026
1027 start = max(from, block_start);
1028 end = min(to, block_end);
1029
Christoph Lametereebd2aa2008-02-04 22:28:29 -08001030 zero_user_segment(page, start, end);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001031 set_buffer_uptodate(bh);
1032 }
1033
1034 clear_buffer_new(bh);
1035 mark_buffer_dirty(bh);
1036 }
1037 }
1038
1039 block_start = block_end;
1040 bh = bh->b_this_page;
1041 } while (bh != head);
1042}
1043
1044/*
1045 * Only called when we have a failure during allocating write to write
1046 * zero's to the newly allocated region.
1047 */
1048static void ocfs2_write_failure(struct inode *inode,
1049 struct ocfs2_write_ctxt *wc,
1050 loff_t user_pos, unsigned user_len)
1051{
1052 int i;
Mark Fasheh5c26a7b2007-09-18 17:49:29 -07001053 unsigned from = user_pos & (PAGE_CACHE_SIZE - 1),
1054 to = user_pos + user_len;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001055 struct page *tmppage;
1056
Mark Fasheh5c26a7b2007-09-18 17:49:29 -07001057 ocfs2_zero_new_buffers(wc->w_target_page, from, to);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001058
1059 for(i = 0; i < wc->w_num_pages; i++) {
1060 tmppage = wc->w_pages[i];
1061
Sunil Mushran961cecb2008-07-16 17:22:22 -07001062 if (page_has_buffers(tmppage)) {
Mark Fasheh53ef99c2008-11-18 16:53:43 -08001063 if (ocfs2_should_order_data(inode))
Joel Becker2b4e30f2008-09-03 20:03:41 -07001064 ocfs2_jbd2_file_inode(wc->w_handle, inode);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001065
Sunil Mushran961cecb2008-07-16 17:22:22 -07001066 block_commit_write(tmppage, from, to);
1067 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001068 }
1069}
1070
1071static int ocfs2_prepare_page_for_write(struct inode *inode, u64 *p_blkno,
1072 struct ocfs2_write_ctxt *wc,
1073 struct page *page, u32 cpos,
1074 loff_t user_pos, unsigned user_len,
1075 int new)
1076{
1077 int ret;
1078 unsigned int map_from = 0, map_to = 0;
1079 unsigned int cluster_start, cluster_end;
1080 unsigned int user_data_from = 0, user_data_to = 0;
1081
1082 ocfs2_figure_cluster_boundaries(OCFS2_SB(inode->i_sb), cpos,
Mark Fasheh9517bac2007-02-09 20:24:12 -08001083 &cluster_start, &cluster_end);
1084
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001085 if (page == wc->w_target_page) {
1086 map_from = user_pos & (PAGE_CACHE_SIZE - 1);
1087 map_to = map_from + user_len;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001088
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001089 if (new)
1090 ret = ocfs2_map_page_blocks(page, p_blkno, inode,
1091 cluster_start, cluster_end,
1092 new);
1093 else
1094 ret = ocfs2_map_page_blocks(page, p_blkno, inode,
1095 map_from, map_to, new);
1096 if (ret) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08001097 mlog_errno(ret);
1098 goto out;
1099 }
1100
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001101 user_data_from = map_from;
1102 user_data_to = map_to;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001103 if (new) {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001104 map_from = cluster_start;
1105 map_to = cluster_end;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001106 }
1107 } else {
1108 /*
1109 * If we haven't allocated the new page yet, we
1110 * shouldn't be writing it out without copying user
1111 * data. This is likely a math error from the caller.
1112 */
1113 BUG_ON(!new);
1114
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001115 map_from = cluster_start;
1116 map_to = cluster_end;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001117
1118 ret = ocfs2_map_page_blocks(page, p_blkno, inode,
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001119 cluster_start, cluster_end, new);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001120 if (ret) {
1121 mlog_errno(ret);
1122 goto out;
1123 }
1124 }
1125
1126 /*
1127 * Parts of newly allocated pages need to be zero'd.
1128 *
1129 * Above, we have also rewritten 'to' and 'from' - as far as
1130 * the rest of the function is concerned, the entire cluster
1131 * range inside of a page needs to be written.
1132 *
1133 * We can skip this if the page is up to date - it's already
1134 * been zero'd from being read in as a hole.
1135 */
1136 if (new && !PageUptodate(page))
1137 ocfs2_clear_page_regions(page, OCFS2_SB(inode->i_sb),
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001138 cpos, user_data_from, user_data_to);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001139
1140 flush_dcache_page(page);
1141
Mark Fasheh9517bac2007-02-09 20:24:12 -08001142out:
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001143 return ret;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001144}
1145
1146/*
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001147 * This function will only grab one clusters worth of pages.
Mark Fasheh9517bac2007-02-09 20:24:12 -08001148 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001149static int ocfs2_grab_pages_for_write(struct address_space *mapping,
1150 struct ocfs2_write_ctxt *wc,
Mark Fasheh7307de82007-05-09 15:16:19 -07001151 u32 cpos, loff_t user_pos, int new,
1152 struct page *mmap_page)
Mark Fasheh9517bac2007-02-09 20:24:12 -08001153{
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001154 int ret = 0, i;
1155 unsigned long start, target_index, index;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001156 struct inode *inode = mapping->host;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001157
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001158 target_index = user_pos >> PAGE_CACHE_SHIFT;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001159
1160 /*
1161 * Figure out how many pages we'll be manipulating here. For
Mark Fasheh60b11392007-02-16 11:46:50 -08001162 * non allocating write, we just change the one
1163 * page. Otherwise, we'll need a whole clusters worth.
Mark Fasheh9517bac2007-02-09 20:24:12 -08001164 */
Mark Fasheh9517bac2007-02-09 20:24:12 -08001165 if (new) {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001166 wc->w_num_pages = ocfs2_pages_per_cluster(inode->i_sb);
1167 start = ocfs2_align_clusters_to_page_index(inode->i_sb, cpos);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001168 } else {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001169 wc->w_num_pages = 1;
1170 start = target_index;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001171 }
1172
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001173 for(i = 0; i < wc->w_num_pages; i++) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08001174 index = start + i;
1175
Mark Fasheh7307de82007-05-09 15:16:19 -07001176 if (index == target_index && mmap_page) {
1177 /*
1178 * ocfs2_pagemkwrite() is a little different
1179 * and wants us to directly use the page
1180 * passed in.
1181 */
1182 lock_page(mmap_page);
1183
1184 if (mmap_page->mapping != mapping) {
1185 unlock_page(mmap_page);
1186 /*
1187 * Sanity check - the locking in
1188 * ocfs2_pagemkwrite() should ensure
1189 * that this code doesn't trigger.
1190 */
1191 ret = -EINVAL;
1192 mlog_errno(ret);
1193 goto out;
1194 }
1195
1196 page_cache_get(mmap_page);
1197 wc->w_pages[i] = mmap_page;
1198 } else {
1199 wc->w_pages[i] = find_or_create_page(mapping, index,
1200 GFP_NOFS);
1201 if (!wc->w_pages[i]) {
1202 ret = -ENOMEM;
1203 mlog_errno(ret);
1204 goto out;
1205 }
Mark Fasheh9517bac2007-02-09 20:24:12 -08001206 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001207
1208 if (index == target_index)
1209 wc->w_target_page = wc->w_pages[i];
Mark Fasheh9517bac2007-02-09 20:24:12 -08001210 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001211out:
1212 return ret;
1213}
1214
1215/*
1216 * Prepare a single cluster for write one cluster into the file.
1217 */
1218static int ocfs2_write_cluster(struct address_space *mapping,
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001219 u32 phys, unsigned int unwritten,
1220 struct ocfs2_alloc_context *data_ac,
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001221 struct ocfs2_alloc_context *meta_ac,
1222 struct ocfs2_write_ctxt *wc, u32 cpos,
1223 loff_t user_pos, unsigned user_len)
1224{
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001225 int ret, i, new, should_zero = 0;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001226 u64 v_blkno, p_blkno;
1227 struct inode *inode = mapping->host;
Joel Beckerf99b9b72008-08-20 19:36:33 -07001228 struct ocfs2_extent_tree et;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001229
1230 new = phys == 0 ? 1 : 0;
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001231 if (new || unwritten)
1232 should_zero = 1;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001233
1234 if (new) {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001235 u32 tmp_pos;
1236
Mark Fasheh9517bac2007-02-09 20:24:12 -08001237 /*
1238 * This is safe to call with the page locks - it won't take
1239 * any additional semaphores or cluster locks.
1240 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001241 tmp_pos = cpos;
Tao Ma0eb8d472008-08-18 17:38:45 +08001242 ret = ocfs2_add_inode_data(OCFS2_SB(inode->i_sb), inode,
1243 &tmp_pos, 1, 0, wc->w_di_bh,
1244 wc->w_handle, data_ac,
1245 meta_ac, NULL);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001246 /*
1247 * This shouldn't happen because we must have already
1248 * calculated the correct meta data allocation required. The
1249 * internal tree allocation code should know how to increase
1250 * transaction credits itself.
1251 *
1252 * If need be, we could handle -EAGAIN for a
1253 * RESTART_TRANS here.
1254 */
1255 mlog_bug_on_msg(ret == -EAGAIN,
1256 "Inode %llu: EAGAIN return during allocation.\n",
1257 (unsigned long long)OCFS2_I(inode)->ip_blkno);
1258 if (ret < 0) {
1259 mlog_errno(ret);
1260 goto out;
1261 }
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001262 } else if (unwritten) {
Joel Becker8d6220d2008-08-22 12:46:09 -07001263 ocfs2_init_dinode_extent_tree(&et, inode, wc->w_di_bh);
Joel Beckerf99b9b72008-08-20 19:36:33 -07001264 ret = ocfs2_mark_extent_written(inode, &et,
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001265 wc->w_handle, cpos, 1, phys,
Joel Beckerf99b9b72008-08-20 19:36:33 -07001266 meta_ac, &wc->w_dealloc);
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001267 if (ret < 0) {
1268 mlog_errno(ret);
1269 goto out;
1270 }
Mark Fasheh9517bac2007-02-09 20:24:12 -08001271 }
1272
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001273 if (should_zero)
1274 v_blkno = ocfs2_clusters_to_blocks(inode->i_sb, cpos);
1275 else
1276 v_blkno = user_pos >> inode->i_sb->s_blocksize_bits;
1277
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001278 /*
1279 * The only reason this should fail is due to an inability to
1280 * find the extent added.
1281 */
Mark Fasheh49cb8d22007-03-09 16:21:46 -08001282 ret = ocfs2_extent_map_get_blocks(inode, v_blkno, &p_blkno, NULL,
1283 NULL);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001284 if (ret < 0) {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001285 ocfs2_error(inode->i_sb, "Corrupting extend for inode %llu, "
1286 "at logical block %llu",
1287 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1288 (unsigned long long)v_blkno);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001289 goto out;
1290 }
1291
1292 BUG_ON(p_blkno == 0);
1293
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001294 for(i = 0; i < wc->w_num_pages; i++) {
1295 int tmpret;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001296
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001297 tmpret = ocfs2_prepare_page_for_write(inode, &p_blkno, wc,
1298 wc->w_pages[i], cpos,
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001299 user_pos, user_len,
1300 should_zero);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001301 if (tmpret) {
1302 mlog_errno(tmpret);
1303 if (ret == 0)
1304 tmpret = ret;
1305 }
Mark Fasheh9517bac2007-02-09 20:24:12 -08001306 }
1307
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001308 /*
1309 * We only have cleanup to do in case of allocating write.
1310 */
1311 if (ret && new)
1312 ocfs2_write_failure(inode, wc, user_pos, user_len);
1313
Mark Fasheh9517bac2007-02-09 20:24:12 -08001314out:
Mark Fasheh9517bac2007-02-09 20:24:12 -08001315
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001316 return ret;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001317}
1318
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001319static int ocfs2_write_cluster_by_desc(struct address_space *mapping,
1320 struct ocfs2_alloc_context *data_ac,
1321 struct ocfs2_alloc_context *meta_ac,
1322 struct ocfs2_write_ctxt *wc,
1323 loff_t pos, unsigned len)
1324{
1325 int ret, i;
Mark Fashehdb562462007-09-17 09:06:29 -07001326 loff_t cluster_off;
1327 unsigned int local_len = len;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001328 struct ocfs2_write_cluster_desc *desc;
Mark Fashehdb562462007-09-17 09:06:29 -07001329 struct ocfs2_super *osb = OCFS2_SB(mapping->host->i_sb);
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001330
1331 for (i = 0; i < wc->w_clen; i++) {
1332 desc = &wc->w_desc[i];
1333
Mark Fashehdb562462007-09-17 09:06:29 -07001334 /*
1335 * We have to make sure that the total write passed in
1336 * doesn't extend past a single cluster.
1337 */
1338 local_len = len;
1339 cluster_off = pos & (osb->s_clustersize - 1);
1340 if ((cluster_off + local_len) > osb->s_clustersize)
1341 local_len = osb->s_clustersize - cluster_off;
1342
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001343 ret = ocfs2_write_cluster(mapping, desc->c_phys,
1344 desc->c_unwritten, data_ac, meta_ac,
Mark Fashehdb562462007-09-17 09:06:29 -07001345 wc, desc->c_cpos, pos, local_len);
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001346 if (ret) {
1347 mlog_errno(ret);
1348 goto out;
1349 }
Mark Fashehdb562462007-09-17 09:06:29 -07001350
1351 len -= local_len;
1352 pos += local_len;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001353 }
1354
1355 ret = 0;
1356out:
1357 return ret;
1358}
1359
Mark Fasheh9517bac2007-02-09 20:24:12 -08001360/*
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001361 * ocfs2_write_end() wants to know which parts of the target page it
1362 * should complete the write on. It's easiest to compute them ahead of
1363 * time when a more complete view of the write is available.
Mark Fasheh9517bac2007-02-09 20:24:12 -08001364 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001365static void ocfs2_set_target_boundaries(struct ocfs2_super *osb,
1366 struct ocfs2_write_ctxt *wc,
1367 loff_t pos, unsigned len, int alloc)
Mark Fasheh9517bac2007-02-09 20:24:12 -08001368{
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001369 struct ocfs2_write_cluster_desc *desc;
1370
1371 wc->w_target_from = pos & (PAGE_CACHE_SIZE - 1);
1372 wc->w_target_to = wc->w_target_from + len;
1373
1374 if (alloc == 0)
1375 return;
1376
1377 /*
1378 * Allocating write - we may have different boundaries based
1379 * on page size and cluster size.
1380 *
1381 * NOTE: We can no longer compute one value from the other as
1382 * the actual write length and user provided length may be
1383 * different.
1384 */
1385
1386 if (wc->w_large_pages) {
1387 /*
1388 * We only care about the 1st and last cluster within
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001389 * our range and whether they should be zero'd or not. Either
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001390 * value may be extended out to the start/end of a
1391 * newly allocated cluster.
1392 */
1393 desc = &wc->w_desc[0];
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001394 if (ocfs2_should_zero_cluster(desc))
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001395 ocfs2_figure_cluster_boundaries(osb,
1396 desc->c_cpos,
1397 &wc->w_target_from,
1398 NULL);
1399
1400 desc = &wc->w_desc[wc->w_clen - 1];
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001401 if (ocfs2_should_zero_cluster(desc))
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001402 ocfs2_figure_cluster_boundaries(osb,
1403 desc->c_cpos,
1404 NULL,
1405 &wc->w_target_to);
1406 } else {
1407 wc->w_target_from = 0;
1408 wc->w_target_to = PAGE_CACHE_SIZE;
1409 }
1410}
1411
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001412/*
1413 * Populate each single-cluster write descriptor in the write context
1414 * with information about the i/o to be done.
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001415 *
1416 * Returns the number of clusters that will have to be allocated, as
1417 * well as a worst case estimate of the number of extent records that
1418 * would have to be created during a write to an unwritten region.
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001419 */
1420static int ocfs2_populate_write_desc(struct inode *inode,
1421 struct ocfs2_write_ctxt *wc,
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001422 unsigned int *clusters_to_alloc,
1423 unsigned int *extents_to_split)
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001424{
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001425 int ret;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001426 struct ocfs2_write_cluster_desc *desc;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001427 unsigned int num_clusters = 0;
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001428 unsigned int ext_flags = 0;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001429 u32 phys = 0;
1430 int i;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001431
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001432 *clusters_to_alloc = 0;
1433 *extents_to_split = 0;
1434
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001435 for (i = 0; i < wc->w_clen; i++) {
1436 desc = &wc->w_desc[i];
1437 desc->c_cpos = wc->w_cpos + i;
1438
1439 if (num_clusters == 0) {
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001440 /*
1441 * Need to look up the next extent record.
1442 */
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001443 ret = ocfs2_get_clusters(inode, desc->c_cpos, &phys,
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001444 &num_clusters, &ext_flags);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001445 if (ret) {
1446 mlog_errno(ret);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001447 goto out;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001448 }
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001449
1450 /*
1451 * Assume worst case - that we're writing in
1452 * the middle of the extent.
1453 *
1454 * We can assume that the write proceeds from
1455 * left to right, in which case the extent
1456 * insert code is smart enough to coalesce the
1457 * next splits into the previous records created.
1458 */
1459 if (ext_flags & OCFS2_EXT_UNWRITTEN)
1460 *extents_to_split = *extents_to_split + 2;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001461 } else if (phys) {
1462 /*
1463 * Only increment phys if it doesn't describe
1464 * a hole.
1465 */
1466 phys++;
1467 }
1468
1469 desc->c_phys = phys;
1470 if (phys == 0) {
1471 desc->c_new = 1;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001472 *clusters_to_alloc = *clusters_to_alloc + 1;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001473 }
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001474 if (ext_flags & OCFS2_EXT_UNWRITTEN)
1475 desc->c_unwritten = 1;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001476
1477 num_clusters--;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001478 }
1479
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001480 ret = 0;
1481out:
1482 return ret;
1483}
1484
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001485static int ocfs2_write_begin_inline(struct address_space *mapping,
1486 struct inode *inode,
1487 struct ocfs2_write_ctxt *wc)
1488{
1489 int ret;
1490 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1491 struct page *page;
1492 handle_t *handle;
1493 struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1494
1495 page = find_or_create_page(mapping, 0, GFP_NOFS);
1496 if (!page) {
1497 ret = -ENOMEM;
1498 mlog_errno(ret);
1499 goto out;
1500 }
1501 /*
1502 * If we don't set w_num_pages then this page won't get unlocked
1503 * and freed on cleanup of the write context.
1504 */
1505 wc->w_pages[0] = wc->w_target_page = page;
1506 wc->w_num_pages = 1;
1507
1508 handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1509 if (IS_ERR(handle)) {
1510 ret = PTR_ERR(handle);
1511 mlog_errno(ret);
1512 goto out;
1513 }
1514
Joel Becker13723d02008-10-17 19:25:01 -07001515 ret = ocfs2_journal_access_di(handle, inode, wc->w_di_bh,
1516 OCFS2_JOURNAL_ACCESS_WRITE);
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001517 if (ret) {
1518 ocfs2_commit_trans(osb, handle);
1519
1520 mlog_errno(ret);
1521 goto out;
1522 }
1523
1524 if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL))
1525 ocfs2_set_inode_data_inline(inode, di);
1526
1527 if (!PageUptodate(page)) {
1528 ret = ocfs2_read_inline_data(inode, page, wc->w_di_bh);
1529 if (ret) {
1530 ocfs2_commit_trans(osb, handle);
1531
1532 goto out;
1533 }
1534 }
1535
1536 wc->w_handle = handle;
1537out:
1538 return ret;
1539}
1540
1541int ocfs2_size_fits_inline_data(struct buffer_head *di_bh, u64 new_size)
1542{
1543 struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
1544
Mark Fasheh0d8a4e02007-11-20 11:48:41 -08001545 if (new_size <= le16_to_cpu(di->id2.i_data.id_count))
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001546 return 1;
1547 return 0;
1548}
1549
1550static int ocfs2_try_to_write_inline_data(struct address_space *mapping,
1551 struct inode *inode, loff_t pos,
1552 unsigned len, struct page *mmap_page,
1553 struct ocfs2_write_ctxt *wc)
1554{
1555 int ret, written = 0;
1556 loff_t end = pos + len;
1557 struct ocfs2_inode_info *oi = OCFS2_I(inode);
1558
1559 mlog(0, "Inode %llu, write of %u bytes at off %llu. features: 0x%x\n",
1560 (unsigned long long)oi->ip_blkno, len, (unsigned long long)pos,
1561 oi->ip_dyn_features);
1562
1563 /*
1564 * Handle inodes which already have inline data 1st.
1565 */
1566 if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1567 if (mmap_page == NULL &&
1568 ocfs2_size_fits_inline_data(wc->w_di_bh, end))
1569 goto do_inline_write;
1570
1571 /*
1572 * The write won't fit - we have to give this inode an
1573 * inline extent list now.
1574 */
1575 ret = ocfs2_convert_inline_data_to_extents(inode, wc->w_di_bh);
1576 if (ret)
1577 mlog_errno(ret);
1578 goto out;
1579 }
1580
1581 /*
1582 * Check whether the inode can accept inline data.
1583 */
1584 if (oi->ip_clusters != 0 || i_size_read(inode) != 0)
1585 return 0;
1586
1587 /*
1588 * Check whether the write can fit.
1589 */
1590 if (mmap_page || end > ocfs2_max_inline_data(inode->i_sb))
1591 return 0;
1592
1593do_inline_write:
1594 ret = ocfs2_write_begin_inline(mapping, inode, wc);
1595 if (ret) {
1596 mlog_errno(ret);
1597 goto out;
1598 }
1599
1600 /*
1601 * This signals to the caller that the data can be written
1602 * inline.
1603 */
1604 written = 1;
1605out:
1606 return written ? written : ret;
1607}
1608
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001609/*
1610 * This function only does anything for file systems which can't
1611 * handle sparse files.
1612 *
1613 * What we want to do here is fill in any hole between the current end
1614 * of allocation and the end of our write. That way the rest of the
1615 * write path can treat it as an non-allocating write, which has no
1616 * special case code for sparse/nonsparse files.
1617 */
1618static int ocfs2_expand_nonsparse_inode(struct inode *inode, loff_t pos,
1619 unsigned len,
1620 struct ocfs2_write_ctxt *wc)
1621{
1622 int ret;
1623 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1624 loff_t newsize = pos + len;
1625
1626 if (ocfs2_sparse_alloc(osb))
1627 return 0;
1628
1629 if (newsize <= i_size_read(inode))
1630 return 0;
1631
1632 ret = ocfs2_extend_no_holes(inode, newsize, newsize - len);
1633 if (ret)
1634 mlog_errno(ret);
1635
1636 return ret;
1637}
1638
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001639int ocfs2_write_begin_nolock(struct address_space *mapping,
1640 loff_t pos, unsigned len, unsigned flags,
1641 struct page **pagep, void **fsdata,
1642 struct buffer_head *di_bh, struct page *mmap_page)
1643{
1644 int ret, credits = OCFS2_INODE_UPDATE_CREDITS;
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001645 unsigned int clusters_to_alloc, extents_to_split;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001646 struct ocfs2_write_ctxt *wc;
1647 struct inode *inode = mapping->host;
1648 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1649 struct ocfs2_dinode *di;
1650 struct ocfs2_alloc_context *data_ac = NULL;
1651 struct ocfs2_alloc_context *meta_ac = NULL;
1652 handle_t *handle;
Joel Beckerf99b9b72008-08-20 19:36:33 -07001653 struct ocfs2_extent_tree et;
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001654
1655 ret = ocfs2_alloc_write_ctxt(&wc, osb, pos, len, di_bh);
1656 if (ret) {
1657 mlog_errno(ret);
1658 return ret;
1659 }
1660
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001661 if (ocfs2_supports_inline_data(osb)) {
1662 ret = ocfs2_try_to_write_inline_data(mapping, inode, pos, len,
1663 mmap_page, wc);
1664 if (ret == 1) {
1665 ret = 0;
1666 goto success;
1667 }
1668 if (ret < 0) {
1669 mlog_errno(ret);
1670 goto out;
1671 }
1672 }
1673
Mark Fasheh65ed39d2007-08-28 17:13:23 -07001674 ret = ocfs2_expand_nonsparse_inode(inode, pos, len, wc);
1675 if (ret) {
1676 mlog_errno(ret);
1677 goto out;
1678 }
1679
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001680 ret = ocfs2_populate_write_desc(inode, wc, &clusters_to_alloc,
1681 &extents_to_split);
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001682 if (ret) {
1683 mlog_errno(ret);
1684 goto out;
1685 }
1686
1687 di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1688
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001689 /*
1690 * We set w_target_from, w_target_to here so that
1691 * ocfs2_write_end() knows which range in the target page to
1692 * write out. An allocation requires that we write the entire
1693 * cluster range.
1694 */
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001695 if (clusters_to_alloc || extents_to_split) {
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001696 /*
1697 * XXX: We are stretching the limits of
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001698 * ocfs2_lock_allocators(). It greatly over-estimates
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001699 * the work to be done.
1700 */
Tao Mae7d4cb62008-08-18 17:38:44 +08001701 mlog(0, "extend inode %llu, i_size = %lld, di->i_clusters = %u,"
1702 " clusters_to_add = %u, extents_to_split = %u\n",
1703 (unsigned long long)OCFS2_I(inode)->ip_blkno,
1704 (long long)i_size_read(inode), le32_to_cpu(di->i_clusters),
1705 clusters_to_alloc, extents_to_split);
1706
Joel Becker8d6220d2008-08-22 12:46:09 -07001707 ocfs2_init_dinode_extent_tree(&et, inode, wc->w_di_bh);
Joel Beckerf99b9b72008-08-20 19:36:33 -07001708 ret = ocfs2_lock_allocators(inode, &et,
Tao Ma231b87d2008-08-18 17:38:42 +08001709 clusters_to_alloc, extents_to_split,
Joel Beckerf99b9b72008-08-20 19:36:33 -07001710 &data_ac, &meta_ac);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001711 if (ret) {
1712 mlog_errno(ret);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001713 goto out;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001714 }
1715
Tao Ma811f9332008-08-18 17:38:43 +08001716 credits = ocfs2_calc_extend_credits(inode->i_sb,
1717 &di->id2.i_list,
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001718 clusters_to_alloc);
1719
Mark Fasheh9517bac2007-02-09 20:24:12 -08001720 }
1721
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001722 ocfs2_set_target_boundaries(osb, wc, pos, len,
1723 clusters_to_alloc + extents_to_split);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001724
Mark Fasheh9517bac2007-02-09 20:24:12 -08001725 handle = ocfs2_start_trans(osb, credits);
1726 if (IS_ERR(handle)) {
1727 ret = PTR_ERR(handle);
1728 mlog_errno(ret);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001729 goto out;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001730 }
1731
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001732 wc->w_handle = handle;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001733
Jan Karaa90714c2008-10-09 19:38:40 +02001734 if (clusters_to_alloc && vfs_dq_alloc_space_nodirty(inode,
1735 ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc))) {
1736 ret = -EDQUOT;
1737 goto out_commit;
1738 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001739 /*
1740 * We don't want this to fail in ocfs2_write_end(), so do it
1741 * here.
1742 */
Joel Becker13723d02008-10-17 19:25:01 -07001743 ret = ocfs2_journal_access_di(handle, inode, wc->w_di_bh,
1744 OCFS2_JOURNAL_ACCESS_WRITE);
Mark Fasheh9517bac2007-02-09 20:24:12 -08001745 if (ret) {
1746 mlog_errno(ret);
Jan Karaa90714c2008-10-09 19:38:40 +02001747 goto out_quota;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001748 }
1749
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001750 /*
1751 * Fill our page array first. That way we've grabbed enough so
1752 * that we can zero and flush if we error after adding the
1753 * extent.
1754 */
1755 ret = ocfs2_grab_pages_for_write(mapping, wc, wc->w_cpos, pos,
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001756 clusters_to_alloc + extents_to_split,
1757 mmap_page);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001758 if (ret) {
Mark Fasheh9517bac2007-02-09 20:24:12 -08001759 mlog_errno(ret);
Jan Karaa90714c2008-10-09 19:38:40 +02001760 goto out_quota;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001761 }
Mark Fasheh9517bac2007-02-09 20:24:12 -08001762
Mark Fasheh0d172ba2007-05-14 18:09:54 -07001763 ret = ocfs2_write_cluster_by_desc(mapping, data_ac, meta_ac, wc, pos,
1764 len);
1765 if (ret) {
1766 mlog_errno(ret);
Jan Karaa90714c2008-10-09 19:38:40 +02001767 goto out_quota;
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001768 }
1769
1770 if (data_ac)
1771 ocfs2_free_alloc_context(data_ac);
1772 if (meta_ac)
1773 ocfs2_free_alloc_context(meta_ac);
1774
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001775success:
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001776 *pagep = wc->w_target_page;
1777 *fsdata = wc;
1778 return 0;
Jan Karaa90714c2008-10-09 19:38:40 +02001779out_quota:
1780 if (clusters_to_alloc)
1781 vfs_dq_free_space(inode,
1782 ocfs2_clusters_to_bytes(osb->sb, clusters_to_alloc));
Mark Fasheh9517bac2007-02-09 20:24:12 -08001783out_commit:
1784 ocfs2_commit_trans(osb, handle);
1785
Mark Fasheh9517bac2007-02-09 20:24:12 -08001786out:
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001787 ocfs2_free_write_ctxt(wc);
1788
Mark Fasheh9517bac2007-02-09 20:24:12 -08001789 if (data_ac)
1790 ocfs2_free_alloc_context(data_ac);
1791 if (meta_ac)
1792 ocfs2_free_alloc_context(meta_ac);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001793 return ret;
1794}
Mark Fasheh9517bac2007-02-09 20:24:12 -08001795
Nick Pigginb6af1bc2007-10-16 01:25:24 -07001796static int ocfs2_write_begin(struct file *file, struct address_space *mapping,
1797 loff_t pos, unsigned len, unsigned flags,
1798 struct page **pagep, void **fsdata)
Mark Fasheh607d44a2007-05-09 15:14:45 -07001799{
1800 int ret;
1801 struct buffer_head *di_bh = NULL;
1802 struct inode *inode = mapping->host;
1803
Mark Fashehe63aecb62007-10-18 15:30:42 -07001804 ret = ocfs2_inode_lock(inode, &di_bh, 1);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001805 if (ret) {
1806 mlog_errno(ret);
1807 return ret;
1808 }
1809
1810 /*
1811 * Take alloc sem here to prevent concurrent lookups. That way
1812 * the mapping, zeroing and tree manipulation within
1813 * ocfs2_write() will be safe against ->readpage(). This
1814 * should also serve to lock out allocation from a shared
1815 * writeable region.
1816 */
1817 down_write(&OCFS2_I(inode)->ip_alloc_sem);
1818
Mark Fasheh607d44a2007-05-09 15:14:45 -07001819 ret = ocfs2_write_begin_nolock(mapping, pos, len, flags, pagep,
Mark Fasheh7307de82007-05-09 15:16:19 -07001820 fsdata, di_bh, NULL);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001821 if (ret) {
1822 mlog_errno(ret);
Mark Fashehc934a922007-10-18 15:23:46 -07001823 goto out_fail;
Mark Fasheh607d44a2007-05-09 15:14:45 -07001824 }
1825
1826 brelse(di_bh);
1827
1828 return 0;
1829
Mark Fasheh607d44a2007-05-09 15:14:45 -07001830out_fail:
1831 up_write(&OCFS2_I(inode)->ip_alloc_sem);
1832
1833 brelse(di_bh);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001834 ocfs2_inode_unlock(inode, 1);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001835
1836 return ret;
1837}
1838
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001839static void ocfs2_write_end_inline(struct inode *inode, loff_t pos,
1840 unsigned len, unsigned *copied,
1841 struct ocfs2_dinode *di,
1842 struct ocfs2_write_ctxt *wc)
1843{
1844 void *kaddr;
1845
1846 if (unlikely(*copied < len)) {
1847 if (!PageUptodate(wc->w_target_page)) {
1848 *copied = 0;
1849 return;
1850 }
1851 }
1852
1853 kaddr = kmap_atomic(wc->w_target_page, KM_USER0);
1854 memcpy(di->id2.i_data.id_data + pos, kaddr + pos, *copied);
1855 kunmap_atomic(kaddr, KM_USER0);
1856
1857 mlog(0, "Data written to inode at offset %llu. "
1858 "id_count = %u, copied = %u, i_dyn_features = 0x%x\n",
1859 (unsigned long long)pos, *copied,
1860 le16_to_cpu(di->id2.i_data.id_count),
1861 le16_to_cpu(di->i_dyn_features));
1862}
1863
Mark Fasheh7307de82007-05-09 15:16:19 -07001864int ocfs2_write_end_nolock(struct address_space *mapping,
1865 loff_t pos, unsigned len, unsigned copied,
1866 struct page *page, void *fsdata)
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001867{
1868 int i;
1869 unsigned from, to, start = pos & (PAGE_CACHE_SIZE - 1);
1870 struct inode *inode = mapping->host;
1871 struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1872 struct ocfs2_write_ctxt *wc = fsdata;
1873 struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1874 handle_t *handle = wc->w_handle;
1875 struct page *tmppage;
1876
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001877 if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1878 ocfs2_write_end_inline(inode, pos, len, &copied, di, wc);
1879 goto out_write_size;
1880 }
1881
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001882 if (unlikely(copied < len)) {
1883 if (!PageUptodate(wc->w_target_page))
1884 copied = 0;
1885
1886 ocfs2_zero_new_buffers(wc->w_target_page, start+copied,
1887 start+len);
1888 }
1889 flush_dcache_page(wc->w_target_page);
1890
1891 for(i = 0; i < wc->w_num_pages; i++) {
1892 tmppage = wc->w_pages[i];
1893
1894 if (tmppage == wc->w_target_page) {
1895 from = wc->w_target_from;
1896 to = wc->w_target_to;
1897
1898 BUG_ON(from > PAGE_CACHE_SIZE ||
1899 to > PAGE_CACHE_SIZE ||
1900 to < from);
1901 } else {
1902 /*
1903 * Pages adjacent to the target (if any) imply
1904 * a hole-filling write in which case we want
1905 * to flush their entire range.
1906 */
1907 from = 0;
1908 to = PAGE_CACHE_SIZE;
1909 }
1910
Sunil Mushran961cecb2008-07-16 17:22:22 -07001911 if (page_has_buffers(tmppage)) {
Mark Fasheh53ef99c2008-11-18 16:53:43 -08001912 if (ocfs2_should_order_data(inode))
Joel Becker2b4e30f2008-09-03 20:03:41 -07001913 ocfs2_jbd2_file_inode(wc->w_handle, inode);
Sunil Mushran961cecb2008-07-16 17:22:22 -07001914 block_commit_write(tmppage, from, to);
1915 }
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001916 }
1917
Mark Fasheh1afc32b2007-09-07 14:46:51 -07001918out_write_size:
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001919 pos += copied;
1920 if (pos > inode->i_size) {
1921 i_size_write(inode, pos);
1922 mark_inode_dirty(inode);
1923 }
1924 inode->i_blocks = ocfs2_inode_sector_count(inode);
1925 di->i_size = cpu_to_le64((u64)i_size_read(inode));
1926 inode->i_mtime = inode->i_ctime = CURRENT_TIME;
1927 di->i_mtime = di->i_ctime = cpu_to_le64(inode->i_mtime.tv_sec);
1928 di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode->i_mtime.tv_nsec);
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001929 ocfs2_journal_dirty(handle, wc->w_di_bh);
1930
1931 ocfs2_commit_trans(osb, handle);
Mark Fasheh59a5e412007-06-22 15:52:36 -07001932
Mark Fashehb27b7cb2007-06-18 11:22:56 -07001933 ocfs2_run_deallocs(osb, &wc->w_dealloc);
1934
Mark Fasheh3a307ff2007-05-08 17:47:32 -07001935 ocfs2_free_write_ctxt(wc);
1936
1937 return copied;
Mark Fasheh9517bac2007-02-09 20:24:12 -08001938}
1939
Nick Pigginb6af1bc2007-10-16 01:25:24 -07001940static int ocfs2_write_end(struct file *file, struct address_space *mapping,
1941 loff_t pos, unsigned len, unsigned copied,
1942 struct page *page, void *fsdata)
Mark Fasheh607d44a2007-05-09 15:14:45 -07001943{
1944 int ret;
1945 struct inode *inode = mapping->host;
1946
1947 ret = ocfs2_write_end_nolock(mapping, pos, len, copied, page, fsdata);
1948
Mark Fasheh607d44a2007-05-09 15:14:45 -07001949 up_write(&OCFS2_I(inode)->ip_alloc_sem);
Mark Fashehe63aecb62007-10-18 15:30:42 -07001950 ocfs2_inode_unlock(inode, 1);
Mark Fasheh607d44a2007-05-09 15:14:45 -07001951
1952 return ret;
1953}
1954
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07001955const struct address_space_operations ocfs2_aops = {
Mark Fashehccd979b2005-12-15 14:31:24 -08001956 .readpage = ocfs2_readpage,
Mark Fasheh628a24f2007-10-30 12:08:32 -07001957 .readpages = ocfs2_readpages,
Mark Fashehccd979b2005-12-15 14:31:24 -08001958 .writepage = ocfs2_writepage,
Nick Pigginb6af1bc2007-10-16 01:25:24 -07001959 .write_begin = ocfs2_write_begin,
1960 .write_end = ocfs2_write_end,
Mark Fashehccd979b2005-12-15 14:31:24 -08001961 .bmap = ocfs2_bmap,
1962 .sync_page = block_sync_page,
Joel Becker03f981c2007-01-04 14:54:41 -08001963 .direct_IO = ocfs2_direct_IO,
1964 .invalidatepage = ocfs2_invalidatepage,
1965 .releasepage = ocfs2_releasepage,
1966 .migratepage = buffer_migrate_page,
Mark Fashehccd979b2005-12-15 14:31:24 -08001967};