11a59d1b8SThomas Gleixner // SPDX-License-Identifier: GPL-2.0-or-later
2801c135cSArtem B. Bityutskiy /*
3801c135cSArtem B. Bityutskiy * Copyright (c) International Business Machines Corp., 2006
4801c135cSArtem B. Bityutskiy *
5801c135cSArtem B. Bityutskiy * Author: Artem Bityutskiy (Битюцкий Артём)
6801c135cSArtem B. Bityutskiy */
7801c135cSArtem B. Bityutskiy
8801c135cSArtem B. Bityutskiy /*
9801c135cSArtem B. Bityutskiy * This file contains implementation of volume creation, deletion, updating and
10801c135cSArtem B. Bityutskiy * resizing.
11801c135cSArtem B. Bityutskiy */
12801c135cSArtem B. Bityutskiy
13801c135cSArtem B. Bityutskiy #include <linux/err.h>
143013ee31SArtem Bityutskiy #include <linux/math64.h>
155a0e3ad6STejun Heo #include <linux/slab.h>
16f3bcc017SPaul Gortmaker #include <linux/export.h>
17801c135cSArtem B. Bityutskiy #include "ubi.h"
18801c135cSArtem B. Bityutskiy
197bf523aeSArtem Bityutskiy static int self_check_volumes(struct ubi_device *ubi);
20801c135cSArtem B. Bityutskiy
21801c135cSArtem B. Bityutskiy static ssize_t vol_attribute_show(struct device *dev,
22801c135cSArtem B. Bityutskiy struct device_attribute *attr, char *buf);
23801c135cSArtem B. Bityutskiy
24801c135cSArtem B. Bityutskiy /* Device attributes corresponding to files in '/<sysfs>/class/ubi/ubiX_Y' */
258bc22961SArtem Bityutskiy static struct device_attribute attr_vol_reserved_ebs =
26801c135cSArtem B. Bityutskiy __ATTR(reserved_ebs, S_IRUGO, vol_attribute_show, NULL);
278bc22961SArtem Bityutskiy static struct device_attribute attr_vol_type =
28801c135cSArtem B. Bityutskiy __ATTR(type, S_IRUGO, vol_attribute_show, NULL);
298bc22961SArtem Bityutskiy static struct device_attribute attr_vol_name =
30801c135cSArtem B. Bityutskiy __ATTR(name, S_IRUGO, vol_attribute_show, NULL);
318bc22961SArtem Bityutskiy static struct device_attribute attr_vol_corrupted =
32801c135cSArtem B. Bityutskiy __ATTR(corrupted, S_IRUGO, vol_attribute_show, NULL);
338bc22961SArtem Bityutskiy static struct device_attribute attr_vol_alignment =
34801c135cSArtem B. Bityutskiy __ATTR(alignment, S_IRUGO, vol_attribute_show, NULL);
358bc22961SArtem Bityutskiy static struct device_attribute attr_vol_usable_eb_size =
36801c135cSArtem B. Bityutskiy __ATTR(usable_eb_size, S_IRUGO, vol_attribute_show, NULL);
378bc22961SArtem Bityutskiy static struct device_attribute attr_vol_data_bytes =
38801c135cSArtem B. Bityutskiy __ATTR(data_bytes, S_IRUGO, vol_attribute_show, NULL);
398bc22961SArtem Bityutskiy static struct device_attribute attr_vol_upd_marker =
40801c135cSArtem B. Bityutskiy __ATTR(upd_marker, S_IRUGO, vol_attribute_show, NULL);
41801c135cSArtem B. Bityutskiy
42801c135cSArtem B. Bityutskiy /*
43801c135cSArtem B. Bityutskiy * "Show" method for files in '/<sysfs>/class/ubi/ubiX_Y/'.
44801c135cSArtem B. Bityutskiy *
45801c135cSArtem B. Bityutskiy * Consider a situation:
46801c135cSArtem B. Bityutskiy * A. process 1 opens a sysfs file related to volume Y, say
47801c135cSArtem B. Bityutskiy * /<sysfs>/class/ubi/ubiX_Y/reserved_ebs;
48801c135cSArtem B. Bityutskiy * B. process 2 removes volume Y;
49801c135cSArtem B. Bityutskiy * C. process 1 starts reading the /<sysfs>/class/ubi/ubiX_Y/reserved_ebs file;
50801c135cSArtem B. Bityutskiy *
51d05c77a8SArtem Bityutskiy * In this situation, this function will return %-ENODEV because it will find
52d05c77a8SArtem Bityutskiy * out that the volume was removed from the @ubi->volumes array.
53801c135cSArtem B. Bityutskiy */
vol_attribute_show(struct device * dev,struct device_attribute * attr,char * buf)54801c135cSArtem B. Bityutskiy static ssize_t vol_attribute_show(struct device *dev,
55801c135cSArtem B. Bityutskiy struct device_attribute *attr, char *buf)
56801c135cSArtem B. Bityutskiy {
57d05c77a8SArtem Bityutskiy int ret;
58801c135cSArtem B. Bityutskiy struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev);
593cbf0e39SBaokun Li struct ubi_device *ubi = vol->ubi;
60801c135cSArtem B. Bityutskiy
61d05c77a8SArtem Bityutskiy spin_lock(&ubi->volumes_lock);
62d05c77a8SArtem Bityutskiy if (!ubi->volumes[vol->vol_id]) {
63d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
64d05c77a8SArtem Bityutskiy return -ENODEV;
65801c135cSArtem B. Bityutskiy }
66d05c77a8SArtem Bityutskiy /* Take a reference to prevent volume removal */
67d05c77a8SArtem Bityutskiy vol->ref_count += 1;
68d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
69732aeacfSArtem Bityutskiy
708bc22961SArtem Bityutskiy if (attr == &attr_vol_reserved_ebs)
71801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%d\n", vol->reserved_pebs);
728bc22961SArtem Bityutskiy else if (attr == &attr_vol_type) {
73801c135cSArtem B. Bityutskiy const char *tp;
748bc22961SArtem Bityutskiy
758bc22961SArtem Bityutskiy if (vol->vol_type == UBI_DYNAMIC_VOLUME)
768bc22961SArtem Bityutskiy tp = "dynamic";
778bc22961SArtem Bityutskiy else
788bc22961SArtem Bityutskiy tp = "static";
79801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%s\n", tp);
808bc22961SArtem Bityutskiy } else if (attr == &attr_vol_name)
81801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%s\n", vol->name);
828bc22961SArtem Bityutskiy else if (attr == &attr_vol_corrupted)
83801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%d\n", vol->corrupted);
848bc22961SArtem Bityutskiy else if (attr == &attr_vol_alignment)
85801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%d\n", vol->alignment);
86732aeacfSArtem Bityutskiy else if (attr == &attr_vol_usable_eb_size)
87801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%d\n", vol->usable_leb_size);
88732aeacfSArtem Bityutskiy else if (attr == &attr_vol_data_bytes)
89801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%lld\n", vol->used_bytes);
908bc22961SArtem Bityutskiy else if (attr == &attr_vol_upd_marker)
91801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%d\n", vol->upd_marker);
92801c135cSArtem B. Bityutskiy else
93d05c77a8SArtem Bityutskiy /* This must be a bug */
94d05c77a8SArtem Bityutskiy ret = -EINVAL;
95d05c77a8SArtem Bityutskiy
96e73f4459SArtem Bityutskiy /* We've done the operation, drop volume and UBI device references */
97d05c77a8SArtem Bityutskiy spin_lock(&ubi->volumes_lock);
98d05c77a8SArtem Bityutskiy vol->ref_count -= 1;
99d05c77a8SArtem Bityutskiy ubi_assert(vol->ref_count >= 0);
100d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
101801c135cSArtem B. Bityutskiy return ret;
102801c135cSArtem B. Bityutskiy }
103801c135cSArtem B. Bityutskiy
10453cd255cSTakashi Iwai static struct attribute *volume_dev_attrs[] = {
10553cd255cSTakashi Iwai &attr_vol_reserved_ebs.attr,
10653cd255cSTakashi Iwai &attr_vol_type.attr,
10753cd255cSTakashi Iwai &attr_vol_name.attr,
10853cd255cSTakashi Iwai &attr_vol_corrupted.attr,
10953cd255cSTakashi Iwai &attr_vol_alignment.attr,
11053cd255cSTakashi Iwai &attr_vol_usable_eb_size.attr,
11153cd255cSTakashi Iwai &attr_vol_data_bytes.attr,
11253cd255cSTakashi Iwai &attr_vol_upd_marker.attr,
11353cd255cSTakashi Iwai NULL
11453cd255cSTakashi Iwai };
11553cd255cSTakashi Iwai ATTRIBUTE_GROUPS(volume_dev);
11653cd255cSTakashi Iwai
117801c135cSArtem B. Bityutskiy /* Release method for volume devices */
vol_release(struct device * dev)118801c135cSArtem B. Bityutskiy static void vol_release(struct device *dev)
119801c135cSArtem B. Bityutskiy {
120801c135cSArtem B. Bityutskiy struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev);
121732aeacfSArtem Bityutskiy
122799dca34SBoris Brezillon ubi_eba_replace_table(vol, NULL);
12334653fd8SRichard Weinberger ubi_fastmap_destroy_checkmap(vol);
124801c135cSArtem B. Bityutskiy kfree(vol);
125801c135cSArtem B. Bityutskiy }
126801c135cSArtem B. Bityutskiy
127801c135cSArtem B. Bityutskiy /**
128801c135cSArtem B. Bityutskiy * ubi_create_volume - create volume.
129801c135cSArtem B. Bityutskiy * @ubi: UBI device description object
130801c135cSArtem B. Bityutskiy * @req: volume creation request
131801c135cSArtem B. Bityutskiy *
132801c135cSArtem B. Bityutskiy * This function creates volume described by @req. If @req->vol_id id
133d05c77a8SArtem Bityutskiy * %UBI_VOL_NUM_AUTO, this function automatically assign ID to the new volume
134801c135cSArtem B. Bityutskiy * and saves it in @req->vol_id. Returns zero in case of success and a negative
13540e4d0c1SArtem Bityutskiy * error code in case of failure. Note, the caller has to have the
136f089c0b2SArtem Bityutskiy * @ubi->device_mutex locked.
137801c135cSArtem B. Bityutskiy */
ubi_create_volume(struct ubi_device * ubi,struct ubi_mkvol_req * req)138801c135cSArtem B. Bityutskiy int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
139801c135cSArtem B. Bityutskiy {
140493cfaeaSLogan Gunthorpe int i, err, vol_id = req->vol_id;
141801c135cSArtem B. Bityutskiy struct ubi_volume *vol;
142801c135cSArtem B. Bityutskiy struct ubi_vtbl_record vtbl_rec;
143799dca34SBoris Brezillon struct ubi_eba_table *eba_tbl = NULL;
144801c135cSArtem B. Bityutskiy
145801c135cSArtem B. Bityutskiy if (ubi->ro_mode)
146801c135cSArtem B. Bityutskiy return -EROFS;
147801c135cSArtem B. Bityutskiy
148801c135cSArtem B. Bityutskiy vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
149801c135cSArtem B. Bityutskiy if (!vol)
150801c135cSArtem B. Bityutskiy return -ENOMEM;
151801c135cSArtem B. Bityutskiy
152493cfaeaSLogan Gunthorpe device_initialize(&vol->dev);
153493cfaeaSLogan Gunthorpe vol->dev.release = vol_release;
154493cfaeaSLogan Gunthorpe vol->dev.parent = &ubi->dev;
155493cfaeaSLogan Gunthorpe vol->dev.class = &ubi_class;
156493cfaeaSLogan Gunthorpe vol->dev.groups = volume_dev_groups;
157493cfaeaSLogan Gunthorpe
158c355aa46SQuentin Schulz if (req->flags & UBI_VOL_SKIP_CRC_CHECK_FLG)
159c355aa46SQuentin Schulz vol->skip_check = 1;
160c355aa46SQuentin Schulz
161801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock);
162801c135cSArtem B. Bityutskiy if (vol_id == UBI_VOL_NUM_AUTO) {
163801c135cSArtem B. Bityutskiy /* Find unused volume ID */
164c8566350SArtem Bityutskiy dbg_gen("search for vacant volume ID");
165801c135cSArtem B. Bityutskiy for (i = 0; i < ubi->vtbl_slots; i++)
166801c135cSArtem B. Bityutskiy if (!ubi->volumes[i]) {
167801c135cSArtem B. Bityutskiy vol_id = i;
168801c135cSArtem B. Bityutskiy break;
169801c135cSArtem B. Bityutskiy }
170801c135cSArtem B. Bityutskiy
171801c135cSArtem B. Bityutskiy if (vol_id == UBI_VOL_NUM_AUTO) {
17232608703STanya Brokhman ubi_err(ubi, "out of volume IDs");
173801c135cSArtem B. Bityutskiy err = -ENFILE;
174801c135cSArtem B. Bityutskiy goto out_unlock;
175801c135cSArtem B. Bityutskiy }
176801c135cSArtem B. Bityutskiy req->vol_id = vol_id;
177801c135cSArtem B. Bityutskiy }
178801c135cSArtem B. Bityutskiy
179e1cf7e6dSArtem Bityutskiy dbg_gen("create device %d, volume %d, %llu bytes, type %d, name %s",
180e1cf7e6dSArtem Bityutskiy ubi->ubi_num, vol_id, (unsigned long long)req->bytes,
181801c135cSArtem B. Bityutskiy (int)req->vol_type, req->name);
182801c135cSArtem B. Bityutskiy
183801c135cSArtem B. Bityutskiy /* Ensure that this volume does not exist */
184801c135cSArtem B. Bityutskiy err = -EEXIST;
185801c135cSArtem B. Bityutskiy if (ubi->volumes[vol_id]) {
18632608703STanya Brokhman ubi_err(ubi, "volume %d already exists", vol_id);
187801c135cSArtem B. Bityutskiy goto out_unlock;
188801c135cSArtem B. Bityutskiy }
189801c135cSArtem B. Bityutskiy
190801c135cSArtem B. Bityutskiy /* Ensure that the name is unique */
191801c135cSArtem B. Bityutskiy for (i = 0; i < ubi->vtbl_slots; i++)
192801c135cSArtem B. Bityutskiy if (ubi->volumes[i] &&
193801c135cSArtem B. Bityutskiy ubi->volumes[i]->name_len == req->name_len &&
19494784d91SArtem Bityutskiy !strcmp(ubi->volumes[i]->name, req->name)) {
19532608703STanya Brokhman ubi_err(ubi, "volume \"%s\" exists (ID %d)",
19632608703STanya Brokhman req->name, i);
197801c135cSArtem B. Bityutskiy goto out_unlock;
198801c135cSArtem B. Bityutskiy }
199801c135cSArtem B. Bityutskiy
200801c135cSArtem B. Bityutskiy /* Calculate how many eraseblocks are requested */
201801c135cSArtem B. Bityutskiy vol->usable_leb_size = ubi->leb_size - ubi->leb_size % req->alignment;
202e8d266cfSshengyong vol->reserved_pebs = div_u64(req->bytes + vol->usable_leb_size - 1,
2033013ee31SArtem Bityutskiy vol->usable_leb_size);
204801c135cSArtem B. Bityutskiy
205801c135cSArtem B. Bityutskiy /* Reserve physical eraseblocks */
206801c135cSArtem B. Bityutskiy if (vol->reserved_pebs > ubi->avail_pebs) {
20732608703STanya Brokhman ubi_err(ubi, "not enough PEBs, only %d available",
20832608703STanya Brokhman ubi->avail_pebs);
2095fc01ab6SArtem Bityutskiy if (ubi->corr_peb_count)
21032608703STanya Brokhman ubi_err(ubi, "%d PEBs are corrupted and not used",
2115fc01ab6SArtem Bityutskiy ubi->corr_peb_count);
212801c135cSArtem B. Bityutskiy err = -ENOSPC;
213801c135cSArtem B. Bityutskiy goto out_unlock;
214801c135cSArtem B. Bityutskiy }
215801c135cSArtem B. Bityutskiy ubi->avail_pebs -= vol->reserved_pebs;
216801c135cSArtem B. Bityutskiy ubi->rsvd_pebs += vol->reserved_pebs;
217e73f4459SArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
218801c135cSArtem B. Bityutskiy
219801c135cSArtem B. Bityutskiy vol->vol_id = vol_id;
220801c135cSArtem B. Bityutskiy vol->alignment = req->alignment;
221801c135cSArtem B. Bityutskiy vol->data_pad = ubi->leb_size % vol->alignment;
222801c135cSArtem B. Bityutskiy vol->vol_type = req->vol_type;
223801c135cSArtem B. Bityutskiy vol->name_len = req->name_len;
224a6ea4407SArtem Bityutskiy memcpy(vol->name, req->name, vol->name_len);
225801c135cSArtem B. Bityutskiy vol->ubi = ubi;
226801c135cSArtem B. Bityutskiy
227801c135cSArtem B. Bityutskiy /*
228801c135cSArtem B. Bityutskiy * Finish all pending erases because there may be some LEBs belonging
229801c135cSArtem B. Bityutskiy * to the same volume ID.
230801c135cSArtem B. Bityutskiy */
23162f38455SJoel Reardon err = ubi_wl_flush(ubi, vol_id, UBI_ALL);
232801c135cSArtem B. Bityutskiy if (err)
233801c135cSArtem B. Bityutskiy goto out_acc;
234801c135cSArtem B. Bityutskiy
235799dca34SBoris Brezillon eba_tbl = ubi_eba_create_table(vol, vol->reserved_pebs);
236799dca34SBoris Brezillon if (IS_ERR(eba_tbl)) {
237799dca34SBoris Brezillon err = PTR_ERR(eba_tbl);
238801c135cSArtem B. Bityutskiy goto out_acc;
239801c135cSArtem B. Bityutskiy }
240801c135cSArtem B. Bityutskiy
241799dca34SBoris Brezillon ubi_eba_replace_table(vol, eba_tbl);
242801c135cSArtem B. Bityutskiy
243801c135cSArtem B. Bityutskiy if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
244801c135cSArtem B. Bityutskiy vol->used_ebs = vol->reserved_pebs;
245801c135cSArtem B. Bityutskiy vol->last_eb_bytes = vol->usable_leb_size;
246d08c3b78SVinit Agnihotri vol->used_bytes =
247d08c3b78SVinit Agnihotri (long long)vol->used_ebs * vol->usable_leb_size;
248801c135cSArtem B. Bityutskiy } else {
2493013ee31SArtem Bityutskiy vol->used_ebs = div_u64_rem(vol->used_bytes,
2503013ee31SArtem Bityutskiy vol->usable_leb_size,
2513013ee31SArtem Bityutskiy &vol->last_eb_bytes);
2523013ee31SArtem Bityutskiy if (vol->last_eb_bytes != 0)
253801c135cSArtem B. Bityutskiy vol->used_ebs += 1;
254801c135cSArtem B. Bityutskiy else
255801c135cSArtem B. Bityutskiy vol->last_eb_bytes = vol->usable_leb_size;
256801c135cSArtem B. Bityutskiy }
257801c135cSArtem B. Bityutskiy
258a51a0c8dSClay McClure /* Make volume "available" before it becomes accessible via sysfs */
259a51a0c8dSClay McClure spin_lock(&ubi->volumes_lock);
260a51a0c8dSClay McClure ubi->volumes[vol_id] = vol;
261a51a0c8dSClay McClure ubi->vol_count += 1;
262a51a0c8dSClay McClure spin_unlock(&ubi->volumes_lock);
263a51a0c8dSClay McClure
264801c135cSArtem B. Bityutskiy /* Register character device for the volume */
265801c135cSArtem B. Bityutskiy cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
266801c135cSArtem B. Bityutskiy vol->cdev.owner = THIS_MODULE;
267801c135cSArtem B. Bityutskiy
268493cfaeaSLogan Gunthorpe vol->dev.devt = MKDEV(MAJOR(ubi->cdev.dev), vol_id + 1);
269475b44c1SKay Sievers dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
270493cfaeaSLogan Gunthorpe err = cdev_device_add(&vol->cdev, &vol->dev);
27101f7b309SArtem Bityutskiy if (err) {
272493cfaeaSLogan Gunthorpe ubi_err(ubi, "cannot add device");
273493cfaeaSLogan Gunthorpe goto out_mapping;
27401f7b309SArtem Bityutskiy }
275801c135cSArtem B. Bityutskiy
276801c135cSArtem B. Bityutskiy /* Fill volume table record */
277801c135cSArtem B. Bityutskiy memset(&vtbl_rec, 0, sizeof(struct ubi_vtbl_record));
2783261ebd7SChristoph Hellwig vtbl_rec.reserved_pebs = cpu_to_be32(vol->reserved_pebs);
2793261ebd7SChristoph Hellwig vtbl_rec.alignment = cpu_to_be32(vol->alignment);
2803261ebd7SChristoph Hellwig vtbl_rec.data_pad = cpu_to_be32(vol->data_pad);
2813261ebd7SChristoph Hellwig vtbl_rec.name_len = cpu_to_be16(vol->name_len);
282801c135cSArtem B. Bityutskiy if (vol->vol_type == UBI_DYNAMIC_VOLUME)
283801c135cSArtem B. Bityutskiy vtbl_rec.vol_type = UBI_VID_DYNAMIC;
284801c135cSArtem B. Bityutskiy else
285801c135cSArtem B. Bityutskiy vtbl_rec.vol_type = UBI_VID_STATIC;
28662652517SQuentin Schulz
28762652517SQuentin Schulz if (vol->skip_check)
28862652517SQuentin Schulz vtbl_rec.flags |= UBI_VTBL_SKIP_CRC_CHECK_FLG;
28962652517SQuentin Schulz
290a6ea4407SArtem Bityutskiy memcpy(vtbl_rec.name, vol->name, vol->name_len);
291801c135cSArtem B. Bityutskiy
292801c135cSArtem B. Bityutskiy err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
293801c135cSArtem B. Bityutskiy if (err)
294801c135cSArtem B. Bityutskiy goto out_sysfs;
295801c135cSArtem B. Bityutskiy
2960e0ee1ccSDmitry Pervushin ubi_volume_notify(ubi, vol, UBI_VOLUME_ADDED);
2977bf523aeSArtem Bityutskiy self_check_volumes(ubi);
298c8566350SArtem Bityutskiy return err;
299801c135cSArtem B. Bityutskiy
300fc75a1e1SArtem Bityutskiy out_sysfs:
301fc75a1e1SArtem Bityutskiy /*
302abc5e922SArtem Bityutskiy * We have registered our device, we should not free the volume
303fc75a1e1SArtem Bityutskiy * description object in this function in case of an error - it is
304fc75a1e1SArtem Bityutskiy * freed by the release function.
305fc75a1e1SArtem Bityutskiy */
306493cfaeaSLogan Gunthorpe cdev_device_del(&vol->cdev, &vol->dev);
307801c135cSArtem B. Bityutskiy out_mapping:
308a51a0c8dSClay McClure spin_lock(&ubi->volumes_lock);
309a51a0c8dSClay McClure ubi->volumes[vol_id] = NULL;
310a51a0c8dSClay McClure ubi->vol_count -= 1;
311a51a0c8dSClay McClure spin_unlock(&ubi->volumes_lock);
312801c135cSArtem B. Bityutskiy out_acc:
313801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock);
314801c135cSArtem B. Bityutskiy ubi->rsvd_pebs -= vol->reserved_pebs;
315801c135cSArtem B. Bityutskiy ubi->avail_pebs += vol->reserved_pebs;
316801c135cSArtem B. Bityutskiy out_unlock:
317801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock);
318abc5e922SArtem Bityutskiy put_device(&vol->dev);
31932608703STanya Brokhman ubi_err(ubi, "cannot create volume %d, error %d", vol_id, err);
320801c135cSArtem B. Bityutskiy return err;
321801c135cSArtem B. Bityutskiy }
322801c135cSArtem B. Bityutskiy
323801c135cSArtem B. Bityutskiy /**
324801c135cSArtem B. Bityutskiy * ubi_remove_volume - remove volume.
325801c135cSArtem B. Bityutskiy * @desc: volume descriptor
326f40ac9cdSArtem Bityutskiy * @no_vtbl: do not change volume table if not zero
327801c135cSArtem B. Bityutskiy *
328801c135cSArtem B. Bityutskiy * This function removes volume described by @desc. The volume has to be opened
329801c135cSArtem B. Bityutskiy * in "exclusive" mode. Returns zero in case of success and a negative error
330f089c0b2SArtem Bityutskiy * code in case of failure. The caller has to have the @ubi->device_mutex
33140e4d0c1SArtem Bityutskiy * locked.
332801c135cSArtem B. Bityutskiy */
ubi_remove_volume(struct ubi_volume_desc * desc,int no_vtbl)333f40ac9cdSArtem Bityutskiy int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl)
334801c135cSArtem B. Bityutskiy {
335801c135cSArtem B. Bityutskiy struct ubi_volume *vol = desc->vol;
336801c135cSArtem B. Bityutskiy struct ubi_device *ubi = vol->ubi;
337801c135cSArtem B. Bityutskiy int i, err, vol_id = vol->vol_id, reserved_pebs = vol->reserved_pebs;
338801c135cSArtem B. Bityutskiy
339e1cf7e6dSArtem Bityutskiy dbg_gen("remove device %d, volume %d", ubi->ubi_num, vol_id);
340801c135cSArtem B. Bityutskiy ubi_assert(desc->mode == UBI_EXCLUSIVE);
341801c135cSArtem B. Bityutskiy ubi_assert(vol == ubi->volumes[vol_id]);
342801c135cSArtem B. Bityutskiy
343801c135cSArtem B. Bityutskiy if (ubi->ro_mode)
344801c135cSArtem B. Bityutskiy return -EROFS;
345801c135cSArtem B. Bityutskiy
346d05c77a8SArtem Bityutskiy spin_lock(&ubi->volumes_lock);
347d05c77a8SArtem Bityutskiy if (vol->ref_count > 1) {
348d05c77a8SArtem Bityutskiy /*
349d05c77a8SArtem Bityutskiy * The volume is busy, probably someone is reading one of its
350d05c77a8SArtem Bityutskiy * sysfs files.
351d05c77a8SArtem Bityutskiy */
352d05c77a8SArtem Bityutskiy err = -EBUSY;
353d05c77a8SArtem Bityutskiy goto out_unlock;
354d05c77a8SArtem Bityutskiy }
355d05c77a8SArtem Bityutskiy ubi->volumes[vol_id] = NULL;
356d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
357d05c77a8SArtem Bityutskiy
358f40ac9cdSArtem Bityutskiy if (!no_vtbl) {
359801c135cSArtem B. Bityutskiy err = ubi_change_vtbl_record(ubi, vol_id, NULL);
360801c135cSArtem B. Bityutskiy if (err)
361d05c77a8SArtem Bityutskiy goto out_err;
362f40ac9cdSArtem Bityutskiy }
363801c135cSArtem B. Bityutskiy
364801c135cSArtem B. Bityutskiy for (i = 0; i < vol->reserved_pebs; i++) {
36589b96b69SArtem Bityutskiy err = ubi_eba_unmap_leb(ubi, vol, i);
366801c135cSArtem B. Bityutskiy if (err)
367d05c77a8SArtem Bityutskiy goto out_err;
368801c135cSArtem B. Bityutskiy }
369801c135cSArtem B. Bityutskiy
370493cfaeaSLogan Gunthorpe cdev_device_del(&vol->cdev, &vol->dev);
371493cfaeaSLogan Gunthorpe put_device(&vol->dev);
372801c135cSArtem B. Bityutskiy
373801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock);
374801c135cSArtem B. Bityutskiy ubi->rsvd_pebs -= reserved_pebs;
375801c135cSArtem B. Bityutskiy ubi->avail_pebs += reserved_pebs;
37687e773c9SShmulik Ladkani ubi_update_reserved(ubi);
377801c135cSArtem B. Bityutskiy ubi->vol_count -= 1;
378801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock);
379801c135cSArtem B. Bityutskiy
3800e0ee1ccSDmitry Pervushin ubi_volume_notify(ubi, vol, UBI_VOLUME_REMOVED);
3817bf523aeSArtem Bityutskiy if (!no_vtbl)
3827bf523aeSArtem Bityutskiy self_check_volumes(ubi);
383d38dce5bSArtem Bityutskiy
384fadb3665SDan Carpenter return 0;
385d05c77a8SArtem Bityutskiy
386d05c77a8SArtem Bityutskiy out_err:
38732608703STanya Brokhman ubi_err(ubi, "cannot remove volume %d, error %d", vol_id, err);
388d05c77a8SArtem Bityutskiy spin_lock(&ubi->volumes_lock);
389d05c77a8SArtem Bityutskiy ubi->volumes[vol_id] = vol;
390d05c77a8SArtem Bityutskiy out_unlock:
391d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
392cae0a771SArtem Bityutskiy return err;
393801c135cSArtem B. Bityutskiy }
394801c135cSArtem B. Bityutskiy
395801c135cSArtem B. Bityutskiy /**
396801c135cSArtem B. Bityutskiy * ubi_resize_volume - re-size volume.
397801c135cSArtem B. Bityutskiy * @desc: volume descriptor
398801c135cSArtem B. Bityutskiy * @reserved_pebs: new size in physical eraseblocks
399801c135cSArtem B. Bityutskiy *
40040e4d0c1SArtem Bityutskiy * This function re-sizes the volume and returns zero in case of success, and a
40140e4d0c1SArtem Bityutskiy * negative error code in case of failure. The caller has to have the
402f089c0b2SArtem Bityutskiy * @ubi->device_mutex locked.
403801c135cSArtem B. Bityutskiy */
ubi_resize_volume(struct ubi_volume_desc * desc,int reserved_pebs)404801c135cSArtem B. Bityutskiy int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs)
405801c135cSArtem B. Bityutskiy {
406799dca34SBoris Brezillon int i, err, pebs;
407801c135cSArtem B. Bityutskiy struct ubi_volume *vol = desc->vol;
408801c135cSArtem B. Bityutskiy struct ubi_device *ubi = vol->ubi;
409801c135cSArtem B. Bityutskiy struct ubi_vtbl_record vtbl_rec;
410799dca34SBoris Brezillon struct ubi_eba_table *new_eba_tbl = NULL;
411801c135cSArtem B. Bityutskiy int vol_id = vol->vol_id;
412801c135cSArtem B. Bityutskiy
413801c135cSArtem B. Bityutskiy if (ubi->ro_mode)
414801c135cSArtem B. Bityutskiy return -EROFS;
415801c135cSArtem B. Bityutskiy
416e1cf7e6dSArtem Bityutskiy dbg_gen("re-size device %d, volume %d to from %d to %d PEBs",
417e1cf7e6dSArtem Bityutskiy ubi->ubi_num, vol_id, vol->reserved_pebs, reserved_pebs);
418801c135cSArtem B. Bityutskiy
419801c135cSArtem B. Bityutskiy if (vol->vol_type == UBI_STATIC_VOLUME &&
420801c135cSArtem B. Bityutskiy reserved_pebs < vol->used_ebs) {
42132608703STanya Brokhman ubi_err(ubi, "too small size %d, %d LEBs contain data",
422801c135cSArtem B. Bityutskiy reserved_pebs, vol->used_ebs);
423801c135cSArtem B. Bityutskiy return -EINVAL;
424801c135cSArtem B. Bityutskiy }
425801c135cSArtem B. Bityutskiy
426801c135cSArtem B. Bityutskiy /* If the size is the same, we have nothing to do */
427801c135cSArtem B. Bityutskiy if (reserved_pebs == vol->reserved_pebs)
428801c135cSArtem B. Bityutskiy return 0;
429801c135cSArtem B. Bityutskiy
430799dca34SBoris Brezillon new_eba_tbl = ubi_eba_create_table(vol, reserved_pebs);
431799dca34SBoris Brezillon if (IS_ERR(new_eba_tbl))
432799dca34SBoris Brezillon return PTR_ERR(new_eba_tbl);
433801c135cSArtem B. Bityutskiy
434d05c77a8SArtem Bityutskiy spin_lock(&ubi->volumes_lock);
435d05c77a8SArtem Bityutskiy if (vol->ref_count > 1) {
436d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
437d05c77a8SArtem Bityutskiy err = -EBUSY;
438d05c77a8SArtem Bityutskiy goto out_free;
439d05c77a8SArtem Bityutskiy }
440d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
441d05c77a8SArtem Bityutskiy
442d05c77a8SArtem Bityutskiy /* Reserve physical eraseblocks */
443801c135cSArtem B. Bityutskiy pebs = reserved_pebs - vol->reserved_pebs;
444801c135cSArtem B. Bityutskiy if (pebs > 0) {
445801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock);
446801c135cSArtem B. Bityutskiy if (pebs > ubi->avail_pebs) {
44732608703STanya Brokhman ubi_err(ubi, "not enough PEBs: requested %d, available %d",
448801c135cSArtem B. Bityutskiy pebs, ubi->avail_pebs);
4495fc01ab6SArtem Bityutskiy if (ubi->corr_peb_count)
45032608703STanya Brokhman ubi_err(ubi, "%d PEBs are corrupted and not used",
4515fc01ab6SArtem Bityutskiy ubi->corr_peb_count);
452801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock);
453801c135cSArtem B. Bityutskiy err = -ENOSPC;
454801c135cSArtem B. Bityutskiy goto out_free;
455801c135cSArtem B. Bityutskiy }
456801c135cSArtem B. Bityutskiy ubi->avail_pebs -= pebs;
457801c135cSArtem B. Bityutskiy ubi->rsvd_pebs += pebs;
458799dca34SBoris Brezillon ubi_eba_copy_table(vol, new_eba_tbl, vol->reserved_pebs);
459799dca34SBoris Brezillon ubi_eba_replace_table(vol, new_eba_tbl);
460801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock);
461801c135cSArtem B. Bityutskiy }
462801c135cSArtem B. Bityutskiy
463801c135cSArtem B. Bityutskiy if (pebs < 0) {
464801c135cSArtem B. Bityutskiy for (i = 0; i < -pebs; i++) {
46589b96b69SArtem Bityutskiy err = ubi_eba_unmap_leb(ubi, vol, reserved_pebs + i);
466801c135cSArtem B. Bityutskiy if (err)
4679af31d6eSLi Zetao goto out_free;
468801c135cSArtem B. Bityutskiy }
469801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock);
470801c135cSArtem B. Bityutskiy ubi->rsvd_pebs += pebs;
471801c135cSArtem B. Bityutskiy ubi->avail_pebs -= pebs;
47287e773c9SShmulik Ladkani ubi_update_reserved(ubi);
473799dca34SBoris Brezillon ubi_eba_copy_table(vol, new_eba_tbl, reserved_pebs);
474799dca34SBoris Brezillon ubi_eba_replace_table(vol, new_eba_tbl);
475801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock);
476801c135cSArtem B. Bityutskiy }
477801c135cSArtem B. Bityutskiy
4784946784bSRichard Weinberger /*
4794946784bSRichard Weinberger * When we shrink a volume we have to flush all pending (erase) work.
4804946784bSRichard Weinberger * Otherwise it can happen that upon next attach UBI finds a LEB with
4814946784bSRichard Weinberger * lnum > highest_lnum and refuses to attach.
4824946784bSRichard Weinberger */
4834946784bSRichard Weinberger if (pebs < 0) {
4844946784bSRichard Weinberger err = ubi_wl_flush(ubi, vol_id, UBI_ALL);
4854946784bSRichard Weinberger if (err)
4864946784bSRichard Weinberger goto out_acc;
4874946784bSRichard Weinberger }
4884946784bSRichard Weinberger
4894946784bSRichard Weinberger /* Change volume table record */
4904946784bSRichard Weinberger vtbl_rec = ubi->vtbl[vol_id];
4914946784bSRichard Weinberger vtbl_rec.reserved_pebs = cpu_to_be32(reserved_pebs);
4924946784bSRichard Weinberger err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
4934946784bSRichard Weinberger if (err)
4944946784bSRichard Weinberger goto out_acc;
4954946784bSRichard Weinberger
496801c135cSArtem B. Bityutskiy vol->reserved_pebs = reserved_pebs;
497801c135cSArtem B. Bityutskiy if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
498801c135cSArtem B. Bityutskiy vol->used_ebs = reserved_pebs;
499801c135cSArtem B. Bityutskiy vol->last_eb_bytes = vol->usable_leb_size;
500d08c3b78SVinit Agnihotri vol->used_bytes =
501d08c3b78SVinit Agnihotri (long long)vol->used_ebs * vol->usable_leb_size;
502801c135cSArtem B. Bityutskiy }
503801c135cSArtem B. Bityutskiy
5040e0ee1ccSDmitry Pervushin ubi_volume_notify(ubi, vol, UBI_VOLUME_RESIZED);
5057bf523aeSArtem Bityutskiy self_check_volumes(ubi);
506c8566350SArtem Bityutskiy return err;
507801c135cSArtem B. Bityutskiy
508801c135cSArtem B. Bityutskiy out_acc:
509801c135cSArtem B. Bityutskiy if (pebs > 0) {
510801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock);
511801c135cSArtem B. Bityutskiy ubi->rsvd_pebs -= pebs;
512801c135cSArtem B. Bityutskiy ubi->avail_pebs += pebs;
513801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock);
514801c135cSArtem B. Bityutskiy }
5159af31d6eSLi Zetao return err;
5169af31d6eSLi Zetao
517801c135cSArtem B. Bityutskiy out_free:
5181e591ea0SLi Zetao ubi_eba_destroy_table(new_eba_tbl);
519801c135cSArtem B. Bityutskiy return err;
520801c135cSArtem B. Bityutskiy }
521801c135cSArtem B. Bityutskiy
522801c135cSArtem B. Bityutskiy /**
523f40ac9cdSArtem Bityutskiy * ubi_rename_volumes - re-name UBI volumes.
524f40ac9cdSArtem Bityutskiy * @ubi: UBI device description object
525ebaaf1afSArtem Bityutskiy * @rename_list: list of &struct ubi_rename_entry objects
526f40ac9cdSArtem Bityutskiy *
527f40ac9cdSArtem Bityutskiy * This function re-names or removes volumes specified in the re-name list.
528f40ac9cdSArtem Bityutskiy * Returns zero in case of success and a negative error code in case of
529f40ac9cdSArtem Bityutskiy * failure.
530f40ac9cdSArtem Bityutskiy */
ubi_rename_volumes(struct ubi_device * ubi,struct list_head * rename_list)531f40ac9cdSArtem Bityutskiy int ubi_rename_volumes(struct ubi_device *ubi, struct list_head *rename_list)
532f40ac9cdSArtem Bityutskiy {
533f40ac9cdSArtem Bityutskiy int err;
534f40ac9cdSArtem Bityutskiy struct ubi_rename_entry *re;
535f40ac9cdSArtem Bityutskiy
536f40ac9cdSArtem Bityutskiy err = ubi_vtbl_rename_volumes(ubi, rename_list);
537f40ac9cdSArtem Bityutskiy if (err)
538f40ac9cdSArtem Bityutskiy return err;
539f40ac9cdSArtem Bityutskiy
540f40ac9cdSArtem Bityutskiy list_for_each_entry(re, rename_list, list) {
541f40ac9cdSArtem Bityutskiy if (re->remove) {
542f40ac9cdSArtem Bityutskiy err = ubi_remove_volume(re->desc, 1);
543f40ac9cdSArtem Bityutskiy if (err)
544f40ac9cdSArtem Bityutskiy break;
545f40ac9cdSArtem Bityutskiy } else {
546f40ac9cdSArtem Bityutskiy struct ubi_volume *vol = re->desc->vol;
547f40ac9cdSArtem Bityutskiy
548f40ac9cdSArtem Bityutskiy spin_lock(&ubi->volumes_lock);
549f40ac9cdSArtem Bityutskiy vol->name_len = re->new_name_len;
550f40ac9cdSArtem Bityutskiy memcpy(vol->name, re->new_name, re->new_name_len + 1);
551f40ac9cdSArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
5520e0ee1ccSDmitry Pervushin ubi_volume_notify(ubi, vol, UBI_VOLUME_RENAMED);
553f40ac9cdSArtem Bityutskiy }
554f40ac9cdSArtem Bityutskiy }
555f40ac9cdSArtem Bityutskiy
5567bf523aeSArtem Bityutskiy if (!err)
5577bf523aeSArtem Bityutskiy self_check_volumes(ubi);
558f40ac9cdSArtem Bityutskiy return err;
559f40ac9cdSArtem Bityutskiy }
560f40ac9cdSArtem Bityutskiy
561f40ac9cdSArtem Bityutskiy /**
562801c135cSArtem B. Bityutskiy * ubi_add_volume - add volume.
563801c135cSArtem B. Bityutskiy * @ubi: UBI device description object
56489b96b69SArtem Bityutskiy * @vol: volume description object
565801c135cSArtem B. Bityutskiy *
566d05c77a8SArtem Bityutskiy * This function adds an existing volume and initializes all its data
567d05c77a8SArtem Bityutskiy * structures. Returns zero in case of success and a negative error code in
568801c135cSArtem B. Bityutskiy * case of failure.
569801c135cSArtem B. Bityutskiy */
ubi_add_volume(struct ubi_device * ubi,struct ubi_volume * vol)57089b96b69SArtem Bityutskiy int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol)
571801c135cSArtem B. Bityutskiy {
57289b96b69SArtem Bityutskiy int err, vol_id = vol->vol_id;
57349dfc299SArtem Bityutskiy dev_t dev;
574801c135cSArtem B. Bityutskiy
575c8566350SArtem Bityutskiy dbg_gen("add volume %d", vol_id);
576801c135cSArtem B. Bityutskiy
577801c135cSArtem B. Bityutskiy /* Register character device for the volume */
578801c135cSArtem B. Bityutskiy cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
579801c135cSArtem B. Bityutskiy vol->cdev.owner = THIS_MODULE;
58049dfc299SArtem Bityutskiy dev = MKDEV(MAJOR(ubi->cdev.dev), vol->vol_id + 1);
58149dfc299SArtem Bityutskiy err = cdev_add(&vol->cdev, dev, 1);
582801c135cSArtem B. Bityutskiy if (err) {
58332608703STanya Brokhman ubi_err(ubi, "cannot add character device for volume %d, error %d",
58401f7b309SArtem Bityutskiy vol_id, err);
585*c15859bfSYang Yingliang vol_release(&vol->dev);
586801c135cSArtem B. Bityutskiy return err;
587801c135cSArtem B. Bityutskiy }
588801c135cSArtem B. Bityutskiy
589801c135cSArtem B. Bityutskiy vol->dev.release = vol_release;
590801c135cSArtem B. Bityutskiy vol->dev.parent = &ubi->dev;
59149dfc299SArtem Bityutskiy vol->dev.devt = dev;
59253cd255cSTakashi Iwai vol->dev.class = &ubi_class;
59353cd255cSTakashi Iwai vol->dev.groups = volume_dev_groups;
594475b44c1SKay Sievers dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id);
595801c135cSArtem B. Bityutskiy err = device_register(&vol->dev);
596*c15859bfSYang Yingliang if (err) {
597*c15859bfSYang Yingliang cdev_del(&vol->cdev);
598*c15859bfSYang Yingliang put_device(&vol->dev);
599*c15859bfSYang Yingliang return err;
600*c15859bfSYang Yingliang }
601801c135cSArtem B. Bityutskiy
6027bf523aeSArtem Bityutskiy self_check_volumes(ubi);
603c8566350SArtem Bityutskiy return err;
604801c135cSArtem B. Bityutskiy }
605801c135cSArtem B. Bityutskiy
606801c135cSArtem B. Bityutskiy /**
607801c135cSArtem B. Bityutskiy * ubi_free_volume - free volume.
608801c135cSArtem B. Bityutskiy * @ubi: UBI device description object
60989b96b69SArtem Bityutskiy * @vol: volume description object
610801c135cSArtem B. Bityutskiy *
61189b96b69SArtem Bityutskiy * This function frees all resources for volume @vol but does not remove it.
612801c135cSArtem B. Bityutskiy * Used only when the UBI device is detached.
613801c135cSArtem B. Bityutskiy */
ubi_free_volume(struct ubi_device * ubi,struct ubi_volume * vol)61489b96b69SArtem Bityutskiy void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol)
615801c135cSArtem B. Bityutskiy {
616c8566350SArtem Bityutskiy dbg_gen("free volume %d", vol->vol_id);
617801c135cSArtem B. Bityutskiy
61889b96b69SArtem Bityutskiy ubi->volumes[vol->vol_id] = NULL;
619801c135cSArtem B. Bityutskiy cdev_del(&vol->cdev);
62053cd255cSTakashi Iwai device_unregister(&vol->dev);
621801c135cSArtem B. Bityutskiy }
622801c135cSArtem B. Bityutskiy
623801c135cSArtem B. Bityutskiy /**
6247bf523aeSArtem Bityutskiy * self_check_volume - check volume information.
625801c135cSArtem B. Bityutskiy * @ubi: UBI device description object
626801c135cSArtem B. Bityutskiy * @vol_id: volume ID
627c8566350SArtem Bityutskiy *
628019ac05eSJiang Jian * Returns zero if volume is all right and a negative error code if not.
629801c135cSArtem B. Bityutskiy */
self_check_volume(struct ubi_device * ubi,int vol_id)6307bf523aeSArtem Bityutskiy static int self_check_volume(struct ubi_device *ubi, int vol_id)
631801c135cSArtem B. Bityutskiy {
632801c135cSArtem B. Bityutskiy int idx = vol_id2idx(ubi, vol_id);
633801c135cSArtem B. Bityutskiy int reserved_pebs, alignment, data_pad, vol_type, name_len, upd_marker;
634b89044bfSArtem Bityutskiy const struct ubi_volume *vol;
635801c135cSArtem B. Bityutskiy long long n;
636801c135cSArtem B. Bityutskiy const char *name;
637801c135cSArtem B. Bityutskiy
638b89044bfSArtem Bityutskiy spin_lock(&ubi->volumes_lock);
6393261ebd7SChristoph Hellwig reserved_pebs = be32_to_cpu(ubi->vtbl[vol_id].reserved_pebs);
640b89044bfSArtem Bityutskiy vol = ubi->volumes[idx];
641801c135cSArtem B. Bityutskiy
642801c135cSArtem B. Bityutskiy if (!vol) {
643801c135cSArtem B. Bityutskiy if (reserved_pebs) {
64432608703STanya Brokhman ubi_err(ubi, "no volume info, but volume exists");
645801c135cSArtem B. Bityutskiy goto fail;
646801c135cSArtem B. Bityutskiy }
647b89044bfSArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
648c8566350SArtem Bityutskiy return 0;
649801c135cSArtem B. Bityutskiy }
650801c135cSArtem B. Bityutskiy
651801c135cSArtem B. Bityutskiy if (vol->reserved_pebs < 0 || vol->alignment < 0 || vol->data_pad < 0 ||
652801c135cSArtem B. Bityutskiy vol->name_len < 0) {
65332608703STanya Brokhman ubi_err(ubi, "negative values");
654801c135cSArtem B. Bityutskiy goto fail;
655801c135cSArtem B. Bityutskiy }
656801c135cSArtem B. Bityutskiy if (vol->alignment > ubi->leb_size || vol->alignment == 0) {
65732608703STanya Brokhman ubi_err(ubi, "bad alignment");
658801c135cSArtem B. Bityutskiy goto fail;
659801c135cSArtem B. Bityutskiy }
660801c135cSArtem B. Bityutskiy
661cadb40ccSKyungmin Park n = vol->alignment & (ubi->min_io_size - 1);
662801c135cSArtem B. Bityutskiy if (vol->alignment != 1 && n) {
66332608703STanya Brokhman ubi_err(ubi, "alignment is not multiple of min I/O unit");
664801c135cSArtem B. Bityutskiy goto fail;
665801c135cSArtem B. Bityutskiy }
666801c135cSArtem B. Bityutskiy
667801c135cSArtem B. Bityutskiy n = ubi->leb_size % vol->alignment;
668801c135cSArtem B. Bityutskiy if (vol->data_pad != n) {
66932608703STanya Brokhman ubi_err(ubi, "bad data_pad, has to be %lld", n);
670801c135cSArtem B. Bityutskiy goto fail;
671801c135cSArtem B. Bityutskiy }
672801c135cSArtem B. Bityutskiy
673801c135cSArtem B. Bityutskiy if (vol->vol_type != UBI_DYNAMIC_VOLUME &&
674801c135cSArtem B. Bityutskiy vol->vol_type != UBI_STATIC_VOLUME) {
67532608703STanya Brokhman ubi_err(ubi, "bad vol_type");
676801c135cSArtem B. Bityutskiy goto fail;
677801c135cSArtem B. Bityutskiy }
678801c135cSArtem B. Bityutskiy
679801c135cSArtem B. Bityutskiy if (vol->upd_marker && vol->corrupted) {
68032608703STanya Brokhman ubi_err(ubi, "update marker and corrupted simultaneously");
681801c135cSArtem B. Bityutskiy goto fail;
682801c135cSArtem B. Bityutskiy }
683801c135cSArtem B. Bityutskiy
684801c135cSArtem B. Bityutskiy if (vol->reserved_pebs > ubi->good_peb_count) {
68532608703STanya Brokhman ubi_err(ubi, "too large reserved_pebs");
686801c135cSArtem B. Bityutskiy goto fail;
687801c135cSArtem B. Bityutskiy }
688801c135cSArtem B. Bityutskiy
689801c135cSArtem B. Bityutskiy n = ubi->leb_size - vol->data_pad;
690801c135cSArtem B. Bityutskiy if (vol->usable_leb_size != ubi->leb_size - vol->data_pad) {
69132608703STanya Brokhman ubi_err(ubi, "bad usable_leb_size, has to be %lld", n);
692801c135cSArtem B. Bityutskiy goto fail;
693801c135cSArtem B. Bityutskiy }
694801c135cSArtem B. Bityutskiy
695801c135cSArtem B. Bityutskiy if (vol->name_len > UBI_VOL_NAME_MAX) {
69632608703STanya Brokhman ubi_err(ubi, "too long volume name, max is %d",
69732608703STanya Brokhman UBI_VOL_NAME_MAX);
698801c135cSArtem B. Bityutskiy goto fail;
699801c135cSArtem B. Bityutskiy }
700801c135cSArtem B. Bityutskiy
701801c135cSArtem B. Bityutskiy n = strnlen(vol->name, vol->name_len + 1);
702801c135cSArtem B. Bityutskiy if (n != vol->name_len) {
70332608703STanya Brokhman ubi_err(ubi, "bad name_len %lld", n);
704801c135cSArtem B. Bityutskiy goto fail;
705801c135cSArtem B. Bityutskiy }
706801c135cSArtem B. Bityutskiy
707d08c3b78SVinit Agnihotri n = (long long)vol->used_ebs * vol->usable_leb_size;
708801c135cSArtem B. Bityutskiy if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
709896c0c06SArtem Bityutskiy if (vol->corrupted) {
71032608703STanya Brokhman ubi_err(ubi, "corrupted dynamic volume");
711801c135cSArtem B. Bityutskiy goto fail;
712801c135cSArtem B. Bityutskiy }
713801c135cSArtem B. Bityutskiy if (vol->used_ebs != vol->reserved_pebs) {
71432608703STanya Brokhman ubi_err(ubi, "bad used_ebs");
715801c135cSArtem B. Bityutskiy goto fail;
716801c135cSArtem B. Bityutskiy }
717801c135cSArtem B. Bityutskiy if (vol->last_eb_bytes != vol->usable_leb_size) {
71832608703STanya Brokhman ubi_err(ubi, "bad last_eb_bytes");
719801c135cSArtem B. Bityutskiy goto fail;
720801c135cSArtem B. Bityutskiy }
721801c135cSArtem B. Bityutskiy if (vol->used_bytes != n) {
72232608703STanya Brokhman ubi_err(ubi, "bad used_bytes");
723801c135cSArtem B. Bityutskiy goto fail;
724801c135cSArtem B. Bityutskiy }
72562652517SQuentin Schulz
72662652517SQuentin Schulz if (vol->skip_check) {
72762652517SQuentin Schulz ubi_err(ubi, "bad skip_check");
72862652517SQuentin Schulz goto fail;
72962652517SQuentin Schulz }
730801c135cSArtem B. Bityutskiy } else {
731801c135cSArtem B. Bityutskiy if (vol->used_ebs < 0 || vol->used_ebs > vol->reserved_pebs) {
73232608703STanya Brokhman ubi_err(ubi, "bad used_ebs");
733801c135cSArtem B. Bityutskiy goto fail;
734801c135cSArtem B. Bityutskiy }
735801c135cSArtem B. Bityutskiy if (vol->last_eb_bytes < 0 ||
736801c135cSArtem B. Bityutskiy vol->last_eb_bytes > vol->usable_leb_size) {
73732608703STanya Brokhman ubi_err(ubi, "bad last_eb_bytes");
738801c135cSArtem B. Bityutskiy goto fail;
739801c135cSArtem B. Bityutskiy }
740801c135cSArtem B. Bityutskiy if (vol->used_bytes < 0 || vol->used_bytes > n ||
741801c135cSArtem B. Bityutskiy vol->used_bytes < n - vol->usable_leb_size) {
74232608703STanya Brokhman ubi_err(ubi, "bad used_bytes");
743801c135cSArtem B. Bityutskiy goto fail;
744801c135cSArtem B. Bityutskiy }
745801c135cSArtem B. Bityutskiy }
746801c135cSArtem B. Bityutskiy
7473261ebd7SChristoph Hellwig alignment = be32_to_cpu(ubi->vtbl[vol_id].alignment);
7483261ebd7SChristoph Hellwig data_pad = be32_to_cpu(ubi->vtbl[vol_id].data_pad);
7493261ebd7SChristoph Hellwig name_len = be16_to_cpu(ubi->vtbl[vol_id].name_len);
750801c135cSArtem B. Bityutskiy upd_marker = ubi->vtbl[vol_id].upd_marker;
751801c135cSArtem B. Bityutskiy name = &ubi->vtbl[vol_id].name[0];
752801c135cSArtem B. Bityutskiy if (ubi->vtbl[vol_id].vol_type == UBI_VID_DYNAMIC)
753801c135cSArtem B. Bityutskiy vol_type = UBI_DYNAMIC_VOLUME;
754801c135cSArtem B. Bityutskiy else
755801c135cSArtem B. Bityutskiy vol_type = UBI_STATIC_VOLUME;
756801c135cSArtem B. Bityutskiy
757801c135cSArtem B. Bityutskiy if (alignment != vol->alignment || data_pad != vol->data_pad ||
758801c135cSArtem B. Bityutskiy upd_marker != vol->upd_marker || vol_type != vol->vol_type ||
759801c135cSArtem B. Bityutskiy name_len != vol->name_len || strncmp(name, vol->name, name_len)) {
76032608703STanya Brokhman ubi_err(ubi, "volume info is different");
761801c135cSArtem B. Bityutskiy goto fail;
762801c135cSArtem B. Bityutskiy }
763801c135cSArtem B. Bityutskiy
764b89044bfSArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
765c8566350SArtem Bityutskiy return 0;
766801c135cSArtem B. Bityutskiy
767801c135cSArtem B. Bityutskiy fail:
76832608703STanya Brokhman ubi_err(ubi, "self-check failed for volume %d", vol_id);
769f40ac9cdSArtem Bityutskiy if (vol)
770766381f0SArtem Bityutskiy ubi_dump_vol_info(vol);
7711f021e1dSArtem Bityutskiy ubi_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id);
772cfcf0ec8SArtem Bityutskiy dump_stack();
773b89044bfSArtem Bityutskiy spin_unlock(&ubi->volumes_lock);
774c8566350SArtem Bityutskiy return -EINVAL;
775801c135cSArtem B. Bityutskiy }
776801c135cSArtem B. Bityutskiy
777801c135cSArtem B. Bityutskiy /**
7787bf523aeSArtem Bityutskiy * self_check_volumes - check information about all volumes.
779801c135cSArtem B. Bityutskiy * @ubi: UBI device description object
780c8566350SArtem Bityutskiy *
781019ac05eSJiang Jian * Returns zero if volumes are all right and a negative error code if not.
782801c135cSArtem B. Bityutskiy */
self_check_volumes(struct ubi_device * ubi)7837bf523aeSArtem Bityutskiy static int self_check_volumes(struct ubi_device *ubi)
784801c135cSArtem B. Bityutskiy {
785c8566350SArtem Bityutskiy int i, err = 0;
786801c135cSArtem B. Bityutskiy
78764575574SEzequiel Garcia if (!ubi_dbg_chk_gen(ubi))
78892d124f5SArtem Bityutskiy return 0;
78992d124f5SArtem Bityutskiy
790c8566350SArtem Bityutskiy for (i = 0; i < ubi->vtbl_slots; i++) {
7917bf523aeSArtem Bityutskiy err = self_check_volume(ubi, i);
792c8566350SArtem Bityutskiy if (err)
793c8566350SArtem Bityutskiy break;
794c8566350SArtem Bityutskiy }
795c8566350SArtem Bityutskiy
796c8566350SArtem Bityutskiy return err;
797801c135cSArtem B. Bityutskiy }
798