1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * This file is part of UBIFS. 4 * 5 * Copyright (C) 2006-2008 Nokia Corporation. 6 * 7 * Authors: Artem Bityutskiy (Битюцкий Артём) 8 * Adrian Hunter 9 */ 10 11 /* 12 * This file implements VFS file and inode operations for regular files, device 13 * nodes and symlinks as well as address space operations. 14 * 15 * UBIFS uses 2 page flags: @PG_private and @PG_checked. @PG_private is set if 16 * the page is dirty and is used for optimization purposes - dirty pages are 17 * not budgeted so the flag shows that 'ubifs_write_end()' should not release 18 * the budget for this page. The @PG_checked flag is set if full budgeting is 19 * required for the page e.g., when it corresponds to a file hole or it is 20 * beyond the file size. The budgeting is done in 'ubifs_write_begin()', because 21 * it is OK to fail in this function, and the budget is released in 22 * 'ubifs_write_end()'. So the @PG_private and @PG_checked flags carry 23 * information about how the page was budgeted, to make it possible to release 24 * the budget properly. 25 * 26 * A thing to keep in mind: inode @i_mutex is locked in most VFS operations we 27 * implement. However, this is not true for 'ubifs_writepage()', which may be 28 * called with @i_mutex unlocked. For example, when flusher thread is doing 29 * background write-back, it calls 'ubifs_writepage()' with unlocked @i_mutex. 30 * At "normal" work-paths the @i_mutex is locked in 'ubifs_writepage()', e.g. 31 * in the "sys_write -> alloc_pages -> direct reclaim path". So, in 32 * 'ubifs_writepage()' we are only guaranteed that the page is locked. 33 * 34 * Similarly, @i_mutex is not always locked in 'ubifs_readpage()', e.g., the 35 * read-ahead path does not lock it ("sys_read -> generic_file_aio_read -> 36 * ondemand_readahead -> readpage"). In case of readahead, @I_SYNC flag is not 37 * set as well. However, UBIFS disables readahead. 38 */ 39 40 #include "ubifs.h" 41 #include <linux/mount.h> 42 #include <linux/slab.h> 43 #include <linux/migrate.h> 44 45 static int read_block(struct inode *inode, void *addr, unsigned int block, 46 struct ubifs_data_node *dn) 47 { 48 struct ubifs_info *c = inode->i_sb->s_fs_info; 49 int err, len, out_len; 50 union ubifs_key key; 51 unsigned int dlen; 52 53 data_key_init(c, &key, inode->i_ino, block); 54 err = ubifs_tnc_lookup(c, &key, dn); 55 if (err) { 56 if (err == -ENOENT) 57 /* Not found, so it must be a hole */ 58 memset(addr, 0, UBIFS_BLOCK_SIZE); 59 return err; 60 } 61 62 ubifs_assert(c, le64_to_cpu(dn->ch.sqnum) > 63 ubifs_inode(inode)->creat_sqnum); 64 len = le32_to_cpu(dn->size); 65 if (len <= 0 || len > UBIFS_BLOCK_SIZE) 66 goto dump; 67 68 dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ; 69 70 if (IS_ENCRYPTED(inode)) { 71 err = ubifs_decrypt(inode, dn, &dlen, block); 72 if (err) 73 goto dump; 74 } 75 76 out_len = UBIFS_BLOCK_SIZE; 77 err = ubifs_decompress(c, &dn->data, dlen, addr, &out_len, 78 le16_to_cpu(dn->compr_type)); 79 if (err || len != out_len) 80 goto dump; 81 82 /* 83 * Data length can be less than a full block, even for blocks that are 84 * not the last in the file (e.g., as a result of making a hole and 85 * appending data). Ensure that the remainder is zeroed out. 86 */ 87 if (len < UBIFS_BLOCK_SIZE) 88 memset(addr + len, 0, UBIFS_BLOCK_SIZE - len); 89 90 return 0; 91 92 dump: 93 ubifs_err(c, "bad data node (block %u, inode %lu)", 94 block, inode->i_ino); 95 ubifs_dump_node(c, dn, UBIFS_MAX_DATA_NODE_SZ); 96 return -EINVAL; 97 } 98 99 static int do_readpage(struct page *page) 100 { 101 void *addr; 102 int err = 0, i; 103 unsigned int block, beyond; 104 struct ubifs_data_node *dn; 105 struct inode *inode = page->mapping->host; 106 struct ubifs_info *c = inode->i_sb->s_fs_info; 107 loff_t i_size = i_size_read(inode); 108 109 dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx", 110 inode->i_ino, page->index, i_size, page->flags); 111 ubifs_assert(c, !PageChecked(page)); 112 ubifs_assert(c, !PagePrivate(page)); 113 114 addr = kmap(page); 115 116 block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT; 117 beyond = (i_size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT; 118 if (block >= beyond) { 119 /* Reading beyond inode */ 120 SetPageChecked(page); 121 memset(addr, 0, PAGE_SIZE); 122 goto out; 123 } 124 125 dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS); 126 if (!dn) { 127 err = -ENOMEM; 128 goto error; 129 } 130 131 i = 0; 132 while (1) { 133 int ret; 134 135 if (block >= beyond) { 136 /* Reading beyond inode */ 137 err = -ENOENT; 138 memset(addr, 0, UBIFS_BLOCK_SIZE); 139 } else { 140 ret = read_block(inode, addr, block, dn); 141 if (ret) { 142 err = ret; 143 if (err != -ENOENT) 144 break; 145 } else if (block + 1 == beyond) { 146 int dlen = le32_to_cpu(dn->size); 147 int ilen = i_size & (UBIFS_BLOCK_SIZE - 1); 148 149 if (ilen && ilen < dlen) 150 memset(addr + ilen, 0, dlen - ilen); 151 } 152 } 153 if (++i >= UBIFS_BLOCKS_PER_PAGE) 154 break; 155 block += 1; 156 addr += UBIFS_BLOCK_SIZE; 157 } 158 if (err) { 159 struct ubifs_info *c = inode->i_sb->s_fs_info; 160 if (err == -ENOENT) { 161 /* Not found, so it must be a hole */ 162 SetPageChecked(page); 163 dbg_gen("hole"); 164 goto out_free; 165 } 166 ubifs_err(c, "cannot read page %lu of inode %lu, error %d", 167 page->index, inode->i_ino, err); 168 goto error; 169 } 170 171 out_free: 172 kfree(dn); 173 out: 174 SetPageUptodate(page); 175 ClearPageError(page); 176 flush_dcache_page(page); 177 kunmap(page); 178 return 0; 179 180 error: 181 kfree(dn); 182 ClearPageUptodate(page); 183 SetPageError(page); 184 flush_dcache_page(page); 185 kunmap(page); 186 return err; 187 } 188 189 /** 190 * release_new_page_budget - release budget of a new page. 191 * @c: UBIFS file-system description object 192 * 193 * This is a helper function which releases budget corresponding to the budget 194 * of one new page of data. 195 */ 196 static void release_new_page_budget(struct ubifs_info *c) 197 { 198 struct ubifs_budget_req req = { .recalculate = 1, .new_page = 1 }; 199 200 ubifs_release_budget(c, &req); 201 } 202 203 /** 204 * release_existing_page_budget - release budget of an existing page. 205 * @c: UBIFS file-system description object 206 * 207 * This is a helper function which releases budget corresponding to the budget 208 * of changing one page of data which already exists on the flash media. 209 */ 210 static void release_existing_page_budget(struct ubifs_info *c) 211 { 212 struct ubifs_budget_req req = { .dd_growth = c->bi.page_budget}; 213 214 ubifs_release_budget(c, &req); 215 } 216 217 static int write_begin_slow(struct address_space *mapping, 218 loff_t pos, unsigned len, struct page **pagep, 219 unsigned flags) 220 { 221 struct inode *inode = mapping->host; 222 struct ubifs_info *c = inode->i_sb->s_fs_info; 223 pgoff_t index = pos >> PAGE_SHIFT; 224 struct ubifs_budget_req req = { .new_page = 1 }; 225 int err, appending = !!(pos + len > inode->i_size); 226 struct page *page; 227 228 dbg_gen("ino %lu, pos %llu, len %u, i_size %lld", 229 inode->i_ino, pos, len, inode->i_size); 230 231 /* 232 * At the slow path we have to budget before locking the page, because 233 * budgeting may force write-back, which would wait on locked pages and 234 * deadlock if we had the page locked. At this point we do not know 235 * anything about the page, so assume that this is a new page which is 236 * written to a hole. This corresponds to largest budget. Later the 237 * budget will be amended if this is not true. 238 */ 239 if (appending) 240 /* We are appending data, budget for inode change */ 241 req.dirtied_ino = 1; 242 243 err = ubifs_budget_space(c, &req); 244 if (unlikely(err)) 245 return err; 246 247 page = grab_cache_page_write_begin(mapping, index, flags); 248 if (unlikely(!page)) { 249 ubifs_release_budget(c, &req); 250 return -ENOMEM; 251 } 252 253 if (!PageUptodate(page)) { 254 if (!(pos & ~PAGE_MASK) && len == PAGE_SIZE) 255 SetPageChecked(page); 256 else { 257 err = do_readpage(page); 258 if (err) { 259 unlock_page(page); 260 put_page(page); 261 ubifs_release_budget(c, &req); 262 return err; 263 } 264 } 265 266 SetPageUptodate(page); 267 ClearPageError(page); 268 } 269 270 if (PagePrivate(page)) 271 /* 272 * The page is dirty, which means it was budgeted twice: 273 * o first time the budget was allocated by the task which 274 * made the page dirty and set the PG_private flag; 275 * o and then we budgeted for it for the second time at the 276 * very beginning of this function. 277 * 278 * So what we have to do is to release the page budget we 279 * allocated. 280 */ 281 release_new_page_budget(c); 282 else if (!PageChecked(page)) 283 /* 284 * We are changing a page which already exists on the media. 285 * This means that changing the page does not make the amount 286 * of indexing information larger, and this part of the budget 287 * which we have already acquired may be released. 288 */ 289 ubifs_convert_page_budget(c); 290 291 if (appending) { 292 struct ubifs_inode *ui = ubifs_inode(inode); 293 294 /* 295 * 'ubifs_write_end()' is optimized from the fast-path part of 296 * 'ubifs_write_begin()' and expects the @ui_mutex to be locked 297 * if data is appended. 298 */ 299 mutex_lock(&ui->ui_mutex); 300 if (ui->dirty) 301 /* 302 * The inode is dirty already, so we may free the 303 * budget we allocated. 304 */ 305 ubifs_release_dirty_inode_budget(c, ui); 306 } 307 308 *pagep = page; 309 return 0; 310 } 311 312 /** 313 * allocate_budget - allocate budget for 'ubifs_write_begin()'. 314 * @c: UBIFS file-system description object 315 * @page: page to allocate budget for 316 * @ui: UBIFS inode object the page belongs to 317 * @appending: non-zero if the page is appended 318 * 319 * This is a helper function for 'ubifs_write_begin()' which allocates budget 320 * for the operation. The budget is allocated differently depending on whether 321 * this is appending, whether the page is dirty or not, and so on. This 322 * function leaves the @ui->ui_mutex locked in case of appending. Returns zero 323 * in case of success and %-ENOSPC in case of failure. 324 */ 325 static int allocate_budget(struct ubifs_info *c, struct page *page, 326 struct ubifs_inode *ui, int appending) 327 { 328 struct ubifs_budget_req req = { .fast = 1 }; 329 330 if (PagePrivate(page)) { 331 if (!appending) 332 /* 333 * The page is dirty and we are not appending, which 334 * means no budget is needed at all. 335 */ 336 return 0; 337 338 mutex_lock(&ui->ui_mutex); 339 if (ui->dirty) 340 /* 341 * The page is dirty and we are appending, so the inode 342 * has to be marked as dirty. However, it is already 343 * dirty, so we do not need any budget. We may return, 344 * but @ui->ui_mutex hast to be left locked because we 345 * should prevent write-back from flushing the inode 346 * and freeing the budget. The lock will be released in 347 * 'ubifs_write_end()'. 348 */ 349 return 0; 350 351 /* 352 * The page is dirty, we are appending, the inode is clean, so 353 * we need to budget the inode change. 354 */ 355 req.dirtied_ino = 1; 356 } else { 357 if (PageChecked(page)) 358 /* 359 * The page corresponds to a hole and does not 360 * exist on the media. So changing it makes 361 * make the amount of indexing information 362 * larger, and we have to budget for a new 363 * page. 364 */ 365 req.new_page = 1; 366 else 367 /* 368 * Not a hole, the change will not add any new 369 * indexing information, budget for page 370 * change. 371 */ 372 req.dirtied_page = 1; 373 374 if (appending) { 375 mutex_lock(&ui->ui_mutex); 376 if (!ui->dirty) 377 /* 378 * The inode is clean but we will have to mark 379 * it as dirty because we are appending. This 380 * needs a budget. 381 */ 382 req.dirtied_ino = 1; 383 } 384 } 385 386 return ubifs_budget_space(c, &req); 387 } 388 389 /* 390 * This function is called when a page of data is going to be written. Since 391 * the page of data will not necessarily go to the flash straight away, UBIFS 392 * has to reserve space on the media for it, which is done by means of 393 * budgeting. 394 * 395 * This is the hot-path of the file-system and we are trying to optimize it as 396 * much as possible. For this reasons it is split on 2 parts - slow and fast. 397 * 398 * There many budgeting cases: 399 * o a new page is appended - we have to budget for a new page and for 400 * changing the inode; however, if the inode is already dirty, there is 401 * no need to budget for it; 402 * o an existing clean page is changed - we have budget for it; if the page 403 * does not exist on the media (a hole), we have to budget for a new 404 * page; otherwise, we may budget for changing an existing page; the 405 * difference between these cases is that changing an existing page does 406 * not introduce anything new to the FS indexing information, so it does 407 * not grow, and smaller budget is acquired in this case; 408 * o an existing dirty page is changed - no need to budget at all, because 409 * the page budget has been acquired by earlier, when the page has been 410 * marked dirty. 411 * 412 * UBIFS budgeting sub-system may force write-back if it thinks there is no 413 * space to reserve. This imposes some locking restrictions and makes it 414 * impossible to take into account the above cases, and makes it impossible to 415 * optimize budgeting. 416 * 417 * The solution for this is that the fast path of 'ubifs_write_begin()' assumes 418 * there is a plenty of flash space and the budget will be acquired quickly, 419 * without forcing write-back. The slow path does not make this assumption. 420 */ 421 static int ubifs_write_begin(struct file *file, struct address_space *mapping, 422 loff_t pos, unsigned len, unsigned flags, 423 struct page **pagep, void **fsdata) 424 { 425 struct inode *inode = mapping->host; 426 struct ubifs_info *c = inode->i_sb->s_fs_info; 427 struct ubifs_inode *ui = ubifs_inode(inode); 428 pgoff_t index = pos >> PAGE_SHIFT; 429 int err, appending = !!(pos + len > inode->i_size); 430 int skipped_read = 0; 431 struct page *page; 432 433 ubifs_assert(c, ubifs_inode(inode)->ui_size == inode->i_size); 434 ubifs_assert(c, !c->ro_media && !c->ro_mount); 435 436 if (unlikely(c->ro_error)) 437 return -EROFS; 438 439 /* Try out the fast-path part first */ 440 page = grab_cache_page_write_begin(mapping, index, flags); 441 if (unlikely(!page)) 442 return -ENOMEM; 443 444 if (!PageUptodate(page)) { 445 /* The page is not loaded from the flash */ 446 if (!(pos & ~PAGE_MASK) && len == PAGE_SIZE) { 447 /* 448 * We change whole page so no need to load it. But we 449 * do not know whether this page exists on the media or 450 * not, so we assume the latter because it requires 451 * larger budget. The assumption is that it is better 452 * to budget a bit more than to read the page from the 453 * media. Thus, we are setting the @PG_checked flag 454 * here. 455 */ 456 SetPageChecked(page); 457 skipped_read = 1; 458 } else { 459 err = do_readpage(page); 460 if (err) { 461 unlock_page(page); 462 put_page(page); 463 return err; 464 } 465 } 466 467 SetPageUptodate(page); 468 ClearPageError(page); 469 } 470 471 err = allocate_budget(c, page, ui, appending); 472 if (unlikely(err)) { 473 ubifs_assert(c, err == -ENOSPC); 474 /* 475 * If we skipped reading the page because we were going to 476 * write all of it, then it is not up to date. 477 */ 478 if (skipped_read) { 479 ClearPageChecked(page); 480 ClearPageUptodate(page); 481 } 482 /* 483 * Budgeting failed which means it would have to force 484 * write-back but didn't, because we set the @fast flag in the 485 * request. Write-back cannot be done now, while we have the 486 * page locked, because it would deadlock. Unlock and free 487 * everything and fall-back to slow-path. 488 */ 489 if (appending) { 490 ubifs_assert(c, mutex_is_locked(&ui->ui_mutex)); 491 mutex_unlock(&ui->ui_mutex); 492 } 493 unlock_page(page); 494 put_page(page); 495 496 return write_begin_slow(mapping, pos, len, pagep, flags); 497 } 498 499 /* 500 * Whee, we acquired budgeting quickly - without involving 501 * garbage-collection, committing or forcing write-back. We return 502 * with @ui->ui_mutex locked if we are appending pages, and unlocked 503 * otherwise. This is an optimization (slightly hacky though). 504 */ 505 *pagep = page; 506 return 0; 507 508 } 509 510 /** 511 * cancel_budget - cancel budget. 512 * @c: UBIFS file-system description object 513 * @page: page to cancel budget for 514 * @ui: UBIFS inode object the page belongs to 515 * @appending: non-zero if the page is appended 516 * 517 * This is a helper function for a page write operation. It unlocks the 518 * @ui->ui_mutex in case of appending. 519 */ 520 static void cancel_budget(struct ubifs_info *c, struct page *page, 521 struct ubifs_inode *ui, int appending) 522 { 523 if (appending) { 524 if (!ui->dirty) 525 ubifs_release_dirty_inode_budget(c, ui); 526 mutex_unlock(&ui->ui_mutex); 527 } 528 if (!PagePrivate(page)) { 529 if (PageChecked(page)) 530 release_new_page_budget(c); 531 else 532 release_existing_page_budget(c); 533 } 534 } 535 536 static int ubifs_write_end(struct file *file, struct address_space *mapping, 537 loff_t pos, unsigned len, unsigned copied, 538 struct page *page, void *fsdata) 539 { 540 struct inode *inode = mapping->host; 541 struct ubifs_inode *ui = ubifs_inode(inode); 542 struct ubifs_info *c = inode->i_sb->s_fs_info; 543 loff_t end_pos = pos + len; 544 int appending = !!(end_pos > inode->i_size); 545 546 dbg_gen("ino %lu, pos %llu, pg %lu, len %u, copied %d, i_size %lld", 547 inode->i_ino, pos, page->index, len, copied, inode->i_size); 548 549 if (unlikely(copied < len && len == PAGE_SIZE)) { 550 /* 551 * VFS copied less data to the page that it intended and 552 * declared in its '->write_begin()' call via the @len 553 * argument. If the page was not up-to-date, and @len was 554 * @PAGE_SIZE, the 'ubifs_write_begin()' function did 555 * not load it from the media (for optimization reasons). This 556 * means that part of the page contains garbage. So read the 557 * page now. 558 */ 559 dbg_gen("copied %d instead of %d, read page and repeat", 560 copied, len); 561 cancel_budget(c, page, ui, appending); 562 ClearPageChecked(page); 563 564 /* 565 * Return 0 to force VFS to repeat the whole operation, or the 566 * error code if 'do_readpage()' fails. 567 */ 568 copied = do_readpage(page); 569 goto out; 570 } 571 572 if (!PagePrivate(page)) { 573 SetPagePrivate(page); 574 atomic_long_inc(&c->dirty_pg_cnt); 575 __set_page_dirty_nobuffers(page); 576 } 577 578 if (appending) { 579 i_size_write(inode, end_pos); 580 ui->ui_size = end_pos; 581 /* 582 * Note, we do not set @I_DIRTY_PAGES (which means that the 583 * inode has dirty pages), this has been done in 584 * '__set_page_dirty_nobuffers()'. 585 */ 586 __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 587 ubifs_assert(c, mutex_is_locked(&ui->ui_mutex)); 588 mutex_unlock(&ui->ui_mutex); 589 } 590 591 out: 592 unlock_page(page); 593 put_page(page); 594 return copied; 595 } 596 597 /** 598 * populate_page - copy data nodes into a page for bulk-read. 599 * @c: UBIFS file-system description object 600 * @page: page 601 * @bu: bulk-read information 602 * @n: next zbranch slot 603 * 604 * This function returns %0 on success and a negative error code on failure. 605 */ 606 static int populate_page(struct ubifs_info *c, struct page *page, 607 struct bu_info *bu, int *n) 608 { 609 int i = 0, nn = *n, offs = bu->zbranch[0].offs, hole = 0, read = 0; 610 struct inode *inode = page->mapping->host; 611 loff_t i_size = i_size_read(inode); 612 unsigned int page_block; 613 void *addr, *zaddr; 614 pgoff_t end_index; 615 616 dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx", 617 inode->i_ino, page->index, i_size, page->flags); 618 619 addr = zaddr = kmap(page); 620 621 end_index = (i_size - 1) >> PAGE_SHIFT; 622 if (!i_size || page->index > end_index) { 623 hole = 1; 624 memset(addr, 0, PAGE_SIZE); 625 goto out_hole; 626 } 627 628 page_block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT; 629 while (1) { 630 int err, len, out_len, dlen; 631 632 if (nn >= bu->cnt) { 633 hole = 1; 634 memset(addr, 0, UBIFS_BLOCK_SIZE); 635 } else if (key_block(c, &bu->zbranch[nn].key) == page_block) { 636 struct ubifs_data_node *dn; 637 638 dn = bu->buf + (bu->zbranch[nn].offs - offs); 639 640 ubifs_assert(c, le64_to_cpu(dn->ch.sqnum) > 641 ubifs_inode(inode)->creat_sqnum); 642 643 len = le32_to_cpu(dn->size); 644 if (len <= 0 || len > UBIFS_BLOCK_SIZE) 645 goto out_err; 646 647 dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ; 648 out_len = UBIFS_BLOCK_SIZE; 649 650 if (IS_ENCRYPTED(inode)) { 651 err = ubifs_decrypt(inode, dn, &dlen, page_block); 652 if (err) 653 goto out_err; 654 } 655 656 err = ubifs_decompress(c, &dn->data, dlen, addr, &out_len, 657 le16_to_cpu(dn->compr_type)); 658 if (err || len != out_len) 659 goto out_err; 660 661 if (len < UBIFS_BLOCK_SIZE) 662 memset(addr + len, 0, UBIFS_BLOCK_SIZE - len); 663 664 nn += 1; 665 read = (i << UBIFS_BLOCK_SHIFT) + len; 666 } else if (key_block(c, &bu->zbranch[nn].key) < page_block) { 667 nn += 1; 668 continue; 669 } else { 670 hole = 1; 671 memset(addr, 0, UBIFS_BLOCK_SIZE); 672 } 673 if (++i >= UBIFS_BLOCKS_PER_PAGE) 674 break; 675 addr += UBIFS_BLOCK_SIZE; 676 page_block += 1; 677 } 678 679 if (end_index == page->index) { 680 int len = i_size & (PAGE_SIZE - 1); 681 682 if (len && len < read) 683 memset(zaddr + len, 0, read - len); 684 } 685 686 out_hole: 687 if (hole) { 688 SetPageChecked(page); 689 dbg_gen("hole"); 690 } 691 692 SetPageUptodate(page); 693 ClearPageError(page); 694 flush_dcache_page(page); 695 kunmap(page); 696 *n = nn; 697 return 0; 698 699 out_err: 700 ClearPageUptodate(page); 701 SetPageError(page); 702 flush_dcache_page(page); 703 kunmap(page); 704 ubifs_err(c, "bad data node (block %u, inode %lu)", 705 page_block, inode->i_ino); 706 return -EINVAL; 707 } 708 709 /** 710 * ubifs_do_bulk_read - do bulk-read. 711 * @c: UBIFS file-system description object 712 * @bu: bulk-read information 713 * @page1: first page to read 714 * 715 * This function returns %1 if the bulk-read is done, otherwise %0 is returned. 716 */ 717 static int ubifs_do_bulk_read(struct ubifs_info *c, struct bu_info *bu, 718 struct page *page1) 719 { 720 pgoff_t offset = page1->index, end_index; 721 struct address_space *mapping = page1->mapping; 722 struct inode *inode = mapping->host; 723 struct ubifs_inode *ui = ubifs_inode(inode); 724 int err, page_idx, page_cnt, ret = 0, n = 0; 725 int allocate = bu->buf ? 0 : 1; 726 loff_t isize; 727 gfp_t ra_gfp_mask = readahead_gfp_mask(mapping) & ~__GFP_FS; 728 729 err = ubifs_tnc_get_bu_keys(c, bu); 730 if (err) 731 goto out_warn; 732 733 if (bu->eof) { 734 /* Turn off bulk-read at the end of the file */ 735 ui->read_in_a_row = 1; 736 ui->bulk_read = 0; 737 } 738 739 page_cnt = bu->blk_cnt >> UBIFS_BLOCKS_PER_PAGE_SHIFT; 740 if (!page_cnt) { 741 /* 742 * This happens when there are multiple blocks per page and the 743 * blocks for the first page we are looking for, are not 744 * together. If all the pages were like this, bulk-read would 745 * reduce performance, so we turn it off for a while. 746 */ 747 goto out_bu_off; 748 } 749 750 if (bu->cnt) { 751 if (allocate) { 752 /* 753 * Allocate bulk-read buffer depending on how many data 754 * nodes we are going to read. 755 */ 756 bu->buf_len = bu->zbranch[bu->cnt - 1].offs + 757 bu->zbranch[bu->cnt - 1].len - 758 bu->zbranch[0].offs; 759 ubifs_assert(c, bu->buf_len > 0); 760 ubifs_assert(c, bu->buf_len <= c->leb_size); 761 bu->buf = kmalloc(bu->buf_len, GFP_NOFS | __GFP_NOWARN); 762 if (!bu->buf) 763 goto out_bu_off; 764 } 765 766 err = ubifs_tnc_bulk_read(c, bu); 767 if (err) 768 goto out_warn; 769 } 770 771 err = populate_page(c, page1, bu, &n); 772 if (err) 773 goto out_warn; 774 775 unlock_page(page1); 776 ret = 1; 777 778 isize = i_size_read(inode); 779 if (isize == 0) 780 goto out_free; 781 end_index = ((isize - 1) >> PAGE_SHIFT); 782 783 for (page_idx = 1; page_idx < page_cnt; page_idx++) { 784 pgoff_t page_offset = offset + page_idx; 785 struct page *page; 786 787 if (page_offset > end_index) 788 break; 789 page = pagecache_get_page(mapping, page_offset, 790 FGP_LOCK|FGP_ACCESSED|FGP_CREAT|FGP_NOWAIT, 791 ra_gfp_mask); 792 if (!page) 793 break; 794 if (!PageUptodate(page)) 795 err = populate_page(c, page, bu, &n); 796 unlock_page(page); 797 put_page(page); 798 if (err) 799 break; 800 } 801 802 ui->last_page_read = offset + page_idx - 1; 803 804 out_free: 805 if (allocate) 806 kfree(bu->buf); 807 return ret; 808 809 out_warn: 810 ubifs_warn(c, "ignoring error %d and skipping bulk-read", err); 811 goto out_free; 812 813 out_bu_off: 814 ui->read_in_a_row = ui->bulk_read = 0; 815 goto out_free; 816 } 817 818 /** 819 * ubifs_bulk_read - determine whether to bulk-read and, if so, do it. 820 * @page: page from which to start bulk-read. 821 * 822 * Some flash media are capable of reading sequentially at faster rates. UBIFS 823 * bulk-read facility is designed to take advantage of that, by reading in one 824 * go consecutive data nodes that are also located consecutively in the same 825 * LEB. This function returns %1 if a bulk-read is done and %0 otherwise. 826 */ 827 static int ubifs_bulk_read(struct page *page) 828 { 829 struct inode *inode = page->mapping->host; 830 struct ubifs_info *c = inode->i_sb->s_fs_info; 831 struct ubifs_inode *ui = ubifs_inode(inode); 832 pgoff_t index = page->index, last_page_read = ui->last_page_read; 833 struct bu_info *bu; 834 int err = 0, allocated = 0; 835 836 ui->last_page_read = index; 837 if (!c->bulk_read) 838 return 0; 839 840 /* 841 * Bulk-read is protected by @ui->ui_mutex, but it is an optimization, 842 * so don't bother if we cannot lock the mutex. 843 */ 844 if (!mutex_trylock(&ui->ui_mutex)) 845 return 0; 846 847 if (index != last_page_read + 1) { 848 /* Turn off bulk-read if we stop reading sequentially */ 849 ui->read_in_a_row = 1; 850 if (ui->bulk_read) 851 ui->bulk_read = 0; 852 goto out_unlock; 853 } 854 855 if (!ui->bulk_read) { 856 ui->read_in_a_row += 1; 857 if (ui->read_in_a_row < 3) 858 goto out_unlock; 859 /* Three reads in a row, so switch on bulk-read */ 860 ui->bulk_read = 1; 861 } 862 863 /* 864 * If possible, try to use pre-allocated bulk-read information, which 865 * is protected by @c->bu_mutex. 866 */ 867 if (mutex_trylock(&c->bu_mutex)) 868 bu = &c->bu; 869 else { 870 bu = kmalloc(sizeof(struct bu_info), GFP_NOFS | __GFP_NOWARN); 871 if (!bu) 872 goto out_unlock; 873 874 bu->buf = NULL; 875 allocated = 1; 876 } 877 878 bu->buf_len = c->max_bu_buf_len; 879 data_key_init(c, &bu->key, inode->i_ino, 880 page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT); 881 err = ubifs_do_bulk_read(c, bu, page); 882 883 if (!allocated) 884 mutex_unlock(&c->bu_mutex); 885 else 886 kfree(bu); 887 888 out_unlock: 889 mutex_unlock(&ui->ui_mutex); 890 return err; 891 } 892 893 static int ubifs_readpage(struct file *file, struct page *page) 894 { 895 if (ubifs_bulk_read(page)) 896 return 0; 897 do_readpage(page); 898 unlock_page(page); 899 return 0; 900 } 901 902 static int do_writepage(struct page *page, int len) 903 { 904 int err = 0, i, blen; 905 unsigned int block; 906 void *addr; 907 union ubifs_key key; 908 struct inode *inode = page->mapping->host; 909 struct ubifs_info *c = inode->i_sb->s_fs_info; 910 911 #ifdef UBIFS_DEBUG 912 struct ubifs_inode *ui = ubifs_inode(inode); 913 spin_lock(&ui->ui_lock); 914 ubifs_assert(c, page->index <= ui->synced_i_size >> PAGE_SHIFT); 915 spin_unlock(&ui->ui_lock); 916 #endif 917 918 /* Update radix tree tags */ 919 set_page_writeback(page); 920 921 addr = kmap(page); 922 block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT; 923 i = 0; 924 while (len) { 925 blen = min_t(int, len, UBIFS_BLOCK_SIZE); 926 data_key_init(c, &key, inode->i_ino, block); 927 err = ubifs_jnl_write_data(c, inode, &key, addr, blen); 928 if (err) 929 break; 930 if (++i >= UBIFS_BLOCKS_PER_PAGE) 931 break; 932 block += 1; 933 addr += blen; 934 len -= blen; 935 } 936 if (err) { 937 SetPageError(page); 938 ubifs_err(c, "cannot write page %lu of inode %lu, error %d", 939 page->index, inode->i_ino, err); 940 ubifs_ro_mode(c, err); 941 } 942 943 ubifs_assert(c, PagePrivate(page)); 944 if (PageChecked(page)) 945 release_new_page_budget(c); 946 else 947 release_existing_page_budget(c); 948 949 atomic_long_dec(&c->dirty_pg_cnt); 950 ClearPagePrivate(page); 951 ClearPageChecked(page); 952 953 kunmap(page); 954 unlock_page(page); 955 end_page_writeback(page); 956 return err; 957 } 958 959 /* 960 * When writing-back dirty inodes, VFS first writes-back pages belonging to the 961 * inode, then the inode itself. For UBIFS this may cause a problem. Consider a 962 * situation when a we have an inode with size 0, then a megabyte of data is 963 * appended to the inode, then write-back starts and flushes some amount of the 964 * dirty pages, the journal becomes full, commit happens and finishes, and then 965 * an unclean reboot happens. When the file system is mounted next time, the 966 * inode size would still be 0, but there would be many pages which are beyond 967 * the inode size, they would be indexed and consume flash space. Because the 968 * journal has been committed, the replay would not be able to detect this 969 * situation and correct the inode size. This means UBIFS would have to scan 970 * whole index and correct all inode sizes, which is long an unacceptable. 971 * 972 * To prevent situations like this, UBIFS writes pages back only if they are 973 * within the last synchronized inode size, i.e. the size which has been 974 * written to the flash media last time. Otherwise, UBIFS forces inode 975 * write-back, thus making sure the on-flash inode contains current inode size, 976 * and then keeps writing pages back. 977 * 978 * Some locking issues explanation. 'ubifs_writepage()' first is called with 979 * the page locked, and it locks @ui_mutex. However, write-back does take inode 980 * @i_mutex, which means other VFS operations may be run on this inode at the 981 * same time. And the problematic one is truncation to smaller size, from where 982 * we have to call 'truncate_setsize()', which first changes @inode->i_size, 983 * then drops the truncated pages. And while dropping the pages, it takes the 984 * page lock. This means that 'do_truncation()' cannot call 'truncate_setsize()' 985 * with @ui_mutex locked, because it would deadlock with 'ubifs_writepage()'. 986 * This means that @inode->i_size is changed while @ui_mutex is unlocked. 987 * 988 * XXX(truncate): with the new truncate sequence this is not true anymore, 989 * and the calls to truncate_setsize can be move around freely. They should 990 * be moved to the very end of the truncate sequence. 991 * 992 * But in 'ubifs_writepage()' we have to guarantee that we do not write beyond 993 * inode size. How do we do this if @inode->i_size may became smaller while we 994 * are in the middle of 'ubifs_writepage()'? The UBIFS solution is the 995 * @ui->ui_isize "shadow" field which UBIFS uses instead of @inode->i_size 996 * internally and updates it under @ui_mutex. 997 * 998 * Q: why we do not worry that if we race with truncation, we may end up with a 999 * situation when the inode is truncated while we are in the middle of 1000 * 'do_writepage()', so we do write beyond inode size? 1001 * A: If we are in the middle of 'do_writepage()', truncation would be locked 1002 * on the page lock and it would not write the truncated inode node to the 1003 * journal before we have finished. 1004 */ 1005 static int ubifs_writepage(struct page *page, struct writeback_control *wbc) 1006 { 1007 struct inode *inode = page->mapping->host; 1008 struct ubifs_info *c = inode->i_sb->s_fs_info; 1009 struct ubifs_inode *ui = ubifs_inode(inode); 1010 loff_t i_size = i_size_read(inode), synced_i_size; 1011 pgoff_t end_index = i_size >> PAGE_SHIFT; 1012 int err, len = i_size & (PAGE_SIZE - 1); 1013 void *kaddr; 1014 1015 dbg_gen("ino %lu, pg %lu, pg flags %#lx", 1016 inode->i_ino, page->index, page->flags); 1017 ubifs_assert(c, PagePrivate(page)); 1018 1019 /* Is the page fully outside @i_size? (truncate in progress) */ 1020 if (page->index > end_index || (page->index == end_index && !len)) { 1021 err = 0; 1022 goto out_unlock; 1023 } 1024 1025 spin_lock(&ui->ui_lock); 1026 synced_i_size = ui->synced_i_size; 1027 spin_unlock(&ui->ui_lock); 1028 1029 /* Is the page fully inside @i_size? */ 1030 if (page->index < end_index) { 1031 if (page->index >= synced_i_size >> PAGE_SHIFT) { 1032 err = inode->i_sb->s_op->write_inode(inode, NULL); 1033 if (err) 1034 goto out_unlock; 1035 /* 1036 * The inode has been written, but the write-buffer has 1037 * not been synchronized, so in case of an unclean 1038 * reboot we may end up with some pages beyond inode 1039 * size, but they would be in the journal (because 1040 * commit flushes write buffers) and recovery would deal 1041 * with this. 1042 */ 1043 } 1044 return do_writepage(page, PAGE_SIZE); 1045 } 1046 1047 /* 1048 * The page straddles @i_size. It must be zeroed out on each and every 1049 * writepage invocation because it may be mmapped. "A file is mapped 1050 * in multiples of the page size. For a file that is not a multiple of 1051 * the page size, the remaining memory is zeroed when mapped, and 1052 * writes to that region are not written out to the file." 1053 */ 1054 kaddr = kmap_atomic(page); 1055 memset(kaddr + len, 0, PAGE_SIZE - len); 1056 flush_dcache_page(page); 1057 kunmap_atomic(kaddr); 1058 1059 if (i_size > synced_i_size) { 1060 err = inode->i_sb->s_op->write_inode(inode, NULL); 1061 if (err) 1062 goto out_unlock; 1063 } 1064 1065 return do_writepage(page, len); 1066 1067 out_unlock: 1068 unlock_page(page); 1069 return err; 1070 } 1071 1072 /** 1073 * do_attr_changes - change inode attributes. 1074 * @inode: inode to change attributes for 1075 * @attr: describes attributes to change 1076 */ 1077 static void do_attr_changes(struct inode *inode, const struct iattr *attr) 1078 { 1079 if (attr->ia_valid & ATTR_UID) 1080 inode->i_uid = attr->ia_uid; 1081 if (attr->ia_valid & ATTR_GID) 1082 inode->i_gid = attr->ia_gid; 1083 if (attr->ia_valid & ATTR_ATIME) 1084 inode->i_atime = attr->ia_atime; 1085 if (attr->ia_valid & ATTR_MTIME) 1086 inode->i_mtime = attr->ia_mtime; 1087 if (attr->ia_valid & ATTR_CTIME) 1088 inode->i_ctime = attr->ia_ctime; 1089 if (attr->ia_valid & ATTR_MODE) { 1090 umode_t mode = attr->ia_mode; 1091 1092 if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) 1093 mode &= ~S_ISGID; 1094 inode->i_mode = mode; 1095 } 1096 } 1097 1098 /** 1099 * do_truncation - truncate an inode. 1100 * @c: UBIFS file-system description object 1101 * @inode: inode to truncate 1102 * @attr: inode attribute changes description 1103 * 1104 * This function implements VFS '->setattr()' call when the inode is truncated 1105 * to a smaller size. Returns zero in case of success and a negative error code 1106 * in case of failure. 1107 */ 1108 static int do_truncation(struct ubifs_info *c, struct inode *inode, 1109 const struct iattr *attr) 1110 { 1111 int err; 1112 struct ubifs_budget_req req; 1113 loff_t old_size = inode->i_size, new_size = attr->ia_size; 1114 int offset = new_size & (UBIFS_BLOCK_SIZE - 1), budgeted = 1; 1115 struct ubifs_inode *ui = ubifs_inode(inode); 1116 1117 dbg_gen("ino %lu, size %lld -> %lld", inode->i_ino, old_size, new_size); 1118 memset(&req, 0, sizeof(struct ubifs_budget_req)); 1119 1120 /* 1121 * If this is truncation to a smaller size, and we do not truncate on a 1122 * block boundary, budget for changing one data block, because the last 1123 * block will be re-written. 1124 */ 1125 if (new_size & (UBIFS_BLOCK_SIZE - 1)) 1126 req.dirtied_page = 1; 1127 1128 req.dirtied_ino = 1; 1129 /* A funny way to budget for truncation node */ 1130 req.dirtied_ino_d = UBIFS_TRUN_NODE_SZ; 1131 err = ubifs_budget_space(c, &req); 1132 if (err) { 1133 /* 1134 * Treat truncations to zero as deletion and always allow them, 1135 * just like we do for '->unlink()'. 1136 */ 1137 if (new_size || err != -ENOSPC) 1138 return err; 1139 budgeted = 0; 1140 } 1141 1142 truncate_setsize(inode, new_size); 1143 1144 if (offset) { 1145 pgoff_t index = new_size >> PAGE_SHIFT; 1146 struct page *page; 1147 1148 page = find_lock_page(inode->i_mapping, index); 1149 if (page) { 1150 if (PageDirty(page)) { 1151 /* 1152 * 'ubifs_jnl_truncate()' will try to truncate 1153 * the last data node, but it contains 1154 * out-of-date data because the page is dirty. 1155 * Write the page now, so that 1156 * 'ubifs_jnl_truncate()' will see an already 1157 * truncated (and up to date) data node. 1158 */ 1159 ubifs_assert(c, PagePrivate(page)); 1160 1161 clear_page_dirty_for_io(page); 1162 if (UBIFS_BLOCKS_PER_PAGE_SHIFT) 1163 offset = new_size & 1164 (PAGE_SIZE - 1); 1165 err = do_writepage(page, offset); 1166 put_page(page); 1167 if (err) 1168 goto out_budg; 1169 /* 1170 * We could now tell 'ubifs_jnl_truncate()' not 1171 * to read the last block. 1172 */ 1173 } else { 1174 /* 1175 * We could 'kmap()' the page and pass the data 1176 * to 'ubifs_jnl_truncate()' to save it from 1177 * having to read it. 1178 */ 1179 unlock_page(page); 1180 put_page(page); 1181 } 1182 } 1183 } 1184 1185 mutex_lock(&ui->ui_mutex); 1186 ui->ui_size = inode->i_size; 1187 /* Truncation changes inode [mc]time */ 1188 inode->i_mtime = inode->i_ctime = current_time(inode); 1189 /* Other attributes may be changed at the same time as well */ 1190 do_attr_changes(inode, attr); 1191 err = ubifs_jnl_truncate(c, inode, old_size, new_size); 1192 mutex_unlock(&ui->ui_mutex); 1193 1194 out_budg: 1195 if (budgeted) 1196 ubifs_release_budget(c, &req); 1197 else { 1198 c->bi.nospace = c->bi.nospace_rp = 0; 1199 smp_wmb(); 1200 } 1201 return err; 1202 } 1203 1204 /** 1205 * do_setattr - change inode attributes. 1206 * @c: UBIFS file-system description object 1207 * @inode: inode to change attributes for 1208 * @attr: inode attribute changes description 1209 * 1210 * This function implements VFS '->setattr()' call for all cases except 1211 * truncations to smaller size. Returns zero in case of success and a negative 1212 * error code in case of failure. 1213 */ 1214 static int do_setattr(struct ubifs_info *c, struct inode *inode, 1215 const struct iattr *attr) 1216 { 1217 int err, release; 1218 loff_t new_size = attr->ia_size; 1219 struct ubifs_inode *ui = ubifs_inode(inode); 1220 struct ubifs_budget_req req = { .dirtied_ino = 1, 1221 .dirtied_ino_d = ALIGN(ui->data_len, 8) }; 1222 1223 err = ubifs_budget_space(c, &req); 1224 if (err) 1225 return err; 1226 1227 if (attr->ia_valid & ATTR_SIZE) { 1228 dbg_gen("size %lld -> %lld", inode->i_size, new_size); 1229 truncate_setsize(inode, new_size); 1230 } 1231 1232 mutex_lock(&ui->ui_mutex); 1233 if (attr->ia_valid & ATTR_SIZE) { 1234 /* Truncation changes inode [mc]time */ 1235 inode->i_mtime = inode->i_ctime = current_time(inode); 1236 /* 'truncate_setsize()' changed @i_size, update @ui_size */ 1237 ui->ui_size = inode->i_size; 1238 } 1239 1240 do_attr_changes(inode, attr); 1241 1242 release = ui->dirty; 1243 if (attr->ia_valid & ATTR_SIZE) 1244 /* 1245 * Inode length changed, so we have to make sure 1246 * @I_DIRTY_DATASYNC is set. 1247 */ 1248 __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 1249 else 1250 mark_inode_dirty_sync(inode); 1251 mutex_unlock(&ui->ui_mutex); 1252 1253 if (release) 1254 ubifs_release_budget(c, &req); 1255 if (IS_SYNC(inode)) 1256 err = inode->i_sb->s_op->write_inode(inode, NULL); 1257 return err; 1258 } 1259 1260 int ubifs_setattr(struct user_namespace *mnt_userns, struct dentry *dentry, 1261 struct iattr *attr) 1262 { 1263 int err; 1264 struct inode *inode = d_inode(dentry); 1265 struct ubifs_info *c = inode->i_sb->s_fs_info; 1266 1267 dbg_gen("ino %lu, mode %#x, ia_valid %#x", 1268 inode->i_ino, inode->i_mode, attr->ia_valid); 1269 err = setattr_prepare(&init_user_ns, dentry, attr); 1270 if (err) 1271 return err; 1272 1273 err = dbg_check_synced_i_size(c, inode); 1274 if (err) 1275 return err; 1276 1277 err = fscrypt_prepare_setattr(dentry, attr); 1278 if (err) 1279 return err; 1280 1281 if ((attr->ia_valid & ATTR_SIZE) && attr->ia_size < inode->i_size) 1282 /* Truncation to a smaller size */ 1283 err = do_truncation(c, inode, attr); 1284 else 1285 err = do_setattr(c, inode, attr); 1286 1287 return err; 1288 } 1289 1290 static void ubifs_invalidate_folio(struct folio *folio, size_t offset, 1291 size_t length) 1292 { 1293 struct inode *inode = folio->mapping->host; 1294 struct ubifs_info *c = inode->i_sb->s_fs_info; 1295 1296 ubifs_assert(c, folio_test_private(folio)); 1297 if (offset || length < folio_size(folio)) 1298 /* Partial folio remains dirty */ 1299 return; 1300 1301 if (folio_test_checked(folio)) 1302 release_new_page_budget(c); 1303 else 1304 release_existing_page_budget(c); 1305 1306 atomic_long_dec(&c->dirty_pg_cnt); 1307 folio_clear_private(folio); 1308 folio_clear_checked(folio); 1309 } 1310 1311 int ubifs_fsync(struct file *file, loff_t start, loff_t end, int datasync) 1312 { 1313 struct inode *inode = file->f_mapping->host; 1314 struct ubifs_info *c = inode->i_sb->s_fs_info; 1315 int err; 1316 1317 dbg_gen("syncing inode %lu", inode->i_ino); 1318 1319 if (c->ro_mount) 1320 /* 1321 * For some really strange reasons VFS does not filter out 1322 * 'fsync()' for R/O mounted file-systems as per 2.6.39. 1323 */ 1324 return 0; 1325 1326 err = file_write_and_wait_range(file, start, end); 1327 if (err) 1328 return err; 1329 inode_lock(inode); 1330 1331 /* Synchronize the inode unless this is a 'datasync()' call. */ 1332 if (!datasync || (inode->i_state & I_DIRTY_DATASYNC)) { 1333 err = inode->i_sb->s_op->write_inode(inode, NULL); 1334 if (err) 1335 goto out; 1336 } 1337 1338 /* 1339 * Nodes related to this inode may still sit in a write-buffer. Flush 1340 * them. 1341 */ 1342 err = ubifs_sync_wbufs_by_inode(c, inode); 1343 out: 1344 inode_unlock(inode); 1345 return err; 1346 } 1347 1348 /** 1349 * mctime_update_needed - check if mtime or ctime update is needed. 1350 * @inode: the inode to do the check for 1351 * @now: current time 1352 * 1353 * This helper function checks if the inode mtime/ctime should be updated or 1354 * not. If current values of the time-stamps are within the UBIFS inode time 1355 * granularity, they are not updated. This is an optimization. 1356 */ 1357 static inline int mctime_update_needed(const struct inode *inode, 1358 const struct timespec64 *now) 1359 { 1360 if (!timespec64_equal(&inode->i_mtime, now) || 1361 !timespec64_equal(&inode->i_ctime, now)) 1362 return 1; 1363 return 0; 1364 } 1365 1366 /** 1367 * ubifs_update_time - update time of inode. 1368 * @inode: inode to update 1369 * 1370 * This function updates time of the inode. 1371 */ 1372 int ubifs_update_time(struct inode *inode, struct timespec64 *time, 1373 int flags) 1374 { 1375 struct ubifs_inode *ui = ubifs_inode(inode); 1376 struct ubifs_info *c = inode->i_sb->s_fs_info; 1377 struct ubifs_budget_req req = { .dirtied_ino = 1, 1378 .dirtied_ino_d = ALIGN(ui->data_len, 8) }; 1379 int err, release; 1380 1381 if (!IS_ENABLED(CONFIG_UBIFS_ATIME_SUPPORT)) 1382 return generic_update_time(inode, time, flags); 1383 1384 err = ubifs_budget_space(c, &req); 1385 if (err) 1386 return err; 1387 1388 mutex_lock(&ui->ui_mutex); 1389 if (flags & S_ATIME) 1390 inode->i_atime = *time; 1391 if (flags & S_CTIME) 1392 inode->i_ctime = *time; 1393 if (flags & S_MTIME) 1394 inode->i_mtime = *time; 1395 1396 release = ui->dirty; 1397 __mark_inode_dirty(inode, I_DIRTY_SYNC); 1398 mutex_unlock(&ui->ui_mutex); 1399 if (release) 1400 ubifs_release_budget(c, &req); 1401 return 0; 1402 } 1403 1404 /** 1405 * update_mctime - update mtime and ctime of an inode. 1406 * @inode: inode to update 1407 * 1408 * This function updates mtime and ctime of the inode if it is not equivalent to 1409 * current time. Returns zero in case of success and a negative error code in 1410 * case of failure. 1411 */ 1412 static int update_mctime(struct inode *inode) 1413 { 1414 struct timespec64 now = current_time(inode); 1415 struct ubifs_inode *ui = ubifs_inode(inode); 1416 struct ubifs_info *c = inode->i_sb->s_fs_info; 1417 1418 if (mctime_update_needed(inode, &now)) { 1419 int err, release; 1420 struct ubifs_budget_req req = { .dirtied_ino = 1, 1421 .dirtied_ino_d = ALIGN(ui->data_len, 8) }; 1422 1423 err = ubifs_budget_space(c, &req); 1424 if (err) 1425 return err; 1426 1427 mutex_lock(&ui->ui_mutex); 1428 inode->i_mtime = inode->i_ctime = current_time(inode); 1429 release = ui->dirty; 1430 mark_inode_dirty_sync(inode); 1431 mutex_unlock(&ui->ui_mutex); 1432 if (release) 1433 ubifs_release_budget(c, &req); 1434 } 1435 1436 return 0; 1437 } 1438 1439 static ssize_t ubifs_write_iter(struct kiocb *iocb, struct iov_iter *from) 1440 { 1441 int err = update_mctime(file_inode(iocb->ki_filp)); 1442 if (err) 1443 return err; 1444 1445 return generic_file_write_iter(iocb, from); 1446 } 1447 1448 static bool ubifs_dirty_folio(struct address_space *mapping, 1449 struct folio *folio) 1450 { 1451 bool ret; 1452 struct ubifs_info *c = mapping->host->i_sb->s_fs_info; 1453 1454 ret = filemap_dirty_folio(mapping, folio); 1455 /* 1456 * An attempt to dirty a page without budgeting for it - should not 1457 * happen. 1458 */ 1459 ubifs_assert(c, ret == false); 1460 return ret; 1461 } 1462 1463 #ifdef CONFIG_MIGRATION 1464 static int ubifs_migrate_page(struct address_space *mapping, 1465 struct page *newpage, struct page *page, enum migrate_mode mode) 1466 { 1467 int rc; 1468 1469 rc = migrate_page_move_mapping(mapping, newpage, page, 0); 1470 if (rc != MIGRATEPAGE_SUCCESS) 1471 return rc; 1472 1473 if (PagePrivate(page)) { 1474 ClearPagePrivate(page); 1475 SetPagePrivate(newpage); 1476 } 1477 1478 if (mode != MIGRATE_SYNC_NO_COPY) 1479 migrate_page_copy(newpage, page); 1480 else 1481 migrate_page_states(newpage, page); 1482 return MIGRATEPAGE_SUCCESS; 1483 } 1484 #endif 1485 1486 static int ubifs_releasepage(struct page *page, gfp_t unused_gfp_flags) 1487 { 1488 struct inode *inode = page->mapping->host; 1489 struct ubifs_info *c = inode->i_sb->s_fs_info; 1490 1491 /* 1492 * An attempt to release a dirty page without budgeting for it - should 1493 * not happen. 1494 */ 1495 if (PageWriteback(page)) 1496 return 0; 1497 ubifs_assert(c, PagePrivate(page)); 1498 ubifs_assert(c, 0); 1499 ClearPagePrivate(page); 1500 ClearPageChecked(page); 1501 return 1; 1502 } 1503 1504 /* 1505 * mmap()d file has taken write protection fault and is being made writable. 1506 * UBIFS must ensure page is budgeted for. 1507 */ 1508 static vm_fault_t ubifs_vm_page_mkwrite(struct vm_fault *vmf) 1509 { 1510 struct page *page = vmf->page; 1511 struct inode *inode = file_inode(vmf->vma->vm_file); 1512 struct ubifs_info *c = inode->i_sb->s_fs_info; 1513 struct timespec64 now = current_time(inode); 1514 struct ubifs_budget_req req = { .new_page = 1 }; 1515 int err, update_time; 1516 1517 dbg_gen("ino %lu, pg %lu, i_size %lld", inode->i_ino, page->index, 1518 i_size_read(inode)); 1519 ubifs_assert(c, !c->ro_media && !c->ro_mount); 1520 1521 if (unlikely(c->ro_error)) 1522 return VM_FAULT_SIGBUS; /* -EROFS */ 1523 1524 /* 1525 * We have not locked @page so far so we may budget for changing the 1526 * page. Note, we cannot do this after we locked the page, because 1527 * budgeting may cause write-back which would cause deadlock. 1528 * 1529 * At the moment we do not know whether the page is dirty or not, so we 1530 * assume that it is not and budget for a new page. We could look at 1531 * the @PG_private flag and figure this out, but we may race with write 1532 * back and the page state may change by the time we lock it, so this 1533 * would need additional care. We do not bother with this at the 1534 * moment, although it might be good idea to do. Instead, we allocate 1535 * budget for a new page and amend it later on if the page was in fact 1536 * dirty. 1537 * 1538 * The budgeting-related logic of this function is similar to what we 1539 * do in 'ubifs_write_begin()' and 'ubifs_write_end()'. Glance there 1540 * for more comments. 1541 */ 1542 update_time = mctime_update_needed(inode, &now); 1543 if (update_time) 1544 /* 1545 * We have to change inode time stamp which requires extra 1546 * budgeting. 1547 */ 1548 req.dirtied_ino = 1; 1549 1550 err = ubifs_budget_space(c, &req); 1551 if (unlikely(err)) { 1552 if (err == -ENOSPC) 1553 ubifs_warn(c, "out of space for mmapped file (inode number %lu)", 1554 inode->i_ino); 1555 return VM_FAULT_SIGBUS; 1556 } 1557 1558 lock_page(page); 1559 if (unlikely(page->mapping != inode->i_mapping || 1560 page_offset(page) > i_size_read(inode))) { 1561 /* Page got truncated out from underneath us */ 1562 goto sigbus; 1563 } 1564 1565 if (PagePrivate(page)) 1566 release_new_page_budget(c); 1567 else { 1568 if (!PageChecked(page)) 1569 ubifs_convert_page_budget(c); 1570 SetPagePrivate(page); 1571 atomic_long_inc(&c->dirty_pg_cnt); 1572 __set_page_dirty_nobuffers(page); 1573 } 1574 1575 if (update_time) { 1576 int release; 1577 struct ubifs_inode *ui = ubifs_inode(inode); 1578 1579 mutex_lock(&ui->ui_mutex); 1580 inode->i_mtime = inode->i_ctime = current_time(inode); 1581 release = ui->dirty; 1582 mark_inode_dirty_sync(inode); 1583 mutex_unlock(&ui->ui_mutex); 1584 if (release) 1585 ubifs_release_dirty_inode_budget(c, ui); 1586 } 1587 1588 wait_for_stable_page(page); 1589 return VM_FAULT_LOCKED; 1590 1591 sigbus: 1592 unlock_page(page); 1593 ubifs_release_budget(c, &req); 1594 return VM_FAULT_SIGBUS; 1595 } 1596 1597 static const struct vm_operations_struct ubifs_file_vm_ops = { 1598 .fault = filemap_fault, 1599 .map_pages = filemap_map_pages, 1600 .page_mkwrite = ubifs_vm_page_mkwrite, 1601 }; 1602 1603 static int ubifs_file_mmap(struct file *file, struct vm_area_struct *vma) 1604 { 1605 int err; 1606 1607 err = generic_file_mmap(file, vma); 1608 if (err) 1609 return err; 1610 vma->vm_ops = &ubifs_file_vm_ops; 1611 1612 if (IS_ENABLED(CONFIG_UBIFS_ATIME_SUPPORT)) 1613 file_accessed(file); 1614 1615 return 0; 1616 } 1617 1618 static const char *ubifs_get_link(struct dentry *dentry, 1619 struct inode *inode, 1620 struct delayed_call *done) 1621 { 1622 struct ubifs_inode *ui = ubifs_inode(inode); 1623 1624 if (!IS_ENCRYPTED(inode)) 1625 return ui->data; 1626 1627 if (!dentry) 1628 return ERR_PTR(-ECHILD); 1629 1630 return fscrypt_get_symlink(inode, ui->data, ui->data_len, done); 1631 } 1632 1633 static int ubifs_symlink_getattr(struct user_namespace *mnt_userns, 1634 const struct path *path, struct kstat *stat, 1635 u32 request_mask, unsigned int query_flags) 1636 { 1637 ubifs_getattr(mnt_userns, path, stat, request_mask, query_flags); 1638 1639 if (IS_ENCRYPTED(d_inode(path->dentry))) 1640 return fscrypt_symlink_getattr(path, stat); 1641 return 0; 1642 } 1643 1644 const struct address_space_operations ubifs_file_address_operations = { 1645 .readpage = ubifs_readpage, 1646 .writepage = ubifs_writepage, 1647 .write_begin = ubifs_write_begin, 1648 .write_end = ubifs_write_end, 1649 .invalidate_folio = ubifs_invalidate_folio, 1650 .dirty_folio = ubifs_dirty_folio, 1651 #ifdef CONFIG_MIGRATION 1652 .migratepage = ubifs_migrate_page, 1653 #endif 1654 .releasepage = ubifs_releasepage, 1655 }; 1656 1657 const struct inode_operations ubifs_file_inode_operations = { 1658 .setattr = ubifs_setattr, 1659 .getattr = ubifs_getattr, 1660 .listxattr = ubifs_listxattr, 1661 .update_time = ubifs_update_time, 1662 .fileattr_get = ubifs_fileattr_get, 1663 .fileattr_set = ubifs_fileattr_set, 1664 }; 1665 1666 const struct inode_operations ubifs_symlink_inode_operations = { 1667 .get_link = ubifs_get_link, 1668 .setattr = ubifs_setattr, 1669 .getattr = ubifs_symlink_getattr, 1670 .listxattr = ubifs_listxattr, 1671 .update_time = ubifs_update_time, 1672 }; 1673 1674 const struct file_operations ubifs_file_operations = { 1675 .llseek = generic_file_llseek, 1676 .read_iter = generic_file_read_iter, 1677 .write_iter = ubifs_write_iter, 1678 .mmap = ubifs_file_mmap, 1679 .fsync = ubifs_fsync, 1680 .unlocked_ioctl = ubifs_ioctl, 1681 .splice_read = generic_file_splice_read, 1682 .splice_write = iter_file_splice_write, 1683 .open = fscrypt_file_open, 1684 #ifdef CONFIG_COMPAT 1685 .compat_ioctl = ubifs_compat_ioctl, 1686 #endif 1687 }; 1688