1*1a59d1b8SThomas 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 */ 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); 59e73f4459SArtem Bityutskiy struct ubi_device *ubi; 60e73f4459SArtem Bityutskiy 61e73f4459SArtem Bityutskiy ubi = ubi_get_device(vol->ubi->ubi_num); 62e73f4459SArtem Bityutskiy if (!ubi) 63e73f4459SArtem Bityutskiy return -ENODEV; 64801c135cSArtem B. Bityutskiy 65d05c77a8SArtem Bityutskiy spin_lock(&ubi->volumes_lock); 66d05c77a8SArtem Bityutskiy if (!ubi->volumes[vol->vol_id]) { 67d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 68e73f4459SArtem Bityutskiy ubi_put_device(ubi); 69d05c77a8SArtem Bityutskiy return -ENODEV; 70801c135cSArtem B. Bityutskiy } 71d05c77a8SArtem Bityutskiy /* Take a reference to prevent volume removal */ 72d05c77a8SArtem Bityutskiy vol->ref_count += 1; 73d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 74732aeacfSArtem Bityutskiy 758bc22961SArtem Bityutskiy if (attr == &attr_vol_reserved_ebs) 76801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%d\n", vol->reserved_pebs); 778bc22961SArtem Bityutskiy else if (attr == &attr_vol_type) { 78801c135cSArtem B. Bityutskiy const char *tp; 798bc22961SArtem Bityutskiy 808bc22961SArtem Bityutskiy if (vol->vol_type == UBI_DYNAMIC_VOLUME) 818bc22961SArtem Bityutskiy tp = "dynamic"; 828bc22961SArtem Bityutskiy else 838bc22961SArtem Bityutskiy tp = "static"; 84801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%s\n", tp); 858bc22961SArtem Bityutskiy } else if (attr == &attr_vol_name) 86801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%s\n", vol->name); 878bc22961SArtem Bityutskiy else if (attr == &attr_vol_corrupted) 88801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%d\n", vol->corrupted); 898bc22961SArtem Bityutskiy else if (attr == &attr_vol_alignment) 90801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%d\n", vol->alignment); 91732aeacfSArtem Bityutskiy else if (attr == &attr_vol_usable_eb_size) 92801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%d\n", vol->usable_leb_size); 93732aeacfSArtem Bityutskiy else if (attr == &attr_vol_data_bytes) 94801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%lld\n", vol->used_bytes); 958bc22961SArtem Bityutskiy else if (attr == &attr_vol_upd_marker) 96801c135cSArtem B. Bityutskiy ret = sprintf(buf, "%d\n", vol->upd_marker); 97801c135cSArtem B. Bityutskiy else 98d05c77a8SArtem Bityutskiy /* This must be a bug */ 99d05c77a8SArtem Bityutskiy ret = -EINVAL; 100d05c77a8SArtem Bityutskiy 101e73f4459SArtem Bityutskiy /* We've done the operation, drop volume and UBI device references */ 102d05c77a8SArtem Bityutskiy spin_lock(&ubi->volumes_lock); 103d05c77a8SArtem Bityutskiy vol->ref_count -= 1; 104d05c77a8SArtem Bityutskiy ubi_assert(vol->ref_count >= 0); 105d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 106e73f4459SArtem Bityutskiy ubi_put_device(ubi); 107801c135cSArtem B. Bityutskiy return ret; 108801c135cSArtem B. Bityutskiy } 109801c135cSArtem B. Bityutskiy 11053cd255cSTakashi Iwai static struct attribute *volume_dev_attrs[] = { 11153cd255cSTakashi Iwai &attr_vol_reserved_ebs.attr, 11253cd255cSTakashi Iwai &attr_vol_type.attr, 11353cd255cSTakashi Iwai &attr_vol_name.attr, 11453cd255cSTakashi Iwai &attr_vol_corrupted.attr, 11553cd255cSTakashi Iwai &attr_vol_alignment.attr, 11653cd255cSTakashi Iwai &attr_vol_usable_eb_size.attr, 11753cd255cSTakashi Iwai &attr_vol_data_bytes.attr, 11853cd255cSTakashi Iwai &attr_vol_upd_marker.attr, 11953cd255cSTakashi Iwai NULL 12053cd255cSTakashi Iwai }; 12153cd255cSTakashi Iwai ATTRIBUTE_GROUPS(volume_dev); 12253cd255cSTakashi Iwai 123801c135cSArtem B. Bityutskiy /* Release method for volume devices */ 124801c135cSArtem B. Bityutskiy static void vol_release(struct device *dev) 125801c135cSArtem B. Bityutskiy { 126801c135cSArtem B. Bityutskiy struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev); 127732aeacfSArtem Bityutskiy 128799dca34SBoris Brezillon ubi_eba_replace_table(vol, NULL); 12934653fd8SRichard Weinberger ubi_fastmap_destroy_checkmap(vol); 130801c135cSArtem B. Bityutskiy kfree(vol); 131801c135cSArtem B. Bityutskiy } 132801c135cSArtem B. Bityutskiy 133801c135cSArtem B. Bityutskiy /** 134801c135cSArtem B. Bityutskiy * ubi_create_volume - create volume. 135801c135cSArtem B. Bityutskiy * @ubi: UBI device description object 136801c135cSArtem B. Bityutskiy * @req: volume creation request 137801c135cSArtem B. Bityutskiy * 138801c135cSArtem B. Bityutskiy * This function creates volume described by @req. If @req->vol_id id 139d05c77a8SArtem Bityutskiy * %UBI_VOL_NUM_AUTO, this function automatically assign ID to the new volume 140801c135cSArtem B. Bityutskiy * and saves it in @req->vol_id. Returns zero in case of success and a negative 14140e4d0c1SArtem Bityutskiy * error code in case of failure. Note, the caller has to have the 142f089c0b2SArtem Bityutskiy * @ubi->device_mutex locked. 143801c135cSArtem B. Bityutskiy */ 144801c135cSArtem B. Bityutskiy int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req) 145801c135cSArtem B. Bityutskiy { 146493cfaeaSLogan Gunthorpe int i, err, vol_id = req->vol_id; 147801c135cSArtem B. Bityutskiy struct ubi_volume *vol; 148801c135cSArtem B. Bityutskiy struct ubi_vtbl_record vtbl_rec; 149799dca34SBoris Brezillon struct ubi_eba_table *eba_tbl = NULL; 150801c135cSArtem B. Bityutskiy 151801c135cSArtem B. Bityutskiy if (ubi->ro_mode) 152801c135cSArtem B. Bityutskiy return -EROFS; 153801c135cSArtem B. Bityutskiy 154801c135cSArtem B. Bityutskiy vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL); 155801c135cSArtem B. Bityutskiy if (!vol) 156801c135cSArtem B. Bityutskiy return -ENOMEM; 157801c135cSArtem B. Bityutskiy 158493cfaeaSLogan Gunthorpe device_initialize(&vol->dev); 159493cfaeaSLogan Gunthorpe vol->dev.release = vol_release; 160493cfaeaSLogan Gunthorpe vol->dev.parent = &ubi->dev; 161493cfaeaSLogan Gunthorpe vol->dev.class = &ubi_class; 162493cfaeaSLogan Gunthorpe vol->dev.groups = volume_dev_groups; 163493cfaeaSLogan Gunthorpe 164c355aa46SQuentin Schulz if (req->flags & UBI_VOL_SKIP_CRC_CHECK_FLG) 165c355aa46SQuentin Schulz vol->skip_check = 1; 166c355aa46SQuentin Schulz 167801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock); 168801c135cSArtem B. Bityutskiy if (vol_id == UBI_VOL_NUM_AUTO) { 169801c135cSArtem B. Bityutskiy /* Find unused volume ID */ 170c8566350SArtem Bityutskiy dbg_gen("search for vacant volume ID"); 171801c135cSArtem B. Bityutskiy for (i = 0; i < ubi->vtbl_slots; i++) 172801c135cSArtem B. Bityutskiy if (!ubi->volumes[i]) { 173801c135cSArtem B. Bityutskiy vol_id = i; 174801c135cSArtem B. Bityutskiy break; 175801c135cSArtem B. Bityutskiy } 176801c135cSArtem B. Bityutskiy 177801c135cSArtem B. Bityutskiy if (vol_id == UBI_VOL_NUM_AUTO) { 17832608703STanya Brokhman ubi_err(ubi, "out of volume IDs"); 179801c135cSArtem B. Bityutskiy err = -ENFILE; 180801c135cSArtem B. Bityutskiy goto out_unlock; 181801c135cSArtem B. Bityutskiy } 182801c135cSArtem B. Bityutskiy req->vol_id = vol_id; 183801c135cSArtem B. Bityutskiy } 184801c135cSArtem B. Bityutskiy 185e1cf7e6dSArtem Bityutskiy dbg_gen("create device %d, volume %d, %llu bytes, type %d, name %s", 186e1cf7e6dSArtem Bityutskiy ubi->ubi_num, vol_id, (unsigned long long)req->bytes, 187801c135cSArtem B. Bityutskiy (int)req->vol_type, req->name); 188801c135cSArtem B. Bityutskiy 189801c135cSArtem B. Bityutskiy /* Ensure that this volume does not exist */ 190801c135cSArtem B. Bityutskiy err = -EEXIST; 191801c135cSArtem B. Bityutskiy if (ubi->volumes[vol_id]) { 19232608703STanya Brokhman ubi_err(ubi, "volume %d already exists", vol_id); 193801c135cSArtem B. Bityutskiy goto out_unlock; 194801c135cSArtem B. Bityutskiy } 195801c135cSArtem B. Bityutskiy 196801c135cSArtem B. Bityutskiy /* Ensure that the name is unique */ 197801c135cSArtem B. Bityutskiy for (i = 0; i < ubi->vtbl_slots; i++) 198801c135cSArtem B. Bityutskiy if (ubi->volumes[i] && 199801c135cSArtem B. Bityutskiy ubi->volumes[i]->name_len == req->name_len && 20094784d91SArtem Bityutskiy !strcmp(ubi->volumes[i]->name, req->name)) { 20132608703STanya Brokhman ubi_err(ubi, "volume \"%s\" exists (ID %d)", 20232608703STanya Brokhman req->name, i); 203801c135cSArtem B. Bityutskiy goto out_unlock; 204801c135cSArtem B. Bityutskiy } 205801c135cSArtem B. Bityutskiy 206801c135cSArtem B. Bityutskiy /* Calculate how many eraseblocks are requested */ 207801c135cSArtem B. Bityutskiy vol->usable_leb_size = ubi->leb_size - ubi->leb_size % req->alignment; 208e8d266cfSshengyong vol->reserved_pebs = div_u64(req->bytes + vol->usable_leb_size - 1, 2093013ee31SArtem Bityutskiy vol->usable_leb_size); 210801c135cSArtem B. Bityutskiy 211801c135cSArtem B. Bityutskiy /* Reserve physical eraseblocks */ 212801c135cSArtem B. Bityutskiy if (vol->reserved_pebs > ubi->avail_pebs) { 21332608703STanya Brokhman ubi_err(ubi, "not enough PEBs, only %d available", 21432608703STanya Brokhman ubi->avail_pebs); 2155fc01ab6SArtem Bityutskiy if (ubi->corr_peb_count) 21632608703STanya Brokhman ubi_err(ubi, "%d PEBs are corrupted and not used", 2175fc01ab6SArtem Bityutskiy ubi->corr_peb_count); 218801c135cSArtem B. Bityutskiy err = -ENOSPC; 219801c135cSArtem B. Bityutskiy goto out_unlock; 220801c135cSArtem B. Bityutskiy } 221801c135cSArtem B. Bityutskiy ubi->avail_pebs -= vol->reserved_pebs; 222801c135cSArtem B. Bityutskiy ubi->rsvd_pebs += vol->reserved_pebs; 223e73f4459SArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 224801c135cSArtem B. Bityutskiy 225801c135cSArtem B. Bityutskiy vol->vol_id = vol_id; 226801c135cSArtem B. Bityutskiy vol->alignment = req->alignment; 227801c135cSArtem B. Bityutskiy vol->data_pad = ubi->leb_size % vol->alignment; 228801c135cSArtem B. Bityutskiy vol->vol_type = req->vol_type; 229801c135cSArtem B. Bityutskiy vol->name_len = req->name_len; 230a6ea4407SArtem Bityutskiy memcpy(vol->name, req->name, vol->name_len); 231801c135cSArtem B. Bityutskiy vol->ubi = ubi; 232801c135cSArtem B. Bityutskiy 233801c135cSArtem B. Bityutskiy /* 234801c135cSArtem B. Bityutskiy * Finish all pending erases because there may be some LEBs belonging 235801c135cSArtem B. Bityutskiy * to the same volume ID. 236801c135cSArtem B. Bityutskiy */ 23762f38455SJoel Reardon err = ubi_wl_flush(ubi, vol_id, UBI_ALL); 238801c135cSArtem B. Bityutskiy if (err) 239801c135cSArtem B. Bityutskiy goto out_acc; 240801c135cSArtem B. Bityutskiy 241799dca34SBoris Brezillon eba_tbl = ubi_eba_create_table(vol, vol->reserved_pebs); 242799dca34SBoris Brezillon if (IS_ERR(eba_tbl)) { 243799dca34SBoris Brezillon err = PTR_ERR(eba_tbl); 244801c135cSArtem B. Bityutskiy goto out_acc; 245801c135cSArtem B. Bityutskiy } 246801c135cSArtem B. Bityutskiy 247799dca34SBoris Brezillon ubi_eba_replace_table(vol, eba_tbl); 248801c135cSArtem B. Bityutskiy 249801c135cSArtem B. Bityutskiy if (vol->vol_type == UBI_DYNAMIC_VOLUME) { 250801c135cSArtem B. Bityutskiy vol->used_ebs = vol->reserved_pebs; 251801c135cSArtem B. Bityutskiy vol->last_eb_bytes = vol->usable_leb_size; 252d08c3b78SVinit Agnihotri vol->used_bytes = 253d08c3b78SVinit Agnihotri (long long)vol->used_ebs * vol->usable_leb_size; 254801c135cSArtem B. Bityutskiy } else { 2553013ee31SArtem Bityutskiy vol->used_ebs = div_u64_rem(vol->used_bytes, 2563013ee31SArtem Bityutskiy vol->usable_leb_size, 2573013ee31SArtem Bityutskiy &vol->last_eb_bytes); 2583013ee31SArtem Bityutskiy if (vol->last_eb_bytes != 0) 259801c135cSArtem B. Bityutskiy vol->used_ebs += 1; 260801c135cSArtem B. Bityutskiy else 261801c135cSArtem B. Bityutskiy vol->last_eb_bytes = vol->usable_leb_size; 262801c135cSArtem B. Bityutskiy } 263801c135cSArtem B. Bityutskiy 264a51a0c8dSClay McClure /* Make volume "available" before it becomes accessible via sysfs */ 265a51a0c8dSClay McClure spin_lock(&ubi->volumes_lock); 266a51a0c8dSClay McClure ubi->volumes[vol_id] = vol; 267a51a0c8dSClay McClure ubi->vol_count += 1; 268a51a0c8dSClay McClure spin_unlock(&ubi->volumes_lock); 269a51a0c8dSClay McClure 270801c135cSArtem B. Bityutskiy /* Register character device for the volume */ 271801c135cSArtem B. Bityutskiy cdev_init(&vol->cdev, &ubi_vol_cdev_operations); 272801c135cSArtem B. Bityutskiy vol->cdev.owner = THIS_MODULE; 273801c135cSArtem B. Bityutskiy 274493cfaeaSLogan Gunthorpe vol->dev.devt = MKDEV(MAJOR(ubi->cdev.dev), vol_id + 1); 275475b44c1SKay Sievers dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id); 276493cfaeaSLogan Gunthorpe err = cdev_device_add(&vol->cdev, &vol->dev); 27701f7b309SArtem Bityutskiy if (err) { 278493cfaeaSLogan Gunthorpe ubi_err(ubi, "cannot add device"); 279493cfaeaSLogan Gunthorpe goto out_mapping; 28001f7b309SArtem Bityutskiy } 281801c135cSArtem B. Bityutskiy 282801c135cSArtem B. Bityutskiy /* Fill volume table record */ 283801c135cSArtem B. Bityutskiy memset(&vtbl_rec, 0, sizeof(struct ubi_vtbl_record)); 2843261ebd7SChristoph Hellwig vtbl_rec.reserved_pebs = cpu_to_be32(vol->reserved_pebs); 2853261ebd7SChristoph Hellwig vtbl_rec.alignment = cpu_to_be32(vol->alignment); 2863261ebd7SChristoph Hellwig vtbl_rec.data_pad = cpu_to_be32(vol->data_pad); 2873261ebd7SChristoph Hellwig vtbl_rec.name_len = cpu_to_be16(vol->name_len); 288801c135cSArtem B. Bityutskiy if (vol->vol_type == UBI_DYNAMIC_VOLUME) 289801c135cSArtem B. Bityutskiy vtbl_rec.vol_type = UBI_VID_DYNAMIC; 290801c135cSArtem B. Bityutskiy else 291801c135cSArtem B. Bityutskiy vtbl_rec.vol_type = UBI_VID_STATIC; 29262652517SQuentin Schulz 29362652517SQuentin Schulz if (vol->skip_check) 29462652517SQuentin Schulz vtbl_rec.flags |= UBI_VTBL_SKIP_CRC_CHECK_FLG; 29562652517SQuentin Schulz 296a6ea4407SArtem Bityutskiy memcpy(vtbl_rec.name, vol->name, vol->name_len); 297801c135cSArtem B. Bityutskiy 298801c135cSArtem B. Bityutskiy err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec); 299801c135cSArtem B. Bityutskiy if (err) 300801c135cSArtem B. Bityutskiy goto out_sysfs; 301801c135cSArtem B. Bityutskiy 3020e0ee1ccSDmitry Pervushin ubi_volume_notify(ubi, vol, UBI_VOLUME_ADDED); 3037bf523aeSArtem Bityutskiy self_check_volumes(ubi); 304c8566350SArtem Bityutskiy return err; 305801c135cSArtem B. Bityutskiy 306fc75a1e1SArtem Bityutskiy out_sysfs: 307fc75a1e1SArtem Bityutskiy /* 308abc5e922SArtem Bityutskiy * We have registered our device, we should not free the volume 309fc75a1e1SArtem Bityutskiy * description object in this function in case of an error - it is 310fc75a1e1SArtem Bityutskiy * freed by the release function. 311fc75a1e1SArtem Bityutskiy */ 312493cfaeaSLogan Gunthorpe cdev_device_del(&vol->cdev, &vol->dev); 313801c135cSArtem B. Bityutskiy out_mapping: 314a51a0c8dSClay McClure spin_lock(&ubi->volumes_lock); 315a51a0c8dSClay McClure ubi->volumes[vol_id] = NULL; 316a51a0c8dSClay McClure ubi->vol_count -= 1; 317a51a0c8dSClay McClure spin_unlock(&ubi->volumes_lock); 318799dca34SBoris Brezillon ubi_eba_destroy_table(eba_tbl); 319801c135cSArtem B. Bityutskiy out_acc: 320801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock); 321801c135cSArtem B. Bityutskiy ubi->rsvd_pebs -= vol->reserved_pebs; 322801c135cSArtem B. Bityutskiy ubi->avail_pebs += vol->reserved_pebs; 323801c135cSArtem B. Bityutskiy out_unlock: 324801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock); 325abc5e922SArtem Bityutskiy put_device(&vol->dev); 32632608703STanya Brokhman ubi_err(ubi, "cannot create volume %d, error %d", vol_id, err); 327801c135cSArtem B. Bityutskiy return err; 328801c135cSArtem B. Bityutskiy } 329801c135cSArtem B. Bityutskiy 330801c135cSArtem B. Bityutskiy /** 331801c135cSArtem B. Bityutskiy * ubi_remove_volume - remove volume. 332801c135cSArtem B. Bityutskiy * @desc: volume descriptor 333f40ac9cdSArtem Bityutskiy * @no_vtbl: do not change volume table if not zero 334801c135cSArtem B. Bityutskiy * 335801c135cSArtem B. Bityutskiy * This function removes volume described by @desc. The volume has to be opened 336801c135cSArtem B. Bityutskiy * in "exclusive" mode. Returns zero in case of success and a negative error 337f089c0b2SArtem Bityutskiy * code in case of failure. The caller has to have the @ubi->device_mutex 33840e4d0c1SArtem Bityutskiy * locked. 339801c135cSArtem B. Bityutskiy */ 340f40ac9cdSArtem Bityutskiy int ubi_remove_volume(struct ubi_volume_desc *desc, int no_vtbl) 341801c135cSArtem B. Bityutskiy { 342801c135cSArtem B. Bityutskiy struct ubi_volume *vol = desc->vol; 343801c135cSArtem B. Bityutskiy struct ubi_device *ubi = vol->ubi; 344801c135cSArtem B. Bityutskiy int i, err, vol_id = vol->vol_id, reserved_pebs = vol->reserved_pebs; 345801c135cSArtem B. Bityutskiy 346e1cf7e6dSArtem Bityutskiy dbg_gen("remove device %d, volume %d", ubi->ubi_num, vol_id); 347801c135cSArtem B. Bityutskiy ubi_assert(desc->mode == UBI_EXCLUSIVE); 348801c135cSArtem B. Bityutskiy ubi_assert(vol == ubi->volumes[vol_id]); 349801c135cSArtem B. Bityutskiy 350801c135cSArtem B. Bityutskiy if (ubi->ro_mode) 351801c135cSArtem B. Bityutskiy return -EROFS; 352801c135cSArtem B. Bityutskiy 353d05c77a8SArtem Bityutskiy spin_lock(&ubi->volumes_lock); 354d05c77a8SArtem Bityutskiy if (vol->ref_count > 1) { 355d05c77a8SArtem Bityutskiy /* 356d05c77a8SArtem Bityutskiy * The volume is busy, probably someone is reading one of its 357d05c77a8SArtem Bityutskiy * sysfs files. 358d05c77a8SArtem Bityutskiy */ 359d05c77a8SArtem Bityutskiy err = -EBUSY; 360d05c77a8SArtem Bityutskiy goto out_unlock; 361d05c77a8SArtem Bityutskiy } 362d05c77a8SArtem Bityutskiy ubi->volumes[vol_id] = NULL; 363d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 364d05c77a8SArtem Bityutskiy 365f40ac9cdSArtem Bityutskiy if (!no_vtbl) { 366801c135cSArtem B. Bityutskiy err = ubi_change_vtbl_record(ubi, vol_id, NULL); 367801c135cSArtem B. Bityutskiy if (err) 368d05c77a8SArtem Bityutskiy goto out_err; 369f40ac9cdSArtem Bityutskiy } 370801c135cSArtem B. Bityutskiy 371801c135cSArtem B. Bityutskiy for (i = 0; i < vol->reserved_pebs; i++) { 37289b96b69SArtem Bityutskiy err = ubi_eba_unmap_leb(ubi, vol, i); 373801c135cSArtem B. Bityutskiy if (err) 374d05c77a8SArtem Bityutskiy goto out_err; 375801c135cSArtem B. Bityutskiy } 376801c135cSArtem B. Bityutskiy 377493cfaeaSLogan Gunthorpe cdev_device_del(&vol->cdev, &vol->dev); 378493cfaeaSLogan Gunthorpe put_device(&vol->dev); 379801c135cSArtem B. Bityutskiy 380801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock); 381801c135cSArtem B. Bityutskiy ubi->rsvd_pebs -= reserved_pebs; 382801c135cSArtem B. Bityutskiy ubi->avail_pebs += reserved_pebs; 38387e773c9SShmulik Ladkani ubi_update_reserved(ubi); 384801c135cSArtem B. Bityutskiy ubi->vol_count -= 1; 385801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock); 386801c135cSArtem B. Bityutskiy 3870e0ee1ccSDmitry Pervushin ubi_volume_notify(ubi, vol, UBI_VOLUME_REMOVED); 3887bf523aeSArtem Bityutskiy if (!no_vtbl) 3897bf523aeSArtem Bityutskiy self_check_volumes(ubi); 390d38dce5bSArtem Bityutskiy 391fadb3665SDan Carpenter return 0; 392d05c77a8SArtem Bityutskiy 393d05c77a8SArtem Bityutskiy out_err: 39432608703STanya Brokhman ubi_err(ubi, "cannot remove volume %d, error %d", vol_id, err); 395d05c77a8SArtem Bityutskiy spin_lock(&ubi->volumes_lock); 396d05c77a8SArtem Bityutskiy ubi->volumes[vol_id] = vol; 397d05c77a8SArtem Bityutskiy out_unlock: 398d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 399cae0a771SArtem Bityutskiy return err; 400801c135cSArtem B. Bityutskiy } 401801c135cSArtem B. Bityutskiy 402801c135cSArtem B. Bityutskiy /** 403801c135cSArtem B. Bityutskiy * ubi_resize_volume - re-size volume. 404801c135cSArtem B. Bityutskiy * @desc: volume descriptor 405801c135cSArtem B. Bityutskiy * @reserved_pebs: new size in physical eraseblocks 406801c135cSArtem B. Bityutskiy * 40740e4d0c1SArtem Bityutskiy * This function re-sizes the volume and returns zero in case of success, and a 40840e4d0c1SArtem Bityutskiy * negative error code in case of failure. The caller has to have the 409f089c0b2SArtem Bityutskiy * @ubi->device_mutex locked. 410801c135cSArtem B. Bityutskiy */ 411801c135cSArtem B. Bityutskiy int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs) 412801c135cSArtem B. Bityutskiy { 413799dca34SBoris Brezillon int i, err, pebs; 414801c135cSArtem B. Bityutskiy struct ubi_volume *vol = desc->vol; 415801c135cSArtem B. Bityutskiy struct ubi_device *ubi = vol->ubi; 416801c135cSArtem B. Bityutskiy struct ubi_vtbl_record vtbl_rec; 417799dca34SBoris Brezillon struct ubi_eba_table *new_eba_tbl = NULL; 418801c135cSArtem B. Bityutskiy int vol_id = vol->vol_id; 419801c135cSArtem B. Bityutskiy 420801c135cSArtem B. Bityutskiy if (ubi->ro_mode) 421801c135cSArtem B. Bityutskiy return -EROFS; 422801c135cSArtem B. Bityutskiy 423e1cf7e6dSArtem Bityutskiy dbg_gen("re-size device %d, volume %d to from %d to %d PEBs", 424e1cf7e6dSArtem Bityutskiy ubi->ubi_num, vol_id, vol->reserved_pebs, reserved_pebs); 425801c135cSArtem B. Bityutskiy 426801c135cSArtem B. Bityutskiy if (vol->vol_type == UBI_STATIC_VOLUME && 427801c135cSArtem B. Bityutskiy reserved_pebs < vol->used_ebs) { 42832608703STanya Brokhman ubi_err(ubi, "too small size %d, %d LEBs contain data", 429801c135cSArtem B. Bityutskiy reserved_pebs, vol->used_ebs); 430801c135cSArtem B. Bityutskiy return -EINVAL; 431801c135cSArtem B. Bityutskiy } 432801c135cSArtem B. Bityutskiy 433801c135cSArtem B. Bityutskiy /* If the size is the same, we have nothing to do */ 434801c135cSArtem B. Bityutskiy if (reserved_pebs == vol->reserved_pebs) 435801c135cSArtem B. Bityutskiy return 0; 436801c135cSArtem B. Bityutskiy 437799dca34SBoris Brezillon new_eba_tbl = ubi_eba_create_table(vol, reserved_pebs); 438799dca34SBoris Brezillon if (IS_ERR(new_eba_tbl)) 439799dca34SBoris Brezillon return PTR_ERR(new_eba_tbl); 440801c135cSArtem B. Bityutskiy 441d05c77a8SArtem Bityutskiy spin_lock(&ubi->volumes_lock); 442d05c77a8SArtem Bityutskiy if (vol->ref_count > 1) { 443d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 444d05c77a8SArtem Bityutskiy err = -EBUSY; 445d05c77a8SArtem Bityutskiy goto out_free; 446d05c77a8SArtem Bityutskiy } 447d05c77a8SArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 448d05c77a8SArtem Bityutskiy 449d05c77a8SArtem Bityutskiy /* Reserve physical eraseblocks */ 450801c135cSArtem B. Bityutskiy pebs = reserved_pebs - vol->reserved_pebs; 451801c135cSArtem B. Bityutskiy if (pebs > 0) { 452801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock); 453801c135cSArtem B. Bityutskiy if (pebs > ubi->avail_pebs) { 45432608703STanya Brokhman ubi_err(ubi, "not enough PEBs: requested %d, available %d", 455801c135cSArtem B. Bityutskiy pebs, ubi->avail_pebs); 4565fc01ab6SArtem Bityutskiy if (ubi->corr_peb_count) 45732608703STanya Brokhman ubi_err(ubi, "%d PEBs are corrupted and not used", 4585fc01ab6SArtem Bityutskiy ubi->corr_peb_count); 459801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock); 460801c135cSArtem B. Bityutskiy err = -ENOSPC; 461801c135cSArtem B. Bityutskiy goto out_free; 462801c135cSArtem B. Bityutskiy } 463801c135cSArtem B. Bityutskiy ubi->avail_pebs -= pebs; 464801c135cSArtem B. Bityutskiy ubi->rsvd_pebs += pebs; 465799dca34SBoris Brezillon ubi_eba_copy_table(vol, new_eba_tbl, vol->reserved_pebs); 466799dca34SBoris Brezillon ubi_eba_replace_table(vol, new_eba_tbl); 467801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock); 468801c135cSArtem B. Bityutskiy } 469801c135cSArtem B. Bityutskiy 470801c135cSArtem B. Bityutskiy if (pebs < 0) { 471801c135cSArtem B. Bityutskiy for (i = 0; i < -pebs; i++) { 47289b96b69SArtem Bityutskiy err = ubi_eba_unmap_leb(ubi, vol, reserved_pebs + i); 473801c135cSArtem B. Bityutskiy if (err) 474801c135cSArtem B. Bityutskiy goto out_acc; 475801c135cSArtem B. Bityutskiy } 476801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock); 477801c135cSArtem B. Bityutskiy ubi->rsvd_pebs += pebs; 478801c135cSArtem B. Bityutskiy ubi->avail_pebs -= pebs; 47987e773c9SShmulik Ladkani ubi_update_reserved(ubi); 480799dca34SBoris Brezillon ubi_eba_copy_table(vol, new_eba_tbl, reserved_pebs); 481799dca34SBoris Brezillon ubi_eba_replace_table(vol, new_eba_tbl); 482801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock); 483801c135cSArtem B. Bityutskiy } 484801c135cSArtem B. Bityutskiy 4854946784bSRichard Weinberger /* 4864946784bSRichard Weinberger * When we shrink a volume we have to flush all pending (erase) work. 4874946784bSRichard Weinberger * Otherwise it can happen that upon next attach UBI finds a LEB with 4884946784bSRichard Weinberger * lnum > highest_lnum and refuses to attach. 4894946784bSRichard Weinberger */ 4904946784bSRichard Weinberger if (pebs < 0) { 4914946784bSRichard Weinberger err = ubi_wl_flush(ubi, vol_id, UBI_ALL); 4924946784bSRichard Weinberger if (err) 4934946784bSRichard Weinberger goto out_acc; 4944946784bSRichard Weinberger } 4954946784bSRichard Weinberger 4964946784bSRichard Weinberger /* Change volume table record */ 4974946784bSRichard Weinberger vtbl_rec = ubi->vtbl[vol_id]; 4984946784bSRichard Weinberger vtbl_rec.reserved_pebs = cpu_to_be32(reserved_pebs); 4994946784bSRichard Weinberger err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec); 5004946784bSRichard Weinberger if (err) 5014946784bSRichard Weinberger goto out_acc; 5024946784bSRichard Weinberger 503801c135cSArtem B. Bityutskiy vol->reserved_pebs = reserved_pebs; 504801c135cSArtem B. Bityutskiy if (vol->vol_type == UBI_DYNAMIC_VOLUME) { 505801c135cSArtem B. Bityutskiy vol->used_ebs = reserved_pebs; 506801c135cSArtem B. Bityutskiy vol->last_eb_bytes = vol->usable_leb_size; 507d08c3b78SVinit Agnihotri vol->used_bytes = 508d08c3b78SVinit Agnihotri (long long)vol->used_ebs * vol->usable_leb_size; 509801c135cSArtem B. Bityutskiy } 510801c135cSArtem B. Bityutskiy 5110e0ee1ccSDmitry Pervushin ubi_volume_notify(ubi, vol, UBI_VOLUME_RESIZED); 5127bf523aeSArtem Bityutskiy self_check_volumes(ubi); 513c8566350SArtem Bityutskiy return err; 514801c135cSArtem B. Bityutskiy 515801c135cSArtem B. Bityutskiy out_acc: 516801c135cSArtem B. Bityutskiy if (pebs > 0) { 517801c135cSArtem B. Bityutskiy spin_lock(&ubi->volumes_lock); 518801c135cSArtem B. Bityutskiy ubi->rsvd_pebs -= pebs; 519801c135cSArtem B. Bityutskiy ubi->avail_pebs += pebs; 520801c135cSArtem B. Bityutskiy spin_unlock(&ubi->volumes_lock); 521801c135cSArtem B. Bityutskiy } 522801c135cSArtem B. Bityutskiy out_free: 523799dca34SBoris Brezillon kfree(new_eba_tbl); 524801c135cSArtem B. Bityutskiy return err; 525801c135cSArtem B. Bityutskiy } 526801c135cSArtem B. Bityutskiy 527801c135cSArtem B. Bityutskiy /** 528f40ac9cdSArtem Bityutskiy * ubi_rename_volumes - re-name UBI volumes. 529f40ac9cdSArtem Bityutskiy * @ubi: UBI device description object 530ebaaf1afSArtem Bityutskiy * @rename_list: list of &struct ubi_rename_entry objects 531f40ac9cdSArtem Bityutskiy * 532f40ac9cdSArtem Bityutskiy * This function re-names or removes volumes specified in the re-name list. 533f40ac9cdSArtem Bityutskiy * Returns zero in case of success and a negative error code in case of 534f40ac9cdSArtem Bityutskiy * failure. 535f40ac9cdSArtem Bityutskiy */ 536f40ac9cdSArtem Bityutskiy int ubi_rename_volumes(struct ubi_device *ubi, struct list_head *rename_list) 537f40ac9cdSArtem Bityutskiy { 538f40ac9cdSArtem Bityutskiy int err; 539f40ac9cdSArtem Bityutskiy struct ubi_rename_entry *re; 540f40ac9cdSArtem Bityutskiy 541f40ac9cdSArtem Bityutskiy err = ubi_vtbl_rename_volumes(ubi, rename_list); 542f40ac9cdSArtem Bityutskiy if (err) 543f40ac9cdSArtem Bityutskiy return err; 544f40ac9cdSArtem Bityutskiy 545f40ac9cdSArtem Bityutskiy list_for_each_entry(re, rename_list, list) { 546f40ac9cdSArtem Bityutskiy if (re->remove) { 547f40ac9cdSArtem Bityutskiy err = ubi_remove_volume(re->desc, 1); 548f40ac9cdSArtem Bityutskiy if (err) 549f40ac9cdSArtem Bityutskiy break; 550f40ac9cdSArtem Bityutskiy } else { 551f40ac9cdSArtem Bityutskiy struct ubi_volume *vol = re->desc->vol; 552f40ac9cdSArtem Bityutskiy 553f40ac9cdSArtem Bityutskiy spin_lock(&ubi->volumes_lock); 554f40ac9cdSArtem Bityutskiy vol->name_len = re->new_name_len; 555f40ac9cdSArtem Bityutskiy memcpy(vol->name, re->new_name, re->new_name_len + 1); 556f40ac9cdSArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 5570e0ee1ccSDmitry Pervushin ubi_volume_notify(ubi, vol, UBI_VOLUME_RENAMED); 558f40ac9cdSArtem Bityutskiy } 559f40ac9cdSArtem Bityutskiy } 560f40ac9cdSArtem Bityutskiy 5617bf523aeSArtem Bityutskiy if (!err) 5627bf523aeSArtem Bityutskiy self_check_volumes(ubi); 563f40ac9cdSArtem Bityutskiy return err; 564f40ac9cdSArtem Bityutskiy } 565f40ac9cdSArtem Bityutskiy 566f40ac9cdSArtem Bityutskiy /** 567801c135cSArtem B. Bityutskiy * ubi_add_volume - add volume. 568801c135cSArtem B. Bityutskiy * @ubi: UBI device description object 56989b96b69SArtem Bityutskiy * @vol: volume description object 570801c135cSArtem B. Bityutskiy * 571d05c77a8SArtem Bityutskiy * This function adds an existing volume and initializes all its data 572d05c77a8SArtem Bityutskiy * structures. Returns zero in case of success and a negative error code in 573801c135cSArtem B. Bityutskiy * case of failure. 574801c135cSArtem B. Bityutskiy */ 57589b96b69SArtem Bityutskiy int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol) 576801c135cSArtem B. Bityutskiy { 57789b96b69SArtem Bityutskiy int err, vol_id = vol->vol_id; 57849dfc299SArtem Bityutskiy dev_t dev; 579801c135cSArtem B. Bityutskiy 580c8566350SArtem Bityutskiy dbg_gen("add volume %d", vol_id); 581801c135cSArtem B. Bityutskiy 582801c135cSArtem B. Bityutskiy /* Register character device for the volume */ 583801c135cSArtem B. Bityutskiy cdev_init(&vol->cdev, &ubi_vol_cdev_operations); 584801c135cSArtem B. Bityutskiy vol->cdev.owner = THIS_MODULE; 58549dfc299SArtem Bityutskiy dev = MKDEV(MAJOR(ubi->cdev.dev), vol->vol_id + 1); 58649dfc299SArtem Bityutskiy err = cdev_add(&vol->cdev, dev, 1); 587801c135cSArtem B. Bityutskiy if (err) { 58832608703STanya Brokhman ubi_err(ubi, "cannot add character device for volume %d, error %d", 58901f7b309SArtem Bityutskiy vol_id, err); 590801c135cSArtem B. Bityutskiy return err; 591801c135cSArtem B. Bityutskiy } 592801c135cSArtem B. Bityutskiy 593801c135cSArtem B. Bityutskiy vol->dev.release = vol_release; 594801c135cSArtem B. Bityutskiy vol->dev.parent = &ubi->dev; 59549dfc299SArtem Bityutskiy vol->dev.devt = dev; 59653cd255cSTakashi Iwai vol->dev.class = &ubi_class; 59753cd255cSTakashi Iwai vol->dev.groups = volume_dev_groups; 598475b44c1SKay Sievers dev_set_name(&vol->dev, "%s_%d", ubi->ubi_name, vol->vol_id); 599801c135cSArtem B. Bityutskiy err = device_register(&vol->dev); 600801c135cSArtem B. Bityutskiy if (err) 601518ceef0SDmitry Pervushin goto out_cdev; 602801c135cSArtem B. Bityutskiy 6037bf523aeSArtem Bityutskiy self_check_volumes(ubi); 604c8566350SArtem Bityutskiy return err; 605801c135cSArtem B. Bityutskiy 606801c135cSArtem B. Bityutskiy out_cdev: 607801c135cSArtem B. Bityutskiy cdev_del(&vol->cdev); 608801c135cSArtem B. Bityutskiy return err; 609801c135cSArtem B. Bityutskiy } 610801c135cSArtem B. Bityutskiy 611801c135cSArtem B. Bityutskiy /** 612801c135cSArtem B. Bityutskiy * ubi_free_volume - free volume. 613801c135cSArtem B. Bityutskiy * @ubi: UBI device description object 61489b96b69SArtem Bityutskiy * @vol: volume description object 615801c135cSArtem B. Bityutskiy * 61689b96b69SArtem Bityutskiy * This function frees all resources for volume @vol but does not remove it. 617801c135cSArtem B. Bityutskiy * Used only when the UBI device is detached. 618801c135cSArtem B. Bityutskiy */ 61989b96b69SArtem Bityutskiy void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol) 620801c135cSArtem B. Bityutskiy { 621c8566350SArtem Bityutskiy dbg_gen("free volume %d", vol->vol_id); 622801c135cSArtem B. Bityutskiy 62389b96b69SArtem Bityutskiy ubi->volumes[vol->vol_id] = NULL; 624801c135cSArtem B. Bityutskiy cdev_del(&vol->cdev); 62553cd255cSTakashi Iwai device_unregister(&vol->dev); 626801c135cSArtem B. Bityutskiy } 627801c135cSArtem B. Bityutskiy 628801c135cSArtem B. Bityutskiy /** 6297bf523aeSArtem Bityutskiy * self_check_volume - check volume information. 630801c135cSArtem B. Bityutskiy * @ubi: UBI device description object 631801c135cSArtem B. Bityutskiy * @vol_id: volume ID 632c8566350SArtem Bityutskiy * 633c8566350SArtem Bityutskiy * Returns zero if volume is all right and a a negative error code if not. 634801c135cSArtem B. Bityutskiy */ 6357bf523aeSArtem Bityutskiy static int self_check_volume(struct ubi_device *ubi, int vol_id) 636801c135cSArtem B. Bityutskiy { 637801c135cSArtem B. Bityutskiy int idx = vol_id2idx(ubi, vol_id); 638801c135cSArtem B. Bityutskiy int reserved_pebs, alignment, data_pad, vol_type, name_len, upd_marker; 639b89044bfSArtem Bityutskiy const struct ubi_volume *vol; 640801c135cSArtem B. Bityutskiy long long n; 641801c135cSArtem B. Bityutskiy const char *name; 642801c135cSArtem B. Bityutskiy 643b89044bfSArtem Bityutskiy spin_lock(&ubi->volumes_lock); 6443261ebd7SChristoph Hellwig reserved_pebs = be32_to_cpu(ubi->vtbl[vol_id].reserved_pebs); 645b89044bfSArtem Bityutskiy vol = ubi->volumes[idx]; 646801c135cSArtem B. Bityutskiy 647801c135cSArtem B. Bityutskiy if (!vol) { 648801c135cSArtem B. Bityutskiy if (reserved_pebs) { 64932608703STanya Brokhman ubi_err(ubi, "no volume info, but volume exists"); 650801c135cSArtem B. Bityutskiy goto fail; 651801c135cSArtem B. Bityutskiy } 652b89044bfSArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 653c8566350SArtem Bityutskiy return 0; 654801c135cSArtem B. Bityutskiy } 655801c135cSArtem B. Bityutskiy 656801c135cSArtem B. Bityutskiy if (vol->reserved_pebs < 0 || vol->alignment < 0 || vol->data_pad < 0 || 657801c135cSArtem B. Bityutskiy vol->name_len < 0) { 65832608703STanya Brokhman ubi_err(ubi, "negative values"); 659801c135cSArtem B. Bityutskiy goto fail; 660801c135cSArtem B. Bityutskiy } 661801c135cSArtem B. Bityutskiy if (vol->alignment > ubi->leb_size || vol->alignment == 0) { 66232608703STanya Brokhman ubi_err(ubi, "bad alignment"); 663801c135cSArtem B. Bityutskiy goto fail; 664801c135cSArtem B. Bityutskiy } 665801c135cSArtem B. Bityutskiy 666cadb40ccSKyungmin Park n = vol->alignment & (ubi->min_io_size - 1); 667801c135cSArtem B. Bityutskiy if (vol->alignment != 1 && n) { 66832608703STanya Brokhman ubi_err(ubi, "alignment is not multiple of min I/O unit"); 669801c135cSArtem B. Bityutskiy goto fail; 670801c135cSArtem B. Bityutskiy } 671801c135cSArtem B. Bityutskiy 672801c135cSArtem B. Bityutskiy n = ubi->leb_size % vol->alignment; 673801c135cSArtem B. Bityutskiy if (vol->data_pad != n) { 67432608703STanya Brokhman ubi_err(ubi, "bad data_pad, has to be %lld", n); 675801c135cSArtem B. Bityutskiy goto fail; 676801c135cSArtem B. Bityutskiy } 677801c135cSArtem B. Bityutskiy 678801c135cSArtem B. Bityutskiy if (vol->vol_type != UBI_DYNAMIC_VOLUME && 679801c135cSArtem B. Bityutskiy vol->vol_type != UBI_STATIC_VOLUME) { 68032608703STanya Brokhman ubi_err(ubi, "bad vol_type"); 681801c135cSArtem B. Bityutskiy goto fail; 682801c135cSArtem B. Bityutskiy } 683801c135cSArtem B. Bityutskiy 684801c135cSArtem B. Bityutskiy if (vol->upd_marker && vol->corrupted) { 68532608703STanya Brokhman ubi_err(ubi, "update marker and corrupted simultaneously"); 686801c135cSArtem B. Bityutskiy goto fail; 687801c135cSArtem B. Bityutskiy } 688801c135cSArtem B. Bityutskiy 689801c135cSArtem B. Bityutskiy if (vol->reserved_pebs > ubi->good_peb_count) { 69032608703STanya Brokhman ubi_err(ubi, "too large reserved_pebs"); 691801c135cSArtem B. Bityutskiy goto fail; 692801c135cSArtem B. Bityutskiy } 693801c135cSArtem B. Bityutskiy 694801c135cSArtem B. Bityutskiy n = ubi->leb_size - vol->data_pad; 695801c135cSArtem B. Bityutskiy if (vol->usable_leb_size != ubi->leb_size - vol->data_pad) { 69632608703STanya Brokhman ubi_err(ubi, "bad usable_leb_size, has to be %lld", n); 697801c135cSArtem B. Bityutskiy goto fail; 698801c135cSArtem B. Bityutskiy } 699801c135cSArtem B. Bityutskiy 700801c135cSArtem B. Bityutskiy if (vol->name_len > UBI_VOL_NAME_MAX) { 70132608703STanya Brokhman ubi_err(ubi, "too long volume name, max is %d", 70232608703STanya Brokhman UBI_VOL_NAME_MAX); 703801c135cSArtem B. Bityutskiy goto fail; 704801c135cSArtem B. Bityutskiy } 705801c135cSArtem B. Bityutskiy 706801c135cSArtem B. Bityutskiy n = strnlen(vol->name, vol->name_len + 1); 707801c135cSArtem B. Bityutskiy if (n != vol->name_len) { 70832608703STanya Brokhman ubi_err(ubi, "bad name_len %lld", n); 709801c135cSArtem B. Bityutskiy goto fail; 710801c135cSArtem B. Bityutskiy } 711801c135cSArtem B. Bityutskiy 712d08c3b78SVinit Agnihotri n = (long long)vol->used_ebs * vol->usable_leb_size; 713801c135cSArtem B. Bityutskiy if (vol->vol_type == UBI_DYNAMIC_VOLUME) { 714896c0c06SArtem Bityutskiy if (vol->corrupted) { 71532608703STanya Brokhman ubi_err(ubi, "corrupted dynamic volume"); 716801c135cSArtem B. Bityutskiy goto fail; 717801c135cSArtem B. Bityutskiy } 718801c135cSArtem B. Bityutskiy if (vol->used_ebs != vol->reserved_pebs) { 71932608703STanya Brokhman ubi_err(ubi, "bad used_ebs"); 720801c135cSArtem B. Bityutskiy goto fail; 721801c135cSArtem B. Bityutskiy } 722801c135cSArtem B. Bityutskiy if (vol->last_eb_bytes != vol->usable_leb_size) { 72332608703STanya Brokhman ubi_err(ubi, "bad last_eb_bytes"); 724801c135cSArtem B. Bityutskiy goto fail; 725801c135cSArtem B. Bityutskiy } 726801c135cSArtem B. Bityutskiy if (vol->used_bytes != n) { 72732608703STanya Brokhman ubi_err(ubi, "bad used_bytes"); 728801c135cSArtem B. Bityutskiy goto fail; 729801c135cSArtem B. Bityutskiy } 73062652517SQuentin Schulz 73162652517SQuentin Schulz if (vol->skip_check) { 73262652517SQuentin Schulz ubi_err(ubi, "bad skip_check"); 73362652517SQuentin Schulz goto fail; 73462652517SQuentin Schulz } 735801c135cSArtem B. Bityutskiy } else { 736801c135cSArtem B. Bityutskiy if (vol->used_ebs < 0 || vol->used_ebs > vol->reserved_pebs) { 73732608703STanya Brokhman ubi_err(ubi, "bad used_ebs"); 738801c135cSArtem B. Bityutskiy goto fail; 739801c135cSArtem B. Bityutskiy } 740801c135cSArtem B. Bityutskiy if (vol->last_eb_bytes < 0 || 741801c135cSArtem B. Bityutskiy vol->last_eb_bytes > vol->usable_leb_size) { 74232608703STanya Brokhman ubi_err(ubi, "bad last_eb_bytes"); 743801c135cSArtem B. Bityutskiy goto fail; 744801c135cSArtem B. Bityutskiy } 745801c135cSArtem B. Bityutskiy if (vol->used_bytes < 0 || vol->used_bytes > n || 746801c135cSArtem B. Bityutskiy vol->used_bytes < n - vol->usable_leb_size) { 74732608703STanya Brokhman ubi_err(ubi, "bad used_bytes"); 748801c135cSArtem B. Bityutskiy goto fail; 749801c135cSArtem B. Bityutskiy } 750801c135cSArtem B. Bityutskiy } 751801c135cSArtem B. Bityutskiy 7523261ebd7SChristoph Hellwig alignment = be32_to_cpu(ubi->vtbl[vol_id].alignment); 7533261ebd7SChristoph Hellwig data_pad = be32_to_cpu(ubi->vtbl[vol_id].data_pad); 7543261ebd7SChristoph Hellwig name_len = be16_to_cpu(ubi->vtbl[vol_id].name_len); 755801c135cSArtem B. Bityutskiy upd_marker = ubi->vtbl[vol_id].upd_marker; 756801c135cSArtem B. Bityutskiy name = &ubi->vtbl[vol_id].name[0]; 757801c135cSArtem B. Bityutskiy if (ubi->vtbl[vol_id].vol_type == UBI_VID_DYNAMIC) 758801c135cSArtem B. Bityutskiy vol_type = UBI_DYNAMIC_VOLUME; 759801c135cSArtem B. Bityutskiy else 760801c135cSArtem B. Bityutskiy vol_type = UBI_STATIC_VOLUME; 761801c135cSArtem B. Bityutskiy 762801c135cSArtem B. Bityutskiy if (alignment != vol->alignment || data_pad != vol->data_pad || 763801c135cSArtem B. Bityutskiy upd_marker != vol->upd_marker || vol_type != vol->vol_type || 764801c135cSArtem B. Bityutskiy name_len != vol->name_len || strncmp(name, vol->name, name_len)) { 76532608703STanya Brokhman ubi_err(ubi, "volume info is different"); 766801c135cSArtem B. Bityutskiy goto fail; 767801c135cSArtem B. Bityutskiy } 768801c135cSArtem B. Bityutskiy 769b89044bfSArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 770c8566350SArtem Bityutskiy return 0; 771801c135cSArtem B. Bityutskiy 772801c135cSArtem B. Bityutskiy fail: 77332608703STanya Brokhman ubi_err(ubi, "self-check failed for volume %d", vol_id); 774f40ac9cdSArtem Bityutskiy if (vol) 775766381f0SArtem Bityutskiy ubi_dump_vol_info(vol); 7761f021e1dSArtem Bityutskiy ubi_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id); 777cfcf0ec8SArtem Bityutskiy dump_stack(); 778b89044bfSArtem Bityutskiy spin_unlock(&ubi->volumes_lock); 779c8566350SArtem Bityutskiy return -EINVAL; 780801c135cSArtem B. Bityutskiy } 781801c135cSArtem B. Bityutskiy 782801c135cSArtem B. Bityutskiy /** 7837bf523aeSArtem Bityutskiy * self_check_volumes - check information about all volumes. 784801c135cSArtem B. Bityutskiy * @ubi: UBI device description object 785c8566350SArtem Bityutskiy * 786c8566350SArtem Bityutskiy * Returns zero if volumes are all right and a a negative error code if not. 787801c135cSArtem B. Bityutskiy */ 7887bf523aeSArtem Bityutskiy static int self_check_volumes(struct ubi_device *ubi) 789801c135cSArtem B. Bityutskiy { 790c8566350SArtem Bityutskiy int i, err = 0; 791801c135cSArtem B. Bityutskiy 79264575574SEzequiel Garcia if (!ubi_dbg_chk_gen(ubi)) 79392d124f5SArtem Bityutskiy return 0; 79492d124f5SArtem Bityutskiy 795c8566350SArtem Bityutskiy for (i = 0; i < ubi->vtbl_slots; i++) { 7967bf523aeSArtem Bityutskiy err = self_check_volume(ubi, i); 797c8566350SArtem Bityutskiy if (err) 798c8566350SArtem Bityutskiy break; 799c8566350SArtem Bityutskiy } 800c8566350SArtem Bityutskiy 801c8566350SArtem Bityutskiy return err; 802801c135cSArtem B. Bityutskiy } 803