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 functionality. 26 * 27 * The update operation is based on the per-volume update marker which is 28 * stored in the volume table. The update marker is set before the update 29 * starts, and removed after the update has been finished. So if the update was 30 * interrupted by an unclean re-boot or due to some other reasons, the update 31 * marker stays on the flash media and UBI finds it when it attaches the MTD 32 * device next time. If the update marker is set for a volume, the volume is 33 * treated as damaged and most I/O operations are prohibited. Only a new update 34 * operation is allowed. 35 * 36 * Note, in general it is possible to implement the update operation as a 37 * transaction with a roll-back capability. 38 */ 39 40#include <linux/err.h> 41#include <asm/uaccess.h> 42#include <asm/div64.h> 43#include "ubi.h" 44 45/** 46 * set_update_marker - set update marker. 47 * @ubi: UBI device description object 48 * @vol_id: volume ID 49 * 50 * This function sets the update marker flag for volume @vol_id. Returns zero 51 * in case of success and a negative error code in case of failure. 52 */ 53static int set_update_marker(struct ubi_device *ubi, int vol_id) 54{ 55 int err; 56 struct ubi_vtbl_record vtbl_rec; 57 struct ubi_volume *vol = ubi->volumes[vol_id]; 58 59 dbg_msg("set update marker for volume %d", vol_id); 60 61 if (vol->upd_marker) { 62 ubi_assert(ubi->vtbl[vol_id].upd_marker); 63 dbg_msg("already set"); 64 return 0; 65 } 66 67 memcpy(&vtbl_rec, &ubi->vtbl[vol_id], sizeof(struct ubi_vtbl_record)); 68 vtbl_rec.upd_marker = 1; 69 70 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec); 71 vol->upd_marker = 1; 72 return err; 73} 74 75/** 76 * clear_update_marker - clear update marker. 77 * @ubi: UBI device description object 78 * @vol_id: volume ID 79 * @bytes: new data size in bytes 80 * 81 * This function clears the update marker for volume @vol_id, sets new volume 82 * data size and clears the "corrupted" flag (static volumes only). Returns 83 * zero in case of success and a negative error code in case of failure. 84 */ 85static int clear_update_marker(struct ubi_device *ubi, int vol_id, long long bytes) 86{ 87 int err; 88 uint64_t tmp; 89 struct ubi_vtbl_record vtbl_rec; 90 struct ubi_volume *vol = ubi->volumes[vol_id]; 91 92 dbg_msg("clear update marker for volume %d", vol_id); 93 94 memcpy(&vtbl_rec, &ubi->vtbl[vol_id], sizeof(struct ubi_vtbl_record)); 95 ubi_assert(vol->upd_marker && vtbl_rec.upd_marker); 96 vtbl_rec.upd_marker = 0; 97 98 if (vol->vol_type == UBI_STATIC_VOLUME) { 99 vol->corrupted = 0; 100 vol->used_bytes = tmp = bytes; 101 vol->last_eb_bytes = do_div(tmp, vol->usable_leb_size); 102 vol->used_ebs = tmp; 103 if (vol->last_eb_bytes) 104 vol->used_ebs += 1; 105 else 106 vol->last_eb_bytes = vol->usable_leb_size; 107 } 108 109 err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec); 110 vol->upd_marker = 0; 111 return err; 112} 113 114/** 115 * ubi_start_update - start volume update. 116 * @ubi: UBI device description object 117 * @vol_id: volume ID 118 * @bytes: update bytes 119 * 120 * This function starts volume update operation. If @bytes is zero, the volume 121 * is just wiped out. Returns zero in case of success and a negative error code 122 * in case of failure. 123 */ 124int ubi_start_update(struct ubi_device *ubi, int vol_id, long long bytes) 125{ 126 int i, err; 127 uint64_t tmp; 128 struct ubi_volume *vol = ubi->volumes[vol_id]; 129 130 dbg_msg("start update of volume %d, %llu bytes", vol_id, bytes); 131 vol->updating = 1; 132 133 err = set_update_marker(ubi, vol_id); 134 if (err) 135 return err; 136 137 /* Before updating - wipe out the volume */ 138 for (i = 0; i < vol->reserved_pebs; i++) { 139 err = ubi_eba_unmap_leb(ubi, vol_id, i); 140 if (err) 141 return err; 142 } 143 144 if (bytes == 0) { 145 err = clear_update_marker(ubi, vol_id, 0); 146 if (err) 147 return err; 148 err = ubi_wl_flush(ubi); 149 if (!err) 150 vol->updating = 0; 151 } 152 153 vol->upd_buf = kmalloc(ubi->leb_size, GFP_KERNEL); 154 if (!vol->upd_buf) 155 return -ENOMEM; 156 157 tmp = bytes; 158 vol->upd_ebs = !!do_div(tmp, vol->usable_leb_size); 159 vol->upd_ebs += tmp; 160 vol->upd_bytes = bytes; 161 vol->upd_received = 0; 162 return 0; 163} 164 165/** 166 * write_leb - write update data. 167 * @ubi: UBI device description object 168 * @vol_id: volume ID 169 * @lnum: logical eraseblock number 170 * @buf: data to write 171 * @len: data size 172 * @used_ebs: how many logical eraseblocks will this volume contain (static 173 * volumes only) 174 * 175 * This function writes update data to corresponding logical eraseblock. In 176 * case of dynamic volume, this function checks if the data contains 0xFF bytes 177 * at the end. If yes, the 0xFF bytes are cut and not written. So if the whole 178 * buffer contains only 0xFF bytes, the LEB is left unmapped. 179 * 180 * The reason why we skip the trailing 0xFF bytes in case of dynamic volume is 181 * that we want to make sure that more data may be appended to the logical 182 * eraseblock in future. Indeed, writing 0xFF bytes may have side effects and 183 * this PEB won't be writable anymore. So if one writes the file-system image 184 * to the UBI volume where 0xFFs mean free space - UBI makes sure this free 185 * space is writable after the update. 186 * 187 * We do not do this for static volumes because they are read-only. But this 188 * also cannot be done because we have to store per-LEB CRC and the correct 189 * data length. 190 * 191 * This function returns zero in case of success and a negative error code in 192 * case of failure. 193 */ 194static int write_leb(struct ubi_device *ubi, int vol_id, int lnum, void *buf, 195 int len, int used_ebs) 196{ 197 int err, l; 198 struct ubi_volume *vol = ubi->volumes[vol_id]; 199 200 if (vol->vol_type == UBI_DYNAMIC_VOLUME) { 201 l = ALIGN(len, ubi->min_io_size); 202 memset(buf + len, 0xFF, l - len); 203 204 l = ubi_calc_data_len(ubi, buf, l); 205 if (l == 0) { 206 dbg_msg("all %d bytes contain 0xFF - skip", len); 207 return 0; 208 } 209 if (len != l) 210 dbg_msg("skip last %d bytes (0xFF)", len - l); 211 212 err = ubi_eba_write_leb(ubi, vol_id, lnum, buf, 0, l, 213 UBI_UNKNOWN); 214 } else { 215 /* 216 * When writing static volume, and this is the last logical 217 * eraseblock, the length (@len) does not have to be aligned to 218 * the minimal flash I/O unit. The 'ubi_eba_write_leb_st()' 219 * function accepts exact (unaligned) length and stores it in 220 * the VID header. And it takes care of proper alignment by 221 * padding the buffer. Here we just make sure the padding will 222 * contain zeros, not random trash. 223 */ 224 memset(buf + len, 0, vol->usable_leb_size - len); 225 err = ubi_eba_write_leb_st(ubi, vol_id, lnum, buf, len, 226 UBI_UNKNOWN, used_ebs); 227 } 228 229 return err; 230} 231 232/** 233 * ubi_more_update_data - write more update data. 234 * @vol: volume description object 235 * @buf: write data (user-space memory buffer) 236 * @count: how much bytes to write 237 * 238 * This function writes more data to the volume which is being updated. It may 239 * be called arbitrary number of times until all of the update data arrive. 240 * This function returns %0 in case of success, number of bytes written during 241 * the last call if the whole volume update was successfully finished, and a 242 * negative error code in case of failure. 243 */ 244int ubi_more_update_data(struct ubi_device *ubi, int vol_id, 245 const void __user *buf, int count) 246{ 247 uint64_t tmp; 248 struct ubi_volume *vol = ubi->volumes[vol_id]; 249 int lnum, offs, err = 0, len, to_write = count; 250 251 dbg_msg("write %d of %lld bytes, %lld already passed", 252 count, vol->upd_bytes, vol->upd_received); 253 254 if (ubi->ro_mode) 255 return -EROFS; 256 257 tmp = vol->upd_received; 258 offs = do_div(tmp, vol->usable_leb_size); 259 lnum = tmp; 260 261 if (vol->upd_received + count > vol->upd_bytes) 262 to_write = count = vol->upd_bytes - vol->upd_received; 263 264 /* 265 * When updating volumes, we accumulate whole logical eraseblock of 266 * data and write it at once. 267 */ 268 if (offs != 0) { 269 /* 270 * This is a write to the middle of the logical eraseblock. We 271 * copy the data to our update buffer and wait for more data or 272 * flush it if the whole eraseblock is written or the update 273 * is finished. 274 */ 275 276 len = vol->usable_leb_size - offs; 277 if (len > count) 278 len = count; 279 280 err = copy_from_user(vol->upd_buf + offs, buf, len); 281 if (err) 282 return -EFAULT; 283 284 if (offs + len == vol->usable_leb_size || 285 vol->upd_received + len == vol->upd_bytes) { 286 int flush_len = offs + len; 287 288 /* 289 * OK, we gathered either the whole eraseblock or this 290 * is the last chunk, it's time to flush the buffer. 291 */ 292 ubi_assert(flush_len <= vol->usable_leb_size); 293 err = write_leb(ubi, vol_id, lnum, vol->upd_buf, 294 flush_len, vol->upd_ebs); 295 if (err) 296 return err; 297 } 298 299 vol->upd_received += len; 300 count -= len; 301 buf += len; 302 lnum += 1; 303 } 304 305 /* 306 * If we've got more to write, let's continue. At this point we know we 307 * are starting from the beginning of an eraseblock. 308 */ 309 while (count) { 310 if (count > vol->usable_leb_size) 311 len = vol->usable_leb_size; 312 else 313 len = count; 314 315 err = copy_from_user(vol->upd_buf, buf, len); 316 if (err) 317 return -EFAULT; 318 319 if (len == vol->usable_leb_size || 320 vol->upd_received + len == vol->upd_bytes) { 321 err = write_leb(ubi, vol_id, lnum, vol->upd_buf, len, 322 vol->upd_ebs); 323 if (err) 324 break; 325 } 326 327 vol->upd_received += len; 328 count -= len; 329 lnum += 1; 330 buf += len; 331 } 332 333 ubi_assert(vol->upd_received <= vol->upd_bytes); 334 if (vol->upd_received == vol->upd_bytes) { 335 /* The update is finished, clear the update marker */ 336 err = clear_update_marker(ubi, vol_id, vol->upd_bytes); 337 if (err) 338 return err; 339 err = ubi_wl_flush(ubi); 340 if (err == 0) { 341 err = to_write; 342 kfree(vol->upd_buf); 343 vol->updating = 0; 344 } 345 } 346 347 return err; 348} 349