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