13  * space management.
15  * Factors such as compression, wasted space at the ends of LEBs, space in other
17  * impossible to accurately predict the amount of space needed. Consequently
26  * When pessimistic budget calculations say that there is no enough space,
62  * This function runs garbage collector to make some more free space. Returns
70 	/* Make some free space by garbage-collecting dirty space */  in run_gc()
100  * make_free_space - make more free space on the file-system.
104  * is supposedly no free space. But in most cases there is some free space:
106  *     needed, so shrinking the liability is one way to make free space - the
107  *     cached data will take less space then it was budgeted for;
108  *   o GC may turn some dark space into free space (budgeting treats dark space
112  * So this function tries to do the above. Returns %-EAGAIN if some free space
114  * Returns %-ENOSPC if it couldn't do more free space, and other negative error
169 	/* And make sure we have thrice the index size of space reserved */  in ubifs_calc_min_idx_lebs()
188  * ubifs_calc_available - calculate available FS space.
192  * This function calculates and returns amount of FS space available for use.
202 	 * Now 'available' contains theoretically available flash space  in ubifs_calc_available()
203 	 * assuming there is no index, so we have to subtract the space which  in ubifs_calc_available()
222 	/* Subtract the dead space which is not available for use */  in ubifs_calc_available()
226 	 * Subtract dark space, which might or might not be usable - it depends  in ubifs_calc_available()
229 	 * space cannot be used.  in ubifs_calc_available()
234 	 * However, there is more dark space. The index may be bigger than  in ubifs_calc_available()
236 	 * their dark space is not included in total_dark, so it is subtracted  in ubifs_calc_available()
252  * UBIFS has so-called "reserved pool" which is flash space reserved
266  * do_budget_space - reserve flash space for index and data growth.
272  * When budgeting index space, UBIFS reserves thrice as many LEBs as the index
276  * budgeted index space to the size of the current index, multiplies this by 3,
282  *    there is free space. IOW, the index may take a lot of LEBs, but the LEBs
295 	/* First budget index space */  in do_budget_space()
312 	 * dirty space, @c->idx_gc_cnt are available because they are index  in do_budget_space()
329 		dbg_budg("out of indexing space: min_idx_lebs %d (old %d), rsvd_idx_lebs %d",  in do_budget_space()
338 		dbg_budg("out of data space: available %lld, outstanding %lld",  in do_budget_space()
410  * ubifs_budget_space - ensure there is enough space to complete an operation.
415  * approximation of how much flash space the operation needs. The goal of this
416  * function is to make sure UBIFS always has flash space to flush all dirty
419  * %-ENOSPC if there is no free space and other negative error codes in case of
450 		dbg_budg("no space");  in ubifs_budget_space()
475 		dbg_budg("no space for fast budgeting");  in ubifs_budget_space()
496 		ubifs_err(c, "cannot budget space, error %d", err);  in ubifs_budget_space()
501  * ubifs_release_budget - release budgeted free space.
505  * This function releases the space budgeted by 'ubifs_budget_space()'. Note,
576 	/* And re-calculate the indexing space reservation */  in ubifs_convert_page_budget()
588  * clean. It also causes the "no space" flags to be cleared.
596 	/* The "no space" flags will be cleared because dd_growth is > 0 */  in ubifs_release_dirty_inode_budget()
602  * ubifs_reported_space - calculate reported free space.
604  * @free: amount of free space
606  * This function calculates amount of free space which will be reported to
607  * user-space. User-space application tend to expect that if the file-system
611  * overhead, and UBIFS has to report slightly less free space to meet the above
614  * This function assumes free space is made up of uncompressed data nodes and
616  * space to write the index thrice).
619  * UBIFS reports less space than it actually has.
626 	 * Reported space size is @free * X, where X is UBIFS block size  in ubifs_reported_space()
635 	 * Note, the multiplier 3 is because UBIFS reserves thrice as more space  in ubifs_reported_space()
647  * ubifs_get_free_space_nolock - return amount of free space.
650  * This function calculates amount of free space to report to user-space.
654  * free flash space it has (well, because not all dirty space is reclaimable,
656  * bread user expectations about what free space is. Users seem to accustomed
657  * to assume that if the file-system reports N bytes of free space, they would
672 	 * When reporting free space to user-space, UBIFS guarantees that it is  in ubifs_get_free_space_nolock()
673 	 * possible to write a file of free space size. This means that for  in ubifs_get_free_space_nolock()
677 	 * Thus, amend the available space.  in ubifs_get_free_space_nolock()
699  * ubifs_get_free_space - return amount of free space.
702  * This function calculates and returns amount of free space to report to
703  * user-space.