Merge http://ftp.arm.linux.org.uk/pub/linux/arm/kernel/git-cur/linux-2.6-arm into...
[linux-2.6] / drivers / mtd / ubi / vmt.c
1 /*
2  * Copyright (c) International Business Machines Corp., 2006
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation;  either version 2 of the License, or
7  * (at your option) any later version.
8  *
9  * This program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
12  * the GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; if not, write to the Free Software
16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
17  *
18  * Author: Artem Bityutskiy (Битюцкий Артём)
19  */
20
21 /*
22  * This file contains implementation of volume creation, deletion, updating and
23  * resizing.
24  */
25
26 #include <linux/err.h>
27 #include <asm/div64.h>
28 #include "ubi.h"
29
30 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
31 static int paranoid_check_volumes(struct ubi_device *ubi);
32 #else
33 #define paranoid_check_volumes(ubi) 0
34 #endif
35
36 static ssize_t vol_attribute_show(struct device *dev,
37                                   struct device_attribute *attr, char *buf);
38
39 /* Device attributes corresponding to files in '/<sysfs>/class/ubi/ubiX_Y' */
40 static struct device_attribute attr_vol_reserved_ebs =
41         __ATTR(reserved_ebs, S_IRUGO, vol_attribute_show, NULL);
42 static struct device_attribute attr_vol_type =
43         __ATTR(type, S_IRUGO, vol_attribute_show, NULL);
44 static struct device_attribute attr_vol_name =
45         __ATTR(name, S_IRUGO, vol_attribute_show, NULL);
46 static struct device_attribute attr_vol_corrupted =
47         __ATTR(corrupted, S_IRUGO, vol_attribute_show, NULL);
48 static struct device_attribute attr_vol_alignment =
49         __ATTR(alignment, S_IRUGO, vol_attribute_show, NULL);
50 static struct device_attribute attr_vol_usable_eb_size =
51         __ATTR(usable_eb_size, S_IRUGO, vol_attribute_show, NULL);
52 static struct device_attribute attr_vol_data_bytes =
53         __ATTR(data_bytes, S_IRUGO, vol_attribute_show, NULL);
54 static struct device_attribute attr_vol_upd_marker =
55         __ATTR(upd_marker, S_IRUGO, vol_attribute_show, NULL);
56
57 /*
58  * "Show" method for files in '/<sysfs>/class/ubi/ubiX_Y/'.
59  *
60  * Consider a situation:
61  * A. process 1 opens a sysfs file related to volume Y, say
62  *    /<sysfs>/class/ubi/ubiX_Y/reserved_ebs;
63  * B. process 2 removes volume Y;
64  * C. process 1 starts reading the /<sysfs>/class/ubi/ubiX_Y/reserved_ebs file;
65  *
66  * In this situation, this function will return %-ENODEV because it will find
67  * out that the volume was removed from the @ubi->volumes array.
68  */
69 static ssize_t vol_attribute_show(struct device *dev,
70                                   struct device_attribute *attr, char *buf)
71 {
72         int ret;
73         struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev);
74         struct ubi_device *ubi;
75
76         ubi = ubi_get_device(vol->ubi->ubi_num);
77         if (!ubi)
78                 return -ENODEV;
79
80         spin_lock(&ubi->volumes_lock);
81         if (!ubi->volumes[vol->vol_id]) {
82                 spin_unlock(&ubi->volumes_lock);
83                 ubi_put_device(ubi);
84                 return -ENODEV;
85         }
86         /* Take a reference to prevent volume removal */
87         vol->ref_count += 1;
88         spin_unlock(&ubi->volumes_lock);
89
90         if (attr == &attr_vol_reserved_ebs)
91                 ret = sprintf(buf, "%d\n", vol->reserved_pebs);
92         else if (attr == &attr_vol_type) {
93                 const char *tp;
94
95                 if (vol->vol_type == UBI_DYNAMIC_VOLUME)
96                         tp = "dynamic";
97                 else
98                         tp = "static";
99                 ret = sprintf(buf, "%s\n", tp);
100         } else if (attr == &attr_vol_name)
101                 ret = sprintf(buf, "%s\n", vol->name);
102         else if (attr == &attr_vol_corrupted)
103                 ret = sprintf(buf, "%d\n", vol->corrupted);
104         else if (attr == &attr_vol_alignment)
105                 ret = sprintf(buf, "%d\n", vol->alignment);
106         else if (attr == &attr_vol_usable_eb_size)
107                 ret = sprintf(buf, "%d\n", vol->usable_leb_size);
108         else if (attr == &attr_vol_data_bytes)
109                 ret = sprintf(buf, "%lld\n", vol->used_bytes);
110         else if (attr == &attr_vol_upd_marker)
111                 ret = sprintf(buf, "%d\n", vol->upd_marker);
112         else
113                 /* This must be a bug */
114                 ret = -EINVAL;
115
116         /* We've done the operation, drop volume and UBI device references */
117         spin_lock(&ubi->volumes_lock);
118         vol->ref_count -= 1;
119         ubi_assert(vol->ref_count >= 0);
120         spin_unlock(&ubi->volumes_lock);
121         ubi_put_device(ubi);
122         return ret;
123 }
124
125 /* Release method for volume devices */
126 static void vol_release(struct device *dev)
127 {
128         struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev);
129
130         kfree(vol->eba_tbl);
131         kfree(vol);
132 }
133
134 /**
135  * volume_sysfs_init - initialize sysfs for new volume.
136  * @ubi: UBI device description object
137  * @vol: volume description object
138  *
139  * This function returns zero in case of success and a negative error code in
140  * case of failure.
141  *
142  * Note, this function does not free allocated resources in case of failure -
143  * the caller does it. This is because this would cause release() here and the
144  * caller would oops.
145  */
146 static int volume_sysfs_init(struct ubi_device *ubi, struct ubi_volume *vol)
147 {
148         int err;
149
150         err = device_create_file(&vol->dev, &attr_vol_reserved_ebs);
151         if (err)
152                 return err;
153         err = device_create_file(&vol->dev, &attr_vol_type);
154         if (err)
155                 return err;
156         err = device_create_file(&vol->dev, &attr_vol_name);
157         if (err)
158                 return err;
159         err = device_create_file(&vol->dev, &attr_vol_corrupted);
160         if (err)
161                 return err;
162         err = device_create_file(&vol->dev, &attr_vol_alignment);
163         if (err)
164                 return err;
165         err = device_create_file(&vol->dev, &attr_vol_usable_eb_size);
166         if (err)
167                 return err;
168         err = device_create_file(&vol->dev, &attr_vol_data_bytes);
169         if (err)
170                 return err;
171         err = device_create_file(&vol->dev, &attr_vol_upd_marker);
172         return err;
173 }
174
175 /**
176  * volume_sysfs_close - close sysfs for a volume.
177  * @vol: volume description object
178  */
179 static void volume_sysfs_close(struct ubi_volume *vol)
180 {
181         device_remove_file(&vol->dev, &attr_vol_upd_marker);
182         device_remove_file(&vol->dev, &attr_vol_data_bytes);
183         device_remove_file(&vol->dev, &attr_vol_usable_eb_size);
184         device_remove_file(&vol->dev, &attr_vol_alignment);
185         device_remove_file(&vol->dev, &attr_vol_corrupted);
186         device_remove_file(&vol->dev, &attr_vol_name);
187         device_remove_file(&vol->dev, &attr_vol_type);
188         device_remove_file(&vol->dev, &attr_vol_reserved_ebs);
189         device_unregister(&vol->dev);
190 }
191
192 /**
193  * ubi_create_volume - create volume.
194  * @ubi: UBI device description object
195  * @req: volume creation request
196  *
197  * This function creates volume described by @req. If @req->vol_id id
198  * %UBI_VOL_NUM_AUTO, this function automatically assign ID to the new volume
199  * and saves it in @req->vol_id. Returns zero in case of success and a negative
200  * error code in case of failure. Note, the caller has to have the
201  * @ubi->volumes_mutex locked.
202  */
203 int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
204 {
205         int i, err, vol_id = req->vol_id, do_free = 1;
206         struct ubi_volume *vol;
207         struct ubi_vtbl_record vtbl_rec;
208         uint64_t bytes;
209         dev_t dev;
210
211         if (ubi->ro_mode)
212                 return -EROFS;
213
214         vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
215         if (!vol)
216                 return -ENOMEM;
217
218         spin_lock(&ubi->volumes_lock);
219         if (vol_id == UBI_VOL_NUM_AUTO) {
220                 /* Find unused volume ID */
221                 dbg_gen("search for vacant volume ID");
222                 for (i = 0; i < ubi->vtbl_slots; i++)
223                         if (!ubi->volumes[i]) {
224                                 vol_id = i;
225                                 break;
226                         }
227
228                 if (vol_id == UBI_VOL_NUM_AUTO) {
229                         dbg_err("out of volume IDs");
230                         err = -ENFILE;
231                         goto out_unlock;
232                 }
233                 req->vol_id = vol_id;
234         }
235
236         dbg_gen("volume ID %d, %llu bytes, type %d, name %s",
237                 vol_id, (unsigned long long)req->bytes,
238                 (int)req->vol_type, req->name);
239
240         /* Ensure that this volume does not exist */
241         err = -EEXIST;
242         if (ubi->volumes[vol_id]) {
243                 dbg_err("volume %d already exists", vol_id);
244                 goto out_unlock;
245         }
246
247         /* Ensure that the name is unique */
248         for (i = 0; i < ubi->vtbl_slots; i++)
249                 if (ubi->volumes[i] &&
250                     ubi->volumes[i]->name_len == req->name_len &&
251                     !strcmp(ubi->volumes[i]->name, req->name)) {
252                         dbg_err("volume \"%s\" exists (ID %d)", req->name, i);
253                         goto out_unlock;
254                 }
255
256         /* Calculate how many eraseblocks are requested */
257         vol->usable_leb_size = ubi->leb_size - ubi->leb_size % req->alignment;
258         bytes = req->bytes;
259         if (do_div(bytes, vol->usable_leb_size))
260                 vol->reserved_pebs = 1;
261         vol->reserved_pebs += bytes;
262
263         /* Reserve physical eraseblocks */
264         if (vol->reserved_pebs > ubi->avail_pebs) {
265                 dbg_err("not enough PEBs, only %d available", ubi->avail_pebs);
266                 err = -ENOSPC;
267                 goto out_unlock;
268         }
269         ubi->avail_pebs -= vol->reserved_pebs;
270         ubi->rsvd_pebs += vol->reserved_pebs;
271         spin_unlock(&ubi->volumes_lock);
272
273         vol->vol_id    = vol_id;
274         vol->alignment = req->alignment;
275         vol->data_pad  = ubi->leb_size % vol->alignment;
276         vol->vol_type  = req->vol_type;
277         vol->name_len  = req->name_len;
278         memcpy(vol->name, req->name, vol->name_len);
279         vol->ubi = ubi;
280
281         /*
282          * Finish all pending erases because there may be some LEBs belonging
283          * to the same volume ID.
284          */
285         err = ubi_wl_flush(ubi);
286         if (err)
287                 goto out_acc;
288
289         vol->eba_tbl = kmalloc(vol->reserved_pebs * sizeof(int), GFP_KERNEL);
290         if (!vol->eba_tbl) {
291                 err = -ENOMEM;
292                 goto out_acc;
293         }
294
295         for (i = 0; i < vol->reserved_pebs; i++)
296                 vol->eba_tbl[i] = UBI_LEB_UNMAPPED;
297
298         if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
299                 vol->used_ebs = vol->reserved_pebs;
300                 vol->last_eb_bytes = vol->usable_leb_size;
301                 vol->used_bytes =
302                         (long long)vol->used_ebs * vol->usable_leb_size;
303         } else {
304                 bytes = vol->used_bytes;
305                 vol->last_eb_bytes = do_div(bytes, vol->usable_leb_size);
306                 vol->used_ebs = bytes;
307                 if (vol->last_eb_bytes)
308                         vol->used_ebs += 1;
309                 else
310                         vol->last_eb_bytes = vol->usable_leb_size;
311         }
312
313         /* Register character device for the volume */
314         cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
315         vol->cdev.owner = THIS_MODULE;
316         dev = MKDEV(MAJOR(ubi->cdev.dev), vol_id + 1);
317         err = cdev_add(&vol->cdev, dev, 1);
318         if (err) {
319                 ubi_err("cannot add character device");
320                 goto out_mapping;
321         }
322
323         err = ubi_create_gluebi(ubi, vol);
324         if (err)
325                 goto out_cdev;
326
327         vol->dev.release = vol_release;
328         vol->dev.parent = &ubi->dev;
329         vol->dev.devt = dev;
330         vol->dev.class = ubi_class;
331
332         sprintf(&vol->dev.bus_id[0], "%s_%d", ubi->ubi_name, vol->vol_id);
333         err = device_register(&vol->dev);
334         if (err) {
335                 ubi_err("cannot register device");
336                 goto out_gluebi;
337         }
338
339         err = volume_sysfs_init(ubi, vol);
340         if (err)
341                 goto out_sysfs;
342
343         /* Fill volume table record */
344         memset(&vtbl_rec, 0, sizeof(struct ubi_vtbl_record));
345         vtbl_rec.reserved_pebs = cpu_to_be32(vol->reserved_pebs);
346         vtbl_rec.alignment     = cpu_to_be32(vol->alignment);
347         vtbl_rec.data_pad      = cpu_to_be32(vol->data_pad);
348         vtbl_rec.name_len      = cpu_to_be16(vol->name_len);
349         if (vol->vol_type == UBI_DYNAMIC_VOLUME)
350                 vtbl_rec.vol_type = UBI_VID_DYNAMIC;
351         else
352                 vtbl_rec.vol_type = UBI_VID_STATIC;
353         memcpy(vtbl_rec.name, vol->name, vol->name_len);
354
355         err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
356         if (err)
357                 goto out_sysfs;
358
359         spin_lock(&ubi->volumes_lock);
360         ubi->volumes[vol_id] = vol;
361         ubi->vol_count += 1;
362         spin_unlock(&ubi->volumes_lock);
363
364         err = paranoid_check_volumes(ubi);
365         return err;
366
367 out_sysfs:
368         /*
369          * We have registered our device, we should not free the volume
370          * description object in this function in case of an error - it is
371          * freed by the release function.
372          *
373          * Get device reference to prevent the release function from being
374          * called just after sysfs has been closed.
375          */
376         do_free = 0;
377         get_device(&vol->dev);
378         volume_sysfs_close(vol);
379 out_gluebi:
380         if (ubi_destroy_gluebi(vol))
381                 dbg_err("cannot destroy gluebi for volume %d:%d",
382                         ubi->ubi_num, vol_id);
383 out_cdev:
384         cdev_del(&vol->cdev);
385 out_mapping:
386         if (do_free)
387                 kfree(vol->eba_tbl);
388 out_acc:
389         spin_lock(&ubi->volumes_lock);
390         ubi->rsvd_pebs -= vol->reserved_pebs;
391         ubi->avail_pebs += vol->reserved_pebs;
392 out_unlock:
393         spin_unlock(&ubi->volumes_lock);
394         if (do_free)
395                 kfree(vol);
396         else
397                 put_device(&vol->dev);
398         ubi_err("cannot create volume %d, error %d", vol_id, err);
399         return err;
400 }
401
402 /**
403  * ubi_remove_volume - remove volume.
404  * @desc: volume descriptor
405  * @no_vtbl: do not change volume table if not zero
406  *
407  * This function removes volume described by @desc. The volume has to be opened
408  * in "exclusive" mode. Returns zero in case of success and a negative error
409  * code in case of failure. The caller has to have the @ubi->volumes_mutex
410  * locked.
411  */
412 int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl)
413 {
414         struct ubi_volume *vol = desc->vol;
415         struct ubi_device *ubi = vol->ubi;
416         int i, err, vol_id = vol->vol_id, reserved_pebs = vol->reserved_pebs;
417
418         dbg_gen("remove UBI volume %d", vol_id);
419         ubi_assert(desc->mode == UBI_EXCLUSIVE);
420         ubi_assert(vol == ubi->volumes[vol_id]);
421
422         if (ubi->ro_mode)
423                 return -EROFS;
424
425         spin_lock(&ubi->volumes_lock);
426         if (vol->ref_count > 1) {
427                 /*
428                  * The volume is busy, probably someone is reading one of its
429                  * sysfs files.
430                  */
431                 err = -EBUSY;
432                 goto out_unlock;
433         }
434         ubi->volumes[vol_id] = NULL;
435         spin_unlock(&ubi->volumes_lock);
436
437         err = ubi_destroy_gluebi(vol);
438         if (err)
439                 goto out_err;
440
441         if (!no_vtbl) {
442                 err = ubi_change_vtbl_record(ubi, vol_id, NULL);
443                 if (err)
444                         goto out_err;
445         }
446
447         for (i = 0; i < vol->reserved_pebs; i++) {
448                 err = ubi_eba_unmap_leb(ubi, vol, i);
449                 if (err)
450                         goto out_err;
451         }
452
453         cdev_del(&vol->cdev);
454         volume_sysfs_close(vol);
455
456         spin_lock(&ubi->volumes_lock);
457         ubi->rsvd_pebs -= reserved_pebs;
458         ubi->avail_pebs += reserved_pebs;
459         i = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
460         if (i > 0) {
461                 i = ubi->avail_pebs >= i ? i : ubi->avail_pebs;
462                 ubi->avail_pebs -= i;
463                 ubi->rsvd_pebs += i;
464                 ubi->beb_rsvd_pebs += i;
465                 if (i > 0)
466                         ubi_msg("reserve more %d PEBs", i);
467         }
468         ubi->vol_count -= 1;
469         spin_unlock(&ubi->volumes_lock);
470
471         if (!no_vtbl)
472                 err = paranoid_check_volumes(ubi);
473         return err;
474
475 out_err:
476         ubi_err("cannot remove volume %d, error %d", vol_id, err);
477         spin_lock(&ubi->volumes_lock);
478         ubi->volumes[vol_id] = vol;
479 out_unlock:
480         spin_unlock(&ubi->volumes_lock);
481         return err;
482 }
483
484 /**
485  * ubi_resize_volume - re-size volume.
486  * @desc: volume descriptor
487  * @reserved_pebs: new size in physical eraseblocks
488  *
489  * This function re-sizes the volume and returns zero in case of success, and a
490  * negative error code in case of failure. The caller has to have the
491  * @ubi->volumes_mutex locked.
492  */
493 int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs)
494 {
495         int i, err, pebs, *new_mapping;
496         struct ubi_volume *vol = desc->vol;
497         struct ubi_device *ubi = vol->ubi;
498         struct ubi_vtbl_record vtbl_rec;
499         int vol_id = vol->vol_id;
500
501         if (ubi->ro_mode)
502                 return -EROFS;
503
504         dbg_gen("re-size volume %d to from %d to %d PEBs",
505                 vol_id, vol->reserved_pebs, reserved_pebs);
506
507         if (vol->vol_type == UBI_STATIC_VOLUME &&
508             reserved_pebs < vol->used_ebs) {
509                 dbg_err("too small size %d, %d LEBs contain data",
510                         reserved_pebs, vol->used_ebs);
511                 return -EINVAL;
512         }
513
514         /* If the size is the same, we have nothing to do */
515         if (reserved_pebs == vol->reserved_pebs)
516                 return 0;
517
518         new_mapping = kmalloc(reserved_pebs * sizeof(int), GFP_KERNEL);
519         if (!new_mapping)
520                 return -ENOMEM;
521
522         for (i = 0; i < reserved_pebs; i++)
523                 new_mapping[i] = UBI_LEB_UNMAPPED;
524
525         spin_lock(&ubi->volumes_lock);
526         if (vol->ref_count > 1) {
527                 spin_unlock(&ubi->volumes_lock);
528                 err = -EBUSY;
529                 goto out_free;
530         }
531         spin_unlock(&ubi->volumes_lock);
532
533         /* Reserve physical eraseblocks */
534         pebs = reserved_pebs - vol->reserved_pebs;
535         if (pebs > 0) {
536                 spin_lock(&ubi->volumes_lock);
537                 if (pebs > ubi->avail_pebs) {
538                         dbg_err("not enough PEBs: requested %d, available %d",
539                                 pebs, ubi->avail_pebs);
540                         spin_unlock(&ubi->volumes_lock);
541                         err = -ENOSPC;
542                         goto out_free;
543                 }
544                 ubi->avail_pebs -= pebs;
545                 ubi->rsvd_pebs += pebs;
546                 for (i = 0; i < vol->reserved_pebs; i++)
547                         new_mapping[i] = vol->eba_tbl[i];
548                 kfree(vol->eba_tbl);
549                 vol->eba_tbl = new_mapping;
550                 spin_unlock(&ubi->volumes_lock);
551         }
552
553         /* Change volume table record */
554         memcpy(&vtbl_rec, &ubi->vtbl[vol_id], sizeof(struct ubi_vtbl_record));
555         vtbl_rec.reserved_pebs = cpu_to_be32(reserved_pebs);
556         err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
557         if (err)
558                 goto out_acc;
559
560         if (pebs < 0) {
561                 for (i = 0; i < -pebs; i++) {
562                         err = ubi_eba_unmap_leb(ubi, vol, reserved_pebs + i);
563                         if (err)
564                                 goto out_acc;
565                 }
566                 spin_lock(&ubi->volumes_lock);
567                 ubi->rsvd_pebs += pebs;
568                 ubi->avail_pebs -= pebs;
569                 pebs = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
570                 if (pebs > 0) {
571                         pebs = ubi->avail_pebs >= pebs ? pebs : ubi->avail_pebs;
572                         ubi->avail_pebs -= pebs;
573                         ubi->rsvd_pebs += pebs;
574                         ubi->beb_rsvd_pebs += pebs;
575                         if (pebs > 0)
576                                 ubi_msg("reserve more %d PEBs", pebs);
577                 }
578                 for (i = 0; i < reserved_pebs; i++)
579                         new_mapping[i] = vol->eba_tbl[i];
580                 kfree(vol->eba_tbl);
581                 vol->eba_tbl = new_mapping;
582                 spin_unlock(&ubi->volumes_lock);
583         }
584
585         vol->reserved_pebs = reserved_pebs;
586         if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
587                 vol->used_ebs = reserved_pebs;
588                 vol->last_eb_bytes = vol->usable_leb_size;
589                 vol->used_bytes =
590                         (long long)vol->used_ebs * vol->usable_leb_size;
591         }
592
593         err = paranoid_check_volumes(ubi);
594         return err;
595
596 out_acc:
597         if (pebs > 0) {
598                 spin_lock(&ubi->volumes_lock);
599                 ubi->rsvd_pebs -= pebs;
600                 ubi->avail_pebs += pebs;
601                 spin_unlock(&ubi->volumes_lock);
602         }
603 out_free:
604         kfree(new_mapping);
605         return err;
606 }
607
608 /**
609  * ubi_rename_volumes - re-name UBI volumes.
610  * @ubi: UBI device description object
611  * @rename_list: list of &struct ubi_rename_entry objects
612  *
613  * This function re-names or removes volumes specified in the re-name list.
614  * Returns zero in case of success and a negative error code in case of
615  * failure.
616  */
617 int ubi_rename_volumes(struct ubi_device *ubi, struct list_head *rename_list)
618 {
619         int err;
620         struct ubi_rename_entry *re;
621
622         err = ubi_vtbl_rename_volumes(ubi, rename_list);
623         if (err)
624                 return err;
625
626         list_for_each_entry(re, rename_list, list) {
627                 if (re->remove) {
628                         err = ubi_remove_volume(re->desc, 1);
629                         if (err)
630                                 break;
631                 } else {
632                         struct ubi_volume *vol = re->desc->vol;
633
634                         spin_lock(&ubi->volumes_lock);
635                         vol->name_len = re->new_name_len;
636                         memcpy(vol->name, re->new_name, re->new_name_len + 1);
637                         spin_unlock(&ubi->volumes_lock);
638                 }
639         }
640
641         if (!err)
642                 err = paranoid_check_volumes(ubi);
643         return err;
644 }
645
646 /**
647  * ubi_add_volume - add volume.
648  * @ubi: UBI device description object
649  * @vol: volume description object
650  *
651  * This function adds an existing volume and initializes all its data
652  * structures. Returns zero in case of success and a negative error code in
653  * case of failure.
654  */
655 int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol)
656 {
657         int err, vol_id = vol->vol_id;
658         dev_t dev;
659
660         dbg_gen("add volume %d", vol_id);
661
662         /* Register character device for the volume */
663         cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
664         vol->cdev.owner = THIS_MODULE;
665         dev = MKDEV(MAJOR(ubi->cdev.dev), vol->vol_id + 1);
666         err = cdev_add(&vol->cdev, dev, 1);
667         if (err) {
668                 ubi_err("cannot add character device for volume %d, error %d",
669                         vol_id, err);
670                 return err;
671         }
672
673         err = ubi_create_gluebi(ubi, vol);
674         if (err)
675                 goto out_cdev;
676
677         vol->dev.release = vol_release;
678         vol->dev.parent = &ubi->dev;
679         vol->dev.devt = dev;
680         vol->dev.class = ubi_class;
681         sprintf(&vol->dev.bus_id[0], "%s_%d", ubi->ubi_name, vol->vol_id);
682         err = device_register(&vol->dev);
683         if (err)
684                 goto out_gluebi;
685
686         err = volume_sysfs_init(ubi, vol);
687         if (err) {
688                 cdev_del(&vol->cdev);
689                 err = ubi_destroy_gluebi(vol);
690                 volume_sysfs_close(vol);
691                 return err;
692         }
693
694         err = paranoid_check_volumes(ubi);
695         return err;
696
697 out_gluebi:
698         err = ubi_destroy_gluebi(vol);
699 out_cdev:
700         cdev_del(&vol->cdev);
701         return err;
702 }
703
704 /**
705  * ubi_free_volume - free volume.
706  * @ubi: UBI device description object
707  * @vol: volume description object
708  *
709  * This function frees all resources for volume @vol but does not remove it.
710  * Used only when the UBI device is detached.
711  */
712 void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol)
713 {
714         int err;
715
716         dbg_gen("free volume %d", vol->vol_id);
717
718         ubi->volumes[vol->vol_id] = NULL;
719         err = ubi_destroy_gluebi(vol);
720         cdev_del(&vol->cdev);
721         volume_sysfs_close(vol);
722 }
723
724 #ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
725
726 /**
727  * paranoid_check_volume - check volume information.
728  * @ubi: UBI device description object
729  * @vol_id: volume ID
730  *
731  * Returns zero if volume is all right and a a negative error code if not.
732  */
733 static int paranoid_check_volume(struct ubi_device *ubi, int vol_id)
734 {
735         int idx = vol_id2idx(ubi, vol_id);
736         int reserved_pebs, alignment, data_pad, vol_type, name_len, upd_marker;
737         const struct ubi_volume *vol;
738         long long n;
739         const char *name;
740
741         spin_lock(&ubi->volumes_lock);
742         reserved_pebs = be32_to_cpu(ubi->vtbl[vol_id].reserved_pebs);
743         vol = ubi->volumes[idx];
744
745         if (!vol) {
746                 if (reserved_pebs) {
747                         ubi_err("no volume info, but volume exists");
748                         goto fail;
749                 }
750                 spin_unlock(&ubi->volumes_lock);
751                 return 0;
752         }
753
754         if (vol->reserved_pebs < 0 || vol->alignment < 0 || vol->data_pad < 0 ||
755             vol->name_len < 0) {
756                 ubi_err("negative values");
757                 goto fail;
758         }
759         if (vol->alignment > ubi->leb_size || vol->alignment == 0) {
760                 ubi_err("bad alignment");
761                 goto fail;
762         }
763
764         n = vol->alignment & (ubi->min_io_size - 1);
765         if (vol->alignment != 1 && n) {
766                 ubi_err("alignment is not multiple of min I/O unit");
767                 goto fail;
768         }
769
770         n = ubi->leb_size % vol->alignment;
771         if (vol->data_pad != n) {
772                 ubi_err("bad data_pad, has to be %lld", n);
773                 goto fail;
774         }
775
776         if (vol->vol_type != UBI_DYNAMIC_VOLUME &&
777             vol->vol_type != UBI_STATIC_VOLUME) {
778                 ubi_err("bad vol_type");
779                 goto fail;
780         }
781
782         if (vol->upd_marker && vol->corrupted) {
783                 dbg_err("update marker and corrupted simultaneously");
784                 goto fail;
785         }
786
787         if (vol->reserved_pebs > ubi->good_peb_count) {
788                 ubi_err("too large reserved_pebs");
789                 goto fail;
790         }
791
792         n = ubi->leb_size - vol->data_pad;
793         if (vol->usable_leb_size != ubi->leb_size - vol->data_pad) {
794                 ubi_err("bad usable_leb_size, has to be %lld", n);
795                 goto fail;
796         }
797
798         if (vol->name_len > UBI_VOL_NAME_MAX) {
799                 ubi_err("too long volume name, max is %d", UBI_VOL_NAME_MAX);
800                 goto fail;
801         }
802
803         if (!vol->name) {
804                 ubi_err("NULL volume name");
805                 goto fail;
806         }
807
808         n = strnlen(vol->name, vol->name_len + 1);
809         if (n != vol->name_len) {
810                 ubi_err("bad name_len %lld", n);
811                 goto fail;
812         }
813
814         n = (long long)vol->used_ebs * vol->usable_leb_size;
815         if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
816                 if (vol->corrupted) {
817                         ubi_err("corrupted dynamic volume");
818                         goto fail;
819                 }
820                 if (vol->used_ebs != vol->reserved_pebs) {
821                         ubi_err("bad used_ebs");
822                         goto fail;
823                 }
824                 if (vol->last_eb_bytes != vol->usable_leb_size) {
825                         ubi_err("bad last_eb_bytes");
826                         goto fail;
827                 }
828                 if (vol->used_bytes != n) {
829                         ubi_err("bad used_bytes");
830                         goto fail;
831                 }
832         } else {
833                 if (vol->used_ebs < 0 || vol->used_ebs > vol->reserved_pebs) {
834                         ubi_err("bad used_ebs");
835                         goto fail;
836                 }
837                 if (vol->last_eb_bytes < 0 ||
838                     vol->last_eb_bytes > vol->usable_leb_size) {
839                         ubi_err("bad last_eb_bytes");
840                         goto fail;
841                 }
842                 if (vol->used_bytes < 0 || vol->used_bytes > n ||
843                     vol->used_bytes < n - vol->usable_leb_size) {
844                         ubi_err("bad used_bytes");
845                         goto fail;
846                 }
847         }
848
849         alignment  = be32_to_cpu(ubi->vtbl[vol_id].alignment);
850         data_pad   = be32_to_cpu(ubi->vtbl[vol_id].data_pad);
851         name_len   = be16_to_cpu(ubi->vtbl[vol_id].name_len);
852         upd_marker = ubi->vtbl[vol_id].upd_marker;
853         name       = &ubi->vtbl[vol_id].name[0];
854         if (ubi->vtbl[vol_id].vol_type == UBI_VID_DYNAMIC)
855                 vol_type = UBI_DYNAMIC_VOLUME;
856         else
857                 vol_type = UBI_STATIC_VOLUME;
858
859         if (alignment != vol->alignment || data_pad != vol->data_pad ||
860             upd_marker != vol->upd_marker || vol_type != vol->vol_type ||
861             name_len != vol->name_len || strncmp(name, vol->name, name_len)) {
862                 ubi_err("volume info is different");
863                 goto fail;
864         }
865
866         spin_unlock(&ubi->volumes_lock);
867         return 0;
868
869 fail:
870         ubi_err("paranoid check failed for volume %d", vol_id);
871         if (vol)
872                 ubi_dbg_dump_vol_info(vol);
873         ubi_dbg_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id);
874         spin_unlock(&ubi->volumes_lock);
875         return -EINVAL;
876 }
877
878 /**
879  * paranoid_check_volumes - check information about all volumes.
880  * @ubi: UBI device description object
881  *
882  * Returns zero if volumes are all right and a a negative error code if not.
883  */
884 static int paranoid_check_volumes(struct ubi_device *ubi)
885 {
886         int i, err = 0;
887
888         for (i = 0; i < ubi->vtbl_slots; i++) {
889                 err = paranoid_check_volume(ubi, i);
890                 if (err)
891                         break;
892         }
893
894         return err;
895 }
896 #endif