fs/ubifs/io.c

   1 /*
   2  * This file is part of UBIFS.
   3  *
   4  * Copyright (C) 2006-2008 Nokia Corporation.
   5  * Copyright (C) 2006, 2007 University of Szeged, Hungary
   6  *
   7  * This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the GNU General Public License version 2 as published by
   9  * the Free Software Foundation.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program; if not, write to the Free Software Foundation, Inc., 51
  18  * Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  19  *
  20  * Authors: Artem Bityutskiy (Битюцкий Артём)
  21  *          Adrian Hunter
  22  *          Zoltan Sogor
  23  */
  24
  25 /*
  26  * This file implements UBIFS I/O subsystem which provides various I/O-related
  27  * helper functions (reading/writing/checking/validating nodes) and implements
  28  * write-buffering support. Write buffers help to save space which otherwise
  29  * would have been wasted for padding to the nearest minimal I/O unit boundary.
  30  * Instead, data first goes to the write-buffer and is flushed when the
  31  * buffer is full or when it is not used for some time (by timer). This is
  32  * similar to the mechanism is used by JFFS2.
  33  *
  34  * Write-buffers are defined by 'struct ubifs_wbuf' objects and protected by
  35  * mutexes defined inside these objects. Since sometimes upper-level code
  36  * has to lock the write-buffer (e.g. journal space reservation code), many
  37  * functions related to write-buffers have "nolock" suffix which means that the
  38  * caller has to lock the write-buffer before calling this function.
  39  *
  40  * UBIFS stores nodes at 64 bit-aligned addresses. If the node length is not
  41  * aligned, UBIFS starts the next node from the aligned address, and the padded
  42  * bytes may contain any rubbish. In other words, UBIFS does not put padding
  43  * bytes in those small gaps. Common headers of nodes store real node lengths,
  44  * not aligned lengths. Indexing nodes also store real lengths in branches.
  45  *
  46  * UBIFS uses padding when it pads to the next min. I/O unit. In this case it
  47  * uses padding nodes or padding bytes, if the padding node does not fit.
  48  *
  49  * All UBIFS nodes are protected by CRC checksums and UBIFS checks all nodes
  50  * every time they are read from the flash media.
  51  */
  52
  53 #include "ubifs.h"
  54
  55 /**
  56  * ubifs_ro_mode - switch UBIFS to read read-only mode.
  57  * @c: UBIFS file-system description object
  58  * @err: error code which is the reason of switching to R/O mode
  59  */
  60 void ubifs_ro_mode(struct ubifs_info *c, int err)
  61 {
  62         if (!c->ro_media) {
  63                 c->ro_media = 1;
  64                 c->no_chk_data_crc = 0;
  65                 ubifs_warn("switched to read-only mode, error %d", err);
  66                 dbg_dump_stack();
  67         }
  68 }
  69
  70 /**
  71  * ubifs_check_node - check node.
  72  * @c: UBIFS file-system description object
  73  * @buf: node to check
  74  * @lnum: logical eraseblock number
  75  * @offs: offset within the logical eraseblock
  76  * @quiet: print no messages
  77  * @must_chk_crc: indicates whether to always check the CRC
  78  *
  79  * This function checks node magic number and CRC checksum. This function also
  80  * validates node length to prevent UBIFS from becoming crazy when an attacker
  81  * feeds it a file-system image with incorrect nodes. For example, too large
  82  * node length in the common header could cause UBIFS to read memory outside of
  83  * allocated buffer when checking the CRC checksum.
  84  *
  85  * This function may skip data nodes CRC checking if @c->no_chk_data_crc is
  86  * true, which is controlled by corresponding UBIFS mount option. However, if
  87  * @must_chk_crc is true, then @c->no_chk_data_crc is ignored and CRC is
  88  * checked. Similarly, if @c->always_chk_crc is true, @c->no_chk_data_crc is
  89  * ignored and CRC is checked.
  90  *
  91  * This function returns zero in case of success and %-EUCLEAN in case of bad
  92  * CRC or magic.
  93  */
  94 int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum,
  95                      int offs, int quiet, int must_chk_crc)
  96 {
  97         int err = -EINVAL, type, node_len;
  98         uint32_t crc, node_crc, magic;
  99         const struct ubifs_ch *ch = buf;
 100
 101         ubifs_assert(lnum >= 0 && lnum < c->leb_cnt && offs >= 0);
 102         ubifs_assert(!(offs & 7) && offs < c->leb_size);
 103
 104         magic = le32_to_cpu(ch->magic);
 105         if (magic != UBIFS_NODE_MAGIC) {
 106                 if (!quiet)
 107                         ubifs_err("bad magic %#08x, expected %#08x",
 108                                   magic, UBIFS_NODE_MAGIC);
 109                 err = -EUCLEAN;
 110                 goto out;
 111         }
 112
 113         type = ch->node_type;
 114         if (type < 0 || type >= UBIFS_NODE_TYPES_CNT) {
 115                 if (!quiet)
 116                         ubifs_err("bad node type %d", type);
 117                 goto out;
 118         }
 119
 120         node_len = le32_to_cpu(ch->len);
 121         if (node_len + offs > c->leb_size)
 122                 goto out_len;
 123
 124         if (c->ranges[type].max_len == 0) {
 125                 if (node_len != c->ranges[type].len)
 126                         goto out_len;
 127         } else if (node_len < c->ranges[type].min_len ||
 128                    node_len > c->ranges[type].max_len)
 129                 goto out_len;
 130
 131         if (!must_chk_crc && type == UBIFS_DATA_NODE && !c->always_chk_crc &&
 132              c->no_chk_data_crc)
 133                 return 0;
 134
 135         crc = crc32(UBIFS_CRC32_INIT, buf + 8, node_len - 8);
 136         node_crc = le32_to_cpu(ch->crc);
 137         if (crc != node_crc) {
 138                 if (!quiet)
 139                         ubifs_err("bad CRC: calculated %#08x, read %#08x",
 140                                   crc, node_crc);
 141                 err = -EUCLEAN;
 142                 goto out;
 143         }
 144
 145         return 0;
 146
 147 out_len:
 148         if (!quiet)
 149                 ubifs_err("bad node length %d", node_len);
 150 out:
 151         if (!quiet) {
 152                 ubifs_err("bad node at LEB %d:%d", lnum, offs);
 153                 dbg_dump_node(c, buf);
 154                 dbg_dump_stack();
 155         }
 156         return err;
 157 }
 158
 159 /**
 160  * ubifs_pad - pad flash space.
 161  * @c: UBIFS file-system description object
 162  * @buf: buffer to put padding to
 163  * @pad: how many bytes to pad
 164  *
 165  * The flash media obliges us to write only in chunks of %c->min_io_size and
 166  * when we have to write less data we add padding node to the write-buffer and
 167  * pad it to the next minimal I/O unit's boundary. Padding nodes help when the
 168  * media is being scanned. If the amount of wasted space is not enough to fit a
 169  * padding node which takes %UBIFS_PAD_NODE_SZ bytes, we write padding bytes
 170  * pattern (%UBIFS_PADDING_BYTE).
 171  *
 172  * Padding nodes are also used to fill gaps when the "commit-in-gaps" method is
 173  * used.
 174  */
 175 void ubifs_pad(const struct ubifs_info *c, void *buf, int pad)
 176 {
 177         uint32_t crc;
 178
 179         ubifs_assert(pad >= 0 && !(pad & 7));
 180
 181         if (pad >= UBIFS_PAD_NODE_SZ) {
 182                 struct ubifs_ch *ch = buf;
 183                 struct ubifs_pad_node *pad_node = buf;
 184
 185                 ch->magic = cpu_to_le32(UBIFS_NODE_MAGIC);
 186                 ch->node_type = UBIFS_PAD_NODE;
 187                 ch->group_type = UBIFS_NO_NODE_GROUP;
 188                 ch->padding[0] = ch->padding[1] = 0;
 189                 ch->sqnum = 0;
 190                 ch->len = cpu_to_le32(UBIFS_PAD_NODE_SZ);
 191                 pad -= UBIFS_PAD_NODE_SZ;
 192                 pad_node->pad_len = cpu_to_le32(pad);
 193                 crc = crc32(UBIFS_CRC32_INIT, buf + 8, UBIFS_PAD_NODE_SZ - 8);
 194                 ch->crc = cpu_to_le32(crc);
 195                 memset(buf + UBIFS_PAD_NODE_SZ, 0, pad);
 196         } else if (pad > 0)
 197                 /* Too little space, padding node won't fit */
 198                 memset(buf, UBIFS_PADDING_BYTE, pad);
 199 }
 200
 201 /**
 202  * next_sqnum - get next sequence number.
 203  * @c: UBIFS file-system description object
 204  */
 205 static unsigned long long next_sqnum(struct ubifs_info *c)
 206 {
 207         unsigned long long sqnum;
 208
 209         spin_lock(&c->cnt_lock);
 210         sqnum = ++c->max_sqnum;
 211         spin_unlock(&c->cnt_lock);
 212
 213         if (unlikely(sqnum >= SQNUM_WARN_WATERMARK)) {
 214                 if (sqnum >= SQNUM_WATERMARK) {
 215                         ubifs_err("sequence number overflow %llu, end of life",
 216                                   sqnum);
 217                         ubifs_ro_mode(c, -EINVAL);
 218                 }
 219                 ubifs_warn("running out of sequence numbers, end of life soon");
 220         }
 221
 222         return sqnum;
 223 }
 224
 225 /**
 226  * ubifs_prepare_node - prepare node to be written to flash.
 227  * @c: UBIFS file-system description object
 228  * @node: the node to pad
 229  * @len: node length
 230  * @pad: if the buffer has to be padded
 231  *
 232  * This function prepares node at @node to be written to the media - it
 233  * calculates node CRC, fills the common header, and adds proper padding up to
 234  * the next minimum I/O unit if @pad is not zero.
 235  */
 236 void ubifs_prepare_node(struct ubifs_info *c, void *node, int len, int pad)
 237 {
 238         uint32_t crc;
 239         struct ubifs_ch *ch = node;
 240         unsigned long long sqnum = next_sqnum(c);
 241
 242         ubifs_assert(len >= UBIFS_CH_SZ);
 243
 244         ch->magic = cpu_to_le32(UBIFS_NODE_MAGIC);
 245         ch->len = cpu_to_le32(len);
 246         ch->group_type = UBIFS_NO_NODE_GROUP;
 247         ch->sqnum = cpu_to_le64(sqnum);
 248         ch->padding[0] = ch->padding[1] = 0;
 249         crc = crc32(UBIFS_CRC32_INIT, node + 8, len - 8);
 250         ch->crc = cpu_to_le32(crc);
 251
 252         if (pad) {
 253                 len = ALIGN(len, 8);
 254                 pad = ALIGN(len, c->min_io_size) - len;
 255                 ubifs_pad(c, node + len, pad);
 256         }
 257 }
 258
 259 /**
 260  * ubifs_read_node - read node.
 261  * @c: UBIFS file-system description object
 262  * @buf: buffer to read to
 263  * @type: node type
 264  * @len: node length (not aligned)
 265  * @lnum: logical eraseblock number
 266  * @offs: offset within the logical eraseblock
 267  *
 268  * This function reads a node of known type and and length, checks it and
 269  * stores in @buf. Returns zero in case of success, %-EUCLEAN if CRC mismatched
 270  * and a negative error code in case of failure.
 271  */
 272 int ubifs_read_node(const struct ubifs_info *c, void *buf, int type, int len,
 273                     int lnum, int offs)
 274 {
 275         int err, l;
 276         struct ubifs_ch *ch = buf;
 277
 278         dbg_io("LEB %d:%d, %s, length %d", lnum, offs, dbg_ntype(type), len);
 279         ubifs_assert(lnum >= 0 && lnum < c->leb_cnt && offs >= 0);
 280         ubifs_assert(len >= UBIFS_CH_SZ && offs + len <= c->leb_size);
 281         ubifs_assert(!(offs & 7) && offs < c->leb_size);
 282         ubifs_assert(type >= 0 && type < UBIFS_NODE_TYPES_CNT);
 283
 284         err = ubi_read(c->ubi, lnum, buf, offs, len);
 285         if (err && err != -EBADMSG) {
 286                 ubifs_err("cannot read node %d from LEB %d:%d, error %d",
 287                           type, lnum, offs, err);
 288                 return err;
 289         }
 290
 291         if (type != ch->node_type) {
 292                 ubifs_err("bad node type (%d but expected %d)",
 293                           ch->node_type, type);
 294                 goto out;
 295         }
 296
 297         err = ubifs_check_node(c, buf, lnum, offs, 0, 0);
 298         if (err) {
 299                 ubifs_err("expected node type %d", type);
 300                 return err;
 301         }
 302
 303         l = le32_to_cpu(ch->len);
 304         if (l != len) {
 305                 ubifs_err("bad node length %d, expected %d", l, len);
 306                 goto out;
 307         }
 308
 309         return 0;
 310
 311 out:
 312         ubifs_err("bad node at LEB %d:%d", lnum, offs);
 313         dbg_dump_node(c, buf);
 314         dbg_dump_stack();
 315         return -EINVAL;
 316 }