Blame view
fs/ubifs/budget.c
23.8 KB
1e51764a3 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 UBIFS: use nicer ... |
35 |
#include <linux/math64.h> |
1e51764a3 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 UBIFS: simplify m... |
40 |
* or committing. The below constant defines maximum number of times UBIFS |
1e51764a3 UBIFS: add new fl... |
41 42 |
* repeats the operations. */ |
2acf80675 UBIFS: simplify m... |
43 |
#define MAX_MKSPC_RETRIES 3 |
1e51764a3 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 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 writeback: separa... |
57 |
* of dirty inodes and their pages. |
1e51764a3 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 writeback: separa... |
63 |
static void shrink_liability(struct ubifs_info *c, int nr_to_write) |
1e51764a3 UBIFS: add new fl... |
64 |
{ |
cf37e9724 writeback: enforc... |
65 |
down_read(&c->vfs_sb->s_umount); |
0e175a183 writeback: Add a ... |
66 |
writeback_inodes_sb(c->vfs_sb, WB_REASON_FS_FREE_SPACE); |
cf37e9724 writeback: enforc... |
67 |
up_read(&c->vfs_sb->s_umount); |
1e51764a3 UBIFS: add new fl... |
68 |
} |
1e51764a3 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 UBIFS: simplify m... |
97 98 99 100 101 102 103 104 105 106 107 |
* 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); |
b137545c4 UBIFS: introduce ... |
108 |
liab = c->bi.idx_growth + c->bi.data_growth + c->bi.dd_growth; |
2acf80675 UBIFS: simplify m... |
109 110 111 112 113 |
spin_unlock(&c->space_lock); return liab; } /** |
1e51764a3 UBIFS: add new fl... |
114 115 |
* make_free_space - make more free space on the file-system. * @c: UBIFS file-system description object |
1e51764a3 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 trivial: fix then... |
119 |
* o budgeting is pessimistic, so it always budgets more than it is actually |
1e51764a3 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 UBIFS: simplify m... |
131 |
static int make_free_space(struct ubifs_info *c) |
1e51764a3 UBIFS: add new fl... |
132 |
{ |
2acf80675 UBIFS: simplify m... |
133 134 |
int err, retries = 0; long long liab1, liab2; |
1e51764a3 UBIFS: add new fl... |
135 |
|
2acf80675 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 UBIFS: add new fl... |
144 |
|
2acf80675 UBIFS: simplify m... |
145 146 147 |
liab2 = get_liability(c); if (liab2 < liab1) return -EAGAIN; |
1e51764a3 UBIFS: add new fl... |
148 |
|
25985edce Fix common misspe... |
149 |
dbg_budg("new liability %lld (not shrunk)", liab2); |
1e51764a3 UBIFS: add new fl... |
150 |
|
2acf80675 UBIFS: simplify m... |
151 152 |
/* Liability did not shrink again, try GC */ dbg_budg("Run GC"); |
1e51764a3 UBIFS: add new fl... |
153 154 155 |
err = run_gc(c); if (!err) return -EAGAIN; |
2acf80675 UBIFS: simplify m... |
156 157 |
if (err != -EAGAIN && err != -ENOSPC) /* Some real error happened */ |
1e51764a3 UBIFS: add new fl... |
158 |
return err; |
1e51764a3 UBIFS: add new fl... |
159 |
|
2acf80675 UBIFS: simplify m... |
160 |
dbg_budg("Run commit (retries %d)", retries); |
1e51764a3 UBIFS: add new fl... |
161 162 163 |
err = ubifs_run_commit(c); if (err) return err; |
2acf80675 UBIFS: simplify m... |
164 |
} while (retries++ < MAX_MKSPC_RETRIES); |
1e51764a3 UBIFS: add new fl... |
165 166 167 168 |
return -ENOSPC; } /** |
fb1cd01a3 UBIFS: introduce ... |
169 |
* ubifs_calc_min_idx_lebs - calculate amount of LEBs for the index. |
1e51764a3 UBIFS: add new fl... |
170 171 |
* @c: UBIFS file-system description object * |
fb1cd01a3 UBIFS: introduce ... |
172 173 |
* This function calculates and returns the number of LEBs which should be kept * for index usage. |
1e51764a3 UBIFS: add new fl... |
174 175 176 |
*/ int ubifs_calc_min_idx_lebs(struct ubifs_info *c) { |
fb1cd01a3 UBIFS: introduce ... |
177 |
int idx_lebs; |
4d61db4f8 UBIFS: use nicer ... |
178 |
long long idx_size; |
1e51764a3 UBIFS: add new fl... |
179 |
|
b137545c4 UBIFS: introduce ... |
180 |
idx_size = c->bi.old_idx_sz + c->bi.idx_growth + c->bi.uncommitted_idx; |
3a13252c6 UBIFS: correct sp... |
181 |
/* And make sure we have thrice the index size of space reserved */ |
fb1cd01a3 UBIFS: introduce ... |
182 |
idx_size += idx_size << 1; |
1e51764a3 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 UBIFS: introduce ... |
188 |
idx_lebs = div_u64(idx_size + c->idx_leb_size - 1, c->idx_leb_size); |
1e51764a3 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 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 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 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 CRED: Wrap task c... |
271 |
if (current_fsuid() == c->rp_uid || capable(CAP_SYS_RESOURCE) || |
1e51764a3 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 UBIFS: introduce ... |
281 282 |
* This function makes sure UBIFS has enough free LEBs for index growth and * data. |
1e51764a3 UBIFS: add new fl... |
283 |
* |
3a13252c6 UBIFS: correct sp... |
284 |
* When budgeting index space, UBIFS reserves thrice as many LEBs as the index |
1e51764a3 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 UBIFS: reserve mo... |
288 |
* budgeted index space to the size of the current index, multiplies this by 3, |
fb1cd01a3 UBIFS: introduce ... |
289 |
* and makes sure this does not exceed the amount of free LEBs. |
1e51764a3 UBIFS: add new fl... |
290 |
* |
b137545c4 UBIFS: introduce ... |
291 |
* Notes about @c->bi.min_idx_lebs and @c->lst.idx_lebs variables: |
1e51764a3 UBIFS: add new fl... |
292 293 294 295 |
* 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. |
b137545c4 UBIFS: introduce ... |
296 297 |
* o @c->bi.min_idx_lebs is the number of LEBS the index presumably takes. IOW, * the index may be consolidated to take up to @c->bi.min_idx_lebs LEBs. |
1e51764a3 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 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 UBIFS: add new fl... |
329 |
* |
948cfb219 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 UBIFS: add new fl... |
337 338 339 340 341 |
*/ 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), " |
b137545c4 UBIFS: introduce ... |
342 |
"rsvd_idx_lebs %d", min_idx_lebs, c->bi.min_idx_lebs, |
1e51764a3 UBIFS: add new fl... |
343 344 345 346 347 |
rsvd_idx_lebs); return -ENOSPC; } available = ubifs_calc_available(c, min_idx_lebs); |
b137545c4 UBIFS: introduce ... |
348 |
outstanding = c->bi.data_growth + c->bi.dd_growth; |
1e51764a3 UBIFS: add new fl... |
349 350 351 352 353 354 355 356 357 |
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; |
b137545c4 UBIFS: introduce ... |
358 |
c->bi.min_idx_lebs = min_idx_lebs; |
1e51764a3 UBIFS: add new fl... |
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 |
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; |
b137545c4 UBIFS: introduce ... |
390 |
data_growth = req->new_ino ? c->bi.inode_budget : 0; |
1e51764a3 UBIFS: add new fl... |
391 |
if (req->new_page) |
b137545c4 UBIFS: introduce ... |
392 |
data_growth += c->bi.page_budget; |
1e51764a3 UBIFS: add new fl... |
393 |
if (req->new_dent) |
b137545c4 UBIFS: introduce ... |
394 |
data_growth += c->bi.dent_budget; |
1e51764a3 UBIFS: add new fl... |
395 396 397 398 399 400 401 402 403 404 405 406 407 408 |
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; |
b137545c4 UBIFS: introduce ... |
409 |
dd_growth = req->dirtied_page ? c->bi.page_budget : 0; |
1e51764a3 UBIFS: add new fl... |
410 411 |
if (req->dirtied_ino) |
b137545c4 UBIFS: introduce ... |
412 |
dd_growth += c->bi.inode_budget << (req->dirtied_ino - 1); |
1e51764a3 UBIFS: add new fl... |
413 |
if (req->mod_dent) |
b137545c4 UBIFS: introduce ... |
414 |
dd_growth += c->bi.dent_budget; |
1e51764a3 UBIFS: add new fl... |
415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 |
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 UBIFS: simplify m... |
435 |
int err, idx_growth, data_growth, dd_growth, retried = 0; |
1e51764a3 UBIFS: add new fl... |
436 |
|
547000da6 UBIFS: improve bu... |
437 438 439 440 441 442 |
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 UBIFS: add new fl... |
443 444 |
ubifs_assert(req->dirtied_ino <= 4); ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4); |
dab4b4d2f UBIFS: align inod... |
445 446 |
ubifs_assert(!(req->new_ino_d & 7)); ubifs_assert(!(req->dirtied_ino_d & 7)); |
1e51764a3 UBIFS: add new fl... |
447 448 449 450 451 452 |
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 UBIFS: add new fl... |
453 454 455 |
again: spin_lock(&c->space_lock); |
b137545c4 UBIFS: introduce ... |
456 457 458 |
ubifs_assert(c->bi.idx_growth >= 0); ubifs_assert(c->bi.data_growth >= 0); ubifs_assert(c->bi.dd_growth >= 0); |
1e51764a3 UBIFS: add new fl... |
459 |
|
b137545c4 UBIFS: introduce ... |
460 |
if (unlikely(c->bi.nospace) && (c->bi.nospace_rp || !can_use_rp(c))) { |
1e51764a3 UBIFS: add new fl... |
461 462 463 464 |
dbg_budg("no space"); spin_unlock(&c->space_lock); return -ENOSPC; } |
b137545c4 UBIFS: introduce ... |
465 466 467 |
c->bi.idx_growth += idx_growth; c->bi.data_growth += data_growth; c->bi.dd_growth += dd_growth; |
1e51764a3 UBIFS: add new fl... |
468 469 470 471 472 473 474 475 476 477 478 |
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 */ |
b137545c4 UBIFS: introduce ... |
479 480 481 |
c->bi.idx_growth -= idx_growth; c->bi.data_growth -= data_growth; c->bi.dd_growth -= dd_growth; |
1e51764a3 UBIFS: add new fl... |
482 483 484 485 486 487 |
spin_unlock(&c->space_lock); if (req->fast) { dbg_budg("no space for fast budgeting"); return err; } |
2acf80675 UBIFS: simplify m... |
488 489 |
err = make_free_space(c); cond_resched(); |
1e51764a3 UBIFS: add new fl... |
490 491 |
if (err == -EAGAIN) { dbg_budg("try again"); |
1e51764a3 UBIFS: add new fl... |
492 493 |
goto again; } else if (err == -ENOSPC) { |
2acf80675 UBIFS: simplify m... |
494 495 496 497 498 |
if (!retried) { retried = 1; dbg_budg("-ENOSPC, but anyway try once again"); goto again; } |
1e51764a3 UBIFS: add new fl... |
499 |
dbg_budg("FS is full, -ENOSPC"); |
b137545c4 UBIFS: introduce ... |
500 |
c->bi.nospace = 1; |
1e51764a3 UBIFS: add new fl... |
501 |
if (can_use_rp(c) || c->rp_size == 0) |
b137545c4 UBIFS: introduce ... |
502 |
c->bi.nospace_rp = 1; |
1e51764a3 UBIFS: add new fl... |
503 504 505 506 507 508 509 510 511 512 513 514 515 516 |
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 |
b137545c4 UBIFS: introduce ... |
517 518 |
* from @c->bi.idx_growth to @c->bi.uncommitted_idx. The latter will be zeroed * by the commit operation. |
1e51764a3 UBIFS: add new fl... |
519 520 521 |
*/ void ubifs_release_budget(struct ubifs_info *c, struct ubifs_budget_req *req) { |
547000da6 UBIFS: improve bu... |
522 523 524 525 526 527 |
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 UBIFS: add new fl... |
528 529 |
ubifs_assert(req->dirtied_ino <= 4); ubifs_assert(req->dirtied_ino_d <= UBIFS_MAX_INO_DATA * 4); |
dab4b4d2f UBIFS: align inod... |
530 531 |
ubifs_assert(!(req->new_ino_d & 7)); ubifs_assert(!(req->dirtied_ino_d & 7)); |
1e51764a3 UBIFS: add new fl... |
532 533 534 535 536 537 538 539 540 541 542 543 544 545 |
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; |
b137545c4 UBIFS: introduce ... |
546 |
c->bi.nospace = c->bi.nospace_rp = 0; |
1e51764a3 UBIFS: add new fl... |
547 548 549 |
smp_wmb(); spin_lock(&c->space_lock); |
b137545c4 UBIFS: introduce ... |
550 551 552 553 554 555 556 557 558 559 560 561 562 |
c->bi.idx_growth -= req->idx_growth; c->bi.uncommitted_idx += req->idx_growth; c->bi.data_growth -= req->data_growth; c->bi.dd_growth -= req->dd_growth; c->bi.min_idx_lebs = ubifs_calc_min_idx_lebs(c); ubifs_assert(c->bi.idx_growth >= 0); ubifs_assert(c->bi.data_growth >= 0); ubifs_assert(c->bi.dd_growth >= 0); ubifs_assert(c->bi.min_idx_lebs < c->main_lebs); ubifs_assert(!(c->bi.idx_growth & 7)); ubifs_assert(!(c->bi.data_growth & 7)); ubifs_assert(!(c->bi.dd_growth & 7)); |
1e51764a3 UBIFS: add new fl... |
563 564 565 566 567 568 569 570 |
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 trivial: fix then... |
571 |
* the budget of changing an existing page of data. The latter is smaller than |
1e51764a3 UBIFS: add new fl... |
572 573 574 575 576 577 578 |
* 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 */ |
b137545c4 UBIFS: introduce ... |
579 |
c->bi.idx_growth -= c->max_idx_node_sz << UBIFS_BLOCKS_PER_PAGE_SHIFT; |
1e51764a3 UBIFS: add new fl... |
580 |
/* Release the data growth reservation */ |
b137545c4 UBIFS: introduce ... |
581 |
c->bi.data_growth -= c->bi.page_budget; |
1e51764a3 UBIFS: add new fl... |
582 |
/* Increase the dirty data growth reservation instead */ |
b137545c4 UBIFS: introduce ... |
583 |
c->bi.dd_growth += c->bi.page_budget; |
1e51764a3 UBIFS: add new fl... |
584 |
/* And re-calculate the indexing space reservation */ |
b137545c4 UBIFS: introduce ... |
585 |
c->bi.min_idx_lebs = ubifs_calc_min_idx_lebs(c); |
1e51764a3 UBIFS: add new fl... |
586 587 588 589 590 591 592 593 594 595 |
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 UBIFS: reset no_s... |
596 |
* clean. It also causes the "no space" flags to be cleared. |
1e51764a3 UBIFS: add new fl... |
597 598 599 600 |
*/ void ubifs_release_dirty_inode_budget(struct ubifs_info *c, struct ubifs_inode *ui) { |
182854b46 UBIFS: fix budget... |
601 |
struct ubifs_budget_req req; |
1e51764a3 UBIFS: add new fl... |
602 |
|
182854b46 UBIFS: fix budget... |
603 |
memset(&req, 0, sizeof(struct ubifs_budget_req)); |
6d6cb0d68 UBIFS: reset no_s... |
604 |
/* The "no space" flags will be cleared because dd_growth is > 0 */ |
b137545c4 UBIFS: introduce ... |
605 |
req.dd_growth = c->bi.inode_budget + ALIGN(ui->data_len, 8); |
1e51764a3 UBIFS: add new fl... |
606 607 608 609 |
ubifs_release_budget(c, &req); } /** |
4b5f2762e UBIFS: improve st... |
610 611 612 613 614 615 616 617 |
* 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 UBIFS: fix numero... |
618 619 620 |
* 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 UBIFS: improve st... |
621 622 623 624 625 626 627 628 |
* * 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 UBIFS: use nicer ... |
629 |
long long ubifs_reported_space(const struct ubifs_info *c, long long free) |
4b5f2762e UBIFS: improve st... |
630 |
{ |
f171d4d76 UBIFS: fix divisi... |
631 |
int divisor, factor, f; |
4b5f2762e UBIFS: improve st... |
632 633 634 635 636 637 |
/* * 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 UBIFS: fix divisi... |
638 639 640 641 |
* 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 UBIFS: improve st... |
642 |
* introduces 3 * @c->max_idx_node_sz / (@c->fanout/2 - 1) bytes. |
80736d41f UBIFS: fix numero... |
643 |
* Note, the multiplier 3 is because UBIFS reserves thrice as more space |
4b5f2762e UBIFS: improve st... |
644 645 |
* for the index. */ |
f171d4d76 UBIFS: fix divisi... |
646 |
f = c->fanout > 3 ? c->fanout >> 1 : 2; |
4b5f2762e UBIFS: improve st... |
647 648 |
factor = UBIFS_BLOCK_SIZE; divisor = UBIFS_MAX_DATA_NODE_SZ; |
f171d4d76 UBIFS: fix divisi... |
649 |
divisor += (c->max_idx_node_sz * 3) / (f - 1); |
4b5f2762e UBIFS: improve st... |
650 |
free *= factor; |
4d61db4f8 UBIFS: use nicer ... |
651 |
return div_u64(free, divisor); |
4b5f2762e UBIFS: improve st... |
652 653 654 |
} /** |
84abf972c UBIFS: add re-mou... |
655 |
* ubifs_get_free_space_nolock - return amount of free space. |
1e51764a3 UBIFS: add new fl... |
656 657 |
* @c: UBIFS file-system description object * |
7dad181bb UBIFS: improve st... |
658 659 660 |
* This function calculates amount of free space to report to user-space. * * Because UBIFS may introduce substantial overhead (the index, node headers, |
fb1cd01a3 UBIFS: introduce ... |
661 662 663 664 665 666 |
* 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 UBIFS: improve st... |
667 668 |
* 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 UBIFS: add new fl... |
669 |
*/ |
84abf972c UBIFS: add re-mou... |
670 |
long long ubifs_get_free_space_nolock(struct ubifs_info *c) |
1e51764a3 UBIFS: add new fl... |
671 |
{ |
84abf972c UBIFS: add re-mou... |
672 |
int rsvd_idx_lebs, lebs; |
1e51764a3 UBIFS: add new fl... |
673 |
long long available, outstanding, free; |
b137545c4 UBIFS: introduce ... |
674 675 676 |
ubifs_assert(c->bi.min_idx_lebs == ubifs_calc_min_idx_lebs(c)); outstanding = c->bi.data_growth + c->bi.dd_growth; available = ubifs_calc_available(c, c->bi.min_idx_lebs); |
7dad181bb UBIFS: improve st... |
677 678 679 680 681 682 683 684 685 686 687 688 |
/* * 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. */ |
b137545c4 UBIFS: introduce ... |
689 690 |
if (c->bi.min_idx_lebs > c->lst.idx_lebs) rsvd_idx_lebs = c->bi.min_idx_lebs - c->lst.idx_lebs; |
7dad181bb UBIFS: improve st... |
691 692 693 694 695 696 |
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 UBIFS: add new fl... |
697 698 699 700 701 702 703 |
if (available > outstanding) free = ubifs_reported_space(c, available - outstanding); else free = 0; return free; } |
84abf972c UBIFS: add re-mou... |
704 705 706 707 708 |
/** * ubifs_get_free_space - return amount of free space. * @c: UBIFS file-system description object * |
055da1b70 UBIFS: various mi... |
709 |
* This function calculates and returns amount of free space to report to |
84abf972c UBIFS: add re-mou... |
710 711 712 713 714 715 716 717 718 719 720 721 |
* 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; } |