1 /* 2 * Copyright (c) International Business Machines Corp., 2006 3 * Copyright (c) Nokia Corporation, 2006 4 * 5 * This program is free software; you can redistribute it and/or modify 6 * it under the terms of the GNU General Public License as published by 7 * the Free Software Foundation; either version 2 of the License, or 8 * (at your option) any later version. 9 * 10 * This program is distributed in the hope that it will be useful, 11 * but WITHOUT ANY WARRANTY; without even the implied warranty of 12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See 13 * the GNU General Public License for more details. 14 * 15 * You should have received a copy of the GNU General Public License 16 * along with this program; if not, write to the Free Software 17 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 18 * 19 * Author: Artem Bityutskiy (Битюцкий Артём) 20 * 21 * Jan 2007: Alexander Schmidt, hacked per-volume update. 22 */ 23 24 /* 25 * This file contains implementation of the volume update and atomic LEB change 26 * functionality. 27 * 28 * The update operation is based on the per-volume update marker which is 29 * stored in the volume table. The update marker is set before the update 30 * starts, and removed after the update has been finished. So if the update was 31 * interrupted by an unclean re-boot or due to some other reasons, the update 32 * marker stays on the flash media and UBI finds it when it attaches the MTD 33 * device next time. If the update marker is set for a volume, the volume is 34 * treated as damaged and most I/O operations are prohibited. Only a new update 35 * operation is allowed. 36 * 37 * Note, in general it is possible to implement the update operation as a 38 * transaction with a roll-back capability. 39 */ 40 41 #ifdef UBI_LINUX 42 #include <linux/err.h> 43 #include <asm/uaccess.h> 44 #include <asm/div64.h> 45 #endif 46 47 #include <ubi_uboot.h> 48 #include "ubi.h" 49 50 /** 51 * set_update_marker - set update marker. 52 * @ubi: UBI device description object 53 * @vol: volume description object 54 * 55 * This function sets the update marker flag for volume @vol. Returns zero 56 * in case of success and a negative error code in case of failure. 57 */ 58 static int set_update_marker(struct ubi_device *ubi, struct ubi_volume *vol) 59 { 60 int err; 61 struct ubi_vtbl_record vtbl_rec; 62 63 dbg_msg("set update marker for volume %d", vol->vol_id); 64 65 if (vol->upd_marker) { 66 ubi_assert(ubi->vtbl[vol->vol_id].upd_marker); 67 dbg_msg("already set"); 68 return 0; 69 } 70 71 memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id], 72 sizeof(struct ubi_vtbl_record)); 73 vtbl_rec.upd_marker = 1; 74 75 mutex_lock(&ubi->volumes_mutex); 76 err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec); 77 mutex_unlock(&ubi->volumes_mutex); 78 vol->upd_marker = 1; 79 return err; 80 } 81 82 /** 83 * clear_update_marker - clear update marker. 84 * @ubi: UBI device description object 85 * @vol: volume description object 86 * @bytes: new data size in bytes 87 * 88 * This function clears the update marker for volume @vol, sets new volume 89 * data size and clears the "corrupted" flag (static volumes only). Returns 90 * zero in case of success and a negative error code in case of failure. 91 */ 92 static int clear_update_marker(struct ubi_device *ubi, struct ubi_volume *vol, 93 long long bytes) 94 { 95 int err; 96 uint64_t tmp; 97 struct ubi_vtbl_record vtbl_rec; 98 99 dbg_msg("clear update marker for volume %d", vol->vol_id); 100 101 memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id], 102 sizeof(struct ubi_vtbl_record)); 103 ubi_assert(vol->upd_marker && vtbl_rec.upd_marker); 104 vtbl_rec.upd_marker = 0; 105 106 if (vol->vol_type == UBI_STATIC_VOLUME) { 107 vol->corrupted = 0; 108 vol->used_bytes = tmp = bytes; 109 vol->last_eb_bytes = do_div(tmp, vol->usable_leb_size); 110 vol->used_ebs = tmp; 111 if (vol->last_eb_bytes) 112 vol->used_ebs += 1; 113 else 114 vol->last_eb_bytes = vol->usable_leb_size; 115 } 116 117 mutex_lock(&ubi->volumes_mutex); 118 err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec); 119 mutex_unlock(&ubi->volumes_mutex); 120 vol->upd_marker = 0; 121 return err; 122 } 123 124 /** 125 * ubi_start_update - start volume update. 126 * @ubi: UBI device description object 127 * @vol: volume description object 128 * @bytes: update bytes 129 * 130 * This function starts volume update operation. If @bytes is zero, the volume 131 * is just wiped out. Returns zero in case of success and a negative error code 132 * in case of failure. 133 */ 134 int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol, 135 long long bytes) 136 { 137 int i, err; 138 uint64_t tmp; 139 140 dbg_msg("start update of volume %d, %llu bytes", vol->vol_id, bytes); 141 ubi_assert(!vol->updating && !vol->changing_leb); 142 vol->updating = 1; 143 144 err = set_update_marker(ubi, vol); 145 if (err) 146 return err; 147 148 /* Before updating - wipe out the volume */ 149 for (i = 0; i < vol->reserved_pebs; i++) { 150 err = ubi_eba_unmap_leb(ubi, vol, i); 151 if (err) 152 return err; 153 } 154 155 if (bytes == 0) { 156 err = clear_update_marker(ubi, vol, 0); 157 if (err) 158 return err; 159 err = ubi_wl_flush(ubi); 160 if (!err) 161 vol->updating = 0; 162 } 163 164 vol->upd_buf = vmalloc(ubi->leb_size); 165 if (!vol->upd_buf) 166 return -ENOMEM; 167 168 tmp = bytes; 169 vol->upd_ebs = !!do_div(tmp, vol->usable_leb_size); 170 vol->upd_ebs += tmp; 171 vol->upd_bytes = bytes; 172 vol->upd_received = 0; 173 return 0; 174 } 175 176 /** 177 * ubi_start_leb_change - start atomic LEB change. 178 * @ubi: UBI device description object 179 * @vol: volume description object 180 * @req: operation request 181 * 182 * This function starts atomic LEB change operation. Returns zero in case of 183 * success and a negative error code in case of failure. 184 */ 185 int ubi_start_leb_change(struct ubi_device *ubi, struct ubi_volume *vol, 186 const struct ubi_leb_change_req *req) 187 { 188 ubi_assert(!vol->updating && !vol->changing_leb); 189 190 dbg_msg("start changing LEB %d:%d, %u bytes", 191 vol->vol_id, req->lnum, req->bytes); 192 if (req->bytes == 0) 193 return ubi_eba_atomic_leb_change(ubi, vol, req->lnum, NULL, 0, 194 req->dtype); 195 196 vol->upd_bytes = req->bytes; 197 vol->upd_received = 0; 198 vol->changing_leb = 1; 199 vol->ch_lnum = req->lnum; 200 vol->ch_dtype = req->dtype; 201 202 vol->upd_buf = vmalloc(req->bytes); 203 if (!vol->upd_buf) 204 return -ENOMEM; 205 206 return 0; 207 } 208 209 /** 210 * write_leb - write update data. 211 * @ubi: UBI device description object 212 * @vol: volume description object 213 * @lnum: logical eraseblock number 214 * @buf: data to write 215 * @len: data size 216 * @used_ebs: how many logical eraseblocks will this volume contain (static 217 * volumes only) 218 * 219 * This function writes update data to corresponding logical eraseblock. In 220 * case of dynamic volume, this function checks if the data contains 0xFF bytes 221 * at the end. If yes, the 0xFF bytes are cut and not written. So if the whole 222 * buffer contains only 0xFF bytes, the LEB is left unmapped. 223 * 224 * The reason why we skip the trailing 0xFF bytes in case of dynamic volume is 225 * that we want to make sure that more data may be appended to the logical 226 * eraseblock in future. Indeed, writing 0xFF bytes may have side effects and 227 * this PEB won't be writable anymore. So if one writes the file-system image 228 * to the UBI volume where 0xFFs mean free space - UBI makes sure this free 229 * space is writable after the update. 230 * 231 * We do not do this for static volumes because they are read-only. But this 232 * also cannot be done because we have to store per-LEB CRC and the correct 233 * data length. 234 * 235 * This function returns zero in case of success and a negative error code in 236 * case of failure. 237 */ 238 static int write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum, 239 void *buf, int len, int used_ebs) 240 { 241 int err; 242 243 if (vol->vol_type == UBI_DYNAMIC_VOLUME) { 244 int l = ALIGN(len, ubi->min_io_size); 245 246 memset(buf + len, 0xFF, l - len); 247 len = ubi_calc_data_len(ubi, buf, l); 248 if (len == 0) { 249 dbg_msg("all %d bytes contain 0xFF - skip", len); 250 return 0; 251 } 252 253 err = ubi_eba_write_leb(ubi, vol, lnum, buf, 0, len, UBI_UNKNOWN); 254 } else { 255 /* 256 * When writing static volume, and this is the last logical 257 * eraseblock, the length (@len) does not have to be aligned to 258 * the minimal flash I/O unit. The 'ubi_eba_write_leb_st()' 259 * function accepts exact (unaligned) length and stores it in 260 * the VID header. And it takes care of proper alignment by 261 * padding the buffer. Here we just make sure the padding will 262 * contain zeros, not random trash. 263 */ 264 memset(buf + len, 0, vol->usable_leb_size - len); 265 err = ubi_eba_write_leb_st(ubi, vol, lnum, buf, len, 266 UBI_UNKNOWN, used_ebs); 267 } 268 269 return err; 270 } 271 272 /** 273 * ubi_more_update_data - write more update data. 274 * @vol: volume description object 275 * @buf: write data (user-space memory buffer) 276 * @count: how much bytes to write 277 * 278 * This function writes more data to the volume which is being updated. It may 279 * be called arbitrary number of times until all the update data arriveis. This 280 * function returns %0 in case of success, number of bytes written during the 281 * last call if the whole volume update has been successfully finished, and a 282 * negative error code in case of failure. 283 */ 284 int ubi_more_update_data(struct ubi_device *ubi, struct ubi_volume *vol, 285 const void __user *buf, int count) 286 { 287 uint64_t tmp; 288 int lnum, offs, err = 0, len, to_write = count; 289 290 dbg_msg("write %d of %lld bytes, %lld already passed", 291 count, vol->upd_bytes, vol->upd_received); 292 293 if (ubi->ro_mode) 294 return -EROFS; 295 296 tmp = vol->upd_received; 297 offs = do_div(tmp, vol->usable_leb_size); 298 lnum = tmp; 299 300 if (vol->upd_received + count > vol->upd_bytes) 301 to_write = count = vol->upd_bytes - vol->upd_received; 302 303 /* 304 * When updating volumes, we accumulate whole logical eraseblock of 305 * data and write it at once. 306 */ 307 if (offs != 0) { 308 /* 309 * This is a write to the middle of the logical eraseblock. We 310 * copy the data to our update buffer and wait for more data or 311 * flush it if the whole eraseblock is written or the update 312 * is finished. 313 */ 314 315 len = vol->usable_leb_size - offs; 316 if (len > count) 317 len = count; 318 319 err = copy_from_user(vol->upd_buf + offs, buf, len); 320 if (err) 321 return -EFAULT; 322 323 if (offs + len == vol->usable_leb_size || 324 vol->upd_received + len == vol->upd_bytes) { 325 int flush_len = offs + len; 326 327 /* 328 * OK, we gathered either the whole eraseblock or this 329 * is the last chunk, it's time to flush the buffer. 330 */ 331 ubi_assert(flush_len <= vol->usable_leb_size); 332 err = write_leb(ubi, vol, lnum, vol->upd_buf, flush_len, 333 vol->upd_ebs); 334 if (err) 335 return err; 336 } 337 338 vol->upd_received += len; 339 count -= len; 340 buf += len; 341 lnum += 1; 342 } 343 344 /* 345 * If we've got more to write, let's continue. At this point we know we 346 * are starting from the beginning of an eraseblock. 347 */ 348 while (count) { 349 if (count > vol->usable_leb_size) 350 len = vol->usable_leb_size; 351 else 352 len = count; 353 354 err = copy_from_user(vol->upd_buf, buf, len); 355 if (err) 356 return -EFAULT; 357 358 if (len == vol->usable_leb_size || 359 vol->upd_received + len == vol->upd_bytes) { 360 err = write_leb(ubi, vol, lnum, vol->upd_buf, 361 len, vol->upd_ebs); 362 if (err) 363 break; 364 } 365 366 vol->upd_received += len; 367 count -= len; 368 lnum += 1; 369 buf += len; 370 } 371 372 ubi_assert(vol->upd_received <= vol->upd_bytes); 373 if (vol->upd_received == vol->upd_bytes) { 374 /* The update is finished, clear the update marker */ 375 err = clear_update_marker(ubi, vol, vol->upd_bytes); 376 if (err) 377 return err; 378 err = ubi_wl_flush(ubi); 379 if (err == 0) { 380 vol->updating = 0; 381 err = to_write; 382 vfree(vol->upd_buf); 383 } 384 } 385 386 return err; 387 } 388 389 /** 390 * ubi_more_leb_change_data - accept more data for atomic LEB change. 391 * @vol: volume description object 392 * @buf: write data (user-space memory buffer) 393 * @count: how much bytes to write 394 * 395 * This function accepts more data to the volume which is being under the 396 * "atomic LEB change" operation. It may be called arbitrary number of times 397 * until all data arrives. This function returns %0 in case of success, number 398 * of bytes written during the last call if the whole "atomic LEB change" 399 * operation has been successfully finished, and a negative error code in case 400 * of failure. 401 */ 402 int ubi_more_leb_change_data(struct ubi_device *ubi, struct ubi_volume *vol, 403 const void __user *buf, int count) 404 { 405 int err; 406 407 dbg_msg("write %d of %lld bytes, %lld already passed", 408 count, vol->upd_bytes, vol->upd_received); 409 410 if (ubi->ro_mode) 411 return -EROFS; 412 413 if (vol->upd_received + count > vol->upd_bytes) 414 count = vol->upd_bytes - vol->upd_received; 415 416 err = copy_from_user(vol->upd_buf + vol->upd_received, buf, count); 417 if (err) 418 return -EFAULT; 419 420 vol->upd_received += count; 421 422 if (vol->upd_received == vol->upd_bytes) { 423 int len = ALIGN((int)vol->upd_bytes, ubi->min_io_size); 424 425 memset(vol->upd_buf + vol->upd_bytes, 0xFF, len - vol->upd_bytes); 426 len = ubi_calc_data_len(ubi, vol->upd_buf, len); 427 err = ubi_eba_atomic_leb_change(ubi, vol, vol->ch_lnum, 428 vol->upd_buf, len, UBI_UNKNOWN); 429 if (err) 430 return err; 431 } 432 433 ubi_assert(vol->upd_received <= vol->upd_bytes); 434 if (vol->upd_received == vol->upd_bytes) { 435 vol->changing_leb = 0; 436 err = count; 437 vfree(vol->upd_buf); 438 } 439 440 return err; 441 } 442