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