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 #include <linux/err.h> 42 #include <linux/uaccess.h> 43 #include <asm/div64.h> 44 #include "ubi.h" 45 46 /** 47 * set_update_marker - set update marker. 48 * @ubi: UBI device description object 49 * @vol: volume description object 50 * 51 * This function sets the update marker flag for volume @vol. Returns zero 52 * in case of success and a negative error code in case of failure. 53 */ 54 static int set_update_marker(struct ubi_device *ubi, struct ubi_volume *vol) 55 { 56 int err; 57 struct ubi_vtbl_record vtbl_rec; 58 59 dbg_gen("set update marker for volume %d", vol->vol_id); 60 61 if (vol->upd_marker) { 62 ubi_assert(ubi->vtbl[vol->vol_id].upd_marker); 63 dbg_gen("already set"); 64 return 0; 65 } 66 67 memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id], 68 sizeof(struct ubi_vtbl_record)); 69 vtbl_rec.upd_marker = 1; 70 71 mutex_lock(&ubi->volumes_mutex); 72 err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec); 73 mutex_unlock(&ubi->volumes_mutex); 74 vol->upd_marker = 1; 75 return err; 76 } 77 78 /** 79 * clear_update_marker - clear update marker. 80 * @ubi: UBI device description object 81 * @vol: volume description object 82 * @bytes: new data size in bytes 83 * 84 * This function clears the update marker for volume @vol, sets new volume 85 * data size and clears the "corrupted" flag (static volumes only). Returns 86 * zero in case of success and a negative error code in case of failure. 87 */ 88 static int clear_update_marker(struct ubi_device *ubi, struct ubi_volume *vol, 89 long long bytes) 90 { 91 int err; 92 uint64_t tmp; 93 struct ubi_vtbl_record vtbl_rec; 94 95 dbg_gen("clear update marker for volume %d", vol->vol_id); 96 97 memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id], 98 sizeof(struct ubi_vtbl_record)); 99 ubi_assert(vol->upd_marker && vtbl_rec.upd_marker); 100 vtbl_rec.upd_marker = 0; 101 102 if (vol->vol_type == UBI_STATIC_VOLUME) { 103 vol->corrupted = 0; 104 vol->used_bytes = tmp = bytes; 105 vol->last_eb_bytes = do_div(tmp, vol->usable_leb_size); 106 vol->used_ebs = tmp; 107 if (vol->last_eb_bytes) 108 vol->used_ebs += 1; 109 else 110 vol->last_eb_bytes = vol->usable_leb_size; 111 } 112 113 mutex_lock(&ubi->volumes_mutex); 114 err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec); 115 mutex_unlock(&ubi->volumes_mutex); 116 vol->upd_marker = 0; 117 return err; 118 } 119 120 /** 121 * ubi_start_update - start volume update. 122 * @ubi: UBI device description object 123 * @vol: volume description object 124 * @bytes: update bytes 125 * 126 * This function starts volume update operation. If @bytes is zero, the volume 127 * is just wiped out. Returns zero in case of success and a negative error code 128 * in case of failure. 129 */ 130 int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol, 131 long long bytes) 132 { 133 int i, err; 134 uint64_t tmp; 135 136 dbg_gen("start update of volume %d, %llu bytes", vol->vol_id, bytes); 137 ubi_assert(!vol->updating && !vol->changing_leb); 138 vol->updating = 1; 139 140 err = set_update_marker(ubi, vol); 141 if (err) 142 return err; 143 144 /* Before updating - wipe out the volume */ 145 for (i = 0; i < vol->reserved_pebs; i++) { 146 err = ubi_eba_unmap_leb(ubi, vol, i); 147 if (err) 148 return err; 149 } 150 151 if (bytes == 0) { 152 err = clear_update_marker(ubi, vol, 0); 153 if (err) 154 return err; 155 err = ubi_wl_flush(ubi); 156 if (!err) 157 vol->updating = 0; 158 } 159 160 vol->upd_buf = vmalloc(ubi->leb_size); 161 if (!vol->upd_buf) 162 return -ENOMEM; 163 164 tmp = bytes; 165 vol->upd_ebs = !!do_div(tmp, vol->usable_leb_size); 166 vol->upd_ebs += tmp; 167 vol->upd_bytes = bytes; 168 vol->upd_received = 0; 169 return 0; 170 } 171 172 /** 173 * ubi_start_leb_change - start atomic LEB change. 174 * @ubi: UBI device description object 175 * @vol: volume description object 176 * @req: operation request 177 * 178 * This function starts atomic LEB change operation. Returns zero in case of 179 * success and a negative error code in case of failure. 180 */ 181 int ubi_start_leb_change(struct ubi_device *ubi, struct ubi_volume *vol, 182 const struct ubi_leb_change_req *req) 183 { 184 ubi_assert(!vol->updating && !vol->changing_leb); 185 186 dbg_gen("start changing LEB %d:%d, %u bytes", 187 vol->vol_id, req->lnum, req->bytes); 188 if (req->bytes == 0) 189 return ubi_eba_atomic_leb_change(ubi, vol, req->lnum, NULL, 0, 190 req->dtype); 191 192 vol->upd_bytes = req->bytes; 193 vol->upd_received = 0; 194 vol->changing_leb = 1; 195 vol->ch_lnum = req->lnum; 196 vol->ch_dtype = req->dtype; 197 198 vol->upd_buf = vmalloc(req->bytes); 199 if (!vol->upd_buf) 200 return -ENOMEM; 201 202 return 0; 203 } 204 205 /** 206 * write_leb - write update data. 207 * @ubi: UBI device description object 208 * @vol: volume description object 209 * @lnum: logical eraseblock number 210 * @buf: data to write 211 * @len: data size 212 * @used_ebs: how many logical eraseblocks will this volume contain (static 213 * volumes only) 214 * 215 * This function writes update data to corresponding logical eraseblock. In 216 * case of dynamic volume, this function checks if the data contains 0xFF bytes 217 * at the end. If yes, the 0xFF bytes are cut and not written. So if the whole 218 * buffer contains only 0xFF bytes, the LEB is left unmapped. 219 * 220 * The reason why we skip the trailing 0xFF bytes in case of dynamic volume is 221 * that we want to make sure that more data may be appended to the logical 222 * eraseblock in future. Indeed, writing 0xFF bytes may have side effects and 223 * this PEB won't be writable anymore. So if one writes the file-system image 224 * to the UBI volume where 0xFFs mean free space - UBI makes sure this free 225 * space is writable after the update. 226 * 227 * We do not do this for static volumes because they are read-only. But this 228 * also cannot be done because we have to store per-LEB CRC and the correct 229 * data length. 230 * 231 * This function returns zero in case of success and a negative error code in 232 * case of failure. 233 */ 234 static int write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum, 235 void *buf, int len, int used_ebs) 236 { 237 int err; 238 239 if (vol->vol_type == UBI_DYNAMIC_VOLUME) { 240 int l = ALIGN(len, ubi->min_io_size); 241 242 memset(buf + len, 0xFF, l - len); 243 len = ubi_calc_data_len(ubi, buf, l); 244 if (len == 0) { 245 dbg_gen("all %d bytes contain 0xFF - skip", len); 246 return 0; 247 } 248 249 err = ubi_eba_write_leb(ubi, vol, lnum, buf, 0, len, 250 UBI_UNKNOWN); 251 } else { 252 /* 253 * When writing static volume, and this is the last logical 254 * eraseblock, the length (@len) does not have to be aligned to 255 * the minimal flash I/O unit. The 'ubi_eba_write_leb_st()' 256 * function accepts exact (unaligned) length and stores it in 257 * the VID header. And it takes care of proper alignment by 258 * padding the buffer. Here we just make sure the padding will 259 * contain zeros, not random trash. 260 */ 261 memset(buf + len, 0, vol->usable_leb_size - len); 262 err = ubi_eba_write_leb_st(ubi, vol, lnum, buf, len, 263 UBI_UNKNOWN, used_ebs); 264 } 265 266 return err; 267 } 268 269 /** 270 * ubi_more_update_data - write more update data. 271 * @ubi: UBI device description object 272 * @vol: volume description object 273 * @buf: write data (user-space memory buffer) 274 * @count: how much bytes to write 275 * 276 * This function writes more data to the volume which is being updated. It may 277 * be called arbitrary number of times until all the update data arriveis. This 278 * function returns %0 in case of success, number of bytes written during the 279 * last call if the whole volume update has been successfully finished, and a 280 * negative error code in case of failure. 281 */ 282 int ubi_more_update_data(struct ubi_device *ubi, struct ubi_volume *vol, 283 const void __user *buf, int count) 284 { 285 uint64_t tmp; 286 int lnum, offs, err = 0, len, to_write = count; 287 288 dbg_gen("write %d of %lld bytes, %lld already passed", 289 count, vol->upd_bytes, vol->upd_received); 290 291 if (ubi->ro_mode) 292 return -EROFS; 293 294 tmp = vol->upd_received; 295 offs = do_div(tmp, vol->usable_leb_size); 296 lnum = tmp; 297 298 if (vol->upd_received + count > vol->upd_bytes) 299 to_write = count = vol->upd_bytes - vol->upd_received; 300 301 /* 302 * When updating volumes, we accumulate whole logical eraseblock of 303 * data and write it at once. 304 */ 305 if (offs != 0) { 306 /* 307 * This is a write to the middle of the logical eraseblock. We 308 * copy the data to our update buffer and wait for more data or 309 * flush it if the whole eraseblock is written or the update 310 * is finished. 311 */ 312 313 len = vol->usable_leb_size - offs; 314 if (len > count) 315 len = count; 316 317 err = copy_from_user(vol->upd_buf + offs, buf, len); 318 if (err) 319 return -EFAULT; 320 321 if (offs + len == vol->usable_leb_size || 322 vol->upd_received + len == vol->upd_bytes) { 323 int flush_len = offs + len; 324 325 /* 326 * OK, we gathered either the whole eraseblock or this 327 * is the last chunk, it's time to flush the buffer. 328 */ 329 ubi_assert(flush_len <= vol->usable_leb_size); 330 err = write_leb(ubi, vol, lnum, vol->upd_buf, flush_len, 331 vol->upd_ebs); 332 if (err) 333 return err; 334 } 335 336 vol->upd_received += len; 337 count -= len; 338 buf += len; 339 lnum += 1; 340 } 341 342 /* 343 * If we've got more to write, let's continue. At this point we know we 344 * are starting from the beginning of an eraseblock. 345 */ 346 while (count) { 347 if (count > vol->usable_leb_size) 348 len = vol->usable_leb_size; 349 else 350 len = count; 351 352 err = copy_from_user(vol->upd_buf, buf, len); 353 if (err) 354 return -EFAULT; 355 356 if (len == vol->usable_leb_size || 357 vol->upd_received + len == vol->upd_bytes) { 358 err = write_leb(ubi, vol, lnum, vol->upd_buf, 359 len, vol->upd_ebs); 360 if (err) 361 break; 362 } 363 364 vol->upd_received += len; 365 count -= len; 366 lnum += 1; 367 buf += len; 368 } 369 370 ubi_assert(vol->upd_received <= vol->upd_bytes); 371 if (vol->upd_received == vol->upd_bytes) { 372 /* The update is finished, clear the update marker */ 373 err = clear_update_marker(ubi, vol, vol->upd_bytes); 374 if (err) 375 return err; 376 err = ubi_wl_flush(ubi); 377 if (err == 0) { 378 vol->updating = 0; 379 err = to_write; 380 vfree(vol->upd_buf); 381 } 382 } 383 384 return err; 385 } 386 387 /** 388 * ubi_more_leb_change_data - accept more data for atomic LEB change. 389 * @ubi: UBI device description object 390 * @vol: volume description object 391 * @buf: write data (user-space memory buffer) 392 * @count: how much bytes to write 393 * 394 * This function accepts more data to the volume which is being under the 395 * "atomic LEB change" operation. It may be called arbitrary number of times 396 * until all data arrives. This function returns %0 in case of success, number 397 * of bytes written during the last call if the whole "atomic LEB change" 398 * operation has been successfully finished, and a negative error code in case 399 * of failure. 400 */ 401 int ubi_more_leb_change_data(struct ubi_device *ubi, struct ubi_volume *vol, 402 const void __user *buf, int count) 403 { 404 int err; 405 406 dbg_gen("write %d of %lld bytes, %lld already passed", 407 count, vol->upd_bytes, vol->upd_received); 408 409 if (ubi->ro_mode) 410 return -EROFS; 411 412 if (vol->upd_received + count > vol->upd_bytes) 413 count = vol->upd_bytes - vol->upd_received; 414 415 err = copy_from_user(vol->upd_buf + vol->upd_received, buf, count); 416 if (err) 417 return -EFAULT; 418 419 vol->upd_received += count; 420 421 if (vol->upd_received == vol->upd_bytes) { 422 int len = ALIGN((int)vol->upd_bytes, ubi->min_io_size); 423 424 memset(vol->upd_buf + vol->upd_bytes, 0xFF, 425 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