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