vmt.rar_creation

/* * Copyright (c) International Business Machines Corp., 2006 * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See * the GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA * * Author: Artem Bityutskiy (Битюцкий Артём) */ /* * This file contains implementation of volume creation, deletion, updating and * resizing. */ #include <linux/err.h> #include <linux/math64.h> #include <linux/slab.h> #include <linux/export.h> #include "ubi.h" static int self_check_volumes(struct ubi_device *ubi); static ssize_t vol_attribute_show(struct device *dev, struct device_attribute *attr, char *buf); /* Device attributes corresponding to files in '/<sysfs>/class/ubi/ubiX_Y' */ static struct device_attribute attr_vol_reserved_ebs = __ATTR(reserved_ebs, S_IRUGO, vol_attribute_show, NULL); static struct device_attribute attr_vol_type = __ATTR(type, S_IRUGO, vol_attribute_show, NULL); static struct device_attribute attr_vol_name = __ATTR(name, S_IRUGO, vol_attribute_show, NULL); static struct device_attribute attr_vol_corrupted = __ATTR(corrupted, S_IRUGO, vol_attribute_show, NULL); static struct device_attribute attr_vol_alignment = __ATTR(alignment, S_IRUGO, vol_attribute_show, NULL); static struct device_attribute attr_vol_usable_eb_size = __ATTR(usable_eb_size, S_IRUGO, vol_attribute_show, NULL); static struct device_attribute attr_vol_data_bytes = __ATTR(data_bytes, S_IRUGO, vol_attribute_show, NULL); static struct device_attribute attr_vol_upd_marker = __ATTR(upd_marker, S_IRUGO, vol_attribute_show, NULL); /* * "Show" method for files in '/<sysfs>/class/ubi/ubiX_Y/'. * * Consider a situation: * A. process 1 opens a sysfs file related to volume Y, say * /<sysfs>/class/ubi/ubiX_Y/reserved_ebs; * B. process 2 removes volume Y; * C. process 1 starts reading the /<sysfs>/class/ubi/ubiX_Y/reserved_ebs file; * * In this situation, this function will return %-ENODEV because it will find * out that the volume was removed from the @ubi->volumes array. */ static ssize_t vol_attribute_show(struct device *dev, struct device_attribute *attr, char *buf) { int ret; struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev); struct ubi_device *ubi; ubi = ubi_get_device(vol->ubi->ubi_num); if (!ubi) return -ENODEV; spin_lock(&ubi->volumes_lock); if (!ubi->volumes[vol->vol_id]) { spin_unlock(&ubi->volumes_lock); ubi_put_device(ubi); return -ENODEV; } /* Take a reference to prevent volume removal */ vol->ref_count += 1; spin_unlock(&ubi->volumes_lock); if (attr == &attr_vol_reserved_ebs) ret = sprintf(buf, "%d\n", vol->reserved_pebs); else if (attr == &attr_vol_type) { const char *tp; if (vol->vol_type == UBI_DYNAMIC_VOLUME) tp = "dynamic"; else tp = "static"; ret = sprintf(buf, "%s\n", tp); } else if (attr == &attr_vol_name) ret = sprintf(buf, "%s\n", vol->name); else if (attr == &attr_vol_corrupted) ret = sprintf(buf, "%d\n", vol->corrupted); else if (attr == &attr_vol_alignment) ret = sprintf(buf, "%d\n", vol->alignment); else if (attr == &attr_vol_usable_eb_size) ret = sprintf(buf, "%d\n", vol->usable_leb_size); else if (attr == &attr_vol_data_bytes) ret = sprintf(buf, "%lld\n", vol->used_bytes); else if (attr == &attr_vol_upd_marker) ret = sprintf(buf, "%d\n", vol->upd_marker); else /* This must be a bug */ ret = -EINVAL; /* We've done the operation, drop volume and UBI device references */ spin_lock(&ubi->volumes_lock); vol->ref_count -= 1; ubi_assert(vol->ref_count >= 0); spin_unlock(&ubi->volumes_lock); ubi_put_device(ubi); return ret; } /* Release method for volume devices */ static void vol_release(struct device *dev) { struct ubi_volume *vol = container_of(dev, struct ubi_volume, dev); kfree(vol->eba_tbl); kfree(vol); } /** * volume_sysfs_init - initialize sysfs for new volume. * @ubi: UBI device description object * @vol: volume description object * * This function returns zero in case of success and a negative error code in * case of failure. * * Note, this function does not free allocated resources in case of failure - * the caller does it. This is because this would cause release() here and the * caller would oops. */ static int volume_sysfs_init(struct ubi_device *ubi, struct ubi_volume *vol) { int err; err = device_create_file(&vol->dev, &attr_vol_reserved_ebs); if (err) return err; err = device_create_file(&vol->dev, &attr_vol_type); if (err) return err; err = device_create_file(&vol->dev, &attr_vol_name); if (err) return err; err = device_create_file(&vol->dev, &attr_vol_corrupted); if (err) return err; err = device_create_file(&vol->dev, &attr_vol_alignment); if (err) return err; err = device_create_file(&vol->dev, &attr_vol_usable_eb_size); if (err) return err; err = device_create_file(&vol->dev, &attr_vol_data_bytes); if (err) return err; err = device_create_file(&vol->dev, &attr_vol_upd_marker); return err; } /** * volume_sysfs_close - close sysfs for a volume. * @vol: volume description object */ static void volume_sysfs_close(struct ubi_volume *vol) { device_remove_file(&vol->dev, &attr_vol_upd_marker); device_remove_file(&vol->dev, &attr_vol_data_bytes); device_remove_file(&vol->dev, &attr_vol_usable_eb_size); device_remove_file(&vol->dev, &attr_vol_alignment); device_remove_file(&vol->dev, &attr_vol_corrupted); device_remove_file(&vol->dev, &attr_vol_name); device_remove_file(&vol->dev, &attr_vol_type); device_remove_file(&vol->dev, &attr_vol_reserved_ebs); device_unregister(&vol->dev); } /** * ubi_create_volume - create volume. * @ubi: UBI device description object * @req: volume creation request * * This function creates volume described by @req. If @req->vol_id id * %UBI_VOL_NUM_AUTO, this function automatically assign ID to the new volume * and saves it in @req->vol_id. Returns zero in case of success and a negative * error code in case of failure. Note, the caller has to have the * @ubi->device_mutex locked. */ int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req) { int i, err, vol_id = req->vol_id, do_free = 1; struct ubi_volume *vol; struct ubi_vtbl_record vtbl_rec; dev_t dev; if (ubi->ro_mode) return -EROFS; vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL); if (!vol) return -ENOMEM; spin_lock(&ubi->volumes_lock); if (vol_id == UBI_VOL_NUM_AUTO) { /* Find unused volume ID */ dbg_gen("search for vacant volume ID"); for (i = 0; i < ubi->vtbl_slots; i++) if (!ubi->volumes[i]) { vol_id = i; break; } if (vol_id == UBI_VOL_NUM_AUTO) { ubi_err(ubi, "out of volume IDs"); err = -ENFILE; goto out_unlock; } req->vol_id = vol_id; } dbg_gen("create device %d, volume %d, %llu bytes, type %d, name %s", ubi->ubi_num, vol_id, (unsigned long long)req->bytes, (int)req->vol_type, req->name); /* Ensure that this volume does not exist */ err = -EEXIST; if (ubi->volumes[vol_id]) { ubi_err(ubi, "volume %d already exists", vol_id); goto out_unlock; } /* Ensure that the name is unique */ for (i = 0; i < ubi->vtbl_slots; i++) if (ubi->volumes[i] && ubi->volumes[i]->name_len == req->name_len && !strcmp(ubi->volumes[i]->name, req->name)) { ubi_err(ubi, "volume \"%s\" exists (ID %d)", req->name, i); goto out_unlock; } /* Calculate how many eraseblocks are request