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
read_block(struct inode * inode,void * addr,unsigned int block,struct ubifs_data_node * dn)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
do_readpage(struct folio * folio)99b96af1fdSMatthew Wilcox (Oracle) static int do_readpage(struct folio *folio)
1001e51764aSArtem Bityutskiy {
1011e51764aSArtem Bityutskiy void *addr;
1021e51764aSArtem Bityutskiy int err = 0, i;
1031e51764aSArtem Bityutskiy unsigned int block, beyond;
104b96af1fdSMatthew Wilcox (Oracle) struct ubifs_data_node *dn = NULL;
105b96af1fdSMatthew Wilcox (Oracle) struct inode *inode = folio->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",
110b96af1fdSMatthew Wilcox (Oracle) inode->i_ino, folio->index, i_size, folio->flags);
111b96af1fdSMatthew Wilcox (Oracle) ubifs_assert(c, !folio_test_checked(folio));
112b96af1fdSMatthew Wilcox (Oracle) ubifs_assert(c, !folio->private);
1131e51764aSArtem Bityutskiy
114b96af1fdSMatthew Wilcox (Oracle) addr = kmap_local_folio(folio, 0);
1151e51764aSArtem Bityutskiy
116b96af1fdSMatthew Wilcox (Oracle) block = folio->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 */
120b96af1fdSMatthew Wilcox (Oracle) folio_set_checked(folio);
121b96af1fdSMatthew Wilcox (Oracle) addr = folio_zero_tail(folio, 0, addr);
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;
128b96af1fdSMatthew Wilcox (Oracle) goto out;
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 }
153b96af1fdSMatthew Wilcox (Oracle) if (++i >= (UBIFS_BLOCKS_PER_PAGE << folio_order(folio)))
1541e51764aSArtem Bityutskiy break;
1551e51764aSArtem Bityutskiy block += 1;
1561e51764aSArtem Bityutskiy addr += UBIFS_BLOCK_SIZE;
157b96af1fdSMatthew Wilcox (Oracle) if (folio_test_highmem(folio) && (offset_in_page(addr) == 0)) {
158b96af1fdSMatthew Wilcox (Oracle) kunmap_local(addr - UBIFS_BLOCK_SIZE);
159b96af1fdSMatthew Wilcox (Oracle) addr = kmap_local_folio(folio, i * UBIFS_BLOCK_SIZE);
1601e51764aSArtem Bityutskiy }
161b96af1fdSMatthew Wilcox (Oracle) }
162b96af1fdSMatthew Wilcox (Oracle)
1631e51764aSArtem Bityutskiy if (err) {
164235c362bSSheng Yong struct ubifs_info *c = inode->i_sb->s_fs_info;
1651e51764aSArtem Bityutskiy if (err == -ENOENT) {
1661e51764aSArtem Bityutskiy /* Not found, so it must be a hole */
167b96af1fdSMatthew Wilcox (Oracle) folio_set_checked(folio);
1681e51764aSArtem Bityutskiy dbg_gen("hole");
169b96af1fdSMatthew Wilcox (Oracle) err = 0;
170b96af1fdSMatthew Wilcox (Oracle) } else {
171235c362bSSheng Yong ubifs_err(c, "cannot read page %lu of inode %lu, error %d",
172b96af1fdSMatthew Wilcox (Oracle) folio->index, inode->i_ino, err);
173b96af1fdSMatthew Wilcox (Oracle) }
1741e51764aSArtem Bityutskiy }
1751e51764aSArtem Bityutskiy
1761e51764aSArtem Bityutskiy out:
1771e51764aSArtem Bityutskiy kfree(dn);
178b96af1fdSMatthew Wilcox (Oracle) if (!err)
179b96af1fdSMatthew Wilcox (Oracle) folio_mark_uptodate(folio);
180b96af1fdSMatthew Wilcox (Oracle) flush_dcache_folio(folio);
181b96af1fdSMatthew Wilcox (Oracle) kunmap_local(addr);
1821e51764aSArtem Bityutskiy return err;
1831e51764aSArtem Bityutskiy }
1841e51764aSArtem Bityutskiy
1851e51764aSArtem Bityutskiy /**
1861e51764aSArtem Bityutskiy * release_new_page_budget - release budget of a new page.
1871e51764aSArtem Bityutskiy * @c: UBIFS file-system description object
1881e51764aSArtem Bityutskiy *
1891e51764aSArtem Bityutskiy * This is a helper function which releases budget corresponding to the budget
1901e51764aSArtem Bityutskiy * of one new page of data.
1911e51764aSArtem Bityutskiy */
release_new_page_budget(struct ubifs_info * c)1921e51764aSArtem Bityutskiy static void release_new_page_budget(struct ubifs_info *c)
1931e51764aSArtem Bityutskiy {
1941e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .recalculate = 1, .new_page = 1 };
1951e51764aSArtem Bityutskiy
1961e51764aSArtem Bityutskiy ubifs_release_budget(c, &req);
1971e51764aSArtem Bityutskiy }
1981e51764aSArtem Bityutskiy
1991e51764aSArtem Bityutskiy /**
2001e51764aSArtem Bityutskiy * release_existing_page_budget - release budget of an existing page.
2011e51764aSArtem Bityutskiy * @c: UBIFS file-system description object
2021e51764aSArtem Bityutskiy *
2031e51764aSArtem Bityutskiy * This is a helper function which releases budget corresponding to the budget
204b8f1da98SRandy Dunlap * of changing one page of data which already exists on the flash media.
2051e51764aSArtem Bityutskiy */
release_existing_page_budget(struct ubifs_info * c)2061e51764aSArtem Bityutskiy static void release_existing_page_budget(struct ubifs_info *c)
2071e51764aSArtem Bityutskiy {
208b137545cSArtem Bityutskiy struct ubifs_budget_req req = { .dd_growth = c->bi.page_budget};
2091e51764aSArtem Bityutskiy
2101e51764aSArtem Bityutskiy ubifs_release_budget(c, &req);
2111e51764aSArtem Bityutskiy }
2121e51764aSArtem Bityutskiy
write_begin_slow(struct address_space * mapping,loff_t pos,unsigned len,struct folio ** foliop)2131e51764aSArtem Bityutskiy static int write_begin_slow(struct address_space *mapping,
214*1da86618SMatthew Wilcox (Oracle) loff_t pos, unsigned len, struct folio **foliop)
2151e51764aSArtem Bityutskiy {
2161e51764aSArtem Bityutskiy struct inode *inode = mapping->host;
2171e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info;
21809cbfeafSKirill A. Shutemov pgoff_t index = pos >> PAGE_SHIFT;
2191e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .new_page = 1 };
2203f649ab7SKees Cook int err, appending = !!(pos + len > inode->i_size);
2212ec71843SMatthew Wilcox (Oracle) struct folio *folio;
2221e51764aSArtem Bityutskiy
2231e51764aSArtem Bityutskiy dbg_gen("ino %lu, pos %llu, len %u, i_size %lld",
2241e51764aSArtem Bityutskiy inode->i_ino, pos, len, inode->i_size);
2251e51764aSArtem Bityutskiy
2261e51764aSArtem Bityutskiy /*
2272ec71843SMatthew Wilcox (Oracle) * At the slow path we have to budget before locking the folio, because
2282ec71843SMatthew Wilcox (Oracle) * budgeting may force write-back, which would wait on locked folios and
2292ec71843SMatthew Wilcox (Oracle) * deadlock if we had the folio locked. At this point we do not know
2302ec71843SMatthew Wilcox (Oracle) * anything about the folio, so assume that this is a new folio which is
2311e51764aSArtem Bityutskiy * written to a hole. This corresponds to largest budget. Later the
2321e51764aSArtem Bityutskiy * budget will be amended if this is not true.
2331e51764aSArtem Bityutskiy */
2341e51764aSArtem Bityutskiy if (appending)
2351e51764aSArtem Bityutskiy /* We are appending data, budget for inode change */
2361e51764aSArtem Bityutskiy req.dirtied_ino = 1;
2371e51764aSArtem Bityutskiy
2381e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req);
2391e51764aSArtem Bityutskiy if (unlikely(err))
2401e51764aSArtem Bityutskiy return err;
2411e51764aSArtem Bityutskiy
2422ec71843SMatthew Wilcox (Oracle) folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,
2432ec71843SMatthew Wilcox (Oracle) mapping_gfp_mask(mapping));
2442ec71843SMatthew Wilcox (Oracle) if (IS_ERR(folio)) {
2451e51764aSArtem Bityutskiy ubifs_release_budget(c, &req);
2462ec71843SMatthew Wilcox (Oracle) return PTR_ERR(folio);
2471e51764aSArtem Bityutskiy }
2481e51764aSArtem Bityutskiy
2492ec71843SMatthew Wilcox (Oracle) if (!folio_test_uptodate(folio)) {
2502ec71843SMatthew Wilcox (Oracle) if (pos == folio_pos(folio) && len >= folio_size(folio))
2512ec71843SMatthew Wilcox (Oracle) folio_set_checked(folio);
2521e51764aSArtem Bityutskiy else {
253b96af1fdSMatthew Wilcox (Oracle) err = do_readpage(folio);
2541e51764aSArtem Bityutskiy if (err) {
2552ec71843SMatthew Wilcox (Oracle) folio_unlock(folio);
2562ec71843SMatthew Wilcox (Oracle) folio_put(folio);
257789c8993SArtem Bityutskiy ubifs_release_budget(c, &req);
2581e51764aSArtem Bityutskiy return err;
2591e51764aSArtem Bityutskiy }
2601e51764aSArtem Bityutskiy }
2611e51764aSArtem Bityutskiy }
2621e51764aSArtem Bityutskiy
2632ec71843SMatthew Wilcox (Oracle) if (folio->private)
2641e51764aSArtem Bityutskiy /*
2652ec71843SMatthew Wilcox (Oracle) * The folio is dirty, which means it was budgeted twice:
2661e51764aSArtem Bityutskiy * o first time the budget was allocated by the task which
2672ec71843SMatthew Wilcox (Oracle) * made the folio dirty and set the private field;
2681e51764aSArtem Bityutskiy * o and then we budgeted for it for the second time at the
2691e51764aSArtem Bityutskiy * very beginning of this function.
2701e51764aSArtem Bityutskiy *
2712ec71843SMatthew Wilcox (Oracle) * So what we have to do is to release the folio budget we
2721e51764aSArtem Bityutskiy * allocated.
2731e51764aSArtem Bityutskiy */
2741e51764aSArtem Bityutskiy release_new_page_budget(c);
2752ec71843SMatthew Wilcox (Oracle) else if (!folio_test_checked(folio))
2761e51764aSArtem Bityutskiy /*
2772ec71843SMatthew Wilcox (Oracle) * We are changing a folio which already exists on the media.
2782ec71843SMatthew Wilcox (Oracle) * This means that changing the folio does not make the amount
2791e51764aSArtem Bityutskiy * of indexing information larger, and this part of the budget
2801e51764aSArtem Bityutskiy * which we have already acquired may be released.
2811e51764aSArtem Bityutskiy */
2821e51764aSArtem Bityutskiy ubifs_convert_page_budget(c);
2831e51764aSArtem Bityutskiy
2841e51764aSArtem Bityutskiy if (appending) {
2851e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode);
2861e51764aSArtem Bityutskiy
2871e51764aSArtem Bityutskiy /*
2881e51764aSArtem Bityutskiy * 'ubifs_write_end()' is optimized from the fast-path part of
2891e51764aSArtem Bityutskiy * 'ubifs_write_begin()' and expects the @ui_mutex to be locked
2901e51764aSArtem Bityutskiy * if data is appended.
2911e51764aSArtem Bityutskiy */
2921e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex);
2931e51764aSArtem Bityutskiy if (ui->dirty)
2941e51764aSArtem Bityutskiy /*
2951e51764aSArtem Bityutskiy * The inode is dirty already, so we may free the
2961e51764aSArtem Bityutskiy * budget we allocated.
2971e51764aSArtem Bityutskiy */
2981e51764aSArtem Bityutskiy ubifs_release_dirty_inode_budget(c, ui);
2991e51764aSArtem Bityutskiy }
3001e51764aSArtem Bityutskiy
301*1da86618SMatthew Wilcox (Oracle) *foliop = folio;
3021e51764aSArtem Bityutskiy return 0;
3031e51764aSArtem Bityutskiy }
3041e51764aSArtem Bityutskiy
3051e51764aSArtem Bityutskiy /**
3061e51764aSArtem Bityutskiy * allocate_budget - allocate budget for 'ubifs_write_begin()'.
3071e51764aSArtem Bityutskiy * @c: UBIFS file-system description object
308a3c2f196SMatthew Wilcox (Oracle) * @folio: folio to allocate budget for
3091e51764aSArtem Bityutskiy * @ui: UBIFS inode object the page belongs to
3101e51764aSArtem Bityutskiy * @appending: non-zero if the page is appended
3111e51764aSArtem Bityutskiy *
3121e51764aSArtem Bityutskiy * This is a helper function for 'ubifs_write_begin()' which allocates budget
3131e51764aSArtem Bityutskiy * for the operation. The budget is allocated differently depending on whether
3141e51764aSArtem Bityutskiy * this is appending, whether the page is dirty or not, and so on. This
315ac8e9f64SRandy Dunlap * function leaves the @ui->ui_mutex locked in case of appending.
316ac8e9f64SRandy Dunlap *
317ac8e9f64SRandy Dunlap * Returns: %0 in case of success and %-ENOSPC in case of failure.
3181e51764aSArtem Bityutskiy */
allocate_budget(struct ubifs_info * c,struct folio * folio,struct ubifs_inode * ui,int appending)319a3c2f196SMatthew Wilcox (Oracle) static int allocate_budget(struct ubifs_info *c, struct folio *folio,
3201e51764aSArtem Bityutskiy struct ubifs_inode *ui, int appending)
3211e51764aSArtem Bityutskiy {
3221e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .fast = 1 };
3231e51764aSArtem Bityutskiy
324a3c2f196SMatthew Wilcox (Oracle) if (folio->private) {
3251e51764aSArtem Bityutskiy if (!appending)
3261e51764aSArtem Bityutskiy /*
327a3c2f196SMatthew Wilcox (Oracle) * The folio is dirty and we are not appending, which
3281e51764aSArtem Bityutskiy * means no budget is needed at all.
3291e51764aSArtem Bityutskiy */
3301e51764aSArtem Bityutskiy return 0;
3311e51764aSArtem Bityutskiy
3321e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex);
3331e51764aSArtem Bityutskiy if (ui->dirty)
3341e51764aSArtem Bityutskiy /*
3351e51764aSArtem Bityutskiy * The page is dirty and we are appending, so the inode
3361e51764aSArtem Bityutskiy * has to be marked as dirty. However, it is already
3371e51764aSArtem Bityutskiy * dirty, so we do not need any budget. We may return,
3381e51764aSArtem Bityutskiy * but @ui->ui_mutex hast to be left locked because we
3391e51764aSArtem Bityutskiy * should prevent write-back from flushing the inode
3401e51764aSArtem Bityutskiy * and freeing the budget. The lock will be released in
3411e51764aSArtem Bityutskiy * 'ubifs_write_end()'.
3421e51764aSArtem Bityutskiy */
3431e51764aSArtem Bityutskiy return 0;
3441e51764aSArtem Bityutskiy
3451e51764aSArtem Bityutskiy /*
3461e51764aSArtem Bityutskiy * The page is dirty, we are appending, the inode is clean, so
3471e51764aSArtem Bityutskiy * we need to budget the inode change.
3481e51764aSArtem Bityutskiy */
3491e51764aSArtem Bityutskiy req.dirtied_ino = 1;
3501e51764aSArtem Bityutskiy } else {
351a3c2f196SMatthew Wilcox (Oracle) if (folio_test_checked(folio))
3521e51764aSArtem Bityutskiy /*
3531e51764aSArtem Bityutskiy * The page corresponds to a hole and does not
3541e51764aSArtem Bityutskiy * exist on the media. So changing it makes
355a3c2f196SMatthew Wilcox (Oracle) * the amount of indexing information
3561e51764aSArtem Bityutskiy * larger, and we have to budget for a new
3571e51764aSArtem Bityutskiy * page.
3581e51764aSArtem Bityutskiy */
3591e51764aSArtem Bityutskiy req.new_page = 1;
3601e51764aSArtem Bityutskiy else
3611e51764aSArtem Bityutskiy /*
3621e51764aSArtem Bityutskiy * Not a hole, the change will not add any new
3631e51764aSArtem Bityutskiy * indexing information, budget for page
3641e51764aSArtem Bityutskiy * change.
3651e51764aSArtem Bityutskiy */
3661e51764aSArtem Bityutskiy req.dirtied_page = 1;
3671e51764aSArtem Bityutskiy
3681e51764aSArtem Bityutskiy if (appending) {
3691e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex);
3701e51764aSArtem Bityutskiy if (!ui->dirty)
3711e51764aSArtem Bityutskiy /*
3721e51764aSArtem Bityutskiy * The inode is clean but we will have to mark
3731e51764aSArtem Bityutskiy * it as dirty because we are appending. This
3741e51764aSArtem Bityutskiy * needs a budget.
3751e51764aSArtem Bityutskiy */
3761e51764aSArtem Bityutskiy req.dirtied_ino = 1;
3771e51764aSArtem Bityutskiy }
3781e51764aSArtem Bityutskiy }
3791e51764aSArtem Bityutskiy
3801e51764aSArtem Bityutskiy return ubifs_budget_space(c, &req);
3811e51764aSArtem Bityutskiy }
3821e51764aSArtem Bityutskiy
3831e51764aSArtem Bityutskiy /*
3841e51764aSArtem Bityutskiy * This function is called when a page of data is going to be written. Since
3851e51764aSArtem Bityutskiy * the page of data will not necessarily go to the flash straight away, UBIFS
3861e51764aSArtem Bityutskiy * has to reserve space on the media for it, which is done by means of
3871e51764aSArtem Bityutskiy * budgeting.
3881e51764aSArtem Bityutskiy *
3891e51764aSArtem Bityutskiy * This is the hot-path of the file-system and we are trying to optimize it as
3901e51764aSArtem Bityutskiy * much as possible. For this reasons it is split on 2 parts - slow and fast.
3911e51764aSArtem Bityutskiy *
3921e51764aSArtem Bityutskiy * There many budgeting cases:
3931e51764aSArtem Bityutskiy * o a new page is appended - we have to budget for a new page and for
3941e51764aSArtem Bityutskiy * changing the inode; however, if the inode is already dirty, there is
3951e51764aSArtem Bityutskiy * no need to budget for it;
3961e51764aSArtem Bityutskiy * o an existing clean page is changed - we have budget for it; if the page
3971e51764aSArtem Bityutskiy * does not exist on the media (a hole), we have to budget for a new
3981e51764aSArtem Bityutskiy * page; otherwise, we may budget for changing an existing page; the
3991e51764aSArtem Bityutskiy * difference between these cases is that changing an existing page does
4001e51764aSArtem Bityutskiy * not introduce anything new to the FS indexing information, so it does
4011e51764aSArtem Bityutskiy * not grow, and smaller budget is acquired in this case;
4021e51764aSArtem Bityutskiy * o an existing dirty page is changed - no need to budget at all, because
4031e51764aSArtem Bityutskiy * the page budget has been acquired by earlier, when the page has been
4041e51764aSArtem Bityutskiy * marked dirty.
4051e51764aSArtem Bityutskiy *
4061e51764aSArtem Bityutskiy * UBIFS budgeting sub-system may force write-back if it thinks there is no
4071e51764aSArtem Bityutskiy * space to reserve. This imposes some locking restrictions and makes it
4081e51764aSArtem Bityutskiy * impossible to take into account the above cases, and makes it impossible to
4091e51764aSArtem Bityutskiy * optimize budgeting.
4101e51764aSArtem Bityutskiy *
4111e51764aSArtem Bityutskiy * The solution for this is that the fast path of 'ubifs_write_begin()' assumes
4121e51764aSArtem Bityutskiy * there is a plenty of flash space and the budget will be acquired quickly,
4131e51764aSArtem Bityutskiy * without forcing write-back. The slow path does not make this assumption.
4141e51764aSArtem Bityutskiy */
ubifs_write_begin(struct file * file,struct address_space * mapping,loff_t pos,unsigned len,struct folio ** foliop,void ** fsdata)4151e51764aSArtem Bityutskiy static int ubifs_write_begin(struct file *file, struct address_space *mapping,
4169d6b0cd7SMatthew Wilcox (Oracle) loff_t pos, unsigned len,
417*1da86618SMatthew Wilcox (Oracle) struct folio **foliop, void **fsdata)
4181e51764aSArtem Bityutskiy {
4191e51764aSArtem Bityutskiy struct inode *inode = mapping->host;
4201e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info;
4211e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode);
42209cbfeafSKirill A. Shutemov pgoff_t index = pos >> PAGE_SHIFT;
4233f649ab7SKees Cook int err, appending = !!(pos + len > inode->i_size);
424f55aa591SAdrian Hunter int skipped_read = 0;
425f60d356eSMatthew Wilcox (Oracle) struct folio *folio;
4261e51764aSArtem Bityutskiy
4276eb61d58SRichard Weinberger ubifs_assert(c, ubifs_inode(inode)->ui_size == inode->i_size);
4286eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount);
4291e51764aSArtem Bityutskiy
4302680d722SArtem Bityutskiy if (unlikely(c->ro_error))
4311e51764aSArtem Bityutskiy return -EROFS;
4321e51764aSArtem Bityutskiy
4331e51764aSArtem Bityutskiy /* Try out the fast-path part first */
434f60d356eSMatthew Wilcox (Oracle) folio = __filemap_get_folio(mapping, index, FGP_WRITEBEGIN,
435f60d356eSMatthew Wilcox (Oracle) mapping_gfp_mask(mapping));
436f60d356eSMatthew Wilcox (Oracle) if (IS_ERR(folio))
437f60d356eSMatthew Wilcox (Oracle) return PTR_ERR(folio);
4381e51764aSArtem Bityutskiy
439f60d356eSMatthew Wilcox (Oracle) if (!folio_test_uptodate(folio)) {
4401e51764aSArtem Bityutskiy /* The page is not loaded from the flash */
441f60d356eSMatthew Wilcox (Oracle) if (pos == folio_pos(folio) && len >= folio_size(folio)) {
4421e51764aSArtem Bityutskiy /*
4431e51764aSArtem Bityutskiy * We change whole page so no need to load it. But we
4446ed09c34SArtem Bityutskiy * do not know whether this page exists on the media or
4456ed09c34SArtem Bityutskiy * not, so we assume the latter because it requires
4466ed09c34SArtem Bityutskiy * larger budget. The assumption is that it is better
4476ed09c34SArtem Bityutskiy * to budget a bit more than to read the page from the
4486ed09c34SArtem Bityutskiy * media. Thus, we are setting the @PG_checked flag
4496ed09c34SArtem Bityutskiy * here.
4501e51764aSArtem Bityutskiy */
451f60d356eSMatthew Wilcox (Oracle) folio_set_checked(folio);
452f55aa591SAdrian Hunter skipped_read = 1;
453f55aa591SAdrian Hunter } else {
454b96af1fdSMatthew Wilcox (Oracle) err = do_readpage(folio);
4551e51764aSArtem Bityutskiy if (err) {
456f60d356eSMatthew Wilcox (Oracle) folio_unlock(folio);
457f60d356eSMatthew Wilcox (Oracle) folio_put(folio);
4581e51764aSArtem Bityutskiy return err;
4591e51764aSArtem Bityutskiy }
4601e51764aSArtem Bityutskiy }
4611e51764aSArtem Bityutskiy }
4621e51764aSArtem Bityutskiy
463a3c2f196SMatthew Wilcox (Oracle) err = allocate_budget(c, folio, ui, appending);
4641e51764aSArtem Bityutskiy if (unlikely(err)) {
4656eb61d58SRichard Weinberger ubifs_assert(c, err == -ENOSPC);
4661e51764aSArtem Bityutskiy /*
467f55aa591SAdrian Hunter * If we skipped reading the page because we were going to
468f55aa591SAdrian Hunter * write all of it, then it is not up to date.
469f55aa591SAdrian Hunter */
470723012caSMatthew Wilcox (Oracle) if (skipped_read)
471f60d356eSMatthew Wilcox (Oracle) folio_clear_checked(folio);
472f55aa591SAdrian Hunter /*
4731e51764aSArtem Bityutskiy * Budgeting failed which means it would have to force
4741e51764aSArtem Bityutskiy * write-back but didn't, because we set the @fast flag in the
4751e51764aSArtem Bityutskiy * request. Write-back cannot be done now, while we have the
4761e51764aSArtem Bityutskiy * page locked, because it would deadlock. Unlock and free
4771e51764aSArtem Bityutskiy * everything and fall-back to slow-path.
4781e51764aSArtem Bityutskiy */
4791e51764aSArtem Bityutskiy if (appending) {
4806eb61d58SRichard Weinberger ubifs_assert(c, mutex_is_locked(&ui->ui_mutex));
4811e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex);
4821e51764aSArtem Bityutskiy }
483f60d356eSMatthew Wilcox (Oracle) folio_unlock(folio);
484f60d356eSMatthew Wilcox (Oracle) folio_put(folio);
4851e51764aSArtem Bityutskiy
486*1da86618SMatthew Wilcox (Oracle) return write_begin_slow(mapping, pos, len, foliop);
4871e51764aSArtem Bityutskiy }
4881e51764aSArtem Bityutskiy
4891e51764aSArtem Bityutskiy /*
490873a64c7SArtem Bityutskiy * Whee, we acquired budgeting quickly - without involving
491873a64c7SArtem Bityutskiy * garbage-collection, committing or forcing write-back. We return
4921e51764aSArtem Bityutskiy * with @ui->ui_mutex locked if we are appending pages, and unlocked
4931e51764aSArtem Bityutskiy * otherwise. This is an optimization (slightly hacky though).
4941e51764aSArtem Bityutskiy */
495*1da86618SMatthew Wilcox (Oracle) *foliop = folio;
4961e51764aSArtem Bityutskiy return 0;
4971e51764aSArtem Bityutskiy }
4981e51764aSArtem Bityutskiy
4991e51764aSArtem Bityutskiy /**
5001e51764aSArtem Bityutskiy * cancel_budget - cancel budget.
5011e51764aSArtem Bityutskiy * @c: UBIFS file-system description object
50245d76698SMatthew Wilcox (Oracle) * @folio: folio to cancel budget for
5031e51764aSArtem Bityutskiy * @ui: UBIFS inode object the page belongs to
5041e51764aSArtem Bityutskiy * @appending: non-zero if the page is appended
5051e51764aSArtem Bityutskiy *
5061e51764aSArtem Bityutskiy * This is a helper function for a page write operation. It unlocks the
5071e51764aSArtem Bityutskiy * @ui->ui_mutex in case of appending.
5081e51764aSArtem Bityutskiy */
cancel_budget(struct ubifs_info * c,struct folio * folio,struct ubifs_inode * ui,int appending)50945d76698SMatthew Wilcox (Oracle) static void cancel_budget(struct ubifs_info *c, struct folio *folio,
5101e51764aSArtem Bityutskiy struct ubifs_inode *ui, int appending)
5111e51764aSArtem Bityutskiy {
5121e51764aSArtem Bityutskiy if (appending) {
5131e51764aSArtem Bityutskiy if (!ui->dirty)
5141e51764aSArtem Bityutskiy ubifs_release_dirty_inode_budget(c, ui);
5151e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex);
5161e51764aSArtem Bityutskiy }
51745d76698SMatthew Wilcox (Oracle) if (!folio->private) {
51845d76698SMatthew Wilcox (Oracle) if (folio_test_checked(folio))
5191e51764aSArtem Bityutskiy release_new_page_budget(c);
5201e51764aSArtem Bityutskiy else
5211e51764aSArtem Bityutskiy release_existing_page_budget(c);
5221e51764aSArtem Bityutskiy }
5231e51764aSArtem Bityutskiy }
5241e51764aSArtem Bityutskiy
ubifs_write_end(struct file * file,struct address_space * mapping,loff_t pos,unsigned len,unsigned copied,struct folio * folio,void * fsdata)5251e51764aSArtem Bityutskiy static int ubifs_write_end(struct file *file, struct address_space *mapping,
5261e51764aSArtem Bityutskiy loff_t pos, unsigned len, unsigned copied,
527a225800fSMatthew Wilcox (Oracle) struct folio *folio, void *fsdata)
5281e51764aSArtem Bityutskiy {
5291e51764aSArtem Bityutskiy struct inode *inode = mapping->host;
5301e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode);
5311e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info;
5321e51764aSArtem Bityutskiy loff_t end_pos = pos + len;
5331e51764aSArtem Bityutskiy int appending = !!(end_pos > inode->i_size);
5341e51764aSArtem Bityutskiy
5351e51764aSArtem Bityutskiy dbg_gen("ino %lu, pos %llu, pg %lu, len %u, copied %d, i_size %lld",
536ffdff813SMatthew Wilcox (Oracle) inode->i_ino, pos, folio->index, len, copied, inode->i_size);
5371e51764aSArtem Bityutskiy
538ffdff813SMatthew Wilcox (Oracle) if (unlikely(copied < len && !folio_test_uptodate(folio))) {
5391e51764aSArtem Bityutskiy /*
540ffdff813SMatthew Wilcox (Oracle) * VFS copied less data to the folio than it intended and
5411e51764aSArtem Bityutskiy * declared in its '->write_begin()' call via the @len
542ffdff813SMatthew Wilcox (Oracle) * argument. If the folio was not up-to-date,
543ffdff813SMatthew Wilcox (Oracle) * the 'ubifs_write_begin()' function did
5441e51764aSArtem Bityutskiy * not load it from the media (for optimization reasons). This
545ffdff813SMatthew Wilcox (Oracle) * means that part of the folio contains garbage. So read the
546ffdff813SMatthew Wilcox (Oracle) * folio now.
5471e51764aSArtem Bityutskiy */
5481e51764aSArtem Bityutskiy dbg_gen("copied %d instead of %d, read page and repeat",
5491e51764aSArtem Bityutskiy copied, len);
55045d76698SMatthew Wilcox (Oracle) cancel_budget(c, folio, ui, appending);
551ffdff813SMatthew Wilcox (Oracle) folio_clear_checked(folio);
5521e51764aSArtem Bityutskiy
5531e51764aSArtem Bityutskiy /*
5541e51764aSArtem Bityutskiy * Return 0 to force VFS to repeat the whole operation, or the
555873a64c7SArtem Bityutskiy * error code if 'do_readpage()' fails.
5561e51764aSArtem Bityutskiy */
557b96af1fdSMatthew Wilcox (Oracle) copied = do_readpage(folio);
5581e51764aSArtem Bityutskiy goto out;
5591e51764aSArtem Bityutskiy }
5601e51764aSArtem Bityutskiy
561ffdff813SMatthew Wilcox (Oracle) if (len == folio_size(folio))
562ffdff813SMatthew Wilcox (Oracle) folio_mark_uptodate(folio);
563723012caSMatthew Wilcox (Oracle)
564ffdff813SMatthew Wilcox (Oracle) if (!folio->private) {
565ffdff813SMatthew Wilcox (Oracle) folio_attach_private(folio, (void *)1);
5661e51764aSArtem Bityutskiy atomic_long_inc(&c->dirty_pg_cnt);
567ffdff813SMatthew Wilcox (Oracle) filemap_dirty_folio(mapping, folio);
5681e51764aSArtem Bityutskiy }
5691e51764aSArtem Bityutskiy
5701e51764aSArtem Bityutskiy if (appending) {
5711e51764aSArtem Bityutskiy i_size_write(inode, end_pos);
5721e51764aSArtem Bityutskiy ui->ui_size = end_pos;
5731e51764aSArtem Bityutskiy /*
574ffdff813SMatthew Wilcox (Oracle) * We do not set @I_DIRTY_PAGES (which means that
575ffdff813SMatthew Wilcox (Oracle) * the inode has dirty pages), this was done in
576ffdff813SMatthew Wilcox (Oracle) * filemap_dirty_folio().
5771e51764aSArtem Bityutskiy */
5781e51764aSArtem Bityutskiy __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
5796eb61d58SRichard Weinberger ubifs_assert(c, mutex_is_locked(&ui->ui_mutex));
5801e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex);
5811e51764aSArtem Bityutskiy }
5821e51764aSArtem Bityutskiy
5831e51764aSArtem Bityutskiy out:
584ffdff813SMatthew Wilcox (Oracle) folio_unlock(folio);
585ffdff813SMatthew Wilcox (Oracle) folio_put(folio);
5861e51764aSArtem Bityutskiy return copied;
5871e51764aSArtem Bityutskiy }
5881e51764aSArtem Bityutskiy
5894793e7c5SAdrian Hunter /**
5904793e7c5SAdrian Hunter * populate_page - copy data nodes into a page for bulk-read.
5914793e7c5SAdrian Hunter * @c: UBIFS file-system description object
592a16bfab3SMatthew Wilcox (Oracle) * @folio: folio
5934793e7c5SAdrian Hunter * @bu: bulk-read information
5944793e7c5SAdrian Hunter * @n: next zbranch slot
5954793e7c5SAdrian Hunter *
596ac8e9f64SRandy Dunlap * Returns: %0 on success and a negative error code on failure.
5974793e7c5SAdrian Hunter */
populate_page(struct ubifs_info * c,struct folio * folio,struct bu_info * bu,int * n)598a16bfab3SMatthew Wilcox (Oracle) static int populate_page(struct ubifs_info *c, struct folio *folio,
5994793e7c5SAdrian Hunter struct bu_info *bu, int *n)
6004793e7c5SAdrian Hunter {
6015c0013c1SAdrian Hunter int i = 0, nn = *n, offs = bu->zbranch[0].offs, hole = 0, read = 0;
602a16bfab3SMatthew Wilcox (Oracle) struct inode *inode = folio->mapping->host;
6034793e7c5SAdrian Hunter loff_t i_size = i_size_read(inode);
6044793e7c5SAdrian Hunter unsigned int page_block;
6054793e7c5SAdrian Hunter void *addr, *zaddr;
6064793e7c5SAdrian Hunter pgoff_t end_index;
6074793e7c5SAdrian Hunter
6084793e7c5SAdrian Hunter dbg_gen("ino %lu, pg %lu, i_size %lld, flags %#lx",
609a16bfab3SMatthew Wilcox (Oracle) inode->i_ino, folio->index, i_size, folio->flags);
6104793e7c5SAdrian Hunter
611a16bfab3SMatthew Wilcox (Oracle) addr = zaddr = kmap_local_folio(folio, 0);
6124793e7c5SAdrian Hunter
61309cbfeafSKirill A. Shutemov end_index = (i_size - 1) >> PAGE_SHIFT;
614a16bfab3SMatthew Wilcox (Oracle) if (!i_size || folio->index > end_index) {
6155c0013c1SAdrian Hunter hole = 1;
616a16bfab3SMatthew Wilcox (Oracle) addr = folio_zero_tail(folio, 0, addr);
6174793e7c5SAdrian Hunter goto out_hole;
6184793e7c5SAdrian Hunter }
6194793e7c5SAdrian Hunter
620a16bfab3SMatthew Wilcox (Oracle) page_block = folio->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;
6214793e7c5SAdrian Hunter while (1) {
6224793e7c5SAdrian Hunter int err, len, out_len, dlen;
6234793e7c5SAdrian Hunter
6245c0013c1SAdrian Hunter if (nn >= bu->cnt) {
6255c0013c1SAdrian Hunter hole = 1;
6264793e7c5SAdrian Hunter memset(addr, 0, UBIFS_BLOCK_SIZE);
6275c0013c1SAdrian Hunter } else if (key_block(c, &bu->zbranch[nn].key) == page_block) {
6284793e7c5SAdrian Hunter struct ubifs_data_node *dn;
6294793e7c5SAdrian Hunter
6304793e7c5SAdrian Hunter dn = bu->buf + (bu->zbranch[nn].offs - offs);
6314793e7c5SAdrian Hunter
6326eb61d58SRichard Weinberger ubifs_assert(c, le64_to_cpu(dn->ch.sqnum) >
6334793e7c5SAdrian Hunter ubifs_inode(inode)->creat_sqnum);
6344793e7c5SAdrian Hunter
6354793e7c5SAdrian Hunter len = le32_to_cpu(dn->size);
6364793e7c5SAdrian Hunter if (len <= 0 || len > UBIFS_BLOCK_SIZE)
6374793e7c5SAdrian Hunter goto out_err;
6384793e7c5SAdrian Hunter
6394793e7c5SAdrian Hunter dlen = le32_to_cpu(dn->ch.len) - UBIFS_DATA_NODE_SZ;
6404793e7c5SAdrian Hunter out_len = UBIFS_BLOCK_SIZE;
6417799953bSRichard Weinberger
64250d9fad7SEric Biggers if (IS_ENCRYPTED(inode)) {
6437799953bSRichard Weinberger err = ubifs_decrypt(inode, dn, &dlen, page_block);
6447799953bSRichard Weinberger if (err)
6457799953bSRichard Weinberger goto out_err;
6467799953bSRichard Weinberger }
6477799953bSRichard Weinberger
648235c362bSSheng Yong err = ubifs_decompress(c, &dn->data, dlen, addr, &out_len,
6494793e7c5SAdrian Hunter le16_to_cpu(dn->compr_type));
6504793e7c5SAdrian Hunter if (err || len != out_len)
6514793e7c5SAdrian Hunter goto out_err;
6524793e7c5SAdrian Hunter
6534793e7c5SAdrian Hunter if (len < UBIFS_BLOCK_SIZE)
6544793e7c5SAdrian Hunter memset(addr + len, 0, UBIFS_BLOCK_SIZE - len);
6554793e7c5SAdrian Hunter
6564793e7c5SAdrian Hunter nn += 1;
6574793e7c5SAdrian Hunter read = (i << UBIFS_BLOCK_SHIFT) + len;
6585c0013c1SAdrian Hunter } else if (key_block(c, &bu->zbranch[nn].key) < page_block) {
6595c0013c1SAdrian Hunter nn += 1;
6605c0013c1SAdrian Hunter continue;
6615c0013c1SAdrian Hunter } else {
6625c0013c1SAdrian Hunter hole = 1;
6635c0013c1SAdrian Hunter memset(addr, 0, UBIFS_BLOCK_SIZE);
6644793e7c5SAdrian Hunter }
6654793e7c5SAdrian Hunter if (++i >= UBIFS_BLOCKS_PER_PAGE)
6664793e7c5SAdrian Hunter break;
6674793e7c5SAdrian Hunter addr += UBIFS_BLOCK_SIZE;
6684793e7c5SAdrian Hunter page_block += 1;
669a16bfab3SMatthew Wilcox (Oracle) if (folio_test_highmem(folio) && (offset_in_page(addr) == 0)) {
670a16bfab3SMatthew Wilcox (Oracle) kunmap_local(addr - UBIFS_BLOCK_SIZE);
671a16bfab3SMatthew Wilcox (Oracle) addr = kmap_local_folio(folio, i * UBIFS_BLOCK_SIZE);
672a16bfab3SMatthew Wilcox (Oracle) }
6734793e7c5SAdrian Hunter }
6744793e7c5SAdrian Hunter
675a16bfab3SMatthew Wilcox (Oracle) if (end_index == folio->index) {
67609cbfeafSKirill A. Shutemov int len = i_size & (PAGE_SIZE - 1);
6774793e7c5SAdrian Hunter
678ed382d58SAdrian Hunter if (len && len < read)
6794793e7c5SAdrian Hunter memset(zaddr + len, 0, read - len);
6804793e7c5SAdrian Hunter }
6814793e7c5SAdrian Hunter
6824793e7c5SAdrian Hunter out_hole:
6834793e7c5SAdrian Hunter if (hole) {
684a16bfab3SMatthew Wilcox (Oracle) folio_set_checked(folio);
6854793e7c5SAdrian Hunter dbg_gen("hole");
6864793e7c5SAdrian Hunter }
6874793e7c5SAdrian Hunter
688a16bfab3SMatthew Wilcox (Oracle) folio_mark_uptodate(folio);
689a16bfab3SMatthew Wilcox (Oracle) flush_dcache_folio(folio);
690a16bfab3SMatthew Wilcox (Oracle) kunmap_local(addr);
6914793e7c5SAdrian Hunter *n = nn;
6924793e7c5SAdrian Hunter return 0;
6934793e7c5SAdrian Hunter
6944793e7c5SAdrian Hunter out_err:
695a16bfab3SMatthew Wilcox (Oracle) flush_dcache_folio(folio);
696a16bfab3SMatthew Wilcox (Oracle) kunmap_local(addr);
697235c362bSSheng Yong ubifs_err(c, "bad data node (block %u, inode %lu)",
6984793e7c5SAdrian Hunter page_block, inode->i_ino);
6994793e7c5SAdrian Hunter return -EINVAL;
7004793e7c5SAdrian Hunter }
7014793e7c5SAdrian Hunter
7024793e7c5SAdrian Hunter /**
7034793e7c5SAdrian Hunter * ubifs_do_bulk_read - do bulk-read.
7044793e7c5SAdrian Hunter * @c: UBIFS file-system description object
7056c0c42cdSArtem Bityutskiy * @bu: bulk-read information
7067f348f8cSMatthew Wilcox (Oracle) * @folio1: first folio to read
7074793e7c5SAdrian Hunter *
708ac8e9f64SRandy Dunlap * Returns: %1 if the bulk-read is done, otherwise %0 is returned.
7094793e7c5SAdrian Hunter */
ubifs_do_bulk_read(struct ubifs_info * c,struct bu_info * bu,struct folio * folio1)7106c0c42cdSArtem Bityutskiy static int ubifs_do_bulk_read(struct ubifs_info *c, struct bu_info *bu,
7117f348f8cSMatthew Wilcox (Oracle) struct folio *folio1)
7124793e7c5SAdrian Hunter {
7137f348f8cSMatthew Wilcox (Oracle) pgoff_t offset = folio1->index, end_index;
7147f348f8cSMatthew Wilcox (Oracle) struct address_space *mapping = folio1->mapping;
7154793e7c5SAdrian Hunter struct inode *inode = mapping->host;
7164793e7c5SAdrian Hunter struct ubifs_inode *ui = ubifs_inode(inode);
7174793e7c5SAdrian Hunter int err, page_idx, page_cnt, ret = 0, n = 0;
7186c0c42cdSArtem Bityutskiy int allocate = bu->buf ? 0 : 1;
7194793e7c5SAdrian Hunter loff_t isize;
720480a1a6aSHyunchul Lee gfp_t ra_gfp_mask = readahead_gfp_mask(mapping) & ~__GFP_FS;
7214793e7c5SAdrian Hunter
7224793e7c5SAdrian Hunter err = ubifs_tnc_get_bu_keys(c, bu);
7234793e7c5SAdrian Hunter if (err)
7244793e7c5SAdrian Hunter goto out_warn;
7254793e7c5SAdrian Hunter
7264793e7c5SAdrian Hunter if (bu->eof) {
7274793e7c5SAdrian Hunter /* Turn off bulk-read at the end of the file */
7284793e7c5SAdrian Hunter ui->read_in_a_row = 1;
7294793e7c5SAdrian Hunter ui->bulk_read = 0;
7304793e7c5SAdrian Hunter }
7314793e7c5SAdrian Hunter
7324793e7c5SAdrian Hunter page_cnt = bu->blk_cnt >> UBIFS_BLOCKS_PER_PAGE_SHIFT;
7334793e7c5SAdrian Hunter if (!page_cnt) {
7344793e7c5SAdrian Hunter /*
7354793e7c5SAdrian Hunter * This happens when there are multiple blocks per page and the
7364793e7c5SAdrian Hunter * blocks for the first page we are looking for, are not
7374793e7c5SAdrian Hunter * together. If all the pages were like this, bulk-read would
7384793e7c5SAdrian Hunter * reduce performance, so we turn it off for a while.
7394793e7c5SAdrian Hunter */
7406c0c42cdSArtem Bityutskiy goto out_bu_off;
7414793e7c5SAdrian Hunter }
7424793e7c5SAdrian Hunter
7434793e7c5SAdrian Hunter if (bu->cnt) {
7446c0c42cdSArtem Bityutskiy if (allocate) {
7456c0c42cdSArtem Bityutskiy /*
7466c0c42cdSArtem Bityutskiy * Allocate bulk-read buffer depending on how many data
7476c0c42cdSArtem Bityutskiy * nodes we are going to read.
7486c0c42cdSArtem Bityutskiy */
7496c0c42cdSArtem Bityutskiy bu->buf_len = bu->zbranch[bu->cnt - 1].offs +
7506c0c42cdSArtem Bityutskiy bu->zbranch[bu->cnt - 1].len -
7516c0c42cdSArtem Bityutskiy bu->zbranch[0].offs;
7526eb61d58SRichard Weinberger ubifs_assert(c, bu->buf_len > 0);
7536eb61d58SRichard Weinberger ubifs_assert(c, bu->buf_len <= c->leb_size);
7546c0c42cdSArtem Bityutskiy bu->buf = kmalloc(bu->buf_len, GFP_NOFS | __GFP_NOWARN);
7556c0c42cdSArtem Bityutskiy if (!bu->buf)
7566c0c42cdSArtem Bityutskiy goto out_bu_off;
7576c0c42cdSArtem Bityutskiy }
7586c0c42cdSArtem Bityutskiy
7594793e7c5SAdrian Hunter err = ubifs_tnc_bulk_read(c, bu);
7604793e7c5SAdrian Hunter if (err)
7614793e7c5SAdrian Hunter goto out_warn;
7624793e7c5SAdrian Hunter }
7634793e7c5SAdrian Hunter
764a16bfab3SMatthew Wilcox (Oracle) err = populate_page(c, folio1, bu, &n);
7654793e7c5SAdrian Hunter if (err)
7664793e7c5SAdrian Hunter goto out_warn;
7674793e7c5SAdrian Hunter
7687f348f8cSMatthew Wilcox (Oracle) folio_unlock(folio1);
7694793e7c5SAdrian Hunter ret = 1;
7704793e7c5SAdrian Hunter
7714793e7c5SAdrian Hunter isize = i_size_read(inode);
7724793e7c5SAdrian Hunter if (isize == 0)
7734793e7c5SAdrian Hunter goto out_free;
77409cbfeafSKirill A. Shutemov end_index = ((isize - 1) >> PAGE_SHIFT);
7754793e7c5SAdrian Hunter
7764793e7c5SAdrian Hunter for (page_idx = 1; page_idx < page_cnt; page_idx++) {
7774793e7c5SAdrian Hunter pgoff_t page_offset = offset + page_idx;
778d0619273SMatthew Wilcox (Oracle) struct folio *folio;
7794793e7c5SAdrian Hunter
7804793e7c5SAdrian Hunter if (page_offset > end_index)
7814793e7c5SAdrian Hunter break;
782d0619273SMatthew Wilcox (Oracle) folio = __filemap_get_folio(mapping, page_offset,
783f5de5b83SZhihao Cheng FGP_LOCK|FGP_ACCESSED|FGP_CREAT|FGP_NOWAIT,
784f5de5b83SZhihao Cheng ra_gfp_mask);
785d0619273SMatthew Wilcox (Oracle) if (IS_ERR(folio))
7864793e7c5SAdrian Hunter break;
787d0619273SMatthew Wilcox (Oracle) if (!folio_test_uptodate(folio))
788a16bfab3SMatthew Wilcox (Oracle) err = populate_page(c, folio, bu, &n);
789d0619273SMatthew Wilcox (Oracle) folio_unlock(folio);
790d0619273SMatthew Wilcox (Oracle) folio_put(folio);
7914793e7c5SAdrian Hunter if (err)
7924793e7c5SAdrian Hunter break;
7934793e7c5SAdrian Hunter }
7944793e7c5SAdrian Hunter
7954793e7c5SAdrian Hunter ui->last_page_read = offset + page_idx - 1;
7964793e7c5SAdrian Hunter
7974793e7c5SAdrian Hunter out_free:
7986c0c42cdSArtem Bityutskiy if (allocate)
7994793e7c5SAdrian Hunter kfree(bu->buf);
8004793e7c5SAdrian Hunter return ret;
8014793e7c5SAdrian Hunter
8024793e7c5SAdrian Hunter out_warn:
803235c362bSSheng Yong ubifs_warn(c, "ignoring error %d and skipping bulk-read", err);
8044793e7c5SAdrian Hunter goto out_free;
8056c0c42cdSArtem Bityutskiy
8066c0c42cdSArtem Bityutskiy out_bu_off:
8076c0c42cdSArtem Bityutskiy ui->read_in_a_row = ui->bulk_read = 0;
8086c0c42cdSArtem Bityutskiy goto out_free;
8094793e7c5SAdrian Hunter }
8104793e7c5SAdrian Hunter
8114793e7c5SAdrian Hunter /**
8124793e7c5SAdrian Hunter * ubifs_bulk_read - determine whether to bulk-read and, if so, do it.
8137f348f8cSMatthew Wilcox (Oracle) * @folio: folio from which to start bulk-read.
8144793e7c5SAdrian Hunter *
8154793e7c5SAdrian Hunter * Some flash media are capable of reading sequentially at faster rates. UBIFS
8164793e7c5SAdrian Hunter * bulk-read facility is designed to take advantage of that, by reading in one
8174793e7c5SAdrian Hunter * go consecutive data nodes that are also located consecutively in the same
818ac8e9f64SRandy Dunlap * LEB.
819ac8e9f64SRandy Dunlap *
820ac8e9f64SRandy Dunlap * Returns: %1 if a bulk-read is done and %0 otherwise.
8214793e7c5SAdrian Hunter */
ubifs_bulk_read(struct folio * folio)8227f348f8cSMatthew Wilcox (Oracle) static int ubifs_bulk_read(struct folio *folio)
8234793e7c5SAdrian Hunter {
8247f348f8cSMatthew Wilcox (Oracle) struct inode *inode = folio->mapping->host;
8254793e7c5SAdrian Hunter struct ubifs_info *c = inode->i_sb->s_fs_info;
8264793e7c5SAdrian Hunter struct ubifs_inode *ui = ubifs_inode(inode);
8277f348f8cSMatthew Wilcox (Oracle) pgoff_t index = folio->index, last_page_read = ui->last_page_read;
8286c0c42cdSArtem Bityutskiy struct bu_info *bu;
8293477d204SArtem Bityutskiy int err = 0, allocated = 0;
8304793e7c5SAdrian Hunter
8314793e7c5SAdrian Hunter ui->last_page_read = index;
8324793e7c5SAdrian Hunter if (!c->bulk_read)
8334793e7c5SAdrian Hunter return 0;
8346c0c42cdSArtem Bityutskiy
8354793e7c5SAdrian Hunter /*
8363477d204SArtem Bityutskiy * Bulk-read is protected by @ui->ui_mutex, but it is an optimization,
8373477d204SArtem Bityutskiy * so don't bother if we cannot lock the mutex.
8384793e7c5SAdrian Hunter */
8394793e7c5SAdrian Hunter if (!mutex_trylock(&ui->ui_mutex))
8404793e7c5SAdrian Hunter return 0;
8416c0c42cdSArtem Bityutskiy
8424793e7c5SAdrian Hunter if (index != last_page_read + 1) {
8434793e7c5SAdrian Hunter /* Turn off bulk-read if we stop reading sequentially */
8444793e7c5SAdrian Hunter ui->read_in_a_row = 1;
8454793e7c5SAdrian Hunter if (ui->bulk_read)
8464793e7c5SAdrian Hunter ui->bulk_read = 0;
8474793e7c5SAdrian Hunter goto out_unlock;
8484793e7c5SAdrian Hunter }
8496c0c42cdSArtem Bityutskiy
8504793e7c5SAdrian Hunter if (!ui->bulk_read) {
8514793e7c5SAdrian Hunter ui->read_in_a_row += 1;
8524793e7c5SAdrian Hunter if (ui->read_in_a_row < 3)
8534793e7c5SAdrian Hunter goto out_unlock;
8544793e7c5SAdrian Hunter /* Three reads in a row, so switch on bulk-read */
8554793e7c5SAdrian Hunter ui->bulk_read = 1;
8564793e7c5SAdrian Hunter }
8576c0c42cdSArtem Bityutskiy
8583477d204SArtem Bityutskiy /*
8593477d204SArtem Bityutskiy * If possible, try to use pre-allocated bulk-read information, which
8603477d204SArtem Bityutskiy * is protected by @c->bu_mutex.
8613477d204SArtem Bityutskiy */
8623477d204SArtem Bityutskiy if (mutex_trylock(&c->bu_mutex))
8633477d204SArtem Bityutskiy bu = &c->bu;
8643477d204SArtem Bityutskiy else {
8656c0c42cdSArtem Bityutskiy bu = kmalloc(sizeof(struct bu_info), GFP_NOFS | __GFP_NOWARN);
8666c0c42cdSArtem Bityutskiy if (!bu)
8673477d204SArtem Bityutskiy goto out_unlock;
8686c0c42cdSArtem Bityutskiy
8696c0c42cdSArtem Bityutskiy bu->buf = NULL;
8703477d204SArtem Bityutskiy allocated = 1;
8713477d204SArtem Bityutskiy }
8723477d204SArtem Bityutskiy
8736c0c42cdSArtem Bityutskiy bu->buf_len = c->max_bu_buf_len;
8746c0c42cdSArtem Bityutskiy data_key_init(c, &bu->key, inode->i_ino,
8757f348f8cSMatthew Wilcox (Oracle) folio->index << UBIFS_BLOCKS_PER_PAGE_SHIFT);
8767f348f8cSMatthew Wilcox (Oracle) err = ubifs_do_bulk_read(c, bu, folio);
8773477d204SArtem Bityutskiy
8783477d204SArtem Bityutskiy if (!allocated)
8793477d204SArtem Bityutskiy mutex_unlock(&c->bu_mutex);
8803477d204SArtem Bityutskiy else
8816c0c42cdSArtem Bityutskiy kfree(bu);
8826c0c42cdSArtem Bityutskiy
8834793e7c5SAdrian Hunter out_unlock:
8844793e7c5SAdrian Hunter mutex_unlock(&ui->ui_mutex);
8856c0c42cdSArtem Bityutskiy return err;
8864793e7c5SAdrian Hunter }
8874793e7c5SAdrian Hunter
ubifs_read_folio(struct file * file,struct folio * folio)8880b7bf483SMatthew Wilcox (Oracle) static int ubifs_read_folio(struct file *file, struct folio *folio)
8891e51764aSArtem Bityutskiy {
8907f348f8cSMatthew Wilcox (Oracle) if (ubifs_bulk_read(folio))
8914793e7c5SAdrian Hunter return 0;
892b96af1fdSMatthew Wilcox (Oracle) do_readpage(folio);
8930b7bf483SMatthew Wilcox (Oracle) folio_unlock(folio);
8941e51764aSArtem Bityutskiy return 0;
8951e51764aSArtem Bityutskiy }
8961e51764aSArtem Bityutskiy
do_writepage(struct folio * folio,size_t len)8970c2d140cSMatthew Wilcox (Oracle) static int do_writepage(struct folio *folio, size_t len)
8981e51764aSArtem Bityutskiy {
8990c2d140cSMatthew Wilcox (Oracle) int err = 0, blen;
9001e51764aSArtem Bityutskiy unsigned int block;
9011e51764aSArtem Bityutskiy void *addr;
9020c2d140cSMatthew Wilcox (Oracle) size_t offset = 0;
9031e51764aSArtem Bityutskiy union ubifs_key key;
9040c2d140cSMatthew Wilcox (Oracle) struct inode *inode = folio->mapping->host;
9051e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info;
9061e51764aSArtem Bityutskiy
9071e51764aSArtem Bityutskiy #ifdef UBIFS_DEBUG
908a0fd5951SDaniel Golle struct ubifs_inode *ui = ubifs_inode(inode);
9091e51764aSArtem Bityutskiy spin_lock(&ui->ui_lock);
9100c2d140cSMatthew Wilcox (Oracle) ubifs_assert(c, folio->index <= ui->synced_i_size >> PAGE_SHIFT);
9111e51764aSArtem Bityutskiy spin_unlock(&ui->ui_lock);
9121e51764aSArtem Bityutskiy #endif
9131e51764aSArtem Bityutskiy
9140c2d140cSMatthew Wilcox (Oracle) folio_start_writeback(folio);
9151e51764aSArtem Bityutskiy
9160c2d140cSMatthew Wilcox (Oracle) addr = kmap_local_folio(folio, offset);
9170c2d140cSMatthew Wilcox (Oracle) block = folio->index << UBIFS_BLOCKS_PER_PAGE_SHIFT;
9180c2d140cSMatthew Wilcox (Oracle) for (;;) {
9190c2d140cSMatthew Wilcox (Oracle) blen = min_t(size_t, len, UBIFS_BLOCK_SIZE);
9201e51764aSArtem Bityutskiy data_key_init(c, &key, inode->i_ino, block);
9211e51764aSArtem Bityutskiy err = ubifs_jnl_write_data(c, inode, &key, addr, blen);
9221e51764aSArtem Bityutskiy if (err)
9231e51764aSArtem Bityutskiy break;
9240c2d140cSMatthew Wilcox (Oracle) len -= blen;
9250c2d140cSMatthew Wilcox (Oracle) if (!len)
9261e51764aSArtem Bityutskiy break;
9271e51764aSArtem Bityutskiy block += 1;
9281e51764aSArtem Bityutskiy addr += blen;
9290c2d140cSMatthew Wilcox (Oracle) if (folio_test_highmem(folio) && !offset_in_page(addr)) {
9300c2d140cSMatthew Wilcox (Oracle) kunmap_local(addr - blen);
9310c2d140cSMatthew Wilcox (Oracle) offset += PAGE_SIZE;
9320c2d140cSMatthew Wilcox (Oracle) addr = kmap_local_folio(folio, offset);
9331e51764aSArtem Bityutskiy }
9340c2d140cSMatthew Wilcox (Oracle) }
9350c2d140cSMatthew Wilcox (Oracle) kunmap_local(addr);
9361e51764aSArtem Bityutskiy if (err) {
9370c2d140cSMatthew Wilcox (Oracle) mapping_set_error(folio->mapping, err);
9380c2d140cSMatthew Wilcox (Oracle) ubifs_err(c, "cannot write folio %lu of inode %lu, error %d",
9390c2d140cSMatthew Wilcox (Oracle) folio->index, inode->i_ino, err);
9401e51764aSArtem Bityutskiy ubifs_ro_mode(c, err);
9411e51764aSArtem Bityutskiy }
9421e51764aSArtem Bityutskiy
9430c2d140cSMatthew Wilcox (Oracle) ubifs_assert(c, folio->private != NULL);
9440c2d140cSMatthew Wilcox (Oracle) if (folio_test_checked(folio))
9451e51764aSArtem Bityutskiy release_new_page_budget(c);
9461e51764aSArtem Bityutskiy else
9471e51764aSArtem Bityutskiy release_existing_page_budget(c);
9481e51764aSArtem Bityutskiy
9491e51764aSArtem Bityutskiy atomic_long_dec(&c->dirty_pg_cnt);
9500c2d140cSMatthew Wilcox (Oracle) folio_detach_private(folio);
9510c2d140cSMatthew Wilcox (Oracle) folio_clear_checked(folio);
9521e51764aSArtem Bityutskiy
9530c2d140cSMatthew Wilcox (Oracle) folio_unlock(folio);
9540c2d140cSMatthew Wilcox (Oracle) folio_end_writeback(folio);
9551e51764aSArtem Bityutskiy return err;
9561e51764aSArtem Bityutskiy }
9571e51764aSArtem Bityutskiy
9581e51764aSArtem Bityutskiy /*
9591e51764aSArtem Bityutskiy * When writing-back dirty inodes, VFS first writes-back pages belonging to the
9601e51764aSArtem Bityutskiy * inode, then the inode itself. For UBIFS this may cause a problem. Consider a
9611e51764aSArtem Bityutskiy * situation when a we have an inode with size 0, then a megabyte of data is
9621e51764aSArtem Bityutskiy * appended to the inode, then write-back starts and flushes some amount of the
9631e51764aSArtem Bityutskiy * dirty pages, the journal becomes full, commit happens and finishes, and then
9641e51764aSArtem Bityutskiy * an unclean reboot happens. When the file system is mounted next time, the
9651e51764aSArtem Bityutskiy * inode size would still be 0, but there would be many pages which are beyond
9661e51764aSArtem Bityutskiy * the inode size, they would be indexed and consume flash space. Because the
9671e51764aSArtem Bityutskiy * journal has been committed, the replay would not be able to detect this
9681e51764aSArtem Bityutskiy * situation and correct the inode size. This means UBIFS would have to scan
9691e51764aSArtem Bityutskiy * whole index and correct all inode sizes, which is long an unacceptable.
9701e51764aSArtem Bityutskiy *
9711e51764aSArtem Bityutskiy * To prevent situations like this, UBIFS writes pages back only if they are
9727d4e9ccbSArtem Bityutskiy * within the last synchronized inode size, i.e. the size which has been
9731e51764aSArtem Bityutskiy * written to the flash media last time. Otherwise, UBIFS forces inode
9741e51764aSArtem Bityutskiy * write-back, thus making sure the on-flash inode contains current inode size,
9751e51764aSArtem Bityutskiy * and then keeps writing pages back.
9761e51764aSArtem Bityutskiy *
9771e51764aSArtem Bityutskiy * Some locking issues explanation. 'ubifs_writepage()' first is called with
9781e51764aSArtem Bityutskiy * the page locked, and it locks @ui_mutex. However, write-back does take inode
9791e51764aSArtem Bityutskiy * @i_mutex, which means other VFS operations may be run on this inode at the
9801e51764aSArtem Bityutskiy * same time. And the problematic one is truncation to smaller size, from where
981c4361570SArtem Bityutskiy * we have to call 'truncate_setsize()', which first changes @inode->i_size,
982c4361570SArtem Bityutskiy * then drops the truncated pages. And while dropping the pages, it takes the
983c4361570SArtem Bityutskiy * page lock. This means that 'do_truncation()' cannot call 'truncate_setsize()'
984c4361570SArtem Bityutskiy * with @ui_mutex locked, because it would deadlock with 'ubifs_writepage()'.
985c4361570SArtem Bityutskiy * This means that @inode->i_size is changed while @ui_mutex is unlocked.
9861e51764aSArtem Bityutskiy *
9872c27c65eSChristoph Hellwig * XXX(truncate): with the new truncate sequence this is not true anymore,
9882c27c65eSChristoph Hellwig * and the calls to truncate_setsize can be move around freely. They should
9892c27c65eSChristoph Hellwig * be moved to the very end of the truncate sequence.
99015c6fd97Snpiggin@suse.de *
9911e51764aSArtem Bityutskiy * But in 'ubifs_writepage()' we have to guarantee that we do not write beyond
9921e51764aSArtem Bityutskiy * inode size. How do we do this if @inode->i_size may became smaller while we
9931e51764aSArtem Bityutskiy * are in the middle of 'ubifs_writepage()'? The UBIFS solution is the
9941e51764aSArtem Bityutskiy * @ui->ui_isize "shadow" field which UBIFS uses instead of @inode->i_size
9951e51764aSArtem Bityutskiy * internally and updates it under @ui_mutex.
9961e51764aSArtem Bityutskiy *
9971e51764aSArtem Bityutskiy * Q: why we do not worry that if we race with truncation, we may end up with a
9981e51764aSArtem Bityutskiy * situation when the inode is truncated while we are in the middle of
9991e51764aSArtem Bityutskiy * 'do_writepage()', so we do write beyond inode size?
10001e51764aSArtem Bityutskiy * A: If we are in the middle of 'do_writepage()', truncation would be locked
10011e51764aSArtem Bityutskiy * on the page lock and it would not write the truncated inode node to the
10021e51764aSArtem Bityutskiy * journal before we have finished.
10031e51764aSArtem Bityutskiy */
ubifs_writepage(struct folio * folio,struct writeback_control * wbc,void * data)10040df030d0SMatthew Wilcox (Oracle) static int ubifs_writepage(struct folio *folio, struct writeback_control *wbc,
10050df030d0SMatthew Wilcox (Oracle) void *data)
10061e51764aSArtem Bityutskiy {
1007c35acef3SMatthew Wilcox (Oracle) struct inode *inode = folio->mapping->host;
10086eb61d58SRichard Weinberger struct ubifs_info *c = inode->i_sb->s_fs_info;
10091e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode);
10101e51764aSArtem Bityutskiy loff_t i_size = i_size_read(inode), synced_i_size;
1011c35acef3SMatthew Wilcox (Oracle) int err, len = folio_size(folio);
10121e51764aSArtem Bityutskiy
10131e51764aSArtem Bityutskiy dbg_gen("ino %lu, pg %lu, pg flags %#lx",
1014c35acef3SMatthew Wilcox (Oracle) inode->i_ino, folio->index, folio->flags);
1015c35acef3SMatthew Wilcox (Oracle) ubifs_assert(c, folio->private != NULL);
10161e51764aSArtem Bityutskiy
1017c35acef3SMatthew Wilcox (Oracle) /* Is the folio fully outside @i_size? (truncate in progress) */
1018c35acef3SMatthew Wilcox (Oracle) if (folio_pos(folio) >= i_size) {
10191e51764aSArtem Bityutskiy err = 0;
10201e51764aSArtem Bityutskiy goto out_unlock;
10211e51764aSArtem Bityutskiy }
10221e51764aSArtem Bityutskiy
10231e51764aSArtem Bityutskiy spin_lock(&ui->ui_lock);
10241e51764aSArtem Bityutskiy synced_i_size = ui->synced_i_size;
10251e51764aSArtem Bityutskiy spin_unlock(&ui->ui_lock);
10261e51764aSArtem Bityutskiy
1027c35acef3SMatthew Wilcox (Oracle) /* Is the folio fully inside i_size? */
1028c35acef3SMatthew Wilcox (Oracle) if (folio_pos(folio) + len <= i_size) {
102925e79a7fSZhihao Cheng if (folio_pos(folio) + len > synced_i_size) {
1030a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL);
10311e51764aSArtem Bityutskiy if (err)
1032fb8bc4c7SZhihao Cheng goto out_redirty;
10331e51764aSArtem Bityutskiy /*
10341e51764aSArtem Bityutskiy * The inode has been written, but the write-buffer has
10351e51764aSArtem Bityutskiy * not been synchronized, so in case of an unclean
10361e51764aSArtem Bityutskiy * reboot we may end up with some pages beyond inode
10371e51764aSArtem Bityutskiy * size, but they would be in the journal (because
10381e51764aSArtem Bityutskiy * commit flushes write buffers) and recovery would deal
10391e51764aSArtem Bityutskiy * with this.
10401e51764aSArtem Bityutskiy */
10411e51764aSArtem Bityutskiy }
10420c2d140cSMatthew Wilcox (Oracle) return do_writepage(folio, len);
10431e51764aSArtem Bityutskiy }
10441e51764aSArtem Bityutskiy
10451e51764aSArtem Bityutskiy /*
1046c35acef3SMatthew Wilcox (Oracle) * The folio straddles @i_size. It must be zeroed out on each and every
10471e51764aSArtem Bityutskiy * writepage invocation because it may be mmapped. "A file is mapped
10481e51764aSArtem Bityutskiy * in multiples of the page size. For a file that is not a multiple of
10491e51764aSArtem Bityutskiy * the page size, the remaining memory is zeroed when mapped, and
10501e51764aSArtem Bityutskiy * writes to that region are not written out to the file."
10511e51764aSArtem Bityutskiy */
1052c35acef3SMatthew Wilcox (Oracle) len = i_size - folio_pos(folio);
1053c35acef3SMatthew Wilcox (Oracle) folio_zero_segment(folio, len, folio_size(folio));
10541e51764aSArtem Bityutskiy
10551e51764aSArtem Bityutskiy if (i_size > synced_i_size) {
1056a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL);
10571e51764aSArtem Bityutskiy if (err)
1058fb8bc4c7SZhihao Cheng goto out_redirty;
10591e51764aSArtem Bityutskiy }
10601e51764aSArtem Bityutskiy
10610c2d140cSMatthew Wilcox (Oracle) return do_writepage(folio, len);
1062fb8bc4c7SZhihao Cheng out_redirty:
1063fb8bc4c7SZhihao Cheng /*
1064c35acef3SMatthew Wilcox (Oracle) * folio_redirty_for_writepage() won't call ubifs_dirty_inode() because
1065fb8bc4c7SZhihao Cheng * it passes I_DIRTY_PAGES flag while calling __mark_inode_dirty(), so
1066fb8bc4c7SZhihao Cheng * there is no need to do space budget for dirty inode.
1067fb8bc4c7SZhihao Cheng */
1068c35acef3SMatthew Wilcox (Oracle) folio_redirty_for_writepage(wbc, folio);
10691e51764aSArtem Bityutskiy out_unlock:
1070c35acef3SMatthew Wilcox (Oracle) folio_unlock(folio);
10711e51764aSArtem Bityutskiy return err;
10721e51764aSArtem Bityutskiy }
10731e51764aSArtem Bityutskiy
ubifs_writepages(struct address_space * mapping,struct writeback_control * wbc)10740df030d0SMatthew Wilcox (Oracle) static int ubifs_writepages(struct address_space *mapping,
10750df030d0SMatthew Wilcox (Oracle) struct writeback_control *wbc)
10760df030d0SMatthew Wilcox (Oracle) {
10770df030d0SMatthew Wilcox (Oracle) return write_cache_pages(mapping, wbc, ubifs_writepage, NULL);
10780df030d0SMatthew Wilcox (Oracle) }
10790df030d0SMatthew Wilcox (Oracle)
10801e51764aSArtem Bityutskiy /**
10811e51764aSArtem Bityutskiy * do_attr_changes - change inode attributes.
10821e51764aSArtem Bityutskiy * @inode: inode to change attributes for
10831e51764aSArtem Bityutskiy * @attr: describes attributes to change
10841e51764aSArtem Bityutskiy */
do_attr_changes(struct inode * inode,const struct iattr * attr)10851e51764aSArtem Bityutskiy static void do_attr_changes(struct inode *inode, const struct iattr *attr)
10861e51764aSArtem Bityutskiy {
10871e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_UID)
10881e51764aSArtem Bityutskiy inode->i_uid = attr->ia_uid;
10891e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_GID)
10901e51764aSArtem Bityutskiy inode->i_gid = attr->ia_gid;
1091eb31e2f6SAmir Goldstein if (attr->ia_valid & ATTR_ATIME)
1092e4cfef33SJeff Layton inode_set_atime_to_ts(inode, attr->ia_atime);
1093eb31e2f6SAmir Goldstein if (attr->ia_valid & ATTR_MTIME)
1094e4cfef33SJeff Layton inode_set_mtime_to_ts(inode, attr->ia_mtime);
1095eb31e2f6SAmir Goldstein if (attr->ia_valid & ATTR_CTIME)
1096d07d3a7eSJeff Layton inode_set_ctime_to_ts(inode, attr->ia_ctime);
10971e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_MODE) {
10981e51764aSArtem Bityutskiy umode_t mode = attr->ia_mode;
10991e51764aSArtem Bityutskiy
11001e51764aSArtem Bityutskiy if (!in_group_p(inode->i_gid) && !capable(CAP_FSETID))
11011e51764aSArtem Bityutskiy mode &= ~S_ISGID;
11021e51764aSArtem Bityutskiy inode->i_mode = mode;
11031e51764aSArtem Bityutskiy }
11041e51764aSArtem Bityutskiy }
11051e51764aSArtem Bityutskiy
11061e51764aSArtem Bityutskiy /**
11071e51764aSArtem Bityutskiy * do_truncation - truncate an inode.
11081e51764aSArtem Bityutskiy * @c: UBIFS file-system description object
11091e51764aSArtem Bityutskiy * @inode: inode to truncate
11101e51764aSArtem Bityutskiy * @attr: inode attribute changes description
11111e51764aSArtem Bityutskiy *
11121e51764aSArtem Bityutskiy * This function implements VFS '->setattr()' call when the inode is truncated
1113ac8e9f64SRandy Dunlap * to a smaller size.
1114ac8e9f64SRandy Dunlap *
1115ac8e9f64SRandy Dunlap * Returns: %0 in case of success and a negative error code
11161e51764aSArtem Bityutskiy * in case of failure.
11171e51764aSArtem Bityutskiy */
do_truncation(struct ubifs_info * c,struct inode * inode,const struct iattr * attr)11181e51764aSArtem Bityutskiy static int do_truncation(struct ubifs_info *c, struct inode *inode,
11191e51764aSArtem Bityutskiy const struct iattr *attr)
11201e51764aSArtem Bityutskiy {
11211e51764aSArtem Bityutskiy int err;
11221e51764aSArtem Bityutskiy struct ubifs_budget_req req;
11231e51764aSArtem Bityutskiy loff_t old_size = inode->i_size, new_size = attr->ia_size;
112404da11bfSArtem Bityutskiy int offset = new_size & (UBIFS_BLOCK_SIZE - 1), budgeted = 1;
11251e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode);
11261e51764aSArtem Bityutskiy
11271e51764aSArtem Bityutskiy dbg_gen("ino %lu, size %lld -> %lld", inode->i_ino, old_size, new_size);
11281e51764aSArtem Bityutskiy memset(&req, 0, sizeof(struct ubifs_budget_req));
11291e51764aSArtem Bityutskiy
11301e51764aSArtem Bityutskiy /*
11311e51764aSArtem Bityutskiy * If this is truncation to a smaller size, and we do not truncate on a
11321e51764aSArtem Bityutskiy * block boundary, budget for changing one data block, because the last
11331e51764aSArtem Bityutskiy * block will be re-written.
11341e51764aSArtem Bityutskiy */
11351e51764aSArtem Bityutskiy if (new_size & (UBIFS_BLOCK_SIZE - 1))
11361e51764aSArtem Bityutskiy req.dirtied_page = 1;
11371e51764aSArtem Bityutskiy
11381e51764aSArtem Bityutskiy req.dirtied_ino = 1;
11391e51764aSArtem Bityutskiy /* A funny way to budget for truncation node */
11401e51764aSArtem Bityutskiy req.dirtied_ino_d = UBIFS_TRUN_NODE_SZ;
11411e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req);
114204da11bfSArtem Bityutskiy if (err) {
114304da11bfSArtem Bityutskiy /*
114404da11bfSArtem Bityutskiy * Treat truncations to zero as deletion and always allow them,
114504da11bfSArtem Bityutskiy * just like we do for '->unlink()'.
114604da11bfSArtem Bityutskiy */
114704da11bfSArtem Bityutskiy if (new_size || err != -ENOSPC)
11481e51764aSArtem Bityutskiy return err;
114904da11bfSArtem Bityutskiy budgeted = 0;
115004da11bfSArtem Bityutskiy }
11511e51764aSArtem Bityutskiy
11522c27c65eSChristoph Hellwig truncate_setsize(inode, new_size);
11531e51764aSArtem Bityutskiy
11541e51764aSArtem Bityutskiy if (offset) {
115509cbfeafSKirill A. Shutemov pgoff_t index = new_size >> PAGE_SHIFT;
1156783d0741SMatthew Wilcox (Oracle) struct folio *folio;
11571e51764aSArtem Bityutskiy
1158783d0741SMatthew Wilcox (Oracle) folio = filemap_lock_folio(inode->i_mapping, index);
1159783d0741SMatthew Wilcox (Oracle) if (!IS_ERR(folio)) {
1160783d0741SMatthew Wilcox (Oracle) if (folio_test_dirty(folio)) {
11611e51764aSArtem Bityutskiy /*
11621e51764aSArtem Bityutskiy * 'ubifs_jnl_truncate()' will try to truncate
11631e51764aSArtem Bityutskiy * the last data node, but it contains
11641e51764aSArtem Bityutskiy * out-of-date data because the page is dirty.
11651e51764aSArtem Bityutskiy * Write the page now, so that
11661e51764aSArtem Bityutskiy * 'ubifs_jnl_truncate()' will see an already
11671e51764aSArtem Bityutskiy * truncated (and up to date) data node.
11681e51764aSArtem Bityutskiy */
1169783d0741SMatthew Wilcox (Oracle) ubifs_assert(c, folio->private != NULL);
11701e51764aSArtem Bityutskiy
1171783d0741SMatthew Wilcox (Oracle) folio_clear_dirty_for_io(folio);
11721e51764aSArtem Bityutskiy if (UBIFS_BLOCKS_PER_PAGE_SHIFT)
1173783d0741SMatthew Wilcox (Oracle) offset = offset_in_folio(folio,
1174783d0741SMatthew Wilcox (Oracle) new_size);
11750c2d140cSMatthew Wilcox (Oracle) err = do_writepage(folio, offset);
1176783d0741SMatthew Wilcox (Oracle) folio_put(folio);
11771e51764aSArtem Bityutskiy if (err)
11781e51764aSArtem Bityutskiy goto out_budg;
11791e51764aSArtem Bityutskiy /*
11801e51764aSArtem Bityutskiy * We could now tell 'ubifs_jnl_truncate()' not
11811e51764aSArtem Bityutskiy * to read the last block.
11821e51764aSArtem Bityutskiy */
11831e51764aSArtem Bityutskiy } else {
11841e51764aSArtem Bityutskiy /*
11851e51764aSArtem Bityutskiy * We could 'kmap()' the page and pass the data
11861e51764aSArtem Bityutskiy * to 'ubifs_jnl_truncate()' to save it from
11871e51764aSArtem Bityutskiy * having to read it.
11881e51764aSArtem Bityutskiy */
1189783d0741SMatthew Wilcox (Oracle) folio_unlock(folio);
1190783d0741SMatthew Wilcox (Oracle) folio_put(folio);
11911e51764aSArtem Bityutskiy }
11921e51764aSArtem Bityutskiy }
11931e51764aSArtem Bityutskiy }
11941e51764aSArtem Bityutskiy
11951e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex);
11961e51764aSArtem Bityutskiy ui->ui_size = inode->i_size;
11971e51764aSArtem Bityutskiy /* Truncation changes inode [mc]time */
1198e4cfef33SJeff Layton inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
1199873a64c7SArtem Bityutskiy /* Other attributes may be changed at the same time as well */
12001e51764aSArtem Bityutskiy do_attr_changes(inode, attr);
12011e51764aSArtem Bityutskiy err = ubifs_jnl_truncate(c, inode, old_size, new_size);
12021e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex);
1203873a64c7SArtem Bityutskiy
12041e51764aSArtem Bityutskiy out_budg:
120504da11bfSArtem Bityutskiy if (budgeted)
12061e51764aSArtem Bityutskiy ubifs_release_budget(c, &req);
120704da11bfSArtem Bityutskiy else {
1208b137545cSArtem Bityutskiy c->bi.nospace = c->bi.nospace_rp = 0;
120904da11bfSArtem Bityutskiy smp_wmb();
121004da11bfSArtem Bityutskiy }
12111e51764aSArtem Bityutskiy return err;
12121e51764aSArtem Bityutskiy }
12131e51764aSArtem Bityutskiy
12141e51764aSArtem Bityutskiy /**
12151e51764aSArtem Bityutskiy * do_setattr - change inode attributes.
12161e51764aSArtem Bityutskiy * @c: UBIFS file-system description object
12171e51764aSArtem Bityutskiy * @inode: inode to change attributes for
12181e51764aSArtem Bityutskiy * @attr: inode attribute changes description
12191e51764aSArtem Bityutskiy *
12201e51764aSArtem Bityutskiy * This function implements VFS '->setattr()' call for all cases except
1221ac8e9f64SRandy Dunlap * truncations to smaller size.
1222ac8e9f64SRandy Dunlap *
1223ac8e9f64SRandy Dunlap * Returns: %0 in case of success and a negative
12241e51764aSArtem Bityutskiy * error code in case of failure.
12251e51764aSArtem Bityutskiy */
do_setattr(struct ubifs_info * c,struct inode * inode,const struct iattr * attr)12261e51764aSArtem Bityutskiy static int do_setattr(struct ubifs_info *c, struct inode *inode,
12271e51764aSArtem Bityutskiy const struct iattr *attr)
12281e51764aSArtem Bityutskiy {
12291e51764aSArtem Bityutskiy int err, release;
12301e51764aSArtem Bityutskiy loff_t new_size = attr->ia_size;
12311e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode);
12321e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .dirtied_ino = 1,
1233dab4b4d2SArtem Bityutskiy .dirtied_ino_d = ALIGN(ui->data_len, 8) };
12341e51764aSArtem Bityutskiy
12351e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req);
12361e51764aSArtem Bityutskiy if (err)
12371e51764aSArtem Bityutskiy return err;
12381e51764aSArtem Bityutskiy
12391e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_SIZE) {
12401e51764aSArtem Bityutskiy dbg_gen("size %lld -> %lld", inode->i_size, new_size);
12412c27c65eSChristoph Hellwig truncate_setsize(inode, new_size);
12421e51764aSArtem Bityutskiy }
12431e51764aSArtem Bityutskiy
12441e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex);
12451e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_SIZE) {
12461e51764aSArtem Bityutskiy /* Truncation changes inode [mc]time */
1247e4cfef33SJeff Layton inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
12482c27c65eSChristoph Hellwig /* 'truncate_setsize()' changed @i_size, update @ui_size */
12491e51764aSArtem Bityutskiy ui->ui_size = inode->i_size;
12501e51764aSArtem Bityutskiy }
12511e51764aSArtem Bityutskiy
12521e51764aSArtem Bityutskiy do_attr_changes(inode, attr);
12531e51764aSArtem Bityutskiy
12541e51764aSArtem Bityutskiy release = ui->dirty;
12551e51764aSArtem Bityutskiy if (attr->ia_valid & ATTR_SIZE)
12561e51764aSArtem Bityutskiy /*
12571e51764aSArtem Bityutskiy * Inode length changed, so we have to make sure
12581e51764aSArtem Bityutskiy * @I_DIRTY_DATASYNC is set.
12591e51764aSArtem Bityutskiy */
1260f3556254SChristoph Hellwig __mark_inode_dirty(inode, I_DIRTY_DATASYNC);
12611e51764aSArtem Bityutskiy else
12621e51764aSArtem Bityutskiy mark_inode_dirty_sync(inode);
12631e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex);
12641e51764aSArtem Bityutskiy
12651e51764aSArtem Bityutskiy if (release)
12661e51764aSArtem Bityutskiy ubifs_release_budget(c, &req);
12671e51764aSArtem Bityutskiy if (IS_SYNC(inode))
1268a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL);
12691e51764aSArtem Bityutskiy return err;
12701e51764aSArtem Bityutskiy }
12711e51764aSArtem Bityutskiy
ubifs_setattr(struct mnt_idmap * idmap,struct dentry * dentry,struct iattr * attr)1272c1632a0fSChristian Brauner int ubifs_setattr(struct mnt_idmap *idmap, struct dentry *dentry,
1273549c7297SChristian Brauner struct iattr *attr)
12741e51764aSArtem Bityutskiy {
12751e51764aSArtem Bityutskiy int err;
12762b0143b5SDavid Howells struct inode *inode = d_inode(dentry);
12771e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info;
12781e51764aSArtem Bityutskiy
12797d32c2bbSArtem Bityutskiy dbg_gen("ino %lu, mode %#x, ia_valid %#x",
12807d32c2bbSArtem Bityutskiy inode->i_ino, inode->i_mode, attr->ia_valid);
1281c1632a0fSChristian Brauner err = setattr_prepare(&nop_mnt_idmap, dentry, attr);
12821e51764aSArtem Bityutskiy if (err)
12831e51764aSArtem Bityutskiy return err;
12841e51764aSArtem Bityutskiy
1285d808efb4SArtem Bityutskiy err = dbg_check_synced_i_size(c, inode);
12861e51764aSArtem Bityutskiy if (err)
12871e51764aSArtem Bityutskiy return err;
12881e51764aSArtem Bityutskiy
1289252153baSEric Biggers err = fscrypt_prepare_setattr(dentry, attr);
12904afb9996SEric Biggers if (err)
12914afb9996SEric Biggers return err;
12924afb9996SEric Biggers
12931e51764aSArtem Bityutskiy if ((attr->ia_valid & ATTR_SIZE) && attr->ia_size < inode->i_size)
12941e51764aSArtem Bityutskiy /* Truncation to a smaller size */
12951e51764aSArtem Bityutskiy err = do_truncation(c, inode, attr);
12961e51764aSArtem Bityutskiy else
12971e51764aSArtem Bityutskiy err = do_setattr(c, inode, attr);
12981e51764aSArtem Bityutskiy
12991e51764aSArtem Bityutskiy return err;
13001e51764aSArtem Bityutskiy }
13011e51764aSArtem Bityutskiy
ubifs_invalidate_folio(struct folio * folio,size_t offset,size_t length)130258a2fdb6SMatthew Wilcox (Oracle) static void ubifs_invalidate_folio(struct folio *folio, size_t offset,
130358a2fdb6SMatthew Wilcox (Oracle) size_t length)
13041e51764aSArtem Bityutskiy {
130558a2fdb6SMatthew Wilcox (Oracle) struct inode *inode = folio->mapping->host;
13061e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info;
13071e51764aSArtem Bityutskiy
130858a2fdb6SMatthew Wilcox (Oracle) ubifs_assert(c, folio_test_private(folio));
130958a2fdb6SMatthew Wilcox (Oracle) if (offset || length < folio_size(folio))
131058a2fdb6SMatthew Wilcox (Oracle) /* Partial folio remains dirty */
13111e51764aSArtem Bityutskiy return;
13121e51764aSArtem Bityutskiy
131358a2fdb6SMatthew Wilcox (Oracle) if (folio_test_checked(folio))
13141e51764aSArtem Bityutskiy release_new_page_budget(c);
13151e51764aSArtem Bityutskiy else
13161e51764aSArtem Bityutskiy release_existing_page_budget(c);
13171e51764aSArtem Bityutskiy
13181e51764aSArtem Bityutskiy atomic_long_dec(&c->dirty_pg_cnt);
1319a87a08e3SLinus Torvalds folio_detach_private(folio);
132058a2fdb6SMatthew Wilcox (Oracle) folio_clear_checked(folio);
13211e51764aSArtem Bityutskiy }
13221e51764aSArtem Bityutskiy
ubifs_fsync(struct file * file,loff_t start,loff_t end,int datasync)132302c24a82SJosef Bacik int ubifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
13241e51764aSArtem Bityutskiy {
13257ea80859SChristoph Hellwig struct inode *inode = file->f_mapping->host;
13261e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info;
13271e51764aSArtem Bityutskiy int err;
13281e51764aSArtem Bityutskiy
13291e51764aSArtem Bityutskiy dbg_gen("syncing inode %lu", inode->i_ino);
13301e51764aSArtem Bityutskiy
13313b2f9a01SArtem Bityutskiy if (c->ro_mount)
13323b2f9a01SArtem Bityutskiy /*
13333b2f9a01SArtem Bityutskiy * For some really strange reasons VFS does not filter out
13343b2f9a01SArtem Bityutskiy * 'fsync()' for R/O mounted file-systems as per 2.6.39.
13353b2f9a01SArtem Bityutskiy */
133678530bf7SArtem Bityutskiy return 0;
133778530bf7SArtem Bityutskiy
13383b49c9a1SJeff Layton err = file_write_and_wait_range(file, start, end);
133902c24a82SJosef Bacik if (err)
134002c24a82SJosef Bacik return err;
13415955102cSAl Viro inode_lock(inode);
134202c24a82SJosef Bacik
134302c24a82SJosef Bacik /* Synchronize the inode unless this is a 'datasync()' call. */
13441e51764aSArtem Bityutskiy if (!datasync || (inode->i_state & I_DIRTY_DATASYNC)) {
1345a9185b41SChristoph Hellwig err = inode->i_sb->s_op->write_inode(inode, NULL);
13461e51764aSArtem Bityutskiy if (err)
134702c24a82SJosef Bacik goto out;
13481e51764aSArtem Bityutskiy }
13491e51764aSArtem Bityutskiy
13501e51764aSArtem Bityutskiy /*
13511e51764aSArtem Bityutskiy * Nodes related to this inode may still sit in a write-buffer. Flush
13521e51764aSArtem Bityutskiy * them.
13531e51764aSArtem Bityutskiy */
13541e51764aSArtem Bityutskiy err = ubifs_sync_wbufs_by_inode(c, inode);
135502c24a82SJosef Bacik out:
13565955102cSAl Viro inode_unlock(inode);
13571e51764aSArtem Bityutskiy return err;
13581e51764aSArtem Bityutskiy }
13591e51764aSArtem Bityutskiy
13601e51764aSArtem Bityutskiy /**
13611e51764aSArtem Bityutskiy * mctime_update_needed - check if mtime or ctime update is needed.
13621e51764aSArtem Bityutskiy * @inode: the inode to do the check for
13631e51764aSArtem Bityutskiy * @now: current time
13641e51764aSArtem Bityutskiy *
13651e51764aSArtem Bityutskiy * This helper function checks if the inode mtime/ctime should be updated or
13661e51764aSArtem Bityutskiy * not. If current values of the time-stamps are within the UBIFS inode time
13671e51764aSArtem Bityutskiy * granularity, they are not updated. This is an optimization.
1368ac8e9f64SRandy Dunlap *
1369ac8e9f64SRandy Dunlap * Returns: %1 if time update is needed, %0 if not
13701e51764aSArtem Bityutskiy */
mctime_update_needed(const struct inode * inode,const struct timespec64 * now)13711e51764aSArtem Bityutskiy static inline int mctime_update_needed(const struct inode *inode,
13720eca0b80SArnd Bergmann const struct timespec64 *now)
13731e51764aSArtem Bityutskiy {
1374d07d3a7eSJeff Layton struct timespec64 ctime = inode_get_ctime(inode);
1375e4cfef33SJeff Layton struct timespec64 mtime = inode_get_mtime(inode);
1376d07d3a7eSJeff Layton
1377e4cfef33SJeff Layton if (!timespec64_equal(&mtime, now) || !timespec64_equal(&ctime, now))
13781e51764aSArtem Bityutskiy return 1;
13791e51764aSArtem Bityutskiy return 0;
13801e51764aSArtem Bityutskiy }
13811e51764aSArtem Bityutskiy
13828c1c5f26SDongsheng Yang /**
13838c1c5f26SDongsheng Yang * ubifs_update_time - update time of inode.
13848c1c5f26SDongsheng Yang * @inode: inode to update
138548ec6328SYang Li * @flags: time updating control flag determines updating
138648ec6328SYang Li * which time fields of @inode
13878c1c5f26SDongsheng Yang *
13888c1c5f26SDongsheng Yang * This function updates time of the inode.
1389ac8e9f64SRandy Dunlap *
1390ac8e9f64SRandy Dunlap * Returns: %0 for success or a negative error code otherwise.
13918c1c5f26SDongsheng Yang */
ubifs_update_time(struct inode * inode,int flags)1392913e9928SJeff Layton int ubifs_update_time(struct inode *inode, int flags)
13938c1c5f26SDongsheng Yang {
13948c1c5f26SDongsheng Yang struct ubifs_inode *ui = ubifs_inode(inode);
13958c1c5f26SDongsheng Yang struct ubifs_info *c = inode->i_sb->s_fs_info;
13968c1c5f26SDongsheng Yang struct ubifs_budget_req req = { .dirtied_ino = 1,
13978c1c5f26SDongsheng Yang .dirtied_ino_d = ALIGN(ui->data_len, 8) };
13988c1c5f26SDongsheng Yang int err, release;
13998c1c5f26SDongsheng Yang
1400541d4c79SJeff Layton if (!IS_ENABLED(CONFIG_UBIFS_ATIME_SUPPORT)) {
1401541d4c79SJeff Layton generic_update_time(inode, flags);
1402541d4c79SJeff Layton return 0;
1403541d4c79SJeff Layton }
1404e3d73deaSSascha Hauer
14058c1c5f26SDongsheng Yang err = ubifs_budget_space(c, &req);
14068c1c5f26SDongsheng Yang if (err)
14078c1c5f26SDongsheng Yang return err;
14088c1c5f26SDongsheng Yang
14098c1c5f26SDongsheng Yang mutex_lock(&ui->ui_mutex);
141097ebfdb7SJeff Layton inode_update_timestamps(inode, flags);
14118c1c5f26SDongsheng Yang release = ui->dirty;
1412ecf84096SChristoph Hellwig __mark_inode_dirty(inode, I_DIRTY_SYNC);
14138c1c5f26SDongsheng Yang mutex_unlock(&ui->ui_mutex);
14148c1c5f26SDongsheng Yang if (release)
14158c1c5f26SDongsheng Yang ubifs_release_budget(c, &req);
14168c1c5f26SDongsheng Yang return 0;
14178c1c5f26SDongsheng Yang }
14188c1c5f26SDongsheng Yang
14191e51764aSArtem Bityutskiy /**
1420ec037dfcSJulia Lawall * update_mctime - update mtime and ctime of an inode.
14211e51764aSArtem Bityutskiy * @inode: inode to update
14221e51764aSArtem Bityutskiy *
14231e51764aSArtem Bityutskiy * This function updates mtime and ctime of the inode if it is not equivalent to
1424ac8e9f64SRandy Dunlap * current time.
1425ac8e9f64SRandy Dunlap *
1426ac8e9f64SRandy Dunlap * Returns: %0 in case of success and a negative error code in
14271e51764aSArtem Bityutskiy * case of failure.
14281e51764aSArtem Bityutskiy */
update_mctime(struct inode * inode)1429f5674c31SAl Viro static int update_mctime(struct inode *inode)
14301e51764aSArtem Bityutskiy {
14310eca0b80SArnd Bergmann struct timespec64 now = current_time(inode);
14321e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode);
1433f5674c31SAl Viro struct ubifs_info *c = inode->i_sb->s_fs_info;
14341e51764aSArtem Bityutskiy
14351e51764aSArtem Bityutskiy if (mctime_update_needed(inode, &now)) {
14361e51764aSArtem Bityutskiy int err, release;
14371e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .dirtied_ino = 1,
1438dab4b4d2SArtem Bityutskiy .dirtied_ino_d = ALIGN(ui->data_len, 8) };
14391e51764aSArtem Bityutskiy
14401e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req);
14411e51764aSArtem Bityutskiy if (err)
14421e51764aSArtem Bityutskiy return err;
14431e51764aSArtem Bityutskiy
14441e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex);
1445e4cfef33SJeff Layton inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
14461e51764aSArtem Bityutskiy release = ui->dirty;
14471e51764aSArtem Bityutskiy mark_inode_dirty_sync(inode);
14481e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex);
14491e51764aSArtem Bityutskiy if (release)
14501e51764aSArtem Bityutskiy ubifs_release_budget(c, &req);
14511e51764aSArtem Bityutskiy }
14521e51764aSArtem Bityutskiy
14531e51764aSArtem Bityutskiy return 0;
14541e51764aSArtem Bityutskiy }
14551e51764aSArtem Bityutskiy
ubifs_write_iter(struct kiocb * iocb,struct iov_iter * from)1456f5674c31SAl Viro static ssize_t ubifs_write_iter(struct kiocb *iocb, struct iov_iter *from)
14571e51764aSArtem Bityutskiy {
1458f5674c31SAl Viro int err = update_mctime(file_inode(iocb->ki_filp));
14591e51764aSArtem Bityutskiy if (err)
14601e51764aSArtem Bityutskiy return err;
14611e51764aSArtem Bityutskiy
1462f5674c31SAl Viro return generic_file_write_iter(iocb, from);
14631e51764aSArtem Bityutskiy }
14641e51764aSArtem Bityutskiy
ubifs_dirty_folio(struct address_space * mapping,struct folio * folio)14651f1d14dbSMatthew Wilcox (Oracle) static bool ubifs_dirty_folio(struct address_space *mapping,
14661f1d14dbSMatthew Wilcox (Oracle) struct folio *folio)
14671e51764aSArtem Bityutskiy {
14681f1d14dbSMatthew Wilcox (Oracle) bool ret;
14691f1d14dbSMatthew Wilcox (Oracle) struct ubifs_info *c = mapping->host->i_sb->s_fs_info;
14701e51764aSArtem Bityutskiy
14711f1d14dbSMatthew Wilcox (Oracle) ret = filemap_dirty_folio(mapping, folio);
14721e51764aSArtem Bityutskiy /*
14731e51764aSArtem Bityutskiy * An attempt to dirty a page without budgeting for it - should not
14741e51764aSArtem Bityutskiy * happen.
14751e51764aSArtem Bityutskiy */
14761f1d14dbSMatthew Wilcox (Oracle) ubifs_assert(c, ret == false);
14771e51764aSArtem Bityutskiy return ret;
14781e51764aSArtem Bityutskiy }
14791e51764aSArtem Bityutskiy
ubifs_release_folio(struct folio * folio,gfp_t unused_gfp_flags)1480bcaabc55SMatthew Wilcox (Oracle) static bool ubifs_release_folio(struct folio *folio, gfp_t unused_gfp_flags)
14811e51764aSArtem Bityutskiy {
1482bcaabc55SMatthew Wilcox (Oracle) struct inode *inode = folio->mapping->host;
14836eb61d58SRichard Weinberger struct ubifs_info *c = inode->i_sb->s_fs_info;
14846eb61d58SRichard Weinberger
1485bcaabc55SMatthew Wilcox (Oracle) if (folio_test_writeback(folio))
1486bcaabc55SMatthew Wilcox (Oracle) return false;
148766f4742eSZhihao Cheng
148866f4742eSZhihao Cheng /*
148966f4742eSZhihao Cheng * Page is private but not dirty, weird? There is one condition
149066f4742eSZhihao Cheng * making it happened. ubifs_writepage skipped the page because
149166f4742eSZhihao Cheng * page index beyonds isize (for example. truncated by other
149266f4742eSZhihao Cheng * process named A), then the page is invalidated by fadvise64
149366f4742eSZhihao Cheng * syscall before being truncated by process A.
149466f4742eSZhihao Cheng */
1495bcaabc55SMatthew Wilcox (Oracle) ubifs_assert(c, folio_test_private(folio));
149666f4742eSZhihao Cheng if (folio_test_checked(folio))
149766f4742eSZhihao Cheng release_new_page_budget(c);
149866f4742eSZhihao Cheng else
149966f4742eSZhihao Cheng release_existing_page_budget(c);
150066f4742eSZhihao Cheng
150166f4742eSZhihao Cheng atomic_long_dec(&c->dirty_pg_cnt);
1502bcaabc55SMatthew Wilcox (Oracle) folio_detach_private(folio);
1503bcaabc55SMatthew Wilcox (Oracle) folio_clear_checked(folio);
1504bcaabc55SMatthew Wilcox (Oracle) return true;
15051e51764aSArtem Bityutskiy }
15061e51764aSArtem Bityutskiy
15071e51764aSArtem Bityutskiy /*
1508c4361570SArtem Bityutskiy * mmap()d file has taken write protection fault and is being made writable.
1509c4361570SArtem Bityutskiy * UBIFS must ensure page is budgeted for.
15101e51764aSArtem Bityutskiy */
ubifs_vm_page_mkwrite(struct vm_fault * vmf)151131c49eacSSouptick Joarder static vm_fault_t ubifs_vm_page_mkwrite(struct vm_fault *vmf)
15121e51764aSArtem Bityutskiy {
151385ffbf55SMatthew Wilcox (Oracle) struct folio *folio = page_folio(vmf->page);
151411bac800SDave Jiang struct inode *inode = file_inode(vmf->vma->vm_file);
15151e51764aSArtem Bityutskiy struct ubifs_info *c = inode->i_sb->s_fs_info;
15160eca0b80SArnd Bergmann struct timespec64 now = current_time(inode);
15171e51764aSArtem Bityutskiy struct ubifs_budget_req req = { .new_page = 1 };
15181e51764aSArtem Bityutskiy int err, update_time;
15191e51764aSArtem Bityutskiy
152085ffbf55SMatthew Wilcox (Oracle) dbg_gen("ino %lu, pg %lu, i_size %lld", inode->i_ino, folio->index,
15211e51764aSArtem Bityutskiy i_size_read(inode));
15226eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount);
15231e51764aSArtem Bityutskiy
15242680d722SArtem Bityutskiy if (unlikely(c->ro_error))
1525c2ec175cSNick Piggin return VM_FAULT_SIGBUS; /* -EROFS */
15261e51764aSArtem Bityutskiy
15271e51764aSArtem Bityutskiy /*
152885ffbf55SMatthew Wilcox (Oracle) * We have not locked @folio so far so we may budget for changing the
152985ffbf55SMatthew Wilcox (Oracle) * folio. Note, we cannot do this after we locked the folio, because
15301e51764aSArtem Bityutskiy * budgeting may cause write-back which would cause deadlock.
15311e51764aSArtem Bityutskiy *
153285ffbf55SMatthew Wilcox (Oracle) * At the moment we do not know whether the folio is dirty or not, so we
153385ffbf55SMatthew Wilcox (Oracle) * assume that it is not and budget for a new folio. We could look at
15341e51764aSArtem Bityutskiy * the @PG_private flag and figure this out, but we may race with write
153585ffbf55SMatthew Wilcox (Oracle) * back and the folio state may change by the time we lock it, so this
15361e51764aSArtem Bityutskiy * would need additional care. We do not bother with this at the
15371e51764aSArtem Bityutskiy * moment, although it might be good idea to do. Instead, we allocate
153885ffbf55SMatthew Wilcox (Oracle) * budget for a new folio and amend it later on if the folio was in fact
15391e51764aSArtem Bityutskiy * dirty.
15401e51764aSArtem Bityutskiy *
15411e51764aSArtem Bityutskiy * The budgeting-related logic of this function is similar to what we
15421e51764aSArtem Bityutskiy * do in 'ubifs_write_begin()' and 'ubifs_write_end()'. Glance there
15431e51764aSArtem Bityutskiy * for more comments.
15441e51764aSArtem Bityutskiy */
15451e51764aSArtem Bityutskiy update_time = mctime_update_needed(inode, &now);
15461e51764aSArtem Bityutskiy if (update_time)
15471e51764aSArtem Bityutskiy /*
15481e51764aSArtem Bityutskiy * We have to change inode time stamp which requires extra
15491e51764aSArtem Bityutskiy * budgeting.
15501e51764aSArtem Bityutskiy */
15511e51764aSArtem Bityutskiy req.dirtied_ino = 1;
15521e51764aSArtem Bityutskiy
15531e51764aSArtem Bityutskiy err = ubifs_budget_space(c, &req);
15541e51764aSArtem Bityutskiy if (unlikely(err)) {
15551e51764aSArtem Bityutskiy if (err == -ENOSPC)
1556235c362bSSheng Yong ubifs_warn(c, "out of space for mmapped file (inode number %lu)",
155779fda517SArtem Bityutskiy inode->i_ino);
1558c2ec175cSNick Piggin return VM_FAULT_SIGBUS;
15591e51764aSArtem Bityutskiy }
15601e51764aSArtem Bityutskiy
156185ffbf55SMatthew Wilcox (Oracle) folio_lock(folio);
156285ffbf55SMatthew Wilcox (Oracle) if (unlikely(folio->mapping != inode->i_mapping ||
156385ffbf55SMatthew Wilcox (Oracle) folio_pos(folio) >= i_size_read(inode))) {
156485ffbf55SMatthew Wilcox (Oracle) /* Folio got truncated out from underneath us */
156531c49eacSSouptick Joarder goto sigbus;
15661e51764aSArtem Bityutskiy }
15671e51764aSArtem Bityutskiy
156885ffbf55SMatthew Wilcox (Oracle) if (folio->private)
15691e51764aSArtem Bityutskiy release_new_page_budget(c);
15701e51764aSArtem Bityutskiy else {
157185ffbf55SMatthew Wilcox (Oracle) if (!folio_test_checked(folio))
15721e51764aSArtem Bityutskiy ubifs_convert_page_budget(c);
157385ffbf55SMatthew Wilcox (Oracle) folio_attach_private(folio, (void *)1);
15741e51764aSArtem Bityutskiy atomic_long_inc(&c->dirty_pg_cnt);
157585ffbf55SMatthew Wilcox (Oracle) filemap_dirty_folio(folio->mapping, folio);
15761e51764aSArtem Bityutskiy }
15771e51764aSArtem Bityutskiy
15781e51764aSArtem Bityutskiy if (update_time) {
15791e51764aSArtem Bityutskiy int release;
15801e51764aSArtem Bityutskiy struct ubifs_inode *ui = ubifs_inode(inode);
15811e51764aSArtem Bityutskiy
15821e51764aSArtem Bityutskiy mutex_lock(&ui->ui_mutex);
1583e4cfef33SJeff Layton inode_set_mtime_to_ts(inode, inode_set_ctime_current(inode));
15841e51764aSArtem Bityutskiy release = ui->dirty;
15851e51764aSArtem Bityutskiy mark_inode_dirty_sync(inode);
15861e51764aSArtem Bityutskiy mutex_unlock(&ui->ui_mutex);
15871e51764aSArtem Bityutskiy if (release)
15881e51764aSArtem Bityutskiy ubifs_release_dirty_inode_budget(c, ui);
15891e51764aSArtem Bityutskiy }
15901e51764aSArtem Bityutskiy
159185ffbf55SMatthew Wilcox (Oracle) folio_wait_stable(folio);
1592691a7c6fShujianyang return VM_FAULT_LOCKED;
15931e51764aSArtem Bityutskiy
159431c49eacSSouptick Joarder sigbus:
159585ffbf55SMatthew Wilcox (Oracle) folio_unlock(folio);
15961e51764aSArtem Bityutskiy ubifs_release_budget(c, &req);
159731c49eacSSouptick Joarder return VM_FAULT_SIGBUS;
15981e51764aSArtem Bityutskiy }
15991e51764aSArtem Bityutskiy
1600f0f37e2fSAlexey Dobriyan static const struct vm_operations_struct ubifs_file_vm_ops = {
16011e51764aSArtem Bityutskiy .fault = filemap_fault,
1602f1820361SKirill A. Shutemov .map_pages = filemap_map_pages,
16031e51764aSArtem Bityutskiy .page_mkwrite = ubifs_vm_page_mkwrite,
16041e51764aSArtem Bityutskiy };
16051e51764aSArtem Bityutskiy
ubifs_file_mmap(struct file * file,struct vm_area_struct * vma)16061e51764aSArtem Bityutskiy static int ubifs_file_mmap(struct file *file, struct vm_area_struct *vma)
16071e51764aSArtem Bityutskiy {
16081e51764aSArtem Bityutskiy int err;
16091e51764aSArtem Bityutskiy
16101e51764aSArtem Bityutskiy err = generic_file_mmap(file, vma);
16111e51764aSArtem Bityutskiy if (err)
16121e51764aSArtem Bityutskiy return err;
16131e51764aSArtem Bityutskiy vma->vm_ops = &ubifs_file_vm_ops;
1614e3d73deaSSascha Hauer
1615e3d73deaSSascha Hauer if (IS_ENABLED(CONFIG_UBIFS_ATIME_SUPPORT))
16168c1c5f26SDongsheng Yang file_accessed(file);
1617e3d73deaSSascha Hauer
16181e51764aSArtem Bityutskiy return 0;
16191e51764aSArtem Bityutskiy }
16201e51764aSArtem Bityutskiy
ubifs_get_link(struct dentry * dentry,struct inode * inode,struct delayed_call * done)1621ca7f85beSRichard Weinberger static const char *ubifs_get_link(struct dentry *dentry,
1622ca7f85beSRichard Weinberger struct inode *inode,
1623ca7f85beSRichard Weinberger struct delayed_call *done)
1624ca7f85beSRichard Weinberger {
1625ca7f85beSRichard Weinberger struct ubifs_inode *ui = ubifs_inode(inode);
1626ca7f85beSRichard Weinberger
162781dd76b2SEric Biggers if (!IS_ENCRYPTED(inode))
1628ca7f85beSRichard Weinberger return ui->data;
1629ca7f85beSRichard Weinberger
1630ca7f85beSRichard Weinberger if (!dentry)
1631ca7f85beSRichard Weinberger return ERR_PTR(-ECHILD);
1632ca7f85beSRichard Weinberger
163381dd76b2SEric Biggers return fscrypt_get_symlink(inode, ui->data, ui->data_len, done);
1634ca7f85beSRichard Weinberger }
1635ca7f85beSRichard Weinberger
ubifs_symlink_getattr(struct mnt_idmap * idmap,const struct path * path,struct kstat * stat,u32 request_mask,unsigned int query_flags)1636b74d24f7SChristian Brauner static int ubifs_symlink_getattr(struct mnt_idmap *idmap,
1637064c7349SEric Biggers const struct path *path, struct kstat *stat,
1638064c7349SEric Biggers u32 request_mask, unsigned int query_flags)
1639064c7349SEric Biggers {
1640b74d24f7SChristian Brauner ubifs_getattr(idmap, path, stat, request_mask, query_flags);
1641064c7349SEric Biggers
1642064c7349SEric Biggers if (IS_ENCRYPTED(d_inode(path->dentry)))
1643064c7349SEric Biggers return fscrypt_symlink_getattr(path, stat);
1644064c7349SEric Biggers return 0;
1645064c7349SEric Biggers }
1646064c7349SEric Biggers
1647e8b81566SArtem Bityutskiy const struct address_space_operations ubifs_file_address_operations = {
16480b7bf483SMatthew Wilcox (Oracle) .read_folio = ubifs_read_folio,
16490df030d0SMatthew Wilcox (Oracle) .writepages = ubifs_writepages,
16501e51764aSArtem Bityutskiy .write_begin = ubifs_write_begin,
16511e51764aSArtem Bityutskiy .write_end = ubifs_write_end,
165258a2fdb6SMatthew Wilcox (Oracle) .invalidate_folio = ubifs_invalidate_folio,
16531f1d14dbSMatthew Wilcox (Oracle) .dirty_folio = ubifs_dirty_folio,
1654e7b15baeSMatthew Wilcox (Oracle) .migrate_folio = filemap_migrate_folio,
1655bcaabc55SMatthew Wilcox (Oracle) .release_folio = ubifs_release_folio,
16561e51764aSArtem Bityutskiy };
16571e51764aSArtem Bityutskiy
1658e8b81566SArtem Bityutskiy const struct inode_operations ubifs_file_inode_operations = {
16591e51764aSArtem Bityutskiy .setattr = ubifs_setattr,
16601e51764aSArtem Bityutskiy .getattr = ubifs_getattr,
16611e51764aSArtem Bityutskiy .listxattr = ubifs_listxattr,
16628c1c5f26SDongsheng Yang .update_time = ubifs_update_time,
16638871d84cSMiklos Szeredi .fileattr_get = ubifs_fileattr_get,
16648871d84cSMiklos Szeredi .fileattr_set = ubifs_fileattr_set,
16651e51764aSArtem Bityutskiy };
16661e51764aSArtem Bityutskiy
1667e8b81566SArtem Bityutskiy const struct inode_operations ubifs_symlink_inode_operations = {
1668ca7f85beSRichard Weinberger .get_link = ubifs_get_link,
16691e51764aSArtem Bityutskiy .setattr = ubifs_setattr,
1670064c7349SEric Biggers .getattr = ubifs_symlink_getattr,
1671895d9db2SSubodh Nijsure .listxattr = ubifs_listxattr,
16728c1c5f26SDongsheng Yang .update_time = ubifs_update_time,
16731e51764aSArtem Bityutskiy };
16741e51764aSArtem Bityutskiy
1675e8b81566SArtem Bityutskiy const struct file_operations ubifs_file_operations = {
16761e51764aSArtem Bityutskiy .llseek = generic_file_llseek,
1677aad4f8bbSAl Viro .read_iter = generic_file_read_iter,
1678f5674c31SAl Viro .write_iter = ubifs_write_iter,
16791e51764aSArtem Bityutskiy .mmap = ubifs_file_mmap,
16801e51764aSArtem Bityutskiy .fsync = ubifs_fsync,
16811e51764aSArtem Bityutskiy .unlocked_ioctl = ubifs_ioctl,
16822cb1e089SDavid Howells .splice_read = filemap_splice_read,
16838d020765SAl Viro .splice_write = iter_file_splice_write,
16847e35c4daSEric Biggers .open = fscrypt_file_open,
16851e51764aSArtem Bityutskiy #ifdef CONFIG_COMPAT
16861e51764aSArtem Bityutskiy .compat_ioctl = ubifs_compat_ioctl,
16871e51764aSArtem Bityutskiy #endif
16881e51764aSArtem Bityutskiy };
1689