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