Blame view

fs/ubifs/budget.c 23.8 KB
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
  /*
   * This file is part of UBIFS.
   *
   * Copyright (C) 2006-2008 Nokia Corporation.
   *
   * This program is free software; you can redistribute it and/or modify it
   * under the terms of the GNU General Public License version 2 as published by
   * the Free Software Foundation.
   *
   * This program is distributed in the hope that it will be useful, but WITHOUT
   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
   * more details.
   *
   * You should have received a copy of the GNU General Public License along with
   * this program; if not, write to the Free Software Foundation, Inc., 51
   * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
   *
   * Authors: Adrian Hunter
   *          Artem Bityutskiy (Битюцкий Артём)
   */
  
  /*
   * This file implements the budgeting sub-system which is responsible for UBIFS
   * space management.
   *
   * Factors such as compression, wasted space at the ends of LEBs, space in other
   * journal heads, the effect of updates on the index, and so on, make it
   * impossible to accurately predict the amount of space needed. Consequently
   * approximations are used.
   */
  
  #include "ubifs.h"
  #include <linux/writeback.h>
4d61db4f8   Artem Bityutskiy   UBIFS: use nicer ...
35
  #include <linux/math64.h>
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
36
37
38
39
  
  /*
   * When pessimistic budget calculations say that there is no enough space,
   * UBIFS starts writing back dirty inodes and pages, doing garbage collection,
2acf80675   Artem Bityutskiy   UBIFS: simplify m...
40
   * or committing. The below constant defines maximum number of times UBIFS
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
41
42
   * repeats the operations.
   */
2acf80675   Artem Bityutskiy   UBIFS: simplify m...
43
  #define MAX_MKSPC_RETRIES 3
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
44
45
46
47
48
49
50
51
  
  /*
   * The below constant defines amount of dirty pages which should be written
   * back at when trying to shrink the liability.
   */
  #define NR_TO_WRITE 16
  
  /**
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
52
53
54
55
56
   * shrink_liability - write-back some dirty pages/inodes.
   * @c: UBIFS file-system description object
   * @nr_to_write: how many dirty pages to write-back
   *
   * This function shrinks UBIFS liability by means of writing back some amount
b6e51316d   Jens Axboe   writeback: separa...
57
   * of dirty inodes and their pages.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
58
59
60
61
62
   *
   * Note, this function synchronizes even VFS inodes which are locked
   * (@i_mutex) by the caller of the budgeting function, because write-back does
   * not touch @i_mutex.
   */
b6e51316d   Jens Axboe   writeback: separa...
63
  static void shrink_liability(struct ubifs_info *c, int nr_to_write)
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
64
  {
cf37e9724   Christoph Hellwig   writeback: enforc...
65
  	down_read(&c->vfs_sb->s_umount);
b6e51316d   Jens Axboe   writeback: separa...
66
  	writeback_inodes_sb(c->vfs_sb);
cf37e9724   Christoph Hellwig   writeback: enforc...
67
  	up_read(&c->vfs_sb->s_umount);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
68
  }
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
  /**
   * run_gc - run garbage collector.
   * @c: UBIFS file-system description object
   *
   * This function runs garbage collector to make some more free space. Returns
   * zero if a free LEB has been produced, %-EAGAIN if commit is required, and a
   * negative error code in case of failure.
   */
  static int run_gc(struct ubifs_info *c)
  {
  	int err, lnum;
  
  	/* Make some free space by garbage-collecting dirty space */
  	down_read(&c->commit_sem);
  	lnum = ubifs_garbage_collect(c, 1);
  	up_read(&c->commit_sem);
  	if (lnum < 0)
  		return lnum;
  
  	/* GC freed one LEB, return it to lprops */
  	dbg_budg("GC freed LEB %d", lnum);
  	err = ubifs_return_leb(c, lnum);
  	if (err)
  		return err;
  	return 0;
  }
  
  /**
2acf80675   Artem Bityutskiy   UBIFS: simplify m...
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
   * get_liability - calculate current liability.
   * @c: UBIFS file-system description object
   *
   * This function calculates and returns current UBIFS liability, i.e. the
   * amount of bytes UBIFS has "promised" to write to the media.
   */
  static long long get_liability(struct ubifs_info *c)
  {
  	long long liab;
  
  	spin_lock(&c->space_lock);
  	liab = c->budg_idx_growth + c->budg_data_growth + c->budg_dd_growth;
  	spin_unlock(&c->space_lock);
  	return liab;
  }
  
  /**
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
114
115
   * make_free_space - make more free space on the file-system.
   * @c: UBIFS file-system description object
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
116
117
118
   *
   * This function is called when an operation cannot be budgeted because there
   * is supposedly no free space. But in most cases there is some free space:
025dfdafe   Frederik Schwarzer   trivial: fix then...
119
   *   o budgeting is pessimistic, so it always budgets more than it is actually
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
120
121
122
123
124
125
126
127
128
129
130
   *     needed, so shrinking the liability is one way to make free space - the
   *     cached data will take less space then it was budgeted for;
   *   o GC may turn some dark space into free space (budgeting treats dark space
   *     as not available);
   *   o commit may free some LEB, i.e., turn freeable LEBs into free LEBs.
   *
   * So this function tries to do the above. Returns %-EAGAIN if some free space
   * was presumably made and the caller has to re-try budgeting the operation.
   * Returns %-ENOSPC if it couldn't do more free space, and other negative error
   * codes on failures.
   */
2acf80675   Artem Bityutskiy   UBIFS: simplify m...
131
  static int make_free_space(struct ubifs_info *c)
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
132
  {
2acf80675   Artem Bityutskiy   UBIFS: simplify m...
133
134
  	int err, retries = 0;
  	long long liab1, liab2;
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
135

2acf80675   Artem Bityutskiy   UBIFS: simplify m...
136
137
138
139
140
141
142
143
  	do {
  		liab1 = get_liability(c);
  		/*
  		 * We probably have some dirty pages or inodes (liability), try
  		 * to write them back.
  		 */
  		dbg_budg("liability %lld, run write-back", liab1);
  		shrink_liability(c, NR_TO_WRITE);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
144

2acf80675   Artem Bityutskiy   UBIFS: simplify m...
145
146
147
  		liab2 = get_liability(c);
  		if (liab2 < liab1)
  			return -EAGAIN;
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
148

2acf80675   Artem Bityutskiy   UBIFS: simplify m...
149
  		dbg_budg("new liability %lld (not shrinked)", liab2);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
150

2acf80675   Artem Bityutskiy   UBIFS: simplify m...
151
152
  		/* Liability did not shrink again, try GC */
  		dbg_budg("Run GC");
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
153
154
155
  		err = run_gc(c);
  		if (!err)
  			return -EAGAIN;
2acf80675   Artem Bityutskiy   UBIFS: simplify m...
156
157
  		if (err != -EAGAIN && err != -ENOSPC)
  			/* Some real error happened */
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
158
  			return err;
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
159

2acf80675   Artem Bityutskiy   UBIFS: simplify m...
160
  		dbg_budg("Run commit (retries %d)", retries);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
161
162
163
  		err = ubifs_run_commit(c);
  		if (err)
  			return err;
2acf80675   Artem Bityutskiy   UBIFS: simplify m...
164
  	} while (retries++ < MAX_MKSPC_RETRIES);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
165
166
167
168
  	return -ENOSPC;
  }
  
  /**
fb1cd01a3   Artem Bityutskiy   UBIFS: introduce ...
169
   * ubifs_calc_min_idx_lebs - calculate amount of LEBs for the index.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
170
171
   * @c: UBIFS file-system description object
   *
fb1cd01a3   Artem Bityutskiy   UBIFS: introduce ...
172
173
   * This function calculates and returns the number of LEBs which should be kept
   * for index usage.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
174
175
176
   */
  int ubifs_calc_min_idx_lebs(struct ubifs_info *c)
  {
fb1cd01a3   Artem Bityutskiy   UBIFS: introduce ...
177
  	int idx_lebs;
4d61db4f8   Artem Bityutskiy   UBIFS: use nicer ...
178
  	long long idx_size;
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
179
180
  
  	idx_size = c->old_idx_sz + c->budg_idx_growth + c->budg_uncommitted_idx;
3a13252c6   Adrian Hunter   UBIFS: correct sp...
181
  	/* And make sure we have thrice the index size of space reserved */
fb1cd01a3   Artem Bityutskiy   UBIFS: introduce ...
182
  	idx_size += idx_size << 1;
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
183
184
185
186
187
  	/*
  	 * We do not maintain 'old_idx_size' as 'old_idx_lebs'/'old_idx_bytes'
  	 * pair, nor similarly the two variables for the new index size, so we
  	 * have to do this costly 64-bit division on fast-path.
  	 */
fb1cd01a3   Artem Bityutskiy   UBIFS: introduce ...
188
  	idx_lebs = div_u64(idx_size + c->idx_leb_size - 1, c->idx_leb_size);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
189
190
191
192
  	/*
  	 * The index head is not available for the in-the-gaps method, so add an
  	 * extra LEB to compensate.
  	 */
4d61db4f8   Artem Bityutskiy   UBIFS: use nicer ...
193
194
195
196
  	idx_lebs += 1;
  	if (idx_lebs < MIN_INDEX_LEBS)
  		idx_lebs = MIN_INDEX_LEBS;
  	return idx_lebs;
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
197
198
199
200
201
202
203
204
205
206
207
208
209
  }
  
  /**
   * ubifs_calc_available - calculate available FS space.
   * @c: UBIFS file-system description object
   * @min_idx_lebs: minimum number of LEBs reserved for the index
   *
   * This function calculates and returns amount of FS space available for use.
   */
  long long ubifs_calc_available(const struct ubifs_info *c, int min_idx_lebs)
  {
  	int subtract_lebs;
  	long long available;
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
  	available = c->main_bytes - c->lst.total_used;
  
  	/*
  	 * Now 'available' contains theoretically available flash space
  	 * assuming there is no index, so we have to subtract the space which
  	 * is reserved for the index.
  	 */
  	subtract_lebs = min_idx_lebs;
  
  	/* Take into account that GC reserves one LEB for its own needs */
  	subtract_lebs += 1;
  
  	/*
  	 * The GC journal head LEB is not really accessible. And since
  	 * different write types go to different heads, we may count only on
  	 * one head's space.
  	 */
  	subtract_lebs += c->jhead_cnt - 1;
  
  	/* We also reserve one LEB for deletions, which bypass budgeting */
  	subtract_lebs += 1;
  
  	available -= (long long)subtract_lebs * c->leb_size;
  
  	/* Subtract the dead space which is not available for use */
  	available -= c->lst.total_dead;
  
  	/*
  	 * Subtract dark space, which might or might not be usable - it depends
  	 * on the data which we have on the media and which will be written. If
  	 * this is a lot of uncompressed or not-compressible data, the dark
  	 * space cannot be used.
  	 */
  	available -= c->lst.total_dark;
  
  	/*
  	 * However, there is more dark space. The index may be bigger than
  	 * @min_idx_lebs. Those extra LEBs are assumed to be available, but
  	 * their dark space is not included in total_dark, so it is subtracted
  	 * here.
  	 */
  	if (c->lst.idx_lebs > min_idx_lebs) {
  		subtract_lebs = c->lst.idx_lebs - min_idx_lebs;
  		available -= subtract_lebs * c->dark_wm;
  	}
  
  	/* The calculations are rough and may end up with a negative number */
  	return available > 0 ? available : 0;
  }
  
  /**
   * can_use_rp - check whether the user is allowed to use reserved pool.
   * @c: UBIFS file-system description object
   *
   * UBIFS has so-called "reserved pool" which is flash space reserved
   * for the superuser and for uses whose UID/GID is recorded in UBIFS superblock.
   * This function checks whether current user is allowed to use reserved pool.
   * Returns %1  current user is allowed to use reserved pool and %0 otherwise.
   */
  static int can_use_rp(struct ubifs_info *c)
  {
26bf1946e   David Howells   CRED: Wrap task c...
271
  	if (current_fsuid() == c->rp_uid || capable(CAP_SYS_RESOURCE) ||
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
272
273
274
275
276
277
278
279
280
  	    (c->rp_gid != 0 && in_group_p(c->rp_gid)))
  		return 1;
  	return 0;
  }
  
  /**
   * do_budget_space - reserve flash space for index and data growth.
   * @c: UBIFS file-system description object
   *
fb1cd01a3   Artem Bityutskiy   UBIFS: introduce ...
281
282
   * This function makes sure UBIFS has enough free LEBs for index growth and
   * data.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
283
   *
3a13252c6   Adrian Hunter   UBIFS: correct sp...
284
   * When budgeting index space, UBIFS reserves thrice as many LEBs as the index
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
285
286
287
   * would take if it was consolidated and written to the flash. This guarantees
   * that the "in-the-gaps" commit method always succeeds and UBIFS will always
   * be able to commit dirty index. So this function basically adds amount of
b364b41ae   Artem Bityutskiy   UBIFS: reserve mo...
288
   * budgeted index space to the size of the current index, multiplies this by 3,
fb1cd01a3   Artem Bityutskiy   UBIFS: introduce ...
289
   * and makes sure this does not exceed the amount of free LEBs.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
290
291
292
293
294
295
   *
   * Notes about @c->min_idx_lebs and @c->lst.idx_lebs variables:
   * o @c->lst.idx_lebs is the number of LEBs the index currently uses. It might
   *    be large, because UBIFS does not do any index consolidation as long as
   *    there is free space. IOW, the index may take a lot of LEBs, but the LEBs
   *    will contain a lot of dirt.
7d4e9ccb4   Artem Bityutskiy   UBIFS: fix commen...
296
297
   * o @c->min_idx_lebs is the number of LEBS the index presumably takes. IOW,
   *    the index may be consolidated to take up to @c->min_idx_lebs LEBs.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
   *
   * This function returns zero in case of success, and %-ENOSPC in case of
   * failure.
   */
  static int do_budget_space(struct ubifs_info *c)
  {
  	long long outstanding, available;
  	int lebs, rsvd_idx_lebs, min_idx_lebs;
  
  	/* First budget index space */
  	min_idx_lebs = ubifs_calc_min_idx_lebs(c);
  
  	/* Now 'min_idx_lebs' contains number of LEBs to reserve */
  	if (min_idx_lebs > c->lst.idx_lebs)
  		rsvd_idx_lebs = min_idx_lebs - c->lst.idx_lebs;
  	else
  		rsvd_idx_lebs = 0;
  
  	/*
  	 * The number of LEBs that are available to be used by the index is:
  	 *
  	 *    @c->lst.empty_lebs + @c->freeable_cnt + @c->idx_gc_cnt -
  	 *    @c->lst.taken_empty_lebs
  	 *
948cfb219   Artem Bityutskiy   UBIFS: add a prin...
322
323
324
325
326
327
328
  	 * @c->lst.empty_lebs are available because they are empty.
  	 * @c->freeable_cnt are available because they contain only free and
  	 * dirty space, @c->idx_gc_cnt are available because they are index
  	 * LEBs that have been garbage collected and are awaiting the commit
  	 * before they can be used. And the in-the-gaps method will grab these
  	 * if it needs them. @c->lst.taken_empty_lebs are empty LEBs that have
  	 * already been allocated for some purpose.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
329
  	 *
948cfb219   Artem Bityutskiy   UBIFS: add a prin...
330
331
332
333
334
335
336
  	 * Note, @c->idx_gc_cnt is included to both @c->lst.empty_lebs (because
  	 * these LEBs are empty) and to @c->lst.taken_empty_lebs (because they
  	 * are taken until after the commit).
  	 *
  	 * Note, @c->lst.taken_empty_lebs may temporarily be higher by one
  	 * because of the way we serialize LEB allocations and budgeting. See a
  	 * comment in 'ubifs_find_free_space()'.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
  	 */
  	lebs = c->lst.empty_lebs + c->freeable_cnt + c->idx_gc_cnt -
  	       c->lst.taken_empty_lebs;
  	if (unlikely(rsvd_idx_lebs > lebs)) {
  		dbg_budg("out of indexing space: min_idx_lebs %d (old %d), "
  			 "rsvd_idx_lebs %d", min_idx_lebs, c->min_idx_lebs,
  			 rsvd_idx_lebs);
  		return -ENOSPC;
  	}
  
  	available = ubifs_calc_available(c, min_idx_lebs);
  	outstanding = c->budg_data_growth + c->budg_dd_growth;
  
  	if (unlikely(available < outstanding)) {
  		dbg_budg("out of data space: available %lld, outstanding %lld",
  			 available, outstanding);
  		return -ENOSPC;
  	}
  
  	if (available - outstanding <= c->rp_size && !can_use_rp(c))
  		return -ENOSPC;
  
  	c->min_idx_lebs = min_idx_lebs;
  	return 0;
  }
  
  /**
   * calc_idx_growth - calculate approximate index growth from budgeting request.
   * @c: UBIFS file-system description object
   * @req: budgeting request
   *
   * For now we assume each new node adds one znode. But this is rather poor
   * approximation, though.
   */
  static int calc_idx_growth(const struct ubifs_info *c,
  			   const struct ubifs_budget_req *req)
  {
  	int znodes;
  
  	znodes = req->new_ino + (req->new_page << UBIFS_BLOCKS_PER_PAGE_SHIFT) +
  		 req->new_dent;
  	return znodes * c->max_idx_node_sz;
  }
  
  /**
   * calc_data_growth - calculate approximate amount of new data from budgeting
   * request.
   * @c: UBIFS file-system description object
   * @req: budgeting request
   */
  static int calc_data_growth(const struct ubifs_info *c,
  			    const struct ubifs_budget_req *req)
  {
  	int data_growth;
  
  	data_growth = req->new_ino  ? c->inode_budget : 0;
  	if (req->new_page)
  		data_growth += c->page_budget;
  	if (req->new_dent)
  		data_growth += c->dent_budget;
  	data_growth += req->new_ino_d;
  	return data_growth;
  }
  
  /**
   * calc_dd_growth - calculate approximate amount of data which makes other data
   * dirty from budgeting request.
   * @c: UBIFS file-system description object
   * @req: budgeting request
   */
  static int calc_dd_growth(const struct ubifs_info *c,
  			  const struct ubifs_budget_req *req)
  {
  	int dd_growth;
  
  	dd_growth = req->dirtied_page ? c->page_budget : 0;
  
  	if (req->dirtied_ino)
  		dd_growth += c->inode_budget << (req->dirtied_ino - 1);
  	if (req->mod_dent)
  		dd_growth += c->dent_budget;
  	dd_growth += req->dirtied_ino_d;
  	return dd_growth;
  }
  
  /**
   * ubifs_budget_space - ensure there is enough space to complete an operation.
   * @c: UBIFS file-system description object
   * @req: budget request
   *
   * This function allocates budget for an operation. It uses pessimistic
   * approximation of how much flash space the operation needs. The goal of this
   * function is to make sure UBIFS always has flash space to flush all dirty
   * pages, dirty inodes, and dirty znodes (liability). This function may force
   * commit, garbage-collection or write-back. Returns zero in case of success,
   * %-ENOSPC if there is no free space and other negative error codes in case of
   * failures.
   */
  int ubifs_budget_space(struct ubifs_info *c, struct ubifs_budget_req *req)
  {
  	int uninitialized_var(cmt_retries), uninitialized_var(wb_retries);
2acf80675   Artem Bityutskiy   UBIFS: simplify m...
438
  	int err, idx_growth, data_growth, dd_growth, retried = 0;
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
439

547000da6   Artem Bityutskiy   UBIFS: improve bu...
440
441
442
443
444
445
  	ubifs_assert(req->new_page <= 1);
  	ubifs_assert(req->dirtied_page <= 1);
  	ubifs_assert(req->new_dent <= 1);
  	ubifs_assert(req->mod_dent <= 1);
  	ubifs_assert(req->new_ino <= 1);
  	ubifs_assert(req->new_ino_d <= UBIFS_MAX_INO_DATA);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
446
447
  	ubifs_assert(req->dirtied_ino <= 4);
  	ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);
dab4b4d2f   Artem Bityutskiy   UBIFS: align inod...
448
449
  	ubifs_assert(!(req->new_ino_d & 7));
  	ubifs_assert(!(req->dirtied_ino_d & 7));
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
450
451
452
453
454
455
  
  	data_growth = calc_data_growth(c, req);
  	dd_growth = calc_dd_growth(c, req);
  	if (!data_growth && !dd_growth)
  		return 0;
  	idx_growth = calc_idx_growth(c, req);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
  
  again:
  	spin_lock(&c->space_lock);
  	ubifs_assert(c->budg_idx_growth >= 0);
  	ubifs_assert(c->budg_data_growth >= 0);
  	ubifs_assert(c->budg_dd_growth >= 0);
  
  	if (unlikely(c->nospace) && (c->nospace_rp || !can_use_rp(c))) {
  		dbg_budg("no space");
  		spin_unlock(&c->space_lock);
  		return -ENOSPC;
  	}
  
  	c->budg_idx_growth += idx_growth;
  	c->budg_data_growth += data_growth;
  	c->budg_dd_growth += dd_growth;
  
  	err = do_budget_space(c);
  	if (likely(!err)) {
  		req->idx_growth = idx_growth;
  		req->data_growth = data_growth;
  		req->dd_growth = dd_growth;
  		spin_unlock(&c->space_lock);
  		return 0;
  	}
  
  	/* Restore the old values */
  	c->budg_idx_growth -= idx_growth;
  	c->budg_data_growth -= data_growth;
  	c->budg_dd_growth -= dd_growth;
  	spin_unlock(&c->space_lock);
  
  	if (req->fast) {
  		dbg_budg("no space for fast budgeting");
  		return err;
  	}
2acf80675   Artem Bityutskiy   UBIFS: simplify m...
492
493
  	err = make_free_space(c);
  	cond_resched();
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
494
495
  	if (err == -EAGAIN) {
  		dbg_budg("try again");
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
496
497
  		goto again;
  	} else if (err == -ENOSPC) {
2acf80675   Artem Bityutskiy   UBIFS: simplify m...
498
499
500
501
502
  		if (!retried) {
  			retried = 1;
  			dbg_budg("-ENOSPC, but anyway try once again");
  			goto again;
  		}
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
  		dbg_budg("FS is full, -ENOSPC");
  		c->nospace = 1;
  		if (can_use_rp(c) || c->rp_size == 0)
  			c->nospace_rp = 1;
  		smp_wmb();
  	} else
  		ubifs_err("cannot budget space, error %d", err);
  	return err;
  }
  
  /**
   * ubifs_release_budget - release budgeted free space.
   * @c: UBIFS file-system description object
   * @req: budget request
   *
   * This function releases the space budgeted by 'ubifs_budget_space()'. Note,
   * since the index changes (which were budgeted for in @req->idx_growth) will
   * only be written to the media on commit, this function moves the index budget
   * from @c->budg_idx_growth to @c->budg_uncommitted_idx. The latter will be
   * zeroed by the commit operation.
   */
  void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req)
  {
547000da6   Artem Bityutskiy   UBIFS: improve bu...
526
527
528
529
530
531
  	ubifs_assert(req->new_page <= 1);
  	ubifs_assert(req->dirtied_page <= 1);
  	ubifs_assert(req->new_dent <= 1);
  	ubifs_assert(req->mod_dent <= 1);
  	ubifs_assert(req->new_ino <= 1);
  	ubifs_assert(req->new_ino_d <= UBIFS_MAX_INO_DATA);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
532
533
  	ubifs_assert(req->dirtied_ino <= 4);
  	ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4);
dab4b4d2f   Artem Bityutskiy   UBIFS: align inod...
534
535
  	ubifs_assert(!(req->new_ino_d & 7));
  	ubifs_assert(!(req->dirtied_ino_d & 7));
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
  	if (!req->recalculate) {
  		ubifs_assert(req->idx_growth >= 0);
  		ubifs_assert(req->data_growth >= 0);
  		ubifs_assert(req->dd_growth >= 0);
  	}
  
  	if (req->recalculate) {
  		req->data_growth = calc_data_growth(c, req);
  		req->dd_growth = calc_dd_growth(c, req);
  		req->idx_growth = calc_idx_growth(c, req);
  	}
  
  	if (!req->data_growth && !req->dd_growth)
  		return;
  
  	c->nospace = c->nospace_rp = 0;
  	smp_wmb();
  
  	spin_lock(&c->space_lock);
  	c->budg_idx_growth -= req->idx_growth;
  	c->budg_uncommitted_idx += req->idx_growth;
  	c->budg_data_growth -= req->data_growth;
  	c->budg_dd_growth -= req->dd_growth;
  	c->min_idx_lebs = ubifs_calc_min_idx_lebs(c);
  
  	ubifs_assert(c->budg_idx_growth >= 0);
  	ubifs_assert(c->budg_data_growth >= 0);
dab4b4d2f   Artem Bityutskiy   UBIFS: align inod...
563
  	ubifs_assert(c->budg_dd_growth >= 0);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
564
  	ubifs_assert(c->min_idx_lebs < c->main_lebs);
dab4b4d2f   Artem Bityutskiy   UBIFS: align inod...
565
566
567
  	ubifs_assert(!(c->budg_idx_growth & 7));
  	ubifs_assert(!(c->budg_data_growth & 7));
  	ubifs_assert(!(c->budg_dd_growth & 7));
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
568
569
570
571
572
573
574
575
  	spin_unlock(&c->space_lock);
  }
  
  /**
   * ubifs_convert_page_budget - convert budget of a new page.
   * @c: UBIFS file-system description object
   *
   * This function converts budget which was allocated for a new page of data to
025dfdafe   Frederik Schwarzer   trivial: fix then...
576
   * the budget of changing an existing page of data. The latter is smaller than
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
   * the former, so this function only does simple re-calculation and does not
   * involve any write-back.
   */
  void ubifs_convert_page_budget(struct ubifs_info *c)
  {
  	spin_lock(&c->space_lock);
  	/* Release the index growth reservation */
  	c->budg_idx_growth -= c->max_idx_node_sz << UBIFS_BLOCKS_PER_PAGE_SHIFT;
  	/* Release the data growth reservation */
  	c->budg_data_growth -= c->page_budget;
  	/* Increase the dirty data growth reservation instead */
  	c->budg_dd_growth += c->page_budget;
  	/* And re-calculate the indexing space reservation */
  	c->min_idx_lebs = ubifs_calc_min_idx_lebs(c);
  	spin_unlock(&c->space_lock);
  }
  
  /**
   * ubifs_release_dirty_inode_budget - release dirty inode budget.
   * @c: UBIFS file-system description object
   * @ui: UBIFS inode to release the budget for
   *
   * This function releases budget corresponding to a dirty inode. It is usually
   * called when after the inode has been written to the media and marked as
6d6cb0d68   Adrian Hunter   UBIFS: reset no_s...
601
   * clean. It also causes the "no space" flags to be cleared.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
602
603
604
605
   */
  void ubifs_release_dirty_inode_budget(struct ubifs_info *c,
  				      struct ubifs_inode *ui)
  {
182854b46   Artem Bityutskiy   UBIFS: fix budget...
606
  	struct ubifs_budget_req req;
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
607

182854b46   Artem Bityutskiy   UBIFS: fix budget...
608
  	memset(&req, 0, sizeof(struct ubifs_budget_req));
6d6cb0d68   Adrian Hunter   UBIFS: reset no_s...
609
  	/* The "no space" flags will be cleared because dd_growth is > 0 */
dab4b4d2f   Artem Bityutskiy   UBIFS: align inod...
610
  	req.dd_growth = c->inode_budget + ALIGN(ui->data_len, 8);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
611
612
613
614
  	ubifs_release_budget(c, &req);
  }
  
  /**
4b5f2762e   Artem Bityutskiy   UBIFS: improve st...
615
616
617
618
619
620
621
622
   * ubifs_reported_space - calculate reported free space.
   * @c: the UBIFS file-system description object
   * @free: amount of free space
   *
   * This function calculates amount of free space which will be reported to
   * user-space. User-space application tend to expect that if the file-system
   * (e.g., via the 'statfs()' call) reports that it has N bytes available, they
   * are able to write a file of size N. UBIFS attaches node headers to each data
80736d41f   Artem Bityutskiy   UBIFS: fix numero...
623
624
625
   * node and it has to write indexing nodes as well. This introduces additional
   * overhead, and UBIFS has to report slightly less free space to meet the above
   * expectations.
4b5f2762e   Artem Bityutskiy   UBIFS: improve st...
626
627
628
629
630
631
632
633
   *
   * This function assumes free space is made up of uncompressed data nodes and
   * full index nodes (one per data node, tripled because we always allow enough
   * space to write the index thrice).
   *
   * Note, the calculation is pessimistic, which means that most of the time
   * UBIFS reports less space than it actually has.
   */
4d61db4f8   Artem Bityutskiy   UBIFS: use nicer ...
634
  long long ubifs_reported_space(const struct ubifs_info *c, long long free)
4b5f2762e   Artem Bityutskiy   UBIFS: improve st...
635
  {
f171d4d76   Artem Bityutskiy   UBIFS: fix divisi...
636
  	int divisor, factor, f;
4b5f2762e   Artem Bityutskiy   UBIFS: improve st...
637
638
639
640
641
642
  
  	/*
  	 * Reported space size is @free * X, where X is UBIFS block size
  	 * divided by UBIFS block size + all overhead one data block
  	 * introduces. The overhead is the node header + indexing overhead.
  	 *
f171d4d76   Artem Bityutskiy   UBIFS: fix divisi...
643
644
645
646
  	 * Indexing overhead calculations are based on the following formula:
  	 * I = N/(f - 1) + 1, where I - number of indexing nodes, N - number
  	 * of data nodes, f - fanout. Because effective UBIFS fanout is twice
  	 * as less than maximum fanout, we assume that each data node
4b5f2762e   Artem Bityutskiy   UBIFS: improve st...
647
  	 * introduces 3 * @c->max_idx_node_sz / (@c->fanout/2 - 1) bytes.
80736d41f   Artem Bityutskiy   UBIFS: fix numero...
648
  	 * Note, the multiplier 3 is because UBIFS reserves thrice as more space
4b5f2762e   Artem Bityutskiy   UBIFS: improve st...
649
650
  	 * for the index.
  	 */
f171d4d76   Artem Bityutskiy   UBIFS: fix divisi...
651
  	f = c->fanout > 3 ? c->fanout >> 1 : 2;
4b5f2762e   Artem Bityutskiy   UBIFS: improve st...
652
653
  	factor = UBIFS_BLOCK_SIZE;
  	divisor = UBIFS_MAX_DATA_NODE_SZ;
f171d4d76   Artem Bityutskiy   UBIFS: fix divisi...
654
  	divisor += (c->max_idx_node_sz * 3) / (f - 1);
4b5f2762e   Artem Bityutskiy   UBIFS: improve st...
655
  	free *= factor;
4d61db4f8   Artem Bityutskiy   UBIFS: use nicer ...
656
  	return div_u64(free, divisor);
4b5f2762e   Artem Bityutskiy   UBIFS: improve st...
657
658
659
  }
  
  /**
84abf972c   Artem Bityutskiy   UBIFS: add re-mou...
660
   * ubifs_get_free_space_nolock - return amount of free space.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
661
662
   * @c: UBIFS file-system description object
   *
7dad181bb   Artem Bityutskiy   UBIFS: improve st...
663
664
665
   * This function calculates amount of free space to report to user-space.
   *
   * Because UBIFS may introduce substantial overhead (the index, node headers,
fb1cd01a3   Artem Bityutskiy   UBIFS: introduce ...
666
667
668
669
670
671
   * alignment, wastage at the end of LEBs, etc), it cannot report real amount of
   * free flash space it has (well, because not all dirty space is reclaimable,
   * UBIFS does not actually know the real amount). If UBIFS did so, it would
   * bread user expectations about what free space is. Users seem to accustomed
   * to assume that if the file-system reports N bytes of free space, they would
   * be able to fit a file of N bytes to the FS. This almost works for
7dad181bb   Artem Bityutskiy   UBIFS: improve st...
672
673
   * traditional file-systems, because they have way less overhead than UBIFS.
   * So, to keep users happy, UBIFS tries to take the overhead into account.
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
674
   */
84abf972c   Artem Bityutskiy   UBIFS: add re-mou...
675
  long long ubifs_get_free_space_nolock(struct ubifs_info *c)
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
676
  {
84abf972c   Artem Bityutskiy   UBIFS: add re-mou...
677
  	int rsvd_idx_lebs, lebs;
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
678
  	long long available, outstanding, free;
84abf972c   Artem Bityutskiy   UBIFS: add re-mou...
679
  	ubifs_assert(c->min_idx_lebs == ubifs_calc_min_idx_lebs(c));
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
680
  	outstanding = c->budg_data_growth + c->budg_dd_growth;
84abf972c   Artem Bityutskiy   UBIFS: add re-mou...
681
  	available = ubifs_calc_available(c, c->min_idx_lebs);
7dad181bb   Artem Bityutskiy   UBIFS: improve st...
682
683
684
685
686
687
688
689
690
691
692
693
  
  	/*
  	 * When reporting free space to user-space, UBIFS guarantees that it is
  	 * possible to write a file of free space size. This means that for
  	 * empty LEBs we may use more precise calculations than
  	 * 'ubifs_calc_available()' is using. Namely, we know that in empty
  	 * LEBs we would waste only @c->leb_overhead bytes, not @c->dark_wm.
  	 * Thus, amend the available space.
  	 *
  	 * Note, the calculations below are similar to what we have in
  	 * 'do_budget_space()', so refer there for comments.
  	 */
84abf972c   Artem Bityutskiy   UBIFS: add re-mou...
694
695
  	if (c->min_idx_lebs > c->lst.idx_lebs)
  		rsvd_idx_lebs = c->min_idx_lebs - c->lst.idx_lebs;
7dad181bb   Artem Bityutskiy   UBIFS: improve st...
696
697
698
699
700
701
  	else
  		rsvd_idx_lebs = 0;
  	lebs = c->lst.empty_lebs + c->freeable_cnt + c->idx_gc_cnt -
  	       c->lst.taken_empty_lebs;
  	lebs -= rsvd_idx_lebs;
  	available += lebs * (c->dark_wm - c->leb_overhead);
1e51764a3   Artem Bityutskiy   UBIFS: add new fl...
702
703
704
705
706
707
708
  
  	if (available > outstanding)
  		free = ubifs_reported_space(c, available - outstanding);
  	else
  		free = 0;
  	return free;
  }
84abf972c   Artem Bityutskiy   UBIFS: add re-mou...
709
710
711
712
713
  
  /**
   * ubifs_get_free_space - return amount of free space.
   * @c: UBIFS file-system description object
   *
055da1b70   Artem Bityutskiy   UBIFS: various mi...
714
   * This function calculates and returns amount of free space to report to
84abf972c   Artem Bityutskiy   UBIFS: add re-mou...
715
716
717
718
719
720
721
722
723
724
725
726
   * user-space.
   */
  long long ubifs_get_free_space(struct ubifs_info *c)
  {
  	long long free;
  
  	spin_lock(&c->space_lock);
  	free = ubifs_get_free_space_nolock(c);
  	spin_unlock(&c->space_lock);
  
  	return free;
  }