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