11e51764aSArtem Bityutskiy /* 21e51764aSArtem Bityutskiy * This file is part of UBIFS. 31e51764aSArtem Bityutskiy * 41e51764aSArtem Bityutskiy * Copyright (C) 2006-2008 Nokia Corporation. 51e51764aSArtem Bityutskiy * 61e51764aSArtem Bityutskiy * This program is free software; you can redistribute it and/or modify it 71e51764aSArtem Bityutskiy * under the terms of the GNU General Public License version 2 as published by 81e51764aSArtem Bityutskiy * the Free Software Foundation. 91e51764aSArtem Bityutskiy * 101e51764aSArtem Bityutskiy * This program is distributed in the hope that it will be useful, but WITHOUT 111e51764aSArtem Bityutskiy * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or 121e51764aSArtem Bityutskiy * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for 131e51764aSArtem Bityutskiy * more details. 141e51764aSArtem Bityutskiy * 151e51764aSArtem Bityutskiy * You should have received a copy of the GNU General Public License along with 161e51764aSArtem Bityutskiy * this program; if not, write to the Free Software Foundation, Inc., 51 171e51764aSArtem Bityutskiy * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA 181e51764aSArtem Bityutskiy * 191e51764aSArtem Bityutskiy * Authors: Artem Bityutskiy (Битюцкий Артём) 201e51764aSArtem Bityutskiy * Adrian Hunter 211e51764aSArtem Bityutskiy */ 221e51764aSArtem Bityutskiy 231e51764aSArtem Bityutskiy /* 24873a64c7SArtem Bityutskiy * This file implements VFS file and inode operations for regular files, device 251e51764aSArtem Bityutskiy * nodes and symlinks as well as address space operations. 261e51764aSArtem Bityutskiy * 27873a64c7SArtem Bityutskiy * UBIFS uses 2 page flags: @PG_private and @PG_checked. @PG_private is set if 28873a64c7SArtem Bityutskiy * the page is dirty and is used for optimization purposes - dirty pages are 29873a64c7SArtem Bityutskiy * not budgeted so the flag shows that 'ubifs_write_end()' should not release 30873a64c7SArtem Bityutskiy * the budget for this page. The @PG_checked flag is set if full budgeting is 31873a64c7SArtem Bityutskiy * required for the page e.g., when it corresponds to a file hole or it is 32873a64c7SArtem Bityutskiy * beyond the file size. The budgeting is done in 'ubifs_write_begin()', because 33873a64c7SArtem Bityutskiy * it is OK to fail in this function, and the budget is released in 34873a64c7SArtem Bityutskiy * 'ubifs_write_end()'. So the @PG_private and @PG_checked flags carry 35873a64c7SArtem Bityutskiy * information about how the page was budgeted, to make it possible to release 36873a64c7SArtem Bityutskiy * the budget properly. 371e51764aSArtem Bityutskiy * 38873a64c7SArtem Bityutskiy * A thing to keep in mind: inode @i_mutex is locked in most VFS operations we 39873a64c7SArtem Bityutskiy * implement. However, this is not true for 'ubifs_writepage()', which may be 40873a64c7SArtem Bityutskiy * called with @i_mutex unlocked. For example, when pdflush is doing background 41873a64c7SArtem Bityutskiy * write-back, it calls 'ubifs_writepage()' with unlocked @i_mutex. At "normal" 42873a64c7SArtem Bityutskiy * work-paths the @i_mutex is locked in 'ubifs_writepage()', e.g. in the 43873a64c7SArtem Bityutskiy * "sys_write -> alloc_pages -> direct reclaim path". So, in 'ubifs_writepage()' 44873a64c7SArtem Bityutskiy * we are only guaranteed that the page is locked. 451e51764aSArtem Bityutskiy * 46873a64c7SArtem Bityutskiy * Similarly, @i_mutex is not always locked in 'ubifs_readpage()', e.g., the 47873a64c7SArtem Bityutskiy * read-ahead path does not lock it ("sys_read -> generic_file_aio_read -> 48eaff8079SChristoph Hellwig * ondemand_readahead -> readpage"). In case of readahead, @I_SYNC flag is not 49873a64c7SArtem Bityutskiy * set as well. However, UBIFS disables readahead. 501e51764aSArtem Bityutskiy */ 511e51764aSArtem Bityutskiy 521e51764aSArtem Bityutskiy #include "ubifs.h" 531e51764aSArtem Bityutskiy #include <linux/mount.h> 543f8206d4SAl Viro #include <linux/namei.h> 555a0e3ad6STejun Heo #include <linux/slab.h> 561e51764aSArtem Bityutskiy 571e51764aSArtem Bityutskiy static int read_block(struct inode *inode, void *addr, unsigned int block, 581e51764aSArtem Bityutskiy struct ubifs_data_node *dn) 591e51764aSArtem Bityutskiy { 601e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 611e51764aSArtem Bityutskiy int err, len, out_len; 621e51764aSArtem Bityutskiy union ubifs_key key; 631e51764aSArtem Bityutskiy unsigned int dlen; 641e51764aSArtem Bityutskiy 651e51764aSArtem Bityutskiy data_key_init(c, &key, inode->i_ino, block); 661e51764aSArtem Bityutskiy err = ubifs_tnc_lookup(c, &key, dn); 671e51764aSArtem Bityutskiy if (err) { 681e51764aSArtem Bityutskiy if (err == -ENOENT) 691e51764aSArtem Bityutskiy /* Not found, so it must be a hole */ 701e51764aSArtem Bityutskiy memset(addr, 0, UBIFS_BLOCK_SIZE); 711e51764aSArtem Bityutskiy return err; 721e51764aSArtem Bityutskiy } 731e51764aSArtem Bityutskiy 74f92b9826SArtem Bityutskiy ubifs_assert(le64_to_cpu(dn->ch.sqnum) > 75f92b9826SArtem Bityutskiy ubifs_inode(inode)->creat_sqnum); 761e51764aSArtem Bityutskiy len = le32_to_cpu(dn->size); 771e51764aSArtem Bityutskiy if (len <= 0 || len > UBIFS_BLOCK_SIZE) 781e51764aSArtem Bityutskiy goto dump; 791e51764aSArtem Bityutskiy 801e51764aSArtem Bityutskiy dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ; 811e51764aSArtem Bityutskiy out_len = UBIFS_BLOCK_SIZE; 821e51764aSArtem Bityutskiy err = ubifs_decompress(&dn->data, dlen, addr, &out_len, 831e51764aSArtem Bityutskiy le16_to_cpu(dn->compr_type)); 841e51764aSArtem Bityutskiy if (err || len != out_len) 851e51764aSArtem Bityutskiy goto dump; 861e51764aSArtem Bityutskiy 871e51764aSArtem Bityutskiy /* 881e51764aSArtem Bityutskiy * Data length can be less than a full block, even for blocks that are 891e51764aSArtem Bityutskiy * not the last in the file (e.g., as a result of making a hole and 901e51764aSArtem Bityutskiy * appending data). Ensure that the remainder is zeroed out. 911e51764aSArtem Bityutskiy */ 921e51764aSArtem Bityutskiy if (len < UBIFS_BLOCK_SIZE) 931e51764aSArtem Bityutskiy memset(addr + len, 0, UBIFS_BLOCK_SIZE - len); 941e51764aSArtem Bityutskiy 951e51764aSArtem Bityutskiy return 0; 961e51764aSArtem Bityutskiy 971e51764aSArtem Bityutskiy dump: 981e51764aSArtem Bityutskiy ubifs_err("bad data node (block %u, inode %lu)", 991e51764aSArtem Bityutskiy block, inode->i_ino); 1001e51764aSArtem Bityutskiy dbg_dump_node(c, dn); 1011e51764aSArtem Bityutskiy return -EINVAL; 1021e51764aSArtem Bityutskiy } 1031e51764aSArtem Bityutskiy 1041e51764aSArtem Bityutskiy static int do_readpage(struct page *page) 1051e51764aSArtem Bityutskiy { 1061e51764aSArtem Bityutskiy void *addr; 1071e51764aSArtem Bityutskiy int err = 0, i; 1081e51764aSArtem Bityutskiy unsigned int block, beyond; 1091e51764aSArtem Bityutskiy struct ubifs_data_node *dn; 1101e51764aSArtem Bityutskiy struct inode *inode = page->mapping->host; 1111e51764aSArtem Bityutskiy loff_t i_size = i_size_read(inode); 1121e51764aSArtem Bityutskiy 1131e51764aSArtem Bityutskiy dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx", 1141e51764aSArtem Bityutskiy inode->i_ino, page->index, i_size, page->flags); 1151e51764aSArtem Bityutskiy ubifs_assert(!PageChecked(page)); 1161e51764aSArtem Bityutskiy ubifs_assert(!PagePrivate(page)); 1171e51764aSArtem Bityutskiy 1181e51764aSArtem Bityutskiy addr = kmap(page); 1191e51764aSArtem Bityutskiy 1201e51764aSArtem Bityutskiy block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT; 1211e51764aSArtem Bityutskiy beyond = (i_size + UBIFS_BLOCK_SIZE - 1) >> UBIFS_BLOCK_SHIFT; 1221e51764aSArtem Bityutskiy if (block >= beyond) { 1231e51764aSArtem Bityutskiy /* Reading beyond inode */ 1241e51764aSArtem Bityutskiy SetPageChecked(page); 1251e51764aSArtem Bityutskiy memset(addr, 0, PAGE_CACHE_SIZE); 1261e51764aSArtem Bityutskiy goto out; 1271e51764aSArtem Bityutskiy } 1281e51764aSArtem Bityutskiy 1291e51764aSArtem Bityutskiy dn = kmalloc(UBIFS_MAX_DATA_NODE_SZ, GFP_NOFS); 1301e51764aSArtem Bityutskiy if (!dn) { 1311e51764aSArtem Bityutskiy err = -ENOMEM; 1321e51764aSArtem Bityutskiy goto error; 1331e51764aSArtem Bityutskiy } 1341e51764aSArtem Bityutskiy 1351e51764aSArtem Bityutskiy i = 0; 1361e51764aSArtem Bityutskiy while (1) { 1371e51764aSArtem Bityutskiy int ret; 1381e51764aSArtem Bityutskiy 1391e51764aSArtem Bityutskiy if (block >= beyond) { 1401e51764aSArtem Bityutskiy /* Reading beyond inode */ 1411e51764aSArtem Bityutskiy err = -ENOENT; 1421e51764aSArtem Bityutskiy memset(addr, 0, UBIFS_BLOCK_SIZE); 1431e51764aSArtem Bityutskiy } else { 1441e51764aSArtem Bityutskiy ret = read_block(inode, addr, block, dn); 1451e51764aSArtem Bityutskiy if (ret) { 1461e51764aSArtem Bityutskiy err = ret; 1471e51764aSArtem Bityutskiy if (err != -ENOENT) 1481e51764aSArtem Bityutskiy break; 149ed382d58SAdrian Hunter } else if (block + 1 == beyond) { 150ed382d58SAdrian Hunter int dlen = le32_to_cpu(dn->size); 151ed382d58SAdrian Hunter int ilen = i_size & (UBIFS_BLOCK_SIZE - 1); 152ed382d58SAdrian Hunter 153ed382d58SAdrian Hunter if (ilen && ilen < dlen) 154ed382d58SAdrian Hunter memset(addr + ilen, 0, dlen - ilen); 1551e51764aSArtem Bityutskiy } 1561e51764aSArtem Bityutskiy } 1571e51764aSArtem Bityutskiy if (++i >= UBIFS_BLOCKS_PER_PAGE) 1581e51764aSArtem Bityutskiy break; 1591e51764aSArtem Bityutskiy block += 1; 1601e51764aSArtem Bityutskiy addr += UBIFS_BLOCK_SIZE; 1611e51764aSArtem Bityutskiy } 1621e51764aSArtem Bityutskiy if (err) { 1631e51764aSArtem Bityutskiy if (err == -ENOENT) { 1641e51764aSArtem Bityutskiy /* Not found, so it must be a hole */ 1651e51764aSArtem Bityutskiy SetPageChecked(page); 1661e51764aSArtem Bityutskiy dbg_gen("hole"); 1671e51764aSArtem Bityutskiy goto out_free; 1681e51764aSArtem Bityutskiy } 1691e51764aSArtem Bityutskiy ubifs_err("cannot read page %lu of inode %lu, error %d", 1701e51764aSArtem Bityutskiy page->index, inode->i_ino, err); 1711e51764aSArtem Bityutskiy goto error; 1721e51764aSArtem Bityutskiy } 1731e51764aSArtem Bityutskiy 1741e51764aSArtem Bityutskiy out_free: 1751e51764aSArtem Bityutskiy kfree(dn); 1761e51764aSArtem Bityutskiy out: 1771e51764aSArtem Bityutskiy SetPageUptodate(page); 1781e51764aSArtem Bityutskiy ClearPageError(page); 1791e51764aSArtem Bityutskiy flush_dcache_page(page); 1801e51764aSArtem Bityutskiy kunmap(page); 1811e51764aSArtem Bityutskiy return 0; 1821e51764aSArtem Bityutskiy 1831e51764aSArtem Bityutskiy error: 1841e51764aSArtem Bityutskiy kfree(dn); 1851e51764aSArtem Bityutskiy ClearPageUptodate(page); 1861e51764aSArtem Bityutskiy SetPageError(page); 1871e51764aSArtem Bityutskiy flush_dcache_page(page); 1881e51764aSArtem Bityutskiy kunmap(page); 1891e51764aSArtem Bityutskiy return err; 1901e51764aSArtem Bityutskiy } 1911e51764aSArtem Bityutskiy 1921e51764aSArtem Bityutskiy /** 1931e51764aSArtem Bityutskiy * release_new_page_budget - release budget of a new page. 1941e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 1951e51764aSArtem Bityutskiy * 1961e51764aSArtem Bityutskiy * This is a helper function which releases budget corresponding to the budget 1971e51764aSArtem Bityutskiy * of one new page of data. 1981e51764aSArtem Bityutskiy */ 1991e51764aSArtem Bityutskiy static void release_new_page_budget(struct ubifs_info *c) 2001e51764aSArtem Bityutskiy { 2011e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .recalculate = 1, .new_page = 1 }; 2021e51764aSArtem Bityutskiy 2031e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 2041e51764aSArtem Bityutskiy } 2051e51764aSArtem Bityutskiy 2061e51764aSArtem Bityutskiy /** 2071e51764aSArtem Bityutskiy * release_existing_page_budget - release budget of an existing page. 2081e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 2091e51764aSArtem Bityutskiy * 2101e51764aSArtem Bityutskiy * This is a helper function which releases budget corresponding to the budget 2111e51764aSArtem Bityutskiy * of changing one one page of data which already exists on the flash media. 2121e51764aSArtem Bityutskiy */ 2131e51764aSArtem Bityutskiy static void release_existing_page_budget(struct ubifs_info *c) 2141e51764aSArtem Bityutskiy { 2151e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .dd_growth = c->page_budget}; 2161e51764aSArtem Bityutskiy 2171e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 2181e51764aSArtem Bityutskiy } 2191e51764aSArtem Bityutskiy 2201e51764aSArtem Bityutskiy static int write_begin_slow(struct address_space *mapping, 22154566b2cSNick Piggin loff_t pos, unsigned len, struct page **pagep, 22254566b2cSNick Piggin unsigned flags) 2231e51764aSArtem Bityutskiy { 2241e51764aSArtem Bityutskiy struct inode *inode = mapping->host; 2251e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 2261e51764aSArtem Bityutskiy pgoff_t index = pos >> PAGE_CACHE_SHIFT; 2271e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .new_page = 1 }; 2281e51764aSArtem Bityutskiy int uninitialized_var(err), appending = !!(pos + len > inode->i_size); 2291e51764aSArtem Bityutskiy struct page *page; 2301e51764aSArtem Bityutskiy 2311e51764aSArtem Bityutskiy dbg_gen("ino %lu, pos %llu, len %u, i_size %lld", 2321e51764aSArtem Bityutskiy inode->i_ino, pos, len, inode->i_size); 2331e51764aSArtem Bityutskiy 2341e51764aSArtem Bityutskiy /* 2351e51764aSArtem Bityutskiy * At the slow path we have to budget before locking the page, because 2361e51764aSArtem Bityutskiy * budgeting may force write-back, which would wait on locked pages and 2371e51764aSArtem Bityutskiy * deadlock if we had the page locked. At this point we do not know 2381e51764aSArtem Bityutskiy * anything about the page, so assume that this is a new page which is 2391e51764aSArtem Bityutskiy * written to a hole. This corresponds to largest budget. Later the 2401e51764aSArtem Bityutskiy * budget will be amended if this is not true. 2411e51764aSArtem Bityutskiy */ 2421e51764aSArtem Bityutskiy if (appending) 2431e51764aSArtem Bityutskiy /* We are appending data, budget for inode change */ 2441e51764aSArtem Bityutskiy req.dirtied_ino = 1; 2451e51764aSArtem Bityutskiy 2461e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req); 2471e51764aSArtem Bityutskiy if (unlikely(err)) 2481e51764aSArtem Bityutskiy return err; 2491e51764aSArtem Bityutskiy 25054566b2cSNick Piggin page = grab_cache_page_write_begin(mapping, index, flags); 2511e51764aSArtem Bityutskiy if (unlikely(!page)) { 2521e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 2531e51764aSArtem Bityutskiy return -ENOMEM; 2541e51764aSArtem Bityutskiy } 2551e51764aSArtem Bityutskiy 2561e51764aSArtem Bityutskiy if (!PageUptodate(page)) { 2577bbe5b5aSArtem Bityutskiy if (!(pos & ~PAGE_CACHE_MASK) && len == PAGE_CACHE_SIZE) 2581e51764aSArtem Bityutskiy SetPageChecked(page); 2591e51764aSArtem Bityutskiy else { 2601e51764aSArtem Bityutskiy err = do_readpage(page); 2611e51764aSArtem Bityutskiy if (err) { 2621e51764aSArtem Bityutskiy unlock_page(page); 2631e51764aSArtem Bityutskiy page_cache_release(page); 2641e51764aSArtem Bityutskiy return err; 2651e51764aSArtem Bityutskiy } 2661e51764aSArtem Bityutskiy } 2671e51764aSArtem Bityutskiy 2681e51764aSArtem Bityutskiy SetPageUptodate(page); 2691e51764aSArtem Bityutskiy ClearPageError(page); 2701e51764aSArtem Bityutskiy } 2711e51764aSArtem Bityutskiy 2721e51764aSArtem Bityutskiy if (PagePrivate(page)) 2731e51764aSArtem Bityutskiy /* 2741e51764aSArtem Bityutskiy * The page is dirty, which means it was budgeted twice: 2751e51764aSArtem Bityutskiy * o first time the budget was allocated by the task which 2761e51764aSArtem Bityutskiy * made the page dirty and set the PG_private flag; 2771e51764aSArtem Bityutskiy * o and then we budgeted for it for the second time at the 2781e51764aSArtem Bityutskiy * very beginning of this function. 2791e51764aSArtem Bityutskiy * 2801e51764aSArtem Bityutskiy * So what we have to do is to release the page budget we 2811e51764aSArtem Bityutskiy * allocated. 2821e51764aSArtem Bityutskiy */ 2831e51764aSArtem Bityutskiy release_new_page_budget(c); 2841e51764aSArtem Bityutskiy else if (!PageChecked(page)) 2851e51764aSArtem Bityutskiy /* 2861e51764aSArtem Bityutskiy * We are changing a page which already exists on the media. 2871e51764aSArtem Bityutskiy * This means that changing the page does not make the amount 2881e51764aSArtem Bityutskiy * of indexing information larger, and this part of the budget 2891e51764aSArtem Bityutskiy * which we have already acquired may be released. 2901e51764aSArtem Bityutskiy */ 2911e51764aSArtem Bityutskiy ubifs_convert_page_budget(c); 2921e51764aSArtem Bityutskiy 2931e51764aSArtem Bityutskiy if (appending) { 2941e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 2951e51764aSArtem Bityutskiy 2961e51764aSArtem Bityutskiy /* 2971e51764aSArtem Bityutskiy * 'ubifs_write_end()' is optimized from the fast-path part of 2981e51764aSArtem Bityutskiy * 'ubifs_write_begin()' and expects the @ui_mutex to be locked 2991e51764aSArtem Bityutskiy * if data is appended. 3001e51764aSArtem Bityutskiy */ 3011e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 3021e51764aSArtem Bityutskiy if (ui->dirty) 3031e51764aSArtem Bityutskiy /* 3041e51764aSArtem Bityutskiy * The inode is dirty already, so we may free the 3051e51764aSArtem Bityutskiy * budget we allocated. 3061e51764aSArtem Bityutskiy */ 3071e51764aSArtem Bityutskiy ubifs_release_dirty_inode_budget(c, ui); 3081e51764aSArtem Bityutskiy } 3091e51764aSArtem Bityutskiy 3101e51764aSArtem Bityutskiy *pagep = page; 3111e51764aSArtem Bityutskiy return 0; 3121e51764aSArtem Bityutskiy } 3131e51764aSArtem Bityutskiy 3141e51764aSArtem Bityutskiy /** 3151e51764aSArtem Bityutskiy * allocate_budget - allocate budget for 'ubifs_write_begin()'. 3161e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 3171e51764aSArtem Bityutskiy * @page: page to allocate budget for 3181e51764aSArtem Bityutskiy * @ui: UBIFS inode object the page belongs to 3191e51764aSArtem Bityutskiy * @appending: non-zero if the page is appended 3201e51764aSArtem Bityutskiy * 3211e51764aSArtem Bityutskiy * This is a helper function for 'ubifs_write_begin()' which allocates budget 3221e51764aSArtem Bityutskiy * for the operation. The budget is allocated differently depending on whether 3231e51764aSArtem Bityutskiy * this is appending, whether the page is dirty or not, and so on. This 3241e51764aSArtem Bityutskiy * function leaves the @ui->ui_mutex locked in case of appending. Returns zero 3251e51764aSArtem Bityutskiy * in case of success and %-ENOSPC in case of failure. 3261e51764aSArtem Bityutskiy */ 3271e51764aSArtem Bityutskiy static int allocate_budget(struct ubifs_info *c, struct page *page, 3281e51764aSArtem Bityutskiy struct ubifs_inode *ui, int appending) 3291e51764aSArtem Bityutskiy { 3301e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .fast = 1 }; 3311e51764aSArtem Bityutskiy 3321e51764aSArtem Bityutskiy if (PagePrivate(page)) { 3331e51764aSArtem Bityutskiy if (!appending) 3341e51764aSArtem Bityutskiy /* 3351e51764aSArtem Bityutskiy * The page is dirty and we are not appending, which 3361e51764aSArtem Bityutskiy * means no budget is needed at all. 3371e51764aSArtem Bityutskiy */ 3381e51764aSArtem Bityutskiy return 0; 3391e51764aSArtem Bityutskiy 3401e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 3411e51764aSArtem Bityutskiy if (ui->dirty) 3421e51764aSArtem Bityutskiy /* 3431e51764aSArtem Bityutskiy * The page is dirty and we are appending, so the inode 3441e51764aSArtem Bityutskiy * has to be marked as dirty. However, it is already 3451e51764aSArtem Bityutskiy * dirty, so we do not need any budget. We may return, 3461e51764aSArtem Bityutskiy * but @ui->ui_mutex hast to be left locked because we 3471e51764aSArtem Bityutskiy * should prevent write-back from flushing the inode 3481e51764aSArtem Bityutskiy * and freeing the budget. The lock will be released in 3491e51764aSArtem Bityutskiy * 'ubifs_write_end()'. 3501e51764aSArtem Bityutskiy */ 3511e51764aSArtem Bityutskiy return 0; 3521e51764aSArtem Bityutskiy 3531e51764aSArtem Bityutskiy /* 3541e51764aSArtem Bityutskiy * The page is dirty, we are appending, the inode is clean, so 3551e51764aSArtem Bityutskiy * we need to budget the inode change. 3561e51764aSArtem Bityutskiy */ 3571e51764aSArtem Bityutskiy req.dirtied_ino = 1; 3581e51764aSArtem Bityutskiy } else { 3591e51764aSArtem Bityutskiy if (PageChecked(page)) 3601e51764aSArtem Bityutskiy /* 3611e51764aSArtem Bityutskiy * The page corresponds to a hole and does not 3621e51764aSArtem Bityutskiy * exist on the media. So changing it makes 3631e51764aSArtem Bityutskiy * make the amount of indexing information 3641e51764aSArtem Bityutskiy * larger, and we have to budget for a new 3651e51764aSArtem Bityutskiy * page. 3661e51764aSArtem Bityutskiy */ 3671e51764aSArtem Bityutskiy req.new_page = 1; 3681e51764aSArtem Bityutskiy else 3691e51764aSArtem Bityutskiy /* 3701e51764aSArtem Bityutskiy * Not a hole, the change will not add any new 3711e51764aSArtem Bityutskiy * indexing information, budget for page 3721e51764aSArtem Bityutskiy * change. 3731e51764aSArtem Bityutskiy */ 3741e51764aSArtem Bityutskiy req.dirtied_page = 1; 3751e51764aSArtem Bityutskiy 3761e51764aSArtem Bityutskiy if (appending) { 3771e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 3781e51764aSArtem Bityutskiy if (!ui->dirty) 3791e51764aSArtem Bityutskiy /* 3801e51764aSArtem Bityutskiy * The inode is clean but we will have to mark 3811e51764aSArtem Bityutskiy * it as dirty because we are appending. This 3821e51764aSArtem Bityutskiy * needs a budget. 3831e51764aSArtem Bityutskiy */ 3841e51764aSArtem Bityutskiy req.dirtied_ino = 1; 3851e51764aSArtem Bityutskiy } 3861e51764aSArtem Bityutskiy } 3871e51764aSArtem Bityutskiy 3881e51764aSArtem Bityutskiy return ubifs_budget_space(c, &req); 3891e51764aSArtem Bityutskiy } 3901e51764aSArtem Bityutskiy 3911e51764aSArtem Bityutskiy /* 3921e51764aSArtem Bityutskiy * This function is called when a page of data is going to be written. Since 3931e51764aSArtem Bityutskiy * the page of data will not necessarily go to the flash straight away, UBIFS 3941e51764aSArtem Bityutskiy * has to reserve space on the media for it, which is done by means of 3951e51764aSArtem Bityutskiy * budgeting. 3961e51764aSArtem Bityutskiy * 3971e51764aSArtem Bityutskiy * This is the hot-path of the file-system and we are trying to optimize it as 3981e51764aSArtem Bityutskiy * much as possible. For this reasons it is split on 2 parts - slow and fast. 3991e51764aSArtem Bityutskiy * 4001e51764aSArtem Bityutskiy * There many budgeting cases: 4011e51764aSArtem Bityutskiy * o a new page is appended - we have to budget for a new page and for 4021e51764aSArtem Bityutskiy * changing the inode; however, if the inode is already dirty, there is 4031e51764aSArtem Bityutskiy * no need to budget for it; 4041e51764aSArtem Bityutskiy * o an existing clean page is changed - we have budget for it; if the page 4051e51764aSArtem Bityutskiy * does not exist on the media (a hole), we have to budget for a new 4061e51764aSArtem Bityutskiy * page; otherwise, we may budget for changing an existing page; the 4071e51764aSArtem Bityutskiy * difference between these cases is that changing an existing page does 4081e51764aSArtem Bityutskiy * not introduce anything new to the FS indexing information, so it does 4091e51764aSArtem Bityutskiy * not grow, and smaller budget is acquired in this case; 4101e51764aSArtem Bityutskiy * o an existing dirty page is changed - no need to budget at all, because 4111e51764aSArtem Bityutskiy * the page budget has been acquired by earlier, when the page has been 4121e51764aSArtem Bityutskiy * marked dirty. 4131e51764aSArtem Bityutskiy * 4141e51764aSArtem Bityutskiy * UBIFS budgeting sub-system may force write-back if it thinks there is no 4151e51764aSArtem Bityutskiy * space to reserve. This imposes some locking restrictions and makes it 4161e51764aSArtem Bityutskiy * impossible to take into account the above cases, and makes it impossible to 4171e51764aSArtem Bityutskiy * optimize budgeting. 4181e51764aSArtem Bityutskiy * 4191e51764aSArtem Bityutskiy * The solution for this is that the fast path of 'ubifs_write_begin()' assumes 4201e51764aSArtem Bityutskiy * there is a plenty of flash space and the budget will be acquired quickly, 4211e51764aSArtem Bityutskiy * without forcing write-back. The slow path does not make this assumption. 4221e51764aSArtem Bityutskiy */ 4231e51764aSArtem Bityutskiy static int ubifs_write_begin(struct file *file, struct address_space *mapping, 4241e51764aSArtem Bityutskiy loff_t pos, unsigned len, unsigned flags, 4251e51764aSArtem Bityutskiy struct page **pagep, void **fsdata) 4261e51764aSArtem Bityutskiy { 4271e51764aSArtem Bityutskiy struct inode *inode = mapping->host; 4281e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 4291e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 4301e51764aSArtem Bityutskiy pgoff_t index = pos >> PAGE_CACHE_SHIFT; 4311e51764aSArtem Bityutskiy int uninitialized_var(err), appending = !!(pos + len > inode->i_size); 432f55aa591SAdrian Hunter int skipped_read = 0; 4331e51764aSArtem Bityutskiy struct page *page; 4341e51764aSArtem Bityutskiy 4351e51764aSArtem Bityutskiy ubifs_assert(ubifs_inode(inode)->ui_size == inode->i_size); 4361e51764aSArtem Bityutskiy 4371e51764aSArtem Bityutskiy if (unlikely(c->ro_media)) 4381e51764aSArtem Bityutskiy return -EROFS; 4391e51764aSArtem Bityutskiy 4401e51764aSArtem Bityutskiy /* Try out the fast-path part first */ 44154566b2cSNick Piggin page = grab_cache_page_write_begin(mapping, index, flags); 4421e51764aSArtem Bityutskiy if (unlikely(!page)) 4431e51764aSArtem Bityutskiy return -ENOMEM; 4441e51764aSArtem Bityutskiy 4451e51764aSArtem Bityutskiy if (!PageUptodate(page)) { 4461e51764aSArtem Bityutskiy /* The page is not loaded from the flash */ 447f55aa591SAdrian Hunter if (!(pos & ~PAGE_CACHE_MASK) && len == PAGE_CACHE_SIZE) { 4481e51764aSArtem Bityutskiy /* 4491e51764aSArtem Bityutskiy * We change whole page so no need to load it. But we 4501e51764aSArtem Bityutskiy * have to set the @PG_checked flag to make the further 451873a64c7SArtem Bityutskiy * code know that the page is new. This might be not 452873a64c7SArtem Bityutskiy * true, but it is better to budget more than to read 453873a64c7SArtem Bityutskiy * the page from the media. 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); 4611e51764aSArtem Bityutskiy page_cache_release(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)) { 4721e51764aSArtem Bityutskiy ubifs_assert(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) { 4891e51764aSArtem Bityutskiy ubifs_assert(mutex_is_locked(&ui->ui_mutex)); 4901e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 4911e51764aSArtem Bityutskiy } 4921e51764aSArtem Bityutskiy unlock_page(page); 4931e51764aSArtem Bityutskiy page_cache_release(page); 4941e51764aSArtem Bityutskiy 49554566b2cSNick Piggin return write_begin_slow(mapping, pos, len, pagep, flags); 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 5481e51764aSArtem Bityutskiy if (unlikely(copied < len && len == PAGE_CACHE_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 5531e51764aSArtem Bityutskiy * @PAGE_CACHE_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); 5611e51764aSArtem Bityutskiy 5621e51764aSArtem Bityutskiy /* 5631e51764aSArtem Bityutskiy * Return 0 to force VFS to repeat the whole operation, or the 564873a64c7SArtem Bityutskiy * error code if 'do_readpage()' fails. 5651e51764aSArtem Bityutskiy */ 5661e51764aSArtem Bityutskiy copied = do_readpage(page); 5671e51764aSArtem Bityutskiy goto out; 5681e51764aSArtem Bityutskiy } 5691e51764aSArtem Bityutskiy 5701e51764aSArtem Bityutskiy if (!PagePrivate(page)) { 5711e51764aSArtem Bityutskiy SetPagePrivate(page); 5721e51764aSArtem Bityutskiy atomic_long_inc(&c->dirty_pg_cnt); 5731e51764aSArtem Bityutskiy __set_page_dirty_nobuffers(page); 5741e51764aSArtem Bityutskiy } 5751e51764aSArtem Bityutskiy 5761e51764aSArtem Bityutskiy if (appending) { 5771e51764aSArtem Bityutskiy i_size_write(inode, end_pos); 5781e51764aSArtem Bityutskiy ui->ui_size = end_pos; 5791e51764aSArtem Bityutskiy /* 5801e51764aSArtem Bityutskiy * Note, we do not set @I_DIRTY_PAGES (which means that the 5811e51764aSArtem Bityutskiy * inode has dirty pages), this has been done in 5821e51764aSArtem Bityutskiy * '__set_page_dirty_nobuffers()'. 5831e51764aSArtem Bityutskiy */ 5841e51764aSArtem Bityutskiy __mark_inode_dirty(inode, I_DIRTY_DATASYNC); 5851e51764aSArtem Bityutskiy ubifs_assert(mutex_is_locked(&ui->ui_mutex)); 5861e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 5871e51764aSArtem Bityutskiy } 5881e51764aSArtem Bityutskiy 5891e51764aSArtem Bityutskiy out: 5901e51764aSArtem Bityutskiy unlock_page(page); 5911e51764aSArtem Bityutskiy page_cache_release(page); 5921e51764aSArtem Bityutskiy return copied; 5931e51764aSArtem Bityutskiy } 5941e51764aSArtem Bityutskiy 5954793e7c5SAdrian Hunter /** 5964793e7c5SAdrian Hunter * populate_page - copy data nodes into a page for bulk-read. 5974793e7c5SAdrian Hunter * @c: UBIFS file-system description object 5984793e7c5SAdrian Hunter * @page: page 5994793e7c5SAdrian Hunter * @bu: bulk-read information 6004793e7c5SAdrian Hunter * @n: next zbranch slot 6014793e7c5SAdrian Hunter * 6024793e7c5SAdrian Hunter * This function returns %0 on success and a negative error code on failure. 6034793e7c5SAdrian Hunter */ 6044793e7c5SAdrian Hunter static int populate_page(struct ubifs_info *c, struct page *page, 6054793e7c5SAdrian Hunter struct bu_info *bu, int *n) 6064793e7c5SAdrian Hunter { 6075c0013c1SAdrian Hunter int i = 0, nn = *n, offs = bu->zbranch[0].offs, hole = 0, read = 0; 6084793e7c5SAdrian Hunter struct inode *inode = page->mapping->host; 6094793e7c5SAdrian Hunter loff_t i_size = i_size_read(inode); 6104793e7c5SAdrian Hunter unsigned int page_block; 6114793e7c5SAdrian Hunter void *addr, *zaddr; 6124793e7c5SAdrian Hunter pgoff_t end_index; 6134793e7c5SAdrian Hunter 6144793e7c5SAdrian Hunter dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx", 6154793e7c5SAdrian Hunter inode->i_ino, page->index, i_size, page->flags); 6164793e7c5SAdrian Hunter 6174793e7c5SAdrian Hunter addr = zaddr = kmap(page); 6184793e7c5SAdrian Hunter 619ed382d58SAdrian Hunter end_index = (i_size - 1) >> PAGE_CACHE_SHIFT; 6204793e7c5SAdrian Hunter if (!i_size || page->index > end_index) { 6215c0013c1SAdrian Hunter hole = 1; 6224793e7c5SAdrian Hunter memset(addr, 0, PAGE_CACHE_SIZE); 6234793e7c5SAdrian Hunter goto out_hole; 6244793e7c5SAdrian Hunter } 6254793e7c5SAdrian Hunter 6264793e7c5SAdrian Hunter page_block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT; 6274793e7c5SAdrian Hunter while (1) { 6284793e7c5SAdrian Hunter int err, len, out_len, dlen; 6294793e7c5SAdrian Hunter 6305c0013c1SAdrian Hunter if (nn >= bu->cnt) { 6315c0013c1SAdrian Hunter hole = 1; 6324793e7c5SAdrian Hunter memset(addr, 0, UBIFS_BLOCK_SIZE); 6335c0013c1SAdrian Hunter } else if (key_block(c, &bu->zbranch[nn].key) == page_block) { 6344793e7c5SAdrian Hunter struct ubifs_data_node *dn; 6354793e7c5SAdrian Hunter 6364793e7c5SAdrian Hunter dn = bu->buf + (bu->zbranch[nn].offs - offs); 6374793e7c5SAdrian Hunter 6380ecb9529SHarvey Harrison ubifs_assert(le64_to_cpu(dn->ch.sqnum) > 6394793e7c5SAdrian Hunter ubifs_inode(inode)->creat_sqnum); 6404793e7c5SAdrian Hunter 6414793e7c5SAdrian Hunter len = le32_to_cpu(dn->size); 6424793e7c5SAdrian Hunter if (len <= 0 || len > UBIFS_BLOCK_SIZE) 6434793e7c5SAdrian Hunter goto out_err; 6444793e7c5SAdrian Hunter 6454793e7c5SAdrian Hunter dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ; 6464793e7c5SAdrian Hunter out_len = UBIFS_BLOCK_SIZE; 6474793e7c5SAdrian Hunter err = ubifs_decompress(&dn->data, dlen, addr, &out_len, 6484793e7c5SAdrian Hunter le16_to_cpu(dn->compr_type)); 6494793e7c5SAdrian Hunter if (err || len != out_len) 6504793e7c5SAdrian Hunter goto out_err; 6514793e7c5SAdrian Hunter 6524793e7c5SAdrian Hunter if (len < UBIFS_BLOCK_SIZE) 6534793e7c5SAdrian Hunter memset(addr + len, 0, UBIFS_BLOCK_SIZE - len); 6544793e7c5SAdrian Hunter 6554793e7c5SAdrian Hunter nn += 1; 6564793e7c5SAdrian Hunter read = (i << UBIFS_BLOCK_SHIFT) + len; 6575c0013c1SAdrian Hunter } else if (key_block(c, &bu->zbranch[nn].key) < page_block) { 6585c0013c1SAdrian Hunter nn += 1; 6595c0013c1SAdrian Hunter continue; 6605c0013c1SAdrian Hunter } else { 6615c0013c1SAdrian Hunter hole = 1; 6625c0013c1SAdrian Hunter memset(addr, 0, UBIFS_BLOCK_SIZE); 6634793e7c5SAdrian Hunter } 6644793e7c5SAdrian Hunter if (++i >= UBIFS_BLOCKS_PER_PAGE) 6654793e7c5SAdrian Hunter break; 6664793e7c5SAdrian Hunter addr += UBIFS_BLOCK_SIZE; 6674793e7c5SAdrian Hunter page_block += 1; 6684793e7c5SAdrian Hunter } 6694793e7c5SAdrian Hunter 6704793e7c5SAdrian Hunter if (end_index == page->index) { 6714793e7c5SAdrian Hunter int len = i_size & (PAGE_CACHE_SIZE - 1); 6724793e7c5SAdrian Hunter 673ed382d58SAdrian Hunter if (len && len < read) 6744793e7c5SAdrian Hunter memset(zaddr + len, 0, read - len); 6754793e7c5SAdrian Hunter } 6764793e7c5SAdrian Hunter 6774793e7c5SAdrian Hunter out_hole: 6784793e7c5SAdrian Hunter if (hole) { 6794793e7c5SAdrian Hunter SetPageChecked(page); 6804793e7c5SAdrian Hunter dbg_gen("hole"); 6814793e7c5SAdrian Hunter } 6824793e7c5SAdrian Hunter 6834793e7c5SAdrian Hunter SetPageUptodate(page); 6844793e7c5SAdrian Hunter ClearPageError(page); 6854793e7c5SAdrian Hunter flush_dcache_page(page); 6864793e7c5SAdrian Hunter kunmap(page); 6874793e7c5SAdrian Hunter *n = nn; 6884793e7c5SAdrian Hunter return 0; 6894793e7c5SAdrian Hunter 6904793e7c5SAdrian Hunter out_err: 6914793e7c5SAdrian Hunter ClearPageUptodate(page); 6924793e7c5SAdrian Hunter SetPageError(page); 6934793e7c5SAdrian Hunter flush_dcache_page(page); 6944793e7c5SAdrian Hunter kunmap(page); 6954793e7c5SAdrian Hunter ubifs_err("bad data node (block %u, inode %lu)", 6964793e7c5SAdrian Hunter page_block, inode->i_ino); 6974793e7c5SAdrian Hunter return -EINVAL; 6984793e7c5SAdrian Hunter } 6994793e7c5SAdrian Hunter 7004793e7c5SAdrian Hunter /** 7014793e7c5SAdrian Hunter * ubifs_do_bulk_read - do bulk-read. 7024793e7c5SAdrian Hunter * @c: UBIFS file-system description object 7036c0c42cdSArtem Bityutskiy * @bu: bulk-read information 7046c0c42cdSArtem Bityutskiy * @page1: first page to read 7054793e7c5SAdrian Hunter * 7064793e7c5SAdrian Hunter * This function returns %1 if the bulk-read is done, otherwise %0 is returned. 7074793e7c5SAdrian Hunter */ 7086c0c42cdSArtem Bityutskiy static int ubifs_do_bulk_read(struct ubifs_info *c, struct bu_info *bu, 7096c0c42cdSArtem Bityutskiy struct page *page1) 7104793e7c5SAdrian Hunter { 7114793e7c5SAdrian Hunter pgoff_t offset = page1->index, end_index; 7124793e7c5SAdrian Hunter struct address_space *mapping = page1->mapping; 7134793e7c5SAdrian Hunter struct inode *inode = mapping->host; 7144793e7c5SAdrian Hunter struct ubifs_inode *ui = ubifs_inode(inode); 7154793e7c5SAdrian Hunter int err, page_idx, page_cnt, ret = 0, n = 0; 7166c0c42cdSArtem Bityutskiy int allocate = bu->buf ? 0 : 1; 7174793e7c5SAdrian Hunter loff_t isize; 7184793e7c5SAdrian Hunter 7194793e7c5SAdrian Hunter err = ubifs_tnc_get_bu_keys(c, bu); 7204793e7c5SAdrian Hunter if (err) 7214793e7c5SAdrian Hunter goto out_warn; 7224793e7c5SAdrian Hunter 7234793e7c5SAdrian Hunter if (bu->eof) { 7244793e7c5SAdrian Hunter /* Turn off bulk-read at the end of the file */ 7254793e7c5SAdrian Hunter ui->read_in_a_row = 1; 7264793e7c5SAdrian Hunter ui->bulk_read = 0; 7274793e7c5SAdrian Hunter } 7284793e7c5SAdrian Hunter 7294793e7c5SAdrian Hunter page_cnt = bu->blk_cnt >> UBIFS_BLOCKS_PER_PAGE_SHIFT; 7304793e7c5SAdrian Hunter if (!page_cnt) { 7314793e7c5SAdrian Hunter /* 7324793e7c5SAdrian Hunter * This happens when there are multiple blocks per page and the 7334793e7c5SAdrian Hunter * blocks for the first page we are looking for, are not 7344793e7c5SAdrian Hunter * together. If all the pages were like this, bulk-read would 7354793e7c5SAdrian Hunter * reduce performance, so we turn it off for a while. 7364793e7c5SAdrian Hunter */ 7376c0c42cdSArtem Bityutskiy goto out_bu_off; 7384793e7c5SAdrian Hunter } 7394793e7c5SAdrian Hunter 7404793e7c5SAdrian Hunter if (bu->cnt) { 7416c0c42cdSArtem Bityutskiy if (allocate) { 7426c0c42cdSArtem Bityutskiy /* 7436c0c42cdSArtem Bityutskiy * Allocate bulk-read buffer depending on how many data 7446c0c42cdSArtem Bityutskiy * nodes we are going to read. 7456c0c42cdSArtem Bityutskiy */ 7466c0c42cdSArtem Bityutskiy bu->buf_len = bu->zbranch[bu->cnt - 1].offs + 7476c0c42cdSArtem Bityutskiy bu->zbranch[bu->cnt - 1].len - 7486c0c42cdSArtem Bityutskiy bu->zbranch[0].offs; 7496c0c42cdSArtem Bityutskiy ubifs_assert(bu->buf_len > 0); 7506c0c42cdSArtem Bityutskiy ubifs_assert(bu->buf_len <= c->leb_size); 7516c0c42cdSArtem Bityutskiy bu->buf = kmalloc(bu->buf_len, GFP_NOFS | __GFP_NOWARN); 7526c0c42cdSArtem Bityutskiy if (!bu->buf) 7536c0c42cdSArtem Bityutskiy goto out_bu_off; 7546c0c42cdSArtem Bityutskiy } 7556c0c42cdSArtem Bityutskiy 7564793e7c5SAdrian Hunter err = ubifs_tnc_bulk_read(c, bu); 7574793e7c5SAdrian Hunter if (err) 7584793e7c5SAdrian Hunter goto out_warn; 7594793e7c5SAdrian Hunter } 7604793e7c5SAdrian Hunter 7614793e7c5SAdrian Hunter err = populate_page(c, page1, bu, &n); 7624793e7c5SAdrian Hunter if (err) 7634793e7c5SAdrian Hunter goto out_warn; 7644793e7c5SAdrian Hunter 7654793e7c5SAdrian Hunter unlock_page(page1); 7664793e7c5SAdrian Hunter ret = 1; 7674793e7c5SAdrian Hunter 7684793e7c5SAdrian Hunter isize = i_size_read(inode); 7694793e7c5SAdrian Hunter if (isize == 0) 7704793e7c5SAdrian Hunter goto out_free; 7714793e7c5SAdrian Hunter end_index = ((isize - 1) >> PAGE_CACHE_SHIFT); 7724793e7c5SAdrian Hunter 7734793e7c5SAdrian Hunter for (page_idx = 1; page_idx < page_cnt; page_idx++) { 7744793e7c5SAdrian Hunter pgoff_t page_offset = offset + page_idx; 7754793e7c5SAdrian Hunter struct page *page; 7764793e7c5SAdrian Hunter 7774793e7c5SAdrian Hunter if (page_offset > end_index) 7784793e7c5SAdrian Hunter break; 7794793e7c5SAdrian Hunter page = find_or_create_page(mapping, page_offset, 7804793e7c5SAdrian Hunter GFP_NOFS | __GFP_COLD); 7814793e7c5SAdrian Hunter if (!page) 7824793e7c5SAdrian Hunter break; 7834793e7c5SAdrian Hunter if (!PageUptodate(page)) 7844793e7c5SAdrian Hunter err = populate_page(c, page, bu, &n); 7854793e7c5SAdrian Hunter unlock_page(page); 7864793e7c5SAdrian Hunter page_cache_release(page); 7874793e7c5SAdrian Hunter if (err) 7884793e7c5SAdrian Hunter break; 7894793e7c5SAdrian Hunter } 7904793e7c5SAdrian Hunter 7914793e7c5SAdrian Hunter ui->last_page_read = offset + page_idx - 1; 7924793e7c5SAdrian Hunter 7934793e7c5SAdrian Hunter out_free: 7946c0c42cdSArtem Bityutskiy if (allocate) 7954793e7c5SAdrian Hunter kfree(bu->buf); 7964793e7c5SAdrian Hunter return ret; 7974793e7c5SAdrian Hunter 7984793e7c5SAdrian Hunter out_warn: 7994793e7c5SAdrian Hunter ubifs_warn("ignoring error %d and skipping bulk-read", err); 8004793e7c5SAdrian Hunter goto out_free; 8016c0c42cdSArtem Bityutskiy 8026c0c42cdSArtem Bityutskiy out_bu_off: 8036c0c42cdSArtem Bityutskiy ui->read_in_a_row = ui->bulk_read = 0; 8046c0c42cdSArtem Bityutskiy goto out_free; 8054793e7c5SAdrian Hunter } 8064793e7c5SAdrian Hunter 8074793e7c5SAdrian Hunter /** 8084793e7c5SAdrian Hunter * ubifs_bulk_read - determine whether to bulk-read and, if so, do it. 8094793e7c5SAdrian Hunter * @page: page from which to start bulk-read. 8104793e7c5SAdrian Hunter * 8114793e7c5SAdrian Hunter * Some flash media are capable of reading sequentially at faster rates. UBIFS 8124793e7c5SAdrian Hunter * bulk-read facility is designed to take advantage of that, by reading in one 8134793e7c5SAdrian Hunter * go consecutive data nodes that are also located consecutively in the same 8144793e7c5SAdrian Hunter * LEB. This function returns %1 if a bulk-read is done and %0 otherwise. 8154793e7c5SAdrian Hunter */ 8164793e7c5SAdrian Hunter static int ubifs_bulk_read(struct page *page) 8174793e7c5SAdrian Hunter { 8184793e7c5SAdrian Hunter struct inode *inode = page->mapping->host; 8194793e7c5SAdrian Hunter struct ubifs_info *c = inode->i_sb->s_fs_info; 8204793e7c5SAdrian Hunter struct ubifs_inode *ui = ubifs_inode(inode); 8214793e7c5SAdrian Hunter pgoff_t index = page->index, last_page_read = ui->last_page_read; 8226c0c42cdSArtem Bityutskiy struct bu_info *bu; 8233477d204SArtem Bityutskiy int err = 0, allocated = 0; 8244793e7c5SAdrian Hunter 8254793e7c5SAdrian Hunter ui->last_page_read = index; 8264793e7c5SAdrian Hunter if (!c->bulk_read) 8274793e7c5SAdrian Hunter return 0; 8286c0c42cdSArtem Bityutskiy 8294793e7c5SAdrian Hunter /* 8303477d204SArtem Bityutskiy * Bulk-read is protected by @ui->ui_mutex, but it is an optimization, 8313477d204SArtem Bityutskiy * so don't bother if we cannot lock the mutex. 8324793e7c5SAdrian Hunter */ 8334793e7c5SAdrian Hunter if (!mutex_trylock(&ui->ui_mutex)) 8344793e7c5SAdrian Hunter return 0; 8356c0c42cdSArtem Bityutskiy 8364793e7c5SAdrian Hunter if (index != last_page_read + 1) { 8374793e7c5SAdrian Hunter /* Turn off bulk-read if we stop reading sequentially */ 8384793e7c5SAdrian Hunter ui->read_in_a_row = 1; 8394793e7c5SAdrian Hunter if (ui->bulk_read) 8404793e7c5SAdrian Hunter ui->bulk_read = 0; 8414793e7c5SAdrian Hunter goto out_unlock; 8424793e7c5SAdrian Hunter } 8436c0c42cdSArtem Bityutskiy 8444793e7c5SAdrian Hunter if (!ui->bulk_read) { 8454793e7c5SAdrian Hunter ui->read_in_a_row += 1; 8464793e7c5SAdrian Hunter if (ui->read_in_a_row < 3) 8474793e7c5SAdrian Hunter goto out_unlock; 8484793e7c5SAdrian Hunter /* Three reads in a row, so switch on bulk-read */ 8494793e7c5SAdrian Hunter ui->bulk_read = 1; 8504793e7c5SAdrian Hunter } 8516c0c42cdSArtem Bityutskiy 8523477d204SArtem Bityutskiy /* 8533477d204SArtem Bityutskiy * If possible, try to use pre-allocated bulk-read information, which 8543477d204SArtem Bityutskiy * is protected by @c->bu_mutex. 8553477d204SArtem Bityutskiy */ 8563477d204SArtem Bityutskiy if (mutex_trylock(&c->bu_mutex)) 8573477d204SArtem Bityutskiy bu = &c->bu; 8583477d204SArtem Bityutskiy else { 8596c0c42cdSArtem Bityutskiy bu = kmalloc(sizeof(struct bu_info), GFP_NOFS | __GFP_NOWARN); 8606c0c42cdSArtem Bityutskiy if (!bu) 8613477d204SArtem Bityutskiy goto out_unlock; 8626c0c42cdSArtem Bityutskiy 8636c0c42cdSArtem Bityutskiy bu->buf = NULL; 8643477d204SArtem Bityutskiy allocated = 1; 8653477d204SArtem Bityutskiy } 8663477d204SArtem Bityutskiy 8676c0c42cdSArtem Bityutskiy bu->buf_len = c->max_bu_buf_len; 8686c0c42cdSArtem Bityutskiy data_key_init(c, &bu->key, inode->i_ino, 8696c0c42cdSArtem Bityutskiy page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT); 8706c0c42cdSArtem Bityutskiy err = ubifs_do_bulk_read(c, bu, page); 8713477d204SArtem Bityutskiy 8723477d204SArtem Bityutskiy if (!allocated) 8733477d204SArtem Bityutskiy mutex_unlock(&c->bu_mutex); 8743477d204SArtem Bityutskiy else 8756c0c42cdSArtem Bityutskiy kfree(bu); 8766c0c42cdSArtem Bityutskiy 8774793e7c5SAdrian Hunter out_unlock: 8784793e7c5SAdrian Hunter mutex_unlock(&ui->ui_mutex); 8796c0c42cdSArtem Bityutskiy return err; 8804793e7c5SAdrian Hunter } 8814793e7c5SAdrian Hunter 8821e51764aSArtem Bityutskiy static int ubifs_readpage(struct file *file, struct page *page) 8831e51764aSArtem Bityutskiy { 8844793e7c5SAdrian Hunter if (ubifs_bulk_read(page)) 8854793e7c5SAdrian Hunter return 0; 8861e51764aSArtem Bityutskiy do_readpage(page); 8871e51764aSArtem Bityutskiy unlock_page(page); 8881e51764aSArtem Bityutskiy return 0; 8891e51764aSArtem Bityutskiy } 8901e51764aSArtem Bityutskiy 8911e51764aSArtem Bityutskiy static int do_writepage(struct page *page, int len) 8921e51764aSArtem Bityutskiy { 8931e51764aSArtem Bityutskiy int err = 0, i, blen; 8941e51764aSArtem Bityutskiy unsigned int block; 8951e51764aSArtem Bityutskiy void *addr; 8961e51764aSArtem Bityutskiy union ubifs_key key; 8971e51764aSArtem Bityutskiy struct inode *inode = page->mapping->host; 8981e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 8991e51764aSArtem Bityutskiy 9001e51764aSArtem Bityutskiy #ifdef UBIFS_DEBUG 9011e51764aSArtem Bityutskiy spin_lock(&ui->ui_lock); 9021e51764aSArtem Bityutskiy ubifs_assert(page->index <= ui->synced_i_size << PAGE_CACHE_SIZE); 9031e51764aSArtem Bityutskiy spin_unlock(&ui->ui_lock); 9041e51764aSArtem Bityutskiy #endif 9051e51764aSArtem Bityutskiy 9061e51764aSArtem Bityutskiy /* Update radix tree tags */ 9071e51764aSArtem Bityutskiy set_page_writeback(page); 9081e51764aSArtem Bityutskiy 9091e51764aSArtem Bityutskiy addr = kmap(page); 9101e51764aSArtem Bityutskiy block = page->index << UBIFS_BLOCKS_PER_PAGE_SHIFT; 9111e51764aSArtem Bityutskiy i = 0; 9121e51764aSArtem Bityutskiy while (len) { 9131e51764aSArtem Bityutskiy blen = min_t(int, len, UBIFS_BLOCK_SIZE); 9141e51764aSArtem Bityutskiy data_key_init(c, &key, inode->i_ino, block); 9151e51764aSArtem Bityutskiy err = ubifs_jnl_write_data(c, inode, &key, addr, blen); 9161e51764aSArtem Bityutskiy if (err) 9171e51764aSArtem Bityutskiy break; 9181e51764aSArtem Bityutskiy if (++i >= UBIFS_BLOCKS_PER_PAGE) 9191e51764aSArtem Bityutskiy break; 9201e51764aSArtem Bityutskiy block += 1; 9211e51764aSArtem Bityutskiy addr += blen; 9221e51764aSArtem Bityutskiy len -= blen; 9231e51764aSArtem Bityutskiy } 9241e51764aSArtem Bityutskiy if (err) { 9251e51764aSArtem Bityutskiy SetPageError(page); 9261e51764aSArtem Bityutskiy ubifs_err("cannot write page %lu of inode %lu, error %d", 9271e51764aSArtem Bityutskiy page->index, inode->i_ino, err); 9281e51764aSArtem Bityutskiy ubifs_ro_mode(c, err); 9291e51764aSArtem Bityutskiy } 9301e51764aSArtem Bityutskiy 9311e51764aSArtem Bityutskiy ubifs_assert(PagePrivate(page)); 9321e51764aSArtem Bityutskiy if (PageChecked(page)) 9331e51764aSArtem Bityutskiy release_new_page_budget(c); 9341e51764aSArtem Bityutskiy else 9351e51764aSArtem Bityutskiy release_existing_page_budget(c); 9361e51764aSArtem Bityutskiy 9371e51764aSArtem Bityutskiy atomic_long_dec(&c->dirty_pg_cnt); 9381e51764aSArtem Bityutskiy ClearPagePrivate(page); 9391e51764aSArtem Bityutskiy ClearPageChecked(page); 9401e51764aSArtem Bityutskiy 9411e51764aSArtem Bityutskiy kunmap(page); 9421e51764aSArtem Bityutskiy unlock_page(page); 9431e51764aSArtem Bityutskiy end_page_writeback(page); 9441e51764aSArtem Bityutskiy return err; 9451e51764aSArtem Bityutskiy } 9461e51764aSArtem Bityutskiy 9471e51764aSArtem Bityutskiy /* 9481e51764aSArtem Bityutskiy * When writing-back dirty inodes, VFS first writes-back pages belonging to the 9491e51764aSArtem Bityutskiy * inode, then the inode itself. For UBIFS this may cause a problem. Consider a 9501e51764aSArtem Bityutskiy * situation when a we have an inode with size 0, then a megabyte of data is 9511e51764aSArtem Bityutskiy * appended to the inode, then write-back starts and flushes some amount of the 9521e51764aSArtem Bityutskiy * dirty pages, the journal becomes full, commit happens and finishes, and then 9531e51764aSArtem Bityutskiy * an unclean reboot happens. When the file system is mounted next time, the 9541e51764aSArtem Bityutskiy * inode size would still be 0, but there would be many pages which are beyond 9551e51764aSArtem Bityutskiy * the inode size, they would be indexed and consume flash space. Because the 9561e51764aSArtem Bityutskiy * journal has been committed, the replay would not be able to detect this 9571e51764aSArtem Bityutskiy * situation and correct the inode size. This means UBIFS would have to scan 9581e51764aSArtem Bityutskiy * whole index and correct all inode sizes, which is long an unacceptable. 9591e51764aSArtem Bityutskiy * 9601e51764aSArtem Bityutskiy * To prevent situations like this, UBIFS writes pages back only if they are 9617d4e9ccbSArtem Bityutskiy * within the last synchronized inode size, i.e. the size which has been 9621e51764aSArtem Bityutskiy * written to the flash media last time. Otherwise, UBIFS forces inode 9631e51764aSArtem Bityutskiy * write-back, thus making sure the on-flash inode contains current inode size, 9641e51764aSArtem Bityutskiy * and then keeps writing pages back. 9651e51764aSArtem Bityutskiy * 9661e51764aSArtem Bityutskiy * Some locking issues explanation. 'ubifs_writepage()' first is called with 9671e51764aSArtem Bityutskiy * the page locked, and it locks @ui_mutex. However, write-back does take inode 9681e51764aSArtem Bityutskiy * @i_mutex, which means other VFS operations may be run on this inode at the 9691e51764aSArtem Bityutskiy * same time. And the problematic one is truncation to smaller size, from where 9701e51764aSArtem Bityutskiy * we have to call 'vmtruncate()', which first changes @inode->i_size, then 9711e51764aSArtem Bityutskiy * drops the truncated pages. And while dropping the pages, it takes the page 9721e51764aSArtem Bityutskiy * lock. This means that 'do_truncation()' cannot call 'vmtruncate()' with 9731e51764aSArtem Bityutskiy * @ui_mutex locked, because it would deadlock with 'ubifs_writepage()'. This 9741e51764aSArtem Bityutskiy * means that @inode->i_size is changed while @ui_mutex is unlocked. 9751e51764aSArtem Bityutskiy * 9761e51764aSArtem Bityutskiy * But in 'ubifs_writepage()' we have to guarantee that we do not write beyond 9771e51764aSArtem Bityutskiy * inode size. How do we do this if @inode->i_size may became smaller while we 9781e51764aSArtem Bityutskiy * are in the middle of 'ubifs_writepage()'? The UBIFS solution is the 9791e51764aSArtem Bityutskiy * @ui->ui_isize "shadow" field which UBIFS uses instead of @inode->i_size 9801e51764aSArtem Bityutskiy * internally and updates it under @ui_mutex. 9811e51764aSArtem Bityutskiy * 9821e51764aSArtem Bityutskiy * Q: why we do not worry that if we race with truncation, we may end up with a 9831e51764aSArtem Bityutskiy * situation when the inode is truncated while we are in the middle of 9841e51764aSArtem Bityutskiy * 'do_writepage()', so we do write beyond inode size? 9851e51764aSArtem Bityutskiy * A: If we are in the middle of 'do_writepage()', truncation would be locked 9861e51764aSArtem Bityutskiy * on the page lock and it would not write the truncated inode node to the 9871e51764aSArtem Bityutskiy * journal before we have finished. 9881e51764aSArtem Bityutskiy */ 9891e51764aSArtem Bityutskiy static int ubifs_writepage(struct page *page, struct writeback_control *wbc) 9901e51764aSArtem Bityutskiy { 9911e51764aSArtem Bityutskiy struct inode *inode = page->mapping->host; 9921e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 9931e51764aSArtem Bityutskiy loff_t i_size = i_size_read(inode), synced_i_size; 9941e51764aSArtem Bityutskiy pgoff_t end_index = i_size >> PAGE_CACHE_SHIFT; 9951e51764aSArtem Bityutskiy int err, len = i_size & (PAGE_CACHE_SIZE - 1); 9961e51764aSArtem Bityutskiy void *kaddr; 9971e51764aSArtem Bityutskiy 9981e51764aSArtem Bityutskiy dbg_gen("ino %lu, pg %lu, pg flags %#lx", 9991e51764aSArtem Bityutskiy inode->i_ino, page->index, page->flags); 10001e51764aSArtem Bityutskiy ubifs_assert(PagePrivate(page)); 10011e51764aSArtem Bityutskiy 10021e51764aSArtem Bityutskiy /* Is the page fully outside @i_size? (truncate in progress) */ 10031e51764aSArtem Bityutskiy if (page->index > end_index || (page->index == end_index && !len)) { 10041e51764aSArtem Bityutskiy err = 0; 10051e51764aSArtem Bityutskiy goto out_unlock; 10061e51764aSArtem Bityutskiy } 10071e51764aSArtem Bityutskiy 10081e51764aSArtem Bityutskiy spin_lock(&ui->ui_lock); 10091e51764aSArtem Bityutskiy synced_i_size = ui->synced_i_size; 10101e51764aSArtem Bityutskiy spin_unlock(&ui->ui_lock); 10111e51764aSArtem Bityutskiy 10121e51764aSArtem Bityutskiy /* Is the page fully inside @i_size? */ 10131e51764aSArtem Bityutskiy if (page->index < end_index) { 10141e51764aSArtem Bityutskiy if (page->index >= synced_i_size >> PAGE_CACHE_SHIFT) { 1015a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL); 10161e51764aSArtem Bityutskiy if (err) 10171e51764aSArtem Bityutskiy goto out_unlock; 10181e51764aSArtem Bityutskiy /* 10191e51764aSArtem Bityutskiy * The inode has been written, but the write-buffer has 10201e51764aSArtem Bityutskiy * not been synchronized, so in case of an unclean 10211e51764aSArtem Bityutskiy * reboot we may end up with some pages beyond inode 10221e51764aSArtem Bityutskiy * size, but they would be in the journal (because 10231e51764aSArtem Bityutskiy * commit flushes write buffers) and recovery would deal 10241e51764aSArtem Bityutskiy * with this. 10251e51764aSArtem Bityutskiy */ 10261e51764aSArtem Bityutskiy } 10271e51764aSArtem Bityutskiy return do_writepage(page, PAGE_CACHE_SIZE); 10281e51764aSArtem Bityutskiy } 10291e51764aSArtem Bityutskiy 10301e51764aSArtem Bityutskiy /* 10311e51764aSArtem Bityutskiy * The page straddles @i_size. It must be zeroed out on each and every 10321e51764aSArtem Bityutskiy * writepage invocation because it may be mmapped. "A file is mapped 10331e51764aSArtem Bityutskiy * in multiples of the page size. For a file that is not a multiple of 10341e51764aSArtem Bityutskiy * the page size, the remaining memory is zeroed when mapped, and 10351e51764aSArtem Bityutskiy * writes to that region are not written out to the file." 10361e51764aSArtem Bityutskiy */ 10371e51764aSArtem Bityutskiy kaddr = kmap_atomic(page, KM_USER0); 10381e51764aSArtem Bityutskiy memset(kaddr + len, 0, PAGE_CACHE_SIZE - len); 10391e51764aSArtem Bityutskiy flush_dcache_page(page); 10401e51764aSArtem Bityutskiy kunmap_atomic(kaddr, KM_USER0); 10411e51764aSArtem Bityutskiy 10421e51764aSArtem Bityutskiy if (i_size > synced_i_size) { 1043a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL); 10441e51764aSArtem Bityutskiy if (err) 10451e51764aSArtem Bityutskiy goto out_unlock; 10461e51764aSArtem Bityutskiy } 10471e51764aSArtem Bityutskiy 10481e51764aSArtem Bityutskiy return do_writepage(page, len); 10491e51764aSArtem Bityutskiy 10501e51764aSArtem Bityutskiy out_unlock: 10511e51764aSArtem Bityutskiy unlock_page(page); 10521e51764aSArtem Bityutskiy return err; 10531e51764aSArtem Bityutskiy } 10541e51764aSArtem Bityutskiy 10551e51764aSArtem Bityutskiy /** 10561e51764aSArtem Bityutskiy * do_attr_changes - change inode attributes. 10571e51764aSArtem Bityutskiy * @inode: inode to change attributes for 10581e51764aSArtem Bityutskiy * @attr: describes attributes to change 10591e51764aSArtem Bityutskiy */ 10601e51764aSArtem Bityutskiy static void do_attr_changes(struct inode *inode, const struct iattr *attr) 10611e51764aSArtem Bityutskiy { 10621e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_UID) 10631e51764aSArtem Bityutskiy inode->i_uid = attr->ia_uid; 10641e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_GID) 10651e51764aSArtem Bityutskiy inode->i_gid = attr->ia_gid; 10661e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_ATIME) 10671e51764aSArtem Bityutskiy inode->i_atime = timespec_trunc(attr->ia_atime, 10681e51764aSArtem Bityutskiy inode->i_sb->s_time_gran); 10691e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_MTIME) 10701e51764aSArtem Bityutskiy inode->i_mtime = timespec_trunc(attr->ia_mtime, 10711e51764aSArtem Bityutskiy inode->i_sb->s_time_gran); 10721e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_CTIME) 10731e51764aSArtem Bityutskiy inode->i_ctime = timespec_trunc(attr->ia_ctime, 10741e51764aSArtem Bityutskiy inode->i_sb->s_time_gran); 10751e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_MODE) { 10761e51764aSArtem Bityutskiy umode_t mode = attr->ia_mode; 10771e51764aSArtem Bityutskiy 10781e51764aSArtem Bityutskiy if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID)) 10791e51764aSArtem Bityutskiy mode &= ~S_ISGID; 10801e51764aSArtem Bityutskiy inode->i_mode = mode; 10811e51764aSArtem Bityutskiy } 10821e51764aSArtem Bityutskiy } 10831e51764aSArtem Bityutskiy 10841e51764aSArtem Bityutskiy /** 10851e51764aSArtem Bityutskiy * do_truncation - truncate an inode. 10861e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 10871e51764aSArtem Bityutskiy * @inode: inode to truncate 10881e51764aSArtem Bityutskiy * @attr: inode attribute changes description 10891e51764aSArtem Bityutskiy * 10901e51764aSArtem Bityutskiy * This function implements VFS '->setattr()' call when the inode is truncated 10911e51764aSArtem Bityutskiy * to a smaller size. Returns zero in case of success and a negative error code 10921e51764aSArtem Bityutskiy * in case of failure. 10931e51764aSArtem Bityutskiy */ 10941e51764aSArtem Bityutskiy static int do_truncation(struct ubifs_info *c, struct inode *inode, 10951e51764aSArtem Bityutskiy const struct iattr *attr) 10961e51764aSArtem Bityutskiy { 10971e51764aSArtem Bityutskiy int err; 10981e51764aSArtem Bityutskiy struct ubifs_budget_req req; 10991e51764aSArtem Bityutskiy loff_t old_size = inode->i_size, new_size = attr->ia_size; 110004da11bfSArtem Bityutskiy int offset = new_size & (UBIFS_BLOCK_SIZE - 1), budgeted = 1; 11011e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 11021e51764aSArtem Bityutskiy 11031e51764aSArtem Bityutskiy dbg_gen("ino %lu, size %lld -> %lld", inode->i_ino, old_size, new_size); 11041e51764aSArtem Bityutskiy memset(&req, 0, sizeof(struct ubifs_budget_req)); 11051e51764aSArtem Bityutskiy 11061e51764aSArtem Bityutskiy /* 11071e51764aSArtem Bityutskiy * If this is truncation to a smaller size, and we do not truncate on a 11081e51764aSArtem Bityutskiy * block boundary, budget for changing one data block, because the last 11091e51764aSArtem Bityutskiy * block will be re-written. 11101e51764aSArtem Bityutskiy */ 11111e51764aSArtem Bityutskiy if (new_size & (UBIFS_BLOCK_SIZE - 1)) 11121e51764aSArtem Bityutskiy req.dirtied_page = 1; 11131e51764aSArtem Bityutskiy 11141e51764aSArtem Bityutskiy req.dirtied_ino = 1; 11151e51764aSArtem Bityutskiy /* A funny way to budget for truncation node */ 11161e51764aSArtem Bityutskiy req.dirtied_ino_d = UBIFS_TRUN_NODE_SZ; 11171e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req); 111804da11bfSArtem Bityutskiy if (err) { 111904da11bfSArtem Bityutskiy /* 112004da11bfSArtem Bityutskiy * Treat truncations to zero as deletion and always allow them, 112104da11bfSArtem Bityutskiy * just like we do for '->unlink()'. 112204da11bfSArtem Bityutskiy */ 112304da11bfSArtem Bityutskiy if (new_size || err != -ENOSPC) 11241e51764aSArtem Bityutskiy return err; 112504da11bfSArtem Bityutskiy budgeted = 0; 112604da11bfSArtem Bityutskiy } 11271e51764aSArtem Bityutskiy 11281e51764aSArtem Bityutskiy err = vmtruncate(inode, new_size); 11291e51764aSArtem Bityutskiy if (err) 11301e51764aSArtem Bityutskiy goto out_budg; 11311e51764aSArtem Bityutskiy 11321e51764aSArtem Bityutskiy if (offset) { 11331e51764aSArtem Bityutskiy pgoff_t index = new_size >> PAGE_CACHE_SHIFT; 11341e51764aSArtem Bityutskiy struct page *page; 11351e51764aSArtem Bityutskiy 11361e51764aSArtem Bityutskiy page = find_lock_page(inode->i_mapping, index); 11371e51764aSArtem Bityutskiy if (page) { 11381e51764aSArtem Bityutskiy if (PageDirty(page)) { 11391e51764aSArtem Bityutskiy /* 11401e51764aSArtem Bityutskiy * 'ubifs_jnl_truncate()' will try to truncate 11411e51764aSArtem Bityutskiy * the last data node, but it contains 11421e51764aSArtem Bityutskiy * out-of-date data because the page is dirty. 11431e51764aSArtem Bityutskiy * Write the page now, so that 11441e51764aSArtem Bityutskiy * 'ubifs_jnl_truncate()' will see an already 11451e51764aSArtem Bityutskiy * truncated (and up to date) data node. 11461e51764aSArtem Bityutskiy */ 11471e51764aSArtem Bityutskiy ubifs_assert(PagePrivate(page)); 11481e51764aSArtem Bityutskiy 11491e51764aSArtem Bityutskiy clear_page_dirty_for_io(page); 11501e51764aSArtem Bityutskiy if (UBIFS_BLOCKS_PER_PAGE_SHIFT) 11511e51764aSArtem Bityutskiy offset = new_size & 11521e51764aSArtem Bityutskiy (PAGE_CACHE_SIZE - 1); 11531e51764aSArtem Bityutskiy err = do_writepage(page, offset); 11541e51764aSArtem Bityutskiy page_cache_release(page); 11551e51764aSArtem Bityutskiy if (err) 11561e51764aSArtem Bityutskiy goto out_budg; 11571e51764aSArtem Bityutskiy /* 11581e51764aSArtem Bityutskiy * We could now tell 'ubifs_jnl_truncate()' not 11591e51764aSArtem Bityutskiy * to read the last block. 11601e51764aSArtem Bityutskiy */ 11611e51764aSArtem Bityutskiy } else { 11621e51764aSArtem Bityutskiy /* 11631e51764aSArtem Bityutskiy * We could 'kmap()' the page and pass the data 11641e51764aSArtem Bityutskiy * to 'ubifs_jnl_truncate()' to save it from 11651e51764aSArtem Bityutskiy * having to read it. 11661e51764aSArtem Bityutskiy */ 11671e51764aSArtem Bityutskiy unlock_page(page); 11681e51764aSArtem Bityutskiy page_cache_release(page); 11691e51764aSArtem Bityutskiy } 11701e51764aSArtem Bityutskiy } 11711e51764aSArtem Bityutskiy } 11721e51764aSArtem Bityutskiy 11731e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 11741e51764aSArtem Bityutskiy ui->ui_size = inode->i_size; 11751e51764aSArtem Bityutskiy /* Truncation changes inode [mc]time */ 11761e51764aSArtem Bityutskiy inode->i_mtime = inode->i_ctime = ubifs_current_time(inode); 1177873a64c7SArtem Bityutskiy /* Other attributes may be changed at the same time as well */ 11781e51764aSArtem Bityutskiy do_attr_changes(inode, attr); 11791e51764aSArtem Bityutskiy err = ubifs_jnl_truncate(c, inode, old_size, new_size); 11801e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 1181873a64c7SArtem Bityutskiy 11821e51764aSArtem Bityutskiy out_budg: 118304da11bfSArtem Bityutskiy if (budgeted) 11841e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 118504da11bfSArtem Bityutskiy else { 118604da11bfSArtem Bityutskiy c->nospace = c->nospace_rp = 0; 118704da11bfSArtem Bityutskiy smp_wmb(); 118804da11bfSArtem Bityutskiy } 11891e51764aSArtem Bityutskiy return err; 11901e51764aSArtem Bityutskiy } 11911e51764aSArtem Bityutskiy 11921e51764aSArtem Bityutskiy /** 11931e51764aSArtem Bityutskiy * do_setattr - change inode attributes. 11941e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 11951e51764aSArtem Bityutskiy * @inode: inode to change attributes for 11961e51764aSArtem Bityutskiy * @attr: inode attribute changes description 11971e51764aSArtem Bityutskiy * 11981e51764aSArtem Bityutskiy * This function implements VFS '->setattr()' call for all cases except 11991e51764aSArtem Bityutskiy * truncations to smaller size. Returns zero in case of success and a negative 12001e51764aSArtem Bityutskiy * error code in case of failure. 12011e51764aSArtem Bityutskiy */ 12021e51764aSArtem Bityutskiy static int do_setattr(struct ubifs_info *c, struct inode *inode, 12031e51764aSArtem Bityutskiy const struct iattr *attr) 12041e51764aSArtem Bityutskiy { 12051e51764aSArtem Bityutskiy int err, release; 12061e51764aSArtem Bityutskiy loff_t new_size = attr->ia_size; 12071e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 12081e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .dirtied_ino = 1, 1209dab4b4d2SArtem Bityutskiy .dirtied_ino_d = ALIGN(ui->data_len, 8) }; 12101e51764aSArtem Bityutskiy 12111e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req); 12121e51764aSArtem Bityutskiy if (err) 12131e51764aSArtem Bityutskiy return err; 12141e51764aSArtem Bityutskiy 12151e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_SIZE) { 12161e51764aSArtem Bityutskiy dbg_gen("size %lld -> %lld", inode->i_size, new_size); 12171e51764aSArtem Bityutskiy err = vmtruncate(inode, new_size); 12181e51764aSArtem Bityutskiy if (err) 12191e51764aSArtem Bityutskiy goto out; 12201e51764aSArtem Bityutskiy } 12211e51764aSArtem Bityutskiy 12221e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 12231e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_SIZE) { 12241e51764aSArtem Bityutskiy /* Truncation changes inode [mc]time */ 12251e51764aSArtem Bityutskiy inode->i_mtime = inode->i_ctime = ubifs_current_time(inode); 12261e51764aSArtem Bityutskiy /* 'vmtruncate()' changed @i_size, update @ui_size */ 12271e51764aSArtem Bityutskiy ui->ui_size = inode->i_size; 12281e51764aSArtem Bityutskiy } 12291e51764aSArtem Bityutskiy 12301e51764aSArtem Bityutskiy do_attr_changes(inode, attr); 12311e51764aSArtem Bityutskiy 12321e51764aSArtem Bityutskiy release = ui->dirty; 12331e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_SIZE) 12341e51764aSArtem Bityutskiy /* 12351e51764aSArtem Bityutskiy * Inode length changed, so we have to make sure 12361e51764aSArtem Bityutskiy * @I_DIRTY_DATASYNC is set. 12371e51764aSArtem Bityutskiy */ 12381e51764aSArtem Bityutskiy __mark_inode_dirty(inode, I_DIRTY_SYNC | I_DIRTY_DATASYNC); 12391e51764aSArtem Bityutskiy else 12401e51764aSArtem Bityutskiy mark_inode_dirty_sync(inode); 12411e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 12421e51764aSArtem Bityutskiy 12431e51764aSArtem Bityutskiy if (release) 12441e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 12451e51764aSArtem Bityutskiy if (IS_SYNC(inode)) 1246a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL); 12471e51764aSArtem Bityutskiy return err; 12481e51764aSArtem Bityutskiy 12491e51764aSArtem Bityutskiy out: 12501e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 12511e51764aSArtem Bityutskiy return err; 12521e51764aSArtem Bityutskiy } 12531e51764aSArtem Bityutskiy 12541e51764aSArtem Bityutskiy int ubifs_setattr(struct dentry *dentry, struct iattr *attr) 12551e51764aSArtem Bityutskiy { 12561e51764aSArtem Bityutskiy int err; 12571e51764aSArtem Bityutskiy struct inode *inode = dentry->d_inode; 12581e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 12591e51764aSArtem Bityutskiy 12607d32c2bbSArtem Bityutskiy dbg_gen("ino %lu, mode %#x, ia_valid %#x", 12617d32c2bbSArtem Bityutskiy inode->i_ino, inode->i_mode, attr->ia_valid); 12621e51764aSArtem Bityutskiy err = inode_change_ok(inode, attr); 12631e51764aSArtem Bityutskiy if (err) 12641e51764aSArtem Bityutskiy return err; 12651e51764aSArtem Bityutskiy 12661e51764aSArtem Bityutskiy err = dbg_check_synced_i_size(inode); 12671e51764aSArtem Bityutskiy if (err) 12681e51764aSArtem Bityutskiy return err; 12691e51764aSArtem Bityutskiy 12701e51764aSArtem Bityutskiy if ((attr->ia_valid & ATTR_SIZE) && attr->ia_size < inode->i_size) 12711e51764aSArtem Bityutskiy /* Truncation to a smaller size */ 12721e51764aSArtem Bityutskiy err = do_truncation(c, inode, attr); 12731e51764aSArtem Bityutskiy else 12741e51764aSArtem Bityutskiy err = do_setattr(c, inode, attr); 12751e51764aSArtem Bityutskiy 12761e51764aSArtem Bityutskiy return err; 12771e51764aSArtem Bityutskiy } 12781e51764aSArtem Bityutskiy 12791e51764aSArtem Bityutskiy static void ubifs_invalidatepage(struct page *page, unsigned long offset) 12801e51764aSArtem Bityutskiy { 12811e51764aSArtem Bityutskiy struct inode *inode = page->mapping->host; 12821e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 12831e51764aSArtem Bityutskiy 12841e51764aSArtem Bityutskiy ubifs_assert(PagePrivate(page)); 12851e51764aSArtem Bityutskiy if (offset) 12861e51764aSArtem Bityutskiy /* Partial page remains dirty */ 12871e51764aSArtem Bityutskiy return; 12881e51764aSArtem Bityutskiy 12891e51764aSArtem Bityutskiy if (PageChecked(page)) 12901e51764aSArtem Bityutskiy release_new_page_budget(c); 12911e51764aSArtem Bityutskiy else 12921e51764aSArtem Bityutskiy release_existing_page_budget(c); 12931e51764aSArtem Bityutskiy 12941e51764aSArtem Bityutskiy atomic_long_dec(&c->dirty_pg_cnt); 12951e51764aSArtem Bityutskiy ClearPagePrivate(page); 12961e51764aSArtem Bityutskiy ClearPageChecked(page); 12971e51764aSArtem Bityutskiy } 12981e51764aSArtem Bityutskiy 12991e51764aSArtem Bityutskiy static void *ubifs_follow_link(struct dentry *dentry, struct nameidata *nd) 13001e51764aSArtem Bityutskiy { 13011e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(dentry->d_inode); 13021e51764aSArtem Bityutskiy 13031e51764aSArtem Bityutskiy nd_set_link(nd, ui->data); 13041e51764aSArtem Bityutskiy return NULL; 13051e51764aSArtem Bityutskiy } 13061e51764aSArtem Bityutskiy 13077ea80859SChristoph Hellwig int ubifs_fsync(struct file *file, int datasync) 13081e51764aSArtem Bityutskiy { 13097ea80859SChristoph Hellwig struct inode *inode = file->f_mapping->host; 13101e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 13111e51764aSArtem Bityutskiy int err; 13121e51764aSArtem Bityutskiy 13131e51764aSArtem Bityutskiy dbg_gen("syncing inode %lu", inode->i_ino); 13141e51764aSArtem Bityutskiy 13151e51764aSArtem Bityutskiy /* 13161e51764aSArtem Bityutskiy * VFS has already synchronized dirty pages for this inode. Synchronize 13171e51764aSArtem Bityutskiy * the inode unless this is a 'datasync()' call. 13181e51764aSArtem Bityutskiy */ 13191e51764aSArtem Bityutskiy if (!datasync || (inode->i_state & I_DIRTY_DATASYNC)) { 1320a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL); 13211e51764aSArtem Bityutskiy if (err) 13221e51764aSArtem Bityutskiy return err; 13231e51764aSArtem Bityutskiy } 13241e51764aSArtem Bityutskiy 13251e51764aSArtem Bityutskiy /* 13261e51764aSArtem Bityutskiy * Nodes related to this inode may still sit in a write-buffer. Flush 13271e51764aSArtem Bityutskiy * them. 13281e51764aSArtem Bityutskiy */ 13291e51764aSArtem Bityutskiy err = ubifs_sync_wbufs_by_inode(c, inode); 13301e51764aSArtem Bityutskiy if (err) 13311e51764aSArtem Bityutskiy return err; 13321e51764aSArtem Bityutskiy 13331e51764aSArtem Bityutskiy return 0; 13341e51764aSArtem Bityutskiy } 13351e51764aSArtem Bityutskiy 13361e51764aSArtem Bityutskiy /** 13371e51764aSArtem Bityutskiy * mctime_update_needed - check if mtime or ctime update is needed. 13381e51764aSArtem Bityutskiy * @inode: the inode to do the check for 13391e51764aSArtem Bityutskiy * @now: current time 13401e51764aSArtem Bityutskiy * 13411e51764aSArtem Bityutskiy * This helper function checks if the inode mtime/ctime should be updated or 13421e51764aSArtem Bityutskiy * not. If current values of the time-stamps are within the UBIFS inode time 13431e51764aSArtem Bityutskiy * granularity, they are not updated. This is an optimization. 13441e51764aSArtem Bityutskiy */ 13451e51764aSArtem Bityutskiy static inline int mctime_update_needed(const struct inode *inode, 13461e51764aSArtem Bityutskiy const struct timespec *now) 13471e51764aSArtem Bityutskiy { 13481e51764aSArtem Bityutskiy if (!timespec_equal(&inode->i_mtime, now) || 13491e51764aSArtem Bityutskiy !timespec_equal(&inode->i_ctime, now)) 13501e51764aSArtem Bityutskiy return 1; 13511e51764aSArtem Bityutskiy return 0; 13521e51764aSArtem Bityutskiy } 13531e51764aSArtem Bityutskiy 13541e51764aSArtem Bityutskiy /** 13551e51764aSArtem Bityutskiy * update_ctime - update mtime and ctime of an inode. 13561e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 13571e51764aSArtem Bityutskiy * @inode: inode to update 13581e51764aSArtem Bityutskiy * 13591e51764aSArtem Bityutskiy * This function updates mtime and ctime of the inode if it is not equivalent to 13601e51764aSArtem Bityutskiy * current time. Returns zero in case of success and a negative error code in 13611e51764aSArtem Bityutskiy * case of failure. 13621e51764aSArtem Bityutskiy */ 13631e51764aSArtem Bityutskiy static int update_mctime(struct ubifs_info *c, struct inode *inode) 13641e51764aSArtem Bityutskiy { 13651e51764aSArtem Bityutskiy struct timespec now = ubifs_current_time(inode); 13661e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 13671e51764aSArtem Bityutskiy 13681e51764aSArtem Bityutskiy if (mctime_update_needed(inode, &now)) { 13691e51764aSArtem Bityutskiy int err, release; 13701e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .dirtied_ino = 1, 1371dab4b4d2SArtem Bityutskiy .dirtied_ino_d = ALIGN(ui->data_len, 8) }; 13721e51764aSArtem Bityutskiy 13731e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req); 13741e51764aSArtem Bityutskiy if (err) 13751e51764aSArtem Bityutskiy return err; 13761e51764aSArtem Bityutskiy 13771e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 13781e51764aSArtem Bityutskiy inode->i_mtime = inode->i_ctime = ubifs_current_time(inode); 13791e51764aSArtem Bityutskiy release = ui->dirty; 13801e51764aSArtem Bityutskiy mark_inode_dirty_sync(inode); 13811e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 13821e51764aSArtem Bityutskiy if (release) 13831e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 13841e51764aSArtem Bityutskiy } 13851e51764aSArtem Bityutskiy 13861e51764aSArtem Bityutskiy return 0; 13871e51764aSArtem Bityutskiy } 13881e51764aSArtem Bityutskiy 13891e51764aSArtem Bityutskiy static ssize_t ubifs_aio_write(struct kiocb *iocb, const struct iovec *iov, 13901e51764aSArtem Bityutskiy unsigned long nr_segs, loff_t pos) 13911e51764aSArtem Bityutskiy { 13921e51764aSArtem Bityutskiy int err; 13931e51764aSArtem Bityutskiy struct inode *inode = iocb->ki_filp->f_mapping->host; 13941e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 13951e51764aSArtem Bityutskiy 13961e51764aSArtem Bityutskiy err = update_mctime(c, inode); 13971e51764aSArtem Bityutskiy if (err) 13981e51764aSArtem Bityutskiy return err; 13991e51764aSArtem Bityutskiy 1400774888bcSChristoph Hellwig return generic_file_aio_write(iocb, iov, nr_segs, pos); 14011e51764aSArtem Bityutskiy } 14021e51764aSArtem Bityutskiy 14031e51764aSArtem Bityutskiy static int ubifs_set_page_dirty(struct page *page) 14041e51764aSArtem Bityutskiy { 14051e51764aSArtem Bityutskiy int ret; 14061e51764aSArtem Bityutskiy 14071e51764aSArtem Bityutskiy ret = __set_page_dirty_nobuffers(page); 14081e51764aSArtem Bityutskiy /* 14091e51764aSArtem Bityutskiy * An attempt to dirty a page without budgeting for it - should not 14101e51764aSArtem Bityutskiy * happen. 14111e51764aSArtem Bityutskiy */ 14121e51764aSArtem Bityutskiy ubifs_assert(ret == 0); 14131e51764aSArtem Bityutskiy return ret; 14141e51764aSArtem Bityutskiy } 14151e51764aSArtem Bityutskiy 14161e51764aSArtem Bityutskiy static int ubifs_releasepage(struct page *page, gfp_t unused_gfp_flags) 14171e51764aSArtem Bityutskiy { 14181e51764aSArtem Bityutskiy /* 14191e51764aSArtem Bityutskiy * An attempt to release a dirty page without budgeting for it - should 14201e51764aSArtem Bityutskiy * not happen. 14211e51764aSArtem Bityutskiy */ 14221e51764aSArtem Bityutskiy if (PageWriteback(page)) 14231e51764aSArtem Bityutskiy return 0; 14241e51764aSArtem Bityutskiy ubifs_assert(PagePrivate(page)); 14251e51764aSArtem Bityutskiy ubifs_assert(0); 14261e51764aSArtem Bityutskiy ClearPagePrivate(page); 14271e51764aSArtem Bityutskiy ClearPageChecked(page); 14281e51764aSArtem Bityutskiy return 1; 14291e51764aSArtem Bityutskiy } 14301e51764aSArtem Bityutskiy 14311e51764aSArtem Bityutskiy /* 14321e51764aSArtem Bityutskiy * mmap()d file has taken write protection fault and is being made 14331e51764aSArtem Bityutskiy * writable. UBIFS must ensure page is budgeted for. 14341e51764aSArtem Bityutskiy */ 1435c2ec175cSNick Piggin static int ubifs_vm_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf) 14361e51764aSArtem Bityutskiy { 1437c2ec175cSNick Piggin struct page *page = vmf->page; 14381e51764aSArtem Bityutskiy struct inode *inode = vma->vm_file->f_path.dentry->d_inode; 14391e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info; 14401e51764aSArtem Bityutskiy struct timespec now = ubifs_current_time(inode); 14411e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .new_page = 1 }; 14421e51764aSArtem Bityutskiy int err, update_time; 14431e51764aSArtem Bityutskiy 14441e51764aSArtem Bityutskiy dbg_gen("ino %lu, pg %lu, i_size %lld", inode->i_ino, page->index, 14451e51764aSArtem Bityutskiy i_size_read(inode)); 14461e51764aSArtem Bityutskiy ubifs_assert(!(inode->i_sb->s_flags & MS_RDONLY)); 14471e51764aSArtem Bityutskiy 14481e51764aSArtem Bityutskiy if (unlikely(c->ro_media)) 1449c2ec175cSNick Piggin return VM_FAULT_SIGBUS; /* -EROFS */ 14501e51764aSArtem Bityutskiy 14511e51764aSArtem Bityutskiy /* 14521e51764aSArtem Bityutskiy * We have not locked @page so far so we may budget for changing the 14531e51764aSArtem Bityutskiy * page. Note, we cannot do this after we locked the page, because 14541e51764aSArtem Bityutskiy * budgeting may cause write-back which would cause deadlock. 14551e51764aSArtem Bityutskiy * 14561e51764aSArtem Bityutskiy * At the moment we do not know whether the page is dirty or not, so we 14571e51764aSArtem Bityutskiy * assume that it is not and budget for a new page. We could look at 14581e51764aSArtem Bityutskiy * the @PG_private flag and figure this out, but we may race with write 14591e51764aSArtem Bityutskiy * back and the page state may change by the time we lock it, so this 14601e51764aSArtem Bityutskiy * would need additional care. We do not bother with this at the 14611e51764aSArtem Bityutskiy * moment, although it might be good idea to do. Instead, we allocate 14621e51764aSArtem Bityutskiy * budget for a new page and amend it later on if the page was in fact 14631e51764aSArtem Bityutskiy * dirty. 14641e51764aSArtem Bityutskiy * 14651e51764aSArtem Bityutskiy * The budgeting-related logic of this function is similar to what we 14661e51764aSArtem Bityutskiy * do in 'ubifs_write_begin()' and 'ubifs_write_end()'. Glance there 14671e51764aSArtem Bityutskiy * for more comments. 14681e51764aSArtem Bityutskiy */ 14691e51764aSArtem Bityutskiy update_time = mctime_update_needed(inode, &now); 14701e51764aSArtem Bityutskiy if (update_time) 14711e51764aSArtem Bityutskiy /* 14721e51764aSArtem Bityutskiy * We have to change inode time stamp which requires extra 14731e51764aSArtem Bityutskiy * budgeting. 14741e51764aSArtem Bityutskiy */ 14751e51764aSArtem Bityutskiy req.dirtied_ino = 1; 14761e51764aSArtem Bityutskiy 14771e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req); 14781e51764aSArtem Bityutskiy if (unlikely(err)) { 14791e51764aSArtem Bityutskiy if (err == -ENOSPC) 14801e51764aSArtem Bityutskiy ubifs_warn("out of space for mmapped file " 14811e51764aSArtem Bityutskiy "(inode number %lu)", inode->i_ino); 1482c2ec175cSNick Piggin return VM_FAULT_SIGBUS; 14831e51764aSArtem Bityutskiy } 14841e51764aSArtem Bityutskiy 14851e51764aSArtem Bityutskiy lock_page(page); 14861e51764aSArtem Bityutskiy if (unlikely(page->mapping != inode->i_mapping || 14871e51764aSArtem Bityutskiy page_offset(page) > i_size_read(inode))) { 14881e51764aSArtem Bityutskiy /* Page got truncated out from underneath us */ 14891e51764aSArtem Bityutskiy err = -EINVAL; 14901e51764aSArtem Bityutskiy goto out_unlock; 14911e51764aSArtem Bityutskiy } 14921e51764aSArtem Bityutskiy 14931e51764aSArtem Bityutskiy if (PagePrivate(page)) 14941e51764aSArtem Bityutskiy release_new_page_budget(c); 14951e51764aSArtem Bityutskiy else { 14961e51764aSArtem Bityutskiy if (!PageChecked(page)) 14971e51764aSArtem Bityutskiy ubifs_convert_page_budget(c); 14981e51764aSArtem Bityutskiy SetPagePrivate(page); 14991e51764aSArtem Bityutskiy atomic_long_inc(&c->dirty_pg_cnt); 15001e51764aSArtem Bityutskiy __set_page_dirty_nobuffers(page); 15011e51764aSArtem Bityutskiy } 15021e51764aSArtem Bityutskiy 15031e51764aSArtem Bityutskiy if (update_time) { 15041e51764aSArtem Bityutskiy int release; 15051e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode); 15061e51764aSArtem Bityutskiy 15071e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex); 15081e51764aSArtem Bityutskiy inode->i_mtime = inode->i_ctime = ubifs_current_time(inode); 15091e51764aSArtem Bityutskiy release = ui->dirty; 15101e51764aSArtem Bityutskiy mark_inode_dirty_sync(inode); 15111e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex); 15121e51764aSArtem Bityutskiy if (release) 15131e51764aSArtem Bityutskiy ubifs_release_dirty_inode_budget(c, ui); 15141e51764aSArtem Bityutskiy } 15151e51764aSArtem Bityutskiy 15161e51764aSArtem Bityutskiy unlock_page(page); 15171e51764aSArtem Bityutskiy return 0; 15181e51764aSArtem Bityutskiy 15191e51764aSArtem Bityutskiy out_unlock: 15201e51764aSArtem Bityutskiy unlock_page(page); 15211e51764aSArtem Bityutskiy ubifs_release_budget(c, &req); 1522c2ec175cSNick Piggin if (err) 1523c2ec175cSNick Piggin err = VM_FAULT_SIGBUS; 15241e51764aSArtem Bityutskiy return err; 15251e51764aSArtem Bityutskiy } 15261e51764aSArtem Bityutskiy 1527f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct ubifs_file_vm_ops = { 15281e51764aSArtem Bityutskiy .fault = filemap_fault, 15291e51764aSArtem Bityutskiy .page_mkwrite = ubifs_vm_page_mkwrite, 15301e51764aSArtem Bityutskiy }; 15311e51764aSArtem Bityutskiy 15321e51764aSArtem Bityutskiy static int ubifs_file_mmap(struct file *file, struct vm_area_struct *vma) 15331e51764aSArtem Bityutskiy { 15341e51764aSArtem Bityutskiy int err; 15351e51764aSArtem Bityutskiy 15361e51764aSArtem Bityutskiy /* 'generic_file_mmap()' takes care of NOMMU case */ 15371e51764aSArtem Bityutskiy err = generic_file_mmap(file, vma); 15381e51764aSArtem Bityutskiy if (err) 15391e51764aSArtem Bityutskiy return err; 15401e51764aSArtem Bityutskiy vma->vm_ops = &ubifs_file_vm_ops; 15411e51764aSArtem Bityutskiy return 0; 15421e51764aSArtem Bityutskiy } 15431e51764aSArtem Bityutskiy 1544e8b81566SArtem Bityutskiy const struct address_space_operations ubifs_file_address_operations = { 15451e51764aSArtem Bityutskiy .readpage = ubifs_readpage, 15461e51764aSArtem Bityutskiy .writepage = ubifs_writepage, 15471e51764aSArtem Bityutskiy .write_begin = ubifs_write_begin, 15481e51764aSArtem Bityutskiy .write_end = ubifs_write_end, 15491e51764aSArtem Bityutskiy .invalidatepage = ubifs_invalidatepage, 15501e51764aSArtem Bityutskiy .set_page_dirty = ubifs_set_page_dirty, 15511e51764aSArtem Bityutskiy .releasepage = ubifs_releasepage, 15521e51764aSArtem Bityutskiy }; 15531e51764aSArtem Bityutskiy 1554e8b81566SArtem Bityutskiy const struct inode_operations ubifs_file_inode_operations = { 15551e51764aSArtem Bityutskiy .setattr = ubifs_setattr, 15561e51764aSArtem Bityutskiy .getattr = ubifs_getattr, 15571e51764aSArtem Bityutskiy #ifdef CONFIG_UBIFS_FS_XATTR 15581e51764aSArtem Bityutskiy .setxattr = ubifs_setxattr, 15591e51764aSArtem Bityutskiy .getxattr = ubifs_getxattr, 15601e51764aSArtem Bityutskiy .listxattr = ubifs_listxattr, 15611e51764aSArtem Bityutskiy .removexattr = ubifs_removexattr, 15621e51764aSArtem Bityutskiy #endif 15631e51764aSArtem Bityutskiy }; 15641e51764aSArtem Bityutskiy 1565e8b81566SArtem Bityutskiy const struct inode_operations ubifs_symlink_inode_operations = { 15661e51764aSArtem Bityutskiy .readlink = generic_readlink, 15671e51764aSArtem Bityutskiy .follow_link = ubifs_follow_link, 15681e51764aSArtem Bityutskiy .setattr = ubifs_setattr, 15691e51764aSArtem Bityutskiy .getattr = ubifs_getattr, 15701e51764aSArtem Bityutskiy }; 15711e51764aSArtem Bityutskiy 1572e8b81566SArtem Bityutskiy const struct file_operations ubifs_file_operations = { 15731e51764aSArtem Bityutskiy .llseek = generic_file_llseek, 15741e51764aSArtem Bityutskiy .read = do_sync_read, 15751e51764aSArtem Bityutskiy .write = do_sync_write, 15761e51764aSArtem Bityutskiy .aio_read = generic_file_aio_read, 15771e51764aSArtem Bityutskiy .aio_write = ubifs_aio_write, 15781e51764aSArtem Bityutskiy .mmap = ubifs_file_mmap, 15791e51764aSArtem Bityutskiy .fsync = ubifs_fsync, 15801e51764aSArtem Bityutskiy .unlocked_ioctl = ubifs_ioctl, 15811e51764aSArtem Bityutskiy .splice_read = generic_file_splice_read, 158222bc7fa8SZoltan Sogor .splice_write = generic_file_splice_write, 15831e51764aSArtem Bityutskiy #ifdef CONFIG_COMPAT 15841e51764aSArtem Bityutskiy .compat_ioctl = ubifs_compat_ioctl, 15851e51764aSArtem Bityutskiy #endif 15861e51764aSArtem Bityutskiy }; 1587