• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2003-2006, Cluster File Systems, Inc, info@clusterfs.com
3  * Written by Alex Tomas <alex@clusterfs.com>
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License version 2 as
7  * published by the Free Software Foundation.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-
17  */
18 
19 
20 /*
21  * mballoc.c contains the multiblocks allocation routines
22  */
23 
24 #include "ext4_jbd2.h"
25 #include "mballoc.h"
26 #include <linux/log2.h>
27 #include <linux/module.h>
28 #include <linux/slab.h>
29 #include <linux/backing-dev.h>
30 #include <trace/events/ext4.h>
31 
32 #ifdef CONFIG_EXT4_DEBUG
33 ushort ext4_mballoc_debug __read_mostly;
34 
35 module_param_named(mballoc_debug, ext4_mballoc_debug, ushort, 0644);
36 MODULE_PARM_DESC(mballoc_debug, "Debugging level for ext4's mballoc");
37 #endif
38 
39 /*
40  * MUSTDO:
41  *   - test ext4_ext_search_left() and ext4_ext_search_right()
42  *   - search for metadata in few groups
43  *
44  * TODO v4:
45  *   - normalization should take into account whether file is still open
46  *   - discard preallocations if no free space left (policy?)
47  *   - don't normalize tails
48  *   - quota
49  *   - reservation for superuser
50  *
51  * TODO v3:
52  *   - bitmap read-ahead (proposed by Oleg Drokin aka green)
53  *   - track min/max extents in each group for better group selection
54  *   - mb_mark_used() may allocate chunk right after splitting buddy
55  *   - tree of groups sorted by number of free blocks
56  *   - error handling
57  */
58 
59 /*
60  * The allocation request involve request for multiple number of blocks
61  * near to the goal(block) value specified.
62  *
63  * During initialization phase of the allocator we decide to use the
64  * group preallocation or inode preallocation depending on the size of
65  * the file. The size of the file could be the resulting file size we
66  * would have after allocation, or the current file size, which ever
67  * is larger. If the size is less than sbi->s_mb_stream_request we
68  * select to use the group preallocation. The default value of
69  * s_mb_stream_request is 16 blocks. This can also be tuned via
70  * /sys/fs/ext4/<partition>/mb_stream_req. The value is represented in
71  * terms of number of blocks.
72  *
73  * The main motivation for having small file use group preallocation is to
74  * ensure that we have small files closer together on the disk.
75  *
76  * First stage the allocator looks at the inode prealloc list,
77  * ext4_inode_info->i_prealloc_list, which contains list of prealloc
78  * spaces for this particular inode. The inode prealloc space is
79  * represented as:
80  *
81  * pa_lstart -> the logical start block for this prealloc space
82  * pa_pstart -> the physical start block for this prealloc space
83  * pa_len    -> length for this prealloc space (in clusters)
84  * pa_free   ->  free space available in this prealloc space (in clusters)
85  *
86  * The inode preallocation space is used looking at the _logical_ start
87  * block. If only the logical file block falls within the range of prealloc
88  * space we will consume the particular prealloc space. This makes sure that
89  * we have contiguous physical blocks representing the file blocks
90  *
91  * The important thing to be noted in case of inode prealloc space is that
92  * we don't modify the values associated to inode prealloc space except
93  * pa_free.
94  *
95  * If we are not able to find blocks in the inode prealloc space and if we
96  * have the group allocation flag set then we look at the locality group
97  * prealloc space. These are per CPU prealloc list represented as
98  *
99  * ext4_sb_info.s_locality_groups[smp_processor_id()]
100  *
101  * The reason for having a per cpu locality group is to reduce the contention
102  * between CPUs. It is possible to get scheduled at this point.
103  *
104  * The locality group prealloc space is used looking at whether we have
105  * enough free space (pa_free) within the prealloc space.
106  *
107  * If we can't allocate blocks via inode prealloc or/and locality group
108  * prealloc then we look at the buddy cache. The buddy cache is represented
109  * by ext4_sb_info.s_buddy_cache (struct inode) whose file offset gets
110  * mapped to the buddy and bitmap information regarding different
111  * groups. The buddy information is attached to buddy cache inode so that
112  * we can access them through the page cache. The information regarding
113  * each group is loaded via ext4_mb_load_buddy.  The information involve
114  * block bitmap and buddy information. The information are stored in the
115  * inode as:
116  *
117  *  {                        page                        }
118  *  [ group 0 bitmap][ group 0 buddy] [group 1][ group 1]...
119  *
120  *
121  * one block each for bitmap and buddy information.  So for each group we
122  * take up 2 blocks. A page can contain blocks_per_page (PAGE_SIZE /
123  * blocksize) blocks.  So it can have information regarding groups_per_page
124  * which is blocks_per_page/2
125  *
126  * The buddy cache inode is not stored on disk. The inode is thrown
127  * away when the filesystem is unmounted.
128  *
129  * We look for count number of blocks in the buddy cache. If we were able
130  * to locate that many free blocks we return with additional information
131  * regarding rest of the contiguous physical block available
132  *
133  * Before allocating blocks via buddy cache we normalize the request
134  * blocks. This ensure we ask for more blocks that we needed. The extra
135  * blocks that we get after allocation is added to the respective prealloc
136  * list. In case of inode preallocation we follow a list of heuristics
137  * based on file size. This can be found in ext4_mb_normalize_request. If
138  * we are doing a group prealloc we try to normalize the request to
139  * sbi->s_mb_group_prealloc.  The default value of s_mb_group_prealloc is
140  * dependent on the cluster size; for non-bigalloc file systems, it is
141  * 512 blocks. This can be tuned via
142  * /sys/fs/ext4/<partition>/mb_group_prealloc. The value is represented in
143  * terms of number of blocks. If we have mounted the file system with -O
144  * stripe=<value> option the group prealloc request is normalized to the
145  * the smallest multiple of the stripe value (sbi->s_stripe) which is
146  * greater than the default mb_group_prealloc.
147  *
148  * The regular allocator (using the buddy cache) supports a few tunables.
149  *
150  * /sys/fs/ext4/<partition>/mb_min_to_scan
151  * /sys/fs/ext4/<partition>/mb_max_to_scan
152  * /sys/fs/ext4/<partition>/mb_order2_req
153  *
154  * The regular allocator uses buddy scan only if the request len is power of
155  * 2 blocks and the order of allocation is >= sbi->s_mb_order2_reqs. The
156  * value of s_mb_order2_reqs can be tuned via
157  * /sys/fs/ext4/<partition>/mb_order2_req.  If the request len is equal to
158  * stripe size (sbi->s_stripe), we try to search for contiguous block in
159  * stripe size. This should result in better allocation on RAID setups. If
160  * not, we search in the specific group using bitmap for best extents. The
161  * tunable min_to_scan and max_to_scan control the behaviour here.
162  * min_to_scan indicate how long the mballoc __must__ look for a best
163  * extent and max_to_scan indicates how long the mballoc __can__ look for a
164  * best extent in the found extents. Searching for the blocks starts with
165  * the group specified as the goal value in allocation context via
166  * ac_g_ex. Each group is first checked based on the criteria whether it
167  * can be used for allocation. ext4_mb_good_group explains how the groups are
168  * checked.
169  *
170  * Both the prealloc space are getting populated as above. So for the first
171  * request we will hit the buddy cache which will result in this prealloc
172  * space getting filled. The prealloc space is then later used for the
173  * subsequent request.
174  */
175 
176 /*
177  * mballoc operates on the following data:
178  *  - on-disk bitmap
179  *  - in-core buddy (actually includes buddy and bitmap)
180  *  - preallocation descriptors (PAs)
181  *
182  * there are two types of preallocations:
183  *  - inode
184  *    assiged to specific inode and can be used for this inode only.
185  *    it describes part of inode's space preallocated to specific
186  *    physical blocks. any block from that preallocated can be used
187  *    independent. the descriptor just tracks number of blocks left
188  *    unused. so, before taking some block from descriptor, one must
189  *    make sure corresponded logical block isn't allocated yet. this
190  *    also means that freeing any block within descriptor's range
191  *    must discard all preallocated blocks.
192  *  - locality group
193  *    assigned to specific locality group which does not translate to
194  *    permanent set of inodes: inode can join and leave group. space
195  *    from this type of preallocation can be used for any inode. thus
196  *    it's consumed from the beginning to the end.
197  *
198  * relation between them can be expressed as:
199  *    in-core buddy = on-disk bitmap + preallocation descriptors
200  *
201  * this mean blocks mballoc considers used are:
202  *  - allocated blocks (persistent)
203  *  - preallocated blocks (non-persistent)
204  *
205  * consistency in mballoc world means that at any time a block is either
206  * free or used in ALL structures. notice: "any time" should not be read
207  * literally -- time is discrete and delimited by locks.
208  *
209  *  to keep it simple, we don't use block numbers, instead we count number of
210  *  blocks: how many blocks marked used/free in on-disk bitmap, buddy and PA.
211  *
212  * all operations can be expressed as:
213  *  - init buddy:			buddy = on-disk + PAs
214  *  - new PA:				buddy += N; PA = N
215  *  - use inode PA:			on-disk += N; PA -= N
216  *  - discard inode PA			buddy -= on-disk - PA; PA = 0
217  *  - use locality group PA		on-disk += N; PA -= N
218  *  - discard locality group PA		buddy -= PA; PA = 0
219  *  note: 'buddy -= on-disk - PA' is used to show that on-disk bitmap
220  *        is used in real operation because we can't know actual used
221  *        bits from PA, only from on-disk bitmap
222  *
223  * if we follow this strict logic, then all operations above should be atomic.
224  * given some of them can block, we'd have to use something like semaphores
225  * killing performance on high-end SMP hardware. let's try to relax it using
226  * the following knowledge:
227  *  1) if buddy is referenced, it's already initialized
228  *  2) while block is used in buddy and the buddy is referenced,
229  *     nobody can re-allocate that block
230  *  3) we work on bitmaps and '+' actually means 'set bits'. if on-disk has
231  *     bit set and PA claims same block, it's OK. IOW, one can set bit in
232  *     on-disk bitmap if buddy has same bit set or/and PA covers corresponded
233  *     block
234  *
235  * so, now we're building a concurrency table:
236  *  - init buddy vs.
237  *    - new PA
238  *      blocks for PA are allocated in the buddy, buddy must be referenced
239  *      until PA is linked to allocation group to avoid concurrent buddy init
240  *    - use inode PA
241  *      we need to make sure that either on-disk bitmap or PA has uptodate data
242  *      given (3) we care that PA-=N operation doesn't interfere with init
243  *    - discard inode PA
244  *      the simplest way would be to have buddy initialized by the discard
245  *    - use locality group PA
246  *      again PA-=N must be serialized with init
247  *    - discard locality group PA
248  *      the simplest way would be to have buddy initialized by the discard
249  *  - new PA vs.
250  *    - use inode PA
251  *      i_data_sem serializes them
252  *    - discard inode PA
253  *      discard process must wait until PA isn't used by another process
254  *    - use locality group PA
255  *      some mutex should serialize them
256  *    - discard locality group PA
257  *      discard process must wait until PA isn't used by another process
258  *  - use inode PA
259  *    - use inode PA
260  *      i_data_sem or another mutex should serializes them
261  *    - discard inode PA
262  *      discard process must wait until PA isn't used by another process
263  *    - use locality group PA
264  *      nothing wrong here -- they're different PAs covering different blocks
265  *    - discard locality group PA
266  *      discard process must wait until PA isn't used by another process
267  *
268  * now we're ready to make few consequences:
269  *  - PA is referenced and while it is no discard is possible
270  *  - PA is referenced until block isn't marked in on-disk bitmap
271  *  - PA changes only after on-disk bitmap
272  *  - discard must not compete with init. either init is done before
273  *    any discard or they're serialized somehow
274  *  - buddy init as sum of on-disk bitmap and PAs is done atomically
275  *
276  * a special case when we've used PA to emptiness. no need to modify buddy
277  * in this case, but we should care about concurrent init
278  *
279  */
280 
281  /*
282  * Logic in few words:
283  *
284  *  - allocation:
285  *    load group
286  *    find blocks
287  *    mark bits in on-disk bitmap
288  *    release group
289  *
290  *  - use preallocation:
291  *    find proper PA (per-inode or group)
292  *    load group
293  *    mark bits in on-disk bitmap
294  *    release group
295  *    release PA
296  *
297  *  - free:
298  *    load group
299  *    mark bits in on-disk bitmap
300  *    release group
301  *
302  *  - discard preallocations in group:
303  *    mark PAs deleted
304  *    move them onto local list
305  *    load on-disk bitmap
306  *    load group
307  *    remove PA from object (inode or locality group)
308  *    mark free blocks in-core
309  *
310  *  - discard inode's preallocations:
311  */
312 
313 /*
314  * Locking rules
315  *
316  * Locks:
317  *  - bitlock on a group	(group)
318  *  - object (inode/locality)	(object)
319  *  - per-pa lock		(pa)
320  *
321  * Paths:
322  *  - new pa
323  *    object
324  *    group
325  *
326  *  - find and use pa:
327  *    pa
328  *
329  *  - release consumed pa:
330  *    pa
331  *    group
332  *    object
333  *
334  *  - generate in-core bitmap:
335  *    group
336  *        pa
337  *
338  *  - discard all for given object (inode, locality group):
339  *    object
340  *        pa
341  *    group
342  *
343  *  - discard all for given group:
344  *    group
345  *        pa
346  *    group
347  *        object
348  *
349  */
350 static struct kmem_cache *ext4_pspace_cachep;
351 static struct kmem_cache *ext4_ac_cachep;
352 static struct kmem_cache *ext4_free_data_cachep;
353 
354 /* We create slab caches for groupinfo data structures based on the
355  * superblock block size.  There will be one per mounted filesystem for
356  * each unique s_blocksize_bits */
357 #define NR_GRPINFO_CACHES 8
358 static struct kmem_cache *ext4_groupinfo_caches[NR_GRPINFO_CACHES];
359 
360 static const char *ext4_groupinfo_slab_names[NR_GRPINFO_CACHES] = {
361 	"ext4_groupinfo_1k", "ext4_groupinfo_2k", "ext4_groupinfo_4k",
362 	"ext4_groupinfo_8k", "ext4_groupinfo_16k", "ext4_groupinfo_32k",
363 	"ext4_groupinfo_64k", "ext4_groupinfo_128k"
364 };
365 
366 static void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
367 					ext4_group_t group);
368 static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
369 						ext4_group_t group);
370 static void ext4_free_data_callback(struct super_block *sb,
371 				struct ext4_journal_cb_entry *jce, int rc);
372 
mb_correct_addr_and_bit(int * bit,void * addr)373 static inline void *mb_correct_addr_and_bit(int *bit, void *addr)
374 {
375 #if BITS_PER_LONG == 64
376 	*bit += ((unsigned long) addr & 7UL) << 3;
377 	addr = (void *) ((unsigned long) addr & ~7UL);
378 #elif BITS_PER_LONG == 32
379 	*bit += ((unsigned long) addr & 3UL) << 3;
380 	addr = (void *) ((unsigned long) addr & ~3UL);
381 #else
382 #error "how many bits you are?!"
383 #endif
384 	return addr;
385 }
386 
mb_test_bit(int bit,void * addr)387 static inline int mb_test_bit(int bit, void *addr)
388 {
389 	/*
390 	 * ext4_test_bit on architecture like powerpc
391 	 * needs unsigned long aligned address
392 	 */
393 	addr = mb_correct_addr_and_bit(&bit, addr);
394 	return ext4_test_bit(bit, addr);
395 }
396 
mb_set_bit(int bit,void * addr)397 static inline void mb_set_bit(int bit, void *addr)
398 {
399 	addr = mb_correct_addr_and_bit(&bit, addr);
400 	ext4_set_bit(bit, addr);
401 }
402 
mb_clear_bit(int bit,void * addr)403 static inline void mb_clear_bit(int bit, void *addr)
404 {
405 	addr = mb_correct_addr_and_bit(&bit, addr);
406 	ext4_clear_bit(bit, addr);
407 }
408 
mb_test_and_clear_bit(int bit,void * addr)409 static inline int mb_test_and_clear_bit(int bit, void *addr)
410 {
411 	addr = mb_correct_addr_and_bit(&bit, addr);
412 	return ext4_test_and_clear_bit(bit, addr);
413 }
414 
mb_find_next_zero_bit(void * addr,int max,int start)415 static inline int mb_find_next_zero_bit(void *addr, int max, int start)
416 {
417 	int fix = 0, ret, tmpmax;
418 	addr = mb_correct_addr_and_bit(&fix, addr);
419 	tmpmax = max + fix;
420 	start += fix;
421 
422 	ret = ext4_find_next_zero_bit(addr, tmpmax, start) - fix;
423 	if (ret > max)
424 		return max;
425 	return ret;
426 }
427 
mb_find_next_bit(void * addr,int max,int start)428 static inline int mb_find_next_bit(void *addr, int max, int start)
429 {
430 	int fix = 0, ret, tmpmax;
431 	addr = mb_correct_addr_and_bit(&fix, addr);
432 	tmpmax = max + fix;
433 	start += fix;
434 
435 	ret = ext4_find_next_bit(addr, tmpmax, start) - fix;
436 	if (ret > max)
437 		return max;
438 	return ret;
439 }
440 
mb_find_buddy(struct ext4_buddy * e4b,int order,int * max)441 static void *mb_find_buddy(struct ext4_buddy *e4b, int order, int *max)
442 {
443 	char *bb;
444 
445 	BUG_ON(e4b->bd_bitmap == e4b->bd_buddy);
446 	BUG_ON(max == NULL);
447 
448 	if (order > e4b->bd_blkbits + 1) {
449 		*max = 0;
450 		return NULL;
451 	}
452 
453 	/* at order 0 we see each particular block */
454 	if (order == 0) {
455 		*max = 1 << (e4b->bd_blkbits + 3);
456 		return e4b->bd_bitmap;
457 	}
458 
459 	bb = e4b->bd_buddy + EXT4_SB(e4b->bd_sb)->s_mb_offsets[order];
460 	*max = EXT4_SB(e4b->bd_sb)->s_mb_maxs[order];
461 
462 	return bb;
463 }
464 
465 #ifdef DOUBLE_CHECK
mb_free_blocks_double(struct inode * inode,struct ext4_buddy * e4b,int first,int count)466 static void mb_free_blocks_double(struct inode *inode, struct ext4_buddy *e4b,
467 			   int first, int count)
468 {
469 	int i;
470 	struct super_block *sb = e4b->bd_sb;
471 
472 	if (unlikely(e4b->bd_info->bb_bitmap == NULL))
473 		return;
474 	assert_spin_locked(ext4_group_lock_ptr(sb, e4b->bd_group));
475 	for (i = 0; i < count; i++) {
476 		if (!mb_test_bit(first + i, e4b->bd_info->bb_bitmap)) {
477 			ext4_fsblk_t blocknr;
478 
479 			blocknr = ext4_group_first_block_no(sb, e4b->bd_group);
480 			blocknr += EXT4_C2B(EXT4_SB(sb), first + i);
481 			ext4_grp_locked_error(sb, e4b->bd_group,
482 					      inode ? inode->i_ino : 0,
483 					      blocknr,
484 					      "freeing block already freed "
485 					      "(bit %u)",
486 					      first + i);
487 		}
488 		mb_clear_bit(first + i, e4b->bd_info->bb_bitmap);
489 	}
490 }
491 
mb_mark_used_double(struct ext4_buddy * e4b,int first,int count)492 static void mb_mark_used_double(struct ext4_buddy *e4b, int first, int count)
493 {
494 	int i;
495 
496 	if (unlikely(e4b->bd_info->bb_bitmap == NULL))
497 		return;
498 	assert_spin_locked(ext4_group_lock_ptr(e4b->bd_sb, e4b->bd_group));
499 	for (i = 0; i < count; i++) {
500 		BUG_ON(mb_test_bit(first + i, e4b->bd_info->bb_bitmap));
501 		mb_set_bit(first + i, e4b->bd_info->bb_bitmap);
502 	}
503 }
504 
mb_cmp_bitmaps(struct ext4_buddy * e4b,void * bitmap)505 static void mb_cmp_bitmaps(struct ext4_buddy *e4b, void *bitmap)
506 {
507 	if (memcmp(e4b->bd_info->bb_bitmap, bitmap, e4b->bd_sb->s_blocksize)) {
508 		unsigned char *b1, *b2;
509 		int i;
510 		b1 = (unsigned char *) e4b->bd_info->bb_bitmap;
511 		b2 = (unsigned char *) bitmap;
512 		for (i = 0; i < e4b->bd_sb->s_blocksize; i++) {
513 			if (b1[i] != b2[i]) {
514 				ext4_msg(e4b->bd_sb, KERN_ERR,
515 					 "corruption in group %u "
516 					 "at byte %u(%u): %x in copy != %x "
517 					 "on disk/prealloc",
518 					 e4b->bd_group, i, i * 8, b1[i], b2[i]);
519 				BUG();
520 			}
521 		}
522 	}
523 }
524 
525 #else
mb_free_blocks_double(struct inode * inode,struct ext4_buddy * e4b,int first,int count)526 static inline void mb_free_blocks_double(struct inode *inode,
527 				struct ext4_buddy *e4b, int first, int count)
528 {
529 	return;
530 }
mb_mark_used_double(struct ext4_buddy * e4b,int first,int count)531 static inline void mb_mark_used_double(struct ext4_buddy *e4b,
532 						int first, int count)
533 {
534 	return;
535 }
mb_cmp_bitmaps(struct ext4_buddy * e4b,void * bitmap)536 static inline void mb_cmp_bitmaps(struct ext4_buddy *e4b, void *bitmap)
537 {
538 	return;
539 }
540 #endif
541 
542 #ifdef AGGRESSIVE_CHECK
543 
544 #define MB_CHECK_ASSERT(assert)						\
545 do {									\
546 	if (!(assert)) {						\
547 		printk(KERN_EMERG					\
548 			"Assertion failure in %s() at %s:%d: \"%s\"\n",	\
549 			function, file, line, # assert);		\
550 		BUG();							\
551 	}								\
552 } while (0)
553 
__mb_check_buddy(struct ext4_buddy * e4b,char * file,const char * function,int line)554 static int __mb_check_buddy(struct ext4_buddy *e4b, char *file,
555 				const char *function, int line)
556 {
557 	struct super_block *sb = e4b->bd_sb;
558 	int order = e4b->bd_blkbits + 1;
559 	int max;
560 	int max2;
561 	int i;
562 	int j;
563 	int k;
564 	int count;
565 	struct ext4_group_info *grp;
566 	int fragments = 0;
567 	int fstart;
568 	struct list_head *cur;
569 	void *buddy;
570 	void *buddy2;
571 
572 	{
573 		static int mb_check_counter;
574 		if (mb_check_counter++ % 100 != 0)
575 			return 0;
576 	}
577 
578 	while (order > 1) {
579 		buddy = mb_find_buddy(e4b, order, &max);
580 		MB_CHECK_ASSERT(buddy);
581 		buddy2 = mb_find_buddy(e4b, order - 1, &max2);
582 		MB_CHECK_ASSERT(buddy2);
583 		MB_CHECK_ASSERT(buddy != buddy2);
584 		MB_CHECK_ASSERT(max * 2 == max2);
585 
586 		count = 0;
587 		for (i = 0; i < max; i++) {
588 
589 			if (mb_test_bit(i, buddy)) {
590 				/* only single bit in buddy2 may be 1 */
591 				if (!mb_test_bit(i << 1, buddy2)) {
592 					MB_CHECK_ASSERT(
593 						mb_test_bit((i<<1)+1, buddy2));
594 				} else if (!mb_test_bit((i << 1) + 1, buddy2)) {
595 					MB_CHECK_ASSERT(
596 						mb_test_bit(i << 1, buddy2));
597 				}
598 				continue;
599 			}
600 
601 			/* both bits in buddy2 must be 1 */
602 			MB_CHECK_ASSERT(mb_test_bit(i << 1, buddy2));
603 			MB_CHECK_ASSERT(mb_test_bit((i << 1) + 1, buddy2));
604 
605 			for (j = 0; j < (1 << order); j++) {
606 				k = (i * (1 << order)) + j;
607 				MB_CHECK_ASSERT(
608 					!mb_test_bit(k, e4b->bd_bitmap));
609 			}
610 			count++;
611 		}
612 		MB_CHECK_ASSERT(e4b->bd_info->bb_counters[order] == count);
613 		order--;
614 	}
615 
616 	fstart = -1;
617 	buddy = mb_find_buddy(e4b, 0, &max);
618 	for (i = 0; i < max; i++) {
619 		if (!mb_test_bit(i, buddy)) {
620 			MB_CHECK_ASSERT(i >= e4b->bd_info->bb_first_free);
621 			if (fstart == -1) {
622 				fragments++;
623 				fstart = i;
624 			}
625 			continue;
626 		}
627 		fstart = -1;
628 		/* check used bits only */
629 		for (j = 0; j < e4b->bd_blkbits + 1; j++) {
630 			buddy2 = mb_find_buddy(e4b, j, &max2);
631 			k = i >> j;
632 			MB_CHECK_ASSERT(k < max2);
633 			MB_CHECK_ASSERT(mb_test_bit(k, buddy2));
634 		}
635 	}
636 	MB_CHECK_ASSERT(!EXT4_MB_GRP_NEED_INIT(e4b->bd_info));
637 	MB_CHECK_ASSERT(e4b->bd_info->bb_fragments == fragments);
638 
639 	grp = ext4_get_group_info(sb, e4b->bd_group);
640 	list_for_each(cur, &grp->bb_prealloc_list) {
641 		ext4_group_t groupnr;
642 		struct ext4_prealloc_space *pa;
643 		pa = list_entry(cur, struct ext4_prealloc_space, pa_group_list);
644 		ext4_get_group_no_and_offset(sb, pa->pa_pstart, &groupnr, &k);
645 		MB_CHECK_ASSERT(groupnr == e4b->bd_group);
646 		for (i = 0; i < pa->pa_len; i++)
647 			MB_CHECK_ASSERT(mb_test_bit(k + i, buddy));
648 	}
649 	return 0;
650 }
651 #undef MB_CHECK_ASSERT
652 #define mb_check_buddy(e4b) __mb_check_buddy(e4b,	\
653 					__FILE__, __func__, __LINE__)
654 #else
655 #define mb_check_buddy(e4b)
656 #endif
657 
658 /*
659  * Divide blocks started from @first with length @len into
660  * smaller chunks with power of 2 blocks.
661  * Clear the bits in bitmap which the blocks of the chunk(s) covered,
662  * then increase bb_counters[] for corresponded chunk size.
663  */
ext4_mb_mark_free_simple(struct super_block * sb,void * buddy,ext4_grpblk_t first,ext4_grpblk_t len,struct ext4_group_info * grp)664 static void ext4_mb_mark_free_simple(struct super_block *sb,
665 				void *buddy, ext4_grpblk_t first, ext4_grpblk_t len,
666 					struct ext4_group_info *grp)
667 {
668 	struct ext4_sb_info *sbi = EXT4_SB(sb);
669 	ext4_grpblk_t min;
670 	ext4_grpblk_t max;
671 	ext4_grpblk_t chunk;
672 	unsigned int border;
673 
674 	BUG_ON(len > EXT4_CLUSTERS_PER_GROUP(sb));
675 
676 	border = 2 << sb->s_blocksize_bits;
677 
678 	while (len > 0) {
679 		/* find how many blocks can be covered since this position */
680 		max = ffs(first | border) - 1;
681 
682 		/* find how many blocks of power 2 we need to mark */
683 		min = fls(len) - 1;
684 
685 		if (max < min)
686 			min = max;
687 		chunk = 1 << min;
688 
689 		/* mark multiblock chunks only */
690 		grp->bb_counters[min]++;
691 		if (min > 0)
692 			mb_clear_bit(first >> min,
693 				     buddy + sbi->s_mb_offsets[min]);
694 
695 		len -= chunk;
696 		first += chunk;
697 	}
698 }
699 
700 /*
701  * Cache the order of the largest free extent we have available in this block
702  * group.
703  */
704 static void
mb_set_largest_free_order(struct super_block * sb,struct ext4_group_info * grp)705 mb_set_largest_free_order(struct super_block *sb, struct ext4_group_info *grp)
706 {
707 	int i;
708 	int bits;
709 
710 	grp->bb_largest_free_order = -1; /* uninit */
711 
712 	bits = sb->s_blocksize_bits + 1;
713 	for (i = bits; i >= 0; i--) {
714 		if (grp->bb_counters[i] > 0) {
715 			grp->bb_largest_free_order = i;
716 			break;
717 		}
718 	}
719 }
720 
721 static noinline_for_stack
ext4_mb_generate_buddy(struct super_block * sb,void * buddy,void * bitmap,ext4_group_t group)722 void ext4_mb_generate_buddy(struct super_block *sb,
723 				void *buddy, void *bitmap, ext4_group_t group)
724 {
725 	struct ext4_group_info *grp = ext4_get_group_info(sb, group);
726 	struct ext4_sb_info *sbi = EXT4_SB(sb);
727 	ext4_grpblk_t max = EXT4_CLUSTERS_PER_GROUP(sb);
728 	ext4_grpblk_t i = 0;
729 	ext4_grpblk_t first;
730 	ext4_grpblk_t len;
731 	unsigned free = 0;
732 	unsigned fragments = 0;
733 	unsigned long long period = get_cycles();
734 
735 	/* initialize buddy from bitmap which is aggregation
736 	 * of on-disk bitmap and preallocations */
737 	i = mb_find_next_zero_bit(bitmap, max, 0);
738 	grp->bb_first_free = i;
739 	while (i < max) {
740 		fragments++;
741 		first = i;
742 		i = mb_find_next_bit(bitmap, max, i);
743 		len = i - first;
744 		free += len;
745 		if (len > 1)
746 			ext4_mb_mark_free_simple(sb, buddy, first, len, grp);
747 		else
748 			grp->bb_counters[0]++;
749 		if (i < max)
750 			i = mb_find_next_zero_bit(bitmap, max, i);
751 	}
752 	grp->bb_fragments = fragments;
753 
754 	if (free != grp->bb_free) {
755 		ext4_grp_locked_error(sb, group, 0, 0,
756 				      "block bitmap and bg descriptor "
757 				      "inconsistent: %u vs %u free clusters",
758 				      free, grp->bb_free);
759 		/*
760 		 * If we intend to continue, we consider group descriptor
761 		 * corrupt and update bb_free using bitmap value
762 		 */
763 		grp->bb_free = free;
764 		if (!EXT4_MB_GRP_BBITMAP_CORRUPT(grp))
765 			percpu_counter_sub(&sbi->s_freeclusters_counter,
766 					   grp->bb_free);
767 		set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT, &grp->bb_state);
768 	}
769 	mb_set_largest_free_order(sb, grp);
770 
771 	clear_bit(EXT4_GROUP_INFO_NEED_INIT_BIT, &(grp->bb_state));
772 
773 	period = get_cycles() - period;
774 	spin_lock(&EXT4_SB(sb)->s_bal_lock);
775 	EXT4_SB(sb)->s_mb_buddies_generated++;
776 	EXT4_SB(sb)->s_mb_generation_time += period;
777 	spin_unlock(&EXT4_SB(sb)->s_bal_lock);
778 }
779 
mb_regenerate_buddy(struct ext4_buddy * e4b)780 static void mb_regenerate_buddy(struct ext4_buddy *e4b)
781 {
782 	int count;
783 	int order = 1;
784 	void *buddy;
785 
786 	while ((buddy = mb_find_buddy(e4b, order++, &count))) {
787 		ext4_set_bits(buddy, 0, count);
788 	}
789 	e4b->bd_info->bb_fragments = 0;
790 	memset(e4b->bd_info->bb_counters, 0,
791 		sizeof(*e4b->bd_info->bb_counters) *
792 		(e4b->bd_sb->s_blocksize_bits + 2));
793 
794 	ext4_mb_generate_buddy(e4b->bd_sb, e4b->bd_buddy,
795 		e4b->bd_bitmap, e4b->bd_group);
796 }
797 
798 /* The buddy information is attached the buddy cache inode
799  * for convenience. The information regarding each group
800  * is loaded via ext4_mb_load_buddy. The information involve
801  * block bitmap and buddy information. The information are
802  * stored in the inode as
803  *
804  * {                        page                        }
805  * [ group 0 bitmap][ group 0 buddy] [group 1][ group 1]...
806  *
807  *
808  * one block each for bitmap and buddy information.
809  * So for each group we take up 2 blocks. A page can
810  * contain blocks_per_page (PAGE_SIZE / blocksize)  blocks.
811  * So it can have information regarding groups_per_page which
812  * is blocks_per_page/2
813  *
814  * Locking note:  This routine takes the block group lock of all groups
815  * for this page; do not hold this lock when calling this routine!
816  */
817 
ext4_mb_init_cache(struct page * page,char * incore,gfp_t gfp)818 static int ext4_mb_init_cache(struct page *page, char *incore, gfp_t gfp)
819 {
820 	ext4_group_t ngroups;
821 	int blocksize;
822 	int blocks_per_page;
823 	int groups_per_page;
824 	int err = 0;
825 	int i;
826 	ext4_group_t first_group, group;
827 	int first_block;
828 	struct super_block *sb;
829 	struct buffer_head *bhs;
830 	struct buffer_head **bh = NULL;
831 	struct inode *inode;
832 	char *data;
833 	char *bitmap;
834 	struct ext4_group_info *grinfo;
835 
836 	mb_debug(1, "init page %lu\n", page->index);
837 
838 	inode = page->mapping->host;
839 	sb = inode->i_sb;
840 	ngroups = ext4_get_groups_count(sb);
841 	blocksize = i_blocksize(inode);
842 	blocks_per_page = PAGE_SIZE / blocksize;
843 
844 	groups_per_page = blocks_per_page >> 1;
845 	if (groups_per_page == 0)
846 		groups_per_page = 1;
847 
848 	/* allocate buffer_heads to read bitmaps */
849 	if (groups_per_page > 1) {
850 		i = sizeof(struct buffer_head *) * groups_per_page;
851 		bh = kzalloc(i, gfp);
852 		if (bh == NULL) {
853 			err = -ENOMEM;
854 			goto out;
855 		}
856 	} else
857 		bh = &bhs;
858 
859 	first_group = page->index * blocks_per_page / 2;
860 
861 	/* read all groups the page covers into the cache */
862 	for (i = 0, group = first_group; i < groups_per_page; i++, group++) {
863 		if (group >= ngroups)
864 			break;
865 
866 		grinfo = ext4_get_group_info(sb, group);
867 		/*
868 		 * If page is uptodate then we came here after online resize
869 		 * which added some new uninitialized group info structs, so
870 		 * we must skip all initialized uptodate buddies on the page,
871 		 * which may be currently in use by an allocating task.
872 		 */
873 		if (PageUptodate(page) && !EXT4_MB_GRP_NEED_INIT(grinfo)) {
874 			bh[i] = NULL;
875 			continue;
876 		}
877 		bh[i] = ext4_read_block_bitmap_nowait(sb, group);
878 		if (IS_ERR(bh[i])) {
879 			err = PTR_ERR(bh[i]);
880 			bh[i] = NULL;
881 			goto out;
882 		}
883 		mb_debug(1, "read bitmap for group %u\n", group);
884 	}
885 
886 	/* wait for I/O completion */
887 	for (i = 0, group = first_group; i < groups_per_page; i++, group++) {
888 		int err2;
889 
890 		if (!bh[i])
891 			continue;
892 		err2 = ext4_wait_block_bitmap(sb, group, bh[i]);
893 		if (!err)
894 			err = err2;
895 	}
896 
897 	first_block = page->index * blocks_per_page;
898 	for (i = 0; i < blocks_per_page; i++) {
899 		group = (first_block + i) >> 1;
900 		if (group >= ngroups)
901 			break;
902 
903 		if (!bh[group - first_group])
904 			/* skip initialized uptodate buddy */
905 			continue;
906 
907 		if (!buffer_verified(bh[group - first_group]))
908 			/* Skip faulty bitmaps */
909 			continue;
910 		err = 0;
911 
912 		/*
913 		 * data carry information regarding this
914 		 * particular group in the format specified
915 		 * above
916 		 *
917 		 */
918 		data = page_address(page) + (i * blocksize);
919 		bitmap = bh[group - first_group]->b_data;
920 
921 		/*
922 		 * We place the buddy block and bitmap block
923 		 * close together
924 		 */
925 		if ((first_block + i) & 1) {
926 			/* this is block of buddy */
927 			BUG_ON(incore == NULL);
928 			mb_debug(1, "put buddy for group %u in page %lu/%x\n",
929 				group, page->index, i * blocksize);
930 			trace_ext4_mb_buddy_bitmap_load(sb, group);
931 			grinfo = ext4_get_group_info(sb, group);
932 			grinfo->bb_fragments = 0;
933 			memset(grinfo->bb_counters, 0,
934 			       sizeof(*grinfo->bb_counters) *
935 				(sb->s_blocksize_bits+2));
936 			/*
937 			 * incore got set to the group block bitmap below
938 			 */
939 			ext4_lock_group(sb, group);
940 			/* init the buddy */
941 			memset(data, 0xff, blocksize);
942 			ext4_mb_generate_buddy(sb, data, incore, group);
943 			ext4_unlock_group(sb, group);
944 			incore = NULL;
945 		} else {
946 			/* this is block of bitmap */
947 			BUG_ON(incore != NULL);
948 			mb_debug(1, "put bitmap for group %u in page %lu/%x\n",
949 				group, page->index, i * blocksize);
950 			trace_ext4_mb_bitmap_load(sb, group);
951 
952 			/* see comments in ext4_mb_put_pa() */
953 			ext4_lock_group(sb, group);
954 			memcpy(data, bitmap, blocksize);
955 
956 			/* mark all preallocated blks used in in-core bitmap */
957 			ext4_mb_generate_from_pa(sb, data, group);
958 			ext4_mb_generate_from_freelist(sb, data, group);
959 			ext4_unlock_group(sb, group);
960 
961 			/* set incore so that the buddy information can be
962 			 * generated using this
963 			 */
964 			incore = data;
965 		}
966 	}
967 	SetPageUptodate(page);
968 
969 out:
970 	if (bh) {
971 		for (i = 0; i < groups_per_page; i++)
972 			brelse(bh[i]);
973 		if (bh != &bhs)
974 			kfree(bh);
975 	}
976 	return err;
977 }
978 
979 /*
980  * Lock the buddy and bitmap pages. This make sure other parallel init_group
981  * on the same buddy page doesn't happen whild holding the buddy page lock.
982  * Return locked buddy and bitmap pages on e4b struct. If buddy and bitmap
983  * are on the same page e4b->bd_buddy_page is NULL and return value is 0.
984  */
ext4_mb_get_buddy_page_lock(struct super_block * sb,ext4_group_t group,struct ext4_buddy * e4b,gfp_t gfp)985 static int ext4_mb_get_buddy_page_lock(struct super_block *sb,
986 		ext4_group_t group, struct ext4_buddy *e4b, gfp_t gfp)
987 {
988 	struct inode *inode = EXT4_SB(sb)->s_buddy_cache;
989 	int block, pnum, poff;
990 	int blocks_per_page;
991 	struct page *page;
992 
993 	e4b->bd_buddy_page = NULL;
994 	e4b->bd_bitmap_page = NULL;
995 
996 	blocks_per_page = PAGE_SIZE / sb->s_blocksize;
997 	/*
998 	 * the buddy cache inode stores the block bitmap
999 	 * and buddy information in consecutive blocks.
1000 	 * So for each group we need two blocks.
1001 	 */
1002 	block = group * 2;
1003 	pnum = block / blocks_per_page;
1004 	poff = block % blocks_per_page;
1005 	page = find_or_create_page(inode->i_mapping, pnum, gfp);
1006 	if (!page)
1007 		return -ENOMEM;
1008 	BUG_ON(page->mapping != inode->i_mapping);
1009 	e4b->bd_bitmap_page = page;
1010 	e4b->bd_bitmap = page_address(page) + (poff * sb->s_blocksize);
1011 
1012 	if (blocks_per_page >= 2) {
1013 		/* buddy and bitmap are on the same page */
1014 		return 0;
1015 	}
1016 
1017 	block++;
1018 	pnum = block / blocks_per_page;
1019 	page = find_or_create_page(inode->i_mapping, pnum, gfp);
1020 	if (!page)
1021 		return -ENOMEM;
1022 	BUG_ON(page->mapping != inode->i_mapping);
1023 	e4b->bd_buddy_page = page;
1024 	return 0;
1025 }
1026 
ext4_mb_put_buddy_page_lock(struct ext4_buddy * e4b)1027 static void ext4_mb_put_buddy_page_lock(struct ext4_buddy *e4b)
1028 {
1029 	if (e4b->bd_bitmap_page) {
1030 		unlock_page(e4b->bd_bitmap_page);
1031 		put_page(e4b->bd_bitmap_page);
1032 	}
1033 	if (e4b->bd_buddy_page) {
1034 		unlock_page(e4b->bd_buddy_page);
1035 		put_page(e4b->bd_buddy_page);
1036 	}
1037 }
1038 
1039 /*
1040  * Locking note:  This routine calls ext4_mb_init_cache(), which takes the
1041  * block group lock of all groups for this page; do not hold the BG lock when
1042  * calling this routine!
1043  */
1044 static noinline_for_stack
ext4_mb_init_group(struct super_block * sb,ext4_group_t group,gfp_t gfp)1045 int ext4_mb_init_group(struct super_block *sb, ext4_group_t group, gfp_t gfp)
1046 {
1047 
1048 	struct ext4_group_info *this_grp;
1049 	struct ext4_buddy e4b;
1050 	struct page *page;
1051 	int ret = 0;
1052 
1053 	might_sleep();
1054 	mb_debug(1, "init group %u\n", group);
1055 	this_grp = ext4_get_group_info(sb, group);
1056 	/*
1057 	 * This ensures that we don't reinit the buddy cache
1058 	 * page which map to the group from which we are already
1059 	 * allocating. If we are looking at the buddy cache we would
1060 	 * have taken a reference using ext4_mb_load_buddy and that
1061 	 * would have pinned buddy page to page cache.
1062 	 * The call to ext4_mb_get_buddy_page_lock will mark the
1063 	 * page accessed.
1064 	 */
1065 	ret = ext4_mb_get_buddy_page_lock(sb, group, &e4b, gfp);
1066 	if (ret || !EXT4_MB_GRP_NEED_INIT(this_grp)) {
1067 		/*
1068 		 * somebody initialized the group
1069 		 * return without doing anything
1070 		 */
1071 		goto err;
1072 	}
1073 
1074 	page = e4b.bd_bitmap_page;
1075 	ret = ext4_mb_init_cache(page, NULL, gfp);
1076 	if (ret)
1077 		goto err;
1078 	if (!PageUptodate(page)) {
1079 		ret = -EIO;
1080 		goto err;
1081 	}
1082 
1083 	if (e4b.bd_buddy_page == NULL) {
1084 		/*
1085 		 * If both the bitmap and buddy are in
1086 		 * the same page we don't need to force
1087 		 * init the buddy
1088 		 */
1089 		ret = 0;
1090 		goto err;
1091 	}
1092 	/* init buddy cache */
1093 	page = e4b.bd_buddy_page;
1094 	ret = ext4_mb_init_cache(page, e4b.bd_bitmap, gfp);
1095 	if (ret)
1096 		goto err;
1097 	if (!PageUptodate(page)) {
1098 		ret = -EIO;
1099 		goto err;
1100 	}
1101 err:
1102 	ext4_mb_put_buddy_page_lock(&e4b);
1103 	return ret;
1104 }
1105 
1106 /*
1107  * Locking note:  This routine calls ext4_mb_init_cache(), which takes the
1108  * block group lock of all groups for this page; do not hold the BG lock when
1109  * calling this routine!
1110  */
1111 static noinline_for_stack int
ext4_mb_load_buddy_gfp(struct super_block * sb,ext4_group_t group,struct ext4_buddy * e4b,gfp_t gfp)1112 ext4_mb_load_buddy_gfp(struct super_block *sb, ext4_group_t group,
1113 		       struct ext4_buddy *e4b, gfp_t gfp)
1114 {
1115 	int blocks_per_page;
1116 	int block;
1117 	int pnum;
1118 	int poff;
1119 	struct page *page;
1120 	int ret;
1121 	struct ext4_group_info *grp;
1122 	struct ext4_sb_info *sbi = EXT4_SB(sb);
1123 	struct inode *inode = sbi->s_buddy_cache;
1124 
1125 	might_sleep();
1126 	mb_debug(1, "load group %u\n", group);
1127 
1128 	blocks_per_page = PAGE_SIZE / sb->s_blocksize;
1129 	grp = ext4_get_group_info(sb, group);
1130 
1131 	e4b->bd_blkbits = sb->s_blocksize_bits;
1132 	e4b->bd_info = grp;
1133 	e4b->bd_sb = sb;
1134 	e4b->bd_group = group;
1135 	e4b->bd_buddy_page = NULL;
1136 	e4b->bd_bitmap_page = NULL;
1137 
1138 	if (unlikely(EXT4_MB_GRP_NEED_INIT(grp))) {
1139 		/*
1140 		 * we need full data about the group
1141 		 * to make a good selection
1142 		 */
1143 		ret = ext4_mb_init_group(sb, group, gfp);
1144 		if (ret)
1145 			return ret;
1146 	}
1147 
1148 	/*
1149 	 * the buddy cache inode stores the block bitmap
1150 	 * and buddy information in consecutive blocks.
1151 	 * So for each group we need two blocks.
1152 	 */
1153 	block = group * 2;
1154 	pnum = block / blocks_per_page;
1155 	poff = block % blocks_per_page;
1156 
1157 	/* we could use find_or_create_page(), but it locks page
1158 	 * what we'd like to avoid in fast path ... */
1159 	page = find_get_page_flags(inode->i_mapping, pnum, FGP_ACCESSED);
1160 	if (page == NULL || !PageUptodate(page)) {
1161 		if (page)
1162 			/*
1163 			 * drop the page reference and try
1164 			 * to get the page with lock. If we
1165 			 * are not uptodate that implies
1166 			 * somebody just created the page but
1167 			 * is yet to initialize the same. So
1168 			 * wait for it to initialize.
1169 			 */
1170 			put_page(page);
1171 		page = find_or_create_page(inode->i_mapping, pnum, gfp);
1172 		if (page) {
1173 			BUG_ON(page->mapping != inode->i_mapping);
1174 			if (!PageUptodate(page)) {
1175 				ret = ext4_mb_init_cache(page, NULL, gfp);
1176 				if (ret) {
1177 					unlock_page(page);
1178 					goto err;
1179 				}
1180 				mb_cmp_bitmaps(e4b, page_address(page) +
1181 					       (poff * sb->s_blocksize));
1182 			}
1183 			unlock_page(page);
1184 		}
1185 	}
1186 	if (page == NULL) {
1187 		ret = -ENOMEM;
1188 		goto err;
1189 	}
1190 	if (!PageUptodate(page)) {
1191 		ret = -EIO;
1192 		goto err;
1193 	}
1194 
1195 	/* Pages marked accessed already */
1196 	e4b->bd_bitmap_page = page;
1197 	e4b->bd_bitmap = page_address(page) + (poff * sb->s_blocksize);
1198 
1199 	block++;
1200 	pnum = block / blocks_per_page;
1201 	poff = block % blocks_per_page;
1202 
1203 	page = find_get_page_flags(inode->i_mapping, pnum, FGP_ACCESSED);
1204 	if (page == NULL || !PageUptodate(page)) {
1205 		if (page)
1206 			put_page(page);
1207 		page = find_or_create_page(inode->i_mapping, pnum, gfp);
1208 		if (page) {
1209 			BUG_ON(page->mapping != inode->i_mapping);
1210 			if (!PageUptodate(page)) {
1211 				ret = ext4_mb_init_cache(page, e4b->bd_bitmap,
1212 							 gfp);
1213 				if (ret) {
1214 					unlock_page(page);
1215 					goto err;
1216 				}
1217 			}
1218 			unlock_page(page);
1219 		}
1220 	}
1221 	if (page == NULL) {
1222 		ret = -ENOMEM;
1223 		goto err;
1224 	}
1225 	if (!PageUptodate(page)) {
1226 		ret = -EIO;
1227 		goto err;
1228 	}
1229 
1230 	/* Pages marked accessed already */
1231 	e4b->bd_buddy_page = page;
1232 	e4b->bd_buddy = page_address(page) + (poff * sb->s_blocksize);
1233 
1234 	BUG_ON(e4b->bd_bitmap_page == NULL);
1235 	BUG_ON(e4b->bd_buddy_page == NULL);
1236 
1237 	return 0;
1238 
1239 err:
1240 	if (page)
1241 		put_page(page);
1242 	if (e4b->bd_bitmap_page)
1243 		put_page(e4b->bd_bitmap_page);
1244 	if (e4b->bd_buddy_page)
1245 		put_page(e4b->bd_buddy_page);
1246 	e4b->bd_buddy = NULL;
1247 	e4b->bd_bitmap = NULL;
1248 	return ret;
1249 }
1250 
ext4_mb_load_buddy(struct super_block * sb,ext4_group_t group,struct ext4_buddy * e4b)1251 static int ext4_mb_load_buddy(struct super_block *sb, ext4_group_t group,
1252 			      struct ext4_buddy *e4b)
1253 {
1254 	return ext4_mb_load_buddy_gfp(sb, group, e4b, GFP_NOFS);
1255 }
1256 
ext4_mb_unload_buddy(struct ext4_buddy * e4b)1257 static void ext4_mb_unload_buddy(struct ext4_buddy *e4b)
1258 {
1259 	if (e4b->bd_bitmap_page)
1260 		put_page(e4b->bd_bitmap_page);
1261 	if (e4b->bd_buddy_page)
1262 		put_page(e4b->bd_buddy_page);
1263 }
1264 
1265 
mb_find_order_for_block(struct ext4_buddy * e4b,int block)1266 static int mb_find_order_for_block(struct ext4_buddy *e4b, int block)
1267 {
1268 	int order = 1;
1269 	int bb_incr = 1 << (e4b->bd_blkbits - 1);
1270 	void *bb;
1271 
1272 	BUG_ON(e4b->bd_bitmap == e4b->bd_buddy);
1273 	BUG_ON(block >= (1 << (e4b->bd_blkbits + 3)));
1274 
1275 	bb = e4b->bd_buddy;
1276 	while (order <= e4b->bd_blkbits + 1) {
1277 		block = block >> 1;
1278 		if (!mb_test_bit(block, bb)) {
1279 			/* this block is part of buddy of order 'order' */
1280 			return order;
1281 		}
1282 		bb += bb_incr;
1283 		bb_incr >>= 1;
1284 		order++;
1285 	}
1286 	return 0;
1287 }
1288 
mb_clear_bits(void * bm,int cur,int len)1289 static void mb_clear_bits(void *bm, int cur, int len)
1290 {
1291 	__u32 *addr;
1292 
1293 	len = cur + len;
1294 	while (cur < len) {
1295 		if ((cur & 31) == 0 && (len - cur) >= 32) {
1296 			/* fast path: clear whole word at once */
1297 			addr = bm + (cur >> 3);
1298 			*addr = 0;
1299 			cur += 32;
1300 			continue;
1301 		}
1302 		mb_clear_bit(cur, bm);
1303 		cur++;
1304 	}
1305 }
1306 
1307 /* clear bits in given range
1308  * will return first found zero bit if any, -1 otherwise
1309  */
mb_test_and_clear_bits(void * bm,int cur,int len)1310 static int mb_test_and_clear_bits(void *bm, int cur, int len)
1311 {
1312 	__u32 *addr;
1313 	int zero_bit = -1;
1314 
1315 	len = cur + len;
1316 	while (cur < len) {
1317 		if ((cur & 31) == 0 && (len - cur) >= 32) {
1318 			/* fast path: clear whole word at once */
1319 			addr = bm + (cur >> 3);
1320 			if (*addr != (__u32)(-1) && zero_bit == -1)
1321 				zero_bit = cur + mb_find_next_zero_bit(addr, 32, 0);
1322 			*addr = 0;
1323 			cur += 32;
1324 			continue;
1325 		}
1326 		if (!mb_test_and_clear_bit(cur, bm) && zero_bit == -1)
1327 			zero_bit = cur;
1328 		cur++;
1329 	}
1330 
1331 	return zero_bit;
1332 }
1333 
ext4_set_bits(void * bm,int cur,int len)1334 void ext4_set_bits(void *bm, int cur, int len)
1335 {
1336 	__u32 *addr;
1337 
1338 	len = cur + len;
1339 	while (cur < len) {
1340 		if ((cur & 31) == 0 && (len - cur) >= 32) {
1341 			/* fast path: set whole word at once */
1342 			addr = bm + (cur >> 3);
1343 			*addr = 0xffffffff;
1344 			cur += 32;
1345 			continue;
1346 		}
1347 		mb_set_bit(cur, bm);
1348 		cur++;
1349 	}
1350 }
1351 
1352 /*
1353  * _________________________________________________________________ */
1354 
mb_buddy_adjust_border(int * bit,void * bitmap,int side)1355 static inline int mb_buddy_adjust_border(int* bit, void* bitmap, int side)
1356 {
1357 	if (mb_test_bit(*bit + side, bitmap)) {
1358 		mb_clear_bit(*bit, bitmap);
1359 		(*bit) -= side;
1360 		return 1;
1361 	}
1362 	else {
1363 		(*bit) += side;
1364 		mb_set_bit(*bit, bitmap);
1365 		return -1;
1366 	}
1367 }
1368 
mb_buddy_mark_free(struct ext4_buddy * e4b,int first,int last)1369 static void mb_buddy_mark_free(struct ext4_buddy *e4b, int first, int last)
1370 {
1371 	int max;
1372 	int order = 1;
1373 	void *buddy = mb_find_buddy(e4b, order, &max);
1374 
1375 	while (buddy) {
1376 		void *buddy2;
1377 
1378 		/* Bits in range [first; last] are known to be set since
1379 		 * corresponding blocks were allocated. Bits in range
1380 		 * (first; last) will stay set because they form buddies on
1381 		 * upper layer. We just deal with borders if they don't
1382 		 * align with upper layer and then go up.
1383 		 * Releasing entire group is all about clearing
1384 		 * single bit of highest order buddy.
1385 		 */
1386 
1387 		/* Example:
1388 		 * ---------------------------------
1389 		 * |   1   |   1   |   1   |   1   |
1390 		 * ---------------------------------
1391 		 * | 0 | 1 | 1 | 1 | 1 | 1 | 1 | 1 |
1392 		 * ---------------------------------
1393 		 *   0   1   2   3   4   5   6   7
1394 		 *      \_____________________/
1395 		 *
1396 		 * Neither [1] nor [6] is aligned to above layer.
1397 		 * Left neighbour [0] is free, so mark it busy,
1398 		 * decrease bb_counters and extend range to
1399 		 * [0; 6]
1400 		 * Right neighbour [7] is busy. It can't be coaleasced with [6], so
1401 		 * mark [6] free, increase bb_counters and shrink range to
1402 		 * [0; 5].
1403 		 * Then shift range to [0; 2], go up and do the same.
1404 		 */
1405 
1406 
1407 		if (first & 1)
1408 			e4b->bd_info->bb_counters[order] += mb_buddy_adjust_border(&first, buddy, -1);
1409 		if (!(last & 1))
1410 			e4b->bd_info->bb_counters[order] += mb_buddy_adjust_border(&last, buddy, 1);
1411 		if (first > last)
1412 			break;
1413 		order++;
1414 
1415 		if (first == last || !(buddy2 = mb_find_buddy(e4b, order, &max))) {
1416 			mb_clear_bits(buddy, first, last - first + 1);
1417 			e4b->bd_info->bb_counters[order - 1] += last - first + 1;
1418 			break;
1419 		}
1420 		first >>= 1;
1421 		last >>= 1;
1422 		buddy = buddy2;
1423 	}
1424 }
1425 
mb_free_blocks(struct inode * inode,struct ext4_buddy * e4b,int first,int count)1426 static void mb_free_blocks(struct inode *inode, struct ext4_buddy *e4b,
1427 			   int first, int count)
1428 {
1429 	int left_is_free = 0;
1430 	int right_is_free = 0;
1431 	int block;
1432 	int last = first + count - 1;
1433 	struct super_block *sb = e4b->bd_sb;
1434 
1435 	if (WARN_ON(count == 0))
1436 		return;
1437 	BUG_ON(last >= (sb->s_blocksize << 3));
1438 	assert_spin_locked(ext4_group_lock_ptr(sb, e4b->bd_group));
1439 	/* Don't bother if the block group is corrupt. */
1440 	if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(e4b->bd_info)))
1441 		return;
1442 
1443 	mb_check_buddy(e4b);
1444 	mb_free_blocks_double(inode, e4b, first, count);
1445 
1446 	e4b->bd_info->bb_free += count;
1447 	if (first < e4b->bd_info->bb_first_free)
1448 		e4b->bd_info->bb_first_free = first;
1449 
1450 	/* access memory sequentially: check left neighbour,
1451 	 * clear range and then check right neighbour
1452 	 */
1453 	if (first != 0)
1454 		left_is_free = !mb_test_bit(first - 1, e4b->bd_bitmap);
1455 	block = mb_test_and_clear_bits(e4b->bd_bitmap, first, count);
1456 	if (last + 1 < EXT4_SB(sb)->s_mb_maxs[0])
1457 		right_is_free = !mb_test_bit(last + 1, e4b->bd_bitmap);
1458 
1459 	if (unlikely(block != -1)) {
1460 		struct ext4_sb_info *sbi = EXT4_SB(sb);
1461 		ext4_fsblk_t blocknr;
1462 
1463 		blocknr = ext4_group_first_block_no(sb, e4b->bd_group);
1464 		blocknr += EXT4_C2B(EXT4_SB(sb), block);
1465 		ext4_grp_locked_error(sb, e4b->bd_group,
1466 				      inode ? inode->i_ino : 0,
1467 				      blocknr,
1468 				      "freeing already freed block "
1469 				      "(bit %u); block bitmap corrupt.",
1470 				      block);
1471 		if (!EXT4_MB_GRP_BBITMAP_CORRUPT(e4b->bd_info))
1472 			percpu_counter_sub(&sbi->s_freeclusters_counter,
1473 					   e4b->bd_info->bb_free);
1474 		/* Mark the block group as corrupt. */
1475 		set_bit(EXT4_GROUP_INFO_BBITMAP_CORRUPT_BIT,
1476 			&e4b->bd_info->bb_state);
1477 		mb_regenerate_buddy(e4b);
1478 		goto done;
1479 	}
1480 
1481 	/* let's maintain fragments counter */
1482 	if (left_is_free && right_is_free)
1483 		e4b->bd_info->bb_fragments--;
1484 	else if (!left_is_free && !right_is_free)
1485 		e4b->bd_info->bb_fragments++;
1486 
1487 	/* buddy[0] == bd_bitmap is a special case, so handle
1488 	 * it right away and let mb_buddy_mark_free stay free of
1489 	 * zero order checks.
1490 	 * Check if neighbours are to be coaleasced,
1491 	 * adjust bitmap bb_counters and borders appropriately.
1492 	 */
1493 	if (first & 1) {
1494 		first += !left_is_free;
1495 		e4b->bd_info->bb_counters[0] += left_is_free ? -1 : 1;
1496 	}
1497 	if (!(last & 1)) {
1498 		last -= !right_is_free;
1499 		e4b->bd_info->bb_counters[0] += right_is_free ? -1 : 1;
1500 	}
1501 
1502 	if (first <= last)
1503 		mb_buddy_mark_free(e4b, first >> 1, last >> 1);
1504 
1505 done:
1506 	mb_set_largest_free_order(sb, e4b->bd_info);
1507 	mb_check_buddy(e4b);
1508 }
1509 
mb_find_extent(struct ext4_buddy * e4b,int block,int needed,struct ext4_free_extent * ex)1510 static int mb_find_extent(struct ext4_buddy *e4b, int block,
1511 				int needed, struct ext4_free_extent *ex)
1512 {
1513 	int next = block;
1514 	int max, order;
1515 	void *buddy;
1516 
1517 	assert_spin_locked(ext4_group_lock_ptr(e4b->bd_sb, e4b->bd_group));
1518 	BUG_ON(ex == NULL);
1519 
1520 	buddy = mb_find_buddy(e4b, 0, &max);
1521 	BUG_ON(buddy == NULL);
1522 	BUG_ON(block >= max);
1523 	if (mb_test_bit(block, buddy)) {
1524 		ex->fe_len = 0;
1525 		ex->fe_start = 0;
1526 		ex->fe_group = 0;
1527 		return 0;
1528 	}
1529 
1530 	/* find actual order */
1531 	order = mb_find_order_for_block(e4b, block);
1532 	block = block >> order;
1533 
1534 	ex->fe_len = 1 << order;
1535 	ex->fe_start = block << order;
1536 	ex->fe_group = e4b->bd_group;
1537 
1538 	/* calc difference from given start */
1539 	next = next - ex->fe_start;
1540 	ex->fe_len -= next;
1541 	ex->fe_start += next;
1542 
1543 	while (needed > ex->fe_len &&
1544 	       mb_find_buddy(e4b, order, &max)) {
1545 
1546 		if (block + 1 >= max)
1547 			break;
1548 
1549 		next = (block + 1) * (1 << order);
1550 		if (mb_test_bit(next, e4b->bd_bitmap))
1551 			break;
1552 
1553 		order = mb_find_order_for_block(e4b, next);
1554 
1555 		block = next >> order;
1556 		ex->fe_len += 1 << order;
1557 	}
1558 
1559 	BUG_ON(ex->fe_start + ex->fe_len > (1 << (e4b->bd_blkbits + 3)));
1560 	return ex->fe_len;
1561 }
1562 
mb_mark_used(struct ext4_buddy * e4b,struct ext4_free_extent * ex)1563 static int mb_mark_used(struct ext4_buddy *e4b, struct ext4_free_extent *ex)
1564 {
1565 	int ord;
1566 	int mlen = 0;
1567 	int max = 0;
1568 	int cur;
1569 	int start = ex->fe_start;
1570 	int len = ex->fe_len;
1571 	unsigned ret = 0;
1572 	int len0 = len;
1573 	void *buddy;
1574 
1575 	BUG_ON(start + len > (e4b->bd_sb->s_blocksize << 3));
1576 	BUG_ON(e4b->bd_group != ex->fe_group);
1577 	assert_spin_locked(ext4_group_lock_ptr(e4b->bd_sb, e4b->bd_group));
1578 	mb_check_buddy(e4b);
1579 	mb_mark_used_double(e4b, start, len);
1580 
1581 	e4b->bd_info->bb_free -= len;
1582 	if (e4b->bd_info->bb_first_free == start)
1583 		e4b->bd_info->bb_first_free += len;
1584 
1585 	/* let's maintain fragments counter */
1586 	if (start != 0)
1587 		mlen = !mb_test_bit(start - 1, e4b->bd_bitmap);
1588 	if (start + len < EXT4_SB(e4b->bd_sb)->s_mb_maxs[0])
1589 		max = !mb_test_bit(start + len, e4b->bd_bitmap);
1590 	if (mlen && max)
1591 		e4b->bd_info->bb_fragments++;
1592 	else if (!mlen && !max)
1593 		e4b->bd_info->bb_fragments--;
1594 
1595 	/* let's maintain buddy itself */
1596 	while (len) {
1597 		ord = mb_find_order_for_block(e4b, start);
1598 
1599 		if (((start >> ord) << ord) == start && len >= (1 << ord)) {
1600 			/* the whole chunk may be allocated at once! */
1601 			mlen = 1 << ord;
1602 			buddy = mb_find_buddy(e4b, ord, &max);
1603 			BUG_ON((start >> ord) >= max);
1604 			mb_set_bit(start >> ord, buddy);
1605 			e4b->bd_info->bb_counters[ord]--;
1606 			start += mlen;
1607 			len -= mlen;
1608 			BUG_ON(len < 0);
1609 			continue;
1610 		}
1611 
1612 		/* store for history */
1613 		if (ret == 0)
1614 			ret = len | (ord << 16);
1615 
1616 		/* we have to split large buddy */
1617 		BUG_ON(ord <= 0);
1618 		buddy = mb_find_buddy(e4b, ord, &max);
1619 		mb_set_bit(start >> ord, buddy);
1620 		e4b->bd_info->bb_counters[ord]--;
1621 
1622 		ord--;
1623 		cur = (start >> ord) & ~1U;
1624 		buddy = mb_find_buddy(e4b, ord, &max);
1625 		mb_clear_bit(cur, buddy);
1626 		mb_clear_bit(cur + 1, buddy);
1627 		e4b->bd_info->bb_counters[ord]++;
1628 		e4b->bd_info->bb_counters[ord]++;
1629 	}
1630 	mb_set_largest_free_order(e4b->bd_sb, e4b->bd_info);
1631 
1632 	ext4_set_bits(e4b->bd_bitmap, ex->fe_start, len0);
1633 	mb_check_buddy(e4b);
1634 
1635 	return ret;
1636 }
1637 
1638 /*
1639  * Must be called under group lock!
1640  */
ext4_mb_use_best_found(struct ext4_allocation_context * ac,struct ext4_buddy * e4b)1641 static void ext4_mb_use_best_found(struct ext4_allocation_context *ac,
1642 					struct ext4_buddy *e4b)
1643 {
1644 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
1645 	int ret;
1646 
1647 	BUG_ON(ac->ac_b_ex.fe_group != e4b->bd_group);
1648 	BUG_ON(ac->ac_status == AC_STATUS_FOUND);
1649 
1650 	ac->ac_b_ex.fe_len = min(ac->ac_b_ex.fe_len, ac->ac_g_ex.fe_len);
1651 	ac->ac_b_ex.fe_logical = ac->ac_g_ex.fe_logical;
1652 	ret = mb_mark_used(e4b, &ac->ac_b_ex);
1653 
1654 	/* preallocation can change ac_b_ex, thus we store actually
1655 	 * allocated blocks for history */
1656 	ac->ac_f_ex = ac->ac_b_ex;
1657 
1658 	ac->ac_status = AC_STATUS_FOUND;
1659 	ac->ac_tail = ret & 0xffff;
1660 	ac->ac_buddy = ret >> 16;
1661 
1662 	/*
1663 	 * take the page reference. We want the page to be pinned
1664 	 * so that we don't get a ext4_mb_init_cache_call for this
1665 	 * group until we update the bitmap. That would mean we
1666 	 * double allocate blocks. The reference is dropped
1667 	 * in ext4_mb_release_context
1668 	 */
1669 	ac->ac_bitmap_page = e4b->bd_bitmap_page;
1670 	get_page(ac->ac_bitmap_page);
1671 	ac->ac_buddy_page = e4b->bd_buddy_page;
1672 	get_page(ac->ac_buddy_page);
1673 	/* store last allocated for subsequent stream allocation */
1674 	if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
1675 		spin_lock(&sbi->s_md_lock);
1676 		sbi->s_mb_last_group = ac->ac_f_ex.fe_group;
1677 		sbi->s_mb_last_start = ac->ac_f_ex.fe_start;
1678 		spin_unlock(&sbi->s_md_lock);
1679 	}
1680 }
1681 
1682 /*
1683  * regular allocator, for general purposes allocation
1684  */
1685 
ext4_mb_check_limits(struct ext4_allocation_context * ac,struct ext4_buddy * e4b,int finish_group)1686 static void ext4_mb_check_limits(struct ext4_allocation_context *ac,
1687 					struct ext4_buddy *e4b,
1688 					int finish_group)
1689 {
1690 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
1691 	struct ext4_free_extent *bex = &ac->ac_b_ex;
1692 	struct ext4_free_extent *gex = &ac->ac_g_ex;
1693 	struct ext4_free_extent ex;
1694 	int max;
1695 
1696 	if (ac->ac_status == AC_STATUS_FOUND)
1697 		return;
1698 	/*
1699 	 * We don't want to scan for a whole year
1700 	 */
1701 	if (ac->ac_found > sbi->s_mb_max_to_scan &&
1702 			!(ac->ac_flags & EXT4_MB_HINT_FIRST)) {
1703 		ac->ac_status = AC_STATUS_BREAK;
1704 		return;
1705 	}
1706 
1707 	/*
1708 	 * Haven't found good chunk so far, let's continue
1709 	 */
1710 	if (bex->fe_len < gex->fe_len)
1711 		return;
1712 
1713 	if ((finish_group || ac->ac_found > sbi->s_mb_min_to_scan)
1714 			&& bex->fe_group == e4b->bd_group) {
1715 		/* recheck chunk's availability - we don't know
1716 		 * when it was found (within this lock-unlock
1717 		 * period or not) */
1718 		max = mb_find_extent(e4b, bex->fe_start, gex->fe_len, &ex);
1719 		if (max >= gex->fe_len) {
1720 			ext4_mb_use_best_found(ac, e4b);
1721 			return;
1722 		}
1723 	}
1724 }
1725 
1726 /*
1727  * The routine checks whether found extent is good enough. If it is,
1728  * then the extent gets marked used and flag is set to the context
1729  * to stop scanning. Otherwise, the extent is compared with the
1730  * previous found extent and if new one is better, then it's stored
1731  * in the context. Later, the best found extent will be used, if
1732  * mballoc can't find good enough extent.
1733  *
1734  * FIXME: real allocation policy is to be designed yet!
1735  */
ext4_mb_measure_extent(struct ext4_allocation_context * ac,struct ext4_free_extent * ex,struct ext4_buddy * e4b)1736 static void ext4_mb_measure_extent(struct ext4_allocation_context *ac,
1737 					struct ext4_free_extent *ex,
1738 					struct ext4_buddy *e4b)
1739 {
1740 	struct ext4_free_extent *bex = &ac->ac_b_ex;
1741 	struct ext4_free_extent *gex = &ac->ac_g_ex;
1742 
1743 	BUG_ON(ex->fe_len <= 0);
1744 	BUG_ON(ex->fe_len > EXT4_CLUSTERS_PER_GROUP(ac->ac_sb));
1745 	BUG_ON(ex->fe_start >= EXT4_CLUSTERS_PER_GROUP(ac->ac_sb));
1746 	BUG_ON(ac->ac_status != AC_STATUS_CONTINUE);
1747 
1748 	ac->ac_found++;
1749 
1750 	/*
1751 	 * The special case - take what you catch first
1752 	 */
1753 	if (unlikely(ac->ac_flags & EXT4_MB_HINT_FIRST)) {
1754 		*bex = *ex;
1755 		ext4_mb_use_best_found(ac, e4b);
1756 		return;
1757 	}
1758 
1759 	/*
1760 	 * Let's check whether the chuck is good enough
1761 	 */
1762 	if (ex->fe_len == gex->fe_len) {
1763 		*bex = *ex;
1764 		ext4_mb_use_best_found(ac, e4b);
1765 		return;
1766 	}
1767 
1768 	/*
1769 	 * If this is first found extent, just store it in the context
1770 	 */
1771 	if (bex->fe_len == 0) {
1772 		*bex = *ex;
1773 		return;
1774 	}
1775 
1776 	/*
1777 	 * If new found extent is better, store it in the context
1778 	 */
1779 	if (bex->fe_len < gex->fe_len) {
1780 		/* if the request isn't satisfied, any found extent
1781 		 * larger than previous best one is better */
1782 		if (ex->fe_len > bex->fe_len)
1783 			*bex = *ex;
1784 	} else if (ex->fe_len > gex->fe_len) {
1785 		/* if the request is satisfied, then we try to find
1786 		 * an extent that still satisfy the request, but is
1787 		 * smaller than previous one */
1788 		if (ex->fe_len < bex->fe_len)
1789 			*bex = *ex;
1790 	}
1791 
1792 	ext4_mb_check_limits(ac, e4b, 0);
1793 }
1794 
1795 static noinline_for_stack
ext4_mb_try_best_found(struct ext4_allocation_context * ac,struct ext4_buddy * e4b)1796 int ext4_mb_try_best_found(struct ext4_allocation_context *ac,
1797 					struct ext4_buddy *e4b)
1798 {
1799 	struct ext4_free_extent ex = ac->ac_b_ex;
1800 	ext4_group_t group = ex.fe_group;
1801 	int max;
1802 	int err;
1803 
1804 	BUG_ON(ex.fe_len <= 0);
1805 	err = ext4_mb_load_buddy(ac->ac_sb, group, e4b);
1806 	if (err)
1807 		return err;
1808 
1809 	ext4_lock_group(ac->ac_sb, group);
1810 	max = mb_find_extent(e4b, ex.fe_start, ex.fe_len, &ex);
1811 
1812 	if (max > 0) {
1813 		ac->ac_b_ex = ex;
1814 		ext4_mb_use_best_found(ac, e4b);
1815 	}
1816 
1817 	ext4_unlock_group(ac->ac_sb, group);
1818 	ext4_mb_unload_buddy(e4b);
1819 
1820 	return 0;
1821 }
1822 
1823 static noinline_for_stack
ext4_mb_find_by_goal(struct ext4_allocation_context * ac,struct ext4_buddy * e4b)1824 int ext4_mb_find_by_goal(struct ext4_allocation_context *ac,
1825 				struct ext4_buddy *e4b)
1826 {
1827 	ext4_group_t group = ac->ac_g_ex.fe_group;
1828 	int max;
1829 	int err;
1830 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
1831 	struct ext4_group_info *grp = ext4_get_group_info(ac->ac_sb, group);
1832 	struct ext4_free_extent ex;
1833 
1834 	if (!(ac->ac_flags & EXT4_MB_HINT_TRY_GOAL))
1835 		return 0;
1836 	if (grp->bb_free == 0)
1837 		return 0;
1838 
1839 	err = ext4_mb_load_buddy(ac->ac_sb, group, e4b);
1840 	if (err)
1841 		return err;
1842 
1843 	if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(e4b->bd_info))) {
1844 		ext4_mb_unload_buddy(e4b);
1845 		return 0;
1846 	}
1847 
1848 	ext4_lock_group(ac->ac_sb, group);
1849 	max = mb_find_extent(e4b, ac->ac_g_ex.fe_start,
1850 			     ac->ac_g_ex.fe_len, &ex);
1851 	ex.fe_logical = 0xDEADFA11; /* debug value */
1852 
1853 	if (max >= ac->ac_g_ex.fe_len && ac->ac_g_ex.fe_len == sbi->s_stripe) {
1854 		ext4_fsblk_t start;
1855 
1856 		start = ext4_group_first_block_no(ac->ac_sb, e4b->bd_group) +
1857 			ex.fe_start;
1858 		/* use do_div to get remainder (would be 64-bit modulo) */
1859 		if (do_div(start, sbi->s_stripe) == 0) {
1860 			ac->ac_found++;
1861 			ac->ac_b_ex = ex;
1862 			ext4_mb_use_best_found(ac, e4b);
1863 		}
1864 	} else if (max >= ac->ac_g_ex.fe_len) {
1865 		BUG_ON(ex.fe_len <= 0);
1866 		BUG_ON(ex.fe_group != ac->ac_g_ex.fe_group);
1867 		BUG_ON(ex.fe_start != ac->ac_g_ex.fe_start);
1868 		ac->ac_found++;
1869 		ac->ac_b_ex = ex;
1870 		ext4_mb_use_best_found(ac, e4b);
1871 	} else if (max > 0 && (ac->ac_flags & EXT4_MB_HINT_MERGE)) {
1872 		/* Sometimes, caller may want to merge even small
1873 		 * number of blocks to an existing extent */
1874 		BUG_ON(ex.fe_len <= 0);
1875 		BUG_ON(ex.fe_group != ac->ac_g_ex.fe_group);
1876 		BUG_ON(ex.fe_start != ac->ac_g_ex.fe_start);
1877 		ac->ac_found++;
1878 		ac->ac_b_ex = ex;
1879 		ext4_mb_use_best_found(ac, e4b);
1880 	}
1881 	ext4_unlock_group(ac->ac_sb, group);
1882 	ext4_mb_unload_buddy(e4b);
1883 
1884 	return 0;
1885 }
1886 
1887 /*
1888  * The routine scans buddy structures (not bitmap!) from given order
1889  * to max order and tries to find big enough chunk to satisfy the req
1890  */
1891 static noinline_for_stack
ext4_mb_simple_scan_group(struct ext4_allocation_context * ac,struct ext4_buddy * e4b)1892 void ext4_mb_simple_scan_group(struct ext4_allocation_context *ac,
1893 					struct ext4_buddy *e4b)
1894 {
1895 	struct super_block *sb = ac->ac_sb;
1896 	struct ext4_group_info *grp = e4b->bd_info;
1897 	void *buddy;
1898 	int i;
1899 	int k;
1900 	int max;
1901 
1902 	BUG_ON(ac->ac_2order <= 0);
1903 	for (i = ac->ac_2order; i <= sb->s_blocksize_bits + 1; i++) {
1904 		if (grp->bb_counters[i] == 0)
1905 			continue;
1906 
1907 		buddy = mb_find_buddy(e4b, i, &max);
1908 		BUG_ON(buddy == NULL);
1909 
1910 		k = mb_find_next_zero_bit(buddy, max, 0);
1911 		BUG_ON(k >= max);
1912 
1913 		ac->ac_found++;
1914 
1915 		ac->ac_b_ex.fe_len = 1 << i;
1916 		ac->ac_b_ex.fe_start = k << i;
1917 		ac->ac_b_ex.fe_group = e4b->bd_group;
1918 
1919 		ext4_mb_use_best_found(ac, e4b);
1920 
1921 		BUG_ON(ac->ac_b_ex.fe_len != ac->ac_g_ex.fe_len);
1922 
1923 		if (EXT4_SB(sb)->s_mb_stats)
1924 			atomic_inc(&EXT4_SB(sb)->s_bal_2orders);
1925 
1926 		break;
1927 	}
1928 }
1929 
1930 /*
1931  * The routine scans the group and measures all found extents.
1932  * In order to optimize scanning, caller must pass number of
1933  * free blocks in the group, so the routine can know upper limit.
1934  */
1935 static noinline_for_stack
ext4_mb_complex_scan_group(struct ext4_allocation_context * ac,struct ext4_buddy * e4b)1936 void ext4_mb_complex_scan_group(struct ext4_allocation_context *ac,
1937 					struct ext4_buddy *e4b)
1938 {
1939 	struct super_block *sb = ac->ac_sb;
1940 	void *bitmap = e4b->bd_bitmap;
1941 	struct ext4_free_extent ex;
1942 	int i;
1943 	int free;
1944 
1945 	free = e4b->bd_info->bb_free;
1946 	BUG_ON(free <= 0);
1947 
1948 	i = e4b->bd_info->bb_first_free;
1949 
1950 	while (free && ac->ac_status == AC_STATUS_CONTINUE) {
1951 		i = mb_find_next_zero_bit(bitmap,
1952 						EXT4_CLUSTERS_PER_GROUP(sb), i);
1953 		if (i >= EXT4_CLUSTERS_PER_GROUP(sb)) {
1954 			/*
1955 			 * IF we have corrupt bitmap, we won't find any
1956 			 * free blocks even though group info says we
1957 			 * we have free blocks
1958 			 */
1959 			ext4_grp_locked_error(sb, e4b->bd_group, 0, 0,
1960 					"%d free clusters as per "
1961 					"group info. But bitmap says 0",
1962 					free);
1963 			break;
1964 		}
1965 
1966 		mb_find_extent(e4b, i, ac->ac_g_ex.fe_len, &ex);
1967 		BUG_ON(ex.fe_len <= 0);
1968 		if (free < ex.fe_len) {
1969 			ext4_grp_locked_error(sb, e4b->bd_group, 0, 0,
1970 					"%d free clusters as per "
1971 					"group info. But got %d blocks",
1972 					free, ex.fe_len);
1973 			/*
1974 			 * The number of free blocks differs. This mostly
1975 			 * indicate that the bitmap is corrupt. So exit
1976 			 * without claiming the space.
1977 			 */
1978 			break;
1979 		}
1980 		ex.fe_logical = 0xDEADC0DE; /* debug value */
1981 		ext4_mb_measure_extent(ac, &ex, e4b);
1982 
1983 		i += ex.fe_len;
1984 		free -= ex.fe_len;
1985 	}
1986 
1987 	ext4_mb_check_limits(ac, e4b, 1);
1988 }
1989 
1990 /*
1991  * This is a special case for storages like raid5
1992  * we try to find stripe-aligned chunks for stripe-size-multiple requests
1993  */
1994 static noinline_for_stack
ext4_mb_scan_aligned(struct ext4_allocation_context * ac,struct ext4_buddy * e4b)1995 void ext4_mb_scan_aligned(struct ext4_allocation_context *ac,
1996 				 struct ext4_buddy *e4b)
1997 {
1998 	struct super_block *sb = ac->ac_sb;
1999 	struct ext4_sb_info *sbi = EXT4_SB(sb);
2000 	void *bitmap = e4b->bd_bitmap;
2001 	struct ext4_free_extent ex;
2002 	ext4_fsblk_t first_group_block;
2003 	ext4_fsblk_t a;
2004 	ext4_grpblk_t i;
2005 	int max;
2006 
2007 	BUG_ON(sbi->s_stripe == 0);
2008 
2009 	/* find first stripe-aligned block in group */
2010 	first_group_block = ext4_group_first_block_no(sb, e4b->bd_group);
2011 
2012 	a = first_group_block + sbi->s_stripe - 1;
2013 	do_div(a, sbi->s_stripe);
2014 	i = (a * sbi->s_stripe) - first_group_block;
2015 
2016 	while (i < EXT4_CLUSTERS_PER_GROUP(sb)) {
2017 		if (!mb_test_bit(i, bitmap)) {
2018 			max = mb_find_extent(e4b, i, sbi->s_stripe, &ex);
2019 			if (max >= sbi->s_stripe) {
2020 				ac->ac_found++;
2021 				ex.fe_logical = 0xDEADF00D; /* debug value */
2022 				ac->ac_b_ex = ex;
2023 				ext4_mb_use_best_found(ac, e4b);
2024 				break;
2025 			}
2026 		}
2027 		i += sbi->s_stripe;
2028 	}
2029 }
2030 
2031 /*
2032  * This is now called BEFORE we load the buddy bitmap.
2033  * Returns either 1 or 0 indicating that the group is either suitable
2034  * for the allocation or not. In addition it can also return negative
2035  * error code when something goes wrong.
2036  */
ext4_mb_good_group(struct ext4_allocation_context * ac,ext4_group_t group,int cr)2037 static int ext4_mb_good_group(struct ext4_allocation_context *ac,
2038 				ext4_group_t group, int cr)
2039 {
2040 	unsigned free, fragments;
2041 	int flex_size = ext4_flex_bg_size(EXT4_SB(ac->ac_sb));
2042 	struct ext4_group_info *grp = ext4_get_group_info(ac->ac_sb, group);
2043 
2044 	BUG_ON(cr < 0 || cr >= 4);
2045 
2046 	free = grp->bb_free;
2047 	if (free == 0)
2048 		return 0;
2049 	if (cr <= 2 && free < ac->ac_g_ex.fe_len)
2050 		return 0;
2051 
2052 	if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(grp)))
2053 		return 0;
2054 
2055 	/* We only do this if the grp has never been initialized */
2056 	if (unlikely(EXT4_MB_GRP_NEED_INIT(grp))) {
2057 		int ret = ext4_mb_init_group(ac->ac_sb, group, GFP_NOFS);
2058 		if (ret)
2059 			return ret;
2060 	}
2061 
2062 	fragments = grp->bb_fragments;
2063 	if (fragments == 0)
2064 		return 0;
2065 
2066 	switch (cr) {
2067 	case 0:
2068 		BUG_ON(ac->ac_2order == 0);
2069 
2070 		/* Avoid using the first bg of a flexgroup for data files */
2071 		if ((ac->ac_flags & EXT4_MB_HINT_DATA) &&
2072 		    (flex_size >= EXT4_FLEX_SIZE_DIR_ALLOC_SCHEME) &&
2073 		    ((group % flex_size) == 0))
2074 			return 0;
2075 
2076 		if ((ac->ac_2order > ac->ac_sb->s_blocksize_bits+1) ||
2077 		    (free / fragments) >= ac->ac_g_ex.fe_len)
2078 			return 1;
2079 
2080 		if (grp->bb_largest_free_order < ac->ac_2order)
2081 			return 0;
2082 
2083 		return 1;
2084 	case 1:
2085 		if ((free / fragments) >= ac->ac_g_ex.fe_len)
2086 			return 1;
2087 		break;
2088 	case 2:
2089 		if (free >= ac->ac_g_ex.fe_len)
2090 			return 1;
2091 		break;
2092 	case 3:
2093 		return 1;
2094 	default:
2095 		BUG();
2096 	}
2097 
2098 	return 0;
2099 }
2100 
2101 static noinline_for_stack int
ext4_mb_regular_allocator(struct ext4_allocation_context * ac)2102 ext4_mb_regular_allocator(struct ext4_allocation_context *ac)
2103 {
2104 	ext4_group_t ngroups, group, i;
2105 	int cr;
2106 	int err = 0, first_err = 0;
2107 	struct ext4_sb_info *sbi;
2108 	struct super_block *sb;
2109 	struct ext4_buddy e4b;
2110 
2111 	sb = ac->ac_sb;
2112 	sbi = EXT4_SB(sb);
2113 	ngroups = ext4_get_groups_count(sb);
2114 	/* non-extent files are limited to low blocks/groups */
2115 	if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)))
2116 		ngroups = sbi->s_blockfile_groups;
2117 
2118 	BUG_ON(ac->ac_status == AC_STATUS_FOUND);
2119 
2120 	/* first, try the goal */
2121 	err = ext4_mb_find_by_goal(ac, &e4b);
2122 	if (err || ac->ac_status == AC_STATUS_FOUND)
2123 		goto out;
2124 
2125 	if (unlikely(ac->ac_flags & EXT4_MB_HINT_GOAL_ONLY))
2126 		goto out;
2127 
2128 	/*
2129 	 * ac->ac2_order is set only if the fe_len is a power of 2
2130 	 * if ac2_order is set we also set criteria to 0 so that we
2131 	 * try exact allocation using buddy.
2132 	 */
2133 	i = fls(ac->ac_g_ex.fe_len);
2134 	ac->ac_2order = 0;
2135 	/*
2136 	 * We search using buddy data only if the order of the request
2137 	 * is greater than equal to the sbi_s_mb_order2_reqs
2138 	 * You can tune it via /sys/fs/ext4/<partition>/mb_order2_req
2139 	 * We also support searching for power-of-two requests only for
2140 	 * requests upto maximum buddy size we have constructed.
2141 	 */
2142 	if (i >= sbi->s_mb_order2_reqs && i <= sb->s_blocksize_bits + 2) {
2143 		/*
2144 		 * This should tell if fe_len is exactly power of 2
2145 		 */
2146 		if ((ac->ac_g_ex.fe_len & (~(1 << (i - 1)))) == 0)
2147 			ac->ac_2order = i - 1;
2148 	}
2149 
2150 	/* if stream allocation is enabled, use global goal */
2151 	if (ac->ac_flags & EXT4_MB_STREAM_ALLOC) {
2152 		/* TBD: may be hot point */
2153 		spin_lock(&sbi->s_md_lock);
2154 		ac->ac_g_ex.fe_group = sbi->s_mb_last_group;
2155 		ac->ac_g_ex.fe_start = sbi->s_mb_last_start;
2156 		spin_unlock(&sbi->s_md_lock);
2157 	}
2158 
2159 	/* Let's just scan groups to find more-less suitable blocks */
2160 	cr = ac->ac_2order ? 0 : 1;
2161 	/*
2162 	 * cr == 0 try to get exact allocation,
2163 	 * cr == 3  try to get anything
2164 	 */
2165 repeat:
2166 	for (; cr < 4 && ac->ac_status == AC_STATUS_CONTINUE; cr++) {
2167 		ac->ac_criteria = cr;
2168 		/*
2169 		 * searching for the right group start
2170 		 * from the goal value specified
2171 		 */
2172 		group = ac->ac_g_ex.fe_group;
2173 
2174 		for (i = 0; i < ngroups; group++, i++) {
2175 			int ret = 0;
2176 			cond_resched();
2177 			/*
2178 			 * Artificially restricted ngroups for non-extent
2179 			 * files makes group > ngroups possible on first loop.
2180 			 */
2181 			if (group >= ngroups)
2182 				group = 0;
2183 
2184 			/* This now checks without needing the buddy page */
2185 			ret = ext4_mb_good_group(ac, group, cr);
2186 			if (ret <= 0) {
2187 				if (!first_err)
2188 					first_err = ret;
2189 				continue;
2190 			}
2191 
2192 			err = ext4_mb_load_buddy(sb, group, &e4b);
2193 			if (err)
2194 				goto out;
2195 
2196 			ext4_lock_group(sb, group);
2197 
2198 			/*
2199 			 * We need to check again after locking the
2200 			 * block group
2201 			 */
2202 			ret = ext4_mb_good_group(ac, group, cr);
2203 			if (ret <= 0) {
2204 				ext4_unlock_group(sb, group);
2205 				ext4_mb_unload_buddy(&e4b);
2206 				if (!first_err)
2207 					first_err = ret;
2208 				continue;
2209 			}
2210 
2211 			ac->ac_groups_scanned++;
2212 			if (cr == 0)
2213 				ext4_mb_simple_scan_group(ac, &e4b);
2214 			else if (cr == 1 && sbi->s_stripe &&
2215 					!(ac->ac_g_ex.fe_len % sbi->s_stripe))
2216 				ext4_mb_scan_aligned(ac, &e4b);
2217 			else
2218 				ext4_mb_complex_scan_group(ac, &e4b);
2219 
2220 			ext4_unlock_group(sb, group);
2221 			ext4_mb_unload_buddy(&e4b);
2222 
2223 			if (ac->ac_status != AC_STATUS_CONTINUE)
2224 				break;
2225 		}
2226 	}
2227 
2228 	if (ac->ac_b_ex.fe_len > 0 && ac->ac_status != AC_STATUS_FOUND &&
2229 	    !(ac->ac_flags & EXT4_MB_HINT_FIRST)) {
2230 		/*
2231 		 * We've been searching too long. Let's try to allocate
2232 		 * the best chunk we've found so far
2233 		 */
2234 
2235 		ext4_mb_try_best_found(ac, &e4b);
2236 		if (ac->ac_status != AC_STATUS_FOUND) {
2237 			/*
2238 			 * Someone more lucky has already allocated it.
2239 			 * The only thing we can do is just take first
2240 			 * found block(s)
2241 			printk(KERN_DEBUG "EXT4-fs: someone won our chunk\n");
2242 			 */
2243 			ac->ac_b_ex.fe_group = 0;
2244 			ac->ac_b_ex.fe_start = 0;
2245 			ac->ac_b_ex.fe_len = 0;
2246 			ac->ac_status = AC_STATUS_CONTINUE;
2247 			ac->ac_flags |= EXT4_MB_HINT_FIRST;
2248 			cr = 3;
2249 			atomic_inc(&sbi->s_mb_lost_chunks);
2250 			goto repeat;
2251 		}
2252 	}
2253 out:
2254 	if (!err && ac->ac_status != AC_STATUS_FOUND && first_err)
2255 		err = first_err;
2256 	return err;
2257 }
2258 
ext4_mb_seq_groups_start(struct seq_file * seq,loff_t * pos)2259 static void *ext4_mb_seq_groups_start(struct seq_file *seq, loff_t *pos)
2260 {
2261 	struct super_block *sb = seq->private;
2262 	ext4_group_t group;
2263 
2264 	if (*pos < 0 || *pos >= ext4_get_groups_count(sb))
2265 		return NULL;
2266 	group = *pos + 1;
2267 	return (void *) ((unsigned long) group);
2268 }
2269 
ext4_mb_seq_groups_next(struct seq_file * seq,void * v,loff_t * pos)2270 static void *ext4_mb_seq_groups_next(struct seq_file *seq, void *v, loff_t *pos)
2271 {
2272 	struct super_block *sb = seq->private;
2273 	ext4_group_t group;
2274 
2275 	++*pos;
2276 	if (*pos < 0 || *pos >= ext4_get_groups_count(sb))
2277 		return NULL;
2278 	group = *pos + 1;
2279 	return (void *) ((unsigned long) group);
2280 }
2281 
ext4_mb_seq_groups_show(struct seq_file * seq,void * v)2282 static int ext4_mb_seq_groups_show(struct seq_file *seq, void *v)
2283 {
2284 	struct super_block *sb = seq->private;
2285 	ext4_group_t group = (ext4_group_t) ((unsigned long) v);
2286 	int i;
2287 	int err, buddy_loaded = 0;
2288 	struct ext4_buddy e4b;
2289 	struct ext4_group_info *grinfo;
2290 	struct sg {
2291 		struct ext4_group_info info;
2292 		ext4_grpblk_t counters[EXT4_MAX_BLOCK_LOG_SIZE + 2];
2293 	} sg;
2294 
2295 	group--;
2296 	if (group == 0)
2297 		seq_puts(seq, "#group: free  frags first ["
2298 			      " 2^0   2^1   2^2   2^3   2^4   2^5   2^6  "
2299 			      " 2^7   2^8   2^9   2^10  2^11  2^12  2^13  ]\n");
2300 
2301 	i = (sb->s_blocksize_bits + 2) * sizeof(sg.info.bb_counters[0]) +
2302 		sizeof(struct ext4_group_info);
2303 	grinfo = ext4_get_group_info(sb, group);
2304 	/* Load the group info in memory only if not already loaded. */
2305 	if (unlikely(EXT4_MB_GRP_NEED_INIT(grinfo))) {
2306 		err = ext4_mb_load_buddy(sb, group, &e4b);
2307 		if (err) {
2308 			seq_printf(seq, "#%-5u: I/O error\n", group);
2309 			return 0;
2310 		}
2311 		buddy_loaded = 1;
2312 	}
2313 
2314 	memcpy(&sg, ext4_get_group_info(sb, group), i);
2315 
2316 	if (buddy_loaded)
2317 		ext4_mb_unload_buddy(&e4b);
2318 
2319 	seq_printf(seq, "#%-5u: %-5u %-5u %-5u [", group, sg.info.bb_free,
2320 			sg.info.bb_fragments, sg.info.bb_first_free);
2321 	for (i = 0; i <= 13; i++)
2322 		seq_printf(seq, " %-5u", i <= sb->s_blocksize_bits + 1 ?
2323 				sg.info.bb_counters[i] : 0);
2324 	seq_printf(seq, " ]\n");
2325 
2326 	return 0;
2327 }
2328 
ext4_mb_seq_groups_stop(struct seq_file * seq,void * v)2329 static void ext4_mb_seq_groups_stop(struct seq_file *seq, void *v)
2330 {
2331 }
2332 
2333 static const struct seq_operations ext4_mb_seq_groups_ops = {
2334 	.start  = ext4_mb_seq_groups_start,
2335 	.next   = ext4_mb_seq_groups_next,
2336 	.stop   = ext4_mb_seq_groups_stop,
2337 	.show   = ext4_mb_seq_groups_show,
2338 };
2339 
ext4_mb_seq_groups_open(struct inode * inode,struct file * file)2340 static int ext4_mb_seq_groups_open(struct inode *inode, struct file *file)
2341 {
2342 	struct super_block *sb = PDE_DATA(inode);
2343 	int rc;
2344 
2345 	rc = seq_open(file, &ext4_mb_seq_groups_ops);
2346 	if (rc == 0) {
2347 		struct seq_file *m = file->private_data;
2348 		m->private = sb;
2349 	}
2350 	return rc;
2351 
2352 }
2353 
2354 const struct file_operations ext4_seq_mb_groups_fops = {
2355 	.open		= ext4_mb_seq_groups_open,
2356 	.read		= seq_read,
2357 	.llseek		= seq_lseek,
2358 	.release	= seq_release,
2359 };
2360 
get_groupinfo_cache(int blocksize_bits)2361 static struct kmem_cache *get_groupinfo_cache(int blocksize_bits)
2362 {
2363 	int cache_index = blocksize_bits - EXT4_MIN_BLOCK_LOG_SIZE;
2364 	struct kmem_cache *cachep = ext4_groupinfo_caches[cache_index];
2365 
2366 	BUG_ON(!cachep);
2367 	return cachep;
2368 }
2369 
2370 /*
2371  * Allocate the top-level s_group_info array for the specified number
2372  * of groups
2373  */
ext4_mb_alloc_groupinfo(struct super_block * sb,ext4_group_t ngroups)2374 int ext4_mb_alloc_groupinfo(struct super_block *sb, ext4_group_t ngroups)
2375 {
2376 	struct ext4_sb_info *sbi = EXT4_SB(sb);
2377 	unsigned size;
2378 	struct ext4_group_info ***new_groupinfo;
2379 
2380 	size = (ngroups + EXT4_DESC_PER_BLOCK(sb) - 1) >>
2381 		EXT4_DESC_PER_BLOCK_BITS(sb);
2382 	if (size <= sbi->s_group_info_size)
2383 		return 0;
2384 
2385 	size = roundup_pow_of_two(sizeof(*sbi->s_group_info) * size);
2386 	new_groupinfo = ext4_kvzalloc(size, GFP_KERNEL);
2387 	if (!new_groupinfo) {
2388 		ext4_msg(sb, KERN_ERR, "can't allocate buddy meta group");
2389 		return -ENOMEM;
2390 	}
2391 	if (sbi->s_group_info) {
2392 		memcpy(new_groupinfo, sbi->s_group_info,
2393 		       sbi->s_group_info_size * sizeof(*sbi->s_group_info));
2394 		kvfree(sbi->s_group_info);
2395 	}
2396 	sbi->s_group_info = new_groupinfo;
2397 	sbi->s_group_info_size = size / sizeof(*sbi->s_group_info);
2398 	ext4_debug("allocated s_groupinfo array for %d meta_bg's\n",
2399 		   sbi->s_group_info_size);
2400 	return 0;
2401 }
2402 
2403 /* Create and initialize ext4_group_info data for the given group. */
ext4_mb_add_groupinfo(struct super_block * sb,ext4_group_t group,struct ext4_group_desc * desc)2404 int ext4_mb_add_groupinfo(struct super_block *sb, ext4_group_t group,
2405 			  struct ext4_group_desc *desc)
2406 {
2407 	int i;
2408 	int metalen = 0;
2409 	struct ext4_sb_info *sbi = EXT4_SB(sb);
2410 	struct ext4_group_info **meta_group_info;
2411 	struct kmem_cache *cachep = get_groupinfo_cache(sb->s_blocksize_bits);
2412 
2413 	/*
2414 	 * First check if this group is the first of a reserved block.
2415 	 * If it's true, we have to allocate a new table of pointers
2416 	 * to ext4_group_info structures
2417 	 */
2418 	if (group % EXT4_DESC_PER_BLOCK(sb) == 0) {
2419 		metalen = sizeof(*meta_group_info) <<
2420 			EXT4_DESC_PER_BLOCK_BITS(sb);
2421 		meta_group_info = kmalloc(metalen, GFP_NOFS);
2422 		if (meta_group_info == NULL) {
2423 			ext4_msg(sb, KERN_ERR, "can't allocate mem "
2424 				 "for a buddy group");
2425 			goto exit_meta_group_info;
2426 		}
2427 		sbi->s_group_info[group >> EXT4_DESC_PER_BLOCK_BITS(sb)] =
2428 			meta_group_info;
2429 	}
2430 
2431 	meta_group_info =
2432 		sbi->s_group_info[group >> EXT4_DESC_PER_BLOCK_BITS(sb)];
2433 	i = group & (EXT4_DESC_PER_BLOCK(sb) - 1);
2434 
2435 	meta_group_info[i] = kmem_cache_zalloc(cachep, GFP_NOFS);
2436 	if (meta_group_info[i] == NULL) {
2437 		ext4_msg(sb, KERN_ERR, "can't allocate buddy mem");
2438 		goto exit_group_info;
2439 	}
2440 	set_bit(EXT4_GROUP_INFO_NEED_INIT_BIT,
2441 		&(meta_group_info[i]->bb_state));
2442 
2443 	/*
2444 	 * initialize bb_free to be able to skip
2445 	 * empty groups without initialization
2446 	 */
2447 	if (desc->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
2448 		meta_group_info[i]->bb_free =
2449 			ext4_free_clusters_after_init(sb, group, desc);
2450 	} else {
2451 		meta_group_info[i]->bb_free =
2452 			ext4_free_group_clusters(sb, desc);
2453 	}
2454 
2455 	INIT_LIST_HEAD(&meta_group_info[i]->bb_prealloc_list);
2456 	init_rwsem(&meta_group_info[i]->alloc_sem);
2457 	meta_group_info[i]->bb_free_root = RB_ROOT;
2458 	meta_group_info[i]->bb_largest_free_order = -1;  /* uninit */
2459 
2460 #ifdef DOUBLE_CHECK
2461 	{
2462 		struct buffer_head *bh;
2463 		meta_group_info[i]->bb_bitmap =
2464 			kmalloc(sb->s_blocksize, GFP_NOFS);
2465 		BUG_ON(meta_group_info[i]->bb_bitmap == NULL);
2466 		bh = ext4_read_block_bitmap(sb, group);
2467 		BUG_ON(IS_ERR_OR_NULL(bh));
2468 		memcpy(meta_group_info[i]->bb_bitmap, bh->b_data,
2469 			sb->s_blocksize);
2470 		put_bh(bh);
2471 	}
2472 #endif
2473 
2474 	return 0;
2475 
2476 exit_group_info:
2477 	/* If a meta_group_info table has been allocated, release it now */
2478 	if (group % EXT4_DESC_PER_BLOCK(sb) == 0) {
2479 		kfree(sbi->s_group_info[group >> EXT4_DESC_PER_BLOCK_BITS(sb)]);
2480 		sbi->s_group_info[group >> EXT4_DESC_PER_BLOCK_BITS(sb)] = NULL;
2481 	}
2482 exit_meta_group_info:
2483 	return -ENOMEM;
2484 } /* ext4_mb_add_groupinfo */
2485 
ext4_mb_init_backend(struct super_block * sb)2486 static int ext4_mb_init_backend(struct super_block *sb)
2487 {
2488 	ext4_group_t ngroups = ext4_get_groups_count(sb);
2489 	ext4_group_t i;
2490 	struct ext4_sb_info *sbi = EXT4_SB(sb);
2491 	int err;
2492 	struct ext4_group_desc *desc;
2493 	struct kmem_cache *cachep;
2494 
2495 	err = ext4_mb_alloc_groupinfo(sb, ngroups);
2496 	if (err)
2497 		return err;
2498 
2499 	sbi->s_buddy_cache = new_inode(sb);
2500 	if (sbi->s_buddy_cache == NULL) {
2501 		ext4_msg(sb, KERN_ERR, "can't get new inode");
2502 		goto err_freesgi;
2503 	}
2504 	/* To avoid potentially colliding with an valid on-disk inode number,
2505 	 * use EXT4_BAD_INO for the buddy cache inode number.  This inode is
2506 	 * not in the inode hash, so it should never be found by iget(), but
2507 	 * this will avoid confusion if it ever shows up during debugging. */
2508 	sbi->s_buddy_cache->i_ino = EXT4_BAD_INO;
2509 	EXT4_I(sbi->s_buddy_cache)->i_disksize = 0;
2510 	for (i = 0; i < ngroups; i++) {
2511 		desc = ext4_get_group_desc(sb, i, NULL);
2512 		if (desc == NULL) {
2513 			ext4_msg(sb, KERN_ERR, "can't read descriptor %u", i);
2514 			goto err_freebuddy;
2515 		}
2516 		if (ext4_mb_add_groupinfo(sb, i, desc) != 0)
2517 			goto err_freebuddy;
2518 	}
2519 
2520 	return 0;
2521 
2522 err_freebuddy:
2523 	cachep = get_groupinfo_cache(sb->s_blocksize_bits);
2524 	while (i-- > 0)
2525 		kmem_cache_free(cachep, ext4_get_group_info(sb, i));
2526 	i = sbi->s_group_info_size;
2527 	while (i-- > 0)
2528 		kfree(sbi->s_group_info[i]);
2529 	iput(sbi->s_buddy_cache);
2530 err_freesgi:
2531 	kvfree(sbi->s_group_info);
2532 	return -ENOMEM;
2533 }
2534 
ext4_groupinfo_destroy_slabs(void)2535 static void ext4_groupinfo_destroy_slabs(void)
2536 {
2537 	int i;
2538 
2539 	for (i = 0; i < NR_GRPINFO_CACHES; i++) {
2540 		if (ext4_groupinfo_caches[i])
2541 			kmem_cache_destroy(ext4_groupinfo_caches[i]);
2542 		ext4_groupinfo_caches[i] = NULL;
2543 	}
2544 }
2545 
ext4_groupinfo_create_slab(size_t size)2546 static int ext4_groupinfo_create_slab(size_t size)
2547 {
2548 	static DEFINE_MUTEX(ext4_grpinfo_slab_create_mutex);
2549 	int slab_size;
2550 	int blocksize_bits = order_base_2(size);
2551 	int cache_index = blocksize_bits - EXT4_MIN_BLOCK_LOG_SIZE;
2552 	struct kmem_cache *cachep;
2553 
2554 	if (cache_index >= NR_GRPINFO_CACHES)
2555 		return -EINVAL;
2556 
2557 	if (unlikely(cache_index < 0))
2558 		cache_index = 0;
2559 
2560 	mutex_lock(&ext4_grpinfo_slab_create_mutex);
2561 	if (ext4_groupinfo_caches[cache_index]) {
2562 		mutex_unlock(&ext4_grpinfo_slab_create_mutex);
2563 		return 0;	/* Already created */
2564 	}
2565 
2566 	slab_size = offsetof(struct ext4_group_info,
2567 				bb_counters[blocksize_bits + 2]);
2568 
2569 	cachep = kmem_cache_create(ext4_groupinfo_slab_names[cache_index],
2570 					slab_size, 0, SLAB_RECLAIM_ACCOUNT,
2571 					NULL);
2572 
2573 	ext4_groupinfo_caches[cache_index] = cachep;
2574 
2575 	mutex_unlock(&ext4_grpinfo_slab_create_mutex);
2576 	if (!cachep) {
2577 		printk(KERN_EMERG
2578 		       "EXT4-fs: no memory for groupinfo slab cache\n");
2579 		return -ENOMEM;
2580 	}
2581 
2582 	return 0;
2583 }
2584 
ext4_mb_init(struct super_block * sb)2585 int ext4_mb_init(struct super_block *sb)
2586 {
2587 	struct ext4_sb_info *sbi = EXT4_SB(sb);
2588 	unsigned i, j;
2589 	unsigned offset, offset_incr;
2590 	unsigned max;
2591 	int ret;
2592 
2593 	i = (sb->s_blocksize_bits + 2) * sizeof(*sbi->s_mb_offsets);
2594 
2595 	sbi->s_mb_offsets = kmalloc(i, GFP_KERNEL);
2596 	if (sbi->s_mb_offsets == NULL) {
2597 		ret = -ENOMEM;
2598 		goto out;
2599 	}
2600 
2601 	i = (sb->s_blocksize_bits + 2) * sizeof(*sbi->s_mb_maxs);
2602 	sbi->s_mb_maxs = kmalloc(i, GFP_KERNEL);
2603 	if (sbi->s_mb_maxs == NULL) {
2604 		ret = -ENOMEM;
2605 		goto out;
2606 	}
2607 
2608 	ret = ext4_groupinfo_create_slab(sb->s_blocksize);
2609 	if (ret < 0)
2610 		goto out;
2611 
2612 	/* order 0 is regular bitmap */
2613 	sbi->s_mb_maxs[0] = sb->s_blocksize << 3;
2614 	sbi->s_mb_offsets[0] = 0;
2615 
2616 	i = 1;
2617 	offset = 0;
2618 	offset_incr = 1 << (sb->s_blocksize_bits - 1);
2619 	max = sb->s_blocksize << 2;
2620 	do {
2621 		sbi->s_mb_offsets[i] = offset;
2622 		sbi->s_mb_maxs[i] = max;
2623 		offset += offset_incr;
2624 		offset_incr = offset_incr >> 1;
2625 		max = max >> 1;
2626 		i++;
2627 	} while (i <= sb->s_blocksize_bits + 1);
2628 
2629 	spin_lock_init(&sbi->s_md_lock);
2630 	spin_lock_init(&sbi->s_bal_lock);
2631 	sbi->s_mb_free_pending = 0;
2632 
2633 	sbi->s_mb_max_to_scan = MB_DEFAULT_MAX_TO_SCAN;
2634 	sbi->s_mb_min_to_scan = MB_DEFAULT_MIN_TO_SCAN;
2635 	sbi->s_mb_stats = MB_DEFAULT_STATS;
2636 	sbi->s_mb_stream_request = MB_DEFAULT_STREAM_THRESHOLD;
2637 	sbi->s_mb_order2_reqs = MB_DEFAULT_ORDER2_REQS;
2638 	/*
2639 	 * The default group preallocation is 512, which for 4k block
2640 	 * sizes translates to 2 megabytes.  However for bigalloc file
2641 	 * systems, this is probably too big (i.e, if the cluster size
2642 	 * is 1 megabyte, then group preallocation size becomes half a
2643 	 * gigabyte!).  As a default, we will keep a two megabyte
2644 	 * group pralloc size for cluster sizes up to 64k, and after
2645 	 * that, we will force a minimum group preallocation size of
2646 	 * 32 clusters.  This translates to 8 megs when the cluster
2647 	 * size is 256k, and 32 megs when the cluster size is 1 meg,
2648 	 * which seems reasonable as a default.
2649 	 */
2650 	sbi->s_mb_group_prealloc = max(MB_DEFAULT_GROUP_PREALLOC >>
2651 				       sbi->s_cluster_bits, 32);
2652 	/*
2653 	 * If there is a s_stripe > 1, then we set the s_mb_group_prealloc
2654 	 * to the lowest multiple of s_stripe which is bigger than
2655 	 * the s_mb_group_prealloc as determined above. We want
2656 	 * the preallocation size to be an exact multiple of the
2657 	 * RAID stripe size so that preallocations don't fragment
2658 	 * the stripes.
2659 	 */
2660 	if (sbi->s_stripe > 1) {
2661 		sbi->s_mb_group_prealloc = roundup(
2662 			sbi->s_mb_group_prealloc, sbi->s_stripe);
2663 	}
2664 
2665 	sbi->s_locality_groups = alloc_percpu(struct ext4_locality_group);
2666 	if (sbi->s_locality_groups == NULL) {
2667 		ret = -ENOMEM;
2668 		goto out;
2669 	}
2670 	for_each_possible_cpu(i) {
2671 		struct ext4_locality_group *lg;
2672 		lg = per_cpu_ptr(sbi->s_locality_groups, i);
2673 		mutex_init(&lg->lg_mutex);
2674 		for (j = 0; j < PREALLOC_TB_SIZE; j++)
2675 			INIT_LIST_HEAD(&lg->lg_prealloc_list[j]);
2676 		spin_lock_init(&lg->lg_prealloc_lock);
2677 	}
2678 
2679 	/* init file for buddy data */
2680 	ret = ext4_mb_init_backend(sb);
2681 	if (ret != 0)
2682 		goto out_free_locality_groups;
2683 
2684 	return 0;
2685 
2686 out_free_locality_groups:
2687 	free_percpu(sbi->s_locality_groups);
2688 	sbi->s_locality_groups = NULL;
2689 out:
2690 	kfree(sbi->s_mb_offsets);
2691 	sbi->s_mb_offsets = NULL;
2692 	kfree(sbi->s_mb_maxs);
2693 	sbi->s_mb_maxs = NULL;
2694 	return ret;
2695 }
2696 
2697 /* need to called with the ext4 group lock held */
ext4_mb_cleanup_pa(struct ext4_group_info * grp)2698 static void ext4_mb_cleanup_pa(struct ext4_group_info *grp)
2699 {
2700 	struct ext4_prealloc_space *pa;
2701 	struct list_head *cur, *tmp;
2702 	int count = 0;
2703 
2704 	list_for_each_safe(cur, tmp, &grp->bb_prealloc_list) {
2705 		pa = list_entry(cur, struct ext4_prealloc_space, pa_group_list);
2706 		list_del(&pa->pa_group_list);
2707 		count++;
2708 		kmem_cache_free(ext4_pspace_cachep, pa);
2709 	}
2710 	if (count)
2711 		mb_debug(1, "mballoc: %u PAs left\n", count);
2712 
2713 }
2714 
ext4_mb_release(struct super_block * sb)2715 int ext4_mb_release(struct super_block *sb)
2716 {
2717 	ext4_group_t ngroups = ext4_get_groups_count(sb);
2718 	ext4_group_t i;
2719 	int num_meta_group_infos;
2720 	struct ext4_group_info *grinfo;
2721 	struct ext4_sb_info *sbi = EXT4_SB(sb);
2722 	struct kmem_cache *cachep = get_groupinfo_cache(sb->s_blocksize_bits);
2723 
2724 	if (sbi->s_group_info) {
2725 		for (i = 0; i < ngroups; i++) {
2726 			grinfo = ext4_get_group_info(sb, i);
2727 #ifdef DOUBLE_CHECK
2728 			kfree(grinfo->bb_bitmap);
2729 #endif
2730 			ext4_lock_group(sb, i);
2731 			ext4_mb_cleanup_pa(grinfo);
2732 			ext4_unlock_group(sb, i);
2733 			kmem_cache_free(cachep, grinfo);
2734 		}
2735 		num_meta_group_infos = (ngroups +
2736 				EXT4_DESC_PER_BLOCK(sb) - 1) >>
2737 			EXT4_DESC_PER_BLOCK_BITS(sb);
2738 		for (i = 0; i < num_meta_group_infos; i++)
2739 			kfree(sbi->s_group_info[i]);
2740 		kvfree(sbi->s_group_info);
2741 	}
2742 	kfree(sbi->s_mb_offsets);
2743 	kfree(sbi->s_mb_maxs);
2744 	iput(sbi->s_buddy_cache);
2745 	if (sbi->s_mb_stats) {
2746 		ext4_msg(sb, KERN_INFO,
2747 		       "mballoc: %u blocks %u reqs (%u success)",
2748 				atomic_read(&sbi->s_bal_allocated),
2749 				atomic_read(&sbi->s_bal_reqs),
2750 				atomic_read(&sbi->s_bal_success));
2751 		ext4_msg(sb, KERN_INFO,
2752 		      "mballoc: %u extents scanned, %u goal hits, "
2753 				"%u 2^N hits, %u breaks, %u lost",
2754 				atomic_read(&sbi->s_bal_ex_scanned),
2755 				atomic_read(&sbi->s_bal_goals),
2756 				atomic_read(&sbi->s_bal_2orders),
2757 				atomic_read(&sbi->s_bal_breaks),
2758 				atomic_read(&sbi->s_mb_lost_chunks));
2759 		ext4_msg(sb, KERN_INFO,
2760 		       "mballoc: %lu generated and it took %Lu",
2761 				sbi->s_mb_buddies_generated,
2762 				sbi->s_mb_generation_time);
2763 		ext4_msg(sb, KERN_INFO,
2764 		       "mballoc: %u preallocated, %u discarded",
2765 				atomic_read(&sbi->s_mb_preallocated),
2766 				atomic_read(&sbi->s_mb_discarded));
2767 	}
2768 
2769 	free_percpu(sbi->s_locality_groups);
2770 
2771 	return 0;
2772 }
2773 
ext4_issue_discard(struct super_block * sb,ext4_group_t block_group,ext4_grpblk_t cluster,int count,unsigned long flags)2774 static inline int ext4_issue_discard(struct super_block *sb,
2775 		ext4_group_t block_group, ext4_grpblk_t cluster, int count,
2776 		unsigned long flags)
2777 {
2778 	ext4_fsblk_t discard_block;
2779 
2780 	discard_block = (EXT4_C2B(EXT4_SB(sb), cluster) +
2781 			 ext4_group_first_block_no(sb, block_group));
2782 	count = EXT4_C2B(EXT4_SB(sb), count);
2783 	trace_ext4_discard_blocks(sb,
2784 			(unsigned long long) discard_block, count);
2785 	return sb_issue_discard(sb, discard_block, count, GFP_NOFS, flags);
2786 }
2787 
2788 /*
2789  * This function is called by the jbd2 layer once the commit has finished,
2790  * so we know we can free the blocks that were released with that commit.
2791  */
ext4_free_data_callback(struct super_block * sb,struct ext4_journal_cb_entry * jce,int rc)2792 static void ext4_free_data_callback(struct super_block *sb,
2793 				    struct ext4_journal_cb_entry *jce,
2794 				    int rc)
2795 {
2796 	struct ext4_free_data *entry = (struct ext4_free_data *)jce;
2797 	struct ext4_buddy e4b;
2798 	struct ext4_group_info *db;
2799 	int err, count = 0, count2 = 0;
2800 
2801 	mb_debug(1, "gonna free %u blocks in group %u (0x%p):",
2802 		 entry->efd_count, entry->efd_group, entry);
2803 
2804 	if (test_opt(sb, DISCARD)) {
2805 		err = ext4_issue_discard(sb, entry->efd_group,
2806 					 entry->efd_start_cluster,
2807 					 entry->efd_count, 0);
2808 		if (err && err != -EOPNOTSUPP)
2809 			ext4_msg(sb, KERN_WARNING, "discard request in"
2810 				 " group:%d block:%d count:%d failed"
2811 				 " with %d", entry->efd_group,
2812 				 entry->efd_start_cluster,
2813 				 entry->efd_count, err);
2814 	}
2815 
2816 	err = ext4_mb_load_buddy(sb, entry->efd_group, &e4b);
2817 	/* we expect to find existing buddy because it's pinned */
2818 	BUG_ON(err != 0);
2819 
2820 	spin_lock(&EXT4_SB(sb)->s_md_lock);
2821 	EXT4_SB(sb)->s_mb_free_pending -= entry->efd_count;
2822 	spin_unlock(&EXT4_SB(sb)->s_md_lock);
2823 
2824 	db = e4b.bd_info;
2825 	/* there are blocks to put in buddy to make them really free */
2826 	count += entry->efd_count;
2827 	count2++;
2828 	ext4_lock_group(sb, entry->efd_group);
2829 	/* Take it out of per group rb tree */
2830 	rb_erase(&entry->efd_node, &(db->bb_free_root));
2831 	mb_free_blocks(NULL, &e4b, entry->efd_start_cluster, entry->efd_count);
2832 
2833 	/*
2834 	 * Clear the trimmed flag for the group so that the next
2835 	 * ext4_trim_fs can trim it.
2836 	 * If the volume is mounted with -o discard, online discard
2837 	 * is supported and the free blocks will be trimmed online.
2838 	 */
2839 	if (!test_opt(sb, DISCARD))
2840 		EXT4_MB_GRP_CLEAR_TRIMMED(db);
2841 
2842 	if (!db->bb_free_root.rb_node) {
2843 		/* No more items in the per group rb tree
2844 		 * balance refcounts from ext4_mb_free_metadata()
2845 		 */
2846 		put_page(e4b.bd_buddy_page);
2847 		put_page(e4b.bd_bitmap_page);
2848 	}
2849 	ext4_unlock_group(sb, entry->efd_group);
2850 	kmem_cache_free(ext4_free_data_cachep, entry);
2851 	ext4_mb_unload_buddy(&e4b);
2852 
2853 	mb_debug(1, "freed %u blocks in %u structures\n", count, count2);
2854 }
2855 
ext4_init_mballoc(void)2856 int __init ext4_init_mballoc(void)
2857 {
2858 	ext4_pspace_cachep = KMEM_CACHE(ext4_prealloc_space,
2859 					SLAB_RECLAIM_ACCOUNT);
2860 	if (ext4_pspace_cachep == NULL)
2861 		return -ENOMEM;
2862 
2863 	ext4_ac_cachep = KMEM_CACHE(ext4_allocation_context,
2864 				    SLAB_RECLAIM_ACCOUNT);
2865 	if (ext4_ac_cachep == NULL) {
2866 		kmem_cache_destroy(ext4_pspace_cachep);
2867 		return -ENOMEM;
2868 	}
2869 
2870 	ext4_free_data_cachep = KMEM_CACHE(ext4_free_data,
2871 					   SLAB_RECLAIM_ACCOUNT);
2872 	if (ext4_free_data_cachep == NULL) {
2873 		kmem_cache_destroy(ext4_pspace_cachep);
2874 		kmem_cache_destroy(ext4_ac_cachep);
2875 		return -ENOMEM;
2876 	}
2877 	return 0;
2878 }
2879 
ext4_exit_mballoc(void)2880 void ext4_exit_mballoc(void)
2881 {
2882 	/*
2883 	 * Wait for completion of call_rcu()'s on ext4_pspace_cachep
2884 	 * before destroying the slab cache.
2885 	 */
2886 	rcu_barrier();
2887 	kmem_cache_destroy(ext4_pspace_cachep);
2888 	kmem_cache_destroy(ext4_ac_cachep);
2889 	kmem_cache_destroy(ext4_free_data_cachep);
2890 	ext4_groupinfo_destroy_slabs();
2891 }
2892 
2893 
2894 /*
2895  * Check quota and mark chosen space (ac->ac_b_ex) non-free in bitmaps
2896  * Returns 0 if success or error code
2897  */
2898 static noinline_for_stack int
ext4_mb_mark_diskspace_used(struct ext4_allocation_context * ac,handle_t * handle,unsigned int reserv_clstrs)2899 ext4_mb_mark_diskspace_used(struct ext4_allocation_context *ac,
2900 				handle_t *handle, unsigned int reserv_clstrs)
2901 {
2902 	struct buffer_head *bitmap_bh = NULL;
2903 	struct ext4_group_desc *gdp;
2904 	struct buffer_head *gdp_bh;
2905 	struct ext4_sb_info *sbi;
2906 	struct super_block *sb;
2907 	ext4_fsblk_t block;
2908 	int err, len;
2909 
2910 	BUG_ON(ac->ac_status != AC_STATUS_FOUND);
2911 	BUG_ON(ac->ac_b_ex.fe_len <= 0);
2912 
2913 	sb = ac->ac_sb;
2914 	sbi = EXT4_SB(sb);
2915 
2916 	bitmap_bh = ext4_read_block_bitmap(sb, ac->ac_b_ex.fe_group);
2917 	if (IS_ERR(bitmap_bh)) {
2918 		err = PTR_ERR(bitmap_bh);
2919 		bitmap_bh = NULL;
2920 		goto out_err;
2921 	}
2922 
2923 	BUFFER_TRACE(bitmap_bh, "getting write access");
2924 	err = ext4_journal_get_write_access(handle, bitmap_bh);
2925 	if (err)
2926 		goto out_err;
2927 
2928 	err = -EIO;
2929 	gdp = ext4_get_group_desc(sb, ac->ac_b_ex.fe_group, &gdp_bh);
2930 	if (!gdp)
2931 		goto out_err;
2932 
2933 	ext4_debug("using block group %u(%d)\n", ac->ac_b_ex.fe_group,
2934 			ext4_free_group_clusters(sb, gdp));
2935 
2936 	BUFFER_TRACE(gdp_bh, "get_write_access");
2937 	err = ext4_journal_get_write_access(handle, gdp_bh);
2938 	if (err)
2939 		goto out_err;
2940 
2941 	block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
2942 
2943 	len = EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
2944 	if (!ext4_data_block_valid(sbi, block, len)) {
2945 		ext4_error(sb, "Allocating blocks %llu-%llu which overlap "
2946 			   "fs metadata", block, block+len);
2947 		/* File system mounted not to panic on error
2948 		 * Fix the bitmap and return EFSCORRUPTED
2949 		 * We leak some of the blocks here.
2950 		 */
2951 		ext4_lock_group(sb, ac->ac_b_ex.fe_group);
2952 		ext4_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,
2953 			      ac->ac_b_ex.fe_len);
2954 		ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
2955 		err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
2956 		if (!err)
2957 			err = -EFSCORRUPTED;
2958 		goto out_err;
2959 	}
2960 
2961 	ext4_lock_group(sb, ac->ac_b_ex.fe_group);
2962 #ifdef AGGRESSIVE_CHECK
2963 	{
2964 		int i;
2965 		for (i = 0; i < ac->ac_b_ex.fe_len; i++) {
2966 			BUG_ON(mb_test_bit(ac->ac_b_ex.fe_start + i,
2967 						bitmap_bh->b_data));
2968 		}
2969 	}
2970 #endif
2971 	ext4_set_bits(bitmap_bh->b_data, ac->ac_b_ex.fe_start,
2972 		      ac->ac_b_ex.fe_len);
2973 	if (gdp->bg_flags & cpu_to_le16(EXT4_BG_BLOCK_UNINIT)) {
2974 		gdp->bg_flags &= cpu_to_le16(~EXT4_BG_BLOCK_UNINIT);
2975 		ext4_free_group_clusters_set(sb, gdp,
2976 					     ext4_free_clusters_after_init(sb,
2977 						ac->ac_b_ex.fe_group, gdp));
2978 	}
2979 	len = ext4_free_group_clusters(sb, gdp) - ac->ac_b_ex.fe_len;
2980 	ext4_free_group_clusters_set(sb, gdp, len);
2981 	ext4_block_bitmap_csum_set(sb, ac->ac_b_ex.fe_group, gdp, bitmap_bh);
2982 	ext4_group_desc_csum_set(sb, ac->ac_b_ex.fe_group, gdp);
2983 
2984 	ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
2985 	percpu_counter_sub(&sbi->s_freeclusters_counter, ac->ac_b_ex.fe_len);
2986 	/*
2987 	 * Now reduce the dirty block count also. Should not go negative
2988 	 */
2989 	if (!(ac->ac_flags & EXT4_MB_DELALLOC_RESERVED))
2990 		/* release all the reserved blocks if non delalloc */
2991 		percpu_counter_sub(&sbi->s_dirtyclusters_counter,
2992 				   reserv_clstrs);
2993 
2994 	if (sbi->s_log_groups_per_flex) {
2995 		ext4_group_t flex_group = ext4_flex_group(sbi,
2996 							  ac->ac_b_ex.fe_group);
2997 		atomic64_sub(ac->ac_b_ex.fe_len,
2998 			     &sbi->s_flex_groups[flex_group].free_clusters);
2999 	}
3000 
3001 	err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
3002 	if (err)
3003 		goto out_err;
3004 	err = ext4_handle_dirty_metadata(handle, NULL, gdp_bh);
3005 
3006 out_err:
3007 	brelse(bitmap_bh);
3008 	return err;
3009 }
3010 
3011 /*
3012  * here we normalize request for locality group
3013  * Group request are normalized to s_mb_group_prealloc, which goes to
3014  * s_strip if we set the same via mount option.
3015  * s_mb_group_prealloc can be configured via
3016  * /sys/fs/ext4/<partition>/mb_group_prealloc
3017  *
3018  * XXX: should we try to preallocate more than the group has now?
3019  */
ext4_mb_normalize_group_request(struct ext4_allocation_context * ac)3020 static void ext4_mb_normalize_group_request(struct ext4_allocation_context *ac)
3021 {
3022 	struct super_block *sb = ac->ac_sb;
3023 	struct ext4_locality_group *lg = ac->ac_lg;
3024 
3025 	BUG_ON(lg == NULL);
3026 	ac->ac_g_ex.fe_len = EXT4_SB(sb)->s_mb_group_prealloc;
3027 	mb_debug(1, "#%u: goal %u blocks for locality group\n",
3028 		current->pid, ac->ac_g_ex.fe_len);
3029 }
3030 
3031 /*
3032  * Normalization means making request better in terms of
3033  * size and alignment
3034  */
3035 static noinline_for_stack void
ext4_mb_normalize_request(struct ext4_allocation_context * ac,struct ext4_allocation_request * ar)3036 ext4_mb_normalize_request(struct ext4_allocation_context *ac,
3037 				struct ext4_allocation_request *ar)
3038 {
3039 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
3040 	int bsbits, max;
3041 	ext4_lblk_t end;
3042 	loff_t size, start_off;
3043 	loff_t orig_size __maybe_unused;
3044 	ext4_lblk_t start;
3045 	struct ext4_inode_info *ei = EXT4_I(ac->ac_inode);
3046 	struct ext4_prealloc_space *pa;
3047 
3048 	/* do normalize only data requests, metadata requests
3049 	   do not need preallocation */
3050 	if (!(ac->ac_flags & EXT4_MB_HINT_DATA))
3051 		return;
3052 
3053 	/* sometime caller may want exact blocks */
3054 	if (unlikely(ac->ac_flags & EXT4_MB_HINT_GOAL_ONLY))
3055 		return;
3056 
3057 	/* caller may indicate that preallocation isn't
3058 	 * required (it's a tail, for example) */
3059 	if (ac->ac_flags & EXT4_MB_HINT_NOPREALLOC)
3060 		return;
3061 
3062 	if (ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC) {
3063 		ext4_mb_normalize_group_request(ac);
3064 		return ;
3065 	}
3066 
3067 	bsbits = ac->ac_sb->s_blocksize_bits;
3068 
3069 	/* first, let's learn actual file size
3070 	 * given current request is allocated */
3071 	size = ac->ac_o_ex.fe_logical + EXT4_C2B(sbi, ac->ac_o_ex.fe_len);
3072 	size = size << bsbits;
3073 	if (size < i_size_read(ac->ac_inode))
3074 		size = i_size_read(ac->ac_inode);
3075 	orig_size = size;
3076 
3077 	/* max size of free chunks */
3078 	max = 2 << bsbits;
3079 
3080 #define NRL_CHECK_SIZE(req, size, max, chunk_size)	\
3081 		(req <= (size) || max <= (chunk_size))
3082 
3083 	/* first, try to predict filesize */
3084 	/* XXX: should this table be tunable? */
3085 	start_off = 0;
3086 	if (size <= 16 * 1024) {
3087 		size = 16 * 1024;
3088 	} else if (size <= 32 * 1024) {
3089 		size = 32 * 1024;
3090 	} else if (size <= 64 * 1024) {
3091 		size = 64 * 1024;
3092 	} else if (size <= 128 * 1024) {
3093 		size = 128 * 1024;
3094 	} else if (size <= 256 * 1024) {
3095 		size = 256 * 1024;
3096 	} else if (size <= 512 * 1024) {
3097 		size = 512 * 1024;
3098 	} else if (size <= 1024 * 1024) {
3099 		size = 1024 * 1024;
3100 	} else if (NRL_CHECK_SIZE(size, 4 * 1024 * 1024, max, 2 * 1024)) {
3101 		start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
3102 						(21 - bsbits)) << 21;
3103 		size = 2 * 1024 * 1024;
3104 	} else if (NRL_CHECK_SIZE(size, 8 * 1024 * 1024, max, 4 * 1024)) {
3105 		start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
3106 							(22 - bsbits)) << 22;
3107 		size = 4 * 1024 * 1024;
3108 	} else if (NRL_CHECK_SIZE(ac->ac_o_ex.fe_len,
3109 					(8<<20)>>bsbits, max, 8 * 1024)) {
3110 		start_off = ((loff_t)ac->ac_o_ex.fe_logical >>
3111 							(23 - bsbits)) << 23;
3112 		size = 8 * 1024 * 1024;
3113 	} else {
3114 		start_off = (loff_t) ac->ac_o_ex.fe_logical << bsbits;
3115 		size	  = (loff_t) EXT4_C2B(EXT4_SB(ac->ac_sb),
3116 					      ac->ac_o_ex.fe_len) << bsbits;
3117 	}
3118 	size = size >> bsbits;
3119 	start = start_off >> bsbits;
3120 
3121 	/* don't cover already allocated blocks in selected range */
3122 	if (ar->pleft && start <= ar->lleft) {
3123 		size -= ar->lleft + 1 - start;
3124 		start = ar->lleft + 1;
3125 	}
3126 	if (ar->pright && start + size - 1 >= ar->lright)
3127 		size -= start + size - ar->lright;
3128 
3129 	/*
3130 	 * Trim allocation request for filesystems with artificially small
3131 	 * groups.
3132 	 */
3133 	if (size > EXT4_BLOCKS_PER_GROUP(ac->ac_sb))
3134 		size = EXT4_BLOCKS_PER_GROUP(ac->ac_sb);
3135 
3136 	end = start + size;
3137 
3138 	/* check we don't cross already preallocated blocks */
3139 	rcu_read_lock();
3140 	list_for_each_entry_rcu(pa, &ei->i_prealloc_list, pa_inode_list) {
3141 		ext4_lblk_t pa_end;
3142 
3143 		if (pa->pa_deleted)
3144 			continue;
3145 		spin_lock(&pa->pa_lock);
3146 		if (pa->pa_deleted) {
3147 			spin_unlock(&pa->pa_lock);
3148 			continue;
3149 		}
3150 
3151 		pa_end = pa->pa_lstart + EXT4_C2B(EXT4_SB(ac->ac_sb),
3152 						  pa->pa_len);
3153 
3154 		/* PA must not overlap original request */
3155 		BUG_ON(!(ac->ac_o_ex.fe_logical >= pa_end ||
3156 			ac->ac_o_ex.fe_logical < pa->pa_lstart));
3157 
3158 		/* skip PAs this normalized request doesn't overlap with */
3159 		if (pa->pa_lstart >= end || pa_end <= start) {
3160 			spin_unlock(&pa->pa_lock);
3161 			continue;
3162 		}
3163 		BUG_ON(pa->pa_lstart <= start && pa_end >= end);
3164 
3165 		/* adjust start or end to be adjacent to this pa */
3166 		if (pa_end <= ac->ac_o_ex.fe_logical) {
3167 			BUG_ON(pa_end < start);
3168 			start = pa_end;
3169 		} else if (pa->pa_lstart > ac->ac_o_ex.fe_logical) {
3170 			BUG_ON(pa->pa_lstart > end);
3171 			end = pa->pa_lstart;
3172 		}
3173 		spin_unlock(&pa->pa_lock);
3174 	}
3175 	rcu_read_unlock();
3176 	size = end - start;
3177 
3178 	/* XXX: extra loop to check we really don't overlap preallocations */
3179 	rcu_read_lock();
3180 	list_for_each_entry_rcu(pa, &ei->i_prealloc_list, pa_inode_list) {
3181 		ext4_lblk_t pa_end;
3182 
3183 		spin_lock(&pa->pa_lock);
3184 		if (pa->pa_deleted == 0) {
3185 			pa_end = pa->pa_lstart + EXT4_C2B(EXT4_SB(ac->ac_sb),
3186 							  pa->pa_len);
3187 			BUG_ON(!(start >= pa_end || end <= pa->pa_lstart));
3188 		}
3189 		spin_unlock(&pa->pa_lock);
3190 	}
3191 	rcu_read_unlock();
3192 
3193 	if (start + size <= ac->ac_o_ex.fe_logical &&
3194 			start > ac->ac_o_ex.fe_logical) {
3195 		ext4_msg(ac->ac_sb, KERN_ERR,
3196 			 "start %lu, size %lu, fe_logical %lu",
3197 			 (unsigned long) start, (unsigned long) size,
3198 			 (unsigned long) ac->ac_o_ex.fe_logical);
3199 		BUG();
3200 	}
3201 	BUG_ON(size <= 0 || size > EXT4_BLOCKS_PER_GROUP(ac->ac_sb));
3202 
3203 	/* now prepare goal request */
3204 
3205 	/* XXX: is it better to align blocks WRT to logical
3206 	 * placement or satisfy big request as is */
3207 	ac->ac_g_ex.fe_logical = start;
3208 	ac->ac_g_ex.fe_len = EXT4_NUM_B2C(sbi, size);
3209 
3210 	/* define goal start in order to merge */
3211 	if (ar->pright && (ar->lright == (start + size))) {
3212 		/* merge to the right */
3213 		ext4_get_group_no_and_offset(ac->ac_sb, ar->pright - size,
3214 						&ac->ac_f_ex.fe_group,
3215 						&ac->ac_f_ex.fe_start);
3216 		ac->ac_flags |= EXT4_MB_HINT_TRY_GOAL;
3217 	}
3218 	if (ar->pleft && (ar->lleft + 1 == start)) {
3219 		/* merge to the left */
3220 		ext4_get_group_no_and_offset(ac->ac_sb, ar->pleft + 1,
3221 						&ac->ac_f_ex.fe_group,
3222 						&ac->ac_f_ex.fe_start);
3223 		ac->ac_flags |= EXT4_MB_HINT_TRY_GOAL;
3224 	}
3225 
3226 	mb_debug(1, "goal: %u(was %u) blocks at %u\n", (unsigned) size,
3227 		(unsigned) orig_size, (unsigned) start);
3228 }
3229 
ext4_mb_collect_stats(struct ext4_allocation_context * ac)3230 static void ext4_mb_collect_stats(struct ext4_allocation_context *ac)
3231 {
3232 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
3233 
3234 	if (sbi->s_mb_stats && ac->ac_g_ex.fe_len > 1) {
3235 		atomic_inc(&sbi->s_bal_reqs);
3236 		atomic_add(ac->ac_b_ex.fe_len, &sbi->s_bal_allocated);
3237 		if (ac->ac_b_ex.fe_len >= ac->ac_o_ex.fe_len)
3238 			atomic_inc(&sbi->s_bal_success);
3239 		atomic_add(ac->ac_found, &sbi->s_bal_ex_scanned);
3240 		if (ac->ac_g_ex.fe_start == ac->ac_b_ex.fe_start &&
3241 				ac->ac_g_ex.fe_group == ac->ac_b_ex.fe_group)
3242 			atomic_inc(&sbi->s_bal_goals);
3243 		if (ac->ac_found > sbi->s_mb_max_to_scan)
3244 			atomic_inc(&sbi->s_bal_breaks);
3245 	}
3246 
3247 	if (ac->ac_op == EXT4_MB_HISTORY_ALLOC)
3248 		trace_ext4_mballoc_alloc(ac);
3249 	else
3250 		trace_ext4_mballoc_prealloc(ac);
3251 }
3252 
3253 /*
3254  * Called on failure; free up any blocks from the inode PA for this
3255  * context.  We don't need this for MB_GROUP_PA because we only change
3256  * pa_free in ext4_mb_release_context(), but on failure, we've already
3257  * zeroed out ac->ac_b_ex.fe_len, so group_pa->pa_free is not changed.
3258  */
ext4_discard_allocated_blocks(struct ext4_allocation_context * ac)3259 static void ext4_discard_allocated_blocks(struct ext4_allocation_context *ac)
3260 {
3261 	struct ext4_prealloc_space *pa = ac->ac_pa;
3262 	struct ext4_buddy e4b;
3263 	int err;
3264 
3265 	if (pa == NULL) {
3266 		if (ac->ac_f_ex.fe_len == 0)
3267 			return;
3268 		err = ext4_mb_load_buddy(ac->ac_sb, ac->ac_f_ex.fe_group, &e4b);
3269 		if (err) {
3270 			/*
3271 			 * This should never happen since we pin the
3272 			 * pages in the ext4_allocation_context so
3273 			 * ext4_mb_load_buddy() should never fail.
3274 			 */
3275 			WARN(1, "mb_load_buddy failed (%d)", err);
3276 			return;
3277 		}
3278 		ext4_lock_group(ac->ac_sb, ac->ac_f_ex.fe_group);
3279 		mb_free_blocks(ac->ac_inode, &e4b, ac->ac_f_ex.fe_start,
3280 			       ac->ac_f_ex.fe_len);
3281 		ext4_unlock_group(ac->ac_sb, ac->ac_f_ex.fe_group);
3282 		ext4_mb_unload_buddy(&e4b);
3283 		return;
3284 	}
3285 	if (pa->pa_type == MB_INODE_PA)
3286 		pa->pa_free += ac->ac_b_ex.fe_len;
3287 }
3288 
3289 /*
3290  * use blocks preallocated to inode
3291  */
ext4_mb_use_inode_pa(struct ext4_allocation_context * ac,struct ext4_prealloc_space * pa)3292 static void ext4_mb_use_inode_pa(struct ext4_allocation_context *ac,
3293 				struct ext4_prealloc_space *pa)
3294 {
3295 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
3296 	ext4_fsblk_t start;
3297 	ext4_fsblk_t end;
3298 	int len;
3299 
3300 	/* found preallocated blocks, use them */
3301 	start = pa->pa_pstart + (ac->ac_o_ex.fe_logical - pa->pa_lstart);
3302 	end = min(pa->pa_pstart + EXT4_C2B(sbi, pa->pa_len),
3303 		  start + EXT4_C2B(sbi, ac->ac_o_ex.fe_len));
3304 	len = EXT4_NUM_B2C(sbi, end - start);
3305 	ext4_get_group_no_and_offset(ac->ac_sb, start, &ac->ac_b_ex.fe_group,
3306 					&ac->ac_b_ex.fe_start);
3307 	ac->ac_b_ex.fe_len = len;
3308 	ac->ac_status = AC_STATUS_FOUND;
3309 	ac->ac_pa = pa;
3310 
3311 	BUG_ON(start < pa->pa_pstart);
3312 	BUG_ON(end > pa->pa_pstart + EXT4_C2B(sbi, pa->pa_len));
3313 	BUG_ON(pa->pa_free < len);
3314 	pa->pa_free -= len;
3315 
3316 	mb_debug(1, "use %llu/%u from inode pa %p\n", start, len, pa);
3317 }
3318 
3319 /*
3320  * use blocks preallocated to locality group
3321  */
ext4_mb_use_group_pa(struct ext4_allocation_context * ac,struct ext4_prealloc_space * pa)3322 static void ext4_mb_use_group_pa(struct ext4_allocation_context *ac,
3323 				struct ext4_prealloc_space *pa)
3324 {
3325 	unsigned int len = ac->ac_o_ex.fe_len;
3326 
3327 	ext4_get_group_no_and_offset(ac->ac_sb, pa->pa_pstart,
3328 					&ac->ac_b_ex.fe_group,
3329 					&ac->ac_b_ex.fe_start);
3330 	ac->ac_b_ex.fe_len = len;
3331 	ac->ac_status = AC_STATUS_FOUND;
3332 	ac->ac_pa = pa;
3333 
3334 	/* we don't correct pa_pstart or pa_plen here to avoid
3335 	 * possible race when the group is being loaded concurrently
3336 	 * instead we correct pa later, after blocks are marked
3337 	 * in on-disk bitmap -- see ext4_mb_release_context()
3338 	 * Other CPUs are prevented from allocating from this pa by lg_mutex
3339 	 */
3340 	mb_debug(1, "use %u/%u from group pa %p\n", pa->pa_lstart-len, len, pa);
3341 }
3342 
3343 /*
3344  * Return the prealloc space that have minimal distance
3345  * from the goal block. @cpa is the prealloc
3346  * space that is having currently known minimal distance
3347  * from the goal block.
3348  */
3349 static struct ext4_prealloc_space *
ext4_mb_check_group_pa(ext4_fsblk_t goal_block,struct ext4_prealloc_space * pa,struct ext4_prealloc_space * cpa)3350 ext4_mb_check_group_pa(ext4_fsblk_t goal_block,
3351 			struct ext4_prealloc_space *pa,
3352 			struct ext4_prealloc_space *cpa)
3353 {
3354 	ext4_fsblk_t cur_distance, new_distance;
3355 
3356 	if (cpa == NULL) {
3357 		atomic_inc(&pa->pa_count);
3358 		return pa;
3359 	}
3360 	cur_distance = abs(goal_block - cpa->pa_pstart);
3361 	new_distance = abs(goal_block - pa->pa_pstart);
3362 
3363 	if (cur_distance <= new_distance)
3364 		return cpa;
3365 
3366 	/* drop the previous reference */
3367 	atomic_dec(&cpa->pa_count);
3368 	atomic_inc(&pa->pa_count);
3369 	return pa;
3370 }
3371 
3372 /*
3373  * search goal blocks in preallocated space
3374  */
3375 static noinline_for_stack int
ext4_mb_use_preallocated(struct ext4_allocation_context * ac)3376 ext4_mb_use_preallocated(struct ext4_allocation_context *ac)
3377 {
3378 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
3379 	int order, i;
3380 	struct ext4_inode_info *ei = EXT4_I(ac->ac_inode);
3381 	struct ext4_locality_group *lg;
3382 	struct ext4_prealloc_space *pa, *cpa = NULL;
3383 	ext4_fsblk_t goal_block;
3384 
3385 	/* only data can be preallocated */
3386 	if (!(ac->ac_flags & EXT4_MB_HINT_DATA))
3387 		return 0;
3388 
3389 	/* first, try per-file preallocation */
3390 	rcu_read_lock();
3391 	list_for_each_entry_rcu(pa, &ei->i_prealloc_list, pa_inode_list) {
3392 
3393 		/* all fields in this condition don't change,
3394 		 * so we can skip locking for them */
3395 		if (ac->ac_o_ex.fe_logical < pa->pa_lstart ||
3396 		    ac->ac_o_ex.fe_logical >= (pa->pa_lstart +
3397 					       EXT4_C2B(sbi, pa->pa_len)))
3398 			continue;
3399 
3400 		/* non-extent files can't have physical blocks past 2^32 */
3401 		if (!(ext4_test_inode_flag(ac->ac_inode, EXT4_INODE_EXTENTS)) &&
3402 		    (pa->pa_pstart + EXT4_C2B(sbi, pa->pa_len) >
3403 		     EXT4_MAX_BLOCK_FILE_PHYS))
3404 			continue;
3405 
3406 		/* found preallocated blocks, use them */
3407 		spin_lock(&pa->pa_lock);
3408 		if (pa->pa_deleted == 0 && pa->pa_free) {
3409 			atomic_inc(&pa->pa_count);
3410 			ext4_mb_use_inode_pa(ac, pa);
3411 			spin_unlock(&pa->pa_lock);
3412 			ac->ac_criteria = 10;
3413 			rcu_read_unlock();
3414 			return 1;
3415 		}
3416 		spin_unlock(&pa->pa_lock);
3417 	}
3418 	rcu_read_unlock();
3419 
3420 	/* can we use group allocation? */
3421 	if (!(ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC))
3422 		return 0;
3423 
3424 	/* inode may have no locality group for some reason */
3425 	lg = ac->ac_lg;
3426 	if (lg == NULL)
3427 		return 0;
3428 	order  = fls(ac->ac_o_ex.fe_len) - 1;
3429 	if (order > PREALLOC_TB_SIZE - 1)
3430 		/* The max size of hash table is PREALLOC_TB_SIZE */
3431 		order = PREALLOC_TB_SIZE - 1;
3432 
3433 	goal_block = ext4_grp_offs_to_block(ac->ac_sb, &ac->ac_g_ex);
3434 	/*
3435 	 * search for the prealloc space that is having
3436 	 * minimal distance from the goal block.
3437 	 */
3438 	for (i = order; i < PREALLOC_TB_SIZE; i++) {
3439 		rcu_read_lock();
3440 		list_for_each_entry_rcu(pa, &lg->lg_prealloc_list[i],
3441 					pa_inode_list) {
3442 			spin_lock(&pa->pa_lock);
3443 			if (pa->pa_deleted == 0 &&
3444 					pa->pa_free >= ac->ac_o_ex.fe_len) {
3445 
3446 				cpa = ext4_mb_check_group_pa(goal_block,
3447 								pa, cpa);
3448 			}
3449 			spin_unlock(&pa->pa_lock);
3450 		}
3451 		rcu_read_unlock();
3452 	}
3453 	if (cpa) {
3454 		ext4_mb_use_group_pa(ac, cpa);
3455 		ac->ac_criteria = 20;
3456 		return 1;
3457 	}
3458 	return 0;
3459 }
3460 
3461 /*
3462  * the function goes through all block freed in the group
3463  * but not yet committed and marks them used in in-core bitmap.
3464  * buddy must be generated from this bitmap
3465  * Need to be called with the ext4 group lock held
3466  */
ext4_mb_generate_from_freelist(struct super_block * sb,void * bitmap,ext4_group_t group)3467 static void ext4_mb_generate_from_freelist(struct super_block *sb, void *bitmap,
3468 						ext4_group_t group)
3469 {
3470 	struct rb_node *n;
3471 	struct ext4_group_info *grp;
3472 	struct ext4_free_data *entry;
3473 
3474 	grp = ext4_get_group_info(sb, group);
3475 	n = rb_first(&(grp->bb_free_root));
3476 
3477 	while (n) {
3478 		entry = rb_entry(n, struct ext4_free_data, efd_node);
3479 		ext4_set_bits(bitmap, entry->efd_start_cluster, entry->efd_count);
3480 		n = rb_next(n);
3481 	}
3482 	return;
3483 }
3484 
3485 /*
3486  * the function goes through all preallocation in this group and marks them
3487  * used in in-core bitmap. buddy must be generated from this bitmap
3488  * Need to be called with ext4 group lock held
3489  */
3490 static noinline_for_stack
ext4_mb_generate_from_pa(struct super_block * sb,void * bitmap,ext4_group_t group)3491 void ext4_mb_generate_from_pa(struct super_block *sb, void *bitmap,
3492 					ext4_group_t group)
3493 {
3494 	struct ext4_group_info *grp = ext4_get_group_info(sb, group);
3495 	struct ext4_prealloc_space *pa;
3496 	struct list_head *cur;
3497 	ext4_group_t groupnr;
3498 	ext4_grpblk_t start;
3499 	int preallocated = 0;
3500 	int len;
3501 
3502 	/* all form of preallocation discards first load group,
3503 	 * so the only competing code is preallocation use.
3504 	 * we don't need any locking here
3505 	 * notice we do NOT ignore preallocations with pa_deleted
3506 	 * otherwise we could leave used blocks available for
3507 	 * allocation in buddy when concurrent ext4_mb_put_pa()
3508 	 * is dropping preallocation
3509 	 */
3510 	list_for_each(cur, &grp->bb_prealloc_list) {
3511 		pa = list_entry(cur, struct ext4_prealloc_space, pa_group_list);
3512 		spin_lock(&pa->pa_lock);
3513 		ext4_get_group_no_and_offset(sb, pa->pa_pstart,
3514 					     &groupnr, &start);
3515 		len = pa->pa_len;
3516 		spin_unlock(&pa->pa_lock);
3517 		if (unlikely(len == 0))
3518 			continue;
3519 		BUG_ON(groupnr != group);
3520 		ext4_set_bits(bitmap, start, len);
3521 		preallocated += len;
3522 	}
3523 	mb_debug(1, "prellocated %u for group %u\n", preallocated, group);
3524 }
3525 
ext4_mb_pa_callback(struct rcu_head * head)3526 static void ext4_mb_pa_callback(struct rcu_head *head)
3527 {
3528 	struct ext4_prealloc_space *pa;
3529 	pa = container_of(head, struct ext4_prealloc_space, u.pa_rcu);
3530 
3531 	BUG_ON(atomic_read(&pa->pa_count));
3532 	BUG_ON(pa->pa_deleted == 0);
3533 	kmem_cache_free(ext4_pspace_cachep, pa);
3534 }
3535 
3536 /*
3537  * drops a reference to preallocated space descriptor
3538  * if this was the last reference and the space is consumed
3539  */
ext4_mb_put_pa(struct ext4_allocation_context * ac,struct super_block * sb,struct ext4_prealloc_space * pa)3540 static void ext4_mb_put_pa(struct ext4_allocation_context *ac,
3541 			struct super_block *sb, struct ext4_prealloc_space *pa)
3542 {
3543 	ext4_group_t grp;
3544 	ext4_fsblk_t grp_blk;
3545 
3546 	/* in this short window concurrent discard can set pa_deleted */
3547 	spin_lock(&pa->pa_lock);
3548 	if (!atomic_dec_and_test(&pa->pa_count) || pa->pa_free != 0) {
3549 		spin_unlock(&pa->pa_lock);
3550 		return;
3551 	}
3552 
3553 	if (pa->pa_deleted == 1) {
3554 		spin_unlock(&pa->pa_lock);
3555 		return;
3556 	}
3557 
3558 	pa->pa_deleted = 1;
3559 	spin_unlock(&pa->pa_lock);
3560 
3561 	grp_blk = pa->pa_pstart;
3562 	/*
3563 	 * If doing group-based preallocation, pa_pstart may be in the
3564 	 * next group when pa is used up
3565 	 */
3566 	if (pa->pa_type == MB_GROUP_PA)
3567 		grp_blk--;
3568 
3569 	grp = ext4_get_group_number(sb, grp_blk);
3570 
3571 	/*
3572 	 * possible race:
3573 	 *
3574 	 *  P1 (buddy init)			P2 (regular allocation)
3575 	 *					find block B in PA
3576 	 *  copy on-disk bitmap to buddy
3577 	 *  					mark B in on-disk bitmap
3578 	 *					drop PA from group
3579 	 *  mark all PAs in buddy
3580 	 *
3581 	 * thus, P1 initializes buddy with B available. to prevent this
3582 	 * we make "copy" and "mark all PAs" atomic and serialize "drop PA"
3583 	 * against that pair
3584 	 */
3585 	ext4_lock_group(sb, grp);
3586 	list_del(&pa->pa_group_list);
3587 	ext4_unlock_group(sb, grp);
3588 
3589 	spin_lock(pa->pa_obj_lock);
3590 	list_del_rcu(&pa->pa_inode_list);
3591 	spin_unlock(pa->pa_obj_lock);
3592 
3593 	call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
3594 }
3595 
3596 /*
3597  * creates new preallocated space for given inode
3598  */
3599 static noinline_for_stack int
ext4_mb_new_inode_pa(struct ext4_allocation_context * ac)3600 ext4_mb_new_inode_pa(struct ext4_allocation_context *ac)
3601 {
3602 	struct super_block *sb = ac->ac_sb;
3603 	struct ext4_sb_info *sbi = EXT4_SB(sb);
3604 	struct ext4_prealloc_space *pa;
3605 	struct ext4_group_info *grp;
3606 	struct ext4_inode_info *ei;
3607 
3608 	/* preallocate only when found space is larger then requested */
3609 	BUG_ON(ac->ac_o_ex.fe_len >= ac->ac_b_ex.fe_len);
3610 	BUG_ON(ac->ac_status != AC_STATUS_FOUND);
3611 	BUG_ON(!S_ISREG(ac->ac_inode->i_mode));
3612 
3613 	pa = kmem_cache_alloc(ext4_pspace_cachep, GFP_NOFS);
3614 	if (pa == NULL)
3615 		return -ENOMEM;
3616 
3617 	if (ac->ac_b_ex.fe_len < ac->ac_g_ex.fe_len) {
3618 		int winl;
3619 		int wins;
3620 		int win;
3621 		int offs;
3622 
3623 		/* we can't allocate as much as normalizer wants.
3624 		 * so, found space must get proper lstart
3625 		 * to cover original request */
3626 		BUG_ON(ac->ac_g_ex.fe_logical > ac->ac_o_ex.fe_logical);
3627 		BUG_ON(ac->ac_g_ex.fe_len < ac->ac_o_ex.fe_len);
3628 
3629 		/* we're limited by original request in that
3630 		 * logical block must be covered any way
3631 		 * winl is window we can move our chunk within */
3632 		winl = ac->ac_o_ex.fe_logical - ac->ac_g_ex.fe_logical;
3633 
3634 		/* also, we should cover whole original request */
3635 		wins = EXT4_C2B(sbi, ac->ac_b_ex.fe_len - ac->ac_o_ex.fe_len);
3636 
3637 		/* the smallest one defines real window */
3638 		win = min(winl, wins);
3639 
3640 		offs = ac->ac_o_ex.fe_logical %
3641 			EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
3642 		if (offs && offs < win)
3643 			win = offs;
3644 
3645 		ac->ac_b_ex.fe_logical = ac->ac_o_ex.fe_logical -
3646 			EXT4_NUM_B2C(sbi, win);
3647 		BUG_ON(ac->ac_o_ex.fe_logical < ac->ac_b_ex.fe_logical);
3648 		BUG_ON(ac->ac_o_ex.fe_len > ac->ac_b_ex.fe_len);
3649 	}
3650 
3651 	/* preallocation can change ac_b_ex, thus we store actually
3652 	 * allocated blocks for history */
3653 	ac->ac_f_ex = ac->ac_b_ex;
3654 
3655 	pa->pa_lstart = ac->ac_b_ex.fe_logical;
3656 	pa->pa_pstart = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
3657 	pa->pa_len = ac->ac_b_ex.fe_len;
3658 	pa->pa_free = pa->pa_len;
3659 	atomic_set(&pa->pa_count, 1);
3660 	spin_lock_init(&pa->pa_lock);
3661 	INIT_LIST_HEAD(&pa->pa_inode_list);
3662 	INIT_LIST_HEAD(&pa->pa_group_list);
3663 	pa->pa_deleted = 0;
3664 	pa->pa_type = MB_INODE_PA;
3665 
3666 	mb_debug(1, "new inode pa %p: %llu/%u for %u\n", pa,
3667 			pa->pa_pstart, pa->pa_len, pa->pa_lstart);
3668 	trace_ext4_mb_new_inode_pa(ac, pa);
3669 
3670 	ext4_mb_use_inode_pa(ac, pa);
3671 	atomic_add(pa->pa_free, &sbi->s_mb_preallocated);
3672 
3673 	ei = EXT4_I(ac->ac_inode);
3674 	grp = ext4_get_group_info(sb, ac->ac_b_ex.fe_group);
3675 
3676 	pa->pa_obj_lock = &ei->i_prealloc_lock;
3677 	pa->pa_inode = ac->ac_inode;
3678 
3679 	ext4_lock_group(sb, ac->ac_b_ex.fe_group);
3680 	list_add(&pa->pa_group_list, &grp->bb_prealloc_list);
3681 	ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
3682 
3683 	spin_lock(pa->pa_obj_lock);
3684 	list_add_rcu(&pa->pa_inode_list, &ei->i_prealloc_list);
3685 	spin_unlock(pa->pa_obj_lock);
3686 
3687 	return 0;
3688 }
3689 
3690 /*
3691  * creates new preallocated space for locality group inodes belongs to
3692  */
3693 static noinline_for_stack int
ext4_mb_new_group_pa(struct ext4_allocation_context * ac)3694 ext4_mb_new_group_pa(struct ext4_allocation_context *ac)
3695 {
3696 	struct super_block *sb = ac->ac_sb;
3697 	struct ext4_locality_group *lg;
3698 	struct ext4_prealloc_space *pa;
3699 	struct ext4_group_info *grp;
3700 
3701 	/* preallocate only when found space is larger then requested */
3702 	BUG_ON(ac->ac_o_ex.fe_len >= ac->ac_b_ex.fe_len);
3703 	BUG_ON(ac->ac_status != AC_STATUS_FOUND);
3704 	BUG_ON(!S_ISREG(ac->ac_inode->i_mode));
3705 
3706 	BUG_ON(ext4_pspace_cachep == NULL);
3707 	pa = kmem_cache_alloc(ext4_pspace_cachep, GFP_NOFS);
3708 	if (pa == NULL)
3709 		return -ENOMEM;
3710 
3711 	/* preallocation can change ac_b_ex, thus we store actually
3712 	 * allocated blocks for history */
3713 	ac->ac_f_ex = ac->ac_b_ex;
3714 
3715 	pa->pa_pstart = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
3716 	pa->pa_lstart = pa->pa_pstart;
3717 	pa->pa_len = ac->ac_b_ex.fe_len;
3718 	pa->pa_free = pa->pa_len;
3719 	atomic_set(&pa->pa_count, 1);
3720 	spin_lock_init(&pa->pa_lock);
3721 	INIT_LIST_HEAD(&pa->pa_inode_list);
3722 	INIT_LIST_HEAD(&pa->pa_group_list);
3723 	pa->pa_deleted = 0;
3724 	pa->pa_type = MB_GROUP_PA;
3725 
3726 	mb_debug(1, "new group pa %p: %llu/%u for %u\n", pa,
3727 			pa->pa_pstart, pa->pa_len, pa->pa_lstart);
3728 	trace_ext4_mb_new_group_pa(ac, pa);
3729 
3730 	ext4_mb_use_group_pa(ac, pa);
3731 	atomic_add(pa->pa_free, &EXT4_SB(sb)->s_mb_preallocated);
3732 
3733 	grp = ext4_get_group_info(sb, ac->ac_b_ex.fe_group);
3734 	lg = ac->ac_lg;
3735 	BUG_ON(lg == NULL);
3736 
3737 	pa->pa_obj_lock = &lg->lg_prealloc_lock;
3738 	pa->pa_inode = NULL;
3739 
3740 	ext4_lock_group(sb, ac->ac_b_ex.fe_group);
3741 	list_add(&pa->pa_group_list, &grp->bb_prealloc_list);
3742 	ext4_unlock_group(sb, ac->ac_b_ex.fe_group);
3743 
3744 	/*
3745 	 * We will later add the new pa to the right bucket
3746 	 * after updating the pa_free in ext4_mb_release_context
3747 	 */
3748 	return 0;
3749 }
3750 
ext4_mb_new_preallocation(struct ext4_allocation_context * ac)3751 static int ext4_mb_new_preallocation(struct ext4_allocation_context *ac)
3752 {
3753 	int err;
3754 
3755 	if (ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC)
3756 		err = ext4_mb_new_group_pa(ac);
3757 	else
3758 		err = ext4_mb_new_inode_pa(ac);
3759 	return err;
3760 }
3761 
3762 /*
3763  * finds all unused blocks in on-disk bitmap, frees them in
3764  * in-core bitmap and buddy.
3765  * @pa must be unlinked from inode and group lists, so that
3766  * nobody else can find/use it.
3767  * the caller MUST hold group/inode locks.
3768  * TODO: optimize the case when there are no in-core structures yet
3769  */
3770 static noinline_for_stack int
ext4_mb_release_inode_pa(struct ext4_buddy * e4b,struct buffer_head * bitmap_bh,struct ext4_prealloc_space * pa)3771 ext4_mb_release_inode_pa(struct ext4_buddy *e4b, struct buffer_head *bitmap_bh,
3772 			struct ext4_prealloc_space *pa)
3773 {
3774 	struct super_block *sb = e4b->bd_sb;
3775 	struct ext4_sb_info *sbi = EXT4_SB(sb);
3776 	unsigned int end;
3777 	unsigned int next;
3778 	ext4_group_t group;
3779 	ext4_grpblk_t bit;
3780 	unsigned long long grp_blk_start;
3781 	int err = 0;
3782 	int free = 0;
3783 
3784 	BUG_ON(pa->pa_deleted == 0);
3785 	ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit);
3786 	grp_blk_start = pa->pa_pstart - EXT4_C2B(sbi, bit);
3787 	BUG_ON(group != e4b->bd_group && pa->pa_len != 0);
3788 	end = bit + pa->pa_len;
3789 
3790 	while (bit < end) {
3791 		bit = mb_find_next_zero_bit(bitmap_bh->b_data, end, bit);
3792 		if (bit >= end)
3793 			break;
3794 		next = mb_find_next_bit(bitmap_bh->b_data, end, bit);
3795 		mb_debug(1, "    free preallocated %u/%u in group %u\n",
3796 			 (unsigned) ext4_group_first_block_no(sb, group) + bit,
3797 			 (unsigned) next - bit, (unsigned) group);
3798 		free += next - bit;
3799 
3800 		trace_ext4_mballoc_discard(sb, NULL, group, bit, next - bit);
3801 		trace_ext4_mb_release_inode_pa(pa, (grp_blk_start +
3802 						    EXT4_C2B(sbi, bit)),
3803 					       next - bit);
3804 		mb_free_blocks(pa->pa_inode, e4b, bit, next - bit);
3805 		bit = next + 1;
3806 	}
3807 	if (free != pa->pa_free) {
3808 		ext4_msg(e4b->bd_sb, KERN_CRIT,
3809 			 "pa %p: logic %lu, phys. %lu, len %lu",
3810 			 pa, (unsigned long) pa->pa_lstart,
3811 			 (unsigned long) pa->pa_pstart,
3812 			 (unsigned long) pa->pa_len);
3813 		ext4_grp_locked_error(sb, group, 0, 0, "free %u, pa_free %u",
3814 					free, pa->pa_free);
3815 		/*
3816 		 * pa is already deleted so we use the value obtained
3817 		 * from the bitmap and continue.
3818 		 */
3819 	}
3820 	atomic_add(free, &sbi->s_mb_discarded);
3821 
3822 	return err;
3823 }
3824 
3825 static noinline_for_stack int
ext4_mb_release_group_pa(struct ext4_buddy * e4b,struct ext4_prealloc_space * pa)3826 ext4_mb_release_group_pa(struct ext4_buddy *e4b,
3827 				struct ext4_prealloc_space *pa)
3828 {
3829 	struct super_block *sb = e4b->bd_sb;
3830 	ext4_group_t group;
3831 	ext4_grpblk_t bit;
3832 
3833 	trace_ext4_mb_release_group_pa(sb, pa);
3834 	BUG_ON(pa->pa_deleted == 0);
3835 	ext4_get_group_no_and_offset(sb, pa->pa_pstart, &group, &bit);
3836 	BUG_ON(group != e4b->bd_group && pa->pa_len != 0);
3837 	mb_free_blocks(pa->pa_inode, e4b, bit, pa->pa_len);
3838 	atomic_add(pa->pa_len, &EXT4_SB(sb)->s_mb_discarded);
3839 	trace_ext4_mballoc_discard(sb, NULL, group, bit, pa->pa_len);
3840 
3841 	return 0;
3842 }
3843 
3844 /*
3845  * releases all preallocations in given group
3846  *
3847  * first, we need to decide discard policy:
3848  * - when do we discard
3849  *   1) ENOSPC
3850  * - how many do we discard
3851  *   1) how many requested
3852  */
3853 static noinline_for_stack int
ext4_mb_discard_group_preallocations(struct super_block * sb,ext4_group_t group,int needed)3854 ext4_mb_discard_group_preallocations(struct super_block *sb,
3855 					ext4_group_t group, int needed)
3856 {
3857 	struct ext4_group_info *grp = ext4_get_group_info(sb, group);
3858 	struct buffer_head *bitmap_bh = NULL;
3859 	struct ext4_prealloc_space *pa, *tmp;
3860 	struct list_head list;
3861 	struct ext4_buddy e4b;
3862 	int err;
3863 	int busy = 0;
3864 	int free = 0;
3865 
3866 	mb_debug(1, "discard preallocation for group %u\n", group);
3867 
3868 	if (list_empty(&grp->bb_prealloc_list))
3869 		return 0;
3870 
3871 	bitmap_bh = ext4_read_block_bitmap(sb, group);
3872 	if (IS_ERR(bitmap_bh)) {
3873 		err = PTR_ERR(bitmap_bh);
3874 		ext4_error(sb, "Error %d reading block bitmap for %u",
3875 			   err, group);
3876 		return 0;
3877 	}
3878 
3879 	err = ext4_mb_load_buddy(sb, group, &e4b);
3880 	if (err) {
3881 		ext4_warning(sb, "Error %d loading buddy information for %u",
3882 			     err, group);
3883 		put_bh(bitmap_bh);
3884 		return 0;
3885 	}
3886 
3887 	if (needed == 0)
3888 		needed = EXT4_CLUSTERS_PER_GROUP(sb) + 1;
3889 
3890 	INIT_LIST_HEAD(&list);
3891 repeat:
3892 	ext4_lock_group(sb, group);
3893 	list_for_each_entry_safe(pa, tmp,
3894 				&grp->bb_prealloc_list, pa_group_list) {
3895 		spin_lock(&pa->pa_lock);
3896 		if (atomic_read(&pa->pa_count)) {
3897 			spin_unlock(&pa->pa_lock);
3898 			busy = 1;
3899 			continue;
3900 		}
3901 		if (pa->pa_deleted) {
3902 			spin_unlock(&pa->pa_lock);
3903 			continue;
3904 		}
3905 
3906 		/* seems this one can be freed ... */
3907 		pa->pa_deleted = 1;
3908 
3909 		/* we can trust pa_free ... */
3910 		free += pa->pa_free;
3911 
3912 		spin_unlock(&pa->pa_lock);
3913 
3914 		list_del(&pa->pa_group_list);
3915 		list_add(&pa->u.pa_tmp_list, &list);
3916 	}
3917 
3918 	/* if we still need more blocks and some PAs were used, try again */
3919 	if (free < needed && busy) {
3920 		busy = 0;
3921 		ext4_unlock_group(sb, group);
3922 		cond_resched();
3923 		goto repeat;
3924 	}
3925 
3926 	/* found anything to free? */
3927 	if (list_empty(&list)) {
3928 		BUG_ON(free != 0);
3929 		goto out;
3930 	}
3931 
3932 	/* now free all selected PAs */
3933 	list_for_each_entry_safe(pa, tmp, &list, u.pa_tmp_list) {
3934 
3935 		/* remove from object (inode or locality group) */
3936 		spin_lock(pa->pa_obj_lock);
3937 		list_del_rcu(&pa->pa_inode_list);
3938 		spin_unlock(pa->pa_obj_lock);
3939 
3940 		if (pa->pa_type == MB_GROUP_PA)
3941 			ext4_mb_release_group_pa(&e4b, pa);
3942 		else
3943 			ext4_mb_release_inode_pa(&e4b, bitmap_bh, pa);
3944 
3945 		list_del(&pa->u.pa_tmp_list);
3946 		call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
3947 	}
3948 
3949 out:
3950 	ext4_unlock_group(sb, group);
3951 	ext4_mb_unload_buddy(&e4b);
3952 	put_bh(bitmap_bh);
3953 	return free;
3954 }
3955 
3956 /*
3957  * releases all non-used preallocated blocks for given inode
3958  *
3959  * It's important to discard preallocations under i_data_sem
3960  * We don't want another block to be served from the prealloc
3961  * space when we are discarding the inode prealloc space.
3962  *
3963  * FIXME!! Make sure it is valid at all the call sites
3964  */
ext4_discard_preallocations(struct inode * inode)3965 void ext4_discard_preallocations(struct inode *inode)
3966 {
3967 	struct ext4_inode_info *ei = EXT4_I(inode);
3968 	struct super_block *sb = inode->i_sb;
3969 	struct buffer_head *bitmap_bh = NULL;
3970 	struct ext4_prealloc_space *pa, *tmp;
3971 	ext4_group_t group = 0;
3972 	struct list_head list;
3973 	struct ext4_buddy e4b;
3974 	int err;
3975 
3976 	if (!S_ISREG(inode->i_mode)) {
3977 		/*BUG_ON(!list_empty(&ei->i_prealloc_list));*/
3978 		return;
3979 	}
3980 
3981 	mb_debug(1, "discard preallocation for inode %lu\n", inode->i_ino);
3982 	trace_ext4_discard_preallocations(inode);
3983 
3984 	INIT_LIST_HEAD(&list);
3985 
3986 repeat:
3987 	/* first, collect all pa's in the inode */
3988 	spin_lock(&ei->i_prealloc_lock);
3989 	while (!list_empty(&ei->i_prealloc_list)) {
3990 		pa = list_entry(ei->i_prealloc_list.next,
3991 				struct ext4_prealloc_space, pa_inode_list);
3992 		BUG_ON(pa->pa_obj_lock != &ei->i_prealloc_lock);
3993 		spin_lock(&pa->pa_lock);
3994 		if (atomic_read(&pa->pa_count)) {
3995 			/* this shouldn't happen often - nobody should
3996 			 * use preallocation while we're discarding it */
3997 			spin_unlock(&pa->pa_lock);
3998 			spin_unlock(&ei->i_prealloc_lock);
3999 			ext4_msg(sb, KERN_ERR,
4000 				 "uh-oh! used pa while discarding");
4001 			WARN_ON(1);
4002 			schedule_timeout_uninterruptible(HZ);
4003 			goto repeat;
4004 
4005 		}
4006 		if (pa->pa_deleted == 0) {
4007 			pa->pa_deleted = 1;
4008 			spin_unlock(&pa->pa_lock);
4009 			list_del_rcu(&pa->pa_inode_list);
4010 			list_add(&pa->u.pa_tmp_list, &list);
4011 			continue;
4012 		}
4013 
4014 		/* someone is deleting pa right now */
4015 		spin_unlock(&pa->pa_lock);
4016 		spin_unlock(&ei->i_prealloc_lock);
4017 
4018 		/* we have to wait here because pa_deleted
4019 		 * doesn't mean pa is already unlinked from
4020 		 * the list. as we might be called from
4021 		 * ->clear_inode() the inode will get freed
4022 		 * and concurrent thread which is unlinking
4023 		 * pa from inode's list may access already
4024 		 * freed memory, bad-bad-bad */
4025 
4026 		/* XXX: if this happens too often, we can
4027 		 * add a flag to force wait only in case
4028 		 * of ->clear_inode(), but not in case of
4029 		 * regular truncate */
4030 		schedule_timeout_uninterruptible(HZ);
4031 		goto repeat;
4032 	}
4033 	spin_unlock(&ei->i_prealloc_lock);
4034 
4035 	list_for_each_entry_safe(pa, tmp, &list, u.pa_tmp_list) {
4036 		BUG_ON(pa->pa_type != MB_INODE_PA);
4037 		group = ext4_get_group_number(sb, pa->pa_pstart);
4038 
4039 		err = ext4_mb_load_buddy_gfp(sb, group, &e4b,
4040 					     GFP_NOFS|__GFP_NOFAIL);
4041 		if (err) {
4042 			ext4_error(sb, "Error %d loading buddy information for %u",
4043 				   err, group);
4044 			continue;
4045 		}
4046 
4047 		bitmap_bh = ext4_read_block_bitmap(sb, group);
4048 		if (IS_ERR(bitmap_bh)) {
4049 			err = PTR_ERR(bitmap_bh);
4050 			ext4_error(sb, "Error %d reading block bitmap for %u",
4051 					err, group);
4052 			ext4_mb_unload_buddy(&e4b);
4053 			continue;
4054 		}
4055 
4056 		ext4_lock_group(sb, group);
4057 		list_del(&pa->pa_group_list);
4058 		ext4_mb_release_inode_pa(&e4b, bitmap_bh, pa);
4059 		ext4_unlock_group(sb, group);
4060 
4061 		ext4_mb_unload_buddy(&e4b);
4062 		put_bh(bitmap_bh);
4063 
4064 		list_del(&pa->u.pa_tmp_list);
4065 		call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
4066 	}
4067 }
4068 
4069 #ifdef CONFIG_EXT4_DEBUG
ext4_mb_show_ac(struct ext4_allocation_context * ac)4070 static void ext4_mb_show_ac(struct ext4_allocation_context *ac)
4071 {
4072 	struct super_block *sb = ac->ac_sb;
4073 	ext4_group_t ngroups, i;
4074 
4075 	if (!ext4_mballoc_debug ||
4076 	    (EXT4_SB(sb)->s_mount_flags & EXT4_MF_FS_ABORTED))
4077 		return;
4078 
4079 	ext4_msg(ac->ac_sb, KERN_ERR, "Can't allocate:"
4080 			" Allocation context details:");
4081 	ext4_msg(ac->ac_sb, KERN_ERR, "status %d flags %d",
4082 			ac->ac_status, ac->ac_flags);
4083 	ext4_msg(ac->ac_sb, KERN_ERR, "orig %lu/%lu/%lu@%lu, "
4084 		 	"goal %lu/%lu/%lu@%lu, "
4085 			"best %lu/%lu/%lu@%lu cr %d",
4086 			(unsigned long)ac->ac_o_ex.fe_group,
4087 			(unsigned long)ac->ac_o_ex.fe_start,
4088 			(unsigned long)ac->ac_o_ex.fe_len,
4089 			(unsigned long)ac->ac_o_ex.fe_logical,
4090 			(unsigned long)ac->ac_g_ex.fe_group,
4091 			(unsigned long)ac->ac_g_ex.fe_start,
4092 			(unsigned long)ac->ac_g_ex.fe_len,
4093 			(unsigned long)ac->ac_g_ex.fe_logical,
4094 			(unsigned long)ac->ac_b_ex.fe_group,
4095 			(unsigned long)ac->ac_b_ex.fe_start,
4096 			(unsigned long)ac->ac_b_ex.fe_len,
4097 			(unsigned long)ac->ac_b_ex.fe_logical,
4098 			(int)ac->ac_criteria);
4099 	ext4_msg(ac->ac_sb, KERN_ERR, "%d found", ac->ac_found);
4100 	ext4_msg(ac->ac_sb, KERN_ERR, "groups: ");
4101 	ngroups = ext4_get_groups_count(sb);
4102 	for (i = 0; i < ngroups; i++) {
4103 		struct ext4_group_info *grp = ext4_get_group_info(sb, i);
4104 		struct ext4_prealloc_space *pa;
4105 		ext4_grpblk_t start;
4106 		struct list_head *cur;
4107 		ext4_lock_group(sb, i);
4108 		list_for_each(cur, &grp->bb_prealloc_list) {
4109 			pa = list_entry(cur, struct ext4_prealloc_space,
4110 					pa_group_list);
4111 			spin_lock(&pa->pa_lock);
4112 			ext4_get_group_no_and_offset(sb, pa->pa_pstart,
4113 						     NULL, &start);
4114 			spin_unlock(&pa->pa_lock);
4115 			printk(KERN_ERR "PA:%u:%d:%u \n", i,
4116 			       start, pa->pa_len);
4117 		}
4118 		ext4_unlock_group(sb, i);
4119 
4120 		if (grp->bb_free == 0)
4121 			continue;
4122 		printk(KERN_ERR "%u: %d/%d \n",
4123 		       i, grp->bb_free, grp->bb_fragments);
4124 	}
4125 	printk(KERN_ERR "\n");
4126 }
4127 #else
ext4_mb_show_ac(struct ext4_allocation_context * ac)4128 static inline void ext4_mb_show_ac(struct ext4_allocation_context *ac)
4129 {
4130 	return;
4131 }
4132 #endif
4133 
4134 /*
4135  * We use locality group preallocation for small size file. The size of the
4136  * file is determined by the current size or the resulting size after
4137  * allocation which ever is larger
4138  *
4139  * One can tune this size via /sys/fs/ext4/<partition>/mb_stream_req
4140  */
ext4_mb_group_or_file(struct ext4_allocation_context * ac)4141 static void ext4_mb_group_or_file(struct ext4_allocation_context *ac)
4142 {
4143 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
4144 	int bsbits = ac->ac_sb->s_blocksize_bits;
4145 	loff_t size, isize;
4146 
4147 	if (!(ac->ac_flags & EXT4_MB_HINT_DATA))
4148 		return;
4149 
4150 	if (unlikely(ac->ac_flags & EXT4_MB_HINT_GOAL_ONLY))
4151 		return;
4152 
4153 	size = ac->ac_o_ex.fe_logical + EXT4_C2B(sbi, ac->ac_o_ex.fe_len);
4154 	isize = (i_size_read(ac->ac_inode) + ac->ac_sb->s_blocksize - 1)
4155 		>> bsbits;
4156 
4157 	if ((size == isize) &&
4158 	    !ext4_fs_is_busy(sbi) &&
4159 	    (atomic_read(&ac->ac_inode->i_writecount) == 0)) {
4160 		ac->ac_flags |= EXT4_MB_HINT_NOPREALLOC;
4161 		return;
4162 	}
4163 
4164 	if (sbi->s_mb_group_prealloc <= 0) {
4165 		ac->ac_flags |= EXT4_MB_STREAM_ALLOC;
4166 		return;
4167 	}
4168 
4169 	/* don't use group allocation for large files */
4170 	size = max(size, isize);
4171 	if (size > sbi->s_mb_stream_request) {
4172 		ac->ac_flags |= EXT4_MB_STREAM_ALLOC;
4173 		return;
4174 	}
4175 
4176 	BUG_ON(ac->ac_lg != NULL);
4177 	/*
4178 	 * locality group prealloc space are per cpu. The reason for having
4179 	 * per cpu locality group is to reduce the contention between block
4180 	 * request from multiple CPUs.
4181 	 */
4182 	ac->ac_lg = raw_cpu_ptr(sbi->s_locality_groups);
4183 
4184 	/* we're going to use group allocation */
4185 	ac->ac_flags |= EXT4_MB_HINT_GROUP_ALLOC;
4186 
4187 	/* serialize all allocations in the group */
4188 	mutex_lock(&ac->ac_lg->lg_mutex);
4189 }
4190 
4191 static noinline_for_stack int
ext4_mb_initialize_context(struct ext4_allocation_context * ac,struct ext4_allocation_request * ar)4192 ext4_mb_initialize_context(struct ext4_allocation_context *ac,
4193 				struct ext4_allocation_request *ar)
4194 {
4195 	struct super_block *sb = ar->inode->i_sb;
4196 	struct ext4_sb_info *sbi = EXT4_SB(sb);
4197 	struct ext4_super_block *es = sbi->s_es;
4198 	ext4_group_t group;
4199 	unsigned int len;
4200 	ext4_fsblk_t goal;
4201 	ext4_grpblk_t block;
4202 
4203 	/* we can't allocate > group size */
4204 	len = ar->len;
4205 
4206 	/* just a dirty hack to filter too big requests  */
4207 	if (len >= EXT4_CLUSTERS_PER_GROUP(sb))
4208 		len = EXT4_CLUSTERS_PER_GROUP(sb);
4209 
4210 	/* start searching from the goal */
4211 	goal = ar->goal;
4212 	if (goal < le32_to_cpu(es->s_first_data_block) ||
4213 			goal >= ext4_blocks_count(es))
4214 		goal = le32_to_cpu(es->s_first_data_block);
4215 	ext4_get_group_no_and_offset(sb, goal, &group, &block);
4216 
4217 	/* set up allocation goals */
4218 	ac->ac_b_ex.fe_logical = EXT4_LBLK_CMASK(sbi, ar->logical);
4219 	ac->ac_status = AC_STATUS_CONTINUE;
4220 	ac->ac_sb = sb;
4221 	ac->ac_inode = ar->inode;
4222 	ac->ac_o_ex.fe_logical = ac->ac_b_ex.fe_logical;
4223 	ac->ac_o_ex.fe_group = group;
4224 	ac->ac_o_ex.fe_start = block;
4225 	ac->ac_o_ex.fe_len = len;
4226 	ac->ac_g_ex = ac->ac_o_ex;
4227 	ac->ac_flags = ar->flags;
4228 
4229 	/* we have to define context: we'll we work with a file or
4230 	 * locality group. this is a policy, actually */
4231 	ext4_mb_group_or_file(ac);
4232 
4233 	mb_debug(1, "init ac: %u blocks @ %u, goal %u, flags %x, 2^%d, "
4234 			"left: %u/%u, right %u/%u to %swritable\n",
4235 			(unsigned) ar->len, (unsigned) ar->logical,
4236 			(unsigned) ar->goal, ac->ac_flags, ac->ac_2order,
4237 			(unsigned) ar->lleft, (unsigned) ar->pleft,
4238 			(unsigned) ar->lright, (unsigned) ar->pright,
4239 			atomic_read(&ar->inode->i_writecount) ? "" : "non-");
4240 	return 0;
4241 
4242 }
4243 
4244 static noinline_for_stack void
ext4_mb_discard_lg_preallocations(struct super_block * sb,struct ext4_locality_group * lg,int order,int total_entries)4245 ext4_mb_discard_lg_preallocations(struct super_block *sb,
4246 					struct ext4_locality_group *lg,
4247 					int order, int total_entries)
4248 {
4249 	ext4_group_t group = 0;
4250 	struct ext4_buddy e4b;
4251 	struct list_head discard_list;
4252 	struct ext4_prealloc_space *pa, *tmp;
4253 
4254 	mb_debug(1, "discard locality group preallocation\n");
4255 
4256 	INIT_LIST_HEAD(&discard_list);
4257 
4258 	spin_lock(&lg->lg_prealloc_lock);
4259 	list_for_each_entry_rcu(pa, &lg->lg_prealloc_list[order],
4260 						pa_inode_list) {
4261 		spin_lock(&pa->pa_lock);
4262 		if (atomic_read(&pa->pa_count)) {
4263 			/*
4264 			 * This is the pa that we just used
4265 			 * for block allocation. So don't
4266 			 * free that
4267 			 */
4268 			spin_unlock(&pa->pa_lock);
4269 			continue;
4270 		}
4271 		if (pa->pa_deleted) {
4272 			spin_unlock(&pa->pa_lock);
4273 			continue;
4274 		}
4275 		/* only lg prealloc space */
4276 		BUG_ON(pa->pa_type != MB_GROUP_PA);
4277 
4278 		/* seems this one can be freed ... */
4279 		pa->pa_deleted = 1;
4280 		spin_unlock(&pa->pa_lock);
4281 
4282 		list_del_rcu(&pa->pa_inode_list);
4283 		list_add(&pa->u.pa_tmp_list, &discard_list);
4284 
4285 		total_entries--;
4286 		if (total_entries <= 5) {
4287 			/*
4288 			 * we want to keep only 5 entries
4289 			 * allowing it to grow to 8. This
4290 			 * mak sure we don't call discard
4291 			 * soon for this list.
4292 			 */
4293 			break;
4294 		}
4295 	}
4296 	spin_unlock(&lg->lg_prealloc_lock);
4297 
4298 	list_for_each_entry_safe(pa, tmp, &discard_list, u.pa_tmp_list) {
4299 		int err;
4300 
4301 		group = ext4_get_group_number(sb, pa->pa_pstart);
4302 		err = ext4_mb_load_buddy_gfp(sb, group, &e4b,
4303 					     GFP_NOFS|__GFP_NOFAIL);
4304 		if (err) {
4305 			ext4_error(sb, "Error %d loading buddy information for %u",
4306 				   err, group);
4307 			continue;
4308 		}
4309 		ext4_lock_group(sb, group);
4310 		list_del(&pa->pa_group_list);
4311 		ext4_mb_release_group_pa(&e4b, pa);
4312 		ext4_unlock_group(sb, group);
4313 
4314 		ext4_mb_unload_buddy(&e4b);
4315 		list_del(&pa->u.pa_tmp_list);
4316 		call_rcu(&(pa)->u.pa_rcu, ext4_mb_pa_callback);
4317 	}
4318 }
4319 
4320 /*
4321  * We have incremented pa_count. So it cannot be freed at this
4322  * point. Also we hold lg_mutex. So no parallel allocation is
4323  * possible from this lg. That means pa_free cannot be updated.
4324  *
4325  * A parallel ext4_mb_discard_group_preallocations is possible.
4326  * which can cause the lg_prealloc_list to be updated.
4327  */
4328 
ext4_mb_add_n_trim(struct ext4_allocation_context * ac)4329 static void ext4_mb_add_n_trim(struct ext4_allocation_context *ac)
4330 {
4331 	int order, added = 0, lg_prealloc_count = 1;
4332 	struct super_block *sb = ac->ac_sb;
4333 	struct ext4_locality_group *lg = ac->ac_lg;
4334 	struct ext4_prealloc_space *tmp_pa, *pa = ac->ac_pa;
4335 
4336 	order = fls(pa->pa_free) - 1;
4337 	if (order > PREALLOC_TB_SIZE - 1)
4338 		/* The max size of hash table is PREALLOC_TB_SIZE */
4339 		order = PREALLOC_TB_SIZE - 1;
4340 	/* Add the prealloc space to lg */
4341 	spin_lock(&lg->lg_prealloc_lock);
4342 	list_for_each_entry_rcu(tmp_pa, &lg->lg_prealloc_list[order],
4343 						pa_inode_list) {
4344 		spin_lock(&tmp_pa->pa_lock);
4345 		if (tmp_pa->pa_deleted) {
4346 			spin_unlock(&tmp_pa->pa_lock);
4347 			continue;
4348 		}
4349 		if (!added && pa->pa_free < tmp_pa->pa_free) {
4350 			/* Add to the tail of the previous entry */
4351 			list_add_tail_rcu(&pa->pa_inode_list,
4352 						&tmp_pa->pa_inode_list);
4353 			added = 1;
4354 			/*
4355 			 * we want to count the total
4356 			 * number of entries in the list
4357 			 */
4358 		}
4359 		spin_unlock(&tmp_pa->pa_lock);
4360 		lg_prealloc_count++;
4361 	}
4362 	if (!added)
4363 		list_add_tail_rcu(&pa->pa_inode_list,
4364 					&lg->lg_prealloc_list[order]);
4365 	spin_unlock(&lg->lg_prealloc_lock);
4366 
4367 	/* Now trim the list to be not more than 8 elements */
4368 	if (lg_prealloc_count > 8) {
4369 		ext4_mb_discard_lg_preallocations(sb, lg,
4370 						  order, lg_prealloc_count);
4371 		return;
4372 	}
4373 	return ;
4374 }
4375 
4376 /*
4377  * release all resource we used in allocation
4378  */
ext4_mb_release_context(struct ext4_allocation_context * ac)4379 static int ext4_mb_release_context(struct ext4_allocation_context *ac)
4380 {
4381 	struct ext4_sb_info *sbi = EXT4_SB(ac->ac_sb);
4382 	struct ext4_prealloc_space *pa = ac->ac_pa;
4383 	if (pa) {
4384 		if (pa->pa_type == MB_GROUP_PA) {
4385 			/* see comment in ext4_mb_use_group_pa() */
4386 			spin_lock(&pa->pa_lock);
4387 			pa->pa_pstart += EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
4388 			pa->pa_lstart += EXT4_C2B(sbi, ac->ac_b_ex.fe_len);
4389 			pa->pa_free -= ac->ac_b_ex.fe_len;
4390 			pa->pa_len -= ac->ac_b_ex.fe_len;
4391 			spin_unlock(&pa->pa_lock);
4392 		}
4393 	}
4394 	if (pa) {
4395 		/*
4396 		 * We want to add the pa to the right bucket.
4397 		 * Remove it from the list and while adding
4398 		 * make sure the list to which we are adding
4399 		 * doesn't grow big.
4400 		 */
4401 		if ((pa->pa_type == MB_GROUP_PA) && likely(pa->pa_free)) {
4402 			spin_lock(pa->pa_obj_lock);
4403 			list_del_rcu(&pa->pa_inode_list);
4404 			spin_unlock(pa->pa_obj_lock);
4405 			ext4_mb_add_n_trim(ac);
4406 		}
4407 		ext4_mb_put_pa(ac, ac->ac_sb, pa);
4408 	}
4409 	if (ac->ac_bitmap_page)
4410 		put_page(ac->ac_bitmap_page);
4411 	if (ac->ac_buddy_page)
4412 		put_page(ac->ac_buddy_page);
4413 	if (ac->ac_flags & EXT4_MB_HINT_GROUP_ALLOC)
4414 		mutex_unlock(&ac->ac_lg->lg_mutex);
4415 	ext4_mb_collect_stats(ac);
4416 	return 0;
4417 }
4418 
ext4_mb_discard_preallocations(struct super_block * sb,int needed)4419 static int ext4_mb_discard_preallocations(struct super_block *sb, int needed)
4420 {
4421 	ext4_group_t i, ngroups = ext4_get_groups_count(sb);
4422 	int ret;
4423 	int freed = 0;
4424 
4425 	trace_ext4_mb_discard_preallocations(sb, needed);
4426 	for (i = 0; i < ngroups && needed > 0; i++) {
4427 		ret = ext4_mb_discard_group_preallocations(sb, i, needed);
4428 		freed += ret;
4429 		needed -= ret;
4430 	}
4431 
4432 	return freed;
4433 }
4434 
4435 /*
4436  * Main entry point into mballoc to allocate blocks
4437  * it tries to use preallocation first, then falls back
4438  * to usual allocation
4439  */
ext4_mb_new_blocks(handle_t * handle,struct ext4_allocation_request * ar,int * errp)4440 ext4_fsblk_t ext4_mb_new_blocks(handle_t *handle,
4441 				struct ext4_allocation_request *ar, int *errp)
4442 {
4443 	int freed;
4444 	struct ext4_allocation_context *ac = NULL;
4445 	struct ext4_sb_info *sbi;
4446 	struct super_block *sb;
4447 	ext4_fsblk_t block = 0;
4448 	unsigned int inquota = 0;
4449 	unsigned int reserv_clstrs = 0;
4450 
4451 	might_sleep();
4452 	sb = ar->inode->i_sb;
4453 	sbi = EXT4_SB(sb);
4454 
4455 	trace_ext4_request_blocks(ar);
4456 
4457 	/* Allow to use superuser reservation for quota file */
4458 	if (IS_NOQUOTA(ar->inode))
4459 		ar->flags |= EXT4_MB_USE_ROOT_BLOCKS;
4460 
4461 	if ((ar->flags & EXT4_MB_DELALLOC_RESERVED) == 0) {
4462 		/* Without delayed allocation we need to verify
4463 		 * there is enough free blocks to do block allocation
4464 		 * and verify allocation doesn't exceed the quota limits.
4465 		 */
4466 		while (ar->len &&
4467 			ext4_claim_free_clusters(sbi, ar->len, ar->flags)) {
4468 
4469 			/* let others to free the space */
4470 			cond_resched();
4471 			ar->len = ar->len >> 1;
4472 		}
4473 		if (!ar->len) {
4474 			*errp = -ENOSPC;
4475 			return 0;
4476 		}
4477 		reserv_clstrs = ar->len;
4478 		if (ar->flags & EXT4_MB_USE_ROOT_BLOCKS) {
4479 			dquot_alloc_block_nofail(ar->inode,
4480 						 EXT4_C2B(sbi, ar->len));
4481 		} else {
4482 			while (ar->len &&
4483 				dquot_alloc_block(ar->inode,
4484 						  EXT4_C2B(sbi, ar->len))) {
4485 
4486 				ar->flags |= EXT4_MB_HINT_NOPREALLOC;
4487 				ar->len--;
4488 			}
4489 		}
4490 		inquota = ar->len;
4491 		if (ar->len == 0) {
4492 			*errp = -EDQUOT;
4493 			goto out;
4494 		}
4495 	}
4496 
4497 	ac = kmem_cache_zalloc(ext4_ac_cachep, GFP_NOFS);
4498 	if (!ac) {
4499 		ar->len = 0;
4500 		*errp = -ENOMEM;
4501 		goto out;
4502 	}
4503 
4504 	*errp = ext4_mb_initialize_context(ac, ar);
4505 	if (*errp) {
4506 		ar->len = 0;
4507 		goto out;
4508 	}
4509 
4510 	ac->ac_op = EXT4_MB_HISTORY_PREALLOC;
4511 	if (!ext4_mb_use_preallocated(ac)) {
4512 		ac->ac_op = EXT4_MB_HISTORY_ALLOC;
4513 		ext4_mb_normalize_request(ac, ar);
4514 repeat:
4515 		/* allocate space in core */
4516 		*errp = ext4_mb_regular_allocator(ac);
4517 		if (*errp)
4518 			goto discard_and_exit;
4519 
4520 		/* as we've just preallocated more space than
4521 		 * user requested originally, we store allocated
4522 		 * space in a special descriptor */
4523 		if (ac->ac_status == AC_STATUS_FOUND &&
4524 		    ac->ac_o_ex.fe_len < ac->ac_b_ex.fe_len)
4525 			*errp = ext4_mb_new_preallocation(ac);
4526 		if (*errp) {
4527 		discard_and_exit:
4528 			ext4_discard_allocated_blocks(ac);
4529 			goto errout;
4530 		}
4531 	}
4532 	if (likely(ac->ac_status == AC_STATUS_FOUND)) {
4533 		*errp = ext4_mb_mark_diskspace_used(ac, handle, reserv_clstrs);
4534 		if (*errp) {
4535 			ext4_discard_allocated_blocks(ac);
4536 			goto errout;
4537 		} else {
4538 			block = ext4_grp_offs_to_block(sb, &ac->ac_b_ex);
4539 			ar->len = ac->ac_b_ex.fe_len;
4540 		}
4541 	} else {
4542 		freed  = ext4_mb_discard_preallocations(sb, ac->ac_o_ex.fe_len);
4543 		if (freed)
4544 			goto repeat;
4545 		*errp = -ENOSPC;
4546 	}
4547 
4548 errout:
4549 	if (*errp) {
4550 		ac->ac_b_ex.fe_len = 0;
4551 		ar->len = 0;
4552 		ext4_mb_show_ac(ac);
4553 	}
4554 	ext4_mb_release_context(ac);
4555 out:
4556 	if (ac)
4557 		kmem_cache_free(ext4_ac_cachep, ac);
4558 	if (inquota && ar->len < inquota)
4559 		dquot_free_block(ar->inode, EXT4_C2B(sbi, inquota - ar->len));
4560 	if (!ar->len) {
4561 		if ((ar->flags & EXT4_MB_DELALLOC_RESERVED) == 0)
4562 			/* release all the reserved blocks if non delalloc */
4563 			percpu_counter_sub(&sbi->s_dirtyclusters_counter,
4564 						reserv_clstrs);
4565 	}
4566 
4567 	trace_ext4_allocate_blocks(ar, (unsigned long long)block);
4568 
4569 	return block;
4570 }
4571 
4572 /*
4573  * We can merge two free data extents only if the physical blocks
4574  * are contiguous, AND the extents were freed by the same transaction,
4575  * AND the blocks are associated with the same group.
4576  */
can_merge(struct ext4_free_data * entry1,struct ext4_free_data * entry2)4577 static int can_merge(struct ext4_free_data *entry1,
4578 			struct ext4_free_data *entry2)
4579 {
4580 	if ((entry1->efd_tid == entry2->efd_tid) &&
4581 	    (entry1->efd_group == entry2->efd_group) &&
4582 	    ((entry1->efd_start_cluster + entry1->efd_count) == entry2->efd_start_cluster))
4583 		return 1;
4584 	return 0;
4585 }
4586 
4587 static noinline_for_stack int
ext4_mb_free_metadata(handle_t * handle,struct ext4_buddy * e4b,struct ext4_free_data * new_entry)4588 ext4_mb_free_metadata(handle_t *handle, struct ext4_buddy *e4b,
4589 		      struct ext4_free_data *new_entry)
4590 {
4591 	ext4_group_t group = e4b->bd_group;
4592 	ext4_grpblk_t cluster;
4593 	ext4_grpblk_t clusters = new_entry->efd_count;
4594 	struct ext4_free_data *entry;
4595 	struct ext4_group_info *db = e4b->bd_info;
4596 	struct super_block *sb = e4b->bd_sb;
4597 	struct ext4_sb_info *sbi = EXT4_SB(sb);
4598 	struct rb_node **n = &db->bb_free_root.rb_node, *node;
4599 	struct rb_node *parent = NULL, *new_node;
4600 
4601 	BUG_ON(!ext4_handle_valid(handle));
4602 	BUG_ON(e4b->bd_bitmap_page == NULL);
4603 	BUG_ON(e4b->bd_buddy_page == NULL);
4604 
4605 	new_node = &new_entry->efd_node;
4606 	cluster = new_entry->efd_start_cluster;
4607 
4608 	if (!*n) {
4609 		/* first free block exent. We need to
4610 		   protect buddy cache from being freed,
4611 		 * otherwise we'll refresh it from
4612 		 * on-disk bitmap and lose not-yet-available
4613 		 * blocks */
4614 		get_page(e4b->bd_buddy_page);
4615 		get_page(e4b->bd_bitmap_page);
4616 	}
4617 	while (*n) {
4618 		parent = *n;
4619 		entry = rb_entry(parent, struct ext4_free_data, efd_node);
4620 		if (cluster < entry->efd_start_cluster)
4621 			n = &(*n)->rb_left;
4622 		else if (cluster >= (entry->efd_start_cluster + entry->efd_count))
4623 			n = &(*n)->rb_right;
4624 		else {
4625 			ext4_grp_locked_error(sb, group, 0,
4626 				ext4_group_first_block_no(sb, group) +
4627 				EXT4_C2B(sbi, cluster),
4628 				"Block already on to-be-freed list");
4629 			return 0;
4630 		}
4631 	}
4632 
4633 	rb_link_node(new_node, parent, n);
4634 	rb_insert_color(new_node, &db->bb_free_root);
4635 
4636 	/* Now try to see the extent can be merged to left and right */
4637 	node = rb_prev(new_node);
4638 	if (node) {
4639 		entry = rb_entry(node, struct ext4_free_data, efd_node);
4640 		if (can_merge(entry, new_entry) &&
4641 		    ext4_journal_callback_try_del(handle, &entry->efd_jce)) {
4642 			new_entry->efd_start_cluster = entry->efd_start_cluster;
4643 			new_entry->efd_count += entry->efd_count;
4644 			rb_erase(node, &(db->bb_free_root));
4645 			kmem_cache_free(ext4_free_data_cachep, entry);
4646 		}
4647 	}
4648 
4649 	node = rb_next(new_node);
4650 	if (node) {
4651 		entry = rb_entry(node, struct ext4_free_data, efd_node);
4652 		if (can_merge(new_entry, entry) &&
4653 		    ext4_journal_callback_try_del(handle, &entry->efd_jce)) {
4654 			new_entry->efd_count += entry->efd_count;
4655 			rb_erase(node, &(db->bb_free_root));
4656 			kmem_cache_free(ext4_free_data_cachep, entry);
4657 		}
4658 	}
4659 	/* Add the extent to transaction's private list */
4660 	new_entry->efd_jce.jce_func = ext4_free_data_callback;
4661 	spin_lock(&sbi->s_md_lock);
4662 	_ext4_journal_callback_add(handle, &new_entry->efd_jce);
4663 	sbi->s_mb_free_pending += clusters;
4664 	spin_unlock(&sbi->s_md_lock);
4665 	return 0;
4666 }
4667 
4668 /**
4669  * ext4_free_blocks() -- Free given blocks and update quota
4670  * @handle:		handle for this transaction
4671  * @inode:		inode
4672  * @block:		start physical block to free
4673  * @count:		number of blocks to count
4674  * @flags:		flags used by ext4_free_blocks
4675  */
ext4_free_blocks(handle_t * handle,struct inode * inode,struct buffer_head * bh,ext4_fsblk_t block,unsigned long count,int flags)4676 void ext4_free_blocks(handle_t *handle, struct inode *inode,
4677 		      struct buffer_head *bh, ext4_fsblk_t block,
4678 		      unsigned long count, int flags)
4679 {
4680 	struct buffer_head *bitmap_bh = NULL;
4681 	struct super_block *sb = inode->i_sb;
4682 	struct ext4_group_desc *gdp;
4683 	unsigned int overflow;
4684 	ext4_grpblk_t bit;
4685 	struct buffer_head *gd_bh;
4686 	ext4_group_t block_group;
4687 	struct ext4_sb_info *sbi;
4688 	struct ext4_buddy e4b;
4689 	unsigned int count_clusters;
4690 	int err = 0;
4691 	int ret;
4692 
4693 	might_sleep();
4694 	if (bh) {
4695 		if (block)
4696 			BUG_ON(block != bh->b_blocknr);
4697 		else
4698 			block = bh->b_blocknr;
4699 	}
4700 
4701 	sbi = EXT4_SB(sb);
4702 	if (!(flags & EXT4_FREE_BLOCKS_VALIDATED) &&
4703 	    !ext4_data_block_valid(sbi, block, count)) {
4704 		ext4_error(sb, "Freeing blocks not in datazone - "
4705 			   "block = %llu, count = %lu", block, count);
4706 		goto error_return;
4707 	}
4708 
4709 	ext4_debug("freeing block %llu\n", block);
4710 	trace_ext4_free_blocks(inode, block, count, flags);
4711 
4712 	if (bh && (flags & EXT4_FREE_BLOCKS_FORGET)) {
4713 		BUG_ON(count > 1);
4714 
4715 		ext4_forget(handle, flags & EXT4_FREE_BLOCKS_METADATA,
4716 			    inode, bh, block);
4717 	}
4718 
4719 	/*
4720 	 * If the extent to be freed does not begin on a cluster
4721 	 * boundary, we need to deal with partial clusters at the
4722 	 * beginning and end of the extent.  Normally we will free
4723 	 * blocks at the beginning or the end unless we are explicitly
4724 	 * requested to avoid doing so.
4725 	 */
4726 	overflow = EXT4_PBLK_COFF(sbi, block);
4727 	if (overflow) {
4728 		if (flags & EXT4_FREE_BLOCKS_NOFREE_FIRST_CLUSTER) {
4729 			overflow = sbi->s_cluster_ratio - overflow;
4730 			block += overflow;
4731 			if (count > overflow)
4732 				count -= overflow;
4733 			else
4734 				return;
4735 		} else {
4736 			block -= overflow;
4737 			count += overflow;
4738 		}
4739 	}
4740 	overflow = EXT4_LBLK_COFF(sbi, count);
4741 	if (overflow) {
4742 		if (flags & EXT4_FREE_BLOCKS_NOFREE_LAST_CLUSTER) {
4743 			if (count > overflow)
4744 				count -= overflow;
4745 			else
4746 				return;
4747 		} else
4748 			count += sbi->s_cluster_ratio - overflow;
4749 	}
4750 
4751 	if (!bh && (flags & EXT4_FREE_BLOCKS_FORGET)) {
4752 		int i;
4753 		int is_metadata = flags & EXT4_FREE_BLOCKS_METADATA;
4754 
4755 		for (i = 0; i < count; i++) {
4756 			cond_resched();
4757 			if (is_metadata)
4758 				bh = sb_find_get_block(inode->i_sb, block + i);
4759 			ext4_forget(handle, is_metadata, inode, bh, block + i);
4760 		}
4761 	}
4762 
4763 do_more:
4764 	overflow = 0;
4765 	ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
4766 
4767 	if (unlikely(EXT4_MB_GRP_BBITMAP_CORRUPT(
4768 			ext4_get_group_info(sb, block_group))))
4769 		return;
4770 
4771 	/*
4772 	 * Check to see if we are freeing blocks across a group
4773 	 * boundary.
4774 	 */
4775 	if (EXT4_C2B(sbi, bit) + count > EXT4_BLOCKS_PER_GROUP(sb)) {
4776 		overflow = EXT4_C2B(sbi, bit) + count -
4777 			EXT4_BLOCKS_PER_GROUP(sb);
4778 		count -= overflow;
4779 	}
4780 	count_clusters = EXT4_NUM_B2C(sbi, count);
4781 	bitmap_bh = ext4_read_block_bitmap(sb, block_group);
4782 	if (IS_ERR(bitmap_bh)) {
4783 		err = PTR_ERR(bitmap_bh);
4784 		bitmap_bh = NULL;
4785 		goto error_return;
4786 	}
4787 	gdp = ext4_get_group_desc(sb, block_group, &gd_bh);
4788 	if (!gdp) {
4789 		err = -EIO;
4790 		goto error_return;
4791 	}
4792 
4793 	if (in_range(ext4_block_bitmap(sb, gdp), block, count) ||
4794 	    in_range(ext4_inode_bitmap(sb, gdp), block, count) ||
4795 	    in_range(block, ext4_inode_table(sb, gdp),
4796 		     EXT4_SB(sb)->s_itb_per_group) ||
4797 	    in_range(block + count - 1, ext4_inode_table(sb, gdp),
4798 		     EXT4_SB(sb)->s_itb_per_group)) {
4799 
4800 		ext4_error(sb, "Freeing blocks in system zone - "
4801 			   "Block = %llu, count = %lu", block, count);
4802 		/* err = 0. ext4_std_error should be a no op */
4803 		goto error_return;
4804 	}
4805 
4806 	BUFFER_TRACE(bitmap_bh, "getting write access");
4807 	err = ext4_journal_get_write_access(handle, bitmap_bh);
4808 	if (err)
4809 		goto error_return;
4810 
4811 	/*
4812 	 * We are about to modify some metadata.  Call the journal APIs
4813 	 * to unshare ->b_data if a currently-committing transaction is
4814 	 * using it
4815 	 */
4816 	BUFFER_TRACE(gd_bh, "get_write_access");
4817 	err = ext4_journal_get_write_access(handle, gd_bh);
4818 	if (err)
4819 		goto error_return;
4820 #ifdef AGGRESSIVE_CHECK
4821 	{
4822 		int i;
4823 		for (i = 0; i < count_clusters; i++)
4824 			BUG_ON(!mb_test_bit(bit + i, bitmap_bh->b_data));
4825 	}
4826 #endif
4827 	trace_ext4_mballoc_free(sb, inode, block_group, bit, count_clusters);
4828 
4829 	/* __GFP_NOFAIL: retry infinitely, ignore TIF_MEMDIE and memcg limit. */
4830 	err = ext4_mb_load_buddy_gfp(sb, block_group, &e4b,
4831 				     GFP_NOFS|__GFP_NOFAIL);
4832 	if (err)
4833 		goto error_return;
4834 
4835 	/*
4836 	 * We need to make sure we don't reuse the freed block until after the
4837 	 * transaction is committed. We make an exception if the inode is to be
4838 	 * written in writeback mode since writeback mode has weak data
4839 	 * consistency guarantees.
4840 	 */
4841 	if (ext4_handle_valid(handle) &&
4842 	    ((flags & EXT4_FREE_BLOCKS_METADATA) ||
4843 	     !ext4_should_writeback_data(inode))) {
4844 		struct ext4_free_data *new_entry;
4845 		/*
4846 		 * We use __GFP_NOFAIL because ext4_free_blocks() is not allowed
4847 		 * to fail.
4848 		 */
4849 		new_entry = kmem_cache_alloc(ext4_free_data_cachep,
4850 				GFP_NOFS|__GFP_NOFAIL);
4851 		new_entry->efd_start_cluster = bit;
4852 		new_entry->efd_group = block_group;
4853 		new_entry->efd_count = count_clusters;
4854 		new_entry->efd_tid = handle->h_transaction->t_tid;
4855 
4856 		ext4_lock_group(sb, block_group);
4857 		mb_clear_bits(bitmap_bh->b_data, bit, count_clusters);
4858 		ext4_mb_free_metadata(handle, &e4b, new_entry);
4859 	} else {
4860 		/* need to update group_info->bb_free and bitmap
4861 		 * with group lock held. generate_buddy look at
4862 		 * them with group lock_held
4863 		 */
4864 		if (test_opt(sb, DISCARD)) {
4865 			err = ext4_issue_discard(sb, block_group, bit, count,
4866 						 0);
4867 			if (err && err != -EOPNOTSUPP)
4868 				ext4_msg(sb, KERN_WARNING, "discard request in"
4869 					 " group:%d block:%d count:%lu failed"
4870 					 " with %d", block_group, bit, count,
4871 					 err);
4872 		} else
4873 			EXT4_MB_GRP_CLEAR_TRIMMED(e4b.bd_info);
4874 
4875 		ext4_lock_group(sb, block_group);
4876 		mb_clear_bits(bitmap_bh->b_data, bit, count_clusters);
4877 		mb_free_blocks(inode, &e4b, bit, count_clusters);
4878 	}
4879 
4880 	ret = ext4_free_group_clusters(sb, gdp) + count_clusters;
4881 	ext4_free_group_clusters_set(sb, gdp, ret);
4882 	ext4_block_bitmap_csum_set(sb, block_group, gdp, bitmap_bh);
4883 	ext4_group_desc_csum_set(sb, block_group, gdp);
4884 	ext4_unlock_group(sb, block_group);
4885 
4886 	if (sbi->s_log_groups_per_flex) {
4887 		ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
4888 		atomic64_add(count_clusters,
4889 			     &sbi->s_flex_groups[flex_group].free_clusters);
4890 	}
4891 
4892 	if (!(flags & EXT4_FREE_BLOCKS_NO_QUOT_UPDATE))
4893 		dquot_free_block(inode, EXT4_C2B(sbi, count_clusters));
4894 	percpu_counter_add(&sbi->s_freeclusters_counter, count_clusters);
4895 
4896 	ext4_mb_unload_buddy(&e4b);
4897 
4898 	/* We dirtied the bitmap block */
4899 	BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
4900 	err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
4901 
4902 	/* And the group descriptor block */
4903 	BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
4904 	ret = ext4_handle_dirty_metadata(handle, NULL, gd_bh);
4905 	if (!err)
4906 		err = ret;
4907 
4908 	if (overflow && !err) {
4909 		block += count;
4910 		count = overflow;
4911 		put_bh(bitmap_bh);
4912 		goto do_more;
4913 	}
4914 error_return:
4915 	brelse(bitmap_bh);
4916 	ext4_std_error(sb, err);
4917 	return;
4918 }
4919 
4920 /**
4921  * ext4_group_add_blocks() -- Add given blocks to an existing group
4922  * @handle:			handle to this transaction
4923  * @sb:				super block
4924  * @block:			start physical block to add to the block group
4925  * @count:			number of blocks to free
4926  *
4927  * This marks the blocks as free in the bitmap and buddy.
4928  */
ext4_group_add_blocks(handle_t * handle,struct super_block * sb,ext4_fsblk_t block,unsigned long count)4929 int ext4_group_add_blocks(handle_t *handle, struct super_block *sb,
4930 			 ext4_fsblk_t block, unsigned long count)
4931 {
4932 	struct buffer_head *bitmap_bh = NULL;
4933 	struct buffer_head *gd_bh;
4934 	ext4_group_t block_group;
4935 	ext4_grpblk_t bit;
4936 	unsigned int i;
4937 	struct ext4_group_desc *desc;
4938 	struct ext4_sb_info *sbi = EXT4_SB(sb);
4939 	struct ext4_buddy e4b;
4940 	int err = 0, ret, blk_free_count;
4941 	ext4_grpblk_t blocks_freed;
4942 
4943 	ext4_debug("Adding block(s) %llu-%llu\n", block, block + count - 1);
4944 
4945 	if (count == 0)
4946 		return 0;
4947 
4948 	ext4_get_group_no_and_offset(sb, block, &block_group, &bit);
4949 	/*
4950 	 * Check to see if we are freeing blocks across a group
4951 	 * boundary.
4952 	 */
4953 	if (bit + count > EXT4_BLOCKS_PER_GROUP(sb)) {
4954 		ext4_warning(sb, "too much blocks added to group %u",
4955 			     block_group);
4956 		err = -EINVAL;
4957 		goto error_return;
4958 	}
4959 
4960 	bitmap_bh = ext4_read_block_bitmap(sb, block_group);
4961 	if (IS_ERR(bitmap_bh)) {
4962 		err = PTR_ERR(bitmap_bh);
4963 		bitmap_bh = NULL;
4964 		goto error_return;
4965 	}
4966 
4967 	desc = ext4_get_group_desc(sb, block_group, &gd_bh);
4968 	if (!desc) {
4969 		err = -EIO;
4970 		goto error_return;
4971 	}
4972 
4973 	if (in_range(ext4_block_bitmap(sb, desc), block, count) ||
4974 	    in_range(ext4_inode_bitmap(sb, desc), block, count) ||
4975 	    in_range(block, ext4_inode_table(sb, desc), sbi->s_itb_per_group) ||
4976 	    in_range(block + count - 1, ext4_inode_table(sb, desc),
4977 		     sbi->s_itb_per_group)) {
4978 		ext4_error(sb, "Adding blocks in system zones - "
4979 			   "Block = %llu, count = %lu",
4980 			   block, count);
4981 		err = -EINVAL;
4982 		goto error_return;
4983 	}
4984 
4985 	BUFFER_TRACE(bitmap_bh, "getting write access");
4986 	err = ext4_journal_get_write_access(handle, bitmap_bh);
4987 	if (err)
4988 		goto error_return;
4989 
4990 	/*
4991 	 * We are about to modify some metadata.  Call the journal APIs
4992 	 * to unshare ->b_data if a currently-committing transaction is
4993 	 * using it
4994 	 */
4995 	BUFFER_TRACE(gd_bh, "get_write_access");
4996 	err = ext4_journal_get_write_access(handle, gd_bh);
4997 	if (err)
4998 		goto error_return;
4999 
5000 	for (i = 0, blocks_freed = 0; i < count; i++) {
5001 		BUFFER_TRACE(bitmap_bh, "clear bit");
5002 		if (!mb_test_bit(bit + i, bitmap_bh->b_data)) {
5003 			ext4_error(sb, "bit already cleared for block %llu",
5004 				   (ext4_fsblk_t)(block + i));
5005 			BUFFER_TRACE(bitmap_bh, "bit already cleared");
5006 		} else {
5007 			blocks_freed++;
5008 		}
5009 	}
5010 
5011 	err = ext4_mb_load_buddy(sb, block_group, &e4b);
5012 	if (err)
5013 		goto error_return;
5014 
5015 	/*
5016 	 * need to update group_info->bb_free and bitmap
5017 	 * with group lock held. generate_buddy look at
5018 	 * them with group lock_held
5019 	 */
5020 	ext4_lock_group(sb, block_group);
5021 	mb_clear_bits(bitmap_bh->b_data, bit, count);
5022 	mb_free_blocks(NULL, &e4b, bit, count);
5023 	blk_free_count = blocks_freed + ext4_free_group_clusters(sb, desc);
5024 	ext4_free_group_clusters_set(sb, desc, blk_free_count);
5025 	ext4_block_bitmap_csum_set(sb, block_group, desc, bitmap_bh);
5026 	ext4_group_desc_csum_set(sb, block_group, desc);
5027 	ext4_unlock_group(sb, block_group);
5028 	percpu_counter_add(&sbi->s_freeclusters_counter,
5029 			   EXT4_NUM_B2C(sbi, blocks_freed));
5030 
5031 	if (sbi->s_log_groups_per_flex) {
5032 		ext4_group_t flex_group = ext4_flex_group(sbi, block_group);
5033 		atomic64_add(EXT4_NUM_B2C(sbi, blocks_freed),
5034 			     &sbi->s_flex_groups[flex_group].free_clusters);
5035 	}
5036 
5037 	ext4_mb_unload_buddy(&e4b);
5038 
5039 	/* We dirtied the bitmap block */
5040 	BUFFER_TRACE(bitmap_bh, "dirtied bitmap block");
5041 	err = ext4_handle_dirty_metadata(handle, NULL, bitmap_bh);
5042 
5043 	/* And the group descriptor block */
5044 	BUFFER_TRACE(gd_bh, "dirtied group descriptor block");
5045 	ret = ext4_handle_dirty_metadata(handle, NULL, gd_bh);
5046 	if (!err)
5047 		err = ret;
5048 
5049 error_return:
5050 	brelse(bitmap_bh);
5051 	ext4_std_error(sb, err);
5052 	return err;
5053 }
5054 
5055 /**
5056  * ext4_trim_extent -- function to TRIM one single free extent in the group
5057  * @sb:		super block for the file system
5058  * @start:	starting block of the free extent in the alloc. group
5059  * @count:	number of blocks to TRIM
5060  * @group:	alloc. group we are working with
5061  * @e4b:	ext4 buddy for the group
5062  * @blkdev_flags: flags for the block device
5063  *
5064  * Trim "count" blocks starting at "start" in the "group". To assure that no
5065  * one will allocate those blocks, mark it as used in buddy bitmap. This must
5066  * be called with under the group lock.
5067  */
ext4_trim_extent(struct super_block * sb,int start,int count,ext4_group_t group,struct ext4_buddy * e4b,unsigned long blkdev_flags)5068 static int ext4_trim_extent(struct super_block *sb, int start, int count,
5069 			    ext4_group_t group, struct ext4_buddy *e4b,
5070 			    unsigned long blkdev_flags)
5071 __releases(bitlock)
5072 __acquires(bitlock)
5073 {
5074 	struct ext4_free_extent ex;
5075 	int ret = 0;
5076 
5077 	trace_ext4_trim_extent(sb, group, start, count);
5078 
5079 	assert_spin_locked(ext4_group_lock_ptr(sb, group));
5080 
5081 	ex.fe_start = start;
5082 	ex.fe_group = group;
5083 	ex.fe_len = count;
5084 
5085 	/*
5086 	 * Mark blocks used, so no one can reuse them while
5087 	 * being trimmed.
5088 	 */
5089 	mb_mark_used(e4b, &ex);
5090 	ext4_unlock_group(sb, group);
5091 	ret = ext4_issue_discard(sb, group, start, count, blkdev_flags);
5092 	ext4_lock_group(sb, group);
5093 	mb_free_blocks(NULL, e4b, start, ex.fe_len);
5094 	return ret;
5095 }
5096 
5097 /**
5098  * ext4_trim_all_free -- function to trim all free space in alloc. group
5099  * @sb:			super block for file system
5100  * @group:		group to be trimmed
5101  * @start:		first group block to examine
5102  * @max:		last group block to examine
5103  * @minblocks:		minimum extent block count
5104  * @blkdev_flags:	flags for the block device
5105  *
5106  * ext4_trim_all_free walks through group's buddy bitmap searching for free
5107  * extents. When the free block is found, ext4_trim_extent is called to TRIM
5108  * the extent.
5109  *
5110  *
5111  * ext4_trim_all_free walks through group's block bitmap searching for free
5112  * extents. When the free extent is found, mark it as used in group buddy
5113  * bitmap. Then issue a TRIM command on this extent and free the extent in
5114  * the group buddy bitmap. This is done until whole group is scanned.
5115  */
5116 static ext4_grpblk_t
ext4_trim_all_free(struct super_block * sb,ext4_group_t group,ext4_grpblk_t start,ext4_grpblk_t max,ext4_grpblk_t minblocks,unsigned long blkdev_flags)5117 ext4_trim_all_free(struct super_block *sb, ext4_group_t group,
5118 		   ext4_grpblk_t start, ext4_grpblk_t max,
5119 		   ext4_grpblk_t minblocks, unsigned long blkdev_flags)
5120 {
5121 	void *bitmap;
5122 	ext4_grpblk_t next, count = 0, free_count = 0;
5123 	struct ext4_buddy e4b;
5124 	int ret = 0;
5125 
5126 	trace_ext4_trim_all_free(sb, group, start, max);
5127 
5128 	ret = ext4_mb_load_buddy(sb, group, &e4b);
5129 	if (ret) {
5130 		ext4_warning(sb, "Error %d loading buddy information for %u",
5131 			     ret, group);
5132 		return ret;
5133 	}
5134 	bitmap = e4b.bd_bitmap;
5135 
5136 	ext4_lock_group(sb, group);
5137 	if (EXT4_MB_GRP_WAS_TRIMMED(e4b.bd_info) &&
5138 	    minblocks >= atomic_read(&EXT4_SB(sb)->s_last_trim_minblks))
5139 		goto out;
5140 
5141 	start = (e4b.bd_info->bb_first_free > start) ?
5142 		e4b.bd_info->bb_first_free : start;
5143 
5144 	while (start <= max) {
5145 		start = mb_find_next_zero_bit(bitmap, max + 1, start);
5146 		if (start > max)
5147 			break;
5148 		next = mb_find_next_bit(bitmap, max + 1, start);
5149 
5150 		if ((next - start) >= minblocks) {
5151 			ret = ext4_trim_extent(sb, start,
5152 					       next - start, group, &e4b,
5153 					       blkdev_flags);
5154 			if (ret && ret != -EOPNOTSUPP)
5155 				break;
5156 			ret = 0;
5157 			count += next - start;
5158 		}
5159 		free_count += next - start;
5160 		start = next + 1;
5161 
5162 		if (fatal_signal_pending(current)) {
5163 			count = -ERESTARTSYS;
5164 			break;
5165 		}
5166 
5167 		if (need_resched()) {
5168 			ext4_unlock_group(sb, group);
5169 			cond_resched();
5170 			ext4_lock_group(sb, group);
5171 		}
5172 
5173 		if ((e4b.bd_info->bb_free - free_count) < minblocks)
5174 			break;
5175 	}
5176 
5177 	if (!ret) {
5178 		ret = count;
5179 		EXT4_MB_GRP_SET_TRIMMED(e4b.bd_info);
5180 	}
5181 out:
5182 	ext4_unlock_group(sb, group);
5183 	ext4_mb_unload_buddy(&e4b);
5184 
5185 	ext4_debug("trimmed %d blocks in the group %d\n",
5186 		count, group);
5187 
5188 	return ret;
5189 }
5190 
5191 /**
5192  * ext4_trim_fs() -- trim ioctl handle function
5193  * @sb:			superblock for filesystem
5194  * @range:		fstrim_range structure
5195  * @blkdev_flags:	flags for the block device
5196  *
5197  * start:	First Byte to trim
5198  * len:		number of Bytes to trim from start
5199  * minlen:	minimum extent length in Bytes
5200  * ext4_trim_fs goes through all allocation groups containing Bytes from
5201  * start to start+len. For each such a group ext4_trim_all_free function
5202  * is invoked to trim all free space.
5203  */
ext4_trim_fs(struct super_block * sb,struct fstrim_range * range,unsigned long blkdev_flags)5204 int ext4_trim_fs(struct super_block *sb, struct fstrim_range *range,
5205 			unsigned long blkdev_flags)
5206 {
5207 	struct ext4_group_info *grp;
5208 	ext4_group_t group, first_group, last_group;
5209 	ext4_grpblk_t cnt = 0, first_cluster, last_cluster;
5210 	uint64_t start, end, minlen, trimmed = 0;
5211 	ext4_fsblk_t first_data_blk =
5212 			le32_to_cpu(EXT4_SB(sb)->s_es->s_first_data_block);
5213 	ext4_fsblk_t max_blks = ext4_blocks_count(EXT4_SB(sb)->s_es);
5214 	int ret = 0;
5215 
5216 	start = range->start >> sb->s_blocksize_bits;
5217 	end = start + (range->len >> sb->s_blocksize_bits) - 1;
5218 	minlen = EXT4_NUM_B2C(EXT4_SB(sb),
5219 			      range->minlen >> sb->s_blocksize_bits);
5220 
5221 	if (minlen > EXT4_CLUSTERS_PER_GROUP(sb) ||
5222 	    start >= max_blks ||
5223 	    range->len < sb->s_blocksize)
5224 		return -EINVAL;
5225 	if (end >= max_blks)
5226 		end = max_blks - 1;
5227 	if (end <= first_data_blk)
5228 		goto out;
5229 	if (start < first_data_blk)
5230 		start = first_data_blk;
5231 
5232 	/* Determine first and last group to examine based on start and end */
5233 	ext4_get_group_no_and_offset(sb, (ext4_fsblk_t) start,
5234 				     &first_group, &first_cluster);
5235 	ext4_get_group_no_and_offset(sb, (ext4_fsblk_t) end,
5236 				     &last_group, &last_cluster);
5237 
5238 	/* end now represents the last cluster to discard in this group */
5239 	end = EXT4_CLUSTERS_PER_GROUP(sb) - 1;
5240 
5241 	for (group = first_group; group <= last_group; group++) {
5242 		grp = ext4_get_group_info(sb, group);
5243 		/* We only do this if the grp has never been initialized */
5244 		if (unlikely(EXT4_MB_GRP_NEED_INIT(grp))) {
5245 			ret = ext4_mb_init_group(sb, group, GFP_NOFS);
5246 			if (ret)
5247 				break;
5248 		}
5249 
5250 		/*
5251 		 * For all the groups except the last one, last cluster will
5252 		 * always be EXT4_CLUSTERS_PER_GROUP(sb)-1, so we only need to
5253 		 * change it for the last group, note that last_cluster is
5254 		 * already computed earlier by ext4_get_group_no_and_offset()
5255 		 */
5256 		if (group == last_group)
5257 			end = last_cluster;
5258 
5259 		if (grp->bb_free >= minlen) {
5260 			cnt = ext4_trim_all_free(sb, group, first_cluster,
5261 						end, minlen, blkdev_flags);
5262 			if (cnt < 0) {
5263 				ret = cnt;
5264 				break;
5265 			}
5266 			trimmed += cnt;
5267 		}
5268 
5269 		/*
5270 		 * For every group except the first one, we are sure
5271 		 * that the first cluster to discard will be cluster #0.
5272 		 */
5273 		first_cluster = 0;
5274 	}
5275 
5276 	if (!ret)
5277 		atomic_set(&EXT4_SB(sb)->s_last_trim_minblks, minlen);
5278 
5279 out:
5280 	range->len = EXT4_C2B(EXT4_SB(sb), trimmed) << sb->s_blocksize_bits;
5281 	return ret;
5282 }
5283