fs/ubifs/io.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * This file is part of UBIFS.
   4  *
   5  * Copyright (C) 2006-2008 Nokia Corporation.
   6  * Copyright (C) 2006, 2007 University of Szeged, Hungary
   7  *
   8  * Authors: Artem Bityutskiy (Битюцкий Артём)
   9  *          Adrian Hunter
  10  *          Zoltan Sogor
  11  */
  12
  13 /*
  14  * This file implements UBIFS I/O subsystem which provides various I/O-related
  15  * helper functions (reading/writing/checking/validating nodes) and implements
  16  * write-buffering support. Write buffers help to save space which otherwise
  17  * would have been wasted for padding to the nearest minimal I/O unit boundary.
  18  * Instead, data first goes to the write-buffer and is flushed when the
  19  * buffer is full or when it is not used for some time (by timer). This is
  20  * similar to the mechanism is used by JFFS2.
  21  *
  22  * UBIFS distinguishes between minimum write size (@c->min_io_size) and maximum
  23  * write size (@c->max_write_size). The latter is the maximum amount of bytes
  24  * the underlying flash is able to program at a time, and writing in
  25  * @c->max_write_size units should presumably be faster. Obviously,
  26  * @c->min_io_size <= @c->max_write_size. Write-buffers are of
  27  * @c->max_write_size bytes in size for maximum performance. However, when a
  28  * write-buffer is flushed, only the portion of it (aligned to @c->min_io_size
  29  * boundary) which contains data is written, not the whole write-buffer,
  30  * because this is more space-efficient.
  31  *
  32  * This optimization adds few complications to the code. Indeed, on the one
  33  * hand, we want to write in optimal @c->max_write_size bytes chunks, which
  34  * also means aligning writes at the @c->max_write_size bytes offsets. On the
  35  * other hand, we do not want to waste space when synchronizing the write
  36  * buffer, so during synchronization we writes in smaller chunks. And this makes
  37  * the next write offset to be not aligned to @c->max_write_size bytes. So the
  38  * have to make sure that the write-buffer offset (@wbuf->offs) becomes aligned
  39  * to @c->max_write_size bytes again. We do this by temporarily shrinking
  40  * write-buffer size (@wbuf->size).
  41  *
  42  * Write-buffers are defined by 'struct ubifs_wbuf' objects and protected by
  43  * mutexes defined inside these objects. Since sometimes upper-level code
  44  * has to lock the write-buffer (e.g. journal space reservation code), many
  45  * functions related to write-buffers have "nolock" suffix which means that the
  46  * caller has to lock the write-buffer before calling this function.
  47  *
  48  * UBIFS stores nodes at 64 bit-aligned addresses. If the node length is not
  49  * aligned, UBIFS starts the next node from the aligned address, and the padded
  50  * bytes may contain any rubbish. In other words, UBIFS does not put padding
  51  * bytes in those small gaps. Common headers of nodes store real node lengths,
  52  * not aligned lengths. Indexing nodes also store real lengths in branches.
  53  *
  54  * UBIFS uses padding when it pads to the next min. I/O unit. In this case it
  55  * uses padding nodes or padding bytes, if the padding node does not fit.
  56  *
  57  * All UBIFS nodes are protected by CRC checksums and UBIFS checks CRC when
  58  * they are read from the flash media.
  59  */
  60
  61 #ifndef __UBOOT__
  62 #include <dm/devres.h>
  63 #include <linux/crc32.h>
  64 #include <linux/slab.h>
  65 #include <u-boot/crc.h>
  66 #else
  67 #include <linux/compat.h>
  68 #include <linux/err.h>
  69 #endif
  70 #include "ubifs.h"
  71
  72 /**
  73  * ubifs_ro_mode - switch UBIFS to read read-only mode.
  74  * @c: UBIFS file-system description object
  75  * @err: error code which is the reason of switching to R/O mode
  76  */
  77 void ubifs_ro_mode(struct ubifs_info *c, int err)
  78 {
  79         if (!c->ro_error) {
  80                 c->ro_error = 1;
  81                 c->no_chk_data_crc = 0;
  82                 c->vfs_sb->s_flags |= MS_RDONLY;
  83                 ubifs_warn(c, "switched to read-only mode, error %d", err);
  84                 dump_stack();
  85         }
  86 }
  87
  88 /*
  89  * Below are simple wrappers over UBI I/O functions which include some
  90  * additional checks and UBIFS debugging stuff. See corresponding UBI function
  91  * for more information.
  92  */
  93
  94 int ubifs_leb_read(const struct ubifs_info *c, int lnum, void *buf, int offs,
  95                    int len, int even_ebadmsg)
  96 {
  97         int err;
  98
  99         err = ubi_read(c->ubi, lnum, buf, offs, len);
 100         /*
 101          * In case of %-EBADMSG print the error message only if the
 102          * @even_ebadmsg is true.
 103          */
 104         if (err && (err != -EBADMSG || even_ebadmsg)) {
 105                 ubifs_err(c, "reading %d bytes from LEB %d:%d failed, error %d",
 106                           len, lnum, offs, err);
 107                 dump_stack();
 108         }
 109         return err;
 110 }
 111
 112 int ubifs_leb_write(struct ubifs_info *c, int lnum, const void *buf, int offs,
 113                     int len)
 114 {
 115         int err;
 116
 117         ubifs_assert(!c->ro_media && !c->ro_mount);
 118         if (c->ro_error)
 119                 return -EROFS;
 120         if (!dbg_is_tst_rcvry(c))
 121                 err = ubi_leb_write(c->ubi, lnum, buf, offs, len);
 122 #ifndef __UBOOT__
 123         else
 124                 err = dbg_leb_write(c, lnum, buf, offs, len);
 125 #endif
 126         if (err) {
 127                 ubifs_err(c, "writing %d bytes to LEB %d:%d failed, error %d",
 128                           len, lnum, offs, err);
 129                 ubifs_ro_mode(c, err);
 130                 dump_stack();
 131         }
 132         return err;
 133 }
 134
 135 int ubifs_leb_change(struct ubifs_info *c, int lnum, const void *buf, int len)
 136 {
 137         int err;
 138
 139         ubifs_assert(!c->ro_media && !c->ro_mount);
 140         if (c->ro_error)
 141                 return -EROFS;
 142         if (!dbg_is_tst_rcvry(c))
 143                 err = ubi_leb_change(c->ubi, lnum, buf, len);
 144 #ifndef __UBOOT__
 145         else
 146                 err = dbg_leb_change(c, lnum, buf, len);
 147 #endif
 148         if (err) {
 149                 ubifs_err(c, "changing %d bytes in LEB %d failed, error %d",
 150                           len, lnum, err);
 151                 ubifs_ro_mode(c, err);
 152                 dump_stack();
 153         }
 154         return err;
 155 }
 156
 157 int ubifs_leb_unmap(struct ubifs_info *c, int lnum)
 158 {
 159         int err;
 160
 161         ubifs_assert(!c->ro_media && !c->ro_mount);
 162         if (c->ro_error)
 163                 return -EROFS;
 164         if (!dbg_is_tst_rcvry(c))
 165                 err = ubi_leb_unmap(c->ubi, lnum);
 166 #ifndef __UBOOT__
 167         else
 168                 err = dbg_leb_unmap(c, lnum);
 169 #endif
 170         if (err) {
 171                 ubifs_err(c, "unmap LEB %d failed, error %d", lnum, err);
 172                 ubifs_ro_mode(c, err);
 173                 dump_stack();
 174         }
 175         return err;
 176 }
 177
 178 int ubifs_leb_map(struct ubifs_info *c, int lnum)
 179 {
 180         int err;
 181
 182         ubifs_assert(!c->ro_media && !c->ro_mount);
 183         if (c->ro_error)
 184                 return -EROFS;
 185         if (!dbg_is_tst_rcvry(c))
 186                 err = ubi_leb_map(c->ubi, lnum);
 187 #ifndef __UBOOT__
 188         else
 189                 err = dbg_leb_map(c, lnum);
 190 #endif
 191         if (err) {
 192                 ubifs_err(c, "mapping LEB %d failed, error %d", lnum, err);
 193                 ubifs_ro_mode(c, err);
 194                 dump_stack();
 195         }
 196         return err;
 197 }
 198
 199 int ubifs_is_mapped(const struct ubifs_info *c, int lnum)
 200 {
 201         int err;
 202
 203         err = ubi_is_mapped(c->ubi, lnum);
 204         if (err < 0) {
 205                 ubifs_err(c, "ubi_is_mapped failed for LEB %d, error %d",
 206                           lnum, err);
 207                 dump_stack();
 208         }
 209         return err;
 210 }
 211
 212 /**
 213  * ubifs_check_node - check node.
 214  * @c: UBIFS file-system description object
 215  * @buf: node to check
 216  * @lnum: logical eraseblock number
 217  * @offs: offset within the logical eraseblock
 218  * @quiet: print no messages
 219  * @must_chk_crc: indicates whether to always check the CRC
 220  *
 221  * This function checks node magic number and CRC checksum. This function also
 222  * validates node length to prevent UBIFS from becoming crazy when an attacker
 223  * feeds it a file-system image with incorrect nodes. For example, too large
 224  * node length in the common header could cause UBIFS to read memory outside of
 225  * allocated buffer when checking the CRC checksum.
 226  *
 227  * This function may skip data nodes CRC checking if @c->no_chk_data_crc is
 228  * true, which is controlled by corresponding UBIFS mount option. However, if
 229  * @must_chk_crc is true, then @c->no_chk_data_crc is ignored and CRC is
 230  * checked. Similarly, if @c->mounting or @c->remounting_rw is true (we are
 231  * mounting or re-mounting to R/W mode), @c->no_chk_data_crc is ignored and CRC
 232  * is checked. This is because during mounting or re-mounting from R/O mode to
 233  * R/W mode we may read journal nodes (when replying the journal or doing the
 234  * recovery) and the journal nodes may potentially be corrupted, so checking is
 235  * required.
 236  *
 237  * This function returns zero in case of success and %-EUCLEAN in case of bad
 238  * CRC or magic.
 239  */
 240 int ubifs_check_node(const struct ubifs_info *c, const void *buf, int lnum,
 241                      int offs, int quiet, int must_chk_crc)
 242 {
 243         int err = -EINVAL, type, node_len;
 244         uint32_t crc, node_crc, magic;
 245         const struct ubifs_ch *ch = buf;
 246
 247         ubifs_assert(lnum >= 0 && lnum < c->leb_cnt && offs >= 0);
 248         ubifs_assert(!(offs & 7) && offs < c->leb_size);
 249
 250         magic = le32_to_cpu(ch->magic);
 251         if (magic != UBIFS_NODE_MAGIC) {
 252                 if (!quiet)
 253                         ubifs_err(c, "bad magic %#08x, expected %#08x",
 254                                   magic, UBIFS_NODE_MAGIC);
 255                 err = -EUCLEAN;
 256                 goto out;
 257         }
 258
 259         type = ch->node_type;
 260         if (type < 0 || type >= UBIFS_NODE_TYPES_CNT) {
 261                 if (!quiet)
 262                         ubifs_err(c, "bad node type %d", type);
 263                 goto out;
 264         }
 265
 266         node_len = le32_to_cpu(ch->len);
 267         if (node_len + offs > c->leb_size)
 268                 goto out_len;
 269
 270         if (c->ranges[type].max_len == 0) {
 271                 if (node_len != c->ranges[type].len)
 272                         goto out_len;
 273         } else if (node_len < c->ranges[type].min_len ||
 274                    node_len > c->ranges[type].max_len)
 275                 goto out_len;
 276
 277         if (!must_chk_crc && type == UBIFS_DATA_NODE && !c->mounting &&
 278             !c->remounting_rw && c->no_chk_data_crc)
 279                 return 0;
 280
 281         crc = crc32(UBIFS_CRC32_INIT, buf + 8, node_len - 8);
 282         node_crc = le32_to_cpu(ch->crc);
 283         if (crc != node_crc) {
 284                 if (!quiet)
 285                         ubifs_err(c, "bad CRC: calculated %#08x, read %#08x",
 286                                   crc, node_crc);
 287                 err = -EUCLEAN;
 288                 goto out;
 289         }
 290
 291         return 0;
 292
 293 out_len:
 294         if (!quiet)
 295                 ubifs_err(c, "bad node length %d", node_len);
 296 out:
 297         if (!quiet) {
 298                 ubifs_err(c, "bad node at LEB %d:%d", lnum, offs);
 299                 ubifs_dump_node(c, buf);
 300                 dump_stack();
 301         }
 302         return err;
 303 }
 304
 305 /**
 306  * ubifs_pad - pad flash space.
 307  * @c: UBIFS file-system description object
 308  * @buf: buffer to put padding to
 309  * @pad: how many bytes to pad
 310  *
 311  * The flash media obliges us to write only in chunks of %c->min_io_size and
 312  * when we have to write less data we add padding node to the write-buffer and
 313  * pad it to the next minimal I/O unit's boundary. Padding nodes help when the
 314  * media is being scanned. If the amount of wasted space is not enough to fit a
 315  * padding node which takes %UBIFS_PAD_NODE_SZ bytes, we write padding bytes
 316  * pattern (%UBIFS_PADDING_BYTE).
 317  *
 318  * Padding nodes are also used to fill gaps when the "commit-in-gaps" method is
 319  * used.
 320  */
 321 void ubifs_pad(const struct ubifs_info *c, void *buf, int pad)
 322 {
 323         uint32_t crc;
 324
 325         ubifs_assert(pad >= 0 && !(pad & 7));
 326
 327         if (pad >= UBIFS_PAD_NODE_SZ) {
 328                 struct ubifs_ch *ch = buf;
 329                 struct ubifs_pad_node *pad_node = buf;
 330
 331                 ch->magic = cpu_to_le32(UBIFS_NODE_MAGIC);
 332                 ch->node_type = UBIFS_PAD_NODE;
 333                 ch->group_type = UBIFS_NO_NODE_GROUP;
 334                 ch->padding[0] = ch->padding[1] = 0;
 335                 ch->sqnum = 0;
 336                 ch->len = cpu_to_le32(UBIFS_PAD_NODE_SZ);
 337                 pad -= UBIFS_PAD_NODE_SZ;
 338                 pad_node->pad_len = cpu_to_le32(pad);
 339                 crc = crc32(UBIFS_CRC32_INIT, buf + 8, UBIFS_PAD_NODE_SZ - 8);
 340                 ch->crc = cpu_to_le32(crc);
 341                 memset(buf + UBIFS_PAD_NODE_SZ, 0, pad);
 342         } else if (pad > 0)
 343                 /* Too little space, padding node won't fit */
 344                 memset(buf, UBIFS_PADDING_BYTE, pad);
 345 }
 346
 347 /**
 348  * next_sqnum - get next sequence number.
 349  * @c: UBIFS file-system description object
 350  */
 351 static unsigned long long next_sqnum(struct ubifs_info *c)
 352 {
 353         unsigned long long sqnum;
 354
 355         spin_lock(&c->cnt_lock);
 356         sqnum = ++c->max_sqnum;
 357         spin_unlock(&c->cnt_lock);
 358
 359         if (unlikely(sqnum >= SQNUM_WARN_WATERMARK)) {
 360                 if (sqnum >= SQNUM_WATERMARK) {
 361                         ubifs_err(c, "sequence number overflow %llu, end of life",
 362                                   sqnum);
 363                         ubifs_ro_mode(c, -EINVAL);
 364                 }
 365                 ubifs_warn(c, "running out of sequence numbers, end of life soon");
 366         }
 367
 368         return sqnum;
 369 }
 370
 371 /**
 372  * ubifs_prepare_node - prepare node to be written to flash.
 373  * @c: UBIFS file-system description object
 374  * @node: the node to pad
 375  * @len: node length
 376  * @pad: if the buffer has to be padded
 377  *
 378  * This function prepares node at @node to be written to the media - it
 379  * calculates node CRC, fills the common header, and adds proper padding up to
 380  * the next minimum I/O unit if @pad is not zero.
 381  */
 382 void ubifs_prepare_node(struct ubifs_info *c, void *node, int len, int pad)
 383 {
 384         uint32_t crc;
 385         struct ubifs_ch *ch = node;
 386         unsigned long long sqnum = next_sqnum(c);
 387
 388         ubifs_assert(len >= UBIFS_CH_SZ);
 389
 390         ch->magic = cpu_to_le32(UBIFS_NODE_MAGIC);
 391         ch->len = cpu_to_le32(len);
 392         ch->group_type = UBIFS_NO_NODE_GROUP;
 393         ch->sqnum = cpu_to_le64(sqnum);
 394         ch->padding[0] = ch->padding[1] = 0;
 395         crc = crc32(UBIFS_CRC32_INIT, node + 8, len - 8);
 396         ch->crc = cpu_to_le32(crc);
 397
 398         if (pad) {
 399                 len = ALIGN(len, 8);
 400                 pad = ALIGN(len, c->min_io_size) - len;
 401                 ubifs_pad(c, node + len, pad);
 402         }
 403 }
 404
 405 /**
 406  * ubifs_prep_grp_node - prepare node of a group to be written to flash.
 407  * @c: UBIFS file-system description object
 408  * @node: the node to pad
 409  * @len: node length
 410  * @last: indicates the last node of the group
 411  *
 412  * This function prepares node at @node to be written to the media - it
 413  * calculates node CRC and fills the common header.
 414  */
 415 void ubifs_prep_grp_node(struct ubifs_info *c, void *node, int len, int last)
 416 {
 417         uint32_t crc;
 418         struct ubifs_ch *ch = node;
 419         unsigned long long sqnum = next_sqnum(c);
 420
 421         ubifs_assert(len >= UBIFS_CH_SZ);
 422
 423         ch->magic = cpu_to_le32(UBIFS_NODE_MAGIC);
 424         ch->len = cpu_to_le32(len);
 425         if (last)
 426                 ch->group_type = UBIFS_LAST_OF_NODE_GROUP;
 427         else
 428                 ch->group_type = UBIFS_IN_NODE_GROUP;
 429         ch->sqnum = cpu_to_le64(sqnum);
 430         ch->padding[0] = ch->padding[1] = 0;
 431         crc = crc32(UBIFS_CRC32_INIT, node + 8, len - 8);
 432         ch->crc = cpu_to_le32(crc);
 433 }
 434
 435 #ifndef __UBOOT__
 436 /**
 437  * wbuf_timer_callback - write-buffer timer callback function.
 438  * @timer: timer data (write-buffer descriptor)
 439  *
 440  * This function is called when the write-buffer timer expires.
 441  */
 442 static enum hrtimer_restart wbuf_timer_callback_nolock(struct hrtimer *timer)
 443 {
 444         struct ubifs_wbuf *wbuf = container_of(timer, struct ubifs_wbuf, timer);
 445
 446         dbg_io("jhead %s", dbg_jhead(wbuf->jhead));
 447         wbuf->need_sync = 1;
 448         wbuf->c->need_wbuf_sync = 1;
 449         ubifs_wake_up_bgt(wbuf->c);
 450         return HRTIMER_NORESTART;
 451 }
 452
 453 /**
 454  * new_wbuf_timer - start new write-buffer timer.
 455  * @wbuf: write-buffer descriptor
 456  */
 457 static void new_wbuf_timer_nolock(struct ubifs_wbuf *wbuf)
 458 {
 459         ubifs_assert(!hrtimer_active(&wbuf->timer));
 460
 461         if (wbuf->no_timer)
 462                 return;
 463         dbg_io("set timer for jhead %s, %llu-%llu millisecs",
 464                dbg_jhead(wbuf->jhead),
 465                div_u64(ktime_to_ns(wbuf->softlimit), USEC_PER_SEC),
 466                div_u64(ktime_to_ns(wbuf->softlimit) + wbuf->delta,
 467                        USEC_PER_SEC));
 468         hrtimer_start_range_ns(&wbuf->timer, wbuf->softlimit, wbuf->delta,
 469                                HRTIMER_MODE_REL);
 470 }
 471 #endif
 472
 473 /**
 474  * cancel_wbuf_timer - cancel write-buffer timer.
 475  * @wbuf: write-buffer descriptor
 476  */
 477 static void cancel_wbuf_timer_nolock(struct ubifs_wbuf *wbuf)
 478 {
 479         if (wbuf->no_timer)
 480                 return;
 481         wbuf->need_sync = 0;
 482 #ifndef __UBOOT__
 483         hrtimer_cancel(&wbuf->timer);
 484 #endif
 485 }
 486
 487 /**
 488  * ubifs_wbuf_sync_nolock - synchronize write-buffer.
 489  * @wbuf: write-buffer to synchronize
 490  *
 491  * This function synchronizes write-buffer @buf and returns zero in case of
 492  * success or a negative error code in case of failure.
 493  *
 494  * Note, although write-buffers are of @c->max_write_size, this function does
 495  * not necessarily writes all @c->max_write_size bytes to the flash. Instead,
 496  * if the write-buffer is only partially filled with data, only the used part
 497  * of the write-buffer (aligned on @c->min_io_size boundary) is synchronized.
 498  * This way we waste less space.
 499  */
 500 int ubifs_wbuf_sync_nolock(struct ubifs_wbuf *wbuf)
 501 {
 502         struct ubifs_info *c = wbuf->c;
 503         int err, dirt, sync_len;
 504
 505         cancel_wbuf_timer_nolock(wbuf);
 506         if (!wbuf->used || wbuf->lnum == -1)
 507                 /* Write-buffer is empty or not seeked */
 508                 return 0;
 509
 510         dbg_io("LEB %d:%d, %d bytes, jhead %s",
 511                wbuf->lnum, wbuf->offs, wbuf->used, dbg_jhead(wbuf->jhead));
 512         ubifs_assert(!(wbuf->avail & 7));
 513         ubifs_assert(wbuf->offs + wbuf->size <= c->leb_size);
 514         ubifs_assert(wbuf->size >= c->min_io_size);
 515         ubifs_assert(wbuf->size <= c->max_write_size);
 516         ubifs_assert(wbuf->size % c->min_io_size == 0);
 517         ubifs_assert(!c->ro_media && !c->ro_mount);
 518         if (c->leb_size - wbuf->offs >= c->max_write_size)
 519                 ubifs_assert(!((wbuf->offs + wbuf->size) % c->max_write_size));
 520
 521         if (c->ro_error)
 522                 return -EROFS;
 523
 524         /*
 525          * Do not write whole write buffer but write only the minimum necessary
 526          * amount of min. I/O units.
 527          */
 528         sync_len = ALIGN(wbuf->used, c->min_io_size);
 529         dirt = sync_len - wbuf->used;
 530         if (dirt)
 531                 ubifs_pad(c, wbuf->buf + wbuf->used, dirt);
 532         err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf, wbuf->offs, sync_len);
 533         if (err)
 534                 return err;
 535
 536         spin_lock(&wbuf->lock);
 537         wbuf->offs += sync_len;
 538         /*
 539          * Now @wbuf->offs is not necessarily aligned to @c->max_write_size.
 540          * But our goal is to optimize writes and make sure we write in
 541          * @c->max_write_size chunks and to @c->max_write_size-aligned offset.
 542          * Thus, if @wbuf->offs is not aligned to @c->max_write_size now, make
 543          * sure that @wbuf->offs + @wbuf->size is aligned to
 544          * @c->max_write_size. This way we make sure that after next
 545          * write-buffer flush we are again at the optimal offset (aligned to
 546          * @c->max_write_size).
 547          */
 548         if (c->leb_size - wbuf->offs < c->max_write_size)
 549                 wbuf->size = c->leb_size - wbuf->offs;
 550         else if (wbuf->offs & (c->max_write_size - 1))
 551                 wbuf->size = ALIGN(wbuf->offs, c->max_write_size) - wbuf->offs;
 552         else
 553                 wbuf->size = c->max_write_size;
 554         wbuf->avail = wbuf->size;
 555         wbuf->used = 0;
 556         wbuf->next_ino = 0;
 557         spin_unlock(&wbuf->lock);
 558
 559         if (wbuf->sync_callback)
 560                 err = wbuf->sync_callback(c, wbuf->lnum,
 561                                           c->leb_size - wbuf->offs, dirt);
 562         return err;
 563 }
 564
 565 /**
 566  * ubifs_wbuf_seek_nolock - seek write-buffer.
 567  * @wbuf: write-buffer
 568  * @lnum: logical eraseblock number to seek to
 569  * @offs: logical eraseblock offset to seek to
 570  *
 571  * This function targets the write-buffer to logical eraseblock @lnum:@offs.
 572  * The write-buffer has to be empty. Returns zero in case of success and a
 573  * negative error code in case of failure.
 574  */
 575 int ubifs_wbuf_seek_nolock(struct ubifs_wbuf *wbuf, int lnum, int offs)
 576 {
 577         const struct ubifs_info *c = wbuf->c;
 578
 579         dbg_io("LEB %d:%d, jhead %s", lnum, offs, dbg_jhead(wbuf->jhead));
 580         ubifs_assert(lnum >= 0 && lnum < c->leb_cnt);
 581         ubifs_assert(offs >= 0 && offs <= c->leb_size);
 582         ubifs_assert(offs % c->min_io_size == 0 && !(offs & 7));
 583         ubifs_assert(lnum != wbuf->lnum);
 584         ubifs_assert(wbuf->used == 0);
 585
 586         spin_lock(&wbuf->lock);
 587         wbuf->lnum = lnum;
 588         wbuf->offs = offs;
 589         if (c->leb_size - wbuf->offs < c->max_write_size)
 590                 wbuf->size = c->leb_size - wbuf->offs;
 591         else if (wbuf->offs & (c->max_write_size - 1))
 592                 wbuf->size = ALIGN(wbuf->offs, c->max_write_size) - wbuf->offs;
 593         else
 594                 wbuf->size = c->max_write_size;
 595         wbuf->avail = wbuf->size;
 596         wbuf->used = 0;
 597         spin_unlock(&wbuf->lock);
 598
 599         return 0;
 600 }
 601
 602 #ifndef __UBOOT__
 603 /**
 604  * ubifs_bg_wbufs_sync - synchronize write-buffers.
 605  * @c: UBIFS file-system description object
 606  *
 607  * This function is called by background thread to synchronize write-buffers.
 608  * Returns zero in case of success and a negative error code in case of
 609  * failure.
 610  */
 611 int ubifs_bg_wbufs_sync(struct ubifs_info *c)
 612 {
 613         int err, i;
 614
 615         ubifs_assert(!c->ro_media && !c->ro_mount);
 616         if (!c->need_wbuf_sync)
 617                 return 0;
 618         c->need_wbuf_sync = 0;
 619
 620         if (c->ro_error) {
 621                 err = -EROFS;
 622                 goto out_timers;
 623         }
 624
 625         dbg_io("synchronize");
 626         for (i = 0; i < c->jhead_cnt; i++) {
 627                 struct ubifs_wbuf *wbuf = &c->jheads[i].wbuf;
 628
 629                 cond_resched();
 630
 631                 /*
 632                  * If the mutex is locked then wbuf is being changed, so
 633                  * synchronization is not necessary.
 634                  */
 635                 if (mutex_is_locked(&wbuf->io_mutex))
 636                         continue;
 637
 638                 mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
 639                 if (!wbuf->need_sync) {
 640                         mutex_unlock(&wbuf->io_mutex);
 641                         continue;
 642                 }
 643
 644                 err = ubifs_wbuf_sync_nolock(wbuf);
 645                 mutex_unlock(&wbuf->io_mutex);
 646                 if (err) {
 647                         ubifs_err(c, "cannot sync write-buffer, error %d", err);
 648                         ubifs_ro_mode(c, err);
 649                         goto out_timers;
 650                 }
 651         }
 652
 653         return 0;
 654
 655 out_timers:
 656         /* Cancel all timers to prevent repeated errors */
 657         for (i = 0; i < c->jhead_cnt; i++) {
 658                 struct ubifs_wbuf *wbuf = &c->jheads[i].wbuf;
 659
 660                 mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
 661                 cancel_wbuf_timer_nolock(wbuf);
 662                 mutex_unlock(&wbuf->io_mutex);
 663         }
 664         return err;
 665 }
 666
 667 /**
 668  * ubifs_wbuf_write_nolock - write data to flash via write-buffer.
 669  * @wbuf: write-buffer
 670  * @buf: node to write
 671  * @len: node length
 672  *
 673  * This function writes data to flash via write-buffer @wbuf. This means that
 674  * the last piece of the node won't reach the flash media immediately if it
 675  * does not take whole max. write unit (@c->max_write_size). Instead, the node
 676  * will sit in RAM until the write-buffer is synchronized (e.g., by timer, or
 677  * because more data are appended to the write-buffer).
 678  *
 679  * This function returns zero in case of success and a negative error code in
 680  * case of failure. If the node cannot be written because there is no more
 681  * space in this logical eraseblock, %-ENOSPC is returned.
 682  */
 683 int ubifs_wbuf_write_nolock(struct ubifs_wbuf *wbuf, void *buf, int len)
 684 {
 685         struct ubifs_info *c = wbuf->c;
 686         int err, written, n, aligned_len = ALIGN(len, 8);
 687
 688         dbg_io("%d bytes (%s) to jhead %s wbuf at LEB %d:%d", len,
 689                dbg_ntype(((struct ubifs_ch *)buf)->node_type),
 690                dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs + wbuf->used);
 691         ubifs_assert(len > 0 && wbuf->lnum >= 0 && wbuf->lnum < c->leb_cnt);
 692         ubifs_assert(wbuf->offs >= 0 && wbuf->offs % c->min_io_size == 0);
 693         ubifs_assert(!(wbuf->offs & 7) && wbuf->offs <= c->leb_size);
 694         ubifs_assert(wbuf->avail > 0 && wbuf->avail <= wbuf->size);
 695         ubifs_assert(wbuf->size >= c->min_io_size);
 696         ubifs_assert(wbuf->size <= c->max_write_size);
 697         ubifs_assert(wbuf->size % c->min_io_size == 0);
 698         ubifs_assert(mutex_is_locked(&wbuf->io_mutex));
 699         ubifs_assert(!c->ro_media && !c->ro_mount);
 700         ubifs_assert(!c->space_fixup);
 701         if (c->leb_size - wbuf->offs >= c->max_write_size)
 702                 ubifs_assert(!((wbuf->offs + wbuf->size) % c->max_write_size));
 703
 704         if (c->leb_size - wbuf->offs - wbuf->used < aligned_len) {
 705                 err = -ENOSPC;
 706                 goto out;
 707         }
 708
 709         cancel_wbuf_timer_nolock(wbuf);
 710
 711         if (c->ro_error)
 712                 return -EROFS;
 713
 714         if (aligned_len <= wbuf->avail) {
 715                 /*
 716                  * The node is not very large and fits entirely within
 717                  * write-buffer.
 718                  */
 719                 memcpy(wbuf->buf + wbuf->used, buf, len);
 720
 721                 if (aligned_len == wbuf->avail) {
 722                         dbg_io("flush jhead %s wbuf to LEB %d:%d",
 723                                dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs);
 724                         err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf,
 725                                               wbuf->offs, wbuf->size);
 726                         if (err)
 727                                 goto out;
 728
 729                         spin_lock(&wbuf->lock);
 730                         wbuf->offs += wbuf->size;
 731                         if (c->leb_size - wbuf->offs >= c->max_write_size)
 732                                 wbuf->size = c->max_write_size;
 733                         else
 734                                 wbuf->size = c->leb_size - wbuf->offs;
 735                         wbuf->avail = wbuf->size;
 736                         wbuf->used = 0;
 737                         wbuf->next_ino = 0;
 738                         spin_unlock(&wbuf->lock);
 739                 } else {
 740                         spin_lock(&wbuf->lock);
 741                         wbuf->avail -= aligned_len;
 742                         wbuf->used += aligned_len;
 743                         spin_unlock(&wbuf->lock);
 744                 }
 745
 746                 goto exit;
 747         }
 748
 749         written = 0;
 750
 751         if (wbuf->used) {
 752                 /*
 753                  * The node is large enough and does not fit entirely within
 754                  * current available space. We have to fill and flush
 755                  * write-buffer and switch to the next max. write unit.
 756                  */
 757                 dbg_io("flush jhead %s wbuf to LEB %d:%d",
 758                        dbg_jhead(wbuf->jhead), wbuf->lnum, wbuf->offs);
 759                 memcpy(wbuf->buf + wbuf->used, buf, wbuf->avail);
 760                 err = ubifs_leb_write(c, wbuf->lnum, wbuf->buf, wbuf->offs,
 761                                       wbuf->size);
 762                 if (err)
 763                         goto out;
 764
 765                 wbuf->offs += wbuf->size;
 766                 len -= wbuf->avail;
 767                 aligned_len -= wbuf->avail;
 768                 written += wbuf->avail;
 769         } else if (wbuf->offs & (c->max_write_size - 1)) {
 770                 /*
 771                  * The write-buffer offset is not aligned to
 772                  * @c->max_write_size and @wbuf->size is less than
 773                  * @c->max_write_size. Write @wbuf->size bytes to make sure the
 774                  * following writes are done in optimal @c->max_write_size
 775                  * chunks.
 776                  */
 777                 dbg_io("write %d bytes to LEB %d:%d",
 778                        wbuf->size, wbuf->lnum, wbuf->offs);
 779                 err = ubifs_leb_write(c, wbuf->lnum, buf, wbuf->offs,
 780                                       wbuf->size);
 781                 if (err)
 782                         goto out;
 783
 784                 wbuf->offs += wbuf->size;
 785                 len -= wbuf->size;
 786                 aligned_len -= wbuf->size;
 787                 written += wbuf->size;
 788         }
 789
 790         /*
 791          * The remaining data may take more whole max. write units, so write the
 792          * remains multiple to max. write unit size directly to the flash media.
 793          * We align node length to 8-byte boundary because we anyway flash wbuf
 794          * if the remaining space is less than 8 bytes.
 795          */
 796         n = aligned_len >> c->max_write_shift;
 797         if (n) {
 798                 n <<= c->max_write_shift;
 799                 dbg_io("write %d bytes to LEB %d:%d", n, wbuf->lnum,
 800                        wbuf->offs);
 801                 err = ubifs_leb_write(c, wbuf->lnum, buf + written,
 802                                       wbuf->offs, n);
 803                 if (err)
 804                         goto out;
 805                 wbuf->offs += n;
 806                 aligned_len -= n;
 807                 len -= n;
 808                 written += n;
 809         }
 810
 811         spin_lock(&wbuf->lock);
 812         if (aligned_len)
 813                 /*
 814                  * And now we have what's left and what does not take whole
 815                  * max. write unit, so write it to the write-buffer and we are
 816                  * done.
 817                  */
 818                 memcpy(wbuf->buf, buf + written, len);
 819
 820         if (c->leb_size - wbuf->offs >= c->max_write_size)
 821                 wbuf->size = c->max_write_size;
 822         else
 823                 wbuf->size = c->leb_size - wbuf->offs;
 824         wbuf->avail = wbuf->size - aligned_len;
 825         wbuf->used = aligned_len;
 826         wbuf->next_ino = 0;
 827         spin_unlock(&wbuf->lock);
 828
 829 exit:
 830         if (wbuf->sync_callback) {
 831                 int free = c->leb_size - wbuf->offs - wbuf->used;
 832
 833                 err = wbuf->sync_callback(c, wbuf->lnum, free, 0);
 834                 if (err)
 835                         goto out;
 836         }
 837
 838         if (wbuf->used)
 839                 new_wbuf_timer_nolock(wbuf);
 840
 841         return 0;
 842
 843 out:
 844         ubifs_err(c, "cannot write %d bytes to LEB %d:%d, error %d",
 845                   len, wbuf->lnum, wbuf->offs, err);
 846         ubifs_dump_node(c, buf);
 847         dump_stack();
 848         ubifs_dump_leb(c, wbuf->lnum);
 849         return err;
 850 }
 851
 852 /**
 853  * ubifs_write_node - write node to the media.
 854  * @c: UBIFS file-system description object
 855  * @buf: the node to write
 856  * @len: node length
 857  * @lnum: logical eraseblock number
 858  * @offs: offset within the logical eraseblock
 859  *
 860  * This function automatically fills node magic number, assigns sequence
 861  * number, and calculates node CRC checksum. The length of the @buf buffer has
 862  * to be aligned to the minimal I/O unit size. This function automatically
 863  * appends padding node and padding bytes if needed. Returns zero in case of
 864  * success and a negative error code in case of failure.
 865  */
 866 int ubifs_write_node(struct ubifs_info *c, void *buf, int len, int lnum,
 867                      int offs)
 868 {
 869         int err, buf_len = ALIGN(len, c->min_io_size);
 870
 871         dbg_io("LEB %d:%d, %s, length %d (aligned %d)",
 872                lnum, offs, dbg_ntype(((struct ubifs_ch *)buf)->node_type), len,
 873                buf_len);
 874         ubifs_assert(lnum >= 0 && lnum < c->leb_cnt && offs >= 0);
 875         ubifs_assert(offs % c->min_io_size == 0 && offs < c->leb_size);
 876         ubifs_assert(!c->ro_media && !c->ro_mount);
 877         ubifs_assert(!c->space_fixup);
 878
 879         if (c->ro_error)
 880                 return -EROFS;
 881
 882         ubifs_prepare_node(c, buf, len, 1);
 883         err = ubifs_leb_write(c, lnum, buf, offs, buf_len);
 884         if (err)
 885                 ubifs_dump_node(c, buf);
 886
 887         return err;
 888 }
 889 #endif
 890
 891 /**
 892  * ubifs_read_node_wbuf - read node from the media or write-buffer.
 893  * @wbuf: wbuf to check for un-written data
 894  * @buf: buffer to read to
 895  * @type: node type
 896  * @len: node length
 897  * @lnum: logical eraseblock number
 898  * @offs: offset within the logical eraseblock
 899  *
 900  * This function reads a node of known type and length, checks it and stores
 901  * in @buf. If the node partially or fully sits in the write-buffer, this
 902  * function takes data from the buffer, otherwise it reads the flash media.
 903  * Returns zero in case of success, %-EUCLEAN if CRC mismatched and a negative
 904  * error code in case of failure.
 905  */
 906 int ubifs_read_node_wbuf(struct ubifs_wbuf *wbuf, void *buf, int type, int len,
 907                          int lnum, int offs)
 908 {
 909         const struct ubifs_info *c = wbuf->c;
 910         int err, rlen, overlap;
 911         struct ubifs_ch *ch = buf;
 912
 913         dbg_io("LEB %d:%d, %s, length %d, jhead %s", lnum, offs,
 914                dbg_ntype(type), len, dbg_jhead(wbuf->jhead));
 915         ubifs_assert(wbuf && lnum >= 0 && lnum < c->leb_cnt && offs >= 0);
 916         ubifs_assert(!(offs & 7) && offs < c->leb_size);
 917         ubifs_assert(type >= 0 && type < UBIFS_NODE_TYPES_CNT);
 918
 919         spin_lock(&wbuf->lock);
 920         overlap = (lnum == wbuf->lnum && offs + len > wbuf->offs);
 921         if (!overlap) {
 922                 /* We may safely unlock the write-buffer and read the data */
 923                 spin_unlock(&wbuf->lock);
 924                 return ubifs_read_node(c, buf, type, len, lnum, offs);
 925         }
 926
 927         /* Don't read under wbuf */
 928         rlen = wbuf->offs - offs;
 929         if (rlen < 0)
 930                 rlen = 0;
 931
 932         /* Copy the rest from the write-buffer */
 933         memcpy(buf + rlen, wbuf->buf + offs + rlen - wbuf->offs, len - rlen);
 934         spin_unlock(&wbuf->lock);
 935
 936         if (rlen > 0) {
 937                 /* Read everything that goes before write-buffer */
 938                 err = ubifs_leb_read(c, lnum, buf, offs, rlen, 0);
 939                 if (err && err != -EBADMSG)
 940                         return err;
 941         }
 942
 943         if (type != ch->node_type) {
 944                 ubifs_err(c, "bad node type (%d but expected %d)",
 945                           ch->node_type, type);
 946                 goto out;
 947         }
 948
 949         err = ubifs_check_node(c, buf, lnum, offs, 0, 0);
 950         if (err) {
 951                 ubifs_err(c, "expected node type %d", type);
 952                 return err;
 953         }
 954
 955         rlen = le32_to_cpu(ch->len);
 956         if (rlen != len) {
 957                 ubifs_err(c, "bad node length %d, expected %d", rlen, len);
 958                 goto out;
 959         }
 960
 961         return 0;
 962
 963 out:
 964         ubifs_err(c, "bad node at LEB %d:%d", lnum, offs);
 965         ubifs_dump_node(c, buf);
 966         dump_stack();
 967         return -EINVAL;
 968 }
 969
 970 /**
 971  * ubifs_read_node - read node.
 972  * @c: UBIFS file-system description object
 973  * @buf: buffer to read to
 974  * @type: node type
 975  * @len: node length (not aligned)
 976  * @lnum: logical eraseblock number
 977  * @offs: offset within the logical eraseblock
 978  *
 979  * This function reads a node of known type and and length, checks it and
 980  * stores in @buf. Returns zero in case of success, %-EUCLEAN if CRC mismatched
 981  * and a negative error code in case of failure.
 982  */
 983 int ubifs_read_node(const struct ubifs_info *c, void *buf, int type, int len,
 984                     int lnum, int offs)
 985 {
 986         int err, l;
 987         struct ubifs_ch *ch = buf;
 988
 989         dbg_io("LEB %d:%d, %s, length %d", lnum, offs, dbg_ntype(type), len);
 990         ubifs_assert(lnum >= 0 && lnum < c->leb_cnt && offs >= 0);
 991         ubifs_assert(len >= UBIFS_CH_SZ && offs + len <= c->leb_size);
 992         ubifs_assert(!(offs & 7) && offs < c->leb_size);
 993         ubifs_assert(type >= 0 && type < UBIFS_NODE_TYPES_CNT);
 994
 995         err = ubifs_leb_read(c, lnum, buf, offs, len, 0);
 996         if (err && err != -EBADMSG)
 997                 return err;
 998
 999         if (type != ch->node_type) {
1000                 ubifs_errc(c, "bad node type (%d but expected %d)",
1001                            ch->node_type, type);
1002                 goto out;
1003         }
1004
1005         err = ubifs_check_node(c, buf, lnum, offs, 0, 0);
1006         if (err) {
1007                 ubifs_errc(c, "expected node type %d", type);
1008                 return err;
1009         }
1010
1011         l = le32_to_cpu(ch->len);
1012         if (l != len) {
1013                 ubifs_errc(c, "bad node length %d, expected %d", l, len);
1014                 goto out;
1015         }
1016
1017         return 0;
1018
1019 out:
1020         ubifs_errc(c, "bad node at LEB %d:%d, LEB mapping status %d", lnum,
1021                    offs, ubi_is_mapped(c->ubi, lnum));
1022         if (!c->probing) {
1023                 ubifs_dump_node(c, buf);
1024                 dump_stack();
1025         }
1026         return -EINVAL;
1027 }
1028
1029 /**
1030  * ubifs_wbuf_init - initialize write-buffer.
1031  * @c: UBIFS file-system description object
1032  * @wbuf: write-buffer to initialize
1033  *
1034  * This function initializes write-buffer. Returns zero in case of success
1035  * %-ENOMEM in case of failure.
1036  */
1037 int ubifs_wbuf_init(struct ubifs_info *c, struct ubifs_wbuf *wbuf)
1038 {
1039         size_t size;
1040
1041         wbuf->buf = kmalloc(c->max_write_size, GFP_KERNEL);
1042         if (!wbuf->buf)
1043                 return -ENOMEM;
1044
1045         size = (c->max_write_size / UBIFS_CH_SZ + 1) * sizeof(ino_t);
1046         wbuf->inodes = kmalloc(size, GFP_KERNEL);
1047         if (!wbuf->inodes) {
1048                 kfree(wbuf->buf);
1049                 wbuf->buf = NULL;
1050                 return -ENOMEM;
1051         }
1052
1053         wbuf->used = 0;
1054         wbuf->lnum = wbuf->offs = -1;
1055         /*
1056          * If the LEB starts at the max. write size aligned address, then
1057          * write-buffer size has to be set to @c->max_write_size. Otherwise,
1058          * set it to something smaller so that it ends at the closest max.
1059          * write size boundary.
1060          */
1061         size = c->max_write_size - (c->leb_start % c->max_write_size);
1062         wbuf->avail = wbuf->size = size;
1063         wbuf->sync_callback = NULL;
1064         mutex_init(&wbuf->io_mutex);
1065         spin_lock_init(&wbuf->lock);
1066         wbuf->c = c;
1067         wbuf->next_ino = 0;
1068
1069 #ifndef __UBOOT__
1070         hrtimer_init(&wbuf->timer, CLOCK_MONOTONIC, HRTIMER_MODE_REL);
1071         wbuf->timer.function = wbuf_timer_callback_nolock;
1072         wbuf->softlimit = ktime_set(WBUF_TIMEOUT_SOFTLIMIT, 0);
1073         wbuf->delta = WBUF_TIMEOUT_HARDLIMIT - WBUF_TIMEOUT_SOFTLIMIT;
1074         wbuf->delta *= 1000000000ULL;
1075         ubifs_assert(wbuf->delta <= ULONG_MAX);
1076 #endif
1077         return 0;
1078 }
1079
1080 /**
1081  * ubifs_wbuf_add_ino_nolock - add an inode number into the wbuf inode array.
1082  * @wbuf: the write-buffer where to add
1083  * @inum: the inode number
1084  *
1085  * This function adds an inode number to the inode array of the write-buffer.
1086  */
1087 void ubifs_wbuf_add_ino_nolock(struct ubifs_wbuf *wbuf, ino_t inum)
1088 {
1089         if (!wbuf->buf)
1090                 /* NOR flash or something similar */
1091                 return;
1092
1093         spin_lock(&wbuf->lock);
1094         if (wbuf->used)
1095                 wbuf->inodes[wbuf->next_ino++] = inum;
1096         spin_unlock(&wbuf->lock);
1097 }
1098
1099 /**
1100  * wbuf_has_ino - returns if the wbuf contains data from the inode.
1101  * @wbuf: the write-buffer
1102  * @inum: the inode number
1103  *
1104  * This function returns with %1 if the write-buffer contains some data from the
1105  * given inode otherwise it returns with %0.
1106  */
1107 static int wbuf_has_ino(struct ubifs_wbuf *wbuf, ino_t inum)
1108 {
1109         int i, ret = 0;
1110
1111         spin_lock(&wbuf->lock);
1112         for (i = 0; i < wbuf->next_ino; i++)
1113                 if (inum == wbuf->inodes[i]) {
1114                         ret = 1;
1115                         break;
1116                 }
1117         spin_unlock(&wbuf->lock);
1118
1119         return ret;
1120 }
1121
1122 /**
1123  * ubifs_sync_wbufs_by_inode - synchronize write-buffers for an inode.
1124  * @c: UBIFS file-system description object
1125  * @inode: inode to synchronize
1126  *
1127  * This function synchronizes write-buffers which contain nodes belonging to
1128  * @inode. Returns zero in case of success and a negative error code in case of
1129  * failure.
1130  */
1131 int ubifs_sync_wbufs_by_inode(struct ubifs_info *c, struct inode *inode)
1132 {
1133         int i, err = 0;
1134
1135         for (i = 0; i < c->jhead_cnt; i++) {
1136                 struct ubifs_wbuf *wbuf = &c->jheads[i].wbuf;
1137
1138                 if (i == GCHD)
1139                         /*
1140                          * GC head is special, do not look at it. Even if the
1141                          * head contains something related to this inode, it is
1142                          * a _copy_ of corresponding on-flash node which sits
1143                          * somewhere else.
1144                          */
1145                         continue;
1146
1147                 if (!wbuf_has_ino(wbuf, inode->i_ino))
1148                         continue;
1149
1150                 mutex_lock_nested(&wbuf->io_mutex, wbuf->jhead);
1151                 if (wbuf_has_ino(wbuf, inode->i_ino))
1152                         err = ubifs_wbuf_sync_nolock(wbuf);
1153                 mutex_unlock(&wbuf->io_mutex);
1154
1155                 if (err) {
1156                         ubifs_ro_mode(c, err);
1157                         return err;
1158                 }
1159         }
1160         return 0;
1161 }