1	// SPDX-License-Identifier: GPL-2.0-or-later
2	/*
3	* Copyright (C) 2002, 2004 Oracle. All rights reserved.
4	*/
5
6	#include <linux/fs.h>
7	#include <linux/slab.h>
8	#include <linux/highmem.h>
9	#include <linux/pagemap.h>
10	#include <asm/byteorder.h>
11	#include <linux/swap.h>
12	#include <linux/mpage.h>
13	#include <linux/quotaops.h>
14	#include <linux/blkdev.h>
15	#include <linux/uio.h>
16	#include <linux/mm.h>
17
18	#include <cluster/masklog.h>
19
20	#include "ocfs2.h"
21
22	#include "alloc.h"
23	#include "aops.h"
24	#include "dlmglue.h"
25	#include "extent_map.h"
26	#include "file.h"
27	#include "inode.h"
28	#include "journal.h"
29	#include "suballoc.h"
30	#include "super.h"
31	#include "symlink.h"
32	#include "refcounttree.h"
33	#include "ocfs2_trace.h"
34
35	#include "buffer_head_io.h"
36	#include "dir.h"
37	#include "namei.h"
38	#include "sysfile.h"
39
40	static int ocfs2_symlink_get_block(struct inode *inode, sector_t iblock,
41	struct buffer_head *bh_result, int create)
42	{
43	int err = -EIO;
44	int status;
45	struct ocfs2_dinode *fe = NULL;
46	struct buffer_head *bh = NULL;
47	struct buffer_head *buffer_cache_bh = NULL;
48	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
49	void *kaddr;
50
51	trace_ocfs2_symlink_get_block(
52	ino: (unsigned long long)OCFS2_I(inode)->ip_blkno,
53	iblock: (unsigned long long)iblock, bh_result, create);
54
55	BUG_ON(ocfs2_inode_is_fast_symlink(inode));
56
57	if ((iblock << inode->i_sb->s_blocksize_bits) > PATH_MAX + 1) {
58	mlog(ML_ERROR, "block offset > PATH_MAX: %llu",
59	(unsigned long long)iblock);
60	goto bail;
61	}
62
63	status = ocfs2_read_inode_block(inode, bh: &bh);
64	if (status < 0) {
65	mlog_errno(status);
66	goto bail;
67	}
68	fe = (struct ocfs2_dinode *) bh->b_data;
69
70	if ((u64)iblock >= ocfs2_clusters_to_blocks(sb: inode->i_sb,
71	le32_to_cpu(fe->i_clusters))) {
72	err = -ENOMEM;
73	mlog(ML_ERROR, "block offset is outside the allocated size: "
74	"%llu\n", (unsigned long long)iblock);
75	goto bail;
76	}
77
78	/* We don't use the page cache to create symlink data, so if
79	* need be, copy it over from the buffer cache. */
80	if (!buffer_uptodate(bh: bh_result) && ocfs2_inode_is_new(inode)) {
81	u64 blkno = le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) +
82	iblock;
83	buffer_cache_bh = sb_getblk(sb: osb->sb, block: blkno);
84	if (!buffer_cache_bh) {
85	err = -ENOMEM;
86	mlog(ML_ERROR, "couldn't getblock for symlink!\n");
87	goto bail;
88	}
89
90	/* we haven't locked out transactions, so a commit
91	* could've happened. Since we've got a reference on
92	* the bh, even if it commits while we're doing the
93	* copy, the data is still good. */
94	if (buffer_jbd(bh: buffer_cache_bh)
95	&& ocfs2_inode_is_new(inode)) {
96	kaddr = kmap_atomic(page: bh_result->b_page);
97	if (!kaddr) {
98	mlog(ML_ERROR, "couldn't kmap!\n");
99	goto bail;
100	}
101	memcpy(kaddr + (bh_result->b_size * iblock),
102	buffer_cache_bh->b_data,
103	bh_result->b_size);
104	kunmap_atomic(kaddr);
105	set_buffer_uptodate(bh_result);
106	}
107	brelse(bh: buffer_cache_bh);
108	}
109
110	map_bh(bh: bh_result, sb: inode->i_sb,
111	le64_to_cpu(fe->id2.i_list.l_recs[0].e_blkno) + iblock);
112
113	err = 0;
114
115	bail:
116	brelse(bh);
117
118	return err;
119	}
120
121	static int ocfs2_lock_get_block(struct inode *inode, sector_t iblock,
122	struct buffer_head *bh_result, int create)
123	{
124	int ret = 0;
125	struct ocfs2_inode_info *oi = OCFS2_I(inode);
126
127	down_read(sem: &oi->ip_alloc_sem);
128	ret = ocfs2_get_block(inode, iblock, bh_result, create);
129	up_read(sem: &oi->ip_alloc_sem);
130
131	return ret;
132	}
133
134	int ocfs2_get_block(struct inode *inode, sector_t iblock,
135	struct buffer_head *bh_result, int create)
136	{
137	int err = 0;
138	unsigned int ext_flags;
139	u64 max_blocks = bh_result->b_size >> inode->i_blkbits;
140	u64 p_blkno, count, past_eof;
141	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
142
143	trace_ocfs2_get_block(ino: (unsigned long long)OCFS2_I(inode)->ip_blkno,
144	iblock: (unsigned long long)iblock, bh_result, create);
145
146	if (OCFS2_I(inode)->ip_flags & OCFS2_INODE_SYSTEM_FILE)
147	mlog(ML_NOTICE, "get_block on system inode 0x%p (%lu)\n",
148	inode, inode->i_ino);
149
150	if (S_ISLNK(inode->i_mode)) {
151	/* this always does I/O for some reason. */
152	err = ocfs2_symlink_get_block(inode, iblock, bh_result, create);
153	goto bail;
154	}
155
156	err = ocfs2_extent_map_get_blocks(inode, v_blkno: iblock, p_blkno: &p_blkno, ret_count: &count,
157	extent_flags: &ext_flags);
158	if (err) {
159	mlog(ML_ERROR, "Error %d from get_blocks(0x%p, %llu, 1, "
160	"%llu, NULL)\n", err, inode, (unsigned long long)iblock,
161	(unsigned long long)p_blkno);
162	goto bail;
163	}
164
165	if (max_blocks < count)
166	count = max_blocks;
167
168	/*
169	* ocfs2 never allocates in this function - the only time we
170	* need to use BH_New is when we're extending i_size on a file
171	* system which doesn't support holes, in which case BH_New
172	* allows __block_write_begin() to zero.
173	*
174	* If we see this on a sparse file system, then a truncate has
175	* raced us and removed the cluster. In this case, we clear
176	* the buffers dirty and uptodate bits and let the buffer code
177	* ignore it as a hole.
178	*/
179	if (create && p_blkno == 0 && ocfs2_sparse_alloc(osb)) {
180	clear_buffer_dirty(bh: bh_result);
181	clear_buffer_uptodate(bh: bh_result);
182	goto bail;
183	}
184
185	/* Treat the unwritten extent as a hole for zeroing purposes. */
186	if (p_blkno && !(ext_flags & OCFS2_EXT_UNWRITTEN))
187	map_bh(bh: bh_result, sb: inode->i_sb, block: p_blkno);
188
189	bh_result->b_size = count << inode->i_blkbits;
190
191	if (!ocfs2_sparse_alloc(osb)) {
192	if (p_blkno == 0) {
193	err = -EIO;
194	mlog(ML_ERROR,
195	"iblock = %llu p_blkno = %llu blkno=(%llu)\n",
196	(unsigned long long)iblock,
197	(unsigned long long)p_blkno,
198	(unsigned long long)OCFS2_I(inode)->ip_blkno);
199	mlog(ML_ERROR, "Size %llu, clusters %u\n", (unsigned long long)i_size_read(inode), OCFS2_I(inode)->ip_clusters);
200	dump_stack();
201	goto bail;
202	}
203	}
204
205	past_eof = ocfs2_blocks_for_bytes(sb: inode->i_sb, bytes: i_size_read(inode));
206
207	trace_ocfs2_get_block_end(val1: (unsigned long long)OCFS2_I(inode)->ip_blkno,
208	val2: (unsigned long long)past_eof);
209	if (create && (iblock >= past_eof))
210	set_buffer_new(bh_result);
211
212	bail:
213	if (err < 0)
214	err = -EIO;
215
216	return err;
217	}
218
219	int ocfs2_read_inline_data(struct inode *inode, struct page *page,
220	struct buffer_head *di_bh)
221	{
222	void *kaddr;
223	loff_t size;
224	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
225
226	if (!(le16_to_cpu(di->i_dyn_features) & OCFS2_INLINE_DATA_FL)) {
227	ocfs2_error(inode->i_sb, "Inode %llu lost inline data flag\n",
228	(unsigned long long)OCFS2_I(inode)->ip_blkno);
229	return -EROFS;
230	}
231
232	size = i_size_read(inode);
233
234	if (size > PAGE_SIZE ||
235	size > ocfs2_max_inline_data_with_xattr(sb: inode->i_sb, di)) {
236	ocfs2_error(inode->i_sb,
237	"Inode %llu has with inline data has bad size: %Lu\n",
238	(unsigned long long)OCFS2_I(inode)->ip_blkno,
239	(unsigned long long)size);
240	return -EROFS;
241	}
242
243	kaddr = kmap_atomic(page);
244	if (size)
245	memcpy(kaddr, di->id2.i_data.id_data, size);
246	/* Clear the remaining part of the page */
247	memset(kaddr + size, 0, PAGE_SIZE - size);
248	flush_dcache_page(page);
249	kunmap_atomic(kaddr);
250
251	SetPageUptodate(page);
252
253	return 0;
254	}
255
256	static int ocfs2_readpage_inline(struct inode *inode, struct page *page)
257	{
258	int ret;
259	struct buffer_head *di_bh = NULL;
260
261	BUG_ON(!PageLocked(page));
262	BUG_ON(!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL));
263
264	ret = ocfs2_read_inode_block(inode, bh: &di_bh);
265	if (ret) {
266	mlog_errno(ret);
267	goto out;
268	}
269
270	ret = ocfs2_read_inline_data(inode, page, di_bh);
271	out:
272	unlock_page(page);
273
274	brelse(bh: di_bh);
275	return ret;
276	}
277
278	static int ocfs2_read_folio(struct file *file, struct folio *folio)
279	{
280	struct inode *inode = folio->mapping->host;
281	struct ocfs2_inode_info *oi = OCFS2_I(inode);
282	loff_t start = folio_pos(folio);
283	int ret, unlock = 1;
284
285	trace_ocfs2_readpage(val1: (unsigned long long)oi->ip_blkno, val2: folio->index);
286
287	ret = ocfs2_inode_lock_with_page(inode, NULL, ex: 0, page: &folio->page);
288	if (ret != 0) {
289	if (ret == AOP_TRUNCATED_PAGE)
290	unlock = 0;
291	mlog_errno(ret);
292	goto out;
293	}
294
295	if (down_read_trylock(sem: &oi->ip_alloc_sem) == 0) {
296	/*
297	* Unlock the folio and cycle ip_alloc_sem so that we don't
298	* busyloop waiting for ip_alloc_sem to unlock
299	*/
300	ret = AOP_TRUNCATED_PAGE;
301	folio_unlock(folio);
302	unlock = 0;
303	down_read(sem: &oi->ip_alloc_sem);
304	up_read(sem: &oi->ip_alloc_sem);
305	goto out_inode_unlock;
306	}
307
308	/*
309	* i_size might have just been updated as we grabed the meta lock. We
310	* might now be discovering a truncate that hit on another node.
311	* block_read_full_folio->get_block freaks out if it is asked to read
312	* beyond the end of a file, so we check here. Callers
313	* (generic_file_read, vm_ops->fault) are clever enough to check i_size
314	* and notice that the folio they just read isn't needed.
315	*
316	* XXX sys_readahead() seems to get that wrong?
317	*/
318	if (start >= i_size_read(inode)) {
319	folio_zero_segment(folio, start: 0, xend: folio_size(folio));
320	folio_mark_uptodate(folio);
321	ret = 0;
322	goto out_alloc;
323	}
324
325	if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
326	ret = ocfs2_readpage_inline(inode, page: &folio->page);
327	else
328	ret = block_read_full_folio(folio, ocfs2_get_block);
329	unlock = 0;
330
331	out_alloc:
332	up_read(sem: &oi->ip_alloc_sem);
333	out_inode_unlock:
334	ocfs2_inode_unlock(inode, ex: 0);
335	out:
336	if (unlock)
337	folio_unlock(folio);
338	return ret;
339	}
340
341	/*
342	* This is used only for read-ahead. Failures or difficult to handle
343	* situations are safe to ignore.
344	*
345	* Right now, we don't bother with BH_Boundary - in-inode extent lists
346	* are quite large (243 extents on 4k blocks), so most inodes don't
347	* grow out to a tree. If need be, detecting boundary extents could
348	* trivially be added in a future version of ocfs2_get_block().
349	*/
350	static void ocfs2_readahead(struct readahead_control *rac)
351	{
352	int ret;
353	struct inode *inode = rac->mapping->host;
354	struct ocfs2_inode_info *oi = OCFS2_I(inode);
355
356	/*
357	* Use the nonblocking flag for the dlm code to avoid page
358	* lock inversion, but don't bother with retrying.
359	*/
360	ret = ocfs2_inode_lock_full(inode, NULL, 0, OCFS2_LOCK_NONBLOCK);
361	if (ret)
362	return;
363
364	if (down_read_trylock(sem: &oi->ip_alloc_sem) == 0)
365	goto out_unlock;
366
367	/*
368	* Don't bother with inline-data. There isn't anything
369	* to read-ahead in that case anyway...
370	*/
371	if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL)
372	goto out_up;
373
374	/*
375	* Check whether a remote node truncated this file - we just
376	* drop out in that case as it's not worth handling here.
377	*/
378	if (readahead_pos(rac) >= i_size_read(inode))
379	goto out_up;
380
381	mpage_readahead(rac, get_block: ocfs2_get_block);
382
383	out_up:
384	up_read(sem: &oi->ip_alloc_sem);
385	out_unlock:
386	ocfs2_inode_unlock(inode, ex: 0);
387	}
388
389	/* Note: Because we don't support holes, our allocation has
390	* already happened (allocation writes zeros to the file data)
391	* so we don't have to worry about ordered writes in
392	* ocfs2_writepages.
393	*
394	* ->writepages is called during the process of invalidating the page cache
395	* during blocked lock processing. It can't block on any cluster locks
396	* to during block mapping. It's relying on the fact that the block
397	* mapping can't have disappeared under the dirty pages that it is
398	* being asked to write back.
399	*/
400	static int ocfs2_writepages(struct address_space *mapping,
401	struct writeback_control *wbc)
402	{
403	return mpage_writepages(mapping, wbc, get_block: ocfs2_get_block);
404	}
405
406	/* Taken from ext3. We don't necessarily need the full blown
407	* functionality yet, but IMHO it's better to cut and paste the whole
408	* thing so we can avoid introducing our own bugs (and easily pick up
409	* their fixes when they happen) --Mark */
410	int walk_page_buffers( handle_t *handle,
411	struct buffer_head *head,
412	unsigned from,
413	unsigned to,
414	int *partial,
415	int (*fn)( handle_t *handle,
416	struct buffer_head *bh))
417	{
418	struct buffer_head *bh;
419	unsigned block_start, block_end;
420	unsigned blocksize = head->b_size;
421	int err, ret = 0;
422	struct buffer_head *next;
423
424	for ( bh = head, block_start = 0;
425	ret == 0 && (bh != head || !block_start);
426	block_start = block_end, bh = next)
427	{
428	next = bh->b_this_page;
429	block_end = block_start + blocksize;
430	if (block_end <= from || block_start >= to) {
431	if (partial && !buffer_uptodate(bh))
432	*partial = 1;
433	continue;
434	}
435	err = (*fn)(handle, bh);
436	if (!ret)
437	ret = err;
438	}
439	return ret;
440	}
441
442	static sector_t ocfs2_bmap(struct address_space *mapping, sector_t block)
443	{
444	sector_t status;
445	u64 p_blkno = 0;
446	int err = 0;
447	struct inode *inode = mapping->host;
448
449	trace_ocfs2_bmap(val1: (unsigned long long)OCFS2_I(inode)->ip_blkno,
450	val2: (unsigned long long)block);
451
452	/*
453	* The swap code (ab-)uses ->bmap to get a block mapping and then
454	* bypasseѕ the file system for actual I/O. We really can't allow
455	* that on refcounted inodes, so we have to skip out here. And yes,
456	* 0 is the magic code for a bmap error..
457	*/
458	if (ocfs2_is_refcount_inode(inode))
459	return 0;
460
461	/* We don't need to lock journal system files, since they aren't
462	* accessed concurrently from multiple nodes.
463	*/
464	if (!INODE_JOURNAL(inode)) {
465	err = ocfs2_inode_lock(inode, NULL, 0);
466	if (err) {
467	if (err != -ENOENT)
468	mlog_errno(err);
469	goto bail;
470	}
471	down_read(sem: &OCFS2_I(inode)->ip_alloc_sem);
472	}
473
474	if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL))
475	err = ocfs2_extent_map_get_blocks(inode, v_blkno: block, p_blkno: &p_blkno, NULL,
476	NULL);
477
478	if (!INODE_JOURNAL(inode)) {
479	up_read(sem: &OCFS2_I(inode)->ip_alloc_sem);
480	ocfs2_inode_unlock(inode, ex: 0);
481	}
482
483	if (err) {
484	mlog(ML_ERROR, "get_blocks() failed, block = %llu\n",
485	(unsigned long long)block);
486	mlog_errno(err);
487	goto bail;
488	}
489
490	bail:
491	status = err ? 0 : p_blkno;
492
493	return status;
494	}
495
496	static bool ocfs2_release_folio(struct folio *folio, gfp_t wait)
497	{
498	if (!folio_buffers(folio))
499	return false;
500	return try_to_free_buffers(folio);
501	}
502
503	static void ocfs2_figure_cluster_boundaries(struct ocfs2_super *osb,
504	u32 cpos,
505	unsigned int *start,
506	unsigned int *end)
507	{
508	unsigned int cluster_start = 0, cluster_end = PAGE_SIZE;
509
510	if (unlikely(PAGE_SHIFT > osb->s_clustersize_bits)) {
511	unsigned int cpp;
512
513	cpp = 1 << (PAGE_SHIFT - osb->s_clustersize_bits);
514
515	cluster_start = cpos % cpp;
516	cluster_start = cluster_start << osb->s_clustersize_bits;
517
518	cluster_end = cluster_start + osb->s_clustersize;
519	}
520
521	BUG_ON(cluster_start > PAGE_SIZE);
522	BUG_ON(cluster_end > PAGE_SIZE);
523
524	if (start)
525	*start = cluster_start;
526	if (end)
527	*end = cluster_end;
528	}
529
530	/*
531	* 'from' and 'to' are the region in the page to avoid zeroing.
532	*
533	* If pagesize > clustersize, this function will avoid zeroing outside
534	* of the cluster boundary.
535	*
536	* from == to == 0 is code for "zero the entire cluster region"
537	*/
538	static void ocfs2_clear_page_regions(struct page *page,
539	struct ocfs2_super *osb, u32 cpos,
540	unsigned from, unsigned to)
541	{
542	void *kaddr;
543	unsigned int cluster_start, cluster_end;
544
545	ocfs2_figure_cluster_boundaries(osb, cpos, start: &cluster_start, end: &cluster_end);
546
547	kaddr = kmap_atomic(page);
548
549	if (from || to) {
550	if (from > cluster_start)
551	memset(kaddr + cluster_start, 0, from - cluster_start);
552	if (to < cluster_end)
553	memset(kaddr + to, 0, cluster_end - to);
554	} else {
555	memset(kaddr + cluster_start, 0, cluster_end - cluster_start);
556	}
557
558	kunmap_atomic(kaddr);
559	}
560
561	/*
562	* Nonsparse file systems fully allocate before we get to the write
563	* code. This prevents ocfs2_write() from tagging the write as an
564	* allocating one, which means ocfs2_map_page_blocks() might try to
565	* read-in the blocks at the tail of our file. Avoid reading them by
566	* testing i_size against each block offset.
567	*/
568	static int ocfs2_should_read_blk(struct inode *inode, struct folio *folio,
569	unsigned int block_start)
570	{
571	u64 offset = folio_pos(folio) + block_start;
572
573	if (ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)))
574	return 1;
575
576	if (i_size_read(inode) > offset)
577	return 1;
578
579	return 0;
580	}
581
582	/*
583	* Some of this taken from __block_write_begin(). We already have our
584	* mapping by now though, and the entire write will be allocating or
585	* it won't, so not much need to use BH_New.
586	*
587	* This will also skip zeroing, which is handled externally.
588	*/
589	int ocfs2_map_page_blocks(struct page *page, u64 *p_blkno,
590	struct inode *inode, unsigned int from,
591	unsigned int to, int new)
592	{
593	struct folio *folio = page_folio(page);
594	int ret = 0;
595	struct buffer_head *head, *bh, *wait[2], **wait_bh = wait;
596	unsigned int block_end, block_start;
597	unsigned int bsize = i_blocksize(node: inode);
598
599	head = folio_buffers(folio);
600	if (!head)
601	head = create_empty_buffers(folio, blocksize: bsize, b_state: 0);
602
603	for (bh = head, block_start = 0; bh != head || !block_start;
604	bh = bh->b_this_page, block_start += bsize) {
605	block_end = block_start + bsize;
606
607	clear_buffer_new(bh);
608
609	/*
610	* Ignore blocks outside of our i/o range -
611	* they may belong to unallocated clusters.
612	*/
613	if (block_start >= to || block_end <= from) {
614	if (folio_test_uptodate(folio))
615	set_buffer_uptodate(bh);
616	continue;
617	}
618
619	/*
620	* For an allocating write with cluster size >= page
621	* size, we always write the entire page.
622	*/
623	if (new)
624	set_buffer_new(bh);
625
626	if (!buffer_mapped(bh)) {
627	map_bh(bh, sb: inode->i_sb, block: *p_blkno);
628	clean_bdev_bh_alias(bh);
629	}
630
631	if (folio_test_uptodate(folio)) {
632	set_buffer_uptodate(bh);
633	} else if (!buffer_uptodate(bh) && !buffer_delay(bh) &&
634	!buffer_new(bh) &&
635	ocfs2_should_read_blk(inode, folio, block_start) &&
636	(block_start < from || block_end > to)) {
637	bh_read_nowait(bh, op_flags: 0);
638	*wait_bh++=bh;
639	}
640
641	*p_blkno = *p_blkno + 1;
642	}
643
644	/*
645	* If we issued read requests - let them complete.
646	*/
647	while(wait_bh > wait) {
648	wait_on_buffer(bh: *--wait_bh);
649	if (!buffer_uptodate(bh: *wait_bh))
650	ret = -EIO;
651	}
652
653	if (ret == 0 || !new)
654	return ret;
655
656	/*
657	* If we get -EIO above, zero out any newly allocated blocks
658	* to avoid exposing stale data.
659	*/
660	bh = head;
661	block_start = 0;
662	do {
663	block_end = block_start + bsize;
664	if (block_end <= from)
665	goto next_bh;
666	if (block_start >= to)
667	break;
668
669	folio_zero_range(folio, start: block_start, length: bh->b_size);
670	set_buffer_uptodate(bh);
671	mark_buffer_dirty(bh);
672
673	next_bh:
674	block_start = block_end;
675	bh = bh->b_this_page;
676	} while (bh != head);
677
678	return ret;
679	}
680
681	#if (PAGE_SIZE >= OCFS2_MAX_CLUSTERSIZE)
682	#define OCFS2_MAX_CTXT_PAGES 1
683	#else
684	#define OCFS2_MAX_CTXT_PAGES (OCFS2_MAX_CLUSTERSIZE / PAGE_SIZE)
685	#endif
686
687	#define OCFS2_MAX_CLUSTERS_PER_PAGE (PAGE_SIZE / OCFS2_MIN_CLUSTERSIZE)
688
689	struct ocfs2_unwritten_extent {
690	struct list_head ue_node;
691	struct list_head ue_ip_node;
692	u32 ue_cpos;
693	u32 ue_phys;
694	};
695
696	/*
697	* Describe the state of a single cluster to be written to.
698	*/
699	struct ocfs2_write_cluster_desc {
700	u32 c_cpos;
701	u32 c_phys;
702	/*
703	* Give this a unique field because c_phys eventually gets
704	* filled.
705	*/
706	unsigned c_new;
707	unsigned c_clear_unwritten;
708	unsigned c_needs_zero;
709	};
710
711	struct ocfs2_write_ctxt {
712	/* Logical cluster position / len of write */
713	u32 w_cpos;
714	u32 w_clen;
715
716	/* First cluster allocated in a nonsparse extend */
717	u32 w_first_new_cpos;
718
719	/* Type of caller. Must be one of buffer, mmap, direct. */
720	ocfs2_write_type_t w_type;
721
722	struct ocfs2_write_cluster_desc w_desc[OCFS2_MAX_CLUSTERS_PER_PAGE];
723
724	/*
725	* This is true if page_size > cluster_size.
726	*
727	* It triggers a set of special cases during write which might
728	* have to deal with allocating writes to partial pages.
729	*/
730	unsigned int w_large_pages;
731
732	/*
733	* Pages involved in this write.
734	*
735	* w_target_page is the page being written to by the user.
736	*
737	* w_pages is an array of pages which always contains
738	* w_target_page, and in the case of an allocating write with
739	* page_size < cluster size, it will contain zero'd and mapped
740	* pages adjacent to w_target_page which need to be written
741	* out in so that future reads from that region will get
742	* zero's.
743	*/
744	unsigned int w_num_pages;
745	struct page *w_pages[OCFS2_MAX_CTXT_PAGES];
746	struct page *w_target_page;
747
748	/*
749	* w_target_locked is used for page_mkwrite path indicating no unlocking
750	* against w_target_page in ocfs2_write_end_nolock.
751	*/
752	unsigned int w_target_locked:1;
753
754	/*
755	* ocfs2_write_end() uses this to know what the real range to
756	* write in the target should be.
757	*/
758	unsigned int w_target_from;
759	unsigned int w_target_to;
760
761	/*
762	* We could use journal_current_handle() but this is cleaner,
763	* IMHO -Mark
764	*/
765	handle_t *w_handle;
766
767	struct buffer_head *w_di_bh;
768
769	struct ocfs2_cached_dealloc_ctxt w_dealloc;
770
771	struct list_head w_unwritten_list;
772	unsigned int w_unwritten_count;
773	};
774
775	void ocfs2_unlock_and_free_pages(struct page **pages, int num_pages)
776	{
777	int i;
778
779	for(i = 0; i < num_pages; i++) {
780	if (pages[i]) {
781	unlock_page(page: pages[i]);
782	mark_page_accessed(pages[i]);
783	put_page(page: pages[i]);
784	}
785	}
786	}
787
788	static void ocfs2_unlock_pages(struct ocfs2_write_ctxt *wc)
789	{
790	int i;
791
792	/*
793	* w_target_locked is only set to true in the page_mkwrite() case.
794	* The intent is to allow us to lock the target page from write_begin()
795	* to write_end(). The caller must hold a ref on w_target_page.
796	*/
797	if (wc->w_target_locked) {
798	BUG_ON(!wc->w_target_page);
799	for (i = 0; i < wc->w_num_pages; i++) {
800	if (wc->w_target_page == wc->w_pages[i]) {
801	wc->w_pages[i] = NULL;
802	break;
803	}
804	}
805	mark_page_accessed(wc->w_target_page);
806	put_page(page: wc->w_target_page);
807	}
808	ocfs2_unlock_and_free_pages(pages: wc->w_pages, num_pages: wc->w_num_pages);
809	}
810
811	static void ocfs2_free_unwritten_list(struct inode *inode,
812	struct list_head *head)
813	{
814	struct ocfs2_inode_info *oi = OCFS2_I(inode);
815	struct ocfs2_unwritten_extent *ue = NULL, *tmp = NULL;
816
817	list_for_each_entry_safe(ue, tmp, head, ue_node) {
818	list_del(entry: &ue->ue_node);
819	spin_lock(lock: &oi->ip_lock);
820	list_del(entry: &ue->ue_ip_node);
821	spin_unlock(lock: &oi->ip_lock);
822	kfree(objp: ue);
823	}
824	}
825
826	static void ocfs2_free_write_ctxt(struct inode *inode,
827	struct ocfs2_write_ctxt *wc)
828	{
829	ocfs2_free_unwritten_list(inode, head: &wc->w_unwritten_list);
830	ocfs2_unlock_pages(wc);
831	brelse(bh: wc->w_di_bh);
832	kfree(objp: wc);
833	}
834
835	static int ocfs2_alloc_write_ctxt(struct ocfs2_write_ctxt **wcp,
836	struct ocfs2_super *osb, loff_t pos,
837	unsigned len, ocfs2_write_type_t type,
838	struct buffer_head *di_bh)
839	{
840	u32 cend;
841	struct ocfs2_write_ctxt *wc;
842
843	wc = kzalloc(size: sizeof(struct ocfs2_write_ctxt), GFP_NOFS);
844	if (!wc)
845	return -ENOMEM;
846
847	wc->w_cpos = pos >> osb->s_clustersize_bits;
848	wc->w_first_new_cpos = UINT_MAX;
849	cend = (pos + len - 1) >> osb->s_clustersize_bits;
850	wc->w_clen = cend - wc->w_cpos + 1;
851	get_bh(bh: di_bh);
852	wc->w_di_bh = di_bh;
853	wc->w_type = type;
854
855	if (unlikely(PAGE_SHIFT > osb->s_clustersize_bits))
856	wc->w_large_pages = 1;
857	else
858	wc->w_large_pages = 0;
859
860	ocfs2_init_dealloc_ctxt(c: &wc->w_dealloc);
861	INIT_LIST_HEAD(list: &wc->w_unwritten_list);
862
863	*wcp = wc;
864
865	return 0;
866	}
867
868	/*
869	* If a page has any new buffers, zero them out here, and mark them uptodate
870	* and dirty so they'll be written out (in order to prevent uninitialised
871	* block data from leaking). And clear the new bit.
872	*/
873	static void ocfs2_zero_new_buffers(struct page *page, unsigned from, unsigned to)
874	{
875	unsigned int block_start, block_end;
876	struct buffer_head *head, *bh;
877
878	BUG_ON(!PageLocked(page));
879	if (!page_has_buffers(page))
880	return;
881
882	bh = head = page_buffers(page);
883	block_start = 0;
884	do {
885	block_end = block_start + bh->b_size;
886
887	if (buffer_new(bh)) {
888	if (block_end > from && block_start < to) {
889	if (!PageUptodate(page)) {
890	unsigned start, end;
891
892	start = max(from, block_start);
893	end = min(to, block_end);
894
895	zero_user_segment(page, start, end);
896	set_buffer_uptodate(bh);
897	}
898
899	clear_buffer_new(bh);
900	mark_buffer_dirty(bh);
901	}
902	}
903
904	block_start = block_end;
905	bh = bh->b_this_page;
906	} while (bh != head);
907	}
908
909	/*
910	* Only called when we have a failure during allocating write to write
911	* zero's to the newly allocated region.
912	*/
913	static void ocfs2_write_failure(struct inode *inode,
914	struct ocfs2_write_ctxt *wc,
915	loff_t user_pos, unsigned user_len)
916	{
917	int i;
918	unsigned from = user_pos & (PAGE_SIZE - 1),
919	to = user_pos + user_len;
920	struct page *tmppage;
921
922	if (wc->w_target_page)
923	ocfs2_zero_new_buffers(page: wc->w_target_page, from, to);
924
925	for(i = 0; i < wc->w_num_pages; i++) {
926	tmppage = wc->w_pages[i];
927
928	if (tmppage && page_has_buffers(tmppage)) {
929	if (ocfs2_should_order_data(inode))
930	ocfs2_jbd2_inode_add_write(handle: wc->w_handle, inode,
931	start_byte: user_pos, length: user_len);
932
933	block_commit_write(page: tmppage, from, to);
934	}
935	}
936	}
937
938	static int ocfs2_prepare_page_for_write(struct inode *inode, u64 *p_blkno,
939	struct ocfs2_write_ctxt *wc,
940	struct page *page, u32 cpos,
941	loff_t user_pos, unsigned user_len,
942	int new)
943	{
944	int ret;
945	unsigned int map_from = 0, map_to = 0;
946	unsigned int cluster_start, cluster_end;
947	unsigned int user_data_from = 0, user_data_to = 0;
948
949	ocfs2_figure_cluster_boundaries(OCFS2_SB(inode->i_sb), cpos,
950	start: &cluster_start, end: &cluster_end);
951
952	/* treat the write as new if the a hole/lseek spanned across
953	* the page boundary.
954	*/
955	new = new | ((i_size_read(inode) <= page_offset(page)) &&
956	(page_offset(page) <= user_pos));
957
958	if (page == wc->w_target_page) {
959	map_from = user_pos & (PAGE_SIZE - 1);
960	map_to = map_from + user_len;
961
962	if (new)
963	ret = ocfs2_map_page_blocks(page, p_blkno, inode,
964	from: cluster_start, to: cluster_end,
965	new);
966	else
967	ret = ocfs2_map_page_blocks(page, p_blkno, inode,
968	from: map_from, to: map_to, new);
969	if (ret) {
970	mlog_errno(ret);
971	goto out;
972	}
973
974	user_data_from = map_from;
975	user_data_to = map_to;
976	if (new) {
977	map_from = cluster_start;
978	map_to = cluster_end;
979	}
980	} else {
981	/*
982	* If we haven't allocated the new page yet, we
983	* shouldn't be writing it out without copying user
984	* data. This is likely a math error from the caller.
985	*/
986	BUG_ON(!new);
987
988	map_from = cluster_start;
989	map_to = cluster_end;
990
991	ret = ocfs2_map_page_blocks(page, p_blkno, inode,
992	from: cluster_start, to: cluster_end, new);
993	if (ret) {
994	mlog_errno(ret);
995	goto out;
996	}
997	}
998
999	/*
1000	* Parts of newly allocated pages need to be zero'd.
1001	*
1002	* Above, we have also rewritten 'to' and 'from' - as far as
1003	* the rest of the function is concerned, the entire cluster
1004	* range inside of a page needs to be written.
1005	*
1006	* We can skip this if the page is up to date - it's already
1007	* been zero'd from being read in as a hole.
1008	*/
1009	if (new && !PageUptodate(page))
1010	ocfs2_clear_page_regions(page, OCFS2_SB(inode->i_sb),
1011	cpos, from: user_data_from, to: user_data_to);
1012
1013	flush_dcache_page(page);
1014
1015	out:
1016	return ret;
1017	}
1018
1019	/*
1020	* This function will only grab one clusters worth of pages.
1021	*/
1022	static int ocfs2_grab_pages_for_write(struct address_space *mapping,
1023	struct ocfs2_write_ctxt *wc,
1024	u32 cpos, loff_t user_pos,
1025	unsigned user_len, int new,
1026	struct page *mmap_page)
1027	{
1028	int ret = 0, i;
1029	unsigned long start, target_index, end_index, index;
1030	struct inode *inode = mapping->host;
1031	loff_t last_byte;
1032
1033	target_index = user_pos >> PAGE_SHIFT;
1034
1035	/*
1036	* Figure out how many pages we'll be manipulating here. For
1037	* non allocating write, we just change the one
1038	* page. Otherwise, we'll need a whole clusters worth. If we're
1039	* writing past i_size, we only need enough pages to cover the
1040	* last page of the write.
1041	*/
1042	if (new) {
1043	wc->w_num_pages = ocfs2_pages_per_cluster(sb: inode->i_sb);
1044	start = ocfs2_align_clusters_to_page_index(sb: inode->i_sb, clusters: cpos);
1045	/*
1046	* We need the index *past* the last page we could possibly
1047	* touch. This is the page past the end of the write or
1048	* i_size, whichever is greater.
1049	*/
1050	last_byte = max(user_pos + user_len, i_size_read(inode));
1051	BUG_ON(last_byte < 1);
1052	end_index = ((last_byte - 1) >> PAGE_SHIFT) + 1;
1053	if ((start + wc->w_num_pages) > end_index)
1054	wc->w_num_pages = end_index - start;
1055	} else {
1056	wc->w_num_pages = 1;
1057	start = target_index;
1058	}
1059	end_index = (user_pos + user_len - 1) >> PAGE_SHIFT;
1060
1061	for(i = 0; i < wc->w_num_pages; i++) {
1062	index = start + i;
1063
1064	if (index >= target_index && index <= end_index &&
1065	wc->w_type == OCFS2_WRITE_MMAP) {
1066	/*
1067	* ocfs2_pagemkwrite() is a little different
1068	* and wants us to directly use the page
1069	* passed in.
1070	*/
1071	lock_page(page: mmap_page);
1072
1073	/* Exit and let the caller retry */
1074	if (mmap_page->mapping != mapping) {
1075	WARN_ON(mmap_page->mapping);
1076	unlock_page(page: mmap_page);
1077	ret = -EAGAIN;
1078	goto out;
1079	}
1080
1081	get_page(page: mmap_page);
1082	wc->w_pages[i] = mmap_page;
1083	wc->w_target_locked = true;
1084	} else if (index >= target_index && index <= end_index &&
1085	wc->w_type == OCFS2_WRITE_DIRECT) {
1086	/* Direct write has no mapping page. */
1087	wc->w_pages[i] = NULL;
1088	continue;
1089	} else {
1090	wc->w_pages[i] = find_or_create_page(mapping, index,
1091	GFP_NOFS);
1092	if (!wc->w_pages[i]) {
1093	ret = -ENOMEM;
1094	mlog_errno(ret);
1095	goto out;
1096	}
1097	}
1098	wait_for_stable_page(page: wc->w_pages[i]);
1099
1100	if (index == target_index)
1101	wc->w_target_page = wc->w_pages[i];
1102	}
1103	out:
1104	if (ret)
1105	wc->w_target_locked = false;
1106	return ret;
1107	}
1108
1109	/*
1110	* Prepare a single cluster for write one cluster into the file.
1111	*/
1112	static int ocfs2_write_cluster(struct address_space *mapping,
1113	u32 *phys, unsigned int new,
1114	unsigned int clear_unwritten,
1115	unsigned int should_zero,
1116	struct ocfs2_alloc_context *data_ac,
1117	struct ocfs2_alloc_context *meta_ac,
1118	struct ocfs2_write_ctxt *wc, u32 cpos,
1119	loff_t user_pos, unsigned user_len)
1120	{
1121	int ret, i;
1122	u64 p_blkno;
1123	struct inode *inode = mapping->host;
1124	struct ocfs2_extent_tree et;
1125	int bpc = ocfs2_clusters_to_blocks(sb: inode->i_sb, clusters: 1);
1126
1127	if (new) {
1128	u32 tmp_pos;
1129
1130	/*
1131	* This is safe to call with the page locks - it won't take
1132	* any additional semaphores or cluster locks.
1133	*/
1134	tmp_pos = cpos;
1135	ret = ocfs2_add_inode_data(OCFS2_SB(inode->i_sb), inode,
1136	logical_offset: &tmp_pos, clusters_to_add: 1, mark_unwritten: !clear_unwritten,
1137	fe_bh: wc->w_di_bh, handle: wc->w_handle,
1138	data_ac, meta_ac, NULL);
1139	/*
1140	* This shouldn't happen because we must have already
1141	* calculated the correct meta data allocation required. The
1142	* internal tree allocation code should know how to increase
1143	* transaction credits itself.
1144	*
1145	* If need be, we could handle -EAGAIN for a
1146	* RESTART_TRANS here.
1147	*/
1148	mlog_bug_on_msg(ret == -EAGAIN,
1149	"Inode %llu: EAGAIN return during allocation.\n",
1150	(unsigned long long)OCFS2_I(inode)->ip_blkno);
1151	if (ret < 0) {
1152	mlog_errno(ret);
1153	goto out;
1154	}
1155	} else if (clear_unwritten) {
1156	ocfs2_init_dinode_extent_tree(et: &et, ci: INODE_CACHE(inode),
1157	bh: wc->w_di_bh);
1158	ret = ocfs2_mark_extent_written(inode, et: &et,
1159	handle: wc->w_handle, cpos, len: 1, phys: *phys,
1160	meta_ac, dealloc: &wc->w_dealloc);
1161	if (ret < 0) {
1162	mlog_errno(ret);
1163	goto out;
1164	}
1165	}
1166
1167	/*
1168	* The only reason this should fail is due to an inability to
1169	* find the extent added.
1170	*/
1171	ret = ocfs2_get_clusters(inode, v_cluster: cpos, p_cluster: phys, NULL, NULL);
1172	if (ret < 0) {
1173	mlog(ML_ERROR, "Get physical blkno failed for inode %llu, "
1174	"at logical cluster %u",
1175	(unsigned long long)OCFS2_I(inode)->ip_blkno, cpos);
1176	goto out;
1177	}
1178
1179	BUG_ON(*phys == 0);
1180
1181	p_blkno = ocfs2_clusters_to_blocks(sb: inode->i_sb, clusters: *phys);
1182	if (!should_zero)
1183	p_blkno += (user_pos >> inode->i_sb->s_blocksize_bits) & (u64)(bpc - 1);
1184
1185	for(i = 0; i < wc->w_num_pages; i++) {
1186	int tmpret;
1187
1188	/* This is the direct io target page. */
1189	if (wc->w_pages[i] == NULL) {
1190	p_blkno++;
1191	continue;
1192	}
1193
1194	tmpret = ocfs2_prepare_page_for_write(inode, p_blkno: &p_blkno, wc,
1195	page: wc->w_pages[i], cpos,
1196	user_pos, user_len,
1197	new: should_zero);
1198	if (tmpret) {
1199	mlog_errno(tmpret);
1200	if (ret == 0)
1201	ret = tmpret;
1202	}
1203	}
1204
1205	/*
1206	* We only have cleanup to do in case of allocating write.
1207	*/
1208	if (ret && new)
1209	ocfs2_write_failure(inode, wc, user_pos, user_len);
1210
1211	out:
1212
1213	return ret;
1214	}
1215
1216	static int ocfs2_write_cluster_by_desc(struct address_space *mapping,
1217	struct ocfs2_alloc_context *data_ac,
1218	struct ocfs2_alloc_context *meta_ac,
1219	struct ocfs2_write_ctxt *wc,
1220	loff_t pos, unsigned len)
1221	{
1222	int ret, i;
1223	loff_t cluster_off;
1224	unsigned int local_len = len;
1225	struct ocfs2_write_cluster_desc *desc;
1226	struct ocfs2_super *osb = OCFS2_SB(mapping->host->i_sb);
1227
1228	for (i = 0; i < wc->w_clen; i++) {
1229	desc = &wc->w_desc[i];
1230
1231	/*
1232	* We have to make sure that the total write passed in
1233	* doesn't extend past a single cluster.
1234	*/
1235	local_len = len;
1236	cluster_off = pos & (osb->s_clustersize - 1);
1237	if ((cluster_off + local_len) > osb->s_clustersize)
1238	local_len = osb->s_clustersize - cluster_off;
1239
1240	ret = ocfs2_write_cluster(mapping, phys: &desc->c_phys,
1241	new: desc->c_new,
1242	clear_unwritten: desc->c_clear_unwritten,
1243	should_zero: desc->c_needs_zero,
1244	data_ac, meta_ac,
1245	wc, cpos: desc->c_cpos, user_pos: pos, user_len: local_len);
1246	if (ret) {
1247	mlog_errno(ret);
1248	goto out;
1249	}
1250
1251	len -= local_len;
1252	pos += local_len;
1253	}
1254
1255	ret = 0;
1256	out:
1257	return ret;
1258	}
1259
1260	/*
1261	* ocfs2_write_end() wants to know which parts of the target page it
1262	* should complete the write on. It's easiest to compute them ahead of
1263	* time when a more complete view of the write is available.
1264	*/
1265	static void ocfs2_set_target_boundaries(struct ocfs2_super *osb,
1266	struct ocfs2_write_ctxt *wc,
1267	loff_t pos, unsigned len, int alloc)
1268	{
1269	struct ocfs2_write_cluster_desc *desc;
1270
1271	wc->w_target_from = pos & (PAGE_SIZE - 1);
1272	wc->w_target_to = wc->w_target_from + len;
1273
1274	if (alloc == 0)
1275	return;
1276
1277	/*
1278	* Allocating write - we may have different boundaries based
1279	* on page size and cluster size.
1280	*
1281	* NOTE: We can no longer compute one value from the other as
1282	* the actual write length and user provided length may be
1283	* different.
1284	*/
1285
1286	if (wc->w_large_pages) {
1287	/*
1288	* We only care about the 1st and last cluster within
1289	* our range and whether they should be zero'd or not. Either
1290	* value may be extended out to the start/end of a
1291	* newly allocated cluster.
1292	*/
1293	desc = &wc->w_desc[0];
1294	if (desc->c_needs_zero)
1295	ocfs2_figure_cluster_boundaries(osb,
1296	cpos: desc->c_cpos,
1297	start: &wc->w_target_from,
1298	NULL);
1299
1300	desc = &wc->w_desc[wc->w_clen - 1];
1301	if (desc->c_needs_zero)
1302	ocfs2_figure_cluster_boundaries(osb,
1303	cpos: desc->c_cpos,
1304	NULL,
1305	end: &wc->w_target_to);
1306	} else {
1307	wc->w_target_from = 0;
1308	wc->w_target_to = PAGE_SIZE;
1309	}
1310	}
1311
1312	/*
1313	* Check if this extent is marked UNWRITTEN by direct io. If so, we need not to
1314	* do the zero work. And should not to clear UNWRITTEN since it will be cleared
1315	* by the direct io procedure.
1316	* If this is a new extent that allocated by direct io, we should mark it in
1317	* the ip_unwritten_list.
1318	*/
1319	static int ocfs2_unwritten_check(struct inode *inode,
1320	struct ocfs2_write_ctxt *wc,
1321	struct ocfs2_write_cluster_desc *desc)
1322	{
1323	struct ocfs2_inode_info *oi = OCFS2_I(inode);
1324	struct ocfs2_unwritten_extent *ue = NULL, *new = NULL;
1325	int ret = 0;
1326
1327	if (!desc->c_needs_zero)
1328	return 0;
1329
1330	retry:
1331	spin_lock(lock: &oi->ip_lock);
1332	/* Needs not to zero no metter buffer or direct. The one who is zero
1333	* the cluster is doing zero. And he will clear unwritten after all
1334	* cluster io finished. */
1335	list_for_each_entry(ue, &oi->ip_unwritten_list, ue_ip_node) {
1336	if (desc->c_cpos == ue->ue_cpos) {
1337	BUG_ON(desc->c_new);
1338	desc->c_needs_zero = 0;
1339	desc->c_clear_unwritten = 0;
1340	goto unlock;
1341	}
1342	}
1343
1344	if (wc->w_type != OCFS2_WRITE_DIRECT)
1345	goto unlock;
1346
1347	if (new == NULL) {
1348	spin_unlock(lock: &oi->ip_lock);
1349	new = kmalloc(size: sizeof(struct ocfs2_unwritten_extent),
1350	GFP_NOFS);
1351	if (new == NULL) {
1352	ret = -ENOMEM;
1353	goto out;
1354	}
1355	goto retry;
1356	}
1357	/* This direct write will doing zero. */
1358	new->ue_cpos = desc->c_cpos;
1359	new->ue_phys = desc->c_phys;
1360	desc->c_clear_unwritten = 0;
1361	list_add_tail(new: &new->ue_ip_node, head: &oi->ip_unwritten_list);
1362	list_add_tail(new: &new->ue_node, head: &wc->w_unwritten_list);
1363	wc->w_unwritten_count++;
1364	new = NULL;
1365	unlock:
1366	spin_unlock(lock: &oi->ip_lock);
1367	out:
1368	kfree(objp: new);
1369	return ret;
1370	}
1371
1372	/*
1373	* Populate each single-cluster write descriptor in the write context
1374	* with information about the i/o to be done.
1375	*
1376	* Returns the number of clusters that will have to be allocated, as
1377	* well as a worst case estimate of the number of extent records that
1378	* would have to be created during a write to an unwritten region.
1379	*/
1380	static int ocfs2_populate_write_desc(struct inode *inode,
1381	struct ocfs2_write_ctxt *wc,
1382	unsigned int *clusters_to_alloc,
1383	unsigned int *extents_to_split)
1384	{
1385	int ret;
1386	struct ocfs2_write_cluster_desc *desc;
1387	unsigned int num_clusters = 0;
1388	unsigned int ext_flags = 0;
1389	u32 phys = 0;
1390	int i;
1391
1392	*clusters_to_alloc = 0;
1393	*extents_to_split = 0;
1394
1395	for (i = 0; i < wc->w_clen; i++) {
1396	desc = &wc->w_desc[i];
1397	desc->c_cpos = wc->w_cpos + i;
1398
1399	if (num_clusters == 0) {
1400	/*
1401	* Need to look up the next extent record.
1402	*/
1403	ret = ocfs2_get_clusters(inode, v_cluster: desc->c_cpos, p_cluster: &phys,
1404	num_clusters: &num_clusters, extent_flags: &ext_flags);
1405	if (ret) {
1406	mlog_errno(ret);
1407	goto out;
1408	}
1409
1410	/* We should already CoW the refcountd extent. */
1411	BUG_ON(ext_flags & OCFS2_EXT_REFCOUNTED);
1412
1413	/*
1414	* Assume worst case - that we're writing in
1415	* the middle of the extent.
1416	*
1417	* We can assume that the write proceeds from
1418	* left to right, in which case the extent
1419	* insert code is smart enough to coalesce the
1420	* next splits into the previous records created.
1421	*/
1422	if (ext_flags & OCFS2_EXT_UNWRITTEN)
1423	*extents_to_split = *extents_to_split + 2;
1424	} else if (phys) {
1425	/*
1426	* Only increment phys if it doesn't describe
1427	* a hole.
1428	*/
1429	phys++;
1430	}
1431
1432	/*
1433	* If w_first_new_cpos is < UINT_MAX, we have a non-sparse
1434	* file that got extended. w_first_new_cpos tells us
1435	* where the newly allocated clusters are so we can
1436	* zero them.
1437	*/
1438	if (desc->c_cpos >= wc->w_first_new_cpos) {
1439	BUG_ON(phys == 0);
1440	desc->c_needs_zero = 1;
1441	}
1442
1443	desc->c_phys = phys;
1444	if (phys == 0) {
1445	desc->c_new = 1;
1446	desc->c_needs_zero = 1;
1447	desc->c_clear_unwritten = 1;
1448	*clusters_to_alloc = *clusters_to_alloc + 1;
1449	}
1450
1451	if (ext_flags & OCFS2_EXT_UNWRITTEN) {
1452	desc->c_clear_unwritten = 1;
1453	desc->c_needs_zero = 1;
1454	}
1455
1456	ret = ocfs2_unwritten_check(inode, wc, desc);
1457	if (ret) {
1458	mlog_errno(ret);
1459	goto out;
1460	}
1461
1462	num_clusters--;
1463	}
1464
1465	ret = 0;
1466	out:
1467	return ret;
1468	}
1469
1470	static int ocfs2_write_begin_inline(struct address_space *mapping,
1471	struct inode *inode,
1472	struct ocfs2_write_ctxt *wc)
1473	{
1474	int ret;
1475	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1476	struct page *page;
1477	handle_t *handle;
1478	struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1479
1480	handle = ocfs2_start_trans(osb, OCFS2_INODE_UPDATE_CREDITS);
1481	if (IS_ERR(ptr: handle)) {
1482	ret = PTR_ERR(ptr: handle);
1483	mlog_errno(ret);
1484	goto out;
1485	}
1486
1487	page = find_or_create_page(mapping, index: 0, GFP_NOFS);
1488	if (!page) {
1489	ocfs2_commit_trans(osb, handle);
1490	ret = -ENOMEM;
1491	mlog_errno(ret);
1492	goto out;
1493	}
1494	/*
1495	* If we don't set w_num_pages then this page won't get unlocked
1496	* and freed on cleanup of the write context.
1497	*/
1498	wc->w_pages[0] = wc->w_target_page = page;
1499	wc->w_num_pages = 1;
1500
1501	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode), bh: wc->w_di_bh,
1502	OCFS2_JOURNAL_ACCESS_WRITE);
1503	if (ret) {
1504	ocfs2_commit_trans(osb, handle);
1505
1506	mlog_errno(ret);
1507	goto out;
1508	}
1509
1510	if (!(OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL))
1511	ocfs2_set_inode_data_inline(inode, di);
1512
1513	if (!PageUptodate(page)) {
1514	ret = ocfs2_read_inline_data(inode, page, di_bh: wc->w_di_bh);
1515	if (ret) {
1516	ocfs2_commit_trans(osb, handle);
1517
1518	goto out;
1519	}
1520	}
1521
1522	wc->w_handle = handle;
1523	out:
1524	return ret;
1525	}
1526
1527	int ocfs2_size_fits_inline_data(struct buffer_head *di_bh, u64 new_size)
1528	{
1529	struct ocfs2_dinode *di = (struct ocfs2_dinode *)di_bh->b_data;
1530
1531	if (new_size <= le16_to_cpu(di->id2.i_data.id_count))
1532	return 1;
1533	return 0;
1534	}
1535
1536	static int ocfs2_try_to_write_inline_data(struct address_space *mapping,
1537	struct inode *inode, loff_t pos,
1538	unsigned len, struct page *mmap_page,
1539	struct ocfs2_write_ctxt *wc)
1540	{
1541	int ret, written = 0;
1542	loff_t end = pos + len;
1543	struct ocfs2_inode_info *oi = OCFS2_I(inode);
1544	struct ocfs2_dinode *di = NULL;
1545
1546	trace_ocfs2_try_to_write_inline_data(ino: (unsigned long long)oi->ip_blkno,
1547	len, pos: (unsigned long long)pos,
1548	flags: oi->ip_dyn_features);
1549
1550	/*
1551	* Handle inodes which already have inline data 1st.
1552	*/
1553	if (oi->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1554	if (mmap_page == NULL &&
1555	ocfs2_size_fits_inline_data(di_bh: wc->w_di_bh, new_size: end))
1556	goto do_inline_write;
1557
1558	/*
1559	* The write won't fit - we have to give this inode an
1560	* inline extent list now.
1561	*/
1562	ret = ocfs2_convert_inline_data_to_extents(inode, di_bh: wc->w_di_bh);
1563	if (ret)
1564	mlog_errno(ret);
1565	goto out;
1566	}
1567
1568	/*
1569	* Check whether the inode can accept inline data.
1570	*/
1571	if (oi->ip_clusters != 0 || i_size_read(inode) != 0)
1572	return 0;
1573
1574	/*
1575	* Check whether the write can fit.
1576	*/
1577	di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1578	if (mmap_page ||
1579	end > ocfs2_max_inline_data_with_xattr(sb: inode->i_sb, di))
1580	return 0;
1581
1582	do_inline_write:
1583	ret = ocfs2_write_begin_inline(mapping, inode, wc);
1584	if (ret) {
1585	mlog_errno(ret);
1586	goto out;
1587	}
1588
1589	/*
1590	* This signals to the caller that the data can be written
1591	* inline.
1592	*/
1593	written = 1;
1594	out:
1595	return written ? written : ret;
1596	}
1597
1598	/*
1599	* This function only does anything for file systems which can't
1600	* handle sparse files.
1601	*
1602	* What we want to do here is fill in any hole between the current end
1603	* of allocation and the end of our write. That way the rest of the
1604	* write path can treat it as an non-allocating write, which has no
1605	* special case code for sparse/nonsparse files.
1606	*/
1607	static int ocfs2_expand_nonsparse_inode(struct inode *inode,
1608	struct buffer_head *di_bh,
1609	loff_t pos, unsigned len,
1610	struct ocfs2_write_ctxt *wc)
1611	{
1612	int ret;
1613	loff_t newsize = pos + len;
1614
1615	BUG_ON(ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)));
1616
1617	if (newsize <= i_size_read(inode))
1618	return 0;
1619
1620	ret = ocfs2_extend_no_holes(inode, di_bh, new_i_size: newsize, zero_to: pos);
1621	if (ret)
1622	mlog_errno(ret);
1623
1624	/* There is no wc if this is call from direct. */
1625	if (wc)
1626	wc->w_first_new_cpos =
1627	ocfs2_clusters_for_bytes(sb: inode->i_sb, bytes: i_size_read(inode));
1628
1629	return ret;
1630	}
1631
1632	static int ocfs2_zero_tail(struct inode *inode, struct buffer_head *di_bh,
1633	loff_t pos)
1634	{
1635	int ret = 0;
1636
1637	BUG_ON(!ocfs2_sparse_alloc(OCFS2_SB(inode->i_sb)));
1638	if (pos > i_size_read(inode))
1639	ret = ocfs2_zero_extend(inode, di_bh, zero_to: pos);
1640
1641	return ret;
1642	}
1643
1644	int ocfs2_write_begin_nolock(struct address_space *mapping,
1645	loff_t pos, unsigned len, ocfs2_write_type_t type,
1646	struct page **pagep, void **fsdata,
1647	struct buffer_head *di_bh, struct page *mmap_page)
1648	{
1649	int ret, cluster_of_pages, credits = OCFS2_INODE_UPDATE_CREDITS;
1650	unsigned int clusters_to_alloc, extents_to_split, clusters_need = 0;
1651	struct ocfs2_write_ctxt *wc;
1652	struct inode *inode = mapping->host;
1653	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1654	struct ocfs2_dinode *di;
1655	struct ocfs2_alloc_context *data_ac = NULL;
1656	struct ocfs2_alloc_context *meta_ac = NULL;
1657	handle_t *handle;
1658	struct ocfs2_extent_tree et;
1659	int try_free = 1, ret1;
1660
1661	try_again:
1662	ret = ocfs2_alloc_write_ctxt(wcp: &wc, osb, pos, len, type, di_bh);
1663	if (ret) {
1664	mlog_errno(ret);
1665	return ret;
1666	}
1667
1668	if (ocfs2_supports_inline_data(osb)) {
1669	ret = ocfs2_try_to_write_inline_data(mapping, inode, pos, len,
1670	mmap_page, wc);
1671	if (ret == 1) {
1672	ret = 0;
1673	goto success;
1674	}
1675	if (ret < 0) {
1676	mlog_errno(ret);
1677	goto out;
1678	}
1679	}
1680
1681	/* Direct io change i_size late, should not zero tail here. */
1682	if (type != OCFS2_WRITE_DIRECT) {
1683	if (ocfs2_sparse_alloc(osb))
1684	ret = ocfs2_zero_tail(inode, di_bh, pos);
1685	else
1686	ret = ocfs2_expand_nonsparse_inode(inode, di_bh, pos,
1687	len, wc);
1688	if (ret) {
1689	mlog_errno(ret);
1690	goto out;
1691	}
1692	}
1693
1694	ret = ocfs2_check_range_for_refcount(inode, pos, count: len);
1695	if (ret < 0) {
1696	mlog_errno(ret);
1697	goto out;
1698	} else if (ret == 1) {
1699	clusters_need = wc->w_clen;
1700	ret = ocfs2_refcount_cow(inode, di_bh,
1701	cpos: wc->w_cpos, write_len: wc->w_clen, UINT_MAX);
1702	if (ret) {
1703	mlog_errno(ret);
1704	goto out;
1705	}
1706	}
1707
1708	ret = ocfs2_populate_write_desc(inode, wc, clusters_to_alloc: &clusters_to_alloc,
1709	extents_to_split: &extents_to_split);
1710	if (ret) {
1711	mlog_errno(ret);
1712	goto out;
1713	}
1714	clusters_need += clusters_to_alloc;
1715
1716	di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1717
1718	trace_ocfs2_write_begin_nolock(
1719	ino: (unsigned long long)OCFS2_I(inode)->ip_blkno,
1720	i_size: (long long)i_size_read(inode),
1721	le32_to_cpu(di->i_clusters),
1722	pos, len, flags: type, page: mmap_page,
1723	clusters: clusters_to_alloc, extents_to_split);
1724
1725	/*
1726	* We set w_target_from, w_target_to here so that
1727	* ocfs2_write_end() knows which range in the target page to
1728	* write out. An allocation requires that we write the entire
1729	* cluster range.
1730	*/
1731	if (clusters_to_alloc || extents_to_split) {
1732	/*
1733	* XXX: We are stretching the limits of
1734	* ocfs2_lock_allocators(). It greatly over-estimates
1735	* the work to be done.
1736	*/
1737	ocfs2_init_dinode_extent_tree(et: &et, ci: INODE_CACHE(inode),
1738	bh: wc->w_di_bh);
1739	ret = ocfs2_lock_allocators(inode, et: &et,
1740	clusters_to_add: clusters_to_alloc, extents_to_split,
1741	data_ac: &data_ac, meta_ac: &meta_ac);
1742	if (ret) {
1743	mlog_errno(ret);
1744	goto out;
1745	}
1746
1747	if (data_ac)
1748	data_ac->ac_resv = &OCFS2_I(inode)->ip_la_data_resv;
1749
1750	credits = ocfs2_calc_extend_credits(sb: inode->i_sb,
1751	root_el: &di->id2.i_list);
1752	} else if (type == OCFS2_WRITE_DIRECT)
1753	/* direct write needs not to start trans if no extents alloc. */
1754	goto success;
1755
1756	/*
1757	* We have to zero sparse allocated clusters, unwritten extent clusters,
1758	* and non-sparse clusters we just extended. For non-sparse writes,
1759	* we know zeros will only be needed in the first and/or last cluster.
1760	*/
1761	if (wc->w_clen && (wc->w_desc[0].c_needs_zero ||
1762	wc->w_desc[wc->w_clen - 1].c_needs_zero))
1763	cluster_of_pages = 1;
1764	else
1765	cluster_of_pages = 0;
1766
1767	ocfs2_set_target_boundaries(osb, wc, pos, len, alloc: cluster_of_pages);
1768
1769	handle = ocfs2_start_trans(osb, max_buffs: credits);
1770	if (IS_ERR(ptr: handle)) {
1771	ret = PTR_ERR(ptr: handle);
1772	mlog_errno(ret);
1773	goto out;
1774	}
1775
1776	wc->w_handle = handle;
1777
1778	if (clusters_to_alloc) {
1779	ret = dquot_alloc_space_nodirty(inode,
1780	nr: ocfs2_clusters_to_bytes(sb: osb->sb, clusters: clusters_to_alloc));
1781	if (ret)
1782	goto out_commit;
1783	}
1784
1785	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode), bh: wc->w_di_bh,
1786	OCFS2_JOURNAL_ACCESS_WRITE);
1787	if (ret) {
1788	mlog_errno(ret);
1789	goto out_quota;
1790	}
1791
1792	/*
1793	* Fill our page array first. That way we've grabbed enough so
1794	* that we can zero and flush if we error after adding the
1795	* extent.
1796	*/
1797	ret = ocfs2_grab_pages_for_write(mapping, wc, cpos: wc->w_cpos, user_pos: pos, user_len: len,
1798	new: cluster_of_pages, mmap_page);
1799	if (ret) {
1800	/*
1801	* ocfs2_grab_pages_for_write() returns -EAGAIN if it could not lock
1802	* the target page. In this case, we exit with no error and no target
1803	* page. This will trigger the caller, page_mkwrite(), to re-try
1804	* the operation.
1805	*/
1806	if (type == OCFS2_WRITE_MMAP && ret == -EAGAIN) {
1807	BUG_ON(wc->w_target_page);
1808	ret = 0;
1809	goto out_quota;
1810	}
1811
1812	mlog_errno(ret);
1813	goto out_quota;
1814	}
1815
1816	ret = ocfs2_write_cluster_by_desc(mapping, data_ac, meta_ac, wc, pos,
1817	len);
1818	if (ret) {
1819	mlog_errno(ret);
1820	goto out_quota;
1821	}
1822
1823	if (data_ac)
1824	ocfs2_free_alloc_context(ac: data_ac);
1825	if (meta_ac)
1826	ocfs2_free_alloc_context(ac: meta_ac);
1827
1828	success:
1829	if (pagep)
1830	*pagep = wc->w_target_page;
1831	*fsdata = wc;
1832	return 0;
1833	out_quota:
1834	if (clusters_to_alloc)
1835	dquot_free_space(inode,
1836	nr: ocfs2_clusters_to_bytes(sb: osb->sb, clusters: clusters_to_alloc));
1837	out_commit:
1838	ocfs2_commit_trans(osb, handle);
1839
1840	out:
1841	/*
1842	* The mmapped page won't be unlocked in ocfs2_free_write_ctxt(),
1843	* even in case of error here like ENOSPC and ENOMEM. So, we need
1844	* to unlock the target page manually to prevent deadlocks when
1845	* retrying again on ENOSPC, or when returning non-VM_FAULT_LOCKED
1846	* to VM code.
1847	*/
1848	if (wc->w_target_locked)
1849	unlock_page(page: mmap_page);
1850
1851	ocfs2_free_write_ctxt(inode, wc);
1852
1853	if (data_ac) {
1854	ocfs2_free_alloc_context(ac: data_ac);
1855	data_ac = NULL;
1856	}
1857	if (meta_ac) {
1858	ocfs2_free_alloc_context(ac: meta_ac);
1859	meta_ac = NULL;
1860	}
1861
1862	if (ret == -ENOSPC && try_free) {
1863	/*
1864	* Try to free some truncate log so that we can have enough
1865	* clusters to allocate.
1866	*/
1867	try_free = 0;
1868
1869	ret1 = ocfs2_try_to_free_truncate_log(osb, needed: clusters_need);
1870	if (ret1 == 1)
1871	goto try_again;
1872
1873	if (ret1 < 0)
1874	mlog_errno(ret1);
1875	}
1876
1877	return ret;
1878	}
1879
1880	static int ocfs2_write_begin(struct file *file, struct address_space *mapping,
1881	loff_t pos, unsigned len,
1882	struct page **pagep, void **fsdata)
1883	{
1884	int ret;
1885	struct buffer_head *di_bh = NULL;
1886	struct inode *inode = mapping->host;
1887
1888	ret = ocfs2_inode_lock(inode, &di_bh, 1);
1889	if (ret) {
1890	mlog_errno(ret);
1891	return ret;
1892	}
1893
1894	/*
1895	* Take alloc sem here to prevent concurrent lookups. That way
1896	* the mapping, zeroing and tree manipulation within
1897	* ocfs2_write() will be safe against ->read_folio(). This
1898	* should also serve to lock out allocation from a shared
1899	* writeable region.
1900	*/
1901	down_write(sem: &OCFS2_I(inode)->ip_alloc_sem);
1902
1903	ret = ocfs2_write_begin_nolock(mapping, pos, len, type: OCFS2_WRITE_BUFFER,
1904	pagep, fsdata, di_bh, NULL);
1905	if (ret) {
1906	mlog_errno(ret);
1907	goto out_fail;
1908	}
1909
1910	brelse(bh: di_bh);
1911
1912	return 0;
1913
1914	out_fail:
1915	up_write(sem: &OCFS2_I(inode)->ip_alloc_sem);
1916
1917	brelse(bh: di_bh);
1918	ocfs2_inode_unlock(inode, ex: 1);
1919
1920	return ret;
1921	}
1922
1923	static void ocfs2_write_end_inline(struct inode *inode, loff_t pos,
1924	unsigned len, unsigned *copied,
1925	struct ocfs2_dinode *di,
1926	struct ocfs2_write_ctxt *wc)
1927	{
1928	void *kaddr;
1929
1930	if (unlikely(*copied < len)) {
1931	if (!PageUptodate(page: wc->w_target_page)) {
1932	*copied = 0;
1933	return;
1934	}
1935	}
1936
1937	kaddr = kmap_atomic(page: wc->w_target_page);
1938	memcpy(di->id2.i_data.id_data + pos, kaddr + pos, *copied);
1939	kunmap_atomic(kaddr);
1940
1941	trace_ocfs2_write_end_inline(
1942	ino: (unsigned long long)OCFS2_I(inode)->ip_blkno,
1943	pos: (unsigned long long)pos, copied: *copied,
1944	le16_to_cpu(di->id2.i_data.id_count),
1945	le16_to_cpu(di->i_dyn_features));
1946	}
1947
1948	int ocfs2_write_end_nolock(struct address_space *mapping,
1949	loff_t pos, unsigned len, unsigned copied, void *fsdata)
1950	{
1951	int i, ret;
1952	unsigned from, to, start = pos & (PAGE_SIZE - 1);
1953	struct inode *inode = mapping->host;
1954	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
1955	struct ocfs2_write_ctxt *wc = fsdata;
1956	struct ocfs2_dinode *di = (struct ocfs2_dinode *)wc->w_di_bh->b_data;
1957	handle_t *handle = wc->w_handle;
1958	struct page *tmppage;
1959
1960	BUG_ON(!list_empty(&wc->w_unwritten_list));
1961
1962	if (handle) {
1963	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode),
1964	bh: wc->w_di_bh, OCFS2_JOURNAL_ACCESS_WRITE);
1965	if (ret) {
1966	copied = ret;
1967	mlog_errno(ret);
1968	goto out;
1969	}
1970	}
1971
1972	if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL) {
1973	ocfs2_write_end_inline(inode, pos, len, copied: &copied, di, wc);
1974	goto out_write_size;
1975	}
1976
1977	if (unlikely(copied < len) && wc->w_target_page) {
1978	loff_t new_isize;
1979
1980	if (!PageUptodate(page: wc->w_target_page))
1981	copied = 0;
1982
1983	new_isize = max_t(loff_t, i_size_read(inode), pos + copied);
1984	if (new_isize > page_offset(page: wc->w_target_page))
1985	ocfs2_zero_new_buffers(page: wc->w_target_page, from: start+copied,
1986	to: start+len);
1987	else {
1988	/*
1989	* When page is fully beyond new isize (data copy
1990	* failed), do not bother zeroing the page. Invalidate
1991	* it instead so that writeback does not get confused
1992	* put page & buffer dirty bits into inconsistent
1993	* state.
1994	*/
1995	block_invalidate_folio(page_folio(wc->w_target_page),
1996	offset: 0, PAGE_SIZE);
1997	}
1998	}
1999	if (wc->w_target_page)
2000	flush_dcache_page(page: wc->w_target_page);
2001
2002	for(i = 0; i < wc->w_num_pages; i++) {
2003	tmppage = wc->w_pages[i];
2004
2005	/* This is the direct io target page. */
2006	if (tmppage == NULL)
2007	continue;
2008
2009	if (tmppage == wc->w_target_page) {
2010	from = wc->w_target_from;
2011	to = wc->w_target_to;
2012
2013	BUG_ON(from > PAGE_SIZE ||
2014	to > PAGE_SIZE ||
2015	to < from);
2016	} else {
2017	/*
2018	* Pages adjacent to the target (if any) imply
2019	* a hole-filling write in which case we want
2020	* to flush their entire range.
2021	*/
2022	from = 0;
2023	to = PAGE_SIZE;
2024	}
2025
2026	if (page_has_buffers(tmppage)) {
2027	if (handle && ocfs2_should_order_data(inode)) {
2028	loff_t start_byte =
2029	((loff_t)tmppage->index << PAGE_SHIFT) +
2030	from;
2031	loff_t length = to - from;
2032	ocfs2_jbd2_inode_add_write(handle, inode,
2033	start_byte, length);
2034	}
2035	block_commit_write(page: tmppage, from, to);
2036	}
2037	}
2038
2039	out_write_size:
2040	/* Direct io do not update i_size here. */
2041	if (wc->w_type != OCFS2_WRITE_DIRECT) {
2042	pos += copied;
2043	if (pos > i_size_read(inode)) {
2044	i_size_write(inode, i_size: pos);
2045	mark_inode_dirty(inode);
2046	}
2047	inode->i_blocks = ocfs2_inode_sector_count(inode);
2048	di->i_size = cpu_to_le64((u64)i_size_read(inode));
2049	inode_set_mtime_to_ts(inode, ts: inode_set_ctime_current(inode));
2050	di->i_mtime = di->i_ctime = cpu_to_le64(inode_get_mtime_sec(inode));
2051	di->i_mtime_nsec = di->i_ctime_nsec = cpu_to_le32(inode_get_mtime_nsec(inode));
2052	if (handle)
2053	ocfs2_update_inode_fsync_trans(handle, inode, datasync: 1);
2054	}
2055	if (handle)
2056	ocfs2_journal_dirty(handle, bh: wc->w_di_bh);
2057
2058	out:
2059	/* unlock pages before dealloc since it needs acquiring j_trans_barrier
2060	* lock, or it will cause a deadlock since journal commit threads holds
2061	* this lock and will ask for the page lock when flushing the data.
2062	* put it here to preserve the unlock order.
2063	*/
2064	ocfs2_unlock_pages(wc);
2065
2066	if (handle)
2067	ocfs2_commit_trans(osb, handle);
2068
2069	ocfs2_run_deallocs(osb, ctxt: &wc->w_dealloc);
2070
2071	brelse(bh: wc->w_di_bh);
2072	kfree(objp: wc);
2073
2074	return copied;
2075	}
2076
2077	static int ocfs2_write_end(struct file *file, struct address_space *mapping,
2078	loff_t pos, unsigned len, unsigned copied,
2079	struct page *page, void *fsdata)
2080	{
2081	int ret;
2082	struct inode *inode = mapping->host;
2083
2084	ret = ocfs2_write_end_nolock(mapping, pos, len, copied, fsdata);
2085
2086	up_write(sem: &OCFS2_I(inode)->ip_alloc_sem);
2087	ocfs2_inode_unlock(inode, ex: 1);
2088
2089	return ret;
2090	}
2091
2092	struct ocfs2_dio_write_ctxt {
2093	struct list_head dw_zero_list;
2094	unsigned dw_zero_count;
2095	int dw_orphaned;
2096	pid_t dw_writer_pid;
2097	};
2098
2099	static struct ocfs2_dio_write_ctxt *
2100	ocfs2_dio_alloc_write_ctx(struct buffer_head *bh, int *alloc)
2101	{
2102	struct ocfs2_dio_write_ctxt *dwc = NULL;
2103
2104	if (bh->b_private)
2105	return bh->b_private;
2106
2107	dwc = kmalloc(size: sizeof(struct ocfs2_dio_write_ctxt), GFP_NOFS);
2108	if (dwc == NULL)
2109	return NULL;
2110	INIT_LIST_HEAD(list: &dwc->dw_zero_list);
2111	dwc->dw_zero_count = 0;
2112	dwc->dw_orphaned = 0;
2113	dwc->dw_writer_pid = task_pid_nr(current);
2114	bh->b_private = dwc;
2115	*alloc = 1;
2116
2117	return dwc;
2118	}
2119
2120	static void ocfs2_dio_free_write_ctx(struct inode *inode,
2121	struct ocfs2_dio_write_ctxt *dwc)
2122	{
2123	ocfs2_free_unwritten_list(inode, head: &dwc->dw_zero_list);
2124	kfree(objp: dwc);
2125	}
2126
2127	/*
2128	* TODO: Make this into a generic get_blocks function.
2129	*
2130	* From do_direct_io in direct-io.c:
2131	* "So what we do is to permit the ->get_blocks function to populate
2132	* bh.b_size with the size of IO which is permitted at this offset and
2133	* this i_blkbits."
2134	*
2135	* This function is called directly from get_more_blocks in direct-io.c.
2136	*
2137	* called like this: dio->get_blocks(dio->inode, fs_startblk,
2138	* fs_count, map_bh, dio->rw == WRITE);
2139	*/
2140	static int ocfs2_dio_wr_get_block(struct inode *inode, sector_t iblock,
2141	struct buffer_head *bh_result, int create)
2142	{
2143	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2144	struct ocfs2_inode_info *oi = OCFS2_I(inode);
2145	struct ocfs2_write_ctxt *wc;
2146	struct ocfs2_write_cluster_desc *desc = NULL;
2147	struct ocfs2_dio_write_ctxt *dwc = NULL;
2148	struct buffer_head *di_bh = NULL;
2149	u64 p_blkno;
2150	unsigned int i_blkbits = inode->i_sb->s_blocksize_bits;
2151	loff_t pos = iblock << i_blkbits;
2152	sector_t endblk = (i_size_read(inode) - 1) >> i_blkbits;
2153	unsigned len, total_len = bh_result->b_size;
2154	int ret = 0, first_get_block = 0;
2155
2156	len = osb->s_clustersize - (pos & (osb->s_clustersize - 1));
2157	len = min(total_len, len);
2158
2159	/*
2160	* bh_result->b_size is count in get_more_blocks according to write
2161	* "pos" and "end", we need map twice to return different buffer state:
2162	* 1. area in file size, not set NEW;
2163	* 2. area out file size, set NEW.
2164	*
2165	* iblock endblk
2166	* |--------|---------|---------|---------
2167	* |<-------area in file------->|
2168	*/
2169
2170	if ((iblock <= endblk) &&
2171	((iblock + ((len - 1) >> i_blkbits)) > endblk))
2172	len = (endblk - iblock + 1) << i_blkbits;
2173
2174	mlog(0, "get block of %lu at %llu:%u req %u\n",
2175	inode->i_ino, pos, len, total_len);
2176
2177	/*
2178	* Because we need to change file size in ocfs2_dio_end_io_write(), or
2179	* we may need to add it to orphan dir. So can not fall to fast path
2180	* while file size will be changed.
2181	*/
2182	if (pos + total_len <= i_size_read(inode)) {
2183
2184	/* This is the fast path for re-write. */
2185	ret = ocfs2_lock_get_block(inode, iblock, bh_result, create);
2186	if (buffer_mapped(bh: bh_result) &&
2187	!buffer_new(bh: bh_result) &&
2188	ret == 0)
2189	goto out;
2190
2191	/* Clear state set by ocfs2_get_block. */
2192	bh_result->b_state = 0;
2193	}
2194
2195	dwc = ocfs2_dio_alloc_write_ctx(bh: bh_result, alloc: &first_get_block);
2196	if (unlikely(dwc == NULL)) {
2197	ret = -ENOMEM;
2198	mlog_errno(ret);
2199	goto out;
2200	}
2201
2202	if (ocfs2_clusters_for_bytes(sb: inode->i_sb, bytes: pos + total_len) >
2203	ocfs2_clusters_for_bytes(sb: inode->i_sb, bytes: i_size_read(inode)) &&
2204	!dwc->dw_orphaned) {
2205	/*
2206	* when we are going to alloc extents beyond file size, add the
2207	* inode to orphan dir, so we can recall those spaces when
2208	* system crashed during write.
2209	*/
2210	ret = ocfs2_add_inode_to_orphan(osb, inode);
2211	if (ret < 0) {
2212	mlog_errno(ret);
2213	goto out;
2214	}
2215	dwc->dw_orphaned = 1;
2216	}
2217
2218	ret = ocfs2_inode_lock(inode, &di_bh, 1);
2219	if (ret) {
2220	mlog_errno(ret);
2221	goto out;
2222	}
2223
2224	down_write(sem: &oi->ip_alloc_sem);
2225
2226	if (first_get_block) {
2227	if (ocfs2_sparse_alloc(osb))
2228	ret = ocfs2_zero_tail(inode, di_bh, pos);
2229	else
2230	ret = ocfs2_expand_nonsparse_inode(inode, di_bh, pos,
2231	len: total_len, NULL);
2232	if (ret < 0) {
2233	mlog_errno(ret);
2234	goto unlock;
2235	}
2236	}
2237
2238	ret = ocfs2_write_begin_nolock(mapping: inode->i_mapping, pos, len,
2239	type: OCFS2_WRITE_DIRECT, NULL,
2240	fsdata: (void **)&wc, di_bh, NULL);
2241	if (ret) {
2242	mlog_errno(ret);
2243	goto unlock;
2244	}
2245
2246	desc = &wc->w_desc[0];
2247
2248	p_blkno = ocfs2_clusters_to_blocks(sb: inode->i_sb, clusters: desc->c_phys);
2249	BUG_ON(p_blkno == 0);
2250	p_blkno += iblock & (u64)(ocfs2_clusters_to_blocks(sb: inode->i_sb, clusters: 1) - 1);
2251
2252	map_bh(bh: bh_result, sb: inode->i_sb, block: p_blkno);
2253	bh_result->b_size = len;
2254	if (desc->c_needs_zero)
2255	set_buffer_new(bh_result);
2256
2257	if (iblock > endblk)
2258	set_buffer_new(bh_result);
2259
2260	/* May sleep in end_io. It should not happen in a irq context. So defer
2261	* it to dio work queue. */
2262	set_buffer_defer_completion(bh_result);
2263
2264	if (!list_empty(head: &wc->w_unwritten_list)) {
2265	struct ocfs2_unwritten_extent *ue = NULL;
2266
2267	ue = list_first_entry(&wc->w_unwritten_list,
2268	struct ocfs2_unwritten_extent,
2269	ue_node);
2270	BUG_ON(ue->ue_cpos != desc->c_cpos);
2271	/* The physical address may be 0, fill it. */
2272	ue->ue_phys = desc->c_phys;
2273
2274	list_splice_tail_init(list: &wc->w_unwritten_list, head: &dwc->dw_zero_list);
2275	dwc->dw_zero_count += wc->w_unwritten_count;
2276	}
2277
2278	ret = ocfs2_write_end_nolock(mapping: inode->i_mapping, pos, len, copied: len, fsdata: wc);
2279	BUG_ON(ret != len);
2280	ret = 0;
2281	unlock:
2282	up_write(sem: &oi->ip_alloc_sem);
2283	ocfs2_inode_unlock(inode, ex: 1);
2284	brelse(bh: di_bh);
2285	out:
2286	if (ret < 0)
2287	ret = -EIO;
2288	return ret;
2289	}
2290
2291	static int ocfs2_dio_end_io_write(struct inode *inode,
2292	struct ocfs2_dio_write_ctxt *dwc,
2293	loff_t offset,
2294	ssize_t bytes)
2295	{
2296	struct ocfs2_cached_dealloc_ctxt dealloc;
2297	struct ocfs2_extent_tree et;
2298	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2299	struct ocfs2_inode_info *oi = OCFS2_I(inode);
2300	struct ocfs2_unwritten_extent *ue = NULL;
2301	struct buffer_head *di_bh = NULL;
2302	struct ocfs2_dinode *di;
2303	struct ocfs2_alloc_context *data_ac = NULL;
2304	struct ocfs2_alloc_context *meta_ac = NULL;
2305	handle_t *handle = NULL;
2306	loff_t end = offset + bytes;
2307	int ret = 0, credits = 0;
2308
2309	ocfs2_init_dealloc_ctxt(c: &dealloc);
2310
2311	/* We do clear unwritten, delete orphan, change i_size here. If neither
2312	* of these happen, we can skip all this. */
2313	if (list_empty(head: &dwc->dw_zero_list) &&
2314	end <= i_size_read(inode) &&
2315	!dwc->dw_orphaned)
2316	goto out;
2317
2318	ret = ocfs2_inode_lock(inode, &di_bh, 1);
2319	if (ret < 0) {
2320	mlog_errno(ret);
2321	goto out;
2322	}
2323
2324	down_write(sem: &oi->ip_alloc_sem);
2325
2326	/* Delete orphan before acquire i_rwsem. */
2327	if (dwc->dw_orphaned) {
2328	BUG_ON(dwc->dw_writer_pid != task_pid_nr(current));
2329
2330	end = end > i_size_read(inode) ? end : 0;
2331
2332	ret = ocfs2_del_inode_from_orphan(osb, inode, di_bh,
2333	update_isize: !!end, end);
2334	if (ret < 0)
2335	mlog_errno(ret);
2336	}
2337
2338	di = (struct ocfs2_dinode *)di_bh->b_data;
2339
2340	ocfs2_init_dinode_extent_tree(et: &et, ci: INODE_CACHE(inode), bh: di_bh);
2341
2342	/* Attach dealloc with extent tree in case that we may reuse extents
2343	* which are already unlinked from current extent tree due to extent
2344	* rotation and merging.
2345	*/
2346	et.et_dealloc = &dealloc;
2347
2348	ret = ocfs2_lock_allocators(inode, et: &et, clusters_to_add: 0, extents_to_split: dwc->dw_zero_count*2,
2349	data_ac: &data_ac, meta_ac: &meta_ac);
2350	if (ret) {
2351	mlog_errno(ret);
2352	goto unlock;
2353	}
2354
2355	credits = ocfs2_calc_extend_credits(sb: inode->i_sb, root_el: &di->id2.i_list);
2356
2357	handle = ocfs2_start_trans(osb, max_buffs: credits);
2358	if (IS_ERR(ptr: handle)) {
2359	ret = PTR_ERR(ptr: handle);
2360	mlog_errno(ret);
2361	goto unlock;
2362	}
2363	ret = ocfs2_journal_access_di(handle, ci: INODE_CACHE(inode), bh: di_bh,
2364	OCFS2_JOURNAL_ACCESS_WRITE);
2365	if (ret) {
2366	mlog_errno(ret);
2367	goto commit;
2368	}
2369
2370	list_for_each_entry(ue, &dwc->dw_zero_list, ue_node) {
2371	ret = ocfs2_mark_extent_written(inode, et: &et, handle,
2372	cpos: ue->ue_cpos, len: 1,
2373	phys: ue->ue_phys,
2374	meta_ac, dealloc: &dealloc);
2375	if (ret < 0) {
2376	mlog_errno(ret);
2377	break;
2378	}
2379	}
2380
2381	if (end > i_size_read(inode)) {
2382	ret = ocfs2_set_inode_size(handle, inode, fe_bh: di_bh, new_i_size: end);
2383	if (ret < 0)
2384	mlog_errno(ret);
2385	}
2386	commit:
2387	ocfs2_commit_trans(osb, handle);
2388	unlock:
2389	up_write(sem: &oi->ip_alloc_sem);
2390	ocfs2_inode_unlock(inode, ex: 1);
2391	brelse(bh: di_bh);
2392	out:
2393	if (data_ac)
2394	ocfs2_free_alloc_context(ac: data_ac);
2395	if (meta_ac)
2396	ocfs2_free_alloc_context(ac: meta_ac);
2397	ocfs2_run_deallocs(osb, ctxt: &dealloc);
2398	ocfs2_dio_free_write_ctx(inode, dwc);
2399
2400	return ret;
2401	}
2402
2403	/*
2404	* ocfs2_dio_end_io is called by the dio core when a dio is finished. We're
2405	* particularly interested in the aio/dio case. We use the rw_lock DLM lock
2406	* to protect io on one node from truncation on another.
2407	*/
2408	static int ocfs2_dio_end_io(struct kiocb *iocb,
2409	loff_t offset,
2410	ssize_t bytes,
2411	void *private)
2412	{
2413	struct inode *inode = file_inode(f: iocb->ki_filp);
2414	int level;
2415	int ret = 0;
2416
2417	/* this io's submitter should not have unlocked this before we could */
2418	BUG_ON(!ocfs2_iocb_is_rw_locked(iocb));
2419
2420	if (bytes <= 0)
2421	mlog_ratelimited(ML_ERROR, "Direct IO failed, bytes = %lld",
2422	(long long)bytes);
2423	if (private) {
2424	if (bytes > 0)
2425	ret = ocfs2_dio_end_io_write(inode, dwc: private, offset,
2426	bytes);
2427	else
2428	ocfs2_dio_free_write_ctx(inode, dwc: private);
2429	}
2430
2431	ocfs2_iocb_clear_rw_locked(iocb);
2432
2433	level = ocfs2_iocb_rw_locked_level(iocb);
2434	ocfs2_rw_unlock(inode, write: level);
2435	return ret;
2436	}
2437
2438	static ssize_t ocfs2_direct_IO(struct kiocb *iocb, struct iov_iter *iter)
2439	{
2440	struct file *file = iocb->ki_filp;
2441	struct inode *inode = file->f_mapping->host;
2442	struct ocfs2_super *osb = OCFS2_SB(inode->i_sb);
2443	get_block_t *get_block;
2444
2445	/*
2446	* Fallback to buffered I/O if we see an inode without
2447	* extents.
2448	*/
2449	if (OCFS2_I(inode)->ip_dyn_features & OCFS2_INLINE_DATA_FL)
2450	return 0;
2451
2452	/* Fallback to buffered I/O if we do not support append dio. */
2453	if (iocb->ki_pos + iter->count > i_size_read(inode) &&
2454	!ocfs2_supports_append_dio(osb))
2455	return 0;
2456
2457	if (iov_iter_rw(i: iter) == READ)
2458	get_block = ocfs2_lock_get_block;
2459	else
2460	get_block = ocfs2_dio_wr_get_block;
2461
2462	return __blockdev_direct_IO(iocb, inode, bdev: inode->i_sb->s_bdev,
2463	iter, get_block,
2464	end_io: ocfs2_dio_end_io, flags: 0);
2465	}
2466
2467	const struct address_space_operations ocfs2_aops = {
2468	.dirty_folio = block_dirty_folio,
2469	.read_folio = ocfs2_read_folio,
2470	.readahead = ocfs2_readahead,
2471	.writepages = ocfs2_writepages,
2472	.write_begin = ocfs2_write_begin,
2473	.write_end = ocfs2_write_end,
2474	.bmap = ocfs2_bmap,
2475	.direct_IO = ocfs2_direct_IO,
2476	.invalidate_folio = block_invalidate_folio,
2477	.release_folio = ocfs2_release_folio,
2478	.migrate_folio = buffer_migrate_folio,
2479	.is_partially_uptodate = block_is_partially_uptodate,
2480	.error_remove_folio = generic_error_remove_folio,
2481	};
2482