12b27bdccSThomas Gleixner // SPDX-License-Identifier: GPL-2.0-only 21e51764aSArtem Bityutskiy /* 31e51764aSArtem Bityutskiy * This file is part of UBIFS. 41e51764aSArtem Bityutskiy * 51e51764aSArtem Bityutskiy * Copyright (C) 2006-2008 Nokia Corporation. 61e51764aSArtem Bityutskiy * 71e51764aSArtem Bityutskiy * Authors: Artem Bityutskiy (Битюцкий Артём) 81e51764aSArtem Bityutskiy * Adrian Hunter 91e51764aSArtem Bityutskiy */ 101e51764aSArtem Bityutskiy 111e51764aSArtem Bityutskiy /* 12873a64c7SArtem Bityutskiy * This file implements VFS file and inode operations for regular files, device 131e51764aSArtem Bityutskiy * nodes and symlinks as well as address space operations. 141e51764aSArtem Bityutskiy * 15873a64c7SArtem Bityutskiy * UBIFS uses 2 page flags: @PG_private and @PG_checked. @PG_private is set if 16873a64c7SArtem Bityutskiy * the page is dirty and is used for optimization purposes - dirty pages are 17873a64c7SArtem Bityutskiy * not budgeted so the flag shows that 'ubifs_write_end()' should not release 18873a64c7SArtem Bityutskiy * the budget for this page. The @PG_checked flag is set if full budgeting is 19873a64c7SArtem Bityutskiy * required for the page e.g., when it corresponds to a file hole or it is 20873a64c7SArtem Bityutskiy * beyond the file size. The budgeting is done in 'ubifs_write_begin()', because 21873a64c7SArtem Bityutskiy * it is OK to fail in this function, and the budget is released in 22873a64c7SArtem Bityutskiy * 'ubifs_write_end()'. So the @PG_private and @PG_checked flags carry 23873a64c7SArtem Bityutskiy * information about how the page was budgeted, to make it possible to release 24873a64c7SArtem Bityutskiy * the budget properly. 251e51764aSArtem Bityutskiy * 26873a64c7SArtem Bityutskiy * A thing to keep in mind: inode @i_mutex is locked in most VFS operations we 27873a64c7SArtem Bityutskiy * implement. However, this is not true for 'ubifs_writepage()', which may be 285c57f20bSArtem Bityutskiy * called with @i_mutex unlocked. For example, when flusher thread is doing 295c57f20bSArtem Bityutskiy * background write-back, it calls 'ubifs_writepage()' with unlocked @i_mutex. 305c57f20bSArtem Bityutskiy * At "normal" work-paths the @i_mutex is locked in 'ubifs_writepage()', e.g. 315c57f20bSArtem Bityutskiy * in the "sys_write -> alloc_pages -> direct reclaim path". So, in 325c57f20bSArtem Bityutskiy * 'ubifs_writepage()' we are only guaranteed that the page is locked. 331e51764aSArtem Bityutskiy * 340b7bf483SMatthew Wilcox (Oracle) * Similarly, @i_mutex is not always locked in 'ubifs_read_folio()', e.g., the 35873a64c7SArtem Bityutskiy * read-ahead path does not lock it ("sys_read -> generic_file_aio_read -> 360b7bf483SMatthew Wilcox (Oracle) * ondemand_readahead -> read_folio"). In case of readahead, @I_SYNC flag is not 37873a64c7SArtem Bityutskiy * set as well. However, UBIFS disables readahead. 381e51764aSArtem Bityutskiy */ 391e51764aSArtem Bityutskiy 401e51764aSArtem Bityutskiy #include "ubifs.h" 411e51764aSArtem Bityutskiy #include <linux/mount.h> 425a0e3ad6STejun Heo #include <linux/slab.h> 434ac1c17bSKirill A. Shutemov #include <linux/migrate.h> 441e51764aSArtem Bityutskiy 451e51764aSArtem Bityutskiy static int read_block(struct inode *inode, void *addr, unsigned int block, 461e51764aSArtem Bityutskiy struct ubifs_data_node *dn) 471e51764aSArtem Bityutskiy { 481e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 491e51764aSArtem Bityutskiy int err, len, out_len; 501e51764aSArtem Bityutskiy union ubifs_key key; 511e51764aSArtem Bityutskiy unsigned int dlen; 521e51764aSArtem Bityutskiy 531e51764aSArtem Bityutskiy data_key_init(c, &key, inode->i_ino, block); 541e51764aSArtem Bityutskiy err = ubifs_tnc_lookup(c, &key, dn); 551e51764aSArtem Bityutskiy if (err) { 561e51764aSArtem Bityutskiy if (err == -ENOENT) 571e51764aSArtem Bityutskiy /* Not found, so it must be a hole */ 581e51764aSArtem Bityutskiy memset(addr, 0, UBIFS_BLOCK_SIZE); 591e51764aSArtem Bityutskiy return err; 601e51764aSArtem Bityutskiy } 611e51764aSArtem Bityutskiy 626eb61d58SRichard Weinberger ubifs_assert(c, le64_to_cpu(dn->ch.sqnum) > 63f92b9826SArtem Bityutskiy ubifs_inode(inode)->creat_sqnum); 641e51764aSArtem Bityutskiy len = le32_to_cpu(dn->size); 651e51764aSArtem Bityutskiy if (len <= 0 || len > UBIFS_BLOCK_SIZE) 661e51764aSArtem Bityutskiy goto dump; 671e51764aSArtem Bityutskiy 681e51764aSArtem Bityutskiy dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ; 697799953bSRichard Weinberger 7050d9fad7SEric Biggers if (IS_ENCRYPTED(inode)) { 717799953bSRichard Weinberger err = ubifs_decrypt(inode, dn, &dlen, block); 727799953bSRichard Weinberger if (err) 737799953bSRichard Weinberger goto dump; 747799953bSRichard Weinberger } 757799953bSRichard Weinberger 761e51764aSArtem Bityutskiy out_len = UBIFS_BLOCK_SIZE; 77235c362bSSheng Yong err = ubifs_decompress(c, &dn->data, dlen, addr, &out_len, 781e51764aSArtem Bityutskiy le16_to_cpu(dn->compr_type)); 791e51764aSArtem Bityutskiy if (err || len != out_len) 801e51764aSArtem Bityutskiy goto dump; 811e51764aSArtem Bityutskiy 821e51764aSArtem Bityutskiy /* 831e51764aSArtem Bityutskiy * Data length can be less than a full block, even for blocks that are 841e51764aSArtem Bityutskiy * not the last in the file (e.g., as a result of making a hole and 851e51764aSArtem Bityutskiy * appending data). Ensure that the remainder is zeroed out. 861e51764aSArtem Bityutskiy */ 871e51764aSArtem Bityutskiy if (len < UBIFS_BLOCK_SIZE) 881e51764aSArtem Bityutskiy memset(addr + len, 0, UBIFS_BLOCK_SIZE - len); 891e51764aSArtem Bityutskiy 901e51764aSArtem Bityutskiy return 0; 911e51764aSArtem Bityutskiy 921e51764aSArtem Bityutskiy dump: 93235c362bSSheng Yong ubifs_err(c, "bad data node (block %u, inode %lu)", 941e51764aSArtem Bityutskiy block, inode->i_ino); 95a33e30a0SZhihao Cheng ubifs_dump_node(c, dn, UBIFS_MAX_DATA_NODE_SZ); 961e51764aSArtem Bityutskiy return -EINVAL; 971e51764aSArtem Bityutskiy } 981e51764aSArtem Bityutskiy 991e51764aSArtem Bityutskiy static int do_readpage(struct page *page) 1001e51764aSArtem Bityutskiy { 1011e51764aSArtem Bityutskiy void *addr; 1021e51764aSArtem Bityutskiy int err = 0, i; 1031e51764aSArtem Bityutskiy unsigned int block, beyond; 1041e51764aSArtem Bityutskiy struct ubifs_data_node *dn; 1051e51764aSArtem Bityutskiy struct inode *inode = page->mapping->host; 1066eb61d58SRichard Weinberger struct ubifs_info *c = inode->i_sb->s_fs_info; 1071e51764aSArtem Bityutskiy loff_t i_size = i_size_read(inode); 1081e51764aSArtem Bityutskiy 1091e51764aSArtem Bityutskiy dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx", 1101e51764aSArtem Bityutskiy inode->i_ino, page->index, i_size, page->flags); 1116eb61d58SRichard Weinberger ubifs_assert(c, !PageChecked(page)); 1126eb61d58SRichard Weinberger ubifs_assert(c, !PagePrivate(page)); 1131e51764aSArtem Bityutskiy 1141e51764aSArtem Bityutskiy addr = kmap(page); 1151e51764aSArtem Bityutskiy 1161e51764aSArtem Bityutskiy block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT; 1171e51764aSArtem Bityutskiy beyond = (i_size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT; 1181e51764aSArtem Bityutskiy if (block >= beyond) { 1191e51764aSArtem Bityutskiy /* Reading beyond inode */ 1201e51764aSArtem Bityutskiy SetPageChecked(page); 12109cbfeafSKirill A. Shutemov memset(addr, 0, PAGE_SIZE); 1221e51764aSArtem Bityutskiy goto out; 1231e51764aSArtem Bityutskiy } 1241e51764aSArtem Bityutskiy 1251e51764aSArtem Bityutskiy dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS); 1261e51764aSArtem Bityutskiy if (!dn) { 1271e51764aSArtem Bityutskiy err = -ENOMEM; 1281e51764aSArtem Bityutskiy goto error; 1291e51764aSArtem Bityutskiy } 1301e51764aSArtem Bityutskiy 1311e51764aSArtem Bityutskiy i = 0; 1321e51764aSArtem Bityutskiy while (1) { 1331e51764aSArtem Bityutskiy int ret; 1341e51764aSArtem Bityutskiy 1351e51764aSArtem Bityutskiy if (block >= beyond) { 1361e51764aSArtem Bityutskiy /* Reading beyond inode */ 1371e51764aSArtem Bityutskiy err = -ENOENT; 1381e51764aSArtem Bityutskiy memset(addr, 0, UBIFS_BLOCK_SIZE); 1391e51764aSArtem Bityutskiy } else { 1401e51764aSArtem Bityutskiy ret = read_block(inode, addr, block, dn); 1411e51764aSArtem Bityutskiy if (ret) { 1421e51764aSArtem Bityutskiy err = ret; 1431e51764aSArtem Bityutskiy if (err != -ENOENT) 1441e51764aSArtem Bityutskiy break; 145ed382d58SAdrian Hunter } else if (block + 1 == beyond) { 146ed382d58SAdrian Hunter int dlen = le32_to_cpu(dn->size); 147ed382d58SAdrian Hunter int ilen = i_size & (UBIFS_BLOCK_SIZE - 1); 148ed382d58SAdrian Hunter 149ed382d58SAdrian Hunter if (ilen && ilen < dlen) 150ed382d58SAdrian Hunter memset(addr + ilen, 0, dlen - ilen); 1511e51764aSArtem Bityutskiy } 1521e51764aSArtem Bityutskiy } 1531e51764aSArtem Bityutskiy if (++i >= UBIFS_BLOCKS_PER_PAGE) 1541e51764aSArtem Bityutskiy break; 1551e51764aSArtem Bityutskiy block += 1; 1561e51764aSArtem Bityutskiy addr += UBIFS_BLOCK_SIZE; 1571e51764aSArtem Bityutskiy } 1581e51764aSArtem Bityutskiy if (err) { 159235c362bSSheng Yong struct ubifs_info *c = inode->i_sb->s_fs_info; 1601e51764aSArtem Bityutskiy if (err == -ENOENT) { 1611e51764aSArtem Bityutskiy /* Not found, so it must be a hole */ 1621e51764aSArtem Bityutskiy SetPageChecked(page); 1631e51764aSArtem Bityutskiy dbg_gen("hole"); 1641e51764aSArtem Bityutskiy goto out_free; 1651e51764aSArtem Bityutskiy } 166235c362bSSheng Yong ubifs_err(c, "cannot read page %lu of inode %lu, error %d", 1671e51764aSArtem Bityutskiy page->index, inode->i_ino, err); 1681e51764aSArtem Bityutskiy goto error; 1691e51764aSArtem Bityutskiy } 1701e51764aSArtem Bityutskiy 1711e51764aSArtem Bityutskiy out_free: 1721e51764aSArtem Bityutskiy kfree(dn); 1731e51764aSArtem Bityutskiy out: 1741e51764aSArtem Bityutskiy SetPageUptodate(page); 1751e51764aSArtem Bityutskiy ClearPageError(page); 1761e51764aSArtem Bityutskiy flush_dcache_page(page); 1771e51764aSArtem Bityutskiy kunmap(page); 1781e51764aSArtem Bityutskiy return 0; 1791e51764aSArtem Bityutskiy 1801e51764aSArtem Bityutskiy error: 1811e51764aSArtem Bityutskiy kfree(dn); 1821e51764aSArtem Bityutskiy ClearPageUptodate(page); 1831e51764aSArtem Bityutskiy SetPageError(page); 1841e51764aSArtem Bityutskiy flush_dcache_page(page); 1851e51764aSArtem Bityutskiy kunmap(page); 1861e51764aSArtem Bityutskiy return err; 1871e51764aSArtem Bityutskiy } 1881e51764aSArtem Bityutskiy 1891e51764aSArtem Bityutskiy /** 1901e51764aSArtem Bityutskiy * release_new_page_budget - release budget of a new page. 1911e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 1921e51764aSArtem Bityutskiy * 1931e51764aSArtem Bityutskiy * This is a helper function which releases budget corresponding to the budget 1941e51764aSArtem Bityutskiy * of one new page of data. 1951e51764aSArtem Bityutskiy */ 1961e51764aSArtem Bityutskiy static void release_new_page_budget(struct ubifs_info *c) 1971e51764aSArtem Bityutskiy { 1981e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .recalculate = 1, .new_page = 1 }; 1991e51764aSArtem Bityutskiy 2001e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 2011e51764aSArtem Bityutskiy } 2021e51764aSArtem Bityutskiy 2031e51764aSArtem Bityutskiy /** 2041e51764aSArtem Bityutskiy * release_existing_page_budget - release budget of an existing page. 2051e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 2061e51764aSArtem Bityutskiy * 2071e51764aSArtem Bityutskiy * This is a helper function which releases budget corresponding to the budget 208b8f1da98SRandy Dunlap * of changing one page of data which already exists on the flash media. 2091e51764aSArtem Bityutskiy */ 2101e51764aSArtem Bityutskiy static void release_existing_page_budget(struct ubifs_info *c) 2111e51764aSArtem Bityutskiy { 212b137545cSArtem Bityutskiy struct ubifs_budget_req req = { .dd_growth = c->bi.page_budget}; 2131e51764aSArtem Bityutskiy 2141e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 2151e51764aSArtem Bityutskiy } 2161e51764aSArtem Bityutskiy 2171e51764aSArtem Bityutskiy static int write_begin_slow(struct address_space *mapping, 2189d6b0cd7SMatthew Wilcox (Oracle) loff_t pos, unsigned len, struct page **pagep) 2191e51764aSArtem Bityutskiy { 2201e51764aSArtem Bityutskiy struct inode *inode = mapping->host; 2211e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 22209cbfeafSKirill A. Shutemov pgoff_t index = pos >> PAGE_SHIFT; 2231e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .new_page = 1 }; 2243f649ab7SKees Cook int err, appending = !!(pos + len > inode->i_size); 2251e51764aSArtem Bityutskiy struct page *page; 2261e51764aSArtem Bityutskiy 2271e51764aSArtem Bityutskiy dbg_gen("ino %lu, pos %llu, len %u, i_size %lld", 2281e51764aSArtem Bityutskiy inode->i_ino, pos, len, inode->i_size); 2291e51764aSArtem Bityutskiy 2301e51764aSArtem Bityutskiy /* 2311e51764aSArtem Bityutskiy * At the slow path we have to budget before locking the page, because 2321e51764aSArtem Bityutskiy * budgeting may force write-back, which would wait on locked pages and 2331e51764aSArtem Bityutskiy * deadlock if we had the page locked. At this point we do not know 2341e51764aSArtem Bityutskiy * anything about the page, so assume that this is a new page which is 2351e51764aSArtem Bityutskiy * written to a hole. This corresponds to largest budget. Later the 2361e51764aSArtem Bityutskiy * budget will be amended if this is not true. 2371e51764aSArtem Bityutskiy */ 2381e51764aSArtem Bityutskiy if (appending) 2391e51764aSArtem Bityutskiy /* We are appending data, budget for inode change */ 2401e51764aSArtem Bityutskiy req.dirtied_ino = 1; 2411e51764aSArtem Bityutskiy 2421e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req); 2431e51764aSArtem Bityutskiy if (unlikely(err)) 2441e51764aSArtem Bityutskiy return err; 2451e51764aSArtem Bityutskiy 246b7446e7cSMatthew Wilcox (Oracle) page = grab_cache_page_write_begin(mapping, index); 2471e51764aSArtem Bityutskiy if (unlikely(!page)) { 2481e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 2491e51764aSArtem Bityutskiy return -ENOMEM; 2501e51764aSArtem Bityutskiy } 2511e51764aSArtem Bityutskiy 2521e51764aSArtem Bityutskiy if (!PageUptodate(page)) { 25309cbfeafSKirill A. Shutemov if (!(pos & ~PAGE_MASK) && len == PAGE_SIZE) 2541e51764aSArtem Bityutskiy SetPageChecked(page); 2551e51764aSArtem Bityutskiy else { 2561e51764aSArtem Bityutskiy err = do_readpage(page); 2571e51764aSArtem Bityutskiy if (err) { 2581e51764aSArtem Bityutskiy unlock_page(page); 25909cbfeafSKirill A. Shutemov put_page(page); 260789c8993SArtem Bityutskiy ubifs_release_budget(c, &req); 2611e51764aSArtem Bityutskiy return err; 2621e51764aSArtem Bityutskiy } 2631e51764aSArtem Bityutskiy } 2641e51764aSArtem Bityutskiy 2651e51764aSArtem Bityutskiy SetPageUptodate(page); 2661e51764aSArtem Bityutskiy ClearPageError(page); 2671e51764aSArtem Bityutskiy } 2681e51764aSArtem Bityutskiy 2691e51764aSArtem Bityutskiy if (PagePrivate(page)) 2701e51764aSArtem Bityutskiy /* 2711e51764aSArtem Bityutskiy * The page is dirty, which means it was budgeted twice: 2721e51764aSArtem Bityutskiy * o first time the budget was allocated by the task which 2731e51764aSArtem Bityutskiy * made the page dirty and set the PG_private flag; 2741e51764aSArtem Bityutskiy * o and then we budgeted for it for the second time at the 2751e51764aSArtem Bityutskiy * very beginning of this function. 2761e51764aSArtem Bityutskiy * 2771e51764aSArtem Bityutskiy * So what we have to do is to release the page budget we 2781e51764aSArtem Bityutskiy * allocated. 2791e51764aSArtem Bityutskiy */ 2801e51764aSArtem Bityutskiy release_new_page_budget(c); 2811e51764aSArtem Bityutskiy else if (!PageChecked(page)) 2821e51764aSArtem Bityutskiy /* 2831e51764aSArtem Bityutskiy * We are changing a page which already exists on the media. 2841e51764aSArtem Bityutskiy * This means that changing the page does not make the amount 2851e51764aSArtem Bityutskiy * of indexing information larger, and this part of the budget 2861e51764aSArtem Bityutskiy * which we have already acquired may be released. 2871e51764aSArtem Bityutskiy */ 2881e51764aSArtem Bityutskiy ubifs_convert_page_budget(c); 2891e51764aSArtem Bityutskiy 2901e51764aSArtem Bityutskiy if (appending) { 2911e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 2921e51764aSArtem Bityutskiy 2931e51764aSArtem Bityutskiy /* 2941e51764aSArtem Bityutskiy * 'ubifs_write_end()' is optimized from the fast-path part of 2951e51764aSArtem Bityutskiy * 'ubifs_write_begin()' and expects the @ui_mutex to be locked 2961e51764aSArtem Bityutskiy * if data is appended. 2971e51764aSArtem Bityutskiy */ 2981e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 2991e51764aSArtem Bityutskiy if (ui->dirty) 3001e51764aSArtem Bityutskiy /* 3011e51764aSArtem Bityutskiy * The inode is dirty already, so we may free the 3021e51764aSArtem Bityutskiy * budget we allocated. 3031e51764aSArtem Bityutskiy */ 3041e51764aSArtem Bityutskiy ubifs_release_dirty_inode_budget(c, ui); 3051e51764aSArtem Bityutskiy } 3061e51764aSArtem Bityutskiy 3071e51764aSArtem Bityutskiy *pagep = page; 3081e51764aSArtem Bityutskiy return 0; 3091e51764aSArtem Bityutskiy } 3101e51764aSArtem Bityutskiy 3111e51764aSArtem Bityutskiy /** 3121e51764aSArtem Bityutskiy * allocate_budget - allocate budget for 'ubifs_write_begin()'. 3131e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 3141e51764aSArtem Bityutskiy * @page: page to allocate budget for 3151e51764aSArtem Bityutskiy * @ui: UBIFS inode object the page belongs to 3161e51764aSArtem Bityutskiy * @appending: non-zero if the page is appended 3171e51764aSArtem Bityutskiy * 3181e51764aSArtem Bityutskiy * This is a helper function for 'ubifs_write_begin()' which allocates budget 3191e51764aSArtem Bityutskiy * for the operation. The budget is allocated differently depending on whether 3201e51764aSArtem Bityutskiy * this is appending, whether the page is dirty or not, and so on. This 3211e51764aSArtem Bityutskiy * function leaves the @ui->ui_mutex locked in case of appending. Returns zero 3221e51764aSArtem Bityutskiy * in case of success and %-ENOSPC in case of failure. 3231e51764aSArtem Bityutskiy */ 3241e51764aSArtem Bityutskiy static int allocate_budget(struct ubifs_info *c, struct page *page, 3251e51764aSArtem Bityutskiy struct ubifs_inode *ui, int appending) 3261e51764aSArtem Bityutskiy { 3271e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .fast = 1 }; 3281e51764aSArtem Bityutskiy 3291e51764aSArtem Bityutskiy if (PagePrivate(page)) { 3301e51764aSArtem Bityutskiy if (!appending) 3311e51764aSArtem Bityutskiy /* 3321e51764aSArtem Bityutskiy * The page is dirty and we are not appending, which 3331e51764aSArtem Bityutskiy * means no budget is needed at all. 3341e51764aSArtem Bityutskiy */ 3351e51764aSArtem Bityutskiy return 0; 3361e51764aSArtem Bityutskiy 3371e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 3381e51764aSArtem Bityutskiy if (ui->dirty) 3391e51764aSArtem Bityutskiy /* 3401e51764aSArtem Bityutskiy * The page is dirty and we are appending, so the inode 3411e51764aSArtem Bityutskiy * has to be marked as dirty. However, it is already 3421e51764aSArtem Bityutskiy * dirty, so we do not need any budget. We may return, 3431e51764aSArtem Bityutskiy * but @ui->ui_mutex hast to be left locked because we 3441e51764aSArtem Bityutskiy * should prevent write-back from flushing the inode 3451e51764aSArtem Bityutskiy * and freeing the budget. The lock will be released in 3461e51764aSArtem Bityutskiy * 'ubifs_write_end()'. 3471e51764aSArtem Bityutskiy */ 3481e51764aSArtem Bityutskiy return 0; 3491e51764aSArtem Bityutskiy 3501e51764aSArtem Bityutskiy /* 3511e51764aSArtem Bityutskiy * The page is dirty, we are appending, the inode is clean, so 3521e51764aSArtem Bityutskiy * we need to budget the inode change. 3531e51764aSArtem Bityutskiy */ 3541e51764aSArtem Bityutskiy req.dirtied_ino = 1; 3551e51764aSArtem Bityutskiy } else { 3561e51764aSArtem Bityutskiy if (PageChecked(page)) 3571e51764aSArtem Bityutskiy /* 3581e51764aSArtem Bityutskiy * The page corresponds to a hole and does not 3591e51764aSArtem Bityutskiy * exist on the media. So changing it makes 3601e51764aSArtem Bityutskiy * make the amount of indexing information 3611e51764aSArtem Bityutskiy * larger, and we have to budget for a new 3621e51764aSArtem Bityutskiy * page. 3631e51764aSArtem Bityutskiy */ 3641e51764aSArtem Bityutskiy req.new_page = 1; 3651e51764aSArtem Bityutskiy else 3661e51764aSArtem Bityutskiy /* 3671e51764aSArtem Bityutskiy * Not a hole, the change will not add any new 3681e51764aSArtem Bityutskiy * indexing information, budget for page 3691e51764aSArtem Bityutskiy * change. 3701e51764aSArtem Bityutskiy */ 3711e51764aSArtem Bityutskiy req.dirtied_page = 1; 3721e51764aSArtem Bityutskiy 3731e51764aSArtem Bityutskiy if (appending) { 3741e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 3751e51764aSArtem Bityutskiy if (!ui->dirty) 3761e51764aSArtem Bityutskiy /* 3771e51764aSArtem Bityutskiy * The inode is clean but we will have to mark 3781e51764aSArtem Bityutskiy * it as dirty because we are appending. This 3791e51764aSArtem Bityutskiy * needs a budget. 3801e51764aSArtem Bityutskiy */ 3811e51764aSArtem Bityutskiy req.dirtied_ino = 1; 3821e51764aSArtem Bityutskiy } 3831e51764aSArtem Bityutskiy } 3841e51764aSArtem Bityutskiy 3851e51764aSArtem Bityutskiy return ubifs_budget_space(c, &req); 3861e51764aSArtem Bityutskiy } 3871e51764aSArtem Bityutskiy 3881e51764aSArtem Bityutskiy /* 3891e51764aSArtem Bityutskiy * This function is called when a page of data is going to be written. Since 3901e51764aSArtem Bityutskiy * the page of data will not necessarily go to the flash straight away, UBIFS 3911e51764aSArtem Bityutskiy * has to reserve space on the media for it, which is done by means of 3921e51764aSArtem Bityutskiy * budgeting. 3931e51764aSArtem Bityutskiy * 3941e51764aSArtem Bityutskiy * This is the hot-path of the file-system and we are trying to optimize it as 3951e51764aSArtem Bityutskiy * much as possible. For this reasons it is split on 2 parts - slow and fast. 3961e51764aSArtem Bityutskiy * 3971e51764aSArtem Bityutskiy * There many budgeting cases: 3981e51764aSArtem Bityutskiy * o a new page is appended - we have to budget for a new page and for 3991e51764aSArtem Bityutskiy * changing the inode; however, if the inode is already dirty, there is 4001e51764aSArtem Bityutskiy * no need to budget for it; 4011e51764aSArtem Bityutskiy * o an existing clean page is changed - we have budget for it; if the page 4021e51764aSArtem Bityutskiy * does not exist on the media (a hole), we have to budget for a new 4031e51764aSArtem Bityutskiy * page; otherwise, we may budget for changing an existing page; the 4041e51764aSArtem Bityutskiy * difference between these cases is that changing an existing page does 4051e51764aSArtem Bityutskiy * not introduce anything new to the FS indexing information, so it does 4061e51764aSArtem Bityutskiy * not grow, and smaller budget is acquired in this case; 4071e51764aSArtem Bityutskiy * o an existing dirty page is changed - no need to budget at all, because 4081e51764aSArtem Bityutskiy * the page budget has been acquired by earlier, when the page has been 4091e51764aSArtem Bityutskiy * marked dirty. 4101e51764aSArtem Bityutskiy * 4111e51764aSArtem Bityutskiy * UBIFS budgeting sub-system may force write-back if it thinks there is no 4121e51764aSArtem Bityutskiy * space to reserve. This imposes some locking restrictions and makes it 4131e51764aSArtem Bityutskiy * impossible to take into account the above cases, and makes it impossible to 4141e51764aSArtem Bityutskiy * optimize budgeting. 4151e51764aSArtem Bityutskiy * 4161e51764aSArtem Bityutskiy * The solution for this is that the fast path of 'ubifs_write_begin()' assumes 4171e51764aSArtem Bityutskiy * there is a plenty of flash space and the budget will be acquired quickly, 4181e51764aSArtem Bityutskiy * without forcing write-back. The slow path does not make this assumption. 4191e51764aSArtem Bityutskiy */ 4201e51764aSArtem Bityutskiy static int ubifs_write_begin(struct file *file, struct address_space *mapping, 4219d6b0cd7SMatthew Wilcox (Oracle) loff_t pos, unsigned len, 4221e51764aSArtem Bityutskiy struct page **pagep, void **fsdata) 4231e51764aSArtem Bityutskiy { 4241e51764aSArtem Bityutskiy struct inode *inode = mapping->host; 4251e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 4261e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 42709cbfeafSKirill A. Shutemov pgoff_t index = pos >> PAGE_SHIFT; 4283f649ab7SKees Cook int err, appending = !!(pos + len > inode->i_size); 429f55aa591SAdrian Hunter int skipped_read = 0; 4301e51764aSArtem Bityutskiy struct page *page; 4311e51764aSArtem Bityutskiy 4326eb61d58SRichard Weinberger ubifs_assert(c, ubifs_inode(inode)->ui_size == inode->i_size); 4336eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount); 4341e51764aSArtem Bityutskiy 4352680d722SArtem Bityutskiy if (unlikely(c->ro_error)) 4361e51764aSArtem Bityutskiy return -EROFS; 4371e51764aSArtem Bityutskiy 4381e51764aSArtem Bityutskiy /* Try out the fast-path part first */ 439b7446e7cSMatthew Wilcox (Oracle) page = grab_cache_page_write_begin(mapping, index); 4401e51764aSArtem Bityutskiy if (unlikely(!page)) 4411e51764aSArtem Bityutskiy return -ENOMEM; 4421e51764aSArtem Bityutskiy 4431e51764aSArtem Bityutskiy if (!PageUptodate(page)) { 4441e51764aSArtem Bityutskiy /* The page is not loaded from the flash */ 44509cbfeafSKirill A. Shutemov if (!(pos & ~PAGE_MASK) && len == PAGE_SIZE) { 4461e51764aSArtem Bityutskiy /* 4471e51764aSArtem Bityutskiy * We change whole page so no need to load it. But we 4486ed09c34SArtem Bityutskiy * do not know whether this page exists on the media or 4496ed09c34SArtem Bityutskiy * not, so we assume the latter because it requires 4506ed09c34SArtem Bityutskiy * larger budget. The assumption is that it is better 4516ed09c34SArtem Bityutskiy * to budget a bit more than to read the page from the 4526ed09c34SArtem Bityutskiy * media. Thus, we are setting the @PG_checked flag 4536ed09c34SArtem Bityutskiy * here. 4541e51764aSArtem Bityutskiy */ 4551e51764aSArtem Bityutskiy SetPageChecked(page); 456f55aa591SAdrian Hunter skipped_read = 1; 457f55aa591SAdrian Hunter } else { 4581e51764aSArtem Bityutskiy err = do_readpage(page); 4591e51764aSArtem Bityutskiy if (err) { 4601e51764aSArtem Bityutskiy unlock_page(page); 46109cbfeafSKirill A. Shutemov put_page(page); 4621e51764aSArtem Bityutskiy return err; 4631e51764aSArtem Bityutskiy } 4641e51764aSArtem Bityutskiy } 4651e51764aSArtem Bityutskiy 4661e51764aSArtem Bityutskiy SetPageUptodate(page); 4671e51764aSArtem Bityutskiy ClearPageError(page); 4681e51764aSArtem Bityutskiy } 4691e51764aSArtem Bityutskiy 4701e51764aSArtem Bityutskiy err = allocate_budget(c, page, ui, appending); 4711e51764aSArtem Bityutskiy if (unlikely(err)) { 4726eb61d58SRichard Weinberger ubifs_assert(c, err == -ENOSPC); 4731e51764aSArtem Bityutskiy /* 474f55aa591SAdrian Hunter * If we skipped reading the page because we were going to 475f55aa591SAdrian Hunter * write all of it, then it is not up to date. 476f55aa591SAdrian Hunter */ 477f55aa591SAdrian Hunter if (skipped_read) { 478f55aa591SAdrian Hunter ClearPageChecked(page); 479f55aa591SAdrian Hunter ClearPageUptodate(page); 480f55aa591SAdrian Hunter } 481f55aa591SAdrian Hunter /* 4821e51764aSArtem Bityutskiy * Budgeting failed which means it would have to force 4831e51764aSArtem Bityutskiy * write-back but didn't, because we set the @fast flag in the 4841e51764aSArtem Bityutskiy * request. Write-back cannot be done now, while we have the 4851e51764aSArtem Bityutskiy * page locked, because it would deadlock. Unlock and free 4861e51764aSArtem Bityutskiy * everything and fall-back to slow-path. 4871e51764aSArtem Bityutskiy */ 4881e51764aSArtem Bityutskiy if (appending) { 4896eb61d58SRichard Weinberger ubifs_assert(c, mutex_is_locked(&ui->ui_mutex)); 4901e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 4911e51764aSArtem Bityutskiy } 4921e51764aSArtem Bityutskiy unlock_page(page); 49309cbfeafSKirill A. Shutemov put_page(page); 4941e51764aSArtem Bityutskiy 4959d6b0cd7SMatthew Wilcox (Oracle) return write_begin_slow(mapping, pos, len, pagep); 4961e51764aSArtem Bityutskiy } 4971e51764aSArtem Bityutskiy 4981e51764aSArtem Bityutskiy /* 499873a64c7SArtem Bityutskiy * Whee, we acquired budgeting quickly - without involving 500873a64c7SArtem Bityutskiy * garbage-collection, committing or forcing write-back. We return 5011e51764aSArtem Bityutskiy * with @ui->ui_mutex locked if we are appending pages, and unlocked 5021e51764aSArtem Bityutskiy * otherwise. This is an optimization (slightly hacky though). 5031e51764aSArtem Bityutskiy */ 5041e51764aSArtem Bityutskiy *pagep = page; 5051e51764aSArtem Bityutskiy return 0; 5061e51764aSArtem Bityutskiy 5071e51764aSArtem Bityutskiy } 5081e51764aSArtem Bityutskiy 5091e51764aSArtem Bityutskiy /** 5101e51764aSArtem Bityutskiy * cancel_budget - cancel budget. 5111e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 5121e51764aSArtem Bityutskiy * @page: page to cancel budget for 5131e51764aSArtem Bityutskiy * @ui: UBIFS inode object the page belongs to 5141e51764aSArtem Bityutskiy * @appending: non-zero if the page is appended 5151e51764aSArtem Bityutskiy * 5161e51764aSArtem Bityutskiy * This is a helper function for a page write operation. It unlocks the 5171e51764aSArtem Bityutskiy * @ui->ui_mutex in case of appending. 5181e51764aSArtem Bityutskiy */ 5191e51764aSArtem Bityutskiy static void cancel_budget(struct ubifs_info *c, struct page *page, 5201e51764aSArtem Bityutskiy struct ubifs_inode *ui, int appending) 5211e51764aSArtem Bityutskiy { 5221e51764aSArtem Bityutskiy if (appending) { 5231e51764aSArtem Bityutskiy if (!ui->dirty) 5241e51764aSArtem Bityutskiy ubifs_release_dirty_inode_budget(c, ui); 5251e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 5261e51764aSArtem Bityutskiy } 5271e51764aSArtem Bityutskiy if (!PagePrivate(page)) { 5281e51764aSArtem Bityutskiy if (PageChecked(page)) 5291e51764aSArtem Bityutskiy release_new_page_budget(c); 5301e51764aSArtem Bityutskiy else 5311e51764aSArtem Bityutskiy release_existing_page_budget(c); 5321e51764aSArtem Bityutskiy } 5331e51764aSArtem Bityutskiy } 5341e51764aSArtem Bityutskiy 5351e51764aSArtem Bityutskiy static int ubifs_write_end(struct file *file, struct address_space *mapping, 5361e51764aSArtem Bityutskiy loff_t pos, unsigned len, unsigned copied, 5371e51764aSArtem Bityutskiy struct page *page, void *fsdata) 5381e51764aSArtem Bityutskiy { 5391e51764aSArtem Bityutskiy struct inode *inode = mapping->host; 5401e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 5411e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 5421e51764aSArtem Bityutskiy loff_t end_pos = pos + len; 5431e51764aSArtem Bityutskiy int appending = !!(end_pos > inode->i_size); 5441e51764aSArtem Bityutskiy 5451e51764aSArtem Bityutskiy dbg_gen("ino %lu, pos %llu, pg %lu, len %u, copied %d, i_size %lld", 5461e51764aSArtem Bityutskiy inode->i_ino, pos, page->index, len, copied, inode->i_size); 5471e51764aSArtem Bityutskiy 54809cbfeafSKirill A. Shutemov if (unlikely(copied < len && len == PAGE_SIZE)) { 5491e51764aSArtem Bityutskiy /* 5501e51764aSArtem Bityutskiy * VFS copied less data to the page that it intended and 5511e51764aSArtem Bityutskiy * declared in its '->write_begin()' call via the @len 5521e51764aSArtem Bityutskiy * argument. If the page was not up-to-date, and @len was 553ea1754a0SKirill A. Shutemov * @PAGE_SIZE, the 'ubifs_write_begin()' function did 5541e51764aSArtem Bityutskiy * not load it from the media (for optimization reasons). This 5551e51764aSArtem Bityutskiy * means that part of the page contains garbage. So read the 5561e51764aSArtem Bityutskiy * page now. 5571e51764aSArtem Bityutskiy */ 5581e51764aSArtem Bityutskiy dbg_gen("copied %d instead of %d, read page and repeat", 5591e51764aSArtem Bityutskiy copied, len); 5601e51764aSArtem Bityutskiy cancel_budget(c, page, ui, appending); 5616ed09c34SArtem Bityutskiy ClearPageChecked(page); 5621e51764aSArtem Bityutskiy 5631e51764aSArtem Bityutskiy /* 5641e51764aSArtem Bityutskiy * Return 0 to force VFS to repeat the whole operation, or the 565873a64c7SArtem Bityutskiy * error code if 'do_readpage()' fails. 5661e51764aSArtem Bityutskiy */ 5671e51764aSArtem Bityutskiy copied = do_readpage(page); 5681e51764aSArtem Bityutskiy goto out; 5691e51764aSArtem Bityutskiy } 5701e51764aSArtem Bityutskiy 5711e51764aSArtem Bityutskiy if (!PagePrivate(page)) { 5723b67db8aSZhihao Cheng attach_page_private(page, (void *)1); 5731e51764aSArtem Bityutskiy atomic_long_inc(&c->dirty_pg_cnt); 5741e51764aSArtem Bityutskiy __set_page_dirty_nobuffers(page); 5751e51764aSArtem Bityutskiy } 5761e51764aSArtem Bityutskiy 5771e51764aSArtem Bityutskiy if (appending) { 5781e51764aSArtem Bityutskiy i_size_write(inode, end_pos); 5791e51764aSArtem Bityutskiy ui->ui_size = end_pos; 5801e51764aSArtem Bityutskiy /* 5811e51764aSArtem Bityutskiy * Note, we do not set @I_DIRTY_PAGES (which means that the 5821e51764aSArtem Bityutskiy * inode has dirty pages), this has been done in 5831e51764aSArtem Bityutskiy * '__set_page_dirty_nobuffers()'. 5841e51764aSArtem Bityutskiy */ 5851e51764aSArtem Bityutskiy __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 5866eb61d58SRichard Weinberger ubifs_assert(c, mutex_is_locked(&ui->ui_mutex)); 5871e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 5881e51764aSArtem Bityutskiy } 5891e51764aSArtem Bityutskiy 5901e51764aSArtem Bityutskiy out: 5911e51764aSArtem Bityutskiy unlock_page(page); 59209cbfeafSKirill A. Shutemov put_page(page); 5931e51764aSArtem Bityutskiy return copied; 5941e51764aSArtem Bityutskiy } 5951e51764aSArtem Bityutskiy 5964793e7c5SAdrian Hunter /** 5974793e7c5SAdrian Hunter * populate_page - copy data nodes into a page for bulk-read. 5984793e7c5SAdrian Hunter * @c: UBIFS file-system description object 5994793e7c5SAdrian Hunter * @page: page 6004793e7c5SAdrian Hunter * @bu: bulk-read information 6014793e7c5SAdrian Hunter * @n: next zbranch slot 6024793e7c5SAdrian Hunter * 6034793e7c5SAdrian Hunter * This function returns %0 on success and a negative error code on failure. 6044793e7c5SAdrian Hunter */ 6054793e7c5SAdrian Hunter static int populate_page(struct ubifs_info *c, struct page *page, 6064793e7c5SAdrian Hunter struct bu_info *bu, int *n) 6074793e7c5SAdrian Hunter { 6085c0013c1SAdrian Hunter int i = 0, nn = *n, offs = bu->zbranch[0].offs, hole = 0, read = 0; 6094793e7c5SAdrian Hunter struct inode *inode = page->mapping->host; 6104793e7c5SAdrian Hunter loff_t i_size = i_size_read(inode); 6114793e7c5SAdrian Hunter unsigned int page_block; 6124793e7c5SAdrian Hunter void *addr, *zaddr; 6134793e7c5SAdrian Hunter pgoff_t end_index; 6144793e7c5SAdrian Hunter 6154793e7c5SAdrian Hunter dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx", 6164793e7c5SAdrian Hunter inode->i_ino, page->index, i_size, page->flags); 6174793e7c5SAdrian Hunter 6184793e7c5SAdrian Hunter addr = zaddr = kmap(page); 6194793e7c5SAdrian Hunter 62009cbfeafSKirill A. Shutemov end_index = (i_size - 1) >> PAGE_SHIFT; 6214793e7c5SAdrian Hunter if (!i_size || page->index > end_index) { 6225c0013c1SAdrian Hunter hole = 1; 62309cbfeafSKirill A. Shutemov memset(addr, 0, PAGE_SIZE); 6244793e7c5SAdrian Hunter goto out_hole; 6254793e7c5SAdrian Hunter } 6264793e7c5SAdrian Hunter 6274793e7c5SAdrian Hunter page_block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT; 6284793e7c5SAdrian Hunter while (1) { 6294793e7c5SAdrian Hunter int err, len, out_len, dlen; 6304793e7c5SAdrian Hunter 6315c0013c1SAdrian Hunter if (nn >= bu->cnt) { 6325c0013c1SAdrian Hunter hole = 1; 6334793e7c5SAdrian Hunter memset(addr, 0, UBIFS_BLOCK_SIZE); 6345c0013c1SAdrian Hunter } else if (key_block(c, &bu->zbranch[nn].key) == page_block) { 6354793e7c5SAdrian Hunter struct ubifs_data_node *dn; 6364793e7c5SAdrian Hunter 6374793e7c5SAdrian Hunter dn = bu->buf + (bu->zbranch[nn].offs - offs); 6384793e7c5SAdrian Hunter 6396eb61d58SRichard Weinberger ubifs_assert(c, le64_to_cpu(dn->ch.sqnum) > 6404793e7c5SAdrian Hunter ubifs_inode(inode)->creat_sqnum); 6414793e7c5SAdrian Hunter 6424793e7c5SAdrian Hunter len = le32_to_cpu(dn->size); 6434793e7c5SAdrian Hunter if (len <= 0 || len > UBIFS_BLOCK_SIZE) 6444793e7c5SAdrian Hunter goto out_err; 6454793e7c5SAdrian Hunter 6464793e7c5SAdrian Hunter dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ; 6474793e7c5SAdrian Hunter out_len = UBIFS_BLOCK_SIZE; 6487799953bSRichard Weinberger 64950d9fad7SEric Biggers if (IS_ENCRYPTED(inode)) { 6507799953bSRichard Weinberger err = ubifs_decrypt(inode, dn, &dlen, page_block); 6517799953bSRichard Weinberger if (err) 6527799953bSRichard Weinberger goto out_err; 6537799953bSRichard Weinberger } 6547799953bSRichard Weinberger 655235c362bSSheng Yong err = ubifs_decompress(c, &dn->data, dlen, addr, &out_len, 6564793e7c5SAdrian Hunter le16_to_cpu(dn->compr_type)); 6574793e7c5SAdrian Hunter if (err || len != out_len) 6584793e7c5SAdrian Hunter goto out_err; 6594793e7c5SAdrian Hunter 6604793e7c5SAdrian Hunter if (len < UBIFS_BLOCK_SIZE) 6614793e7c5SAdrian Hunter memset(addr + len, 0, UBIFS_BLOCK_SIZE - len); 6624793e7c5SAdrian Hunter 6634793e7c5SAdrian Hunter nn += 1; 6644793e7c5SAdrian Hunter read = (i << UBIFS_BLOCK_SHIFT) + len; 6655c0013c1SAdrian Hunter } else if (key_block(c, &bu->zbranch[nn].key) < page_block) { 6665c0013c1SAdrian Hunter nn += 1; 6675c0013c1SAdrian Hunter continue; 6685c0013c1SAdrian Hunter } else { 6695c0013c1SAdrian Hunter hole = 1; 6705c0013c1SAdrian Hunter memset(addr, 0, UBIFS_BLOCK_SIZE); 6714793e7c5SAdrian Hunter } 6724793e7c5SAdrian Hunter if (++i >= UBIFS_BLOCKS_PER_PAGE) 6734793e7c5SAdrian Hunter break; 6744793e7c5SAdrian Hunter addr += UBIFS_BLOCK_SIZE; 6754793e7c5SAdrian Hunter page_block += 1; 6764793e7c5SAdrian Hunter } 6774793e7c5SAdrian Hunter 6784793e7c5SAdrian Hunter if (end_index == page->index) { 67909cbfeafSKirill A. Shutemov int len = i_size & (PAGE_SIZE - 1); 6804793e7c5SAdrian Hunter 681ed382d58SAdrian Hunter if (len && len < read) 6824793e7c5SAdrian Hunter memset(zaddr + len, 0, read - len); 6834793e7c5SAdrian Hunter } 6844793e7c5SAdrian Hunter 6854793e7c5SAdrian Hunter out_hole: 6864793e7c5SAdrian Hunter if (hole) { 6874793e7c5SAdrian Hunter SetPageChecked(page); 6884793e7c5SAdrian Hunter dbg_gen("hole"); 6894793e7c5SAdrian Hunter } 6904793e7c5SAdrian Hunter 6914793e7c5SAdrian Hunter SetPageUptodate(page); 6924793e7c5SAdrian Hunter ClearPageError(page); 6934793e7c5SAdrian Hunter flush_dcache_page(page); 6944793e7c5SAdrian Hunter kunmap(page); 6954793e7c5SAdrian Hunter *n = nn; 6964793e7c5SAdrian Hunter return 0; 6974793e7c5SAdrian Hunter 6984793e7c5SAdrian Hunter out_err: 6994793e7c5SAdrian Hunter ClearPageUptodate(page); 7004793e7c5SAdrian Hunter SetPageError(page); 7014793e7c5SAdrian Hunter flush_dcache_page(page); 7024793e7c5SAdrian Hunter kunmap(page); 703235c362bSSheng Yong ubifs_err(c, "bad data node (block %u, inode %lu)", 7044793e7c5SAdrian Hunter page_block, inode->i_ino); 7054793e7c5SAdrian Hunter return -EINVAL; 7064793e7c5SAdrian Hunter } 7074793e7c5SAdrian Hunter 7084793e7c5SAdrian Hunter /** 7094793e7c5SAdrian Hunter * ubifs_do_bulk_read - do bulk-read. 7104793e7c5SAdrian Hunter * @c: UBIFS file-system description object 7116c0c42cdSArtem Bityutskiy * @bu: bulk-read information 7126c0c42cdSArtem Bityutskiy * @page1: first page to read 7134793e7c5SAdrian Hunter * 7144793e7c5SAdrian Hunter * This function returns %1 if the bulk-read is done, otherwise %0 is returned. 7154793e7c5SAdrian Hunter */ 7166c0c42cdSArtem Bityutskiy static int ubifs_do_bulk_read(struct ubifs_info *c, struct bu_info *bu, 7176c0c42cdSArtem Bityutskiy struct page *page1) 7184793e7c5SAdrian Hunter { 7194793e7c5SAdrian Hunter pgoff_t offset = page1->index, end_index; 7204793e7c5SAdrian Hunter struct address_space *mapping = page1->mapping; 7214793e7c5SAdrian Hunter struct inode *inode = mapping->host; 7224793e7c5SAdrian Hunter struct ubifs_inode *ui = ubifs_inode(inode); 7234793e7c5SAdrian Hunter int err, page_idx, page_cnt, ret = 0, n = 0; 7246c0c42cdSArtem Bityutskiy int allocate = bu->buf ? 0 : 1; 7254793e7c5SAdrian Hunter loff_t isize; 726480a1a6aSHyunchul Lee gfp_t ra_gfp_mask = readahead_gfp_mask(mapping) & ~__GFP_FS; 7274793e7c5SAdrian Hunter 7284793e7c5SAdrian Hunter err = ubifs_tnc_get_bu_keys(c, bu); 7294793e7c5SAdrian Hunter if (err) 7304793e7c5SAdrian Hunter goto out_warn; 7314793e7c5SAdrian Hunter 7324793e7c5SAdrian Hunter if (bu->eof) { 7334793e7c5SAdrian Hunter /* Turn off bulk-read at the end of the file */ 7344793e7c5SAdrian Hunter ui->read_in_a_row = 1; 7354793e7c5SAdrian Hunter ui->bulk_read = 0; 7364793e7c5SAdrian Hunter } 7374793e7c5SAdrian Hunter 7384793e7c5SAdrian Hunter page_cnt = bu->blk_cnt >> UBIFS_BLOCKS_PER_PAGE_SHIFT; 7394793e7c5SAdrian Hunter if (!page_cnt) { 7404793e7c5SAdrian Hunter /* 7414793e7c5SAdrian Hunter * This happens when there are multiple blocks per page and the 7424793e7c5SAdrian Hunter * blocks for the first page we are looking for, are not 7434793e7c5SAdrian Hunter * together. If all the pages were like this, bulk-read would 7444793e7c5SAdrian Hunter * reduce performance, so we turn it off for a while. 7454793e7c5SAdrian Hunter */ 7466c0c42cdSArtem Bityutskiy goto out_bu_off; 7474793e7c5SAdrian Hunter } 7484793e7c5SAdrian Hunter 7494793e7c5SAdrian Hunter if (bu->cnt) { 7506c0c42cdSArtem Bityutskiy if (allocate) { 7516c0c42cdSArtem Bityutskiy /* 7526c0c42cdSArtem Bityutskiy * Allocate bulk-read buffer depending on how many data 7536c0c42cdSArtem Bityutskiy * nodes we are going to read. 7546c0c42cdSArtem Bityutskiy */ 7556c0c42cdSArtem Bityutskiy bu->buf_len = bu->zbranch[bu->cnt - 1].offs + 7566c0c42cdSArtem Bityutskiy bu->zbranch[bu->cnt - 1].len - 7576c0c42cdSArtem Bityutskiy bu->zbranch[0].offs; 7586eb61d58SRichard Weinberger ubifs_assert(c, bu->buf_len > 0); 7596eb61d58SRichard Weinberger ubifs_assert(c, bu->buf_len <= c->leb_size); 7606c0c42cdSArtem Bityutskiy bu->buf = kmalloc(bu->buf_len, GFP_NOFS | __GFP_NOWARN); 7616c0c42cdSArtem Bityutskiy if (!bu->buf) 7626c0c42cdSArtem Bityutskiy goto out_bu_off; 7636c0c42cdSArtem Bityutskiy } 7646c0c42cdSArtem Bityutskiy 7654793e7c5SAdrian Hunter err = ubifs_tnc_bulk_read(c, bu); 7664793e7c5SAdrian Hunter if (err) 7674793e7c5SAdrian Hunter goto out_warn; 7684793e7c5SAdrian Hunter } 7694793e7c5SAdrian Hunter 7704793e7c5SAdrian Hunter err = populate_page(c, page1, bu, &n); 7714793e7c5SAdrian Hunter if (err) 7724793e7c5SAdrian Hunter goto out_warn; 7734793e7c5SAdrian Hunter 7744793e7c5SAdrian Hunter unlock_page(page1); 7754793e7c5SAdrian Hunter ret = 1; 7764793e7c5SAdrian Hunter 7774793e7c5SAdrian Hunter isize = i_size_read(inode); 7784793e7c5SAdrian Hunter if (isize == 0) 7794793e7c5SAdrian Hunter goto out_free; 78009cbfeafSKirill A. Shutemov end_index = ((isize - 1) >> PAGE_SHIFT); 7814793e7c5SAdrian Hunter 7824793e7c5SAdrian Hunter for (page_idx = 1; page_idx < page_cnt; page_idx++) { 7834793e7c5SAdrian Hunter pgoff_t page_offset = offset + page_idx; 7844793e7c5SAdrian Hunter struct page *page; 7854793e7c5SAdrian Hunter 7864793e7c5SAdrian Hunter if (page_offset > end_index) 7874793e7c5SAdrian Hunter break; 788f5de5b83SZhihao Cheng page = pagecache_get_page(mapping, page_offset, 789f5de5b83SZhihao Cheng FGP_LOCK|FGP_ACCESSED|FGP_CREAT|FGP_NOWAIT, 790f5de5b83SZhihao Cheng ra_gfp_mask); 7914793e7c5SAdrian Hunter if (!page) 7924793e7c5SAdrian Hunter break; 7934793e7c5SAdrian Hunter if (!PageUptodate(page)) 7944793e7c5SAdrian Hunter err = populate_page(c, page, bu, &n); 7954793e7c5SAdrian Hunter unlock_page(page); 79609cbfeafSKirill A. Shutemov put_page(page); 7974793e7c5SAdrian Hunter if (err) 7984793e7c5SAdrian Hunter break; 7994793e7c5SAdrian Hunter } 8004793e7c5SAdrian Hunter 8014793e7c5SAdrian Hunter ui->last_page_read = offset + page_idx - 1; 8024793e7c5SAdrian Hunter 8034793e7c5SAdrian Hunter out_free: 8046c0c42cdSArtem Bityutskiy if (allocate) 8054793e7c5SAdrian Hunter kfree(bu->buf); 8064793e7c5SAdrian Hunter return ret; 8074793e7c5SAdrian Hunter 8084793e7c5SAdrian Hunter out_warn: 809235c362bSSheng Yong ubifs_warn(c, "ignoring error %d and skipping bulk-read", err); 8104793e7c5SAdrian Hunter goto out_free; 8116c0c42cdSArtem Bityutskiy 8126c0c42cdSArtem Bityutskiy out_bu_off: 8136c0c42cdSArtem Bityutskiy ui->read_in_a_row = ui->bulk_read = 0; 8146c0c42cdSArtem Bityutskiy goto out_free; 8154793e7c5SAdrian Hunter } 8164793e7c5SAdrian Hunter 8174793e7c5SAdrian Hunter /** 8184793e7c5SAdrian Hunter * ubifs_bulk_read - determine whether to bulk-read and, if so, do it. 8194793e7c5SAdrian Hunter * @page: page from which to start bulk-read. 8204793e7c5SAdrian Hunter * 8214793e7c5SAdrian Hunter * Some flash media are capable of reading sequentially at faster rates. UBIFS 8224793e7c5SAdrian Hunter * bulk-read facility is designed to take advantage of that, by reading in one 8234793e7c5SAdrian Hunter * go consecutive data nodes that are also located consecutively in the same 8244793e7c5SAdrian Hunter * LEB. This function returns %1 if a bulk-read is done and %0 otherwise. 8254793e7c5SAdrian Hunter */ 8264793e7c5SAdrian Hunter static int ubifs_bulk_read(struct page *page) 8274793e7c5SAdrian Hunter { 8284793e7c5SAdrian Hunter struct inode *inode = page->mapping->host; 8294793e7c5SAdrian Hunter struct ubifs_info *c = inode->i_sb->s_fs_info; 8304793e7c5SAdrian Hunter struct ubifs_inode *ui = ubifs_inode(inode); 8314793e7c5SAdrian Hunter pgoff_t index = page->index, last_page_read = ui->last_page_read; 8326c0c42cdSArtem Bityutskiy struct bu_info *bu; 8333477d204SArtem Bityutskiy int err = 0, allocated = 0; 8344793e7c5SAdrian Hunter 8354793e7c5SAdrian Hunter ui->last_page_read = index; 8364793e7c5SAdrian Hunter if (!c->bulk_read) 8374793e7c5SAdrian Hunter return 0; 8386c0c42cdSArtem Bityutskiy 8394793e7c5SAdrian Hunter /* 8403477d204SArtem Bityutskiy * Bulk-read is protected by @ui->ui_mutex, but it is an optimization, 8413477d204SArtem Bityutskiy * so don't bother if we cannot lock the mutex. 8424793e7c5SAdrian Hunter */ 8434793e7c5SAdrian Hunter if (!mutex_trylock(&ui->ui_mutex)) 8444793e7c5SAdrian Hunter return 0; 8456c0c42cdSArtem Bityutskiy 8464793e7c5SAdrian Hunter if (index != last_page_read + 1) { 8474793e7c5SAdrian Hunter /* Turn off bulk-read if we stop reading sequentially */ 8484793e7c5SAdrian Hunter ui->read_in_a_row = 1; 8494793e7c5SAdrian Hunter if (ui->bulk_read) 8504793e7c5SAdrian Hunter ui->bulk_read = 0; 8514793e7c5SAdrian Hunter goto out_unlock; 8524793e7c5SAdrian Hunter } 8536c0c42cdSArtem Bityutskiy 8544793e7c5SAdrian Hunter if (!ui->bulk_read) { 8554793e7c5SAdrian Hunter ui->read_in_a_row += 1; 8564793e7c5SAdrian Hunter if (ui->read_in_a_row < 3) 8574793e7c5SAdrian Hunter goto out_unlock; 8584793e7c5SAdrian Hunter /* Three reads in a row, so switch on bulk-read */ 8594793e7c5SAdrian Hunter ui->bulk_read = 1; 8604793e7c5SAdrian Hunter } 8616c0c42cdSArtem Bityutskiy 8623477d204SArtem Bityutskiy /* 8633477d204SArtem Bityutskiy * If possible, try to use pre-allocated bulk-read information, which 8643477d204SArtem Bityutskiy * is protected by @c->bu_mutex. 8653477d204SArtem Bityutskiy */ 8663477d204SArtem Bityutskiy if (mutex_trylock(&c->bu_mutex)) 8673477d204SArtem Bityutskiy bu = &c->bu; 8683477d204SArtem Bityutskiy else { 8696c0c42cdSArtem Bityutskiy bu = kmalloc(sizeof(struct bu_info), GFP_NOFS | __GFP_NOWARN); 8706c0c42cdSArtem Bityutskiy if (!bu) 8713477d204SArtem Bityutskiy goto out_unlock; 8726c0c42cdSArtem Bityutskiy 8736c0c42cdSArtem Bityutskiy bu->buf = NULL; 8743477d204SArtem Bityutskiy allocated = 1; 8753477d204SArtem Bityutskiy } 8763477d204SArtem Bityutskiy 8776c0c42cdSArtem Bityutskiy bu->buf_len = c->max_bu_buf_len; 8786c0c42cdSArtem Bityutskiy data_key_init(c, &bu->key, inode->i_ino, 8796c0c42cdSArtem Bityutskiy page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT); 8806c0c42cdSArtem Bityutskiy err = ubifs_do_bulk_read(c, bu, page); 8813477d204SArtem Bityutskiy 8823477d204SArtem Bityutskiy if (!allocated) 8833477d204SArtem Bityutskiy mutex_unlock(&c->bu_mutex); 8843477d204SArtem Bityutskiy else 8856c0c42cdSArtem Bityutskiy kfree(bu); 8866c0c42cdSArtem Bityutskiy 8874793e7c5SAdrian Hunter out_unlock: 8884793e7c5SAdrian Hunter mutex_unlock(&ui->ui_mutex); 8896c0c42cdSArtem Bityutskiy return err; 8904793e7c5SAdrian Hunter } 8914793e7c5SAdrian Hunter 8920b7bf483SMatthew Wilcox (Oracle) static int ubifs_read_folio(struct file *file, struct folio *folio) 8931e51764aSArtem Bityutskiy { 8940b7bf483SMatthew Wilcox (Oracle) struct page *page = &folio->page; 8950b7bf483SMatthew Wilcox (Oracle) 8964793e7c5SAdrian Hunter if (ubifs_bulk_read(page)) 8974793e7c5SAdrian Hunter return 0; 8981e51764aSArtem Bityutskiy do_readpage(page); 8990b7bf483SMatthew Wilcox (Oracle) folio_unlock(folio); 9001e51764aSArtem Bityutskiy return 0; 9011e51764aSArtem Bityutskiy } 9021e51764aSArtem Bityutskiy 9031e51764aSArtem Bityutskiy static int do_writepage(struct page *page, int len) 9041e51764aSArtem Bityutskiy { 9051e51764aSArtem Bityutskiy int err = 0, i, blen; 9061e51764aSArtem Bityutskiy unsigned int block; 9071e51764aSArtem Bityutskiy void *addr; 9081e51764aSArtem Bityutskiy union ubifs_key key; 9091e51764aSArtem Bityutskiy struct inode *inode = page->mapping->host; 9101e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 9111e51764aSArtem Bityutskiy 9121e51764aSArtem Bityutskiy #ifdef UBIFS_DEBUG 913a0fd5951SDaniel Golle struct ubifs_inode *ui = ubifs_inode(inode); 9141e51764aSArtem Bityutskiy spin_lock(&ui->ui_lock); 9156eb61d58SRichard Weinberger ubifs_assert(c, page->index <= ui->synced_i_size >> PAGE_SHIFT); 9161e51764aSArtem Bityutskiy spin_unlock(&ui->ui_lock); 9171e51764aSArtem Bityutskiy #endif 9181e51764aSArtem Bityutskiy 9191e51764aSArtem Bityutskiy /* Update radix tree tags */ 9201e51764aSArtem Bityutskiy set_page_writeback(page); 9211e51764aSArtem Bityutskiy 9221e51764aSArtem Bityutskiy addr = kmap(page); 9231e51764aSArtem Bityutskiy block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT; 9241e51764aSArtem Bityutskiy i = 0; 9251e51764aSArtem Bityutskiy while (len) { 9261e51764aSArtem Bityutskiy blen = min_t(int, len, UBIFS_BLOCK_SIZE); 9271e51764aSArtem Bityutskiy data_key_init(c, &key, inode->i_ino, block); 9281e51764aSArtem Bityutskiy err = ubifs_jnl_write_data(c, inode, &key, addr, blen); 9291e51764aSArtem Bityutskiy if (err) 9301e51764aSArtem Bityutskiy break; 9311e51764aSArtem Bityutskiy if (++i >= UBIFS_BLOCKS_PER_PAGE) 9321e51764aSArtem Bityutskiy break; 9331e51764aSArtem Bityutskiy block += 1; 9341e51764aSArtem Bityutskiy addr += blen; 9351e51764aSArtem Bityutskiy len -= blen; 9361e51764aSArtem Bityutskiy } 9371e51764aSArtem Bityutskiy if (err) { 9381e51764aSArtem Bityutskiy SetPageError(page); 939235c362bSSheng Yong ubifs_err(c, "cannot write page %lu of inode %lu, error %d", 9401e51764aSArtem Bityutskiy page->index, inode->i_ino, err); 9411e51764aSArtem Bityutskiy ubifs_ro_mode(c, err); 9421e51764aSArtem Bityutskiy } 9431e51764aSArtem Bityutskiy 9446eb61d58SRichard Weinberger ubifs_assert(c, PagePrivate(page)); 9451e51764aSArtem Bityutskiy if (PageChecked(page)) 9461e51764aSArtem Bityutskiy release_new_page_budget(c); 9471e51764aSArtem Bityutskiy else 9481e51764aSArtem Bityutskiy release_existing_page_budget(c); 9491e51764aSArtem Bityutskiy 9501e51764aSArtem Bityutskiy atomic_long_dec(&c->dirty_pg_cnt); 9513b67db8aSZhihao Cheng detach_page_private(page); 9521e51764aSArtem Bityutskiy ClearPageChecked(page); 9531e51764aSArtem Bityutskiy 9541e51764aSArtem Bityutskiy kunmap(page); 9551e51764aSArtem Bityutskiy unlock_page(page); 9561e51764aSArtem Bityutskiy end_page_writeback(page); 9571e51764aSArtem Bityutskiy return err; 9581e51764aSArtem Bityutskiy } 9591e51764aSArtem Bityutskiy 9601e51764aSArtem Bityutskiy /* 9611e51764aSArtem Bityutskiy * When writing-back dirty inodes, VFS first writes-back pages belonging to the 9621e51764aSArtem Bityutskiy * inode, then the inode itself. For UBIFS this may cause a problem. Consider a 9631e51764aSArtem Bityutskiy * situation when a we have an inode with size 0, then a megabyte of data is 9641e51764aSArtem Bityutskiy * appended to the inode, then write-back starts and flushes some amount of the 9651e51764aSArtem Bityutskiy * dirty pages, the journal becomes full, commit happens and finishes, and then 9661e51764aSArtem Bityutskiy * an unclean reboot happens. When the file system is mounted next time, the 9671e51764aSArtem Bityutskiy * inode size would still be 0, but there would be many pages which are beyond 9681e51764aSArtem Bityutskiy * the inode size, they would be indexed and consume flash space. Because the 9691e51764aSArtem Bityutskiy * journal has been committed, the replay would not be able to detect this 9701e51764aSArtem Bityutskiy * situation and correct the inode size. This means UBIFS would have to scan 9711e51764aSArtem Bityutskiy * whole index and correct all inode sizes, which is long an unacceptable. 9721e51764aSArtem Bityutskiy * 9731e51764aSArtem Bityutskiy * To prevent situations like this, UBIFS writes pages back only if they are 9747d4e9ccbSArtem Bityutskiy * within the last synchronized inode size, i.e. the size which has been 9751e51764aSArtem Bityutskiy * written to the flash media last time. Otherwise, UBIFS forces inode 9761e51764aSArtem Bityutskiy * write-back, thus making sure the on-flash inode contains current inode size, 9771e51764aSArtem Bityutskiy * and then keeps writing pages back. 9781e51764aSArtem Bityutskiy * 9791e51764aSArtem Bityutskiy * Some locking issues explanation. 'ubifs_writepage()' first is called with 9801e51764aSArtem Bityutskiy * the page locked, and it locks @ui_mutex. However, write-back does take inode 9811e51764aSArtem Bityutskiy * @i_mutex, which means other VFS operations may be run on this inode at the 9821e51764aSArtem Bityutskiy * same time. And the problematic one is truncation to smaller size, from where 983c4361570SArtem Bityutskiy * we have to call 'truncate_setsize()', which first changes @inode->i_size, 984c4361570SArtem Bityutskiy * then drops the truncated pages. And while dropping the pages, it takes the 985c4361570SArtem Bityutskiy * page lock. This means that 'do_truncation()' cannot call 'truncate_setsize()' 986c4361570SArtem Bityutskiy * with @ui_mutex locked, because it would deadlock with 'ubifs_writepage()'. 987c4361570SArtem Bityutskiy * This means that @inode->i_size is changed while @ui_mutex is unlocked. 9881e51764aSArtem Bityutskiy * 9892c27c65eSChristoph Hellwig * XXX(truncate): with the new truncate sequence this is not true anymore, 9902c27c65eSChristoph Hellwig * and the calls to truncate_setsize can be move around freely. They should 9912c27c65eSChristoph Hellwig * be moved to the very end of the truncate sequence. 99215c6fd97Snpiggin@suse.de * 9931e51764aSArtem Bityutskiy * But in 'ubifs_writepage()' we have to guarantee that we do not write beyond 9941e51764aSArtem Bityutskiy * inode size. How do we do this if @inode->i_size may became smaller while we 9951e51764aSArtem Bityutskiy * are in the middle of 'ubifs_writepage()'? The UBIFS solution is the 9961e51764aSArtem Bityutskiy * @ui->ui_isize "shadow" field which UBIFS uses instead of @inode->i_size 9971e51764aSArtem Bityutskiy * internally and updates it under @ui_mutex. 9981e51764aSArtem Bityutskiy * 9991e51764aSArtem Bityutskiy * Q: why we do not worry that if we race with truncation, we may end up with a 10001e51764aSArtem Bityutskiy * situation when the inode is truncated while we are in the middle of 10011e51764aSArtem Bityutskiy * 'do_writepage()', so we do write beyond inode size? 10021e51764aSArtem Bityutskiy * A: If we are in the middle of 'do_writepage()', truncation would be locked 10031e51764aSArtem Bityutskiy * on the page lock and it would not write the truncated inode node to the 10041e51764aSArtem Bityutskiy * journal before we have finished. 10051e51764aSArtem Bityutskiy */ 10061e51764aSArtem Bityutskiy static int ubifs_writepage(struct page *page, struct writeback_control *wbc) 10071e51764aSArtem Bityutskiy { 10081e51764aSArtem Bityutskiy struct inode *inode = page->mapping->host; 10096eb61d58SRichard Weinberger struct ubifs_info *c = inode->i_sb->s_fs_info; 10101e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 10111e51764aSArtem Bityutskiy loff_t i_size = i_size_read(inode), synced_i_size; 101209cbfeafSKirill A. Shutemov pgoff_t end_index = i_size >> PAGE_SHIFT; 101309cbfeafSKirill A. Shutemov int err, len = i_size & (PAGE_SIZE - 1); 10141e51764aSArtem Bityutskiy void *kaddr; 10151e51764aSArtem Bityutskiy 10161e51764aSArtem Bityutskiy dbg_gen("ino %lu, pg %lu, pg flags %#lx", 10171e51764aSArtem Bityutskiy inode->i_ino, page->index, page->flags); 10186eb61d58SRichard Weinberger ubifs_assert(c, PagePrivate(page)); 10191e51764aSArtem Bityutskiy 10201e51764aSArtem Bityutskiy /* Is the page fully outside @i_size? (truncate in progress) */ 10211e51764aSArtem Bityutskiy if (page->index > end_index || (page->index == end_index && !len)) { 10221e51764aSArtem Bityutskiy err = 0; 10231e51764aSArtem Bityutskiy goto out_unlock; 10241e51764aSArtem Bityutskiy } 10251e51764aSArtem Bityutskiy 10261e51764aSArtem Bityutskiy spin_lock(&ui->ui_lock); 10271e51764aSArtem Bityutskiy synced_i_size = ui->synced_i_size; 10281e51764aSArtem Bityutskiy spin_unlock(&ui->ui_lock); 10291e51764aSArtem Bityutskiy 10301e51764aSArtem Bityutskiy /* Is the page fully inside @i_size? */ 10311e51764aSArtem Bityutskiy if (page->index < end_index) { 103209cbfeafSKirill A. Shutemov if (page->index >= synced_i_size >> PAGE_SHIFT) { 1033a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL); 10341e51764aSArtem Bityutskiy if (err) 1035fb8bc4c7SZhihao Cheng goto out_redirty; 10361e51764aSArtem Bityutskiy /* 10371e51764aSArtem Bityutskiy * The inode has been written, but the write-buffer has 10381e51764aSArtem Bityutskiy * not been synchronized, so in case of an unclean 10391e51764aSArtem Bityutskiy * reboot we may end up with some pages beyond inode 10401e51764aSArtem Bityutskiy * size, but they would be in the journal (because 10411e51764aSArtem Bityutskiy * commit flushes write buffers) and recovery would deal 10421e51764aSArtem Bityutskiy * with this. 10431e51764aSArtem Bityutskiy */ 10441e51764aSArtem Bityutskiy } 104509cbfeafSKirill A. Shutemov return do_writepage(page, PAGE_SIZE); 10461e51764aSArtem Bityutskiy } 10471e51764aSArtem Bityutskiy 10481e51764aSArtem Bityutskiy /* 10491e51764aSArtem Bityutskiy * The page straddles @i_size. It must be zeroed out on each and every 10501e51764aSArtem Bityutskiy * writepage invocation because it may be mmapped. "A file is mapped 10511e51764aSArtem Bityutskiy * in multiples of the page size. For a file that is not a multiple of 10521e51764aSArtem Bityutskiy * the page size, the remaining memory is zeroed when mapped, and 10531e51764aSArtem Bityutskiy * writes to that region are not written out to the file." 10541e51764aSArtem Bityutskiy */ 1055a1c7c137SCong Wang kaddr = kmap_atomic(page); 105609cbfeafSKirill A. Shutemov memset(kaddr + len, 0, PAGE_SIZE - len); 10571e51764aSArtem Bityutskiy flush_dcache_page(page); 1058a1c7c137SCong Wang kunmap_atomic(kaddr); 10591e51764aSArtem Bityutskiy 10601e51764aSArtem Bityutskiy if (i_size > synced_i_size) { 1061a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL); 10621e51764aSArtem Bityutskiy if (err) 1063fb8bc4c7SZhihao Cheng goto out_redirty; 10641e51764aSArtem Bityutskiy } 10651e51764aSArtem Bityutskiy 10661e51764aSArtem Bityutskiy return do_writepage(page, len); 1067fb8bc4c7SZhihao Cheng out_redirty: 1068fb8bc4c7SZhihao Cheng /* 1069fb8bc4c7SZhihao Cheng * redirty_page_for_writepage() won't call ubifs_dirty_inode() because 1070fb8bc4c7SZhihao Cheng * it passes I_DIRTY_PAGES flag while calling __mark_inode_dirty(), so 1071fb8bc4c7SZhihao Cheng * there is no need to do space budget for dirty inode. 1072fb8bc4c7SZhihao Cheng */ 1073fb8bc4c7SZhihao Cheng redirty_page_for_writepage(wbc, page); 10741e51764aSArtem Bityutskiy out_unlock: 10751e51764aSArtem Bityutskiy unlock_page(page); 10761e51764aSArtem Bityutskiy return err; 10771e51764aSArtem Bityutskiy } 10781e51764aSArtem Bityutskiy 10791e51764aSArtem Bityutskiy /** 10801e51764aSArtem Bityutskiy * do_attr_changes - change inode attributes. 10811e51764aSArtem Bityutskiy * @inode: inode to change attributes for 10821e51764aSArtem Bityutskiy * @attr: describes attributes to change 10831e51764aSArtem Bityutskiy */ 10841e51764aSArtem Bityutskiy static void do_attr_changes(struct inode *inode, const struct iattr *attr) 10851e51764aSArtem Bityutskiy { 10861e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_UID) 10871e51764aSArtem Bityutskiy inode->i_uid = attr->ia_uid; 10881e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_GID) 10891e51764aSArtem Bityutskiy inode->i_gid = attr->ia_gid; 1090eb31e2f6SAmir Goldstein if (attr->ia_valid & ATTR_ATIME) 1091eb31e2f6SAmir Goldstein inode->i_atime = attr->ia_atime; 1092eb31e2f6SAmir Goldstein if (attr->ia_valid & ATTR_MTIME) 1093eb31e2f6SAmir Goldstein inode->i_mtime = attr->ia_mtime; 1094eb31e2f6SAmir Goldstein if (attr->ia_valid & ATTR_CTIME) 1095*d07d3a7eSJeff Layton inode_set_ctime_to_ts(inode, attr->ia_ctime); 10961e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_MODE) { 10971e51764aSArtem Bityutskiy umode_t mode = attr->ia_mode; 10981e51764aSArtem Bityutskiy 10991e51764aSArtem Bityutskiy if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) 11001e51764aSArtem Bityutskiy mode &= ~S_ISGID; 11011e51764aSArtem Bityutskiy inode->i_mode = mode; 11021e51764aSArtem Bityutskiy } 11031e51764aSArtem Bityutskiy } 11041e51764aSArtem Bityutskiy 11051e51764aSArtem Bityutskiy /** 11061e51764aSArtem Bityutskiy * do_truncation - truncate an inode. 11071e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 11081e51764aSArtem Bityutskiy * @inode: inode to truncate 11091e51764aSArtem Bityutskiy * @attr: inode attribute changes description 11101e51764aSArtem Bityutskiy * 11111e51764aSArtem Bityutskiy * This function implements VFS '->setattr()' call when the inode is truncated 11121e51764aSArtem Bityutskiy * to a smaller size. Returns zero in case of success and a negative error code 11131e51764aSArtem Bityutskiy * in case of failure. 11141e51764aSArtem Bityutskiy */ 11151e51764aSArtem Bityutskiy static int do_truncation(struct ubifs_info *c, struct inode *inode, 11161e51764aSArtem Bityutskiy const struct iattr *attr) 11171e51764aSArtem Bityutskiy { 11181e51764aSArtem Bityutskiy int err; 11191e51764aSArtem Bityutskiy struct ubifs_budget_req req; 11201e51764aSArtem Bityutskiy loff_t old_size = inode->i_size, new_size = attr->ia_size; 112104da11bfSArtem Bityutskiy int offset = new_size & (UBIFS_BLOCK_SIZE - 1), budgeted = 1; 11221e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 11231e51764aSArtem Bityutskiy 11241e51764aSArtem Bityutskiy dbg_gen("ino %lu, size %lld -> %lld", inode->i_ino, old_size, new_size); 11251e51764aSArtem Bityutskiy memset(&req, 0, sizeof(struct ubifs_budget_req)); 11261e51764aSArtem Bityutskiy 11271e51764aSArtem Bityutskiy /* 11281e51764aSArtem Bityutskiy * If this is truncation to a smaller size, and we do not truncate on a 11291e51764aSArtem Bityutskiy * block boundary, budget for changing one data block, because the last 11301e51764aSArtem Bityutskiy * block will be re-written. 11311e51764aSArtem Bityutskiy */ 11321e51764aSArtem Bityutskiy if (new_size & (UBIFS_BLOCK_SIZE - 1)) 11331e51764aSArtem Bityutskiy req.dirtied_page = 1; 11341e51764aSArtem Bityutskiy 11351e51764aSArtem Bityutskiy req.dirtied_ino = 1; 11361e51764aSArtem Bityutskiy /* A funny way to budget for truncation node */ 11371e51764aSArtem Bityutskiy req.dirtied_ino_d = UBIFS_TRUN_NODE_SZ; 11381e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req); 113904da11bfSArtem Bityutskiy if (err) { 114004da11bfSArtem Bityutskiy /* 114104da11bfSArtem Bityutskiy * Treat truncations to zero as deletion and always allow them, 114204da11bfSArtem Bityutskiy * just like we do for '->unlink()'. 114304da11bfSArtem Bityutskiy */ 114404da11bfSArtem Bityutskiy if (new_size || err != -ENOSPC) 11451e51764aSArtem Bityutskiy return err; 114604da11bfSArtem Bityutskiy budgeted = 0; 114704da11bfSArtem Bityutskiy } 11481e51764aSArtem Bityutskiy 11492c27c65eSChristoph Hellwig truncate_setsize(inode, new_size); 11501e51764aSArtem Bityutskiy 11511e51764aSArtem Bityutskiy if (offset) { 115209cbfeafSKirill A. Shutemov pgoff_t index = new_size >> PAGE_SHIFT; 11531e51764aSArtem Bityutskiy struct page *page; 11541e51764aSArtem Bityutskiy 11551e51764aSArtem Bityutskiy page = find_lock_page(inode->i_mapping, index); 11561e51764aSArtem Bityutskiy if (page) { 11571e51764aSArtem Bityutskiy if (PageDirty(page)) { 11581e51764aSArtem Bityutskiy /* 11591e51764aSArtem Bityutskiy * 'ubifs_jnl_truncate()' will try to truncate 11601e51764aSArtem Bityutskiy * the last data node, but it contains 11611e51764aSArtem Bityutskiy * out-of-date data because the page is dirty. 11621e51764aSArtem Bityutskiy * Write the page now, so that 11631e51764aSArtem Bityutskiy * 'ubifs_jnl_truncate()' will see an already 11641e51764aSArtem Bityutskiy * truncated (and up to date) data node. 11651e51764aSArtem Bityutskiy */ 11666eb61d58SRichard Weinberger ubifs_assert(c, PagePrivate(page)); 11671e51764aSArtem Bityutskiy 11681e51764aSArtem Bityutskiy clear_page_dirty_for_io(page); 11691e51764aSArtem Bityutskiy if (UBIFS_BLOCKS_PER_PAGE_SHIFT) 11701e51764aSArtem Bityutskiy offset = new_size & 117109cbfeafSKirill A. Shutemov (PAGE_SIZE - 1); 11721e51764aSArtem Bityutskiy err = do_writepage(page, offset); 117309cbfeafSKirill A. Shutemov put_page(page); 11741e51764aSArtem Bityutskiy if (err) 11751e51764aSArtem Bityutskiy goto out_budg; 11761e51764aSArtem Bityutskiy /* 11771e51764aSArtem Bityutskiy * We could now tell 'ubifs_jnl_truncate()' not 11781e51764aSArtem Bityutskiy * to read the last block. 11791e51764aSArtem Bityutskiy */ 11801e51764aSArtem Bityutskiy } else { 11811e51764aSArtem Bityutskiy /* 11821e51764aSArtem Bityutskiy * We could 'kmap()' the page and pass the data 11831e51764aSArtem Bityutskiy * to 'ubifs_jnl_truncate()' to save it from 11841e51764aSArtem Bityutskiy * having to read it. 11851e51764aSArtem Bityutskiy */ 11861e51764aSArtem Bityutskiy unlock_page(page); 118709cbfeafSKirill A. Shutemov put_page(page); 11881e51764aSArtem Bityutskiy } 11891e51764aSArtem Bityutskiy } 11901e51764aSArtem Bityutskiy } 11911e51764aSArtem Bityutskiy 11921e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 11931e51764aSArtem Bityutskiy ui->ui_size = inode->i_size; 11941e51764aSArtem Bityutskiy /* Truncation changes inode [mc]time */ 1195*d07d3a7eSJeff Layton inode->i_mtime = inode_set_ctime_current(inode); 1196873a64c7SArtem Bityutskiy /* Other attributes may be changed at the same time as well */ 11971e51764aSArtem Bityutskiy do_attr_changes(inode, attr); 11981e51764aSArtem Bityutskiy err = ubifs_jnl_truncate(c, inode, old_size, new_size); 11991e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 1200873a64c7SArtem Bityutskiy 12011e51764aSArtem Bityutskiy out_budg: 120204da11bfSArtem Bityutskiy if (budgeted) 12031e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 120404da11bfSArtem Bityutskiy else { 1205b137545cSArtem Bityutskiy c->bi.nospace = c->bi.nospace_rp = 0; 120604da11bfSArtem Bityutskiy smp_wmb(); 120704da11bfSArtem Bityutskiy } 12081e51764aSArtem Bityutskiy return err; 12091e51764aSArtem Bityutskiy } 12101e51764aSArtem Bityutskiy 12111e51764aSArtem Bityutskiy /** 12121e51764aSArtem Bityutskiy * do_setattr - change inode attributes. 12131e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 12141e51764aSArtem Bityutskiy * @inode: inode to change attributes for 12151e51764aSArtem Bityutskiy * @attr: inode attribute changes description 12161e51764aSArtem Bityutskiy * 12171e51764aSArtem Bityutskiy * This function implements VFS '->setattr()' call for all cases except 12181e51764aSArtem Bityutskiy * truncations to smaller size. Returns zero in case of success and a negative 12191e51764aSArtem Bityutskiy * error code in case of failure. 12201e51764aSArtem Bityutskiy */ 12211e51764aSArtem Bityutskiy static int do_setattr(struct ubifs_info *c, struct inode *inode, 12221e51764aSArtem Bityutskiy const struct iattr *attr) 12231e51764aSArtem Bityutskiy { 12241e51764aSArtem Bityutskiy int err, release; 12251e51764aSArtem Bityutskiy loff_t new_size = attr->ia_size; 12261e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 12271e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .dirtied_ino = 1, 1228dab4b4d2SArtem Bityutskiy .dirtied_ino_d = ALIGN(ui->data_len, 8) }; 12291e51764aSArtem Bityutskiy 12301e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req); 12311e51764aSArtem Bityutskiy if (err) 12321e51764aSArtem Bityutskiy return err; 12331e51764aSArtem Bityutskiy 12341e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_SIZE) { 12351e51764aSArtem Bityutskiy dbg_gen("size %lld -> %lld", inode->i_size, new_size); 12362c27c65eSChristoph Hellwig truncate_setsize(inode, new_size); 12371e51764aSArtem Bityutskiy } 12381e51764aSArtem Bityutskiy 12391e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 12401e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_SIZE) { 12411e51764aSArtem Bityutskiy /* Truncation changes inode [mc]time */ 1242*d07d3a7eSJeff Layton inode->i_mtime = inode_set_ctime_current(inode); 12432c27c65eSChristoph Hellwig /* 'truncate_setsize()' changed @i_size, update @ui_size */ 12441e51764aSArtem Bityutskiy ui->ui_size = inode->i_size; 12451e51764aSArtem Bityutskiy } 12461e51764aSArtem Bityutskiy 12471e51764aSArtem Bityutskiy do_attr_changes(inode, attr); 12481e51764aSArtem Bityutskiy 12491e51764aSArtem Bityutskiy release = ui->dirty; 12501e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_SIZE) 12511e51764aSArtem Bityutskiy /* 12521e51764aSArtem Bityutskiy * Inode length changed, so we have to make sure 12531e51764aSArtem Bityutskiy * @I_DIRTY_DATASYNC is set. 12541e51764aSArtem Bityutskiy */ 1255f3556254SChristoph Hellwig __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 12561e51764aSArtem Bityutskiy else 12571e51764aSArtem Bityutskiy mark_inode_dirty_sync(inode); 12581e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 12591e51764aSArtem Bityutskiy 12601e51764aSArtem Bityutskiy if (release) 12611e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 12621e51764aSArtem Bityutskiy if (IS_SYNC(inode)) 1263a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL); 12641e51764aSArtem Bityutskiy return err; 12651e51764aSArtem Bityutskiy } 12661e51764aSArtem Bityutskiy 1267c1632a0fSChristian Brauner int ubifs_setattr(struct mnt_idmap *idmap, struct dentry *dentry, 1268549c7297SChristian Brauner struct iattr *attr) 12691e51764aSArtem Bityutskiy { 12701e51764aSArtem Bityutskiy int err; 12712b0143b5SDavid Howells struct inode *inode = d_inode(dentry); 12721e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 12731e51764aSArtem Bityutskiy 12747d32c2bbSArtem Bityutskiy dbg_gen("ino %lu, mode %#x, ia_valid %#x", 12757d32c2bbSArtem Bityutskiy inode->i_ino, inode->i_mode, attr->ia_valid); 1276c1632a0fSChristian Brauner err = setattr_prepare(&nop_mnt_idmap, dentry, attr); 12771e51764aSArtem Bityutskiy if (err) 12781e51764aSArtem Bityutskiy return err; 12791e51764aSArtem Bityutskiy 1280d808efb4SArtem Bityutskiy err = dbg_check_synced_i_size(c, inode); 12811e51764aSArtem Bityutskiy if (err) 12821e51764aSArtem Bityutskiy return err; 12831e51764aSArtem Bityutskiy 1284252153baSEric Biggers err = fscrypt_prepare_setattr(dentry, attr); 12854afb9996SEric Biggers if (err) 12864afb9996SEric Biggers return err; 12874afb9996SEric Biggers 12881e51764aSArtem Bityutskiy if ((attr->ia_valid & ATTR_SIZE) && attr->ia_size < inode->i_size) 12891e51764aSArtem Bityutskiy /* Truncation to a smaller size */ 12901e51764aSArtem Bityutskiy err = do_truncation(c, inode, attr); 12911e51764aSArtem Bityutskiy else 12921e51764aSArtem Bityutskiy err = do_setattr(c, inode, attr); 12931e51764aSArtem Bityutskiy 12941e51764aSArtem Bityutskiy return err; 12951e51764aSArtem Bityutskiy } 12961e51764aSArtem Bityutskiy 129758a2fdb6SMatthew Wilcox (Oracle) static void ubifs_invalidate_folio(struct folio *folio, size_t offset, 129858a2fdb6SMatthew Wilcox (Oracle) size_t length) 12991e51764aSArtem Bityutskiy { 130058a2fdb6SMatthew Wilcox (Oracle) struct inode *inode = folio->mapping->host; 13011e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 13021e51764aSArtem Bityutskiy 130358a2fdb6SMatthew Wilcox (Oracle) ubifs_assert(c, folio_test_private(folio)); 130458a2fdb6SMatthew Wilcox (Oracle) if (offset || length < folio_size(folio)) 130558a2fdb6SMatthew Wilcox (Oracle) /* Partial folio remains dirty */ 13061e51764aSArtem Bityutskiy return; 13071e51764aSArtem Bityutskiy 130858a2fdb6SMatthew Wilcox (Oracle) if (folio_test_checked(folio)) 13091e51764aSArtem Bityutskiy release_new_page_budget(c); 13101e51764aSArtem Bityutskiy else 13111e51764aSArtem Bityutskiy release_existing_page_budget(c); 13121e51764aSArtem Bityutskiy 13131e51764aSArtem Bityutskiy atomic_long_dec(&c->dirty_pg_cnt); 1314a87a08e3SLinus Torvalds folio_detach_private(folio); 131558a2fdb6SMatthew Wilcox (Oracle) folio_clear_checked(folio); 13161e51764aSArtem Bityutskiy } 13171e51764aSArtem Bityutskiy 131802c24a82SJosef Bacik int ubifs_fsync(struct file *file, loff_t start, loff_t end, int datasync) 13191e51764aSArtem Bityutskiy { 13207ea80859SChristoph Hellwig struct inode *inode = file->f_mapping->host; 13211e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 13221e51764aSArtem Bityutskiy int err; 13231e51764aSArtem Bityutskiy 13241e51764aSArtem Bityutskiy dbg_gen("syncing inode %lu", inode->i_ino); 13251e51764aSArtem Bityutskiy 13263b2f9a01SArtem Bityutskiy if (c->ro_mount) 13273b2f9a01SArtem Bityutskiy /* 13283b2f9a01SArtem Bityutskiy * For some really strange reasons VFS does not filter out 13293b2f9a01SArtem Bityutskiy * 'fsync()' for R/O mounted file-systems as per 2.6.39. 13303b2f9a01SArtem Bityutskiy */ 133178530bf7SArtem Bityutskiy return 0; 133278530bf7SArtem Bityutskiy 13333b49c9a1SJeff Layton err = file_write_and_wait_range(file, start, end); 133402c24a82SJosef Bacik if (err) 133502c24a82SJosef Bacik return err; 13365955102cSAl Viro inode_lock(inode); 133702c24a82SJosef Bacik 133802c24a82SJosef Bacik /* Synchronize the inode unless this is a 'datasync()' call. */ 13391e51764aSArtem Bityutskiy if (!datasync || (inode->i_state & I_DIRTY_DATASYNC)) { 1340a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL); 13411e51764aSArtem Bityutskiy if (err) 134202c24a82SJosef Bacik goto out; 13431e51764aSArtem Bityutskiy } 13441e51764aSArtem Bityutskiy 13451e51764aSArtem Bityutskiy /* 13461e51764aSArtem Bityutskiy * Nodes related to this inode may still sit in a write-buffer. Flush 13471e51764aSArtem Bityutskiy * them. 13481e51764aSArtem Bityutskiy */ 13491e51764aSArtem Bityutskiy err = ubifs_sync_wbufs_by_inode(c, inode); 135002c24a82SJosef Bacik out: 13515955102cSAl Viro inode_unlock(inode); 13521e51764aSArtem Bityutskiy return err; 13531e51764aSArtem Bityutskiy } 13541e51764aSArtem Bityutskiy 13551e51764aSArtem Bityutskiy /** 13561e51764aSArtem Bityutskiy * mctime_update_needed - check if mtime or ctime update is needed. 13571e51764aSArtem Bityutskiy * @inode: the inode to do the check for 13581e51764aSArtem Bityutskiy * @now: current time 13591e51764aSArtem Bityutskiy * 13601e51764aSArtem Bityutskiy * This helper function checks if the inode mtime/ctime should be updated or 13611e51764aSArtem Bityutskiy * not. If current values of the time-stamps are within the UBIFS inode time 13621e51764aSArtem Bityutskiy * granularity, they are not updated. This is an optimization. 13631e51764aSArtem Bityutskiy */ 13641e51764aSArtem Bityutskiy static inline int mctime_update_needed(const struct inode *inode, 13650eca0b80SArnd Bergmann const struct timespec64 *now) 13661e51764aSArtem Bityutskiy { 1367*d07d3a7eSJeff Layton struct timespec64 ctime = inode_get_ctime(inode); 1368*d07d3a7eSJeff Layton 13690eca0b80SArnd Bergmann if (!timespec64_equal(&inode->i_mtime, now) || 1370*d07d3a7eSJeff Layton !timespec64_equal(&ctime, now)) 13711e51764aSArtem Bityutskiy return 1; 13721e51764aSArtem Bityutskiy return 0; 13731e51764aSArtem Bityutskiy } 13741e51764aSArtem Bityutskiy 13758c1c5f26SDongsheng Yang /** 13768c1c5f26SDongsheng Yang * ubifs_update_time - update time of inode. 13778c1c5f26SDongsheng Yang * @inode: inode to update 13788c1c5f26SDongsheng Yang * 13798c1c5f26SDongsheng Yang * This function updates time of the inode. 13808c1c5f26SDongsheng Yang */ 138195582b00SDeepa Dinamani int ubifs_update_time(struct inode *inode, struct timespec64 *time, 13828c1c5f26SDongsheng Yang int flags) 13838c1c5f26SDongsheng Yang { 13848c1c5f26SDongsheng Yang struct ubifs_inode *ui = ubifs_inode(inode); 13858c1c5f26SDongsheng Yang struct ubifs_info *c = inode->i_sb->s_fs_info; 13868c1c5f26SDongsheng Yang struct ubifs_budget_req req = { .dirtied_ino = 1, 13878c1c5f26SDongsheng Yang .dirtied_ino_d = ALIGN(ui->data_len, 8) }; 13888c1c5f26SDongsheng Yang int err, release; 13898c1c5f26SDongsheng Yang 1390e3d73deaSSascha Hauer if (!IS_ENABLED(CONFIG_UBIFS_ATIME_SUPPORT)) 1391e3d73deaSSascha Hauer return generic_update_time(inode, time, flags); 1392e3d73deaSSascha Hauer 13938c1c5f26SDongsheng Yang err = ubifs_budget_space(c, &req); 13948c1c5f26SDongsheng Yang if (err) 13958c1c5f26SDongsheng Yang return err; 13968c1c5f26SDongsheng Yang 13978c1c5f26SDongsheng Yang mutex_lock(&ui->ui_mutex); 13988c1c5f26SDongsheng Yang if (flags & S_ATIME) 13998c1c5f26SDongsheng Yang inode->i_atime = *time; 14008c1c5f26SDongsheng Yang if (flags & S_CTIME) 1401*d07d3a7eSJeff Layton inode_set_ctime_to_ts(inode, *time); 14028c1c5f26SDongsheng Yang if (flags & S_MTIME) 14038c1c5f26SDongsheng Yang inode->i_mtime = *time; 14048c1c5f26SDongsheng Yang 14058c1c5f26SDongsheng Yang release = ui->dirty; 1406ecf84096SChristoph Hellwig __mark_inode_dirty(inode, I_DIRTY_SYNC); 14078c1c5f26SDongsheng Yang mutex_unlock(&ui->ui_mutex); 14088c1c5f26SDongsheng Yang if (release) 14098c1c5f26SDongsheng Yang ubifs_release_budget(c, &req); 14108c1c5f26SDongsheng Yang return 0; 14118c1c5f26SDongsheng Yang } 14128c1c5f26SDongsheng Yang 14131e51764aSArtem Bityutskiy /** 1414ec037dfcSJulia Lawall * update_mctime - update mtime and ctime of an inode. 14151e51764aSArtem Bityutskiy * @inode: inode to update 14161e51764aSArtem Bityutskiy * 14171e51764aSArtem Bityutskiy * This function updates mtime and ctime of the inode if it is not equivalent to 14181e51764aSArtem Bityutskiy * current time. Returns zero in case of success and a negative error code in 14191e51764aSArtem Bityutskiy * case of failure. 14201e51764aSArtem Bityutskiy */ 1421f5674c31SAl Viro static int update_mctime(struct inode *inode) 14221e51764aSArtem Bityutskiy { 14230eca0b80SArnd Bergmann struct timespec64 now = current_time(inode); 14241e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 1425f5674c31SAl Viro struct ubifs_info *c = inode->i_sb->s_fs_info; 14261e51764aSArtem Bityutskiy 14271e51764aSArtem Bityutskiy if (mctime_update_needed(inode, &now)) { 14281e51764aSArtem Bityutskiy int err, release; 14291e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .dirtied_ino = 1, 1430dab4b4d2SArtem Bityutskiy .dirtied_ino_d = ALIGN(ui->data_len, 8) }; 14311e51764aSArtem Bityutskiy 14321e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req); 14331e51764aSArtem Bityutskiy if (err) 14341e51764aSArtem Bityutskiy return err; 14351e51764aSArtem Bityutskiy 14361e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 1437*d07d3a7eSJeff Layton inode->i_mtime = inode_set_ctime_current(inode); 14381e51764aSArtem Bityutskiy release = ui->dirty; 14391e51764aSArtem Bityutskiy mark_inode_dirty_sync(inode); 14401e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 14411e51764aSArtem Bityutskiy if (release) 14421e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 14431e51764aSArtem Bityutskiy } 14441e51764aSArtem Bityutskiy 14451e51764aSArtem Bityutskiy return 0; 14461e51764aSArtem Bityutskiy } 14471e51764aSArtem Bityutskiy 1448f5674c31SAl Viro static ssize_t ubifs_write_iter(struct kiocb *iocb, struct iov_iter *from) 14491e51764aSArtem Bityutskiy { 1450f5674c31SAl Viro int err = update_mctime(file_inode(iocb->ki_filp)); 14511e51764aSArtem Bityutskiy if (err) 14521e51764aSArtem Bityutskiy return err; 14531e51764aSArtem Bityutskiy 1454f5674c31SAl Viro return generic_file_write_iter(iocb, from); 14551e51764aSArtem Bityutskiy } 14561e51764aSArtem Bityutskiy 14571f1d14dbSMatthew Wilcox (Oracle) static bool ubifs_dirty_folio(struct address_space *mapping, 14581f1d14dbSMatthew Wilcox (Oracle) struct folio *folio) 14591e51764aSArtem Bityutskiy { 14601f1d14dbSMatthew Wilcox (Oracle) bool ret; 14611f1d14dbSMatthew Wilcox (Oracle) struct ubifs_info *c = mapping->host->i_sb->s_fs_info; 14621e51764aSArtem Bityutskiy 14631f1d14dbSMatthew Wilcox (Oracle) ret = filemap_dirty_folio(mapping, folio); 14641e51764aSArtem Bityutskiy /* 14651e51764aSArtem Bityutskiy * An attempt to dirty a page without budgeting for it - should not 14661e51764aSArtem Bityutskiy * happen. 14671e51764aSArtem Bityutskiy */ 14681f1d14dbSMatthew Wilcox (Oracle) ubifs_assert(c, ret == false); 14691e51764aSArtem Bityutskiy return ret; 14701e51764aSArtem Bityutskiy } 14711e51764aSArtem Bityutskiy 1472bcaabc55SMatthew Wilcox (Oracle) static bool ubifs_release_folio(struct folio *folio, gfp_t unused_gfp_flags) 14731e51764aSArtem Bityutskiy { 1474bcaabc55SMatthew Wilcox (Oracle) struct inode *inode = folio->mapping->host; 14756eb61d58SRichard Weinberger struct ubifs_info *c = inode->i_sb->s_fs_info; 14766eb61d58SRichard Weinberger 1477bcaabc55SMatthew Wilcox (Oracle) if (folio_test_writeback(folio)) 1478bcaabc55SMatthew Wilcox (Oracle) return false; 147966f4742eSZhihao Cheng 148066f4742eSZhihao Cheng /* 148166f4742eSZhihao Cheng * Page is private but not dirty, weird? There is one condition 148266f4742eSZhihao Cheng * making it happened. ubifs_writepage skipped the page because 148366f4742eSZhihao Cheng * page index beyonds isize (for example. truncated by other 148466f4742eSZhihao Cheng * process named A), then the page is invalidated by fadvise64 148566f4742eSZhihao Cheng * syscall before being truncated by process A. 148666f4742eSZhihao Cheng */ 1487bcaabc55SMatthew Wilcox (Oracle) ubifs_assert(c, folio_test_private(folio)); 148866f4742eSZhihao Cheng if (folio_test_checked(folio)) 148966f4742eSZhihao Cheng release_new_page_budget(c); 149066f4742eSZhihao Cheng else 149166f4742eSZhihao Cheng release_existing_page_budget(c); 149266f4742eSZhihao Cheng 149366f4742eSZhihao Cheng atomic_long_dec(&c->dirty_pg_cnt); 1494bcaabc55SMatthew Wilcox (Oracle) folio_detach_private(folio); 1495bcaabc55SMatthew Wilcox (Oracle) folio_clear_checked(folio); 1496bcaabc55SMatthew Wilcox (Oracle) return true; 14971e51764aSArtem Bityutskiy } 14981e51764aSArtem Bityutskiy 14991e51764aSArtem Bityutskiy /* 1500c4361570SArtem Bityutskiy * mmap()d file has taken write protection fault and is being made writable. 1501c4361570SArtem Bityutskiy * UBIFS must ensure page is budgeted for. 15021e51764aSArtem Bityutskiy */ 150331c49eacSSouptick Joarder static vm_fault_t ubifs_vm_page_mkwrite(struct vm_fault *vmf) 15041e51764aSArtem Bityutskiy { 1505c2ec175cSNick Piggin struct page *page = vmf->page; 150611bac800SDave Jiang struct inode *inode = file_inode(vmf->vma->vm_file); 15071e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 15080eca0b80SArnd Bergmann struct timespec64 now = current_time(inode); 15091e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .new_page = 1 }; 15101e51764aSArtem Bityutskiy int err, update_time; 15111e51764aSArtem Bityutskiy 15121e51764aSArtem Bityutskiy dbg_gen("ino %lu, pg %lu, i_size %lld", inode->i_ino, page->index, 15131e51764aSArtem Bityutskiy i_size_read(inode)); 15146eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount); 15151e51764aSArtem Bityutskiy 15162680d722SArtem Bityutskiy if (unlikely(c->ro_error)) 1517c2ec175cSNick Piggin return VM_FAULT_SIGBUS; /* -EROFS */ 15181e51764aSArtem Bityutskiy 15191e51764aSArtem Bityutskiy /* 15201e51764aSArtem Bityutskiy * We have not locked @page so far so we may budget for changing the 15211e51764aSArtem Bityutskiy * page. Note, we cannot do this after we locked the page, because 15221e51764aSArtem Bityutskiy * budgeting may cause write-back which would cause deadlock. 15231e51764aSArtem Bityutskiy * 15241e51764aSArtem Bityutskiy * At the moment we do not know whether the page is dirty or not, so we 15251e51764aSArtem Bityutskiy * assume that it is not and budget for a new page. We could look at 15261e51764aSArtem Bityutskiy * the @PG_private flag and figure this out, but we may race with write 15271e51764aSArtem Bityutskiy * back and the page state may change by the time we lock it, so this 15281e51764aSArtem Bityutskiy * would need additional care. We do not bother with this at the 15291e51764aSArtem Bityutskiy * moment, although it might be good idea to do. Instead, we allocate 15301e51764aSArtem Bityutskiy * budget for a new page and amend it later on if the page was in fact 15311e51764aSArtem Bityutskiy * dirty. 15321e51764aSArtem Bityutskiy * 15331e51764aSArtem Bityutskiy * The budgeting-related logic of this function is similar to what we 15341e51764aSArtem Bityutskiy * do in 'ubifs_write_begin()' and 'ubifs_write_end()'. Glance there 15351e51764aSArtem Bityutskiy * for more comments. 15361e51764aSArtem Bityutskiy */ 15371e51764aSArtem Bityutskiy update_time = mctime_update_needed(inode, &now); 15381e51764aSArtem Bityutskiy if (update_time) 15391e51764aSArtem Bityutskiy /* 15401e51764aSArtem Bityutskiy * We have to change inode time stamp which requires extra 15411e51764aSArtem Bityutskiy * budgeting. 15421e51764aSArtem Bityutskiy */ 15431e51764aSArtem Bityutskiy req.dirtied_ino = 1; 15441e51764aSArtem Bityutskiy 15451e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req); 15461e51764aSArtem Bityutskiy if (unlikely(err)) { 15471e51764aSArtem Bityutskiy if (err == -ENOSPC) 1548235c362bSSheng Yong ubifs_warn(c, "out of space for mmapped file (inode number %lu)", 154979fda517SArtem Bityutskiy inode->i_ino); 1550c2ec175cSNick Piggin return VM_FAULT_SIGBUS; 15511e51764aSArtem Bityutskiy } 15521e51764aSArtem Bityutskiy 15531e51764aSArtem Bityutskiy lock_page(page); 15541e51764aSArtem Bityutskiy if (unlikely(page->mapping != inode->i_mapping || 15551e51764aSArtem Bityutskiy page_offset(page) > i_size_read(inode))) { 15561e51764aSArtem Bityutskiy /* Page got truncated out from underneath us */ 155731c49eacSSouptick Joarder goto sigbus; 15581e51764aSArtem Bityutskiy } 15591e51764aSArtem Bityutskiy 15601e51764aSArtem Bityutskiy if (PagePrivate(page)) 15611e51764aSArtem Bityutskiy release_new_page_budget(c); 15621e51764aSArtem Bityutskiy else { 15631e51764aSArtem Bityutskiy if (!PageChecked(page)) 15641e51764aSArtem Bityutskiy ubifs_convert_page_budget(c); 15653b67db8aSZhihao Cheng attach_page_private(page, (void *)1); 15661e51764aSArtem Bityutskiy atomic_long_inc(&c->dirty_pg_cnt); 15671e51764aSArtem Bityutskiy __set_page_dirty_nobuffers(page); 15681e51764aSArtem Bityutskiy } 15691e51764aSArtem Bityutskiy 15701e51764aSArtem Bityutskiy if (update_time) { 15711e51764aSArtem Bityutskiy int release; 15721e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 15731e51764aSArtem Bityutskiy 15741e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 1575*d07d3a7eSJeff Layton inode->i_mtime = inode_set_ctime_current(inode); 15761e51764aSArtem Bityutskiy release = ui->dirty; 15771e51764aSArtem Bityutskiy mark_inode_dirty_sync(inode); 15781e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 15791e51764aSArtem Bityutskiy if (release) 15801e51764aSArtem Bityutskiy ubifs_release_dirty_inode_budget(c, ui); 15811e51764aSArtem Bityutskiy } 15821e51764aSArtem Bityutskiy 1583182dcfd6SJan Kara wait_for_stable_page(page); 1584691a7c6fShujianyang return VM_FAULT_LOCKED; 15851e51764aSArtem Bityutskiy 158631c49eacSSouptick Joarder sigbus: 15871e51764aSArtem Bityutskiy unlock_page(page); 15881e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 158931c49eacSSouptick Joarder return VM_FAULT_SIGBUS; 15901e51764aSArtem Bityutskiy } 15911e51764aSArtem Bityutskiy 1592f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct ubifs_file_vm_ops = { 15931e51764aSArtem Bityutskiy .fault = filemap_fault, 1594f1820361SKirill A. Shutemov .map_pages = filemap_map_pages, 15951e51764aSArtem Bityutskiy .page_mkwrite = ubifs_vm_page_mkwrite, 15961e51764aSArtem Bityutskiy }; 15971e51764aSArtem Bityutskiy 15981e51764aSArtem Bityutskiy static int ubifs_file_mmap(struct file *file, struct vm_area_struct *vma) 15991e51764aSArtem Bityutskiy { 16001e51764aSArtem Bityutskiy int err; 16011e51764aSArtem Bityutskiy 16021e51764aSArtem Bityutskiy err = generic_file_mmap(file, vma); 16031e51764aSArtem Bityutskiy if (err) 16041e51764aSArtem Bityutskiy return err; 16051e51764aSArtem Bityutskiy vma->vm_ops = &ubifs_file_vm_ops; 1606e3d73deaSSascha Hauer 1607e3d73deaSSascha Hauer if (IS_ENABLED(CONFIG_UBIFS_ATIME_SUPPORT)) 16088c1c5f26SDongsheng Yang file_accessed(file); 1609e3d73deaSSascha Hauer 16101e51764aSArtem Bityutskiy return 0; 16111e51764aSArtem Bityutskiy } 16121e51764aSArtem Bityutskiy 1613ca7f85beSRichard Weinberger static const char *ubifs_get_link(struct dentry *dentry, 1614ca7f85beSRichard Weinberger struct inode *inode, 1615ca7f85beSRichard Weinberger struct delayed_call *done) 1616ca7f85beSRichard Weinberger { 1617ca7f85beSRichard Weinberger struct ubifs_inode *ui = ubifs_inode(inode); 1618ca7f85beSRichard Weinberger 161981dd76b2SEric Biggers if (!IS_ENCRYPTED(inode)) 1620ca7f85beSRichard Weinberger return ui->data; 1621ca7f85beSRichard Weinberger 1622ca7f85beSRichard Weinberger if (!dentry) 1623ca7f85beSRichard Weinberger return ERR_PTR(-ECHILD); 1624ca7f85beSRichard Weinberger 162581dd76b2SEric Biggers return fscrypt_get_symlink(inode, ui->data, ui->data_len, done); 1626ca7f85beSRichard Weinberger } 1627ca7f85beSRichard Weinberger 1628b74d24f7SChristian Brauner static int ubifs_symlink_getattr(struct mnt_idmap *idmap, 1629064c7349SEric Biggers const struct path *path, struct kstat *stat, 1630064c7349SEric Biggers u32 request_mask, unsigned int query_flags) 1631064c7349SEric Biggers { 1632b74d24f7SChristian Brauner ubifs_getattr(idmap, path, stat, request_mask, query_flags); 1633064c7349SEric Biggers 1634064c7349SEric Biggers if (IS_ENCRYPTED(d_inode(path->dentry))) 1635064c7349SEric Biggers return fscrypt_symlink_getattr(path, stat); 1636064c7349SEric Biggers return 0; 1637064c7349SEric Biggers } 1638064c7349SEric Biggers 1639e8b81566SArtem Bityutskiy const struct address_space_operations ubifs_file_address_operations = { 16400b7bf483SMatthew Wilcox (Oracle) .read_folio = ubifs_read_folio, 16411e51764aSArtem Bityutskiy .writepage = ubifs_writepage, 16421e51764aSArtem Bityutskiy .write_begin = ubifs_write_begin, 16431e51764aSArtem Bityutskiy .write_end = ubifs_write_end, 164458a2fdb6SMatthew Wilcox (Oracle) .invalidate_folio = ubifs_invalidate_folio, 16451f1d14dbSMatthew Wilcox (Oracle) .dirty_folio = ubifs_dirty_folio, 1646e7b15baeSMatthew Wilcox (Oracle) .migrate_folio = filemap_migrate_folio, 1647bcaabc55SMatthew Wilcox (Oracle) .release_folio = ubifs_release_folio, 16481e51764aSArtem Bityutskiy }; 16491e51764aSArtem Bityutskiy 1650e8b81566SArtem Bityutskiy const struct inode_operations ubifs_file_inode_operations = { 16511e51764aSArtem Bityutskiy .setattr = ubifs_setattr, 16521e51764aSArtem Bityutskiy .getattr = ubifs_getattr, 16531e51764aSArtem Bityutskiy .listxattr = ubifs_listxattr, 16548c1c5f26SDongsheng Yang .update_time = ubifs_update_time, 16558871d84cSMiklos Szeredi .fileattr_get = ubifs_fileattr_get, 16568871d84cSMiklos Szeredi .fileattr_set = ubifs_fileattr_set, 16571e51764aSArtem Bityutskiy }; 16581e51764aSArtem Bityutskiy 1659e8b81566SArtem Bityutskiy const struct inode_operations ubifs_symlink_inode_operations = { 1660ca7f85beSRichard Weinberger .get_link = ubifs_get_link, 16611e51764aSArtem Bityutskiy .setattr = ubifs_setattr, 1662064c7349SEric Biggers .getattr = ubifs_symlink_getattr, 1663895d9db2SSubodh Nijsure .listxattr = ubifs_listxattr, 16648c1c5f26SDongsheng Yang .update_time = ubifs_update_time, 16651e51764aSArtem Bityutskiy }; 16661e51764aSArtem Bityutskiy 1667e8b81566SArtem Bityutskiy const struct file_operations ubifs_file_operations = { 16681e51764aSArtem Bityutskiy .llseek = generic_file_llseek, 1669aad4f8bbSAl Viro .read_iter = generic_file_read_iter, 1670f5674c31SAl Viro .write_iter = ubifs_write_iter, 16711e51764aSArtem Bityutskiy .mmap = ubifs_file_mmap, 16721e51764aSArtem Bityutskiy .fsync = ubifs_fsync, 16731e51764aSArtem Bityutskiy .unlocked_ioctl = ubifs_ioctl, 16742cb1e089SDavid Howells .splice_read = filemap_splice_read, 16758d020765SAl Viro .splice_write = iter_file_splice_write, 16767e35c4daSEric Biggers .open = fscrypt_file_open, 16771e51764aSArtem Bityutskiy #ifdef CONFIG_COMPAT 16781e51764aSArtem Bityutskiy .compat_ioctl = ubifs_compat_ioctl, 16791e51764aSArtem Bityutskiy #endif 16801e51764aSArtem Bityutskiy }; 1681