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