1	// SPDX-License-Identifier: GPL-2.0
2	/*
3	* linux/fs/ext2/inode.c
4	*
5	* Copyright (C) 1992, 1993, 1994, 1995
6	* Remy Card (card@masi.ibp.fr)
7	* Laboratoire MASI - Institut Blaise Pascal
8	* Universite Pierre et Marie Curie (Paris VI)
9	*
10	* from
11	*
12	* linux/fs/minix/inode.c
13	*
14	* Copyright (C) 1991, 1992 Linus Torvalds
15	*
16	* Goal-directed block allocation by Stephen Tweedie
17	* (sct@dcs.ed.ac.uk), 1993, 1998
18	* Big-endian to little-endian byte-swapping/bitmaps by
19	* David S. Miller (davem@caip.rutgers.edu), 1995
20	* 64-bit file support on 64-bit platforms by Jakub Jelinek
21	* (jj@sunsite.ms.mff.cuni.cz)
22	*
23	* Assorted race fixes, rewrite of ext2_get_block() by Al Viro, 2000
24	*/
25
26	#include <linux/time.h>
27	#include <linux/highuid.h>
28	#include <linux/pagemap.h>
29	#include <linux/dax.h>
30	#include <linux/blkdev.h>
31	#include <linux/quotaops.h>
32	#include <linux/writeback.h>
33	#include <linux/buffer_head.h>
34	#include <linux/mpage.h>
35	#include <linux/fiemap.h>
36	#include <linux/iomap.h>
37	#include <linux/namei.h>
38	#include <linux/uio.h>
39	#include "ext2.h"
40	#include "acl.h"
41	#include "xattr.h"
42
43	static int __ext2_write_inode(struct inode *inode, int do_sync);
44
45	/*
46	* Test whether an inode is a fast symlink.
47	*/
48	static inline int ext2_inode_is_fast_symlink(struct inode *inode)
49	{
50	int ea_blocks = EXT2_I(inode)->i_file_acl ?
51	(inode->i_sb->s_blocksize >> 9) : 0;
52
53	return (S_ISLNK(inode->i_mode) &&
54	inode->i_blocks - ea_blocks == 0);
55	}
56
57	static void ext2_truncate_blocks(struct inode *inode, loff_t offset);
58
59	void ext2_write_failed(struct address_space *mapping, loff_t to)
60	{
61	struct inode *inode = mapping->host;
62
63	if (to > inode->i_size) {
64	truncate_pagecache(inode, new: inode->i_size);
65	ext2_truncate_blocks(inode, offset: inode->i_size);
66	}
67	}
68
69	/*
70	* Called at the last iput() if i_nlink is zero.
71	*/
72	void ext2_evict_inode(struct inode * inode)
73	{
74	struct ext2_block_alloc_info *rsv;
75	int want_delete = 0;
76
77	if (!inode->i_nlink && !is_bad_inode(inode)) {
78	want_delete = 1;
79	dquot_initialize(inode);
80	} else {
81	dquot_drop(inode);
82	}
83
84	truncate_inode_pages_final(&inode->i_data);
85
86	if (want_delete) {
87	sb_start_intwrite(sb: inode->i_sb);
88	/* set dtime */
89	EXT2_I(inode)->i_dtime = ktime_get_real_seconds();
90	mark_inode_dirty(inode);
91	__ext2_write_inode(inode, do_sync: inode_needs_sync(inode));
92	/* truncate to 0 */
93	inode->i_size = 0;
94	if (inode->i_blocks)
95	ext2_truncate_blocks(inode, offset: 0);
96	ext2_xattr_delete_inode(inode);
97	}
98
99	invalidate_inode_buffers(inode);
100	clear_inode(inode);
101
102	ext2_discard_reservation(inode);
103	rsv = EXT2_I(inode)->i_block_alloc_info;
104	EXT2_I(inode)->i_block_alloc_info = NULL;
105	if (unlikely(rsv))
106	kfree(objp: rsv);
107
108	if (want_delete) {
109	ext2_free_inode(inode);
110	sb_end_intwrite(sb: inode->i_sb);
111	}
112	}
113
114	typedef struct {
115	__le32 *p;
116	__le32 key;
117	struct buffer_head *bh;
118	} Indirect;
119
120	static inline void add_chain(Indirect *p, struct buffer_head *bh, __le32 *v)
121	{
122	p->key = *(p->p = v);
123	p->bh = bh;
124	}
125
126	static inline int verify_chain(Indirect *from, Indirect *to)
127	{
128	while (from <= to && from->key == *from->p)
129	from++;
130	return (from > to);
131	}
132
133	/**
134	* ext2_block_to_path - parse the block number into array of offsets
135	* @inode: inode in question (we are only interested in its superblock)
136	* @i_block: block number to be parsed
137	* @offsets: array to store the offsets in
138	* @boundary: set this non-zero if the referred-to block is likely to be
139	* followed (on disk) by an indirect block.
140	* To store the locations of file's data ext2 uses a data structure common
141	* for UNIX filesystems - tree of pointers anchored in the inode, with
142	* data blocks at leaves and indirect blocks in intermediate nodes.
143	* This function translates the block number into path in that tree -
144	* return value is the path length and @offsets[n] is the offset of
145	* pointer to (n+1)th node in the nth one. If @block is out of range
146	* (negative or too large) warning is printed and zero returned.
147	*
148	* Note: function doesn't find node addresses, so no IO is needed. All
149	* we need to know is the capacity of indirect blocks (taken from the
150	* inode->i_sb).
151	*/
152
153	/*
154	* Portability note: the last comparison (check that we fit into triple
155	* indirect block) is spelled differently, because otherwise on an
156	* architecture with 32-bit longs and 8Kb pages we might get into trouble
157	* if our filesystem had 8Kb blocks. We might use long long, but that would
158	* kill us on x86. Oh, well, at least the sign propagation does not matter -
159	* i_block would have to be negative in the very beginning, so we would not
160	* get there at all.
161	*/
162
163	static int ext2_block_to_path(struct inode *inode,
164	long i_block, int offsets[4], int *boundary)
165	{
166	int ptrs = EXT2_ADDR_PER_BLOCK(inode->i_sb);
167	int ptrs_bits = EXT2_ADDR_PER_BLOCK_BITS(inode->i_sb);
168	const long direct_blocks = EXT2_NDIR_BLOCKS,
169	indirect_blocks = ptrs,
170	double_blocks = (1 << (ptrs_bits * 2));
171	int n = 0;
172	int final = 0;
173
174	if (i_block < 0) {
175	ext2_msg(inode->i_sb, KERN_WARNING,
176	"warning: %s: block < 0", __func__);
177	} else if (i_block < direct_blocks) {
178	offsets[n++] = i_block;
179	final = direct_blocks;
180	} else if ( (i_block -= direct_blocks) < indirect_blocks) {
181	offsets[n++] = EXT2_IND_BLOCK;
182	offsets[n++] = i_block;
183	final = ptrs;
184	} else if ((i_block -= indirect_blocks) < double_blocks) {
185	offsets[n++] = EXT2_DIND_BLOCK;
186	offsets[n++] = i_block >> ptrs_bits;
187	offsets[n++] = i_block & (ptrs - 1);
188	final = ptrs;
189	} else if (((i_block -= double_blocks) >> (ptrs_bits * 2)) < ptrs) {
190	offsets[n++] = EXT2_TIND_BLOCK;
191	offsets[n++] = i_block >> (ptrs_bits * 2);
192	offsets[n++] = (i_block >> ptrs_bits) & (ptrs - 1);
193	offsets[n++] = i_block & (ptrs - 1);
194	final = ptrs;
195	} else {
196	ext2_msg(inode->i_sb, KERN_WARNING,
197	"warning: %s: block is too big", __func__);
198	}
199	if (boundary)
200	*boundary = final - 1 - (i_block & (ptrs - 1));
201
202	return n;
203	}
204
205	/**
206	* ext2_get_branch - read the chain of indirect blocks leading to data
207	* @inode: inode in question
208	* @depth: depth of the chain (1 - direct pointer, etc.)
209	* @offsets: offsets of pointers in inode/indirect blocks
210	* @chain: place to store the result
211	* @err: here we store the error value
212	*
213	* Function fills the array of triples <key, p, bh> and returns %NULL
214	* if everything went OK or the pointer to the last filled triple
215	* (incomplete one) otherwise. Upon the return chain[i].key contains
216	* the number of (i+1)-th block in the chain (as it is stored in memory,
217	* i.e. little-endian 32-bit), chain[i].p contains the address of that
218	* number (it points into struct inode for i==0 and into the bh->b_data
219	* for i>0) and chain[i].bh points to the buffer_head of i-th indirect
220	* block for i>0 and NULL for i==0. In other words, it holds the block
221	* numbers of the chain, addresses they were taken from (and where we can
222	* verify that chain did not change) and buffer_heads hosting these
223	* numbers.
224	*
225	* Function stops when it stumbles upon zero pointer (absent block)
226	* (pointer to last triple returned, *@err == 0)
227	* or when it gets an IO error reading an indirect block
228	* (ditto, *@err == -EIO)
229	* or when it notices that chain had been changed while it was reading
230	* (ditto, *@err == -EAGAIN)
231	* or when it reads all @depth-1 indirect blocks successfully and finds
232	* the whole chain, all way to the data (returns %NULL, *err == 0).
233	*/
234	static Indirect *ext2_get_branch(struct inode *inode,
235	int depth,
236	int *offsets,
237	Indirect chain[4],
238	int *err)
239	{
240	struct super_block *sb = inode->i_sb;
241	Indirect *p = chain;
242	struct buffer_head *bh;
243
244	*err = 0;
245	/* i_data is not going away, no lock needed */
246	add_chain (p: chain, NULL, v: EXT2_I(inode)->i_data + *offsets);
247	if (!p->key)
248	goto no_block;
249	while (--depth) {
250	bh = sb_bread(sb, le32_to_cpu(p->key));
251	if (!bh)
252	goto failure;
253	read_lock(&EXT2_I(inode)->i_meta_lock);
254	if (!verify_chain(from: chain, to: p))
255	goto changed;
256	add_chain(p: ++p, bh, v: (__le32*)bh->b_data + *++offsets);
257	read_unlock(&EXT2_I(inode)->i_meta_lock);
258	if (!p->key)
259	goto no_block;
260	}
261	return NULL;
262
263	changed:
264	read_unlock(&EXT2_I(inode)->i_meta_lock);
265	brelse(bh);
266	*err = -EAGAIN;
267	goto no_block;
268	failure:
269	*err = -EIO;
270	no_block:
271	return p;
272	}
273
274	/**
275	* ext2_find_near - find a place for allocation with sufficient locality
276	* @inode: owner
277	* @ind: descriptor of indirect block.
278	*
279	* This function returns the preferred place for block allocation.
280	* It is used when heuristic for sequential allocation fails.
281	* Rules are:
282	* + if there is a block to the left of our position - allocate near it.
283	* + if pointer will live in indirect block - allocate near that block.
284	* + if pointer will live in inode - allocate in the same cylinder group.
285	*
286	* In the latter case we colour the starting block by the callers PID to
287	* prevent it from clashing with concurrent allocations for a different inode
288	* in the same block group. The PID is used here so that functionally related
289	* files will be close-by on-disk.
290	*
291	* Caller must make sure that @ind is valid and will stay that way.
292	*/
293
294	static ext2_fsblk_t ext2_find_near(struct inode *inode, Indirect *ind)
295	{
296	struct ext2_inode_info *ei = EXT2_I(inode);
297	__le32 *start = ind->bh ? (__le32 *) ind->bh->b_data : ei->i_data;
298	__le32 *p;
299	ext2_fsblk_t bg_start;
300	ext2_fsblk_t colour;
301
302	/* Try to find previous block */
303	for (p = ind->p - 1; p >= start; p--)
304	if (*p)
305	return le32_to_cpu(*p);
306
307	/* No such thing, so let's try location of indirect block */
308	if (ind->bh)
309	return ind->bh->b_blocknr;
310
311	/*
312	* It is going to be referred from inode itself? OK, just put it into
313	* the same cylinder group then.
314	*/
315	bg_start = ext2_group_first_block_no(sb: inode->i_sb, group_no: ei->i_block_group);
316	colour = (current->pid % 16) *
317	(EXT2_BLOCKS_PER_GROUP(inode->i_sb) / 16);
318	return bg_start + colour;
319	}
320
321	/**
322	* ext2_find_goal - find a preferred place for allocation.
323	* @inode: owner
324	* @block: block we want
325	* @partial: pointer to the last triple within a chain
326	*
327	* Returns preferred place for a block (the goal).
328	*/
329
330	static inline ext2_fsblk_t ext2_find_goal(struct inode *inode, long block,
331	Indirect *partial)
332	{
333	struct ext2_block_alloc_info *block_i;
334
335	block_i = EXT2_I(inode)->i_block_alloc_info;
336
337	/*
338	* try the heuristic for sequential allocation,
339	* failing that at least try to get decent locality.
340	*/
341	if (block_i && (block == block_i->last_alloc_logical_block + 1)
342	&& (block_i->last_alloc_physical_block != 0)) {
343	return block_i->last_alloc_physical_block + 1;
344	}
345
346	return ext2_find_near(inode, ind: partial);
347	}
348
349	/**
350	* ext2_blks_to_allocate: Look up the block map and count the number
351	* of direct blocks need to be allocated for the given branch.
352	*
353	* @branch: chain of indirect blocks
354	* @k: number of blocks need for indirect blocks
355	* @blks: number of data blocks to be mapped.
356	* @blocks_to_boundary: the offset in the indirect block
357	*
358	* return the number of direct blocks to allocate.
359	*/
360	static int
361	ext2_blks_to_allocate(Indirect * branch, int k, unsigned long blks,
362	int blocks_to_boundary)
363	{
364	unsigned long count = 0;
365
366	/*
367	* Simple case, [t,d]Indirect block(s) has not allocated yet
368	* then it's clear blocks on that path have not allocated
369	*/
370	if (k > 0) {
371	/* right now don't hanel cross boundary allocation */
372	if (blks < blocks_to_boundary + 1)
373	count += blks;
374	else
375	count += blocks_to_boundary + 1;
376	return count;
377	}
378
379	count++;
380	while (count < blks && count <= blocks_to_boundary
381	&& le32_to_cpu(*(branch[0].p + count)) == 0) {
382	count++;
383	}
384	return count;
385	}
386
387	/**
388	* ext2_alloc_blocks: Allocate multiple blocks needed for a branch.
389	* @inode: Owner.
390	* @goal: Preferred place for allocation.
391	* @indirect_blks: The number of blocks needed to allocate for indirect blocks.
392	* @blks: The number of blocks need to allocate for direct blocks.
393	* @new_blocks: On return it will store the new block numbers for
394	* the indirect blocks(if needed) and the first direct block.
395	* @err: Error pointer.
396	*
397	* Return: Number of blocks allocated.
398	*/
399	static int ext2_alloc_blocks(struct inode *inode,
400	ext2_fsblk_t goal, int indirect_blks, int blks,
401	ext2_fsblk_t new_blocks[4], int *err)
402	{
403	int target, i;
404	unsigned long count = 0;
405	int index = 0;
406	ext2_fsblk_t current_block = 0;
407	int ret = 0;
408
409	/*
410	* Here we try to allocate the requested multiple blocks at once,
411	* on a best-effort basis.
412	* To build a branch, we should allocate blocks for
413	* the indirect blocks(if not allocated yet), and at least
414	* the first direct block of this branch. That's the
415	* minimum number of blocks need to allocate(required)
416	*/
417	target = blks + indirect_blks;
418
419	while (1) {
420	count = target;
421	/* allocating blocks for indirect blocks and direct blocks */
422	current_block = ext2_new_blocks(inode, goal, &count, err, 0);
423	if (*err)
424	goto failed_out;
425
426	target -= count;
427	/* allocate blocks for indirect blocks */
428	while (index < indirect_blks && count) {
429	new_blocks[index++] = current_block++;
430	count--;
431	}
432
433	if (count > 0)
434	break;
435	}
436
437	/* save the new block number for the first direct block */
438	new_blocks[index] = current_block;
439
440	/* total number of blocks allocated for direct blocks */
441	ret = count;
442	*err = 0;
443	return ret;
444	failed_out:
445	for (i = 0; i <index; i++)
446	ext2_free_blocks(inode, new_blocks[i], 1);
447	if (index)
448	mark_inode_dirty(inode);
449	return ret;
450	}
451
452	/**
453	* ext2_alloc_branch - allocate and set up a chain of blocks.
454	* @inode: owner
455	* @indirect_blks: depth of the chain (number of blocks to allocate)
456	* @blks: number of allocated direct blocks
457	* @goal: preferred place for allocation
458	* @offsets: offsets (in the blocks) to store the pointers to next.
459	* @branch: place to store the chain in.
460	*
461	* This function allocates @num blocks, zeroes out all but the last one,
462	* links them into chain and (if we are synchronous) writes them to disk.
463	* In other words, it prepares a branch that can be spliced onto the
464	* inode. It stores the information about that chain in the branch[], in
465	* the same format as ext2_get_branch() would do. We are calling it after
466	* we had read the existing part of chain and partial points to the last
467	* triple of that (one with zero ->key). Upon the exit we have the same
468	* picture as after the successful ext2_get_block(), except that in one
469	* place chain is disconnected - *branch->p is still zero (we did not
470	* set the last link), but branch->key contains the number that should
471	* be placed into *branch->p to fill that gap.
472	*
473	* If allocation fails we free all blocks we've allocated (and forget
474	* their buffer_heads) and return the error value the from failed
475	* ext2_alloc_block() (normally -ENOSPC). Otherwise we set the chain
476	* as described above and return 0.
477	*/
478
479	static int ext2_alloc_branch(struct inode *inode,
480	int indirect_blks, int *blks, ext2_fsblk_t goal,
481	int *offsets, Indirect *branch)
482	{
483	int blocksize = inode->i_sb->s_blocksize;
484	int i, n = 0;
485	int err = 0;
486	struct buffer_head *bh;
487	int num;
488	ext2_fsblk_t new_blocks[4];
489	ext2_fsblk_t current_block;
490
491	num = ext2_alloc_blocks(inode, goal, indirect_blks,
492	blks: *blks, new_blocks, err: &err);
493	if (err)
494	return err;
495
496	branch[0].key = cpu_to_le32(new_blocks[0]);
497	/*
498	* metadata blocks and data blocks are allocated.
499	*/
500	for (n = 1; n <= indirect_blks; n++) {
501	/*
502	* Get buffer_head for parent block, zero it out
503	* and set the pointer to new one, then send
504	* parent to disk.
505	*/
506	bh = sb_getblk(sb: inode->i_sb, block: new_blocks[n-1]);
507	if (unlikely(!bh)) {
508	err = -ENOMEM;
509	goto failed;
510	}
511	branch[n].bh = bh;
512	lock_buffer(bh);
513	memset(bh->b_data, 0, blocksize);
514	branch[n].p = (__le32 *) bh->b_data + offsets[n];
515	branch[n].key = cpu_to_le32(new_blocks[n]);
516	*branch[n].p = branch[n].key;
517	if ( n == indirect_blks) {
518	current_block = new_blocks[n];
519	/*
520	* End of chain, update the last new metablock of
521	* the chain to point to the new allocated
522	* data blocks numbers
523	*/
524	for (i=1; i < num; i++)
525	*(branch[n].p + i) = cpu_to_le32(++current_block);
526	}
527	set_buffer_uptodate(bh);
528	unlock_buffer(bh);
529	mark_buffer_dirty_inode(bh, inode);
530	/* We used to sync bh here if IS_SYNC(inode).
531	* But we now rely upon generic_write_sync()
532	* and b_inode_buffers. But not for directories.
533	*/
534	if (S_ISDIR(inode->i_mode) && IS_DIRSYNC(inode))
535	sync_dirty_buffer(bh);
536	}
537	*blks = num;
538	return err;
539
540	failed:
541	for (i = 1; i < n; i++)
542	bforget(bh: branch[i].bh);
543	for (i = 0; i < indirect_blks; i++)
544	ext2_free_blocks(inode, new_blocks[i], 1);
545	ext2_free_blocks(inode, new_blocks[i], num);
546	return err;
547	}
548
549	/**
550	* ext2_splice_branch - splice the allocated branch onto inode.
551	* @inode: owner
552	* @block: (logical) number of block we are adding
553	* @where: location of missing link
554	* @num: number of indirect blocks we are adding
555	* @blks: number of direct blocks we are adding
556	*
557	* This function fills the missing link and does all housekeeping needed in
558	* inode (->i_blocks, etc.). In case of success we end up with the full
559	* chain to new block and return 0.
560	*/
561	static void ext2_splice_branch(struct inode *inode,
562	long block, Indirect *where, int num, int blks)
563	{
564	int i;
565	struct ext2_block_alloc_info *block_i;
566	ext2_fsblk_t current_block;
567
568	block_i = EXT2_I(inode)->i_block_alloc_info;
569
570	/* XXX LOCKING probably should have i_meta_lock ?*/
571	/* That's it */
572
573	*where->p = where->key;
574
575	/*
576	* Update the host buffer_head or inode to point to more just allocated
577	* direct blocks blocks
578	*/
579	if (num == 0 && blks > 1) {
580	current_block = le32_to_cpu(where->key) + 1;
581	for (i = 1; i < blks; i++)
582	*(where->p + i ) = cpu_to_le32(current_block++);
583	}
584
585	/*
586	* update the most recently allocated logical & physical block
587	* in i_block_alloc_info, to assist find the proper goal block for next
588	* allocation
589	*/
590	if (block_i) {
591	block_i->last_alloc_logical_block = block + blks - 1;
592	block_i->last_alloc_physical_block =
593	le32_to_cpu(where[num].key) + blks - 1;
594	}
595
596	/* We are done with atomic stuff, now do the rest of housekeeping */
597
598	/* had we spliced it onto indirect block? */
599	if (where->bh)
600	mark_buffer_dirty_inode(bh: where->bh, inode);
601
602	inode_set_ctime_current(inode);
603	mark_inode_dirty(inode);
604	}
605
606	/*
607	* Allocation strategy is simple: if we have to allocate something, we will
608	* have to go the whole way to leaf. So let's do it before attaching anything
609	* to tree, set linkage between the newborn blocks, write them if sync is
610	* required, recheck the path, free and repeat if check fails, otherwise
611	* set the last missing link (that will protect us from any truncate-generated
612	* removals - all blocks on the path are immune now) and possibly force the
613	* write on the parent block.
614	* That has a nice additional property: no special recovery from the failed
615	* allocations is needed - we simply release blocks and do not touch anything
616	* reachable from inode.
617	*
618	* `handle' can be NULL if create == 0.
619	*
620	* return > 0, # of blocks mapped or allocated.
621	* return = 0, if plain lookup failed.
622	* return < 0, error case.
623	*/
624	static int ext2_get_blocks(struct inode *inode,
625	sector_t iblock, unsigned long maxblocks,
626	u32 *bno, bool *new, bool *boundary,
627	int create)
628	{
629	int err;
630	int offsets[4];
631	Indirect chain[4];
632	Indirect *partial;
633	ext2_fsblk_t goal;
634	int indirect_blks;
635	int blocks_to_boundary = 0;
636	int depth;
637	struct ext2_inode_info *ei = EXT2_I(inode);
638	int count = 0;
639	ext2_fsblk_t first_block = 0;
640
641	BUG_ON(maxblocks == 0);
642
643	depth = ext2_block_to_path(inode,i_block: iblock,offsets,boundary: &blocks_to_boundary);
644
645	if (depth == 0)
646	return -EIO;
647
648	partial = ext2_get_branch(inode, depth, offsets, chain, err: &err);
649	/* Simplest case - block found, no allocation needed */
650	if (!partial) {
651	first_block = le32_to_cpu(chain[depth - 1].key);
652	count++;
653	/*map more blocks*/
654	while (count < maxblocks && count <= blocks_to_boundary) {
655	ext2_fsblk_t blk;
656
657	if (!verify_chain(from: chain, to: chain + depth - 1)) {
658	/*
659	* Indirect block might be removed by
660	* truncate while we were reading it.
661	* Handling of that case: forget what we've
662	* got now, go to reread.
663	*/
664	err = -EAGAIN;
665	count = 0;
666	partial = chain + depth - 1;
667	break;
668	}
669	blk = le32_to_cpu(*(chain[depth-1].p + count));
670	if (blk == first_block + count)
671	count++;
672	else
673	break;
674	}
675	if (err != -EAGAIN)
676	goto got_it;
677	}
678
679	/* Next simple case - plain lookup or failed read of indirect block */
680	if (!create || err == -EIO)
681	goto cleanup;
682
683	mutex_lock(&ei->truncate_mutex);
684	/*
685	* If the indirect block is missing while we are reading
686	* the chain(ext2_get_branch() returns -EAGAIN err), or
687	* if the chain has been changed after we grab the semaphore,
688	* (either because another process truncated this branch, or
689	* another get_block allocated this branch) re-grab the chain to see if
690	* the request block has been allocated or not.
691	*
692	* Since we already block the truncate/other get_block
693	* at this point, we will have the current copy of the chain when we
694	* splice the branch into the tree.
695	*/
696	if (err == -EAGAIN || !verify_chain(from: chain, to: partial)) {
697	while (partial > chain) {
698	brelse(bh: partial->bh);
699	partial--;
700	}
701	partial = ext2_get_branch(inode, depth, offsets, chain, err: &err);
702	if (!partial) {
703	count++;
704	mutex_unlock(lock: &ei->truncate_mutex);
705	goto got_it;
706	}
707
708	if (err) {
709	mutex_unlock(lock: &ei->truncate_mutex);
710	goto cleanup;
711	}
712	}
713
714	/*
715	* Okay, we need to do block allocation. Lazily initialize the block
716	* allocation info here if necessary
717	*/
718	if (S_ISREG(inode->i_mode) && (!ei->i_block_alloc_info))
719	ext2_init_block_alloc_info(inode);
720
721	goal = ext2_find_goal(inode, block: iblock, partial);
722
723	/* the number of blocks need to allocate for [d,t]indirect blocks */
724	indirect_blks = (chain + depth) - partial - 1;
725	/*
726	* Next look up the indirect map to count the total number of
727	* direct blocks to allocate for this branch.
728	*/
729	count = ext2_blks_to_allocate(branch: partial, k: indirect_blks,
730	blks: maxblocks, blocks_to_boundary);
731	/*
732	* XXX ???? Block out ext2_truncate while we alter the tree
733	*/
734	err = ext2_alloc_branch(inode, indirect_blks, blks: &count, goal,
735	offsets: offsets + (partial - chain), branch: partial);
736
737	if (err) {
738	mutex_unlock(lock: &ei->truncate_mutex);
739	goto cleanup;
740	}
741
742	if (IS_DAX(inode)) {
743	/*
744	* We must unmap blocks before zeroing so that writeback cannot
745	* overwrite zeros with stale data from block device page cache.
746	*/
747	clean_bdev_aliases(bdev: inode->i_sb->s_bdev,
748	le32_to_cpu(chain[depth-1].key),
749	len: count);
750	/*
751	* block must be initialised before we put it in the tree
752	* so that it's not found by another thread before it's
753	* initialised
754	*/
755	err = sb_issue_zeroout(sb: inode->i_sb,
756	le32_to_cpu(chain[depth-1].key), nr_blocks: count,
757	GFP_KERNEL);
758	if (err) {
759	mutex_unlock(lock: &ei->truncate_mutex);
760	goto cleanup;
761	}
762	}
763	*new = true;
764
765	ext2_splice_branch(inode, block: iblock, where: partial, num: indirect_blks, blks: count);
766	mutex_unlock(lock: &ei->truncate_mutex);
767	got_it:
768	if (count > blocks_to_boundary)
769	*boundary = true;
770	err = count;
771	/* Clean up and exit */
772	partial = chain + depth - 1; /* the whole chain */
773	cleanup:
774	while (partial > chain) {
775	brelse(bh: partial->bh);
776	partial--;
777	}
778	if (err > 0)
779	*bno = le32_to_cpu(chain[depth-1].key);
780	return err;
781	}
782
783	int ext2_get_block(struct inode *inode, sector_t iblock,
784	struct buffer_head *bh_result, int create)
785	{
786	unsigned max_blocks = bh_result->b_size >> inode->i_blkbits;
787	bool new = false, boundary = false;
788	u32 bno;
789	int ret;
790
791	ret = ext2_get_blocks(inode, iblock, maxblocks: max_blocks, bno: &bno, new: &new, boundary: &boundary,
792	create);
793	if (ret <= 0)
794	return ret;
795
796	map_bh(bh: bh_result, sb: inode->i_sb, block: bno);
797	bh_result->b_size = (ret << inode->i_blkbits);
798	if (new)
799	set_buffer_new(bh_result);
800	if (boundary)
801	set_buffer_boundary(bh_result);
802	return 0;
803
804	}
805
806	static int ext2_iomap_begin(struct inode *inode, loff_t offset, loff_t length,
807	unsigned flags, struct iomap *iomap, struct iomap *srcmap)
808	{
809	unsigned int blkbits = inode->i_blkbits;
810	unsigned long first_block = offset >> blkbits;
811	unsigned long max_blocks = (length + (1 << blkbits) - 1) >> blkbits;
812	struct ext2_sb_info *sbi = EXT2_SB(sb: inode->i_sb);
813	bool new = false, boundary = false;
814	u32 bno;
815	int ret;
816	bool create = flags & IOMAP_WRITE;
817
818	/*
819	* For writes that could fill holes inside i_size on a
820	* DIO_SKIP_HOLES filesystem we forbid block creations: only
821	* overwrites are permitted.
822	*/
823	if ((flags & IOMAP_DIRECT) &&
824	(first_block << blkbits) < i_size_read(inode))
825	create = 0;
826
827	/*
828	* Writes that span EOF might trigger an IO size update on completion,
829	* so consider them to be dirty for the purposes of O_DSYNC even if
830	* there is no other metadata changes pending or have been made here.
831	*/
832	if ((flags & IOMAP_WRITE) && offset + length > i_size_read(inode))
833	iomap->flags |= IOMAP_F_DIRTY;
834
835	ret = ext2_get_blocks(inode, iblock: first_block, maxblocks: max_blocks,
836	bno: &bno, new: &new, boundary: &boundary, create);
837	if (ret < 0)
838	return ret;
839
840	iomap->flags = 0;
841	iomap->offset = (u64)first_block << blkbits;
842	if (flags & IOMAP_DAX)
843	iomap->dax_dev = sbi->s_daxdev;
844	else
845	iomap->bdev = inode->i_sb->s_bdev;
846
847	if (ret == 0) {
848	/*
849	* Switch to buffered-io for writing to holes in a non-extent
850	* based filesystem to avoid stale data exposure problem.
851	*/
852	if (!create && (flags & IOMAP_WRITE) && (flags & IOMAP_DIRECT))
853	return -ENOTBLK;
854	iomap->type = IOMAP_HOLE;
855	iomap->addr = IOMAP_NULL_ADDR;
856	iomap->length = 1 << blkbits;
857	} else {
858	iomap->type = IOMAP_MAPPED;
859	iomap->addr = (u64)bno << blkbits;
860	if (flags & IOMAP_DAX)
861	iomap->addr += sbi->s_dax_part_off;
862	iomap->length = (u64)ret << blkbits;
863	iomap->flags |= IOMAP_F_MERGED;
864	}
865
866	if (new)
867	iomap->flags |= IOMAP_F_NEW;
868	return 0;
869	}
870
871	static int
872	ext2_iomap_end(struct inode *inode, loff_t offset, loff_t length,
873	ssize_t written, unsigned flags, struct iomap *iomap)
874	{
875	/*
876	* Switch to buffered-io in case of any error.
877	* Blocks allocated can be used by the buffered-io path.
878	*/
879	if ((flags & IOMAP_DIRECT) && (flags & IOMAP_WRITE) && written == 0)
880	return -ENOTBLK;
881
882	if (iomap->type == IOMAP_MAPPED &&
883	written < length &&
884	(flags & IOMAP_WRITE))
885	ext2_write_failed(mapping: inode->i_mapping, to: offset + length);
886	return 0;
887	}
888
889	const struct iomap_ops ext2_iomap_ops = {
890	.iomap_begin = ext2_iomap_begin,
891	.iomap_end = ext2_iomap_end,
892	};
893
894	int ext2_fiemap(struct inode *inode, struct fiemap_extent_info *fieinfo,
895	u64 start, u64 len)
896	{
897	int ret;
898
899	inode_lock(inode);
900	len = min_t(u64, len, i_size_read(inode));
901	ret = iomap_fiemap(inode, fieinfo, start, len, ops: &ext2_iomap_ops);
902	inode_unlock(inode);
903
904	return ret;
905	}
906
907	static int ext2_read_folio(struct file *file, struct folio *folio)
908	{
909	return mpage_read_folio(folio, get_block: ext2_get_block);
910	}
911
912	static void ext2_readahead(struct readahead_control *rac)
913	{
914	mpage_readahead(rac, get_block: ext2_get_block);
915	}
916
917	static int
918	ext2_write_begin(struct file *file, struct address_space *mapping,
919	loff_t pos, unsigned len, struct page **pagep, void **fsdata)
920	{
921	int ret;
922
923	ret = block_write_begin(mapping, pos, len, pagep, get_block: ext2_get_block);
924	if (ret < 0)
925	ext2_write_failed(mapping, to: pos + len);
926	return ret;
927	}
928
929	static int ext2_write_end(struct file *file, struct address_space *mapping,
930	loff_t pos, unsigned len, unsigned copied,
931	struct page *page, void *fsdata)
932	{
933	int ret;
934
935	ret = generic_write_end(file, mapping, pos, len, copied, page, fsdata);
936	if (ret < len)
937	ext2_write_failed(mapping, to: pos + len);
938	return ret;
939	}
940
941	static sector_t ext2_bmap(struct address_space *mapping, sector_t block)
942	{
943	return generic_block_bmap(mapping,block,ext2_get_block);
944	}
945
946	static int
947	ext2_writepages(struct address_space *mapping, struct writeback_control *wbc)
948	{
949	return mpage_writepages(mapping, wbc, get_block: ext2_get_block);
950	}
951
952	static int
953	ext2_dax_writepages(struct address_space *mapping, struct writeback_control *wbc)
954	{
955	struct ext2_sb_info *sbi = EXT2_SB(sb: mapping->host->i_sb);
956
957	return dax_writeback_mapping_range(mapping, dax_dev: sbi->s_daxdev, wbc);
958	}
959
960	const struct address_space_operations ext2_aops = {
961	.dirty_folio = block_dirty_folio,
962	.invalidate_folio = block_invalidate_folio,
963	.read_folio = ext2_read_folio,
964	.readahead = ext2_readahead,
965	.write_begin = ext2_write_begin,
966	.write_end = ext2_write_end,
967	.bmap = ext2_bmap,
968	.direct_IO = noop_direct_IO,
969	.writepages = ext2_writepages,
970	.migrate_folio = buffer_migrate_folio,
971	.is_partially_uptodate = block_is_partially_uptodate,
972	.error_remove_folio = generic_error_remove_folio,
973	};
974
975	static const struct address_space_operations ext2_dax_aops = {
976	.writepages = ext2_dax_writepages,
977	.direct_IO = noop_direct_IO,
978	.dirty_folio = noop_dirty_folio,
979	};
980
981	/*
982	* Probably it should be a library function... search for first non-zero word
983	* or memcmp with zero_page, whatever is better for particular architecture.
984	* Linus?
985	*/
986	static inline int all_zeroes(__le32 *p, __le32 *q)
987	{
988	while (p < q)
989	if (*p++)
990	return 0;
991	return 1;
992	}
993
994	/**
995	* ext2_find_shared - find the indirect blocks for partial truncation.
996	* @inode: inode in question
997	* @depth: depth of the affected branch
998	* @offsets: offsets of pointers in that branch (see ext2_block_to_path)
999	* @chain: place to store the pointers to partial indirect blocks
1000	* @top: place to the (detached) top of branch
1001	*
1002	* This is a helper function used by ext2_truncate().
1003	*
1004	* When we do truncate() we may have to clean the ends of several indirect
1005	* blocks but leave the blocks themselves alive. Block is partially
1006	* truncated if some data below the new i_size is referred from it (and
1007	* it is on the path to the first completely truncated data block, indeed).
1008	* We have to free the top of that path along with everything to the right
1009	* of the path. Since no allocation past the truncation point is possible
1010	* until ext2_truncate() finishes, we may safely do the latter, but top
1011	* of branch may require special attention - pageout below the truncation
1012	* point might try to populate it.
1013	*
1014	* We atomically detach the top of branch from the tree, store the block
1015	* number of its root in *@top, pointers to buffer_heads of partially
1016	* truncated blocks - in @chain[].bh and pointers to their last elements
1017	* that should not be removed - in @chain[].p. Return value is the pointer
1018	* to last filled element of @chain.
1019	*
1020	* The work left to caller to do the actual freeing of subtrees:
1021	* a) free the subtree starting from *@top
1022	* b) free the subtrees whose roots are stored in
1023	* (@chain[i].p+1 .. end of @chain[i].bh->b_data)
1024	* c) free the subtrees growing from the inode past the @chain[0].p
1025	* (no partially truncated stuff there).
1026	*/
1027
1028	static Indirect *ext2_find_shared(struct inode *inode,
1029	int depth,
1030	int offsets[4],
1031	Indirect chain[4],
1032	__le32 *top)
1033	{
1034	Indirect *partial, *p;
1035	int k, err;
1036
1037	*top = 0;
1038	for (k = depth; k > 1 && !offsets[k-1]; k--)
1039	;
1040	partial = ext2_get_branch(inode, depth: k, offsets, chain, err: &err);
1041	if (!partial)
1042	partial = chain + k-1;
1043	/*
1044	* If the branch acquired continuation since we've looked at it -
1045	* fine, it should all survive and (new) top doesn't belong to us.
1046	*/
1047	write_lock(&EXT2_I(inode)->i_meta_lock);
1048	if (!partial->key && *partial->p) {
1049	write_unlock(&EXT2_I(inode)->i_meta_lock);
1050	goto no_top;
1051	}
1052	for (p=partial; p>chain && all_zeroes(p: (__le32*)p->bh->b_data,q: p->p); p--)
1053	;
1054	/*
1055	* OK, we've found the last block that must survive. The rest of our
1056	* branch should be detached before unlocking. However, if that rest
1057	* of branch is all ours and does not grow immediately from the inode
1058	* it's easier to cheat and just decrement partial->p.
1059	*/
1060	if (p == chain + k - 1 && p > chain) {
1061	p->p--;
1062	} else {
1063	*top = *p->p;
1064	*p->p = 0;
1065	}
1066	write_unlock(&EXT2_I(inode)->i_meta_lock);
1067
1068	while(partial > p)
1069	{
1070	brelse(bh: partial->bh);
1071	partial--;
1072	}
1073	no_top:
1074	return partial;
1075	}
1076
1077	/**
1078	* ext2_free_data - free a list of data blocks
1079	* @inode: inode we are dealing with
1080	* @p: array of block numbers
1081	* @q: points immediately past the end of array
1082	*
1083	* We are freeing all blocks referred from that array (numbers are
1084	* stored as little-endian 32-bit) and updating @inode->i_blocks
1085	* appropriately.
1086	*/
1087	static inline void ext2_free_data(struct inode *inode, __le32 *p, __le32 *q)
1088	{
1089	ext2_fsblk_t block_to_free = 0, count = 0;
1090	ext2_fsblk_t nr;
1091
1092	for ( ; p < q ; p++) {
1093	nr = le32_to_cpu(*p);
1094	if (nr) {
1095	*p = 0;
1096	/* accumulate blocks to free if they're contiguous */
1097	if (count == 0)
1098	goto free_this;
1099	else if (block_to_free == nr - count)
1100	count++;
1101	else {
1102	ext2_free_blocks (inode, block_to_free, count);
1103	mark_inode_dirty(inode);
1104	free_this:
1105	block_to_free = nr;
1106	count = 1;
1107	}
1108	}
1109	}
1110	if (count > 0) {
1111	ext2_free_blocks (inode, block_to_free, count);
1112	mark_inode_dirty(inode);
1113	}
1114	}
1115
1116	/**
1117	* ext2_free_branches - free an array of branches
1118	* @inode: inode we are dealing with
1119	* @p: array of block numbers
1120	* @q: pointer immediately past the end of array
1121	* @depth: depth of the branches to free
1122	*
1123	* We are freeing all blocks referred from these branches (numbers are
1124	* stored as little-endian 32-bit) and updating @inode->i_blocks
1125	* appropriately.
1126	*/
1127	static void ext2_free_branches(struct inode *inode, __le32 *p, __le32 *q, int depth)
1128	{
1129	struct buffer_head * bh;
1130	ext2_fsblk_t nr;
1131
1132	if (depth--) {
1133	int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
1134	for ( ; p < q ; p++) {
1135	nr = le32_to_cpu(*p);
1136	if (!nr)
1137	continue;
1138	*p = 0;
1139	bh = sb_bread(sb: inode->i_sb, block: nr);
1140	/*
1141	* A read failure? Report error and clear slot
1142	* (should be rare).
1143	*/
1144	if (!bh) {
1145	ext2_error(inode->i_sb, "ext2_free_branches",
1146	"Read failure, inode=%ld, block=%ld",
1147	inode->i_ino, nr);
1148	continue;
1149	}
1150	ext2_free_branches(inode,
1151	p: (__le32*)bh->b_data,
1152	q: (__le32*)bh->b_data + addr_per_block,
1153	depth);
1154	bforget(bh);
1155	ext2_free_blocks(inode, nr, 1);
1156	mark_inode_dirty(inode);
1157	}
1158	} else
1159	ext2_free_data(inode, p, q);
1160	}
1161
1162	/* mapping->invalidate_lock must be held when calling this function */
1163	static void __ext2_truncate_blocks(struct inode *inode, loff_t offset)
1164	{
1165	__le32 *i_data = EXT2_I(inode)->i_data;
1166	struct ext2_inode_info *ei = EXT2_I(inode);
1167	int addr_per_block = EXT2_ADDR_PER_BLOCK(inode->i_sb);
1168	int offsets[4];
1169	Indirect chain[4];
1170	Indirect *partial;
1171	__le32 nr = 0;
1172	int n;
1173	long iblock;
1174	unsigned blocksize;
1175	blocksize = inode->i_sb->s_blocksize;
1176	iblock = (offset + blocksize-1) >> EXT2_BLOCK_SIZE_BITS(inode->i_sb);
1177
1178	#ifdef CONFIG_FS_DAX
1179	WARN_ON(!rwsem_is_locked(&inode->i_mapping->invalidate_lock));
1180	#endif
1181
1182	n = ext2_block_to_path(inode, i_block: iblock, offsets, NULL);
1183	if (n == 0)
1184	return;
1185
1186	/*
1187	* From here we block out all ext2_get_block() callers who want to
1188	* modify the block allocation tree.
1189	*/
1190	mutex_lock(&ei->truncate_mutex);
1191
1192	if (n == 1) {
1193	ext2_free_data(inode, p: i_data+offsets[0],
1194	q: i_data + EXT2_NDIR_BLOCKS);
1195	goto do_indirects;
1196	}
1197
1198	partial = ext2_find_shared(inode, depth: n, offsets, chain, top: &nr);
1199	/* Kill the top of shared branch (already detached) */
1200	if (nr) {
1201	if (partial == chain)
1202	mark_inode_dirty(inode);
1203	else
1204	mark_buffer_dirty_inode(bh: partial->bh, inode);
1205	ext2_free_branches(inode, p: &nr, q: &nr+1, depth: (chain+n-1) - partial);
1206	}
1207	/* Clear the ends of indirect blocks on the shared branch */
1208	while (partial > chain) {
1209	ext2_free_branches(inode,
1210	p: partial->p + 1,
1211	q: (__le32*)partial->bh->b_data+addr_per_block,
1212	depth: (chain+n-1) - partial);
1213	mark_buffer_dirty_inode(bh: partial->bh, inode);
1214	brelse (bh: partial->bh);
1215	partial--;
1216	}
1217	do_indirects:
1218	/* Kill the remaining (whole) subtrees */
1219	switch (offsets[0]) {
1220	default:
1221	nr = i_data[EXT2_IND_BLOCK];
1222	if (nr) {
1223	i_data[EXT2_IND_BLOCK] = 0;
1224	mark_inode_dirty(inode);
1225	ext2_free_branches(inode, p: &nr, q: &nr+1, depth: 1);
1226	}
1227	fallthrough;
1228	case EXT2_IND_BLOCK:
1229	nr = i_data[EXT2_DIND_BLOCK];
1230	if (nr) {
1231	i_data[EXT2_DIND_BLOCK] = 0;
1232	mark_inode_dirty(inode);
1233	ext2_free_branches(inode, p: &nr, q: &nr+1, depth: 2);
1234	}
1235	fallthrough;
1236	case EXT2_DIND_BLOCK:
1237	nr = i_data[EXT2_TIND_BLOCK];
1238	if (nr) {
1239	i_data[EXT2_TIND_BLOCK] = 0;
1240	mark_inode_dirty(inode);
1241	ext2_free_branches(inode, p: &nr, q: &nr+1, depth: 3);
1242	}
1243	break;
1244	case EXT2_TIND_BLOCK:
1245	;
1246	}
1247
1248	ext2_discard_reservation(inode);
1249
1250	mutex_unlock(lock: &ei->truncate_mutex);
1251	}
1252
1253	static void ext2_truncate_blocks(struct inode *inode, loff_t offset)
1254	{
1255	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1256	S_ISLNK(inode->i_mode)))
1257	return;
1258	if (ext2_inode_is_fast_symlink(inode))
1259	return;
1260
1261	filemap_invalidate_lock(mapping: inode->i_mapping);
1262	__ext2_truncate_blocks(inode, offset);
1263	filemap_invalidate_unlock(mapping: inode->i_mapping);
1264	}
1265
1266	static int ext2_setsize(struct inode *inode, loff_t newsize)
1267	{
1268	int error;
1269
1270	if (!(S_ISREG(inode->i_mode) || S_ISDIR(inode->i_mode) ||
1271	S_ISLNK(inode->i_mode)))
1272	return -EINVAL;
1273	if (ext2_inode_is_fast_symlink(inode))
1274	return -EINVAL;
1275	if (IS_APPEND(inode) || IS_IMMUTABLE(inode))
1276	return -EPERM;
1277
1278	inode_dio_wait(inode);
1279
1280	if (IS_DAX(inode))
1281	error = dax_truncate_page(inode, pos: newsize, NULL,
1282	ops: &ext2_iomap_ops);
1283	else
1284	error = block_truncate_page(inode->i_mapping,
1285	newsize, ext2_get_block);
1286	if (error)
1287	return error;
1288
1289	filemap_invalidate_lock(mapping: inode->i_mapping);
1290	truncate_setsize(inode, newsize);
1291	__ext2_truncate_blocks(inode, offset: newsize);
1292	filemap_invalidate_unlock(mapping: inode->i_mapping);
1293
1294	inode_set_mtime_to_ts(inode, ts: inode_set_ctime_current(inode));
1295	if (inode_needs_sync(inode)) {
1296	sync_mapping_buffers(mapping: inode->i_mapping);
1297	sync_inode_metadata(inode, wait: 1);
1298	} else {
1299	mark_inode_dirty(inode);
1300	}
1301
1302	return 0;
1303	}
1304
1305	static struct ext2_inode *ext2_get_inode(struct super_block *sb, ino_t ino,
1306	struct buffer_head **p)
1307	{
1308	struct buffer_head * bh;
1309	unsigned long block_group;
1310	unsigned long block;
1311	unsigned long offset;
1312	struct ext2_group_desc * gdp;
1313
1314	*p = NULL;
1315	if ((ino != EXT2_ROOT_INO && ino < EXT2_FIRST_INO(sb)) ||
1316	ino > le32_to_cpu(EXT2_SB(sb)->s_es->s_inodes_count))
1317	goto Einval;
1318
1319	block_group = (ino - 1) / EXT2_INODES_PER_GROUP(sb);
1320	gdp = ext2_get_group_desc(sb, block_group, NULL);
1321	if (!gdp)
1322	goto Egdp;
1323	/*
1324	* Figure out the offset within the block group inode table
1325	*/
1326	offset = ((ino - 1) % EXT2_INODES_PER_GROUP(sb)) * EXT2_INODE_SIZE(sb);
1327	block = le32_to_cpu(gdp->bg_inode_table) +
1328	(offset >> EXT2_BLOCK_SIZE_BITS(sb));
1329	if (!(bh = sb_bread(sb, block)))
1330	goto Eio;
1331
1332	*p = bh;
1333	offset &= (EXT2_BLOCK_SIZE(sb) - 1);
1334	return (struct ext2_inode *) (bh->b_data + offset);
1335
1336	Einval:
1337	ext2_error(sb, "ext2_get_inode", "bad inode number: %lu",
1338	(unsigned long) ino);
1339	return ERR_PTR(error: -EINVAL);
1340	Eio:
1341	ext2_error(sb, "ext2_get_inode",
1342	"unable to read inode block - inode=%lu, block=%lu",
1343	(unsigned long) ino, block);
1344	Egdp:
1345	return ERR_PTR(error: -EIO);
1346	}
1347
1348	void ext2_set_inode_flags(struct inode *inode)
1349	{
1350	unsigned int flags = EXT2_I(inode)->i_flags;
1351
1352	inode->i_flags &= ~(S_SYNC | S_APPEND | S_IMMUTABLE | S_NOATIME |
1353	S_DIRSYNC | S_DAX);
1354	if (flags & EXT2_SYNC_FL)
1355	inode->i_flags |= S_SYNC;
1356	if (flags & EXT2_APPEND_FL)
1357	inode->i_flags |= S_APPEND;
1358	if (flags & EXT2_IMMUTABLE_FL)
1359	inode->i_flags |= S_IMMUTABLE;
1360	if (flags & EXT2_NOATIME_FL)
1361	inode->i_flags |= S_NOATIME;
1362	if (flags & EXT2_DIRSYNC_FL)
1363	inode->i_flags |= S_DIRSYNC;
1364	if (test_opt(inode->i_sb, DAX) && S_ISREG(inode->i_mode))
1365	inode->i_flags |= S_DAX;
1366	}
1367
1368	void ext2_set_file_ops(struct inode *inode)
1369	{
1370	inode->i_op = &ext2_file_inode_operations;
1371	inode->i_fop = &ext2_file_operations;
1372	if (IS_DAX(inode))
1373	inode->i_mapping->a_ops = &ext2_dax_aops;
1374	else
1375	inode->i_mapping->a_ops = &ext2_aops;
1376	}
1377
1378	struct inode *ext2_iget (struct super_block *sb, unsigned long ino)
1379	{
1380	struct ext2_inode_info *ei;
1381	struct buffer_head * bh = NULL;
1382	struct ext2_inode *raw_inode;
1383	struct inode *inode;
1384	long ret = -EIO;
1385	int n;
1386	uid_t i_uid;
1387	gid_t i_gid;
1388
1389	inode = iget_locked(sb, ino);
1390	if (!inode)
1391	return ERR_PTR(error: -ENOMEM);
1392	if (!(inode->i_state & I_NEW))
1393	return inode;
1394
1395	ei = EXT2_I(inode);
1396	ei->i_block_alloc_info = NULL;
1397
1398	raw_inode = ext2_get_inode(sb: inode->i_sb, ino, p: &bh);
1399	if (IS_ERR(ptr: raw_inode)) {
1400	ret = PTR_ERR(ptr: raw_inode);
1401	goto bad_inode;
1402	}
1403
1404	inode->i_mode = le16_to_cpu(raw_inode->i_mode);
1405	i_uid = (uid_t)le16_to_cpu(raw_inode->i_uid_low);
1406	i_gid = (gid_t)le16_to_cpu(raw_inode->i_gid_low);
1407	if (!(test_opt (inode->i_sb, NO_UID32))) {
1408	i_uid |= le16_to_cpu(raw_inode->i_uid_high) << 16;
1409	i_gid |= le16_to_cpu(raw_inode->i_gid_high) << 16;
1410	}
1411	i_uid_write(inode, uid: i_uid);
1412	i_gid_write(inode, gid: i_gid);
1413	set_nlink(inode, le16_to_cpu(raw_inode->i_links_count));
1414	inode->i_size = le32_to_cpu(raw_inode->i_size);
1415	inode_set_atime(inode, sec: (signed)le32_to_cpu(raw_inode->i_atime), nsec: 0);
1416	inode_set_ctime(inode, sec: (signed)le32_to_cpu(raw_inode->i_ctime), nsec: 0);
1417	inode_set_mtime(inode, sec: (signed)le32_to_cpu(raw_inode->i_mtime), nsec: 0);
1418	ei->i_dtime = le32_to_cpu(raw_inode->i_dtime);
1419	/* We now have enough fields to check if the inode was active or not.
1420	* This is needed because nfsd might try to access dead inodes
1421	* the test is that same one that e2fsck uses
1422	* NeilBrown 1999oct15
1423	*/
1424	if (inode->i_nlink == 0 && (inode->i_mode == 0 || ei->i_dtime)) {
1425	/* this inode is deleted */
1426	ret = -ESTALE;
1427	goto bad_inode;
1428	}
1429	inode->i_blocks = le32_to_cpu(raw_inode->i_blocks);
1430	ei->i_flags = le32_to_cpu(raw_inode->i_flags);
1431	ext2_set_inode_flags(inode);
1432	ei->i_faddr = le32_to_cpu(raw_inode->i_faddr);
1433	ei->i_frag_no = raw_inode->i_frag;
1434	ei->i_frag_size = raw_inode->i_fsize;
1435	ei->i_file_acl = le32_to_cpu(raw_inode->i_file_acl);
1436	ei->i_dir_acl = 0;
1437
1438	if (ei->i_file_acl &&
1439	!ext2_data_block_valid(sbi: EXT2_SB(sb), start_blk: ei->i_file_acl, count: 1)) {
1440	ext2_error(sb, "ext2_iget", "bad extended attribute block %u",
1441	ei->i_file_acl);
1442	ret = -EFSCORRUPTED;
1443	goto bad_inode;
1444	}
1445
1446	if (S_ISREG(inode->i_mode))
1447	inode->i_size |= ((__u64)le32_to_cpu(raw_inode->i_size_high)) << 32;
1448	else
1449	ei->i_dir_acl = le32_to_cpu(raw_inode->i_dir_acl);
1450	if (i_size_read(inode) < 0) {
1451	ret = -EFSCORRUPTED;
1452	goto bad_inode;
1453	}
1454	ei->i_dtime = 0;
1455	inode->i_generation = le32_to_cpu(raw_inode->i_generation);
1456	ei->i_state = 0;
1457	ei->i_block_group = (ino - 1) / EXT2_INODES_PER_GROUP(inode->i_sb);
1458	ei->i_dir_start_lookup = 0;
1459
1460	/*
1461	* NOTE! The in-memory inode i_data array is in little-endian order
1462	* even on big-endian machines: we do NOT byteswap the block numbers!
1463	*/
1464	for (n = 0; n < EXT2_N_BLOCKS; n++)
1465	ei->i_data[n] = raw_inode->i_block[n];
1466
1467	if (S_ISREG(inode->i_mode)) {
1468	ext2_set_file_ops(inode);
1469	} else if (S_ISDIR(inode->i_mode)) {
1470	inode->i_op = &ext2_dir_inode_operations;
1471	inode->i_fop = &ext2_dir_operations;
1472	inode->i_mapping->a_ops = &ext2_aops;
1473	} else if (S_ISLNK(inode->i_mode)) {
1474	if (ext2_inode_is_fast_symlink(inode)) {
1475	inode->i_link = (char *)ei->i_data;
1476	inode->i_op = &ext2_fast_symlink_inode_operations;
1477	nd_terminate_link(name: ei->i_data, len: inode->i_size,
1478	maxlen: sizeof(ei->i_data) - 1);
1479	} else {
1480	inode->i_op = &ext2_symlink_inode_operations;
1481	inode_nohighmem(inode);
1482	inode->i_mapping->a_ops = &ext2_aops;
1483	}
1484	} else {
1485	inode->i_op = &ext2_special_inode_operations;
1486	if (raw_inode->i_block[0])
1487	init_special_inode(inode, inode->i_mode,
1488	old_decode_dev(le32_to_cpu(raw_inode->i_block[0])));
1489	else
1490	init_special_inode(inode, inode->i_mode,
1491	new_decode_dev(le32_to_cpu(raw_inode->i_block[1])));
1492	}
1493	brelse (bh);
1494	unlock_new_inode(inode);
1495	return inode;
1496
1497	bad_inode:
1498	brelse(bh);
1499	iget_failed(inode);
1500	return ERR_PTR(error: ret);
1501	}
1502
1503	static int __ext2_write_inode(struct inode *inode, int do_sync)
1504	{
1505	struct ext2_inode_info *ei = EXT2_I(inode);
1506	struct super_block *sb = inode->i_sb;
1507	ino_t ino = inode->i_ino;
1508	uid_t uid = i_uid_read(inode);
1509	gid_t gid = i_gid_read(inode);
1510	struct buffer_head * bh;
1511	struct ext2_inode * raw_inode = ext2_get_inode(sb, ino, p: &bh);
1512	int n;
1513	int err = 0;
1514
1515	if (IS_ERR(ptr: raw_inode))
1516	return -EIO;
1517
1518	/* For fields not tracking in the in-memory inode,
1519	* initialise them to zero for new inodes. */
1520	if (ei->i_state & EXT2_STATE_NEW)
1521	memset(raw_inode, 0, EXT2_SB(sb)->s_inode_size);
1522
1523	raw_inode->i_mode = cpu_to_le16(inode->i_mode);
1524	if (!(test_opt(sb, NO_UID32))) {
1525	raw_inode->i_uid_low = cpu_to_le16(low_16_bits(uid));
1526	raw_inode->i_gid_low = cpu_to_le16(low_16_bits(gid));
1527	/*
1528	* Fix up interoperability with old kernels. Otherwise, old inodes get
1529	* re-used with the upper 16 bits of the uid/gid intact
1530	*/
1531	if (!ei->i_dtime) {
1532	raw_inode->i_uid_high = cpu_to_le16(high_16_bits(uid));
1533	raw_inode->i_gid_high = cpu_to_le16(high_16_bits(gid));
1534	} else {
1535	raw_inode->i_uid_high = 0;
1536	raw_inode->i_gid_high = 0;
1537	}
1538	} else {
1539	raw_inode->i_uid_low = cpu_to_le16(fs_high2lowuid(uid));
1540	raw_inode->i_gid_low = cpu_to_le16(fs_high2lowgid(gid));
1541	raw_inode->i_uid_high = 0;
1542	raw_inode->i_gid_high = 0;
1543	}
1544	raw_inode->i_links_count = cpu_to_le16(inode->i_nlink);
1545	raw_inode->i_size = cpu_to_le32(inode->i_size);
1546	raw_inode->i_atime = cpu_to_le32(inode_get_atime_sec(inode));
1547	raw_inode->i_ctime = cpu_to_le32(inode_get_ctime_sec(inode));
1548	raw_inode->i_mtime = cpu_to_le32(inode_get_mtime_sec(inode));
1549
1550	raw_inode->i_blocks = cpu_to_le32(inode->i_blocks);
1551	raw_inode->i_dtime = cpu_to_le32(ei->i_dtime);
1552	raw_inode->i_flags = cpu_to_le32(ei->i_flags);
1553	raw_inode->i_faddr = cpu_to_le32(ei->i_faddr);
1554	raw_inode->i_frag = ei->i_frag_no;
1555	raw_inode->i_fsize = ei->i_frag_size;
1556	raw_inode->i_file_acl = cpu_to_le32(ei->i_file_acl);
1557	if (!S_ISREG(inode->i_mode))
1558	raw_inode->i_dir_acl = cpu_to_le32(ei->i_dir_acl);
1559	else {
1560	raw_inode->i_size_high = cpu_to_le32(inode->i_size >> 32);
1561	if (inode->i_size > 0x7fffffffULL) {
1562	if (!EXT2_HAS_RO_COMPAT_FEATURE(sb,
1563	EXT2_FEATURE_RO_COMPAT_LARGE_FILE) ||
1564	EXT2_SB(sb)->s_es->s_rev_level ==
1565	cpu_to_le32(EXT2_GOOD_OLD_REV)) {
1566	/* If this is the first large file
1567	* created, add a flag to the superblock.
1568	*/
1569	spin_lock(lock: &EXT2_SB(sb)->s_lock);
1570	ext2_update_dynamic_rev(sb);
1571	EXT2_SET_RO_COMPAT_FEATURE(sb,
1572	EXT2_FEATURE_RO_COMPAT_LARGE_FILE);
1573	spin_unlock(lock: &EXT2_SB(sb)->s_lock);
1574	ext2_sync_super(sb, es: EXT2_SB(sb)->s_es, wait: 1);
1575	}
1576	}
1577	}
1578
1579	raw_inode->i_generation = cpu_to_le32(inode->i_generation);
1580	if (S_ISCHR(inode->i_mode) || S_ISBLK(inode->i_mode)) {
1581	if (old_valid_dev(dev: inode->i_rdev)) {
1582	raw_inode->i_block[0] =
1583	cpu_to_le32(old_encode_dev(inode->i_rdev));
1584	raw_inode->i_block[1] = 0;
1585	} else {
1586	raw_inode->i_block[0] = 0;
1587	raw_inode->i_block[1] =
1588	cpu_to_le32(new_encode_dev(inode->i_rdev));
1589	raw_inode->i_block[2] = 0;
1590	}
1591	} else for (n = 0; n < EXT2_N_BLOCKS; n++)
1592	raw_inode->i_block[n] = ei->i_data[n];
1593	mark_buffer_dirty(bh);
1594	if (do_sync) {
1595	sync_dirty_buffer(bh);
1596	if (buffer_req(bh) && !buffer_uptodate(bh)) {
1597	printk ("IO error syncing ext2 inode [%s:%08lx]\n",
1598	sb->s_id, (unsigned long) ino);
1599	err = -EIO;
1600	}
1601	}
1602	ei->i_state &= ~EXT2_STATE_NEW;
1603	brelse (bh);
1604	return err;
1605	}
1606
1607	int ext2_write_inode(struct inode *inode, struct writeback_control *wbc)
1608	{
1609	return __ext2_write_inode(inode, do_sync: wbc->sync_mode == WB_SYNC_ALL);
1610	}
1611
1612	int ext2_getattr(struct mnt_idmap *idmap, const struct path *path,
1613	struct kstat *stat, u32 request_mask, unsigned int query_flags)
1614	{
1615	struct inode *inode = d_inode(dentry: path->dentry);
1616	struct ext2_inode_info *ei = EXT2_I(inode);
1617	unsigned int flags;
1618
1619	flags = ei->i_flags & EXT2_FL_USER_VISIBLE;
1620	if (flags & EXT2_APPEND_FL)
1621	stat->attributes |= STATX_ATTR_APPEND;
1622	if (flags & EXT2_COMPR_FL)
1623	stat->attributes |= STATX_ATTR_COMPRESSED;
1624	if (flags & EXT2_IMMUTABLE_FL)
1625	stat->attributes |= STATX_ATTR_IMMUTABLE;
1626	if (flags & EXT2_NODUMP_FL)
1627	stat->attributes |= STATX_ATTR_NODUMP;
1628	stat->attributes_mask |= (STATX_ATTR_APPEND |
1629	STATX_ATTR_COMPRESSED |
1630	STATX_ATTR_ENCRYPTED |
1631	STATX_ATTR_IMMUTABLE |
1632	STATX_ATTR_NODUMP);
1633
1634	generic_fillattr(&nop_mnt_idmap, request_mask, inode, stat);
1635	return 0;
1636	}
1637
1638	int ext2_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
1639	struct iattr *iattr)
1640	{
1641	struct inode *inode = d_inode(dentry);
1642	int error;
1643
1644	error = setattr_prepare(&nop_mnt_idmap, dentry, iattr);
1645	if (error)
1646	return error;
1647
1648	if (is_quota_modification(idmap: &nop_mnt_idmap, inode, ia: iattr)) {
1649	error = dquot_initialize(inode);
1650	if (error)
1651	return error;
1652	}
1653	if (i_uid_needs_update(idmap: &nop_mnt_idmap, attr: iattr, inode) ||
1654	i_gid_needs_update(idmap: &nop_mnt_idmap, attr: iattr, inode)) {
1655	error = dquot_transfer(idmap: &nop_mnt_idmap, inode, iattr);
1656	if (error)
1657	return error;
1658	}
1659	if (iattr->ia_valid & ATTR_SIZE && iattr->ia_size != inode->i_size) {
1660	error = ext2_setsize(inode, newsize: iattr->ia_size);
1661	if (error)
1662	return error;
1663	}
1664	setattr_copy(&nop_mnt_idmap, inode, attr: iattr);
1665	if (iattr->ia_valid & ATTR_MODE)
1666	error = posix_acl_chmod(&nop_mnt_idmap, dentry, inode->i_mode);
1667	mark_inode_dirty(inode);
1668
1669	return error;
1670	}
1671