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 * Copyright (C) 2006, 2007 University of Szeged, Hungary 71e51764aSArtem Bityutskiy * 81e51764aSArtem Bityutskiy * Authors: Artem Bityutskiy (Битюцкий Артём) 91e51764aSArtem Bityutskiy * Adrian Hunter 101e51764aSArtem Bityutskiy * Zoltan Sogor 111e51764aSArtem Bityutskiy */ 121e51764aSArtem Bityutskiy 131e51764aSArtem Bityutskiy /* 141e51764aSArtem Bityutskiy * This file implements UBIFS I/O subsystem which provides various I/O-related 151e51764aSArtem Bityutskiy * helper functions (reading/writing/checking/validating nodes) and implements 161e51764aSArtem Bityutskiy * write-buffering support. Write buffers help to save space which otherwise 171e51764aSArtem Bityutskiy * would have been wasted for padding to the nearest minimal I/O unit boundary. 181e51764aSArtem Bityutskiy * Instead, data first goes to the write-buffer and is flushed when the 191e51764aSArtem Bityutskiy * buffer is full or when it is not used for some time (by timer). This is 201e51764aSArtem Bityutskiy * similar to the mechanism is used by JFFS2. 211e51764aSArtem Bityutskiy * 226c7f74f7SArtem Bityutskiy * UBIFS distinguishes between minimum write size (@c->min_io_size) and maximum 236c7f74f7SArtem Bityutskiy * write size (@c->max_write_size). The latter is the maximum amount of bytes 246c7f74f7SArtem Bityutskiy * the underlying flash is able to program at a time, and writing in 256c7f74f7SArtem Bityutskiy * @c->max_write_size units should presumably be faster. Obviously, 266c7f74f7SArtem Bityutskiy * @c->min_io_size <= @c->max_write_size. Write-buffers are of 276c7f74f7SArtem Bityutskiy * @c->max_write_size bytes in size for maximum performance. However, when a 286c7f74f7SArtem Bityutskiy * write-buffer is flushed, only the portion of it (aligned to @c->min_io_size 296c7f74f7SArtem Bityutskiy * boundary) which contains data is written, not the whole write-buffer, 306c7f74f7SArtem Bityutskiy * because this is more space-efficient. 316c7f74f7SArtem Bityutskiy * 326c7f74f7SArtem Bityutskiy * This optimization adds few complications to the code. Indeed, on the one 336c7f74f7SArtem Bityutskiy * hand, we want to write in optimal @c->max_write_size bytes chunks, which 346c7f74f7SArtem Bityutskiy * also means aligning writes at the @c->max_write_size bytes offsets. On the 356c7f74f7SArtem Bityutskiy * other hand, we do not want to waste space when synchronizing the write 366c7f74f7SArtem Bityutskiy * buffer, so during synchronization we writes in smaller chunks. And this makes 376c7f74f7SArtem Bityutskiy * the next write offset to be not aligned to @c->max_write_size bytes. So the 386c7f74f7SArtem Bityutskiy * have to make sure that the write-buffer offset (@wbuf->offs) becomes aligned 396c7f74f7SArtem Bityutskiy * to @c->max_write_size bytes again. We do this by temporarily shrinking 406c7f74f7SArtem Bityutskiy * write-buffer size (@wbuf->size). 416c7f74f7SArtem Bityutskiy * 421e51764aSArtem Bityutskiy * Write-buffers are defined by 'struct ubifs_wbuf' objects and protected by 431e51764aSArtem Bityutskiy * mutexes defined inside these objects. Since sometimes upper-level code 441e51764aSArtem Bityutskiy * has to lock the write-buffer (e.g. journal space reservation code), many 451e51764aSArtem Bityutskiy * functions related to write-buffers have "nolock" suffix which means that the 461e51764aSArtem Bityutskiy * caller has to lock the write-buffer before calling this function. 471e51764aSArtem Bityutskiy * 481e51764aSArtem Bityutskiy * UBIFS stores nodes at 64 bit-aligned addresses. If the node length is not 491e51764aSArtem Bityutskiy * aligned, UBIFS starts the next node from the aligned address, and the padded 501e51764aSArtem Bityutskiy * bytes may contain any rubbish. In other words, UBIFS does not put padding 511e51764aSArtem Bityutskiy * bytes in those small gaps. Common headers of nodes store real node lengths, 521e51764aSArtem Bityutskiy * not aligned lengths. Indexing nodes also store real lengths in branches. 531e51764aSArtem Bityutskiy * 541e51764aSArtem Bityutskiy * UBIFS uses padding when it pads to the next min. I/O unit. In this case it 551e51764aSArtem Bityutskiy * uses padding nodes or padding bytes, if the padding node does not fit. 561e51764aSArtem Bityutskiy * 576c7f74f7SArtem Bityutskiy * All UBIFS nodes are protected by CRC checksums and UBIFS checks CRC when 586c7f74f7SArtem Bityutskiy * they are read from the flash media. 591e51764aSArtem Bityutskiy */ 601e51764aSArtem Bityutskiy 611e51764aSArtem Bityutskiy #include <linux/crc32.h> 625a0e3ad6STejun Heo #include <linux/slab.h> 631e51764aSArtem Bityutskiy #include "ubifs.h" 641e51764aSArtem Bityutskiy 651e51764aSArtem Bityutskiy /** 66ff46d7b3SAdrian Hunter * ubifs_ro_mode - switch UBIFS to read read-only mode. 67ff46d7b3SAdrian Hunter * @c: UBIFS file-system description object 68ff46d7b3SAdrian Hunter * @err: error code which is the reason of switching to R/O mode 69ff46d7b3SAdrian Hunter */ 70ff46d7b3SAdrian Hunter void ubifs_ro_mode(struct ubifs_info *c, int err) 71ff46d7b3SAdrian Hunter { 722680d722SArtem Bityutskiy if (!c->ro_error) { 732680d722SArtem Bityutskiy c->ro_error = 1; 74ccb3eba7SArtem Bityutskiy c->no_chk_data_crc = 0; 751751e8a6SLinus Torvalds c->vfs_sb->s_flags |= SB_RDONLY; 76235c362bSSheng Yong ubifs_warn(c, "switched to read-only mode, error %d", err); 77d033c98bSArtem Bityutskiy dump_stack(); 78ff46d7b3SAdrian Hunter } 79ff46d7b3SAdrian Hunter } 80ff46d7b3SAdrian Hunter 8183cef708SArtem Bityutskiy /* 8283cef708SArtem Bityutskiy * Below are simple wrappers over UBI I/O functions which include some 8383cef708SArtem Bityutskiy * additional checks and UBIFS debugging stuff. See corresponding UBI function 8483cef708SArtem Bityutskiy * for more information. 8583cef708SArtem Bityutskiy */ 8683cef708SArtem Bityutskiy 8783cef708SArtem Bityutskiy int ubifs_leb_read(const struct ubifs_info *c, int lnum, void *buf, int offs, 8883cef708SArtem Bityutskiy int len, int even_ebadmsg) 8983cef708SArtem Bityutskiy { 9083cef708SArtem Bityutskiy int err; 9183cef708SArtem Bityutskiy 9283cef708SArtem Bityutskiy err = ubi_read(c->ubi, lnum, buf, offs, len); 9383cef708SArtem Bityutskiy /* 9483cef708SArtem Bityutskiy * In case of %-EBADMSG print the error message only if the 9583cef708SArtem Bityutskiy * @even_ebadmsg is true. 9683cef708SArtem Bityutskiy */ 9783cef708SArtem Bityutskiy if (err && (err != -EBADMSG || even_ebadmsg)) { 98235c362bSSheng Yong ubifs_err(c, "reading %d bytes from LEB %d:%d failed, error %d", 9983cef708SArtem Bityutskiy len, lnum, offs, err); 1007c46d0aeSArtem Bityutskiy dump_stack(); 10183cef708SArtem Bityutskiy } 10283cef708SArtem Bityutskiy return err; 10383cef708SArtem Bityutskiy } 10483cef708SArtem Bityutskiy 10583cef708SArtem Bityutskiy int ubifs_leb_write(struct ubifs_info *c, int lnum, const void *buf, int offs, 106b36a261eSRichard Weinberger int len) 10783cef708SArtem Bityutskiy { 10883cef708SArtem Bityutskiy int err; 10983cef708SArtem Bityutskiy 1106eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount); 11183cef708SArtem Bityutskiy if (c->ro_error) 11283cef708SArtem Bityutskiy return -EROFS; 11383cef708SArtem Bityutskiy if (!dbg_is_tst_rcvry(c)) 114b36a261eSRichard Weinberger err = ubi_leb_write(c->ubi, lnum, buf, offs, len); 11583cef708SArtem Bityutskiy else 116b36a261eSRichard Weinberger err = dbg_leb_write(c, lnum, buf, offs, len); 11783cef708SArtem Bityutskiy if (err) { 118235c362bSSheng Yong ubifs_err(c, "writing %d bytes to LEB %d:%d failed, error %d", 11983cef708SArtem Bityutskiy len, lnum, offs, err); 12083cef708SArtem Bityutskiy ubifs_ro_mode(c, err); 1217c46d0aeSArtem Bityutskiy dump_stack(); 12283cef708SArtem Bityutskiy } 12383cef708SArtem Bityutskiy return err; 12483cef708SArtem Bityutskiy } 12583cef708SArtem Bityutskiy 126b36a261eSRichard Weinberger int ubifs_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len) 12783cef708SArtem Bityutskiy { 12883cef708SArtem Bityutskiy int err; 12983cef708SArtem Bityutskiy 1306eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount); 13183cef708SArtem Bityutskiy if (c->ro_error) 13283cef708SArtem Bityutskiy return -EROFS; 13383cef708SArtem Bityutskiy if (!dbg_is_tst_rcvry(c)) 134b36a261eSRichard Weinberger err = ubi_leb_change(c->ubi, lnum, buf, len); 13583cef708SArtem Bityutskiy else 136b36a261eSRichard Weinberger err = dbg_leb_change(c, lnum, buf, len); 13783cef708SArtem Bityutskiy if (err) { 138235c362bSSheng Yong ubifs_err(c, "changing %d bytes in LEB %d failed, error %d", 13983cef708SArtem Bityutskiy len, lnum, err); 14083cef708SArtem Bityutskiy ubifs_ro_mode(c, err); 1417c46d0aeSArtem Bityutskiy dump_stack(); 14283cef708SArtem Bityutskiy } 14383cef708SArtem Bityutskiy return err; 14483cef708SArtem Bityutskiy } 14583cef708SArtem Bityutskiy 14683cef708SArtem Bityutskiy int ubifs_leb_unmap(struct ubifs_info *c, int lnum) 14783cef708SArtem Bityutskiy { 14883cef708SArtem Bityutskiy int err; 14983cef708SArtem Bityutskiy 1506eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount); 15183cef708SArtem Bityutskiy if (c->ro_error) 15283cef708SArtem Bityutskiy return -EROFS; 15383cef708SArtem Bityutskiy if (!dbg_is_tst_rcvry(c)) 15483cef708SArtem Bityutskiy err = ubi_leb_unmap(c->ubi, lnum); 15583cef708SArtem Bityutskiy else 156f57cb188SArtem Bityutskiy err = dbg_leb_unmap(c, lnum); 15783cef708SArtem Bityutskiy if (err) { 158235c362bSSheng Yong ubifs_err(c, "unmap LEB %d failed, error %d", lnum, err); 15983cef708SArtem Bityutskiy ubifs_ro_mode(c, err); 1607c46d0aeSArtem Bityutskiy dump_stack(); 16183cef708SArtem Bityutskiy } 16283cef708SArtem Bityutskiy return err; 16383cef708SArtem Bityutskiy } 16483cef708SArtem Bityutskiy 165b36a261eSRichard Weinberger int ubifs_leb_map(struct ubifs_info *c, int lnum) 16683cef708SArtem Bityutskiy { 16783cef708SArtem Bityutskiy int err; 16883cef708SArtem Bityutskiy 1696eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount); 17083cef708SArtem Bityutskiy if (c->ro_error) 17183cef708SArtem Bityutskiy return -EROFS; 17283cef708SArtem Bityutskiy if (!dbg_is_tst_rcvry(c)) 173b36a261eSRichard Weinberger err = ubi_leb_map(c->ubi, lnum); 17483cef708SArtem Bityutskiy else 175b36a261eSRichard Weinberger err = dbg_leb_map(c, lnum); 17683cef708SArtem Bityutskiy if (err) { 177235c362bSSheng Yong ubifs_err(c, "mapping LEB %d failed, error %d", lnum, err); 17883cef708SArtem Bityutskiy ubifs_ro_mode(c, err); 1797c46d0aeSArtem Bityutskiy dump_stack(); 18083cef708SArtem Bityutskiy } 18183cef708SArtem Bityutskiy return err; 18283cef708SArtem Bityutskiy } 18383cef708SArtem Bityutskiy 18483cef708SArtem Bityutskiy int ubifs_is_mapped(const struct ubifs_info *c, int lnum) 18583cef708SArtem Bityutskiy { 18683cef708SArtem Bityutskiy int err; 18783cef708SArtem Bityutskiy 18883cef708SArtem Bityutskiy err = ubi_is_mapped(c->ubi, lnum); 18983cef708SArtem Bityutskiy if (err < 0) { 190235c362bSSheng Yong ubifs_err(c, "ubi_is_mapped failed for LEB %d, error %d", 19183cef708SArtem Bityutskiy lnum, err); 1927c46d0aeSArtem Bityutskiy dump_stack(); 19383cef708SArtem Bityutskiy } 19483cef708SArtem Bityutskiy return err; 19583cef708SArtem Bityutskiy } 19683cef708SArtem Bityutskiy 197ff46d7b3SAdrian Hunter /** 1981e51764aSArtem Bityutskiy * ubifs_check_node - check node. 1991e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 2001e51764aSArtem Bityutskiy * @buf: node to check 2011e51764aSArtem Bityutskiy * @lnum: logical eraseblock number 2021e51764aSArtem Bityutskiy * @offs: offset within the logical eraseblock 2031e51764aSArtem Bityutskiy * @quiet: print no messages 2046f7ab6d4SArtem Bityutskiy * @must_chk_crc: indicates whether to always check the CRC 2051e51764aSArtem Bityutskiy * 2061e51764aSArtem Bityutskiy * This function checks node magic number and CRC checksum. This function also 2071e51764aSArtem Bityutskiy * validates node length to prevent UBIFS from becoming crazy when an attacker 2081e51764aSArtem Bityutskiy * feeds it a file-system image with incorrect nodes. For example, too large 2091e51764aSArtem Bityutskiy * node length in the common header could cause UBIFS to read memory outside of 2101e51764aSArtem Bityutskiy * allocated buffer when checking the CRC checksum. 2111e51764aSArtem Bityutskiy * 2126f7ab6d4SArtem Bityutskiy * This function may skip data nodes CRC checking if @c->no_chk_data_crc is 2136f7ab6d4SArtem Bityutskiy * true, which is controlled by corresponding UBIFS mount option. However, if 2146f7ab6d4SArtem Bityutskiy * @must_chk_crc is true, then @c->no_chk_data_crc is ignored and CRC is 21518d1d7fbSArtem Bityutskiy * checked. Similarly, if @c->mounting or @c->remounting_rw is true (we are 21618d1d7fbSArtem Bityutskiy * mounting or re-mounting to R/W mode), @c->no_chk_data_crc is ignored and CRC 21718d1d7fbSArtem Bityutskiy * is checked. This is because during mounting or re-mounting from R/O mode to 21818d1d7fbSArtem Bityutskiy * R/W mode we may read journal nodes (when replying the journal or doing the 21918d1d7fbSArtem Bityutskiy * recovery) and the journal nodes may potentially be corrupted, so checking is 22018d1d7fbSArtem Bityutskiy * required. 2216f7ab6d4SArtem Bityutskiy * 2226f7ab6d4SArtem Bityutskiy * This function returns zero in case of success and %-EUCLEAN in case of bad 2236f7ab6d4SArtem Bityutskiy * CRC or magic. 2241e51764aSArtem Bityutskiy */ 2251e51764aSArtem Bityutskiy int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum, 2266f7ab6d4SArtem Bityutskiy int offs, int quiet, int must_chk_crc) 2271e51764aSArtem Bityutskiy { 228acc5af3eSLiu Song int err = -EINVAL, type, node_len, dump_node = 1; 2291e51764aSArtem Bityutskiy uint32_t crc, node_crc, magic; 2301e51764aSArtem Bityutskiy const struct ubifs_ch *ch = buf; 2311e51764aSArtem Bityutskiy 2326eb61d58SRichard Weinberger ubifs_assert(c, lnum >= 0 && lnum < c->leb_cnt && offs >= 0); 2336eb61d58SRichard Weinberger ubifs_assert(c, !(offs & 7) && offs < c->leb_size); 2341e51764aSArtem Bityutskiy 2351e51764aSArtem Bityutskiy magic = le32_to_cpu(ch->magic); 2361e51764aSArtem Bityutskiy if (magic != UBIFS_NODE_MAGIC) { 2371e51764aSArtem Bityutskiy if (!quiet) 238235c362bSSheng Yong ubifs_err(c, "bad magic %#08x, expected %#08x", 2391e51764aSArtem Bityutskiy magic, UBIFS_NODE_MAGIC); 2401e51764aSArtem Bityutskiy err = -EUCLEAN; 2411e51764aSArtem Bityutskiy goto out; 2421e51764aSArtem Bityutskiy } 2431e51764aSArtem Bityutskiy 2441e51764aSArtem Bityutskiy type = ch->node_type; 2451e51764aSArtem Bityutskiy if (type < 0 || type >= UBIFS_NODE_TYPES_CNT) { 2461e51764aSArtem Bityutskiy if (!quiet) 247235c362bSSheng Yong ubifs_err(c, "bad node type %d", type); 2481e51764aSArtem Bityutskiy goto out; 2491e51764aSArtem Bityutskiy } 2501e51764aSArtem Bityutskiy 2511e51764aSArtem Bityutskiy node_len = le32_to_cpu(ch->len); 2521e51764aSArtem Bityutskiy if (node_len + offs > c->leb_size) 2531e51764aSArtem Bityutskiy goto out_len; 2541e51764aSArtem Bityutskiy 2551e51764aSArtem Bityutskiy if (c->ranges[type].max_len == 0) { 2561e51764aSArtem Bityutskiy if (node_len != c->ranges[type].len) 2571e51764aSArtem Bityutskiy goto out_len; 2581e51764aSArtem Bityutskiy } else if (node_len < c->ranges[type].min_len || 2591e51764aSArtem Bityutskiy node_len > c->ranges[type].max_len) 2601e51764aSArtem Bityutskiy goto out_len; 2611e51764aSArtem Bityutskiy 26218d1d7fbSArtem Bityutskiy if (!must_chk_crc && type == UBIFS_DATA_NODE && !c->mounting && 26318d1d7fbSArtem Bityutskiy !c->remounting_rw && c->no_chk_data_crc) 2642953e73fSAdrian Hunter return 0; 2652953e73fSAdrian Hunter 2661e51764aSArtem Bityutskiy crc = crc32(UBIFS_CRC32_INIT, buf + 8, node_len - 8); 2671e51764aSArtem Bityutskiy node_crc = le32_to_cpu(ch->crc); 2681e51764aSArtem Bityutskiy if (crc != node_crc) { 2691e51764aSArtem Bityutskiy if (!quiet) 270235c362bSSheng Yong ubifs_err(c, "bad CRC: calculated %#08x, read %#08x", 2711e51764aSArtem Bityutskiy crc, node_crc); 2721e51764aSArtem Bityutskiy err = -EUCLEAN; 2731e51764aSArtem Bityutskiy goto out; 2741e51764aSArtem Bityutskiy } 2751e51764aSArtem Bityutskiy 2761e51764aSArtem Bityutskiy return 0; 2771e51764aSArtem Bityutskiy 2781e51764aSArtem Bityutskiy out_len: 2791e51764aSArtem Bityutskiy if (!quiet) 280235c362bSSheng Yong ubifs_err(c, "bad node length %d", node_len); 281acc5af3eSLiu Song if (type == UBIFS_DATA_NODE && node_len > UBIFS_DATA_NODE_SZ) 282acc5af3eSLiu Song dump_node = 0; 2831e51764aSArtem Bityutskiy out: 2841e51764aSArtem Bityutskiy if (!quiet) { 285235c362bSSheng Yong ubifs_err(c, "bad node at LEB %d:%d", lnum, offs); 286acc5af3eSLiu Song if (dump_node) { 287edf6be24SArtem Bityutskiy ubifs_dump_node(c, buf); 288acc5af3eSLiu Song } else { 289acc5af3eSLiu Song int safe_len = min3(node_len, c->leb_size - offs, 290acc5af3eSLiu Song (int)UBIFS_MAX_DATA_NODE_SZ); 291acc5af3eSLiu Song pr_err("\tprevent out-of-bounds memory access\n"); 292acc5af3eSLiu Song pr_err("\ttruncated data node length %d\n", safe_len); 293acc5af3eSLiu Song pr_err("\tcorrupted data node:\n"); 294acc5af3eSLiu Song print_hex_dump(KERN_ERR, "\t", DUMP_PREFIX_OFFSET, 32, 1, 295acc5af3eSLiu Song buf, safe_len, 0); 296acc5af3eSLiu Song } 2977c46d0aeSArtem Bityutskiy dump_stack(); 2981e51764aSArtem Bityutskiy } 2991e51764aSArtem Bityutskiy return err; 3001e51764aSArtem Bityutskiy } 3011e51764aSArtem Bityutskiy 3021e51764aSArtem Bityutskiy /** 3031e51764aSArtem Bityutskiy * ubifs_pad - pad flash space. 3041e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 3051e51764aSArtem Bityutskiy * @buf: buffer to put padding to 3061e51764aSArtem Bityutskiy * @pad: how many bytes to pad 3071e51764aSArtem Bityutskiy * 3081e51764aSArtem Bityutskiy * The flash media obliges us to write only in chunks of %c->min_io_size and 3091e51764aSArtem Bityutskiy * when we have to write less data we add padding node to the write-buffer and 3101e51764aSArtem Bityutskiy * pad it to the next minimal I/O unit's boundary. Padding nodes help when the 3111e51764aSArtem Bityutskiy * media is being scanned. If the amount of wasted space is not enough to fit a 3121e51764aSArtem Bityutskiy * padding node which takes %UBIFS_PAD_NODE_SZ bytes, we write padding bytes 3131e51764aSArtem Bityutskiy * pattern (%UBIFS_PADDING_BYTE). 3141e51764aSArtem Bityutskiy * 3151e51764aSArtem Bityutskiy * Padding nodes are also used to fill gaps when the "commit-in-gaps" method is 3161e51764aSArtem Bityutskiy * used. 3171e51764aSArtem Bityutskiy */ 3181e51764aSArtem Bityutskiy void ubifs_pad(const struct ubifs_info *c, void *buf, int pad) 3191e51764aSArtem Bityutskiy { 3201e51764aSArtem Bityutskiy uint32_t crc; 3211e51764aSArtem Bityutskiy 322*20f14311SRichard Weinberger ubifs_assert(c, pad >= 0); 3231e51764aSArtem Bityutskiy 3241e51764aSArtem Bityutskiy if (pad >= UBIFS_PAD_NODE_SZ) { 3251e51764aSArtem Bityutskiy struct ubifs_ch *ch = buf; 3261e51764aSArtem Bityutskiy struct ubifs_pad_node *pad_node = buf; 3271e51764aSArtem Bityutskiy 3281e51764aSArtem Bityutskiy ch->magic = cpu_to_le32(UBIFS_NODE_MAGIC); 3291e51764aSArtem Bityutskiy ch->node_type = UBIFS_PAD_NODE; 3301e51764aSArtem Bityutskiy ch->group_type = UBIFS_NO_NODE_GROUP; 3311e51764aSArtem Bityutskiy ch->padding[0] = ch->padding[1] = 0; 3321e51764aSArtem Bityutskiy ch->sqnum = 0; 3331e51764aSArtem Bityutskiy ch->len = cpu_to_le32(UBIFS_PAD_NODE_SZ); 3341e51764aSArtem Bityutskiy pad -= UBIFS_PAD_NODE_SZ; 3351e51764aSArtem Bityutskiy pad_node->pad_len = cpu_to_le32(pad); 3361e51764aSArtem Bityutskiy crc = crc32(UBIFS_CRC32_INIT, buf + 8, UBIFS_PAD_NODE_SZ - 8); 3371e51764aSArtem Bityutskiy ch->crc = cpu_to_le32(crc); 3381e51764aSArtem Bityutskiy memset(buf + UBIFS_PAD_NODE_SZ, 0, pad); 3391e51764aSArtem Bityutskiy } else if (pad > 0) 3401e51764aSArtem Bityutskiy /* Too little space, padding node won't fit */ 3411e51764aSArtem Bityutskiy memset(buf, UBIFS_PADDING_BYTE, pad); 3421e51764aSArtem Bityutskiy } 3431e51764aSArtem Bityutskiy 3441e51764aSArtem Bityutskiy /** 3451e51764aSArtem Bityutskiy * next_sqnum - get next sequence number. 3461e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 3471e51764aSArtem Bityutskiy */ 3481e51764aSArtem Bityutskiy static unsigned long long next_sqnum(struct ubifs_info *c) 3491e51764aSArtem Bityutskiy { 3501e51764aSArtem Bityutskiy unsigned long long sqnum; 3511e51764aSArtem Bityutskiy 3521e51764aSArtem Bityutskiy spin_lock(&c->cnt_lock); 3531e51764aSArtem Bityutskiy sqnum = ++c->max_sqnum; 3541e51764aSArtem Bityutskiy spin_unlock(&c->cnt_lock); 3551e51764aSArtem Bityutskiy 3561e51764aSArtem Bityutskiy if (unlikely(sqnum >= SQNUM_WARN_WATERMARK)) { 3571e51764aSArtem Bityutskiy if (sqnum >= SQNUM_WATERMARK) { 358235c362bSSheng Yong ubifs_err(c, "sequence number overflow %llu, end of life", 3591e51764aSArtem Bityutskiy sqnum); 3601e51764aSArtem Bityutskiy ubifs_ro_mode(c, -EINVAL); 3611e51764aSArtem Bityutskiy } 362235c362bSSheng Yong ubifs_warn(c, "running out of sequence numbers, end of life soon"); 3631e51764aSArtem Bityutskiy } 3641e51764aSArtem Bityutskiy 3651e51764aSArtem Bityutskiy return sqnum; 3661e51764aSArtem Bityutskiy } 3671e51764aSArtem Bityutskiy 368dead9726SSascha Hauer void ubifs_init_node(struct ubifs_info *c, void *node, int len, int pad) 369dead9726SSascha Hauer { 370dead9726SSascha Hauer struct ubifs_ch *ch = node; 371dead9726SSascha Hauer unsigned long long sqnum = next_sqnum(c); 372dead9726SSascha Hauer 373dead9726SSascha Hauer ubifs_assert(c, len >= UBIFS_CH_SZ); 374dead9726SSascha Hauer 375dead9726SSascha Hauer ch->magic = cpu_to_le32(UBIFS_NODE_MAGIC); 376dead9726SSascha Hauer ch->len = cpu_to_le32(len); 377dead9726SSascha Hauer ch->group_type = UBIFS_NO_NODE_GROUP; 378dead9726SSascha Hauer ch->sqnum = cpu_to_le64(sqnum); 379dead9726SSascha Hauer ch->padding[0] = ch->padding[1] = 0; 380dead9726SSascha Hauer 381dead9726SSascha Hauer if (pad) { 382dead9726SSascha Hauer len = ALIGN(len, 8); 383dead9726SSascha Hauer pad = ALIGN(len, c->min_io_size) - len; 384dead9726SSascha Hauer ubifs_pad(c, node + len, pad); 385dead9726SSascha Hauer } 386dead9726SSascha Hauer } 387dead9726SSascha Hauer 388dead9726SSascha Hauer void ubifs_crc_node(struct ubifs_info *c, void *node, int len) 389dead9726SSascha Hauer { 390dead9726SSascha Hauer struct ubifs_ch *ch = node; 391dead9726SSascha Hauer uint32_t crc; 392dead9726SSascha Hauer 393dead9726SSascha Hauer crc = crc32(UBIFS_CRC32_INIT, node + 8, len - 8); 394dead9726SSascha Hauer ch->crc = cpu_to_le32(crc); 395dead9726SSascha Hauer } 396dead9726SSascha Hauer 3971e51764aSArtem Bityutskiy /** 398a384b47eSSascha Hauer * ubifs_prepare_node_hmac - prepare node to be written to flash. 399a384b47eSSascha Hauer * @c: UBIFS file-system description object 400a384b47eSSascha Hauer * @node: the node to pad 401a384b47eSSascha Hauer * @len: node length 402a384b47eSSascha Hauer * @hmac_offs: offset of the HMAC in the node 403a384b47eSSascha Hauer * @pad: if the buffer has to be padded 404a384b47eSSascha Hauer * 405a384b47eSSascha Hauer * This function prepares node at @node to be written to the media - it 406a384b47eSSascha Hauer * calculates node CRC, fills the common header, and adds proper padding up to 407a384b47eSSascha Hauer * the next minimum I/O unit if @pad is not zero. if @hmac_offs is positive then 408a384b47eSSascha Hauer * a HMAC is inserted into the node at the given offset. 409a384b47eSSascha Hauer * 410a384b47eSSascha Hauer * This function returns 0 for success or a negative error code otherwise. 411a384b47eSSascha Hauer */ 412a384b47eSSascha Hauer int ubifs_prepare_node_hmac(struct ubifs_info *c, void *node, int len, 413a384b47eSSascha Hauer int hmac_offs, int pad) 414a384b47eSSascha Hauer { 415a384b47eSSascha Hauer int err; 416a384b47eSSascha Hauer 417a384b47eSSascha Hauer ubifs_init_node(c, node, len, pad); 418a384b47eSSascha Hauer 419a384b47eSSascha Hauer if (hmac_offs > 0) { 420a384b47eSSascha Hauer err = ubifs_node_insert_hmac(c, node, len, hmac_offs); 421a384b47eSSascha Hauer if (err) 422a384b47eSSascha Hauer return err; 423a384b47eSSascha Hauer } 424a384b47eSSascha Hauer 425a384b47eSSascha Hauer ubifs_crc_node(c, node, len); 426a384b47eSSascha Hauer 427a384b47eSSascha Hauer return 0; 428a384b47eSSascha Hauer } 429a384b47eSSascha Hauer 430a384b47eSSascha Hauer /** 4311e51764aSArtem Bityutskiy * ubifs_prepare_node - prepare node to be written to flash. 4321e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 4331e51764aSArtem Bityutskiy * @node: the node to pad 4341e51764aSArtem Bityutskiy * @len: node length 4351e51764aSArtem Bityutskiy * @pad: if the buffer has to be padded 4361e51764aSArtem Bityutskiy * 4371e51764aSArtem Bityutskiy * This function prepares node at @node to be written to the media - it 4381e51764aSArtem Bityutskiy * calculates node CRC, fills the common header, and adds proper padding up to 4391e51764aSArtem Bityutskiy * the next minimum I/O unit if @pad is not zero. 4401e51764aSArtem Bityutskiy */ 4411e51764aSArtem Bityutskiy void ubifs_prepare_node(struct ubifs_info *c, void *node, int len, int pad) 4421e51764aSArtem Bityutskiy { 443a384b47eSSascha Hauer /* 444a384b47eSSascha Hauer * Deliberately ignore return value since this function can only fail 445a384b47eSSascha Hauer * when a hmac offset is given. 446a384b47eSSascha Hauer */ 447a384b47eSSascha Hauer ubifs_prepare_node_hmac(c, node, len, 0, pad); 4481e51764aSArtem Bityutskiy } 4491e51764aSArtem Bityutskiy 4501e51764aSArtem Bityutskiy /** 4511e51764aSArtem Bityutskiy * ubifs_prep_grp_node - prepare node of a group to be written to flash. 4521e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 4531e51764aSArtem Bityutskiy * @node: the node to pad 4541e51764aSArtem Bityutskiy * @len: node length 4551e51764aSArtem Bityutskiy * @last: indicates the last node of the group 4561e51764aSArtem Bityutskiy * 4571e51764aSArtem Bityutskiy * This function prepares node at @node to be written to the media - it 4581e51764aSArtem Bityutskiy * calculates node CRC and fills the common header. 4591e51764aSArtem Bityutskiy */ 4601e51764aSArtem Bityutskiy void ubifs_prep_grp_node(struct ubifs_info *c, void *node, int len, int last) 4611e51764aSArtem Bityutskiy { 4621e51764aSArtem Bityutskiy uint32_t crc; 4631e51764aSArtem Bityutskiy struct ubifs_ch *ch = node; 4641e51764aSArtem Bityutskiy unsigned long long sqnum = next_sqnum(c); 4651e51764aSArtem Bityutskiy 4666eb61d58SRichard Weinberger ubifs_assert(c, len >= UBIFS_CH_SZ); 4671e51764aSArtem Bityutskiy 4681e51764aSArtem Bityutskiy ch->magic = cpu_to_le32(UBIFS_NODE_MAGIC); 4691e51764aSArtem Bityutskiy ch->len = cpu_to_le32(len); 4701e51764aSArtem Bityutskiy if (last) 4711e51764aSArtem Bityutskiy ch->group_type = UBIFS_LAST_OF_NODE_GROUP; 4721e51764aSArtem Bityutskiy else 4731e51764aSArtem Bityutskiy ch->group_type = UBIFS_IN_NODE_GROUP; 4741e51764aSArtem Bityutskiy ch->sqnum = cpu_to_le64(sqnum); 4751e51764aSArtem Bityutskiy ch->padding[0] = ch->padding[1] = 0; 4761e51764aSArtem Bityutskiy crc = crc32(UBIFS_CRC32_INIT, node + 8, len - 8); 4771e51764aSArtem Bityutskiy ch->crc = cpu_to_le32(crc); 4781e51764aSArtem Bityutskiy } 4791e51764aSArtem Bityutskiy 4801e51764aSArtem Bityutskiy /** 4811e51764aSArtem Bityutskiy * wbuf_timer_callback - write-buffer timer callback function. 48239274a1eSFabian Frederick * @timer: timer data (write-buffer descriptor) 4831e51764aSArtem Bityutskiy * 4841e51764aSArtem Bityutskiy * This function is called when the write-buffer timer expires. 4851e51764aSArtem Bityutskiy */ 486f2c5dbd7SArtem Bityutskiy static enum hrtimer_restart wbuf_timer_callback_nolock(struct hrtimer *timer) 4871e51764aSArtem Bityutskiy { 488f2c5dbd7SArtem Bityutskiy struct ubifs_wbuf *wbuf = container_of(timer, struct ubifs_wbuf, timer); 4891e51764aSArtem Bityutskiy 49077a7ae58SArtem Bityutskiy dbg_io("jhead %s", dbg_jhead(wbuf->jhead)); 4911e51764aSArtem Bityutskiy wbuf->need_sync = 1; 4921e51764aSArtem Bityutskiy wbuf->c->need_wbuf_sync = 1; 4931e51764aSArtem Bityutskiy ubifs_wake_up_bgt(wbuf->c); 494f2c5dbd7SArtem Bityutskiy return HRTIMER_NORESTART; 4951e51764aSArtem Bityutskiy } 4961e51764aSArtem Bityutskiy 4971e51764aSArtem Bityutskiy /** 4981e51764aSArtem Bityutskiy * new_wbuf_timer - start new write-buffer timer. 4996eb61d58SRichard Weinberger * @c: UBIFS file-system description object 5001e51764aSArtem Bityutskiy * @wbuf: write-buffer descriptor 5011e51764aSArtem Bityutskiy */ 5026eb61d58SRichard Weinberger static void new_wbuf_timer_nolock(struct ubifs_info *c, struct ubifs_wbuf *wbuf) 5031e51764aSArtem Bityutskiy { 5041b7fc2c0SRafał Miłecki ktime_t softlimit = ms_to_ktime(dirty_writeback_interval * 10); 5051b7fc2c0SRafał Miłecki unsigned long long delta = dirty_writeback_interval; 506854826c9SRafał Miłecki 5071b7fc2c0SRafał Miłecki /* centi to milli, milli to nano, then 10% */ 5081b7fc2c0SRafał Miłecki delta *= 10ULL * NSEC_PER_MSEC / 10ULL; 509854826c9SRafał Miłecki 5106eb61d58SRichard Weinberger ubifs_assert(c, !hrtimer_active(&wbuf->timer)); 5116eb61d58SRichard Weinberger ubifs_assert(c, delta <= ULONG_MAX); 5121e51764aSArtem Bityutskiy 5130b335b9dSArtem Bityutskiy if (wbuf->no_timer) 5141e51764aSArtem Bityutskiy return; 51577a7ae58SArtem Bityutskiy dbg_io("set timer for jhead %s, %llu-%llu millisecs", 51677a7ae58SArtem Bityutskiy dbg_jhead(wbuf->jhead), 517854826c9SRafał Miłecki div_u64(ktime_to_ns(softlimit), USEC_PER_SEC), 518854826c9SRafał Miłecki div_u64(ktime_to_ns(softlimit) + delta, USEC_PER_SEC)); 519854826c9SRafał Miłecki hrtimer_start_range_ns(&wbuf->timer, softlimit, delta, 520f2c5dbd7SArtem Bityutskiy HRTIMER_MODE_REL); 5211e51764aSArtem Bityutskiy } 5221e51764aSArtem Bityutskiy 5231e51764aSArtem Bityutskiy /** 5241e51764aSArtem Bityutskiy * cancel_wbuf_timer - cancel write-buffer timer. 5251e51764aSArtem Bityutskiy * @wbuf: write-buffer descriptor 5261e51764aSArtem Bityutskiy */ 5271e51764aSArtem Bityutskiy static void cancel_wbuf_timer_nolock(struct ubifs_wbuf *wbuf) 5281e51764aSArtem Bityutskiy { 5290b335b9dSArtem Bityutskiy if (wbuf->no_timer) 5300b335b9dSArtem Bityutskiy return; 5311e51764aSArtem Bityutskiy wbuf->need_sync = 0; 532f2c5dbd7SArtem Bityutskiy hrtimer_cancel(&wbuf->timer); 5331e51764aSArtem Bityutskiy } 5341e51764aSArtem Bityutskiy 5351e51764aSArtem Bityutskiy /** 5361e51764aSArtem Bityutskiy * ubifs_wbuf_sync_nolock - synchronize write-buffer. 5371e51764aSArtem Bityutskiy * @wbuf: write-buffer to synchronize 5381e51764aSArtem Bityutskiy * 5391e51764aSArtem Bityutskiy * This function synchronizes write-buffer @buf and returns zero in case of 5401e51764aSArtem Bityutskiy * success or a negative error code in case of failure. 5416c7f74f7SArtem Bityutskiy * 5426c7f74f7SArtem Bityutskiy * Note, although write-buffers are of @c->max_write_size, this function does 5436c7f74f7SArtem Bityutskiy * not necessarily writes all @c->max_write_size bytes to the flash. Instead, 5446c7f74f7SArtem Bityutskiy * if the write-buffer is only partially filled with data, only the used part 5456c7f74f7SArtem Bityutskiy * of the write-buffer (aligned on @c->min_io_size boundary) is synchronized. 5466c7f74f7SArtem Bityutskiy * This way we waste less space. 5471e51764aSArtem Bityutskiy */ 5481e51764aSArtem Bityutskiy int ubifs_wbuf_sync_nolock(struct ubifs_wbuf *wbuf) 5491e51764aSArtem Bityutskiy { 5501e51764aSArtem Bityutskiy struct ubifs_info *c = wbuf->c; 5516c7f74f7SArtem Bityutskiy int err, dirt, sync_len; 5521e51764aSArtem Bityutskiy 5531e51764aSArtem Bityutskiy cancel_wbuf_timer_nolock(wbuf); 5541e51764aSArtem Bityutskiy if (!wbuf->used || wbuf->lnum == -1) 5551e51764aSArtem Bityutskiy /* Write-buffer is empty or not seeked */ 5561e51764aSArtem Bityutskiy return 0; 5571e51764aSArtem Bityutskiy 55877a7ae58SArtem Bityutskiy dbg_io("LEB %d:%d, %d bytes, jhead %s", 55977a7ae58SArtem Bityutskiy wbuf->lnum, wbuf->offs, wbuf->used, dbg_jhead(wbuf->jhead)); 5606eb61d58SRichard Weinberger ubifs_assert(c, !(wbuf->avail & 7)); 5616eb61d58SRichard Weinberger ubifs_assert(c, wbuf->offs + wbuf->size <= c->leb_size); 5626eb61d58SRichard Weinberger ubifs_assert(c, wbuf->size >= c->min_io_size); 5636eb61d58SRichard Weinberger ubifs_assert(c, wbuf->size <= c->max_write_size); 5646eb61d58SRichard Weinberger ubifs_assert(c, wbuf->size % c->min_io_size == 0); 5656eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount); 5666c7f74f7SArtem Bityutskiy if (c->leb_size - wbuf->offs >= c->max_write_size) 5676eb61d58SRichard Weinberger ubifs_assert(c, !((wbuf->offs + wbuf->size) % c->max_write_size)); 5681e51764aSArtem Bityutskiy 5692680d722SArtem Bityutskiy if (c->ro_error) 5701e51764aSArtem Bityutskiy return -EROFS; 5711e51764aSArtem Bityutskiy 5726c7f74f7SArtem Bityutskiy /* 5736c7f74f7SArtem Bityutskiy * Do not write whole write buffer but write only the minimum necessary 5746c7f74f7SArtem Bityutskiy * amount of min. I/O units. 5756c7f74f7SArtem Bityutskiy */ 5766c7f74f7SArtem Bityutskiy sync_len = ALIGN(wbuf->used, c->min_io_size); 5776c7f74f7SArtem Bityutskiy dirt = sync_len - wbuf->used; 5786c7f74f7SArtem Bityutskiy if (dirt) 5796c7f74f7SArtem Bityutskiy ubifs_pad(c, wbuf->buf + wbuf->used, dirt); 580b36a261eSRichard Weinberger err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf, wbuf->offs, sync_len); 581987226a5SArtem Bityutskiy if (err) 5821e51764aSArtem Bityutskiy return err; 5831e51764aSArtem Bityutskiy 5841e51764aSArtem Bityutskiy spin_lock(&wbuf->lock); 5856c7f74f7SArtem Bityutskiy wbuf->offs += sync_len; 5866c7f74f7SArtem Bityutskiy /* 5876c7f74f7SArtem Bityutskiy * Now @wbuf->offs is not necessarily aligned to @c->max_write_size. 5886c7f74f7SArtem Bityutskiy * But our goal is to optimize writes and make sure we write in 5896c7f74f7SArtem Bityutskiy * @c->max_write_size chunks and to @c->max_write_size-aligned offset. 5906c7f74f7SArtem Bityutskiy * Thus, if @wbuf->offs is not aligned to @c->max_write_size now, make 5916c7f74f7SArtem Bityutskiy * sure that @wbuf->offs + @wbuf->size is aligned to 5926c7f74f7SArtem Bityutskiy * @c->max_write_size. This way we make sure that after next 5936c7f74f7SArtem Bityutskiy * write-buffer flush we are again at the optimal offset (aligned to 5946c7f74f7SArtem Bityutskiy * @c->max_write_size). 5956c7f74f7SArtem Bityutskiy */ 5966c7f74f7SArtem Bityutskiy if (c->leb_size - wbuf->offs < c->max_write_size) 5976c7f74f7SArtem Bityutskiy wbuf->size = c->leb_size - wbuf->offs; 5986c7f74f7SArtem Bityutskiy else if (wbuf->offs & (c->max_write_size - 1)) 5996c7f74f7SArtem Bityutskiy wbuf->size = ALIGN(wbuf->offs, c->max_write_size) - wbuf->offs; 6006c7f74f7SArtem Bityutskiy else 6016c7f74f7SArtem Bityutskiy wbuf->size = c->max_write_size; 6026c7f74f7SArtem Bityutskiy wbuf->avail = wbuf->size; 6031e51764aSArtem Bityutskiy wbuf->used = 0; 6041e51764aSArtem Bityutskiy wbuf->next_ino = 0; 6051e51764aSArtem Bityutskiy spin_unlock(&wbuf->lock); 6061e51764aSArtem Bityutskiy 6071e51764aSArtem Bityutskiy if (wbuf->sync_callback) 6081e51764aSArtem Bityutskiy err = wbuf->sync_callback(c, wbuf->lnum, 6091e51764aSArtem Bityutskiy c->leb_size - wbuf->offs, dirt); 6101e51764aSArtem Bityutskiy return err; 6111e51764aSArtem Bityutskiy } 6121e51764aSArtem Bityutskiy 6131e51764aSArtem Bityutskiy /** 6141e51764aSArtem Bityutskiy * ubifs_wbuf_seek_nolock - seek write-buffer. 6151e51764aSArtem Bityutskiy * @wbuf: write-buffer 6161e51764aSArtem Bityutskiy * @lnum: logical eraseblock number to seek to 6171e51764aSArtem Bityutskiy * @offs: logical eraseblock offset to seek to 6181e51764aSArtem Bityutskiy * 619cb54ef8bSArtem Bityutskiy * This function targets the write-buffer to logical eraseblock @lnum:@offs. 620cb14a184SArtem Bityutskiy * The write-buffer has to be empty. Returns zero in case of success and a 621cb14a184SArtem Bityutskiy * negative error code in case of failure. 6221e51764aSArtem Bityutskiy */ 623b36a261eSRichard Weinberger int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs) 6241e51764aSArtem Bityutskiy { 6251e51764aSArtem Bityutskiy const struct ubifs_info *c = wbuf->c; 6261e51764aSArtem Bityutskiy 62777a7ae58SArtem Bityutskiy dbg_io("LEB %d:%d, jhead %s", lnum, offs, dbg_jhead(wbuf->jhead)); 6286eb61d58SRichard Weinberger ubifs_assert(c, lnum >= 0 && lnum < c->leb_cnt); 6296eb61d58SRichard Weinberger ubifs_assert(c, offs >= 0 && offs <= c->leb_size); 6306eb61d58SRichard Weinberger ubifs_assert(c, offs % c->min_io_size == 0 && !(offs & 7)); 6316eb61d58SRichard Weinberger ubifs_assert(c, lnum != wbuf->lnum); 6326eb61d58SRichard Weinberger ubifs_assert(c, wbuf->used == 0); 6331e51764aSArtem Bityutskiy 6341e51764aSArtem Bityutskiy spin_lock(&wbuf->lock); 6351e51764aSArtem Bityutskiy wbuf->lnum = lnum; 6361e51764aSArtem Bityutskiy wbuf->offs = offs; 6376c7f74f7SArtem Bityutskiy if (c->leb_size - wbuf->offs < c->max_write_size) 6386c7f74f7SArtem Bityutskiy wbuf->size = c->leb_size - wbuf->offs; 6396c7f74f7SArtem Bityutskiy else if (wbuf->offs & (c->max_write_size - 1)) 6406c7f74f7SArtem Bityutskiy wbuf->size = ALIGN(wbuf->offs, c->max_write_size) - wbuf->offs; 6416c7f74f7SArtem Bityutskiy else 6426c7f74f7SArtem Bityutskiy wbuf->size = c->max_write_size; 6436c7f74f7SArtem Bityutskiy wbuf->avail = wbuf->size; 6441e51764aSArtem Bityutskiy wbuf->used = 0; 6451e51764aSArtem Bityutskiy spin_unlock(&wbuf->lock); 6461e51764aSArtem Bityutskiy 6471e51764aSArtem Bityutskiy return 0; 6481e51764aSArtem Bityutskiy } 6491e51764aSArtem Bityutskiy 6501e51764aSArtem Bityutskiy /** 6511e51764aSArtem Bityutskiy * ubifs_bg_wbufs_sync - synchronize write-buffers. 6521e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 6531e51764aSArtem Bityutskiy * 6541e51764aSArtem Bityutskiy * This function is called by background thread to synchronize write-buffers. 6551e51764aSArtem Bityutskiy * Returns zero in case of success and a negative error code in case of 6561e51764aSArtem Bityutskiy * failure. 6571e51764aSArtem Bityutskiy */ 6581e51764aSArtem Bityutskiy int ubifs_bg_wbufs_sync(struct ubifs_info *c) 6591e51764aSArtem Bityutskiy { 6601e51764aSArtem Bityutskiy int err, i; 6611e51764aSArtem Bityutskiy 6626eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount); 6631e51764aSArtem Bityutskiy if (!c->need_wbuf_sync) 6641e51764aSArtem Bityutskiy return 0; 6651e51764aSArtem Bityutskiy c->need_wbuf_sync = 0; 6661e51764aSArtem Bityutskiy 6672680d722SArtem Bityutskiy if (c->ro_error) { 6681e51764aSArtem Bityutskiy err = -EROFS; 6691e51764aSArtem Bityutskiy goto out_timers; 6701e51764aSArtem Bityutskiy } 6711e51764aSArtem Bityutskiy 6721e51764aSArtem Bityutskiy dbg_io("synchronize"); 6731e51764aSArtem Bityutskiy for (i = 0; i < c->jhead_cnt; i++) { 6741e51764aSArtem Bityutskiy struct ubifs_wbuf *wbuf = &c->jheads[i].wbuf; 6751e51764aSArtem Bityutskiy 6761e51764aSArtem Bityutskiy cond_resched(); 6771e51764aSArtem Bityutskiy 6781e51764aSArtem Bityutskiy /* 6791e51764aSArtem Bityutskiy * If the mutex is locked then wbuf is being changed, so 6801e51764aSArtem Bityutskiy * synchronization is not necessary. 6811e51764aSArtem Bityutskiy */ 6821e51764aSArtem Bityutskiy if (mutex_is_locked(&wbuf->io_mutex)) 6831e51764aSArtem Bityutskiy continue; 6841e51764aSArtem Bityutskiy 6851e51764aSArtem Bityutskiy mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead); 6861e51764aSArtem Bityutskiy if (!wbuf->need_sync) { 6871e51764aSArtem Bityutskiy mutex_unlock(&wbuf->io_mutex); 6881e51764aSArtem Bityutskiy continue; 6891e51764aSArtem Bityutskiy } 6901e51764aSArtem Bityutskiy 6911e51764aSArtem Bityutskiy err = ubifs_wbuf_sync_nolock(wbuf); 6921e51764aSArtem Bityutskiy mutex_unlock(&wbuf->io_mutex); 6931e51764aSArtem Bityutskiy if (err) { 694235c362bSSheng Yong ubifs_err(c, "cannot sync write-buffer, error %d", err); 6951e51764aSArtem Bityutskiy ubifs_ro_mode(c, err); 6961e51764aSArtem Bityutskiy goto out_timers; 6971e51764aSArtem Bityutskiy } 6981e51764aSArtem Bityutskiy } 6991e51764aSArtem Bityutskiy 7001e51764aSArtem Bityutskiy return 0; 7011e51764aSArtem Bityutskiy 7021e51764aSArtem Bityutskiy out_timers: 7031e51764aSArtem Bityutskiy /* Cancel all timers to prevent repeated errors */ 7041e51764aSArtem Bityutskiy for (i = 0; i < c->jhead_cnt; i++) { 7051e51764aSArtem Bityutskiy struct ubifs_wbuf *wbuf = &c->jheads[i].wbuf; 7061e51764aSArtem Bityutskiy 7071e51764aSArtem Bityutskiy mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead); 7081e51764aSArtem Bityutskiy cancel_wbuf_timer_nolock(wbuf); 7091e51764aSArtem Bityutskiy mutex_unlock(&wbuf->io_mutex); 7101e51764aSArtem Bityutskiy } 7111e51764aSArtem Bityutskiy return err; 7121e51764aSArtem Bityutskiy } 7131e51764aSArtem Bityutskiy 7141e51764aSArtem Bityutskiy /** 7151e51764aSArtem Bityutskiy * ubifs_wbuf_write_nolock - write data to flash via write-buffer. 7161e51764aSArtem Bityutskiy * @wbuf: write-buffer 7171e51764aSArtem Bityutskiy * @buf: node to write 7181e51764aSArtem Bityutskiy * @len: node length 7191e51764aSArtem Bityutskiy * 7201e51764aSArtem Bityutskiy * This function writes data to flash via write-buffer @wbuf. This means that 7211e51764aSArtem Bityutskiy * the last piece of the node won't reach the flash media immediately if it 7226c7f74f7SArtem Bityutskiy * does not take whole max. write unit (@c->max_write_size). Instead, the node 7236c7f74f7SArtem Bityutskiy * will sit in RAM until the write-buffer is synchronized (e.g., by timer, or 7246c7f74f7SArtem Bityutskiy * because more data are appended to the write-buffer). 7251e51764aSArtem Bityutskiy * 7261e51764aSArtem Bityutskiy * This function returns zero in case of success and a negative error code in 7271e51764aSArtem Bityutskiy * case of failure. If the node cannot be written because there is no more 7281e51764aSArtem Bityutskiy * space in this logical eraseblock, %-ENOSPC is returned. 7291e51764aSArtem Bityutskiy */ 7301e51764aSArtem Bityutskiy int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len) 7311e51764aSArtem Bityutskiy { 7321e51764aSArtem Bityutskiy struct ubifs_info *c = wbuf->c; 73312f33891SArtem Bityutskiy int err, written, n, aligned_len = ALIGN(len, 8); 7341e51764aSArtem Bityutskiy 73577a7ae58SArtem Bityutskiy dbg_io("%d bytes (%s) to jhead %s wbuf at LEB %d:%d", len, 73677a7ae58SArtem Bityutskiy dbg_ntype(((struct ubifs_ch *)buf)->node_type), 73777a7ae58SArtem Bityutskiy dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs + wbuf->used); 7386eb61d58SRichard Weinberger ubifs_assert(c, len > 0 && wbuf->lnum >= 0 && wbuf->lnum < c->leb_cnt); 7396eb61d58SRichard Weinberger ubifs_assert(c, wbuf->offs >= 0 && wbuf->offs % c->min_io_size == 0); 7406eb61d58SRichard Weinberger ubifs_assert(c, !(wbuf->offs & 7) && wbuf->offs <= c->leb_size); 7416eb61d58SRichard Weinberger ubifs_assert(c, wbuf->avail > 0 && wbuf->avail <= wbuf->size); 7426eb61d58SRichard Weinberger ubifs_assert(c, wbuf->size >= c->min_io_size); 7436eb61d58SRichard Weinberger ubifs_assert(c, wbuf->size <= c->max_write_size); 7446eb61d58SRichard Weinberger ubifs_assert(c, wbuf->size % c->min_io_size == 0); 7456eb61d58SRichard Weinberger ubifs_assert(c, mutex_is_locked(&wbuf->io_mutex)); 7466eb61d58SRichard Weinberger ubifs_assert(c, !c->ro_media && !c->ro_mount); 7476eb61d58SRichard Weinberger ubifs_assert(c, !c->space_fixup); 7486c7f74f7SArtem Bityutskiy if (c->leb_size - wbuf->offs >= c->max_write_size) 7496eb61d58SRichard Weinberger ubifs_assert(c, !((wbuf->offs + wbuf->size) % c->max_write_size)); 7501e51764aSArtem Bityutskiy 7511e51764aSArtem Bityutskiy if (c->leb_size - wbuf->offs - wbuf->used < aligned_len) { 7521e51764aSArtem Bityutskiy err = -ENOSPC; 7531e51764aSArtem Bityutskiy goto out; 7541e51764aSArtem Bityutskiy } 7551e51764aSArtem Bityutskiy 7561e51764aSArtem Bityutskiy cancel_wbuf_timer_nolock(wbuf); 7571e51764aSArtem Bityutskiy 7582680d722SArtem Bityutskiy if (c->ro_error) 7591e51764aSArtem Bityutskiy return -EROFS; 7601e51764aSArtem Bityutskiy 7611e51764aSArtem Bityutskiy if (aligned_len <= wbuf->avail) { 7621e51764aSArtem Bityutskiy /* 7631e51764aSArtem Bityutskiy * The node is not very large and fits entirely within 7641e51764aSArtem Bityutskiy * write-buffer. 7651e51764aSArtem Bityutskiy */ 7661e51764aSArtem Bityutskiy memcpy(wbuf->buf + wbuf->used, buf, len); 767*20f14311SRichard Weinberger if (aligned_len > len) { 768*20f14311SRichard Weinberger ubifs_assert(c, aligned_len - len < 8); 769*20f14311SRichard Weinberger ubifs_pad(c, wbuf->buf + wbuf->used + len, aligned_len - len); 770*20f14311SRichard Weinberger } 7711e51764aSArtem Bityutskiy 7721e51764aSArtem Bityutskiy if (aligned_len == wbuf->avail) { 77377a7ae58SArtem Bityutskiy dbg_io("flush jhead %s wbuf to LEB %d:%d", 77477a7ae58SArtem Bityutskiy dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs); 775987226a5SArtem Bityutskiy err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf, 776b36a261eSRichard Weinberger wbuf->offs, wbuf->size); 7771e51764aSArtem Bityutskiy if (err) 7781e51764aSArtem Bityutskiy goto out; 7791e51764aSArtem Bityutskiy 7801e51764aSArtem Bityutskiy spin_lock(&wbuf->lock); 7816c7f74f7SArtem Bityutskiy wbuf->offs += wbuf->size; 7826c7f74f7SArtem Bityutskiy if (c->leb_size - wbuf->offs >= c->max_write_size) 7836c7f74f7SArtem Bityutskiy wbuf->size = c->max_write_size; 7846c7f74f7SArtem Bityutskiy else 7856c7f74f7SArtem Bityutskiy wbuf->size = c->leb_size - wbuf->offs; 7866c7f74f7SArtem Bityutskiy wbuf->avail = wbuf->size; 7871e51764aSArtem Bityutskiy wbuf->used = 0; 7881e51764aSArtem Bityutskiy wbuf->next_ino = 0; 7891e51764aSArtem Bityutskiy spin_unlock(&wbuf->lock); 7901e51764aSArtem Bityutskiy } else { 7911e51764aSArtem Bityutskiy spin_lock(&wbuf->lock); 7921e51764aSArtem Bityutskiy wbuf->avail -= aligned_len; 7931e51764aSArtem Bityutskiy wbuf->used += aligned_len; 7941e51764aSArtem Bityutskiy spin_unlock(&wbuf->lock); 7951e51764aSArtem Bityutskiy } 7961e51764aSArtem Bityutskiy 7971e51764aSArtem Bityutskiy goto exit; 7981e51764aSArtem Bityutskiy } 7991e51764aSArtem Bityutskiy 8006c7f74f7SArtem Bityutskiy written = 0; 8016c7f74f7SArtem Bityutskiy 8026c7f74f7SArtem Bityutskiy if (wbuf->used) { 8031e51764aSArtem Bityutskiy /* 8046c7f74f7SArtem Bityutskiy * The node is large enough and does not fit entirely within 8056c7f74f7SArtem Bityutskiy * current available space. We have to fill and flush 8066c7f74f7SArtem Bityutskiy * write-buffer and switch to the next max. write unit. 8071e51764aSArtem Bityutskiy */ 80877a7ae58SArtem Bityutskiy dbg_io("flush jhead %s wbuf to LEB %d:%d", 80977a7ae58SArtem Bityutskiy dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs); 8101e51764aSArtem Bityutskiy memcpy(wbuf->buf + wbuf->used, buf, wbuf->avail); 811987226a5SArtem Bityutskiy err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf, wbuf->offs, 812b36a261eSRichard Weinberger wbuf->size); 8131e51764aSArtem Bityutskiy if (err) 8141e51764aSArtem Bityutskiy goto out; 8151e51764aSArtem Bityutskiy 81612f33891SArtem Bityutskiy wbuf->offs += wbuf->size; 8171e51764aSArtem Bityutskiy len -= wbuf->avail; 8181e51764aSArtem Bityutskiy aligned_len -= wbuf->avail; 8196c7f74f7SArtem Bityutskiy written += wbuf->avail; 8206c7f74f7SArtem Bityutskiy } else if (wbuf->offs & (c->max_write_size - 1)) { 8216c7f74f7SArtem Bityutskiy /* 8226c7f74f7SArtem Bityutskiy * The write-buffer offset is not aligned to 8236c7f74f7SArtem Bityutskiy * @c->max_write_size and @wbuf->size is less than 8246c7f74f7SArtem Bityutskiy * @c->max_write_size. Write @wbuf->size bytes to make sure the 8256c7f74f7SArtem Bityutskiy * following writes are done in optimal @c->max_write_size 8266c7f74f7SArtem Bityutskiy * chunks. 8276c7f74f7SArtem Bityutskiy */ 8286c7f74f7SArtem Bityutskiy dbg_io("write %d bytes to LEB %d:%d", 8296c7f74f7SArtem Bityutskiy wbuf->size, wbuf->lnum, wbuf->offs); 830987226a5SArtem Bityutskiy err = ubifs_leb_write(c, wbuf->lnum, buf, wbuf->offs, 831b36a261eSRichard Weinberger wbuf->size); 8326c7f74f7SArtem Bityutskiy if (err) 8336c7f74f7SArtem Bityutskiy goto out; 8346c7f74f7SArtem Bityutskiy 83512f33891SArtem Bityutskiy wbuf->offs += wbuf->size; 8366c7f74f7SArtem Bityutskiy len -= wbuf->size; 8376c7f74f7SArtem Bityutskiy aligned_len -= wbuf->size; 8386c7f74f7SArtem Bityutskiy written += wbuf->size; 8396c7f74f7SArtem Bityutskiy } 8401e51764aSArtem Bityutskiy 8411e51764aSArtem Bityutskiy /* 8426c7f74f7SArtem Bityutskiy * The remaining data may take more whole max. write units, so write the 8436c7f74f7SArtem Bityutskiy * remains multiple to max. write unit size directly to the flash media. 8441e51764aSArtem Bityutskiy * We align node length to 8-byte boundary because we anyway flash wbuf 8451e51764aSArtem Bityutskiy * if the remaining space is less than 8 bytes. 8461e51764aSArtem Bityutskiy */ 8476c7f74f7SArtem Bityutskiy n = aligned_len >> c->max_write_shift; 8481e51764aSArtem Bityutskiy if (n) { 8496c7f74f7SArtem Bityutskiy n <<= c->max_write_shift; 85012f33891SArtem Bityutskiy dbg_io("write %d bytes to LEB %d:%d", n, wbuf->lnum, 85112f33891SArtem Bityutskiy wbuf->offs); 852987226a5SArtem Bityutskiy err = ubifs_leb_write(c, wbuf->lnum, buf + written, 853b36a261eSRichard Weinberger wbuf->offs, n); 8541e51764aSArtem Bityutskiy if (err) 8551e51764aSArtem Bityutskiy goto out; 85612f33891SArtem Bityutskiy wbuf->offs += n; 8571e51764aSArtem Bityutskiy aligned_len -= n; 8581e51764aSArtem Bityutskiy len -= n; 8591e51764aSArtem Bityutskiy written += n; 8601e51764aSArtem Bityutskiy } 8611e51764aSArtem Bityutskiy 8621e51764aSArtem Bityutskiy spin_lock(&wbuf->lock); 863*20f14311SRichard Weinberger if (aligned_len) { 8641e51764aSArtem Bityutskiy /* 8651e51764aSArtem Bityutskiy * And now we have what's left and what does not take whole 8666c7f74f7SArtem Bityutskiy * max. write unit, so write it to the write-buffer and we are 8671e51764aSArtem Bityutskiy * done. 8681e51764aSArtem Bityutskiy */ 8691e51764aSArtem Bityutskiy memcpy(wbuf->buf, buf + written, len); 870*20f14311SRichard Weinberger if (aligned_len > len) { 871*20f14311SRichard Weinberger ubifs_assert(c, aligned_len - len < 8); 872*20f14311SRichard Weinberger ubifs_pad(c, wbuf->buf + len, aligned_len - len); 873*20f14311SRichard Weinberger } 874*20f14311SRichard Weinberger } 8751e51764aSArtem Bityutskiy 8766c7f74f7SArtem Bityutskiy if (c->leb_size - wbuf->offs >= c->max_write_size) 8776c7f74f7SArtem Bityutskiy wbuf->size = c->max_write_size; 8786c7f74f7SArtem Bityutskiy else 8796c7f74f7SArtem Bityutskiy wbuf->size = c->leb_size - wbuf->offs; 8806c7f74f7SArtem Bityutskiy wbuf->avail = wbuf->size - aligned_len; 8811e51764aSArtem Bityutskiy wbuf->used = aligned_len; 8821e51764aSArtem Bityutskiy wbuf->next_ino = 0; 8831e51764aSArtem Bityutskiy spin_unlock(&wbuf->lock); 8841e51764aSArtem Bityutskiy 8851e51764aSArtem Bityutskiy exit: 8861e51764aSArtem Bityutskiy if (wbuf->sync_callback) { 8871e51764aSArtem Bityutskiy int free = c->leb_size - wbuf->offs - wbuf->used; 8881e51764aSArtem Bityutskiy 8891e51764aSArtem Bityutskiy err = wbuf->sync_callback(c, wbuf->lnum, free, 0); 8901e51764aSArtem Bityutskiy if (err) 8911e51764aSArtem Bityutskiy goto out; 8921e51764aSArtem Bityutskiy } 8931e51764aSArtem Bityutskiy 8941e51764aSArtem Bityutskiy if (wbuf->used) 8956eb61d58SRichard Weinberger new_wbuf_timer_nolock(c, wbuf); 8961e51764aSArtem Bityutskiy 8971e51764aSArtem Bityutskiy return 0; 8981e51764aSArtem Bityutskiy 8991e51764aSArtem Bityutskiy out: 900235c362bSSheng Yong ubifs_err(c, "cannot write %d bytes to LEB %d:%d, error %d", 9011e51764aSArtem Bityutskiy len, wbuf->lnum, wbuf->offs, err); 902edf6be24SArtem Bityutskiy ubifs_dump_node(c, buf); 9037c46d0aeSArtem Bityutskiy dump_stack(); 904edf6be24SArtem Bityutskiy ubifs_dump_leb(c, wbuf->lnum); 9051e51764aSArtem Bityutskiy return err; 9061e51764aSArtem Bityutskiy } 9071e51764aSArtem Bityutskiy 9081e51764aSArtem Bityutskiy /** 909a384b47eSSascha Hauer * ubifs_write_node_hmac - write node to the media. 910a384b47eSSascha Hauer * @c: UBIFS file-system description object 911a384b47eSSascha Hauer * @buf: the node to write 912a384b47eSSascha Hauer * @len: node length 913a384b47eSSascha Hauer * @lnum: logical eraseblock number 914a384b47eSSascha Hauer * @offs: offset within the logical eraseblock 915a384b47eSSascha Hauer * @hmac_offs: offset of the HMAC within the node 916a384b47eSSascha Hauer * 917a384b47eSSascha Hauer * This function automatically fills node magic number, assigns sequence 918a384b47eSSascha Hauer * number, and calculates node CRC checksum. The length of the @buf buffer has 919a384b47eSSascha Hauer * to be aligned to the minimal I/O unit size. This function automatically 920a384b47eSSascha Hauer * appends padding node and padding bytes if needed. Returns zero in case of 921a384b47eSSascha Hauer * success and a negative error code in case of failure. 922a384b47eSSascha Hauer */ 923a384b47eSSascha Hauer int ubifs_write_node_hmac(struct ubifs_info *c, void *buf, int len, int lnum, 924a384b47eSSascha Hauer int offs, int hmac_offs) 925a384b47eSSascha Hauer { 926a384b47eSSascha Hauer int err, buf_len = ALIGN(len, c->min_io_size); 927a384b47eSSascha Hauer 928a384b47eSSascha Hauer dbg_io("LEB %d:%d, %s, length %d (aligned %d)", 929a384b47eSSascha Hauer lnum, offs, dbg_ntype(((struct ubifs_ch *)buf)->node_type), len, 930a384b47eSSascha Hauer buf_len); 931a384b47eSSascha Hauer ubifs_assert(c, lnum >= 0 && lnum < c->leb_cnt && offs >= 0); 932a384b47eSSascha Hauer ubifs_assert(c, offs % c->min_io_size == 0 && offs < c->leb_size); 933a384b47eSSascha Hauer ubifs_assert(c, !c->ro_media && !c->ro_mount); 934a384b47eSSascha Hauer ubifs_assert(c, !c->space_fixup); 935a384b47eSSascha Hauer 936a384b47eSSascha Hauer if (c->ro_error) 937a384b47eSSascha Hauer return -EROFS; 938a384b47eSSascha Hauer 939a384b47eSSascha Hauer err = ubifs_prepare_node_hmac(c, buf, len, hmac_offs, 1); 940a384b47eSSascha Hauer if (err) 941a384b47eSSascha Hauer return err; 942a384b47eSSascha Hauer 943a384b47eSSascha Hauer err = ubifs_leb_write(c, lnum, buf, offs, buf_len); 944a384b47eSSascha Hauer if (err) 945a384b47eSSascha Hauer ubifs_dump_node(c, buf); 946a384b47eSSascha Hauer 947a384b47eSSascha Hauer return err; 948a384b47eSSascha Hauer } 949a384b47eSSascha Hauer 950a384b47eSSascha Hauer /** 9511e51764aSArtem Bityutskiy * ubifs_write_node - write node to the media. 9521e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 9531e51764aSArtem Bityutskiy * @buf: the node to write 9541e51764aSArtem Bityutskiy * @len: node length 9551e51764aSArtem Bityutskiy * @lnum: logical eraseblock number 9561e51764aSArtem Bityutskiy * @offs: offset within the logical eraseblock 9571e51764aSArtem Bityutskiy * 9581e51764aSArtem Bityutskiy * This function automatically fills node magic number, assigns sequence 9591e51764aSArtem Bityutskiy * number, and calculates node CRC checksum. The length of the @buf buffer has 9601e51764aSArtem Bityutskiy * to be aligned to the minimal I/O unit size. This function automatically 9611e51764aSArtem Bityutskiy * appends padding node and padding bytes if needed. Returns zero in case of 9621e51764aSArtem Bityutskiy * success and a negative error code in case of failure. 9631e51764aSArtem Bityutskiy */ 9641e51764aSArtem Bityutskiy int ubifs_write_node(struct ubifs_info *c, void *buf, int len, int lnum, 965b36a261eSRichard Weinberger int offs) 9661e51764aSArtem Bityutskiy { 967a384b47eSSascha Hauer return ubifs_write_node_hmac(c, buf, len, lnum, offs, -1); 9681e51764aSArtem Bityutskiy } 9691e51764aSArtem Bityutskiy 9701e51764aSArtem Bityutskiy /** 9711e51764aSArtem Bityutskiy * ubifs_read_node_wbuf - read node from the media or write-buffer. 9721e51764aSArtem Bityutskiy * @wbuf: wbuf to check for un-written data 9731e51764aSArtem Bityutskiy * @buf: buffer to read to 9741e51764aSArtem Bityutskiy * @type: node type 9751e51764aSArtem Bityutskiy * @len: node length 9761e51764aSArtem Bityutskiy * @lnum: logical eraseblock number 9771e51764aSArtem Bityutskiy * @offs: offset within the logical eraseblock 9781e51764aSArtem Bityutskiy * 9791e51764aSArtem Bityutskiy * This function reads a node of known type and length, checks it and stores 9801e51764aSArtem Bityutskiy * in @buf. If the node partially or fully sits in the write-buffer, this 9811e51764aSArtem Bityutskiy * function takes data from the buffer, otherwise it reads the flash media. 9821e51764aSArtem Bityutskiy * Returns zero in case of success, %-EUCLEAN if CRC mismatched and a negative 9831e51764aSArtem Bityutskiy * error code in case of failure. 9841e51764aSArtem Bityutskiy */ 9851e51764aSArtem Bityutskiy int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len, 9861e51764aSArtem Bityutskiy int lnum, int offs) 9871e51764aSArtem Bityutskiy { 9881e51764aSArtem Bityutskiy const struct ubifs_info *c = wbuf->c; 9891e51764aSArtem Bityutskiy int err, rlen, overlap; 9901e51764aSArtem Bityutskiy struct ubifs_ch *ch = buf; 9911e51764aSArtem Bityutskiy 99277a7ae58SArtem Bityutskiy dbg_io("LEB %d:%d, %s, length %d, jhead %s", lnum, offs, 99377a7ae58SArtem Bityutskiy dbg_ntype(type), len, dbg_jhead(wbuf->jhead)); 9946eb61d58SRichard Weinberger ubifs_assert(c, wbuf && lnum >= 0 && lnum < c->leb_cnt && offs >= 0); 9956eb61d58SRichard Weinberger ubifs_assert(c, !(offs & 7) && offs < c->leb_size); 9966eb61d58SRichard Weinberger ubifs_assert(c, type >= 0 && type < UBIFS_NODE_TYPES_CNT); 9971e51764aSArtem Bityutskiy 9981e51764aSArtem Bityutskiy spin_lock(&wbuf->lock); 9991e51764aSArtem Bityutskiy overlap = (lnum == wbuf->lnum && offs + len > wbuf->offs); 10001e51764aSArtem Bityutskiy if (!overlap) { 10011e51764aSArtem Bityutskiy /* We may safely unlock the write-buffer and read the data */ 10021e51764aSArtem Bityutskiy spin_unlock(&wbuf->lock); 10031e51764aSArtem Bityutskiy return ubifs_read_node(c, buf, type, len, lnum, offs); 10041e51764aSArtem Bityutskiy } 10051e51764aSArtem Bityutskiy 10061e51764aSArtem Bityutskiy /* Don't read under wbuf */ 10071e51764aSArtem Bityutskiy rlen = wbuf->offs - offs; 10081e51764aSArtem Bityutskiy if (rlen < 0) 10091e51764aSArtem Bityutskiy rlen = 0; 10101e51764aSArtem Bityutskiy 10111e51764aSArtem Bityutskiy /* Copy the rest from the write-buffer */ 10121e51764aSArtem Bityutskiy memcpy(buf + rlen, wbuf->buf + offs + rlen - wbuf->offs, len - rlen); 10131e51764aSArtem Bityutskiy spin_unlock(&wbuf->lock); 10141e51764aSArtem Bityutskiy 10151e51764aSArtem Bityutskiy if (rlen > 0) { 10161e51764aSArtem Bityutskiy /* Read everything that goes before write-buffer */ 1017d304820aSArtem Bityutskiy err = ubifs_leb_read(c, lnum, buf, offs, rlen, 0); 1018d304820aSArtem Bityutskiy if (err && err != -EBADMSG) 10191e51764aSArtem Bityutskiy return err; 10201e51764aSArtem Bityutskiy } 10211e51764aSArtem Bityutskiy 10221e51764aSArtem Bityutskiy if (type != ch->node_type) { 1023235c362bSSheng Yong ubifs_err(c, "bad node type (%d but expected %d)", 10241e51764aSArtem Bityutskiy ch->node_type, type); 10251e51764aSArtem Bityutskiy goto out; 10261e51764aSArtem Bityutskiy } 10271e51764aSArtem Bityutskiy 10282953e73fSAdrian Hunter err = ubifs_check_node(c, buf, lnum, offs, 0, 0); 10291e51764aSArtem Bityutskiy if (err) { 1030235c362bSSheng Yong ubifs_err(c, "expected node type %d", type); 10311e51764aSArtem Bityutskiy return err; 10321e51764aSArtem Bityutskiy } 10331e51764aSArtem Bityutskiy 10341e51764aSArtem Bityutskiy rlen = le32_to_cpu(ch->len); 10351e51764aSArtem Bityutskiy if (rlen != len) { 1036235c362bSSheng Yong ubifs_err(c, "bad node length %d, expected %d", rlen, len); 10371e51764aSArtem Bityutskiy goto out; 10381e51764aSArtem Bityutskiy } 10391e51764aSArtem Bityutskiy 10401e51764aSArtem Bityutskiy return 0; 10411e51764aSArtem Bityutskiy 10421e51764aSArtem Bityutskiy out: 1043235c362bSSheng Yong ubifs_err(c, "bad node at LEB %d:%d", lnum, offs); 1044edf6be24SArtem Bityutskiy ubifs_dump_node(c, buf); 10457c46d0aeSArtem Bityutskiy dump_stack(); 10461e51764aSArtem Bityutskiy return -EINVAL; 10471e51764aSArtem Bityutskiy } 10481e51764aSArtem Bityutskiy 10491e51764aSArtem Bityutskiy /** 10501e51764aSArtem Bityutskiy * ubifs_read_node - read node. 10511e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 10521e51764aSArtem Bityutskiy * @buf: buffer to read to 10531e51764aSArtem Bityutskiy * @type: node type 10541e51764aSArtem Bityutskiy * @len: node length (not aligned) 10551e51764aSArtem Bityutskiy * @lnum: logical eraseblock number 10561e51764aSArtem Bityutskiy * @offs: offset within the logical eraseblock 10571e51764aSArtem Bityutskiy * 1058b8f1da98SRandy Dunlap * This function reads a node of known type and length, checks it and 10591e51764aSArtem Bityutskiy * stores in @buf. Returns zero in case of success, %-EUCLEAN if CRC mismatched 10601e51764aSArtem Bityutskiy * and a negative error code in case of failure. 10611e51764aSArtem Bityutskiy */ 10621e51764aSArtem Bityutskiy int ubifs_read_node(const struct ubifs_info *c, void *buf, int type, int len, 10631e51764aSArtem Bityutskiy int lnum, int offs) 10641e51764aSArtem Bityutskiy { 10651e51764aSArtem Bityutskiy int err, l; 10661e51764aSArtem Bityutskiy struct ubifs_ch *ch = buf; 10671e51764aSArtem Bityutskiy 10681e51764aSArtem Bityutskiy dbg_io("LEB %d:%d, %s, length %d", lnum, offs, dbg_ntype(type), len); 10696eb61d58SRichard Weinberger ubifs_assert(c, lnum >= 0 && lnum < c->leb_cnt && offs >= 0); 10706eb61d58SRichard Weinberger ubifs_assert(c, len >= UBIFS_CH_SZ && offs + len <= c->leb_size); 10716eb61d58SRichard Weinberger ubifs_assert(c, !(offs & 7) && offs < c->leb_size); 10726eb61d58SRichard Weinberger ubifs_assert(c, type >= 0 && type < UBIFS_NODE_TYPES_CNT); 10731e51764aSArtem Bityutskiy 1074d304820aSArtem Bityutskiy err = ubifs_leb_read(c, lnum, buf, offs, len, 0); 1075d304820aSArtem Bityutskiy if (err && err != -EBADMSG) 10761e51764aSArtem Bityutskiy return err; 10771e51764aSArtem Bityutskiy 10781e51764aSArtem Bityutskiy if (type != ch->node_type) { 107990bea5a3SDaniel Golle ubifs_errc(c, "bad node type (%d but expected %d)", 10801e51764aSArtem Bityutskiy ch->node_type, type); 10811e51764aSArtem Bityutskiy goto out; 10821e51764aSArtem Bityutskiy } 10831e51764aSArtem Bityutskiy 10842953e73fSAdrian Hunter err = ubifs_check_node(c, buf, lnum, offs, 0, 0); 10851e51764aSArtem Bityutskiy if (err) { 108690bea5a3SDaniel Golle ubifs_errc(c, "expected node type %d", type); 10871e51764aSArtem Bityutskiy return err; 10881e51764aSArtem Bityutskiy } 10891e51764aSArtem Bityutskiy 10901e51764aSArtem Bityutskiy l = le32_to_cpu(ch->len); 10911e51764aSArtem Bityutskiy if (l != len) { 109290bea5a3SDaniel Golle ubifs_errc(c, "bad node length %d, expected %d", l, len); 10931e51764aSArtem Bityutskiy goto out; 10941e51764aSArtem Bityutskiy } 10951e51764aSArtem Bityutskiy 10961e51764aSArtem Bityutskiy return 0; 10971e51764aSArtem Bityutskiy 10981e51764aSArtem Bityutskiy out: 109990bea5a3SDaniel Golle ubifs_errc(c, "bad node at LEB %d:%d, LEB mapping status %d", lnum, 110090bea5a3SDaniel Golle offs, ubi_is_mapped(c->ubi, lnum)); 110190bea5a3SDaniel Golle if (!c->probing) { 1102edf6be24SArtem Bityutskiy ubifs_dump_node(c, buf); 11037c46d0aeSArtem Bityutskiy dump_stack(); 110490bea5a3SDaniel Golle } 11051e51764aSArtem Bityutskiy return -EINVAL; 11061e51764aSArtem Bityutskiy } 11071e51764aSArtem Bityutskiy 11081e51764aSArtem Bityutskiy /** 11091e51764aSArtem Bityutskiy * ubifs_wbuf_init - initialize write-buffer. 11101e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 11111e51764aSArtem Bityutskiy * @wbuf: write-buffer to initialize 11121e51764aSArtem Bityutskiy * 1113cb54ef8bSArtem Bityutskiy * This function initializes write-buffer. Returns zero in case of success 11141e51764aSArtem Bityutskiy * %-ENOMEM in case of failure. 11151e51764aSArtem Bityutskiy */ 11161e51764aSArtem Bityutskiy int ubifs_wbuf_init(struct ubifs_info *c, struct ubifs_wbuf *wbuf) 11171e51764aSArtem Bityutskiy { 11181e51764aSArtem Bityutskiy size_t size; 11191e51764aSArtem Bityutskiy 11206c7f74f7SArtem Bityutskiy wbuf->buf = kmalloc(c->max_write_size, GFP_KERNEL); 11211e51764aSArtem Bityutskiy if (!wbuf->buf) 11221e51764aSArtem Bityutskiy return -ENOMEM; 11231e51764aSArtem Bityutskiy 11246c7f74f7SArtem Bityutskiy size = (c->max_write_size / UBIFS_CH_SZ + 1) * sizeof(ino_t); 11251e51764aSArtem Bityutskiy wbuf->inodes = kmalloc(size, GFP_KERNEL); 11261e51764aSArtem Bityutskiy if (!wbuf->inodes) { 11271e51764aSArtem Bityutskiy kfree(wbuf->buf); 11281e51764aSArtem Bityutskiy wbuf->buf = NULL; 11291e51764aSArtem Bityutskiy return -ENOMEM; 11301e51764aSArtem Bityutskiy } 11311e51764aSArtem Bityutskiy 11321e51764aSArtem Bityutskiy wbuf->used = 0; 11331e51764aSArtem Bityutskiy wbuf->lnum = wbuf->offs = -1; 11346c7f74f7SArtem Bityutskiy /* 11356c7f74f7SArtem Bityutskiy * If the LEB starts at the max. write size aligned address, then 11366c7f74f7SArtem Bityutskiy * write-buffer size has to be set to @c->max_write_size. Otherwise, 11376c7f74f7SArtem Bityutskiy * set it to something smaller so that it ends at the closest max. 11386c7f74f7SArtem Bityutskiy * write size boundary. 11396c7f74f7SArtem Bityutskiy */ 11406c7f74f7SArtem Bityutskiy size = c->max_write_size - (c->leb_start % c->max_write_size); 11416c7f74f7SArtem Bityutskiy wbuf->avail = wbuf->size = size; 11421e51764aSArtem Bityutskiy wbuf->sync_callback = NULL; 11431e51764aSArtem Bityutskiy mutex_init(&wbuf->io_mutex); 11441e51764aSArtem Bityutskiy spin_lock_init(&wbuf->lock); 11451e51764aSArtem Bityutskiy wbuf->c = c; 11461e51764aSArtem Bityutskiy wbuf->next_ino = 0; 11471e51764aSArtem Bityutskiy 1148f2c5dbd7SArtem Bityutskiy hrtimer_init(&wbuf->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL); 1149f2c5dbd7SArtem Bityutskiy wbuf->timer.function = wbuf_timer_callback_nolock; 11501e51764aSArtem Bityutskiy return 0; 11511e51764aSArtem Bityutskiy } 11521e51764aSArtem Bityutskiy 11531e51764aSArtem Bityutskiy /** 11541e51764aSArtem Bityutskiy * ubifs_wbuf_add_ino_nolock - add an inode number into the wbuf inode array. 11551e51764aSArtem Bityutskiy * @wbuf: the write-buffer where to add 11561e51764aSArtem Bityutskiy * @inum: the inode number 11571e51764aSArtem Bityutskiy * 11581e51764aSArtem Bityutskiy * This function adds an inode number to the inode array of the write-buffer. 11591e51764aSArtem Bityutskiy */ 11601e51764aSArtem Bityutskiy void ubifs_wbuf_add_ino_nolock(struct ubifs_wbuf *wbuf, ino_t inum) 11611e51764aSArtem Bityutskiy { 11621e51764aSArtem Bityutskiy if (!wbuf->buf) 11631e51764aSArtem Bityutskiy /* NOR flash or something similar */ 11641e51764aSArtem Bityutskiy return; 11651e51764aSArtem Bityutskiy 11661e51764aSArtem Bityutskiy spin_lock(&wbuf->lock); 11671e51764aSArtem Bityutskiy if (wbuf->used) 11681e51764aSArtem Bityutskiy wbuf->inodes[wbuf->next_ino++] = inum; 11691e51764aSArtem Bityutskiy spin_unlock(&wbuf->lock); 11701e51764aSArtem Bityutskiy } 11711e51764aSArtem Bityutskiy 11721e51764aSArtem Bityutskiy /** 11731e51764aSArtem Bityutskiy * wbuf_has_ino - returns if the wbuf contains data from the inode. 11741e51764aSArtem Bityutskiy * @wbuf: the write-buffer 11751e51764aSArtem Bityutskiy * @inum: the inode number 11761e51764aSArtem Bityutskiy * 11771e51764aSArtem Bityutskiy * This function returns with %1 if the write-buffer contains some data from the 11781e51764aSArtem Bityutskiy * given inode otherwise it returns with %0. 11791e51764aSArtem Bityutskiy */ 11801e51764aSArtem Bityutskiy static int wbuf_has_ino(struct ubifs_wbuf *wbuf, ino_t inum) 11811e51764aSArtem Bityutskiy { 11821e51764aSArtem Bityutskiy int i, ret = 0; 11831e51764aSArtem Bityutskiy 11841e51764aSArtem Bityutskiy spin_lock(&wbuf->lock); 11851e51764aSArtem Bityutskiy for (i = 0; i < wbuf->next_ino; i++) 11861e51764aSArtem Bityutskiy if (inum == wbuf->inodes[i]) { 11871e51764aSArtem Bityutskiy ret = 1; 11881e51764aSArtem Bityutskiy break; 11891e51764aSArtem Bityutskiy } 11901e51764aSArtem Bityutskiy spin_unlock(&wbuf->lock); 11911e51764aSArtem Bityutskiy 11921e51764aSArtem Bityutskiy return ret; 11931e51764aSArtem Bityutskiy } 11941e51764aSArtem Bityutskiy 11951e51764aSArtem Bityutskiy /** 11961e51764aSArtem Bityutskiy * ubifs_sync_wbufs_by_inode - synchronize write-buffers for an inode. 11971e51764aSArtem Bityutskiy * @c: UBIFS file-system description object 11981e51764aSArtem Bityutskiy * @inode: inode to synchronize 11991e51764aSArtem Bityutskiy * 12001e51764aSArtem Bityutskiy * This function synchronizes write-buffers which contain nodes belonging to 12011e51764aSArtem Bityutskiy * @inode. Returns zero in case of success and a negative error code in case of 12021e51764aSArtem Bityutskiy * failure. 12031e51764aSArtem Bityutskiy */ 12041e51764aSArtem Bityutskiy int ubifs_sync_wbufs_by_inode(struct ubifs_info *c, struct inode *inode) 12051e51764aSArtem Bityutskiy { 12061e51764aSArtem Bityutskiy int i, err = 0; 12071e51764aSArtem Bityutskiy 12081e51764aSArtem Bityutskiy for (i = 0; i < c->jhead_cnt; i++) { 12091e51764aSArtem Bityutskiy struct ubifs_wbuf *wbuf = &c->jheads[i].wbuf; 12101e51764aSArtem Bityutskiy 12111e51764aSArtem Bityutskiy if (i == GCHD) 12121e51764aSArtem Bityutskiy /* 12131e51764aSArtem Bityutskiy * GC head is special, do not look at it. Even if the 12141e51764aSArtem Bityutskiy * head contains something related to this inode, it is 12151e51764aSArtem Bityutskiy * a _copy_ of corresponding on-flash node which sits 12161e51764aSArtem Bityutskiy * somewhere else. 12171e51764aSArtem Bityutskiy */ 12181e51764aSArtem Bityutskiy continue; 12191e51764aSArtem Bityutskiy 12201e51764aSArtem Bityutskiy if (!wbuf_has_ino(wbuf, inode->i_ino)) 12211e51764aSArtem Bityutskiy continue; 12221e51764aSArtem Bityutskiy 12231e51764aSArtem Bityutskiy mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead); 12241e51764aSArtem Bityutskiy if (wbuf_has_ino(wbuf, inode->i_ino)) 12251e51764aSArtem Bityutskiy err = ubifs_wbuf_sync_nolock(wbuf); 12261e51764aSArtem Bityutskiy mutex_unlock(&wbuf->io_mutex); 12271e51764aSArtem Bityutskiy 12281e51764aSArtem Bityutskiy if (err) { 12291e51764aSArtem Bityutskiy ubifs_ro_mode(c, err); 12301e51764aSArtem Bityutskiy return err; 12311e51764aSArtem Bityutskiy } 12321e51764aSArtem Bityutskiy } 12331e51764aSArtem Bityutskiy return 0; 12341e51764aSArtem Bityutskiy } 1235