UBI: remove old ubi support
To update to the latest UBI support from the Kernel first remove the old UBI support. Without it the update will be even less reviewable. Signed-off-by: Sascha Hauer <s.hauer@pengutronix.de>
This commit is contained in:
parent
56ac905457
commit
10f7528afb
|
@ -23,6 +23,6 @@ config MTD_RAW_DEVICE
|
|||
source "drivers/mtd/devices/Kconfig"
|
||||
source "drivers/mtd/nor/Kconfig"
|
||||
source "drivers/mtd/nand/Kconfig"
|
||||
source "drivers/mtd/ubi/Kconfig"
|
||||
#source "drivers/mtd/ubi/Kconfig"
|
||||
|
||||
endif
|
||||
|
|
|
@ -1,7 +0,0 @@
|
|||
config UBI
|
||||
bool "UBI support"
|
||||
select PARTITION_NEED_MTD
|
||||
select CRC32
|
||||
help
|
||||
This enables support for UBI (unsorted block images)
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
obj-y += build.o vtbl.o vmt.o upd.o kapi.o eba.o io.o wl.o scan.o misc.o debug.o cdev.o
|
||||
|
||||
|
File diff suppressed because it is too large
Load Diff
|
@ -1,251 +0,0 @@
|
|||
#include <common.h>
|
||||
#include <fcntl.h>
|
||||
#include <fs.h>
|
||||
#include <ioctl.h>
|
||||
#include "ubi-barebox.h"
|
||||
#include "ubi.h"
|
||||
|
||||
struct ubi_volume_cdev_priv {
|
||||
struct ubi_device *ubi;
|
||||
struct ubi_volume *vol;
|
||||
int written;
|
||||
};
|
||||
|
||||
static ssize_t ubi_volume_cdev_read(struct cdev *cdev, void *buf, size_t size,
|
||||
loff_t offset, unsigned long flags)
|
||||
{
|
||||
struct ubi_volume_cdev_priv *priv = cdev->priv;
|
||||
struct ubi_volume *vol = priv->vol;
|
||||
struct ubi_device *ubi = priv->ubi;
|
||||
int err, lnum, off, len;
|
||||
size_t count_save = size;
|
||||
unsigned long long tmp;
|
||||
loff_t offp = offset;
|
||||
int usable_leb_size = vol->usable_leb_size;
|
||||
|
||||
printf("%s: %zd @ 0x%08llx\n", __func__, size, offset);
|
||||
|
||||
len = size > usable_leb_size ? usable_leb_size : size;
|
||||
|
||||
tmp = offp;
|
||||
off = do_div(tmp, usable_leb_size);
|
||||
lnum = tmp;
|
||||
do {
|
||||
if (off + len >= usable_leb_size)
|
||||
len = usable_leb_size - off;
|
||||
|
||||
err = ubi_eba_read_leb(ubi, vol, lnum, buf, off, len, 0);
|
||||
if (err) {
|
||||
printf("read err %x\n", err);
|
||||
break;
|
||||
}
|
||||
off += len;
|
||||
if (off == usable_leb_size) {
|
||||
lnum += 1;
|
||||
off -= usable_leb_size;
|
||||
}
|
||||
|
||||
size -= len;
|
||||
offp += len;
|
||||
|
||||
buf += len;
|
||||
len = size > usable_leb_size ? usable_leb_size : size;
|
||||
} while (size);
|
||||
|
||||
return count_save;
|
||||
}
|
||||
|
||||
static ssize_t ubi_volume_cdev_write(struct cdev* cdev, const void *buf,
|
||||
size_t size, loff_t offset, unsigned long flags)
|
||||
{
|
||||
struct ubi_volume_cdev_priv *priv = cdev->priv;
|
||||
struct ubi_volume *vol = priv->vol;
|
||||
struct ubi_device *ubi = priv->ubi;
|
||||
int err;
|
||||
|
||||
if (!priv->written) {
|
||||
err = ubi_start_update(ubi, vol, vol->used_bytes);
|
||||
if (err < 0) {
|
||||
printf("Cannot start volume update\n");
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
err = ubi_more_update_data(ubi, vol, buf, size);
|
||||
if (err < 0) {
|
||||
printf("Couldnt or partially wrote data \n");
|
||||
return err;
|
||||
}
|
||||
|
||||
priv->written += size;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
static int ubi_volume_cdev_open(struct cdev *cdev, unsigned long flags)
|
||||
{
|
||||
struct ubi_volume_cdev_priv *priv = cdev->priv;
|
||||
|
||||
priv->written = 0;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int ubi_volume_cdev_close(struct cdev *cdev)
|
||||
{
|
||||
struct ubi_volume_cdev_priv *priv = cdev->priv;
|
||||
struct ubi_volume *vol = priv->vol;
|
||||
struct ubi_device *ubi = priv->ubi;
|
||||
int err;
|
||||
|
||||
if (priv->written) {
|
||||
int remaining = vol->usable_leb_size -
|
||||
(priv->written % vol->usable_leb_size);
|
||||
|
||||
if (remaining) {
|
||||
void *buf = xzalloc(remaining);
|
||||
|
||||
memset(buf, 0xff, remaining);
|
||||
|
||||
err = ubi_more_update_data(ubi, vol, buf, remaining);
|
||||
|
||||
free(buf);
|
||||
|
||||
if (err < 0) {
|
||||
printf("Couldnt or partially wrote data \n");
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
err = ubi_finish_update(ubi, vol);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = ubi_check_volume(ubi, vol->vol_id);
|
||||
if (err < 0) {
|
||||
printf("check failed: %s\n", strerror(err));
|
||||
return err;
|
||||
}
|
||||
|
||||
if (err) {
|
||||
ubi_warn("volume %d on UBI device %d is corrupted",
|
||||
vol->vol_id, ubi->ubi_num);
|
||||
vol->corrupted = 1;
|
||||
}
|
||||
|
||||
vol->checked = 1;
|
||||
ubi_gluebi_updated(vol);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static loff_t ubi_volume_cdev_lseek(struct cdev *cdev, loff_t ofs)
|
||||
{
|
||||
struct ubi_volume_cdev_priv *priv = cdev->priv;
|
||||
|
||||
/* We can only update ubi volumes sequentially */
|
||||
if (priv->written)
|
||||
return -EINVAL;
|
||||
|
||||
return ofs;
|
||||
}
|
||||
|
||||
static struct file_operations ubi_volume_fops = {
|
||||
.open = ubi_volume_cdev_open,
|
||||
.close = ubi_volume_cdev_close,
|
||||
.read = ubi_volume_cdev_read,
|
||||
.write = ubi_volume_cdev_write,
|
||||
.lseek = ubi_volume_cdev_lseek,
|
||||
};
|
||||
|
||||
int ubi_volume_cdev_add(struct ubi_device *ubi, struct ubi_volume *vol)
|
||||
{
|
||||
struct cdev *cdev = &vol->cdev;
|
||||
struct ubi_volume_cdev_priv *priv;
|
||||
int ret;
|
||||
|
||||
priv = xzalloc(sizeof(*priv));
|
||||
|
||||
priv->vol = vol;
|
||||
priv->ubi = ubi;
|
||||
|
||||
cdev->ops = &ubi_volume_fops;
|
||||
cdev->name = asprintf("ubi%d.%s", ubi->ubi_num, vol->name);
|
||||
cdev->priv = priv;
|
||||
cdev->size = vol->used_bytes;
|
||||
printf("registering %s as /dev/%s\n", vol->name, cdev->name);
|
||||
ret = devfs_create(cdev);
|
||||
if (ret) {
|
||||
free(priv);
|
||||
free(cdev->name);
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
void ubi_volume_cdev_remove(struct ubi_volume *vol)
|
||||
{
|
||||
struct cdev *cdev = &vol->cdev;
|
||||
struct ubi_volume_cdev_priv *priv = cdev->priv;
|
||||
|
||||
devfs_remove(cdev);
|
||||
free(cdev->name);
|
||||
free(priv);
|
||||
}
|
||||
|
||||
static int ubi_cdev_ioctl(struct cdev *cdev, int cmd, void *buf)
|
||||
{
|
||||
struct ubi_volume_desc *desc;
|
||||
struct ubi_device *ubi = cdev->priv;
|
||||
struct ubi_mkvol_req *req = buf;
|
||||
|
||||
switch (cmd) {
|
||||
case UBI_IOCRMVOL:
|
||||
desc = ubi_open_volume_nm(ubi->ubi_num, req->name,
|
||||
UBI_EXCLUSIVE);
|
||||
if (IS_ERR(desc))
|
||||
return PTR_ERR(desc);
|
||||
ubi_remove_volume(desc);
|
||||
break;
|
||||
case UBI_IOCMKVOL:
|
||||
if (!req->bytes)
|
||||
req->bytes = ubi->avail_pebs * ubi->leb_size;
|
||||
return ubi_create_volume(ubi, req);
|
||||
};
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
static struct file_operations ubi_fops = {
|
||||
.ioctl = ubi_cdev_ioctl,
|
||||
};
|
||||
|
||||
int ubi_cdev_add(struct ubi_device *ubi)
|
||||
{
|
||||
struct cdev *cdev = &ubi->cdev;
|
||||
int ret;
|
||||
|
||||
cdev->ops = &ubi_fops;
|
||||
cdev->name = asprintf("ubi%d", ubi->ubi_num);
|
||||
cdev->priv = ubi;
|
||||
cdev->size = 0;
|
||||
|
||||
printf("registering /dev/%s\n", cdev->name);
|
||||
ret = devfs_create(cdev);
|
||||
if (ret)
|
||||
free(cdev->name);
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
void ubi_cdev_remove(struct ubi_device *ubi)
|
||||
{
|
||||
struct cdev *cdev = &ubi->cdev;
|
||||
|
||||
printf("removing %s\n", cdev->name);
|
||||
|
||||
devfs_remove(cdev);
|
||||
free(cdev->name);
|
||||
}
|
|
@ -1,32 +0,0 @@
|
|||
/*
|
||||
* There are multiple 16-bit CRC polynomials in common use, but this is
|
||||
* *the* standard CRC-32 polynomial, first popularized by Ethernet.
|
||||
* x^32+x^26+x^23+x^22+x^16+x^12+x^11+x^10+x^8+x^7+x^5+x^4+x^2+x^1+x^0
|
||||
*/
|
||||
#define CRCPOLY_LE 0xedb88320
|
||||
#define CRCPOLY_BE 0x04c11db7
|
||||
|
||||
/* How many bits at a time to use. Requires a table of 4<<CRC_xx_BITS bytes. */
|
||||
/* For less performance-sensitive, use 4 */
|
||||
#ifndef CRC_LE_BITS
|
||||
# define CRC_LE_BITS 8
|
||||
#endif
|
||||
#ifndef CRC_BE_BITS
|
||||
# define CRC_BE_BITS 8
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Little-endian CRC computation. Used with serial bit streams sent
|
||||
* lsbit-first. Be sure to use cpu_to_le32() to append the computed CRC.
|
||||
*/
|
||||
#if CRC_LE_BITS > 8 || CRC_LE_BITS < 1 || CRC_LE_BITS & CRC_LE_BITS-1
|
||||
# error CRC_LE_BITS must be a power of 2 between 1 and 8
|
||||
#endif
|
||||
|
||||
/*
|
||||
* Big-endian CRC computation. Used with serial bit streams sent
|
||||
* msbit-first. Be sure to use cpu_to_be32() to append the computed CRC.
|
||||
*/
|
||||
#if CRC_BE_BITS > 8 || CRC_BE_BITS < 1 || CRC_BE_BITS & CRC_BE_BITS-1
|
||||
# error CRC_BE_BITS must be a power of 2 between 1 and 8
|
||||
#endif
|
|
@ -1,189 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* Author: Artem Bityutskiy (Битюцкий Артём)
|
||||
*/
|
||||
|
||||
/*
|
||||
* Here we keep all the UBI debugging stuff which should normally be disabled
|
||||
* and compiled-out, but it is extremely helpful when hunting bugs or doing big
|
||||
* changes.
|
||||
*/
|
||||
#include "ubi-barebox.h"
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_MSG
|
||||
|
||||
#include "ubi.h"
|
||||
|
||||
/**
|
||||
* ubi_dbg_dump_ec_hdr - dump an erase counter header.
|
||||
* @ec_hdr: the erase counter header to dump
|
||||
*/
|
||||
void ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr)
|
||||
{
|
||||
dbg_msg("erase counter header dump:");
|
||||
dbg_msg("magic %#08x", be32_to_cpu(ec_hdr->magic));
|
||||
dbg_msg("version %d", (int)ec_hdr->version);
|
||||
dbg_msg("ec %llu", (long long)be64_to_cpu(ec_hdr->ec));
|
||||
dbg_msg("vid_hdr_offset %d", be32_to_cpu(ec_hdr->vid_hdr_offset));
|
||||
dbg_msg("data_offset %d", be32_to_cpu(ec_hdr->data_offset));
|
||||
dbg_msg("hdr_crc %#08x", be32_to_cpu(ec_hdr->hdr_crc));
|
||||
dbg_msg("erase counter header hexdump:");
|
||||
print_hex_dump(KERN_DEBUG, "", DUMP_PREFIX_OFFSET, 32, 1,
|
||||
ec_hdr, UBI_EC_HDR_SIZE, 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_dbg_dump_vid_hdr - dump a volume identifier header.
|
||||
* @vid_hdr: the volume identifier header to dump
|
||||
*/
|
||||
void ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr)
|
||||
{
|
||||
dbg_msg("volume identifier header dump:");
|
||||
dbg_msg("magic %08x", be32_to_cpu(vid_hdr->magic));
|
||||
dbg_msg("version %d", (int)vid_hdr->version);
|
||||
dbg_msg("vol_type %d", (int)vid_hdr->vol_type);
|
||||
dbg_msg("copy_flag %d", (int)vid_hdr->copy_flag);
|
||||
dbg_msg("compat %d", (int)vid_hdr->compat);
|
||||
dbg_msg("vol_id %d", be32_to_cpu(vid_hdr->vol_id));
|
||||
dbg_msg("lnum %d", be32_to_cpu(vid_hdr->lnum));
|
||||
dbg_msg("leb_ver %u", be32_to_cpu(vid_hdr->leb_ver));
|
||||
dbg_msg("data_size %d", be32_to_cpu(vid_hdr->data_size));
|
||||
dbg_msg("used_ebs %d", be32_to_cpu(vid_hdr->used_ebs));
|
||||
dbg_msg("data_pad %d", be32_to_cpu(vid_hdr->data_pad));
|
||||
dbg_msg("sqnum %llu",
|
||||
(unsigned long long)be64_to_cpu(vid_hdr->sqnum));
|
||||
dbg_msg("hdr_crc %08x", be32_to_cpu(vid_hdr->hdr_crc));
|
||||
dbg_msg("volume identifier header hexdump:");
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_dbg_dump_vol_info- dump volume information.
|
||||
* @vol: UBI volume description object
|
||||
*/
|
||||
void ubi_dbg_dump_vol_info(const struct ubi_volume *vol)
|
||||
{
|
||||
dbg_msg("volume information dump:");
|
||||
dbg_msg("vol_id %d", vol->vol_id);
|
||||
dbg_msg("reserved_pebs %d", vol->reserved_pebs);
|
||||
dbg_msg("alignment %d", vol->alignment);
|
||||
dbg_msg("data_pad %d", vol->data_pad);
|
||||
dbg_msg("vol_type %d", vol->vol_type);
|
||||
dbg_msg("name_len %d", vol->name_len);
|
||||
dbg_msg("usable_leb_size %d", vol->usable_leb_size);
|
||||
dbg_msg("used_ebs %d", vol->used_ebs);
|
||||
dbg_msg("used_bytes %lld", vol->used_bytes);
|
||||
dbg_msg("last_eb_bytes %d", vol->last_eb_bytes);
|
||||
dbg_msg("corrupted %d", vol->corrupted);
|
||||
dbg_msg("upd_marker %d", vol->upd_marker);
|
||||
|
||||
if (vol->name_len <= UBI_VOL_NAME_MAX &&
|
||||
strnlen(vol->name, vol->name_len + 1) == vol->name_len) {
|
||||
dbg_msg("name %s", vol->name);
|
||||
} else {
|
||||
dbg_msg("the 1st 5 characters of the name: %c%c%c%c%c",
|
||||
vol->name[0], vol->name[1], vol->name[2],
|
||||
vol->name[3], vol->name[4]);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_dbg_dump_vtbl_record - dump a &struct ubi_vtbl_record object.
|
||||
* @r: the object to dump
|
||||
* @idx: volume table index
|
||||
*/
|
||||
void ubi_dbg_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx)
|
||||
{
|
||||
int name_len = be16_to_cpu(r->name_len);
|
||||
|
||||
dbg_msg("volume table record %d dump:", idx);
|
||||
dbg_msg("reserved_pebs %d", be32_to_cpu(r->reserved_pebs));
|
||||
dbg_msg("alignment %d", be32_to_cpu(r->alignment));
|
||||
dbg_msg("data_pad %d", be32_to_cpu(r->data_pad));
|
||||
dbg_msg("vol_type %d", (int)r->vol_type);
|
||||
dbg_msg("upd_marker %d", (int)r->upd_marker);
|
||||
dbg_msg("name_len %d", name_len);
|
||||
|
||||
if (r->name[0] == '\0') {
|
||||
dbg_msg("name NULL");
|
||||
return;
|
||||
}
|
||||
|
||||
if (name_len <= UBI_VOL_NAME_MAX &&
|
||||
strnlen(&r->name[0], name_len + 1) == name_len) {
|
||||
dbg_msg("name %s", &r->name[0]);
|
||||
} else {
|
||||
dbg_msg("1st 5 characters of the name: %c%c%c%c%c",
|
||||
r->name[0], r->name[1], r->name[2], r->name[3],
|
||||
r->name[4]);
|
||||
}
|
||||
dbg_msg("crc %#08x", be32_to_cpu(r->crc));
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_dbg_dump_sv - dump a &struct ubi_scan_volume object.
|
||||
* @sv: the object to dump
|
||||
*/
|
||||
void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv)
|
||||
{
|
||||
dbg_msg("volume scanning information dump:");
|
||||
dbg_msg("vol_id %d", sv->vol_id);
|
||||
dbg_msg("highest_lnum %d", sv->highest_lnum);
|
||||
dbg_msg("leb_count %d", sv->leb_count);
|
||||
dbg_msg("compat %d", sv->compat);
|
||||
dbg_msg("vol_type %d", sv->vol_type);
|
||||
dbg_msg("used_ebs %d", sv->used_ebs);
|
||||
dbg_msg("last_data_size %d", sv->last_data_size);
|
||||
dbg_msg("data_pad %d", sv->data_pad);
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_dbg_dump_seb - dump a &struct ubi_scan_leb object.
|
||||
* @seb: the object to dump
|
||||
* @type: object type: 0 - not corrupted, 1 - corrupted
|
||||
*/
|
||||
void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb, int type)
|
||||
{
|
||||
dbg_msg("eraseblock scanning information dump:");
|
||||
dbg_msg("ec %d", seb->ec);
|
||||
dbg_msg("pnum %d", seb->pnum);
|
||||
if (type == 0) {
|
||||
dbg_msg("lnum %d", seb->lnum);
|
||||
dbg_msg("scrub %d", seb->scrub);
|
||||
dbg_msg("sqnum %llu", seb->sqnum);
|
||||
dbg_msg("leb_ver %u", seb->leb_ver);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_dbg_dump_mkvol_req - dump a &struct ubi_mkvol_req object.
|
||||
* @req: the object to dump
|
||||
*/
|
||||
void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req)
|
||||
{
|
||||
char nm[17];
|
||||
|
||||
dbg_msg("volume creation request dump:");
|
||||
dbg_msg("vol_id %d", req->vol_id);
|
||||
dbg_msg("alignment %d", req->alignment);
|
||||
dbg_msg("bytes %lld", (long long)req->bytes);
|
||||
dbg_msg("vol_type %d", req->vol_type);
|
||||
dbg_msg("name_len %d", req->name_len);
|
||||
|
||||
memcpy(nm, req->name, 16);
|
||||
nm[16] = 0;
|
||||
dbg_msg("the 1st 16 characters of the name: %s", nm);
|
||||
}
|
||||
|
||||
#endif /* CONFIG_MTD_UBI_DEBUG_MSG */
|
|
@ -1,149 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* Author: Artem Bityutskiy (Битюцкий Артём)
|
||||
*/
|
||||
|
||||
#ifndef __UBI_DEBUG_H__
|
||||
#define __UBI_DEBUG_H__
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG
|
||||
#ifdef UBI_LINUX
|
||||
#include <linux/random.h>
|
||||
#endif
|
||||
|
||||
#define ubi_assert(expr) BUG_ON(!(expr))
|
||||
#define dbg_err(fmt, ...) ubi_err(fmt, ##__VA_ARGS__)
|
||||
#else
|
||||
#define ubi_assert(expr) ({})
|
||||
#define dbg_err(fmt, ...) ({})
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_DISABLE_BGT
|
||||
#define DBG_DISABLE_BGT 1
|
||||
#else
|
||||
#define DBG_DISABLE_BGT 0
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_MSG
|
||||
/* Generic debugging message */
|
||||
#define dbg_msg(fmt, ...) \
|
||||
printk(KERN_DEBUG "UBI DBG: %s: " fmt "\n", \
|
||||
__FUNCTION__, ##__VA_ARGS__)
|
||||
|
||||
#define ubi_dbg_dump_stack() dump_stack()
|
||||
|
||||
struct ubi_ec_hdr;
|
||||
struct ubi_vid_hdr;
|
||||
struct ubi_volume;
|
||||
struct ubi_vtbl_record;
|
||||
struct ubi_scan_volume;
|
||||
struct ubi_scan_leb;
|
||||
struct ubi_mkvol_req;
|
||||
|
||||
void ubi_dbg_dump_ec_hdr(const struct ubi_ec_hdr *ec_hdr);
|
||||
void ubi_dbg_dump_vid_hdr(const struct ubi_vid_hdr *vid_hdr);
|
||||
void ubi_dbg_dump_vol_info(const struct ubi_volume *vol);
|
||||
void ubi_dbg_dump_vtbl_record(const struct ubi_vtbl_record *r, int idx);
|
||||
void ubi_dbg_dump_sv(const struct ubi_scan_volume *sv);
|
||||
void ubi_dbg_dump_seb(const struct ubi_scan_leb *seb, int type);
|
||||
void ubi_dbg_dump_mkvol_req(const struct ubi_mkvol_req *req);
|
||||
|
||||
#else
|
||||
|
||||
#define dbg_msg(fmt, ...) ({})
|
||||
#define ubi_dbg_dump_stack() ({})
|
||||
#define ubi_dbg_dump_ec_hdr(ec_hdr) ({})
|
||||
#define ubi_dbg_dump_vid_hdr(vid_hdr) ({})
|
||||
#define ubi_dbg_dump_vol_info(vol) ({})
|
||||
#define ubi_dbg_dump_vtbl_record(r, idx) ({})
|
||||
#define ubi_dbg_dump_sv(sv) ({})
|
||||
#define ubi_dbg_dump_seb(seb, type) ({})
|
||||
#define ubi_dbg_dump_mkvol_req(req) ({})
|
||||
|
||||
#endif /* CONFIG_MTD_UBI_DEBUG_MSG */
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_MSG_EBA
|
||||
/* Messages from the eraseblock association unit */
|
||||
#define dbg_eba(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
|
||||
#else
|
||||
#define dbg_eba(fmt, ...) ({})
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_MSG_WL
|
||||
/* Messages from the wear-leveling unit */
|
||||
#define dbg_wl(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
|
||||
#else
|
||||
#define dbg_wl(fmt, ...) ({})
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_MSG_IO
|
||||
/* Messages from the input/output unit */
|
||||
#define dbg_io(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
|
||||
#else
|
||||
#define dbg_io(fmt, ...) ({})
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_MSG_BLD
|
||||
/* Initialization and build messages */
|
||||
#define dbg_bld(fmt, ...) dbg_msg(fmt, ##__VA_ARGS__)
|
||||
#else
|
||||
#define dbg_bld(fmt, ...) ({})
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_EMULATE_BITFLIPS
|
||||
/**
|
||||
* ubi_dbg_is_bitflip - if it is time to emulate a bit-flip.
|
||||
*
|
||||
* Returns non-zero if a bit-flip should be emulated, otherwise returns zero.
|
||||
*/
|
||||
static inline int ubi_dbg_is_bitflip(void)
|
||||
{
|
||||
return !(random32() % 200);
|
||||
}
|
||||
#else
|
||||
#define ubi_dbg_is_bitflip() 0
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_EMULATE_WRITE_FAILURES
|
||||
/**
|
||||
* ubi_dbg_is_write_failure - if it is time to emulate a write failure.
|
||||
*
|
||||
* Returns non-zero if a write failure should be emulated, otherwise returns
|
||||
* zero.
|
||||
*/
|
||||
static inline int ubi_dbg_is_write_failure(void)
|
||||
{
|
||||
return !(random32() % 500);
|
||||
}
|
||||
#else
|
||||
#define ubi_dbg_is_write_failure() 0
|
||||
#endif
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_EMULATE_ERASE_FAILURES
|
||||
/**
|
||||
* ubi_dbg_is_erase_failure - if its time to emulate an erase failure.
|
||||
*
|
||||
* Returns non-zero if an erase failure should be emulated, otherwise returns
|
||||
* zero.
|
||||
*/
|
||||
static inline int ubi_dbg_is_erase_failure(void)
|
||||
{
|
||||
return !(random32() % 400);
|
||||
}
|
||||
#else
|
||||
#define ubi_dbg_is_erase_failure() 0
|
||||
#endif
|
||||
|
||||
#endif /* !__UBI_DEBUG_H__ */
|
File diff suppressed because it is too large
Load Diff
1271
drivers/mtd/ubi/io.c
1271
drivers/mtd/ubi/io.c
File diff suppressed because it is too large
Load Diff
|
@ -1,635 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* Author: Artem Bityutskiy (Битюцкий Артём)
|
||||
*/
|
||||
|
||||
/* This file mostly implements UBI kernel API functions */
|
||||
|
||||
#ifdef UBI_LINUX
|
||||
#include <linux/module.h>
|
||||
#include <linux/err.h>
|
||||
#include <asm/div64.h>
|
||||
#endif
|
||||
|
||||
#include "ubi-barebox.h"
|
||||
#include "ubi.h"
|
||||
|
||||
/**
|
||||
* ubi_get_device_info - get information about UBI device.
|
||||
* @ubi_num: UBI device number
|
||||
* @di: the information is stored here
|
||||
*
|
||||
* This function returns %0 in case of success, %-EINVAL if the UBI device
|
||||
* number is invalid, and %-ENODEV if there is no such UBI device.
|
||||
*/
|
||||
int ubi_get_device_info(int ubi_num, struct ubi_device_info *di)
|
||||
{
|
||||
struct ubi_device *ubi;
|
||||
|
||||
if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES)
|
||||
return -EINVAL;
|
||||
|
||||
ubi = ubi_get_device(ubi_num);
|
||||
if (!ubi)
|
||||
return -ENODEV;
|
||||
|
||||
di->ubi_num = ubi->ubi_num;
|
||||
di->leb_size = ubi->leb_size;
|
||||
di->min_io_size = ubi->min_io_size;
|
||||
di->ro_mode = ubi->ro_mode;
|
||||
di->cdev = &ubi->cdev;
|
||||
|
||||
ubi_put_device(ubi);
|
||||
return 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_get_device_info);
|
||||
|
||||
/**
|
||||
* ubi_get_volume_info - get information about UBI volume.
|
||||
* @desc: volume descriptor
|
||||
* @vi: the information is stored here
|
||||
*/
|
||||
void ubi_get_volume_info(struct ubi_volume_desc *desc,
|
||||
struct ubi_volume_info *vi)
|
||||
{
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
struct ubi_device *ubi = vol->ubi;
|
||||
|
||||
vi->vol_id = vol->vol_id;
|
||||
vi->ubi_num = ubi->ubi_num;
|
||||
vi->size = vol->reserved_pebs;
|
||||
vi->used_bytes = vol->used_bytes;
|
||||
vi->vol_type = vol->vol_type;
|
||||
vi->corrupted = vol->corrupted;
|
||||
vi->upd_marker = vol->upd_marker;
|
||||
vi->alignment = vol->alignment;
|
||||
vi->usable_leb_size = vol->usable_leb_size;
|
||||
vi->name_len = vol->name_len;
|
||||
vi->name = vol->name;
|
||||
vi->cdev = &vol->cdev;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_get_volume_info);
|
||||
|
||||
/**
|
||||
* ubi_open_volume - open UBI volume.
|
||||
* @ubi_num: UBI device number
|
||||
* @vol_id: volume ID
|
||||
* @mode: open mode
|
||||
*
|
||||
* The @mode parameter specifies if the volume should be opened in read-only
|
||||
* mode, read-write mode, or exclusive mode. The exclusive mode guarantees that
|
||||
* nobody else will be able to open this volume. UBI allows to have many volume
|
||||
* readers and one writer at a time.
|
||||
*
|
||||
* If a static volume is being opened for the first time since boot, it will be
|
||||
* checked by this function, which means it will be fully read and the CRC
|
||||
* checksum of each logical eraseblock will be checked.
|
||||
*
|
||||
* This function returns volume descriptor in case of success and a negative
|
||||
* error code in case of failure.
|
||||
*/
|
||||
struct ubi_volume_desc *ubi_open_volume(int ubi_num, int vol_id, int mode)
|
||||
{
|
||||
int err;
|
||||
struct ubi_volume_desc *desc;
|
||||
struct ubi_device *ubi;
|
||||
struct ubi_volume *vol;
|
||||
|
||||
dbg_msg("open device %d volume %d, mode %d", ubi_num, vol_id, mode);
|
||||
|
||||
if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES)
|
||||
return ERR_PTR(-EINVAL);
|
||||
|
||||
if (mode != UBI_READONLY && mode != UBI_READWRITE &&
|
||||
mode != UBI_EXCLUSIVE)
|
||||
return ERR_PTR(-EINVAL);
|
||||
|
||||
/*
|
||||
* First of all, we have to get the UBI device to prevent its removal.
|
||||
*/
|
||||
ubi = ubi_get_device(ubi_num);
|
||||
if (!ubi)
|
||||
return ERR_PTR(-ENODEV);
|
||||
|
||||
if (vol_id < 0 || vol_id >= ubi->vtbl_slots) {
|
||||
err = -EINVAL;
|
||||
goto out_put_ubi;
|
||||
}
|
||||
|
||||
desc = kmalloc(sizeof(struct ubi_volume_desc), GFP_KERNEL);
|
||||
if (!desc) {
|
||||
err = -ENOMEM;
|
||||
goto out_put_ubi;
|
||||
}
|
||||
|
||||
err = -ENODEV;
|
||||
if (!try_module_get(THIS_MODULE))
|
||||
goto out_free;
|
||||
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
vol = ubi->volumes[vol_id];
|
||||
if (!vol)
|
||||
goto out_unlock;
|
||||
|
||||
err = -EBUSY;
|
||||
switch (mode) {
|
||||
case UBI_READONLY:
|
||||
if (vol->exclusive)
|
||||
goto out_unlock;
|
||||
vol->readers += 1;
|
||||
break;
|
||||
|
||||
case UBI_READWRITE:
|
||||
if (vol->exclusive || vol->writers > 0)
|
||||
goto out_unlock;
|
||||
vol->writers += 1;
|
||||
break;
|
||||
|
||||
case UBI_EXCLUSIVE:
|
||||
if (vol->exclusive || vol->writers || vol->readers)
|
||||
goto out_unlock;
|
||||
vol->exclusive = 1;
|
||||
break;
|
||||
}
|
||||
get_device(&vol->dev);
|
||||
vol->ref_count += 1;
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
|
||||
desc->vol = vol;
|
||||
desc->mode = mode;
|
||||
|
||||
mutex_lock(&ubi->ckvol_mutex);
|
||||
if (!vol->checked) {
|
||||
/* This is the first open - check the volume */
|
||||
err = ubi_check_volume(ubi, vol_id);
|
||||
if (err < 0) {
|
||||
mutex_unlock(&ubi->ckvol_mutex);
|
||||
ubi_close_volume(desc);
|
||||
return ERR_PTR(err);
|
||||
}
|
||||
if (err == 1) {
|
||||
ubi_warn("volume %d on UBI device %d is corrupted",
|
||||
vol_id, ubi->ubi_num);
|
||||
vol->corrupted = 1;
|
||||
}
|
||||
vol->checked = 1;
|
||||
}
|
||||
mutex_unlock(&ubi->ckvol_mutex);
|
||||
|
||||
return desc;
|
||||
|
||||
out_unlock:
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
module_put(THIS_MODULE);
|
||||
out_free:
|
||||
kfree(desc);
|
||||
out_put_ubi:
|
||||
ubi_put_device(ubi);
|
||||
return ERR_PTR(err);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_open_volume);
|
||||
|
||||
/**
|
||||
* ubi_open_volume_nm - open UBI volume by name.
|
||||
* @ubi_num: UBI device number
|
||||
* @name: volume name
|
||||
* @mode: open mode
|
||||
*
|
||||
* This function is similar to 'ubi_open_volume()', but opens a volume by name.
|
||||
*/
|
||||
struct ubi_volume_desc *ubi_open_volume_nm(int ubi_num, const char *name,
|
||||
int mode)
|
||||
{
|
||||
int i, vol_id = -1, len;
|
||||
struct ubi_device *ubi;
|
||||
struct ubi_volume_desc *ret;
|
||||
|
||||
dbg_msg("open volume %s, mode %d", name, mode);
|
||||
|
||||
if (!name)
|
||||
return ERR_PTR(-EINVAL);
|
||||
|
||||
len = strnlen(name, UBI_VOL_NAME_MAX + 1);
|
||||
if (len > UBI_VOL_NAME_MAX)
|
||||
return ERR_PTR(-EINVAL);
|
||||
|
||||
if (ubi_num < 0 || ubi_num >= UBI_MAX_DEVICES)
|
||||
return ERR_PTR(-EINVAL);
|
||||
|
||||
ubi = ubi_get_device(ubi_num);
|
||||
if (!ubi)
|
||||
return ERR_PTR(-ENODEV);
|
||||
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
/* Walk all volumes of this UBI device */
|
||||
for (i = 0; i < ubi->vtbl_slots; i++) {
|
||||
struct ubi_volume *vol = ubi->volumes[i];
|
||||
|
||||
if (vol && len == vol->name_len && !strcmp(name, vol->name)) {
|
||||
vol_id = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
|
||||
if (vol_id >= 0)
|
||||
ret = ubi_open_volume(ubi_num, vol_id, mode);
|
||||
else
|
||||
ret = ERR_PTR(-ENODEV);
|
||||
|
||||
/*
|
||||
* We should put the UBI device even in case of success, because
|
||||
* 'ubi_open_volume()' took a reference as well.
|
||||
*/
|
||||
ubi_put_device(ubi);
|
||||
return ret;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_open_volume_nm);
|
||||
|
||||
/**
|
||||
* ubi_close_volume - close UBI volume.
|
||||
* @desc: volume descriptor
|
||||
*/
|
||||
void ubi_close_volume(struct ubi_volume_desc *desc)
|
||||
{
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
struct ubi_device *ubi = vol->ubi;
|
||||
|
||||
dbg_msg("close volume %d, mode %d", vol->vol_id, desc->mode);
|
||||
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
switch (desc->mode) {
|
||||
case UBI_READONLY:
|
||||
vol->readers -= 1;
|
||||
break;
|
||||
case UBI_READWRITE:
|
||||
vol->writers -= 1;
|
||||
break;
|
||||
case UBI_EXCLUSIVE:
|
||||
vol->exclusive = 0;
|
||||
}
|
||||
vol->ref_count -= 1;
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
|
||||
kfree(desc);
|
||||
put_device(&vol->dev);
|
||||
ubi_put_device(ubi);
|
||||
module_put(THIS_MODULE);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_close_volume);
|
||||
|
||||
/**
|
||||
* ubi_leb_read - read data.
|
||||
* @desc: volume descriptor
|
||||
* @lnum: logical eraseblock number to read from
|
||||
* @buf: buffer where to store the read data
|
||||
* @offset: offset within the logical eraseblock to read from
|
||||
* @len: how many bytes to read
|
||||
* @check: whether UBI has to check the read data's CRC or not.
|
||||
*
|
||||
* This function reads data from offset @offset of logical eraseblock @lnum and
|
||||
* stores the data at @buf. When reading from static volumes, @check specifies
|
||||
* whether the data has to be checked or not. If yes, the whole logical
|
||||
* eraseblock will be read and its CRC checksum will be checked (i.e., the CRC
|
||||
* checksum is per-eraseblock). So checking may substantially slow down the
|
||||
* read speed. The @check argument is ignored for dynamic volumes.
|
||||
*
|
||||
* In case of success, this function returns zero. In case of failure, this
|
||||
* function returns a negative error code.
|
||||
*
|
||||
* %-EBADMSG error code is returned:
|
||||
* o for both static and dynamic volumes if MTD driver has detected a data
|
||||
* integrity problem (unrecoverable ECC checksum mismatch in case of NAND);
|
||||
* o for static volumes in case of data CRC mismatch.
|
||||
*
|
||||
* If the volume is damaged because of an interrupted update this function just
|
||||
* returns immediately with %-EBADF error code.
|
||||
*/
|
||||
int ubi_leb_read(struct ubi_volume_desc *desc, int lnum, char *buf, int offset,
|
||||
int len, int check)
|
||||
{
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
struct ubi_device *ubi = vol->ubi;
|
||||
int err, vol_id = vol->vol_id;
|
||||
|
||||
dbg_msg("read %d bytes from LEB %d:%d:%d", len, vol_id, lnum, offset);
|
||||
|
||||
if (vol_id < 0 || vol_id >= ubi->vtbl_slots || lnum < 0 ||
|
||||
lnum >= vol->used_ebs || offset < 0 || len < 0 ||
|
||||
offset + len > vol->usable_leb_size)
|
||||
return -EINVAL;
|
||||
|
||||
if (vol->vol_type == UBI_STATIC_VOLUME) {
|
||||
if (vol->used_ebs == 0)
|
||||
/* Empty static UBI volume */
|
||||
return 0;
|
||||
if (lnum == vol->used_ebs - 1 &&
|
||||
offset + len > vol->last_eb_bytes)
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (vol->upd_marker)
|
||||
return -EBADF;
|
||||
if (len == 0)
|
||||
return 0;
|
||||
|
||||
err = ubi_eba_read_leb(ubi, vol, lnum, buf, offset, len, check);
|
||||
if (err && err == -EBADMSG && vol->vol_type == UBI_STATIC_VOLUME) {
|
||||
ubi_warn("mark volume %d as corrupted", vol_id);
|
||||
vol->corrupted = 1;
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_leb_read);
|
||||
|
||||
/**
|
||||
* ubi_leb_write - write data.
|
||||
* @desc: volume descriptor
|
||||
* @lnum: logical eraseblock number to write to
|
||||
* @buf: data to write
|
||||
* @offset: offset within the logical eraseblock where to write
|
||||
* @len: how many bytes to write
|
||||
* @dtype: expected data type
|
||||
*
|
||||
* This function writes @len bytes of data from @buf to offset @offset of
|
||||
* logical eraseblock @lnum. The @dtype argument describes expected lifetime of
|
||||
* the data.
|
||||
*
|
||||
* This function takes care of physical eraseblock write failures. If write to
|
||||
* the physical eraseblock write operation fails, the logical eraseblock is
|
||||
* re-mapped to another physical eraseblock, the data is recovered, and the
|
||||
* write finishes. UBI has a pool of reserved physical eraseblocks for this.
|
||||
*
|
||||
* If all the data were successfully written, zero is returned. If an error
|
||||
* occurred and UBI has not been able to recover from it, this function returns
|
||||
* a negative error code. Note, in case of an error, it is possible that
|
||||
* something was still written to the flash media, but that may be some
|
||||
* garbage.
|
||||
*
|
||||
* If the volume is damaged because of an interrupted update this function just
|
||||
* returns immediately with %-EBADF code.
|
||||
*/
|
||||
int ubi_leb_write(struct ubi_volume_desc *desc, int lnum, const void *buf,
|
||||
int offset, int len, int dtype)
|
||||
{
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
struct ubi_device *ubi = vol->ubi;
|
||||
int vol_id = vol->vol_id;
|
||||
|
||||
dbg_msg("write %d bytes to LEB %d:%d:%d", len, vol_id, lnum, offset);
|
||||
|
||||
if (vol_id < 0 || vol_id >= ubi->vtbl_slots)
|
||||
return -EINVAL;
|
||||
|
||||
if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME)
|
||||
return -EROFS;
|
||||
|
||||
if (lnum < 0 || lnum >= vol->reserved_pebs || offset < 0 || len < 0 ||
|
||||
offset + len > vol->usable_leb_size ||
|
||||
offset & (ubi->min_io_size - 1) || len & (ubi->min_io_size - 1))
|
||||
return -EINVAL;
|
||||
|
||||
if (dtype != UBI_LONGTERM && dtype != UBI_SHORTTERM &&
|
||||
dtype != UBI_UNKNOWN)
|
||||
return -EINVAL;
|
||||
|
||||
if (vol->upd_marker)
|
||||
return -EBADF;
|
||||
|
||||
if (len == 0)
|
||||
return 0;
|
||||
|
||||
return ubi_eba_write_leb(ubi, vol, lnum, buf, offset, len, dtype);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_leb_write);
|
||||
|
||||
/*
|
||||
* ubi_leb_change - change logical eraseblock atomically.
|
||||
* @desc: volume descriptor
|
||||
* @lnum: logical eraseblock number to change
|
||||
* @buf: data to write
|
||||
* @len: how many bytes to write
|
||||
* @dtype: expected data type
|
||||
*
|
||||
* This function changes the contents of a logical eraseblock atomically. @buf
|
||||
* has to contain new logical eraseblock data, and @len - the length of the
|
||||
* data, which has to be aligned. The length may be shorter then the logical
|
||||
* eraseblock size, ant the logical eraseblock may be appended to more times
|
||||
* later on. This function guarantees that in case of an unclean reboot the old
|
||||
* contents is preserved. Returns zero in case of success and a negative error
|
||||
* code in case of failure.
|
||||
*/
|
||||
int ubi_leb_change(struct ubi_volume_desc *desc, int lnum, const void *buf,
|
||||
int len, int dtype)
|
||||
{
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
struct ubi_device *ubi = vol->ubi;
|
||||
int vol_id = vol->vol_id;
|
||||
|
||||
dbg_msg("atomically write %d bytes to LEB %d:%d", len, vol_id, lnum);
|
||||
|
||||
if (vol_id < 0 || vol_id >= ubi->vtbl_slots)
|
||||
return -EINVAL;
|
||||
|
||||
if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME)
|
||||
return -EROFS;
|
||||
|
||||
if (lnum < 0 || lnum >= vol->reserved_pebs || len < 0 ||
|
||||
len > vol->usable_leb_size || len & (ubi->min_io_size - 1))
|
||||
return -EINVAL;
|
||||
|
||||
if (dtype != UBI_LONGTERM && dtype != UBI_SHORTTERM &&
|
||||
dtype != UBI_UNKNOWN)
|
||||
return -EINVAL;
|
||||
|
||||
if (vol->upd_marker)
|
||||
return -EBADF;
|
||||
|
||||
if (len == 0)
|
||||
return 0;
|
||||
|
||||
return ubi_eba_atomic_leb_change(ubi, vol, lnum, buf, len, dtype);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_leb_change);
|
||||
|
||||
/**
|
||||
* ubi_leb_erase - erase logical eraseblock.
|
||||
* @desc: volume descriptor
|
||||
* @lnum: logical eraseblock number
|
||||
*
|
||||
* This function un-maps logical eraseblock @lnum and synchronously erases the
|
||||
* correspondent physical eraseblock. Returns zero in case of success and a
|
||||
* negative error code in case of failure.
|
||||
*
|
||||
* If the volume is damaged because of an interrupted update this function just
|
||||
* returns immediately with %-EBADF code.
|
||||
*/
|
||||
int ubi_leb_erase(struct ubi_volume_desc *desc, int lnum)
|
||||
{
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
struct ubi_device *ubi = vol->ubi;
|
||||
int err;
|
||||
|
||||
dbg_msg("erase LEB %d:%d", vol->vol_id, lnum);
|
||||
|
||||
if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME)
|
||||
return -EROFS;
|
||||
|
||||
if (lnum < 0 || lnum >= vol->reserved_pebs)
|
||||
return -EINVAL;
|
||||
|
||||
if (vol->upd_marker)
|
||||
return -EBADF;
|
||||
|
||||
err = ubi_eba_unmap_leb(ubi, vol, lnum);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
return ubi_wl_flush(ubi);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_leb_erase);
|
||||
|
||||
/**
|
||||
* ubi_leb_unmap - un-map logical eraseblock.
|
||||
* @desc: volume descriptor
|
||||
* @lnum: logical eraseblock number
|
||||
*
|
||||
* This function un-maps logical eraseblock @lnum and schedules the
|
||||
* corresponding physical eraseblock for erasure, so that it will eventually be
|
||||
* physically erased in background. This operation is much faster then the
|
||||
* erase operation.
|
||||
*
|
||||
* Unlike erase, the un-map operation does not guarantee that the logical
|
||||
* eraseblock will contain all 0xFF bytes when UBI is initialized again. For
|
||||
* example, if several logical eraseblocks are un-mapped, and an unclean reboot
|
||||
* happens after this, the logical eraseblocks will not necessarily be
|
||||
* un-mapped again when this MTD device is attached. They may actually be
|
||||
* mapped to the same physical eraseblocks again. So, this function has to be
|
||||
* used with care.
|
||||
*
|
||||
* In other words, when un-mapping a logical eraseblock, UBI does not store
|
||||
* any information about this on the flash media, it just marks the logical
|
||||
* eraseblock as "un-mapped" in RAM. If UBI is detached before the physical
|
||||
* eraseblock is physically erased, it will be mapped again to the same logical
|
||||
* eraseblock when the MTD device is attached again.
|
||||
*
|
||||
* The main and obvious use-case of this function is when the contents of a
|
||||
* logical eraseblock has to be re-written. Then it is much more efficient to
|
||||
* first un-map it, then write new data, rather then first erase it, then write
|
||||
* new data. Note, once new data has been written to the logical eraseblock,
|
||||
* UBI guarantees that the old contents has gone forever. In other words, if an
|
||||
* unclean reboot happens after the logical eraseblock has been un-mapped and
|
||||
* then written to, it will contain the last written data.
|
||||
*
|
||||
* This function returns zero in case of success and a negative error code in
|
||||
* case of failure. If the volume is damaged because of an interrupted update
|
||||
* this function just returns immediately with %-EBADF code.
|
||||
*/
|
||||
int ubi_leb_unmap(struct ubi_volume_desc *desc, int lnum)
|
||||
{
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
struct ubi_device *ubi = vol->ubi;
|
||||
|
||||
dbg_msg("unmap LEB %d:%d", vol->vol_id, lnum);
|
||||
|
||||
if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME)
|
||||
return -EROFS;
|
||||
|
||||
if (lnum < 0 || lnum >= vol->reserved_pebs)
|
||||
return -EINVAL;
|
||||
|
||||
if (vol->upd_marker)
|
||||
return -EBADF;
|
||||
|
||||
return ubi_eba_unmap_leb(ubi, vol, lnum);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_leb_unmap);
|
||||
|
||||
/**
|
||||
* ubi_leb_map - map logical erasblock to a physical eraseblock.
|
||||
* @desc: volume descriptor
|
||||
* @lnum: logical eraseblock number
|
||||
* @dtype: expected data type
|
||||
*
|
||||
* This function maps an un-mapped logical eraseblock @lnum to a physical
|
||||
* eraseblock. This means, that after a successfull invocation of this
|
||||
* function the logical eraseblock @lnum will be empty (contain only %0xFF
|
||||
* bytes) and be mapped to a physical eraseblock, even if an unclean reboot
|
||||
* happens.
|
||||
*
|
||||
* This function returns zero in case of success, %-EBADF if the volume is
|
||||
* damaged because of an interrupted update, %-EBADMSG if the logical
|
||||
* eraseblock is already mapped, and other negative error codes in case of
|
||||
* other failures.
|
||||
*/
|
||||
int ubi_leb_map(struct ubi_volume_desc *desc, int lnum, int dtype)
|
||||
{
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
struct ubi_device *ubi = vol->ubi;
|
||||
|
||||
dbg_msg("unmap LEB %d:%d", vol->vol_id, lnum);
|
||||
|
||||
if (desc->mode == UBI_READONLY || vol->vol_type == UBI_STATIC_VOLUME)
|
||||
return -EROFS;
|
||||
|
||||
if (lnum < 0 || lnum >= vol->reserved_pebs)
|
||||
return -EINVAL;
|
||||
|
||||
if (dtype != UBI_LONGTERM && dtype != UBI_SHORTTERM &&
|
||||
dtype != UBI_UNKNOWN)
|
||||
return -EINVAL;
|
||||
|
||||
if (vol->upd_marker)
|
||||
return -EBADF;
|
||||
|
||||
if (vol->eba_tbl[lnum] >= 0)
|
||||
return -EBADMSG;
|
||||
|
||||
return ubi_eba_write_leb(ubi, vol, lnum, NULL, 0, 0, dtype);
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_leb_map);
|
||||
|
||||
/**
|
||||
* ubi_is_mapped - check if logical eraseblock is mapped.
|
||||
* @desc: volume descriptor
|
||||
* @lnum: logical eraseblock number
|
||||
*
|
||||
* This function checks if logical eraseblock @lnum is mapped to a physical
|
||||
* eraseblock. If a logical eraseblock is un-mapped, this does not necessarily
|
||||
* mean it will still be un-mapped after the UBI device is re-attached. The
|
||||
* logical eraseblock may become mapped to the physical eraseblock it was last
|
||||
* mapped to.
|
||||
*
|
||||
* This function returns %1 if the LEB is mapped, %0 if not, and a negative
|
||||
* error code in case of failure. If the volume is damaged because of an
|
||||
* interrupted update this function just returns immediately with %-EBADF error
|
||||
* code.
|
||||
*/
|
||||
int ubi_is_mapped(struct ubi_volume_desc *desc, int lnum)
|
||||
{
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
|
||||
dbg_msg("test LEB %d:%d", vol->vol_id, lnum);
|
||||
|
||||
if (lnum < 0 || lnum >= vol->reserved_pebs)
|
||||
return -EINVAL;
|
||||
|
||||
if (vol->upd_marker)
|
||||
return -EBADF;
|
||||
|
||||
return vol->eba_tbl[lnum] >= 0;
|
||||
}
|
||||
EXPORT_SYMBOL_GPL(ubi_is_mapped);
|
|
@ -1,103 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* Author: Artem Bityutskiy (Битюцкий Артём)
|
||||
*/
|
||||
|
||||
/* Here we keep miscellaneous functions which are used all over the UBI code */
|
||||
|
||||
#include "ubi-barebox.h"
|
||||
#include "ubi.h"
|
||||
|
||||
/**
|
||||
* calc_data_len - calculate how much real data is stored in a buffer.
|
||||
* @ubi: UBI device description object
|
||||
* @buf: a buffer with the contents of the physical eraseblock
|
||||
* @length: the buffer length
|
||||
*
|
||||
* This function calculates how much "real data" is stored in @buf and returnes
|
||||
* the length. Continuous 0xFF bytes at the end of the buffer are not
|
||||
* considered as "real data".
|
||||
*/
|
||||
int ubi_calc_data_len(const struct ubi_device *ubi, const void *buf,
|
||||
int length)
|
||||
{
|
||||
int i;
|
||||
|
||||
ubi_assert(!(length & (ubi->min_io_size - 1)));
|
||||
|
||||
for (i = length - 1; i >= 0; i--)
|
||||
if (((const uint8_t *)buf)[i] != 0xFF)
|
||||
break;
|
||||
|
||||
/* The resulting length must be aligned to the minimum flash I/O size */
|
||||
length = ALIGN(i + 1, ubi->min_io_size);
|
||||
return length;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_check_volume - check the contents of a static volume.
|
||||
* @ubi: UBI device description object
|
||||
* @vol_id: ID of the volume to check
|
||||
*
|
||||
* This function checks if static volume @vol_id is corrupted by fully reading
|
||||
* it and checking data CRC. This function returns %0 if the volume is not
|
||||
* corrupted, %1 if it is corrupted and a negative error code in case of
|
||||
* failure. Dynamic volumes are not checked and zero is returned immediately.
|
||||
*/
|
||||
int ubi_check_volume(struct ubi_device *ubi, int vol_id)
|
||||
{
|
||||
void *buf;
|
||||
int err = 0, i;
|
||||
struct ubi_volume *vol = ubi->volumes[vol_id];
|
||||
|
||||
if (vol->vol_type != UBI_STATIC_VOLUME)
|
||||
return 0;
|
||||
|
||||
buf = vmalloc(vol->usable_leb_size);
|
||||
if (!buf)
|
||||
return -ENOMEM;
|
||||
|
||||
for (i = 0; i < vol->used_ebs; i++) {
|
||||
int size;
|
||||
|
||||
if (i == vol->used_ebs - 1)
|
||||
size = vol->last_eb_bytes;
|
||||
else
|
||||
size = vol->usable_leb_size;
|
||||
|
||||
err = ubi_eba_read_leb(ubi, vol, i, buf, 0, size, 1);
|
||||
if (err) {
|
||||
if (err == -EBADMSG)
|
||||
err = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
vfree(buf);
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_calculate_rsvd_pool - calculate how many PEBs must be reserved for bad
|
||||
* eraseblock handling.
|
||||
* @ubi: UBI device description object
|
||||
*/
|
||||
void ubi_calculate_reserved(struct ubi_device *ubi)
|
||||
{
|
||||
ubi->beb_rsvd_level = ubi->good_peb_count/100;
|
||||
ubi->beb_rsvd_level *= CONFIG_MTD_UBI_BEB_RESERVE;
|
||||
if (ubi->beb_rsvd_level < MIN_RESEVED_PEBS)
|
||||
ubi->beb_rsvd_level = MIN_RESEVED_PEBS;
|
||||
}
|
File diff suppressed because it is too large
Load Diff
|
@ -1,162 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* Author: Artem Bityutskiy (Битюцкий Артём)
|
||||
*/
|
||||
|
||||
#ifndef __UBI_SCAN_H__
|
||||
#define __UBI_SCAN_H__
|
||||
|
||||
/* The erase counter value for this physical eraseblock is unknown */
|
||||
#define UBI_SCAN_UNKNOWN_EC (-1)
|
||||
|
||||
/**
|
||||
* struct ubi_scan_leb - scanning information about a physical eraseblock.
|
||||
* @ec: erase counter (%UBI_SCAN_UNKNOWN_EC if it is unknown)
|
||||
* @pnum: physical eraseblock number
|
||||
* @lnum: logical eraseblock number
|
||||
* @scrub: if this physical eraseblock needs scrubbing
|
||||
* @sqnum: sequence number
|
||||
* @u: unions RB-tree or @list links
|
||||
* @u.rb: link in the per-volume RB-tree of &struct ubi_scan_leb objects
|
||||
* @u.list: link in one of the eraseblock lists
|
||||
* @leb_ver: logical eraseblock version (obsolete)
|
||||
*
|
||||
* One object of this type is allocated for each physical eraseblock during
|
||||
* scanning.
|
||||
*/
|
||||
struct ubi_scan_leb {
|
||||
int ec;
|
||||
int pnum;
|
||||
int lnum;
|
||||
int scrub;
|
||||
unsigned long long sqnum;
|
||||
union {
|
||||
struct rb_node rb;
|
||||
struct list_head list;
|
||||
} u;
|
||||
uint32_t leb_ver;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ubi_scan_volume - scanning information about a volume.
|
||||
* @vol_id: volume ID
|
||||
* @highest_lnum: highest logical eraseblock number in this volume
|
||||
* @leb_count: number of logical eraseblocks in this volume
|
||||
* @vol_type: volume type
|
||||
* @used_ebs: number of used logical eraseblocks in this volume (only for
|
||||
* static volumes)
|
||||
* @last_data_size: amount of data in the last logical eraseblock of this
|
||||
* volume (always equivalent to the usable logical eraseblock size in case of
|
||||
* dynamic volumes)
|
||||
* @data_pad: how many bytes at the end of logical eraseblocks of this volume
|
||||
* are not used (due to volume alignment)
|
||||
* @compat: compatibility flags of this volume
|
||||
* @rb: link in the volume RB-tree
|
||||
* @root: root of the RB-tree containing all the eraseblock belonging to this
|
||||
* volume (&struct ubi_scan_leb objects)
|
||||
*
|
||||
* One object of this type is allocated for each volume during scanning.
|
||||
*/
|
||||
struct ubi_scan_volume {
|
||||
int vol_id;
|
||||
int highest_lnum;
|
||||
int leb_count;
|
||||
int vol_type;
|
||||
int used_ebs;
|
||||
int last_data_size;
|
||||
int data_pad;
|
||||
int compat;
|
||||
struct rb_node rb;
|
||||
struct rb_root root;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ubi_scan_info - UBI scanning information.
|
||||
* @volumes: root of the volume RB-tree
|
||||
* @corr: list of corrupted physical eraseblocks
|
||||
* @free: list of free physical eraseblocks
|
||||
* @erase: list of physical eraseblocks which have to be erased
|
||||
* @alien: list of physical eraseblocks which should not be used by UBI (e.g.,
|
||||
* @bad_peb_count: count of bad physical eraseblocks
|
||||
* those belonging to "preserve"-compatible internal volumes)
|
||||
* @vols_found: number of volumes found during scanning
|
||||
* @highest_vol_id: highest volume ID
|
||||
* @alien_peb_count: count of physical eraseblocks in the @alien list
|
||||
* @is_empty: flag indicating whether the MTD device is empty or not
|
||||
* @min_ec: lowest erase counter value
|
||||
* @max_ec: highest erase counter value
|
||||
* @max_sqnum: highest sequence number value
|
||||
* @mean_ec: mean erase counter value
|
||||
* @ec_sum: a temporary variable used when calculating @mean_ec
|
||||
* @ec_count: a temporary variable used when calculating @mean_ec
|
||||
*
|
||||
* This data structure contains the result of scanning and may be used by other
|
||||
* UBI units to build final UBI data structures, further error-recovery and so
|
||||
* on.
|
||||
*/
|
||||
struct ubi_scan_info {
|
||||
struct rb_root volumes;
|
||||
struct list_head corr;
|
||||
struct list_head free;
|
||||
struct list_head erase;
|
||||
struct list_head alien;
|
||||
int bad_peb_count;
|
||||
int vols_found;
|
||||
int highest_vol_id;
|
||||
int alien_peb_count;
|
||||
int is_empty;
|
||||
int min_ec;
|
||||
int max_ec;
|
||||
unsigned long long max_sqnum;
|
||||
int mean_ec;
|
||||
uint64_t ec_sum;
|
||||
int ec_count;
|
||||
};
|
||||
|
||||
struct ubi_device;
|
||||
struct ubi_vid_hdr;
|
||||
|
||||
/*
|
||||
* ubi_scan_move_to_list - move a physical eraseblock from the volume tree to a
|
||||
* list.
|
||||
*
|
||||
* @sv: volume scanning information
|
||||
* @seb: scanning eraseblock infprmation
|
||||
* @list: the list to move to
|
||||
*/
|
||||
static inline void ubi_scan_move_to_list(struct ubi_scan_volume *sv,
|
||||
struct ubi_scan_leb *seb,
|
||||
struct list_head *list)
|
||||
{
|
||||
rb_erase(&seb->u.rb, &sv->root);
|
||||
list_add_tail(&seb->u.list, list);
|
||||
}
|
||||
|
||||
int ubi_scan_add_used(struct ubi_device *ubi, struct ubi_scan_info *si,
|
||||
int pnum, int ec, const struct ubi_vid_hdr *vid_hdr,
|
||||
int bitflips);
|
||||
struct ubi_scan_volume *ubi_scan_find_sv(const struct ubi_scan_info *si,
|
||||
int vol_id);
|
||||
struct ubi_scan_leb *ubi_scan_find_seb(const struct ubi_scan_volume *sv,
|
||||
int lnum);
|
||||
void ubi_scan_rm_volume(struct ubi_scan_info *si, struct ubi_scan_volume *sv);
|
||||
struct ubi_scan_leb *ubi_scan_get_free_peb(struct ubi_device *ubi,
|
||||
struct ubi_scan_info *si);
|
||||
int ubi_scan_erase_peb(struct ubi_device *ubi, const struct ubi_scan_info *si,
|
||||
int pnum, int ec);
|
||||
struct ubi_scan_info *ubi_scan(struct ubi_device *ubi);
|
||||
void ubi_scan_destroy_si(struct ubi_scan_info *si);
|
||||
|
||||
#endif /* !__UBI_SCAN_H__ */
|
|
@ -1,186 +0,0 @@
|
|||
/*
|
||||
* Header file for UBI support for U-Boot
|
||||
*
|
||||
* Adaptation from kernel to U-Boot
|
||||
*
|
||||
* Copyright (C) 2005-2007 Samsung Electronics
|
||||
* Kyungmin Park <kyungmin.park@samsung.com>
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License version 2 as
|
||||
* published by the Free Software Foundation.
|
||||
*/
|
||||
|
||||
#ifndef __UBOOT_UBI_H
|
||||
#define __UBOOT_UBI_H
|
||||
|
||||
#include <common.h>
|
||||
#include <malloc.h>
|
||||
#include <asm-generic/div64.h>
|
||||
#include <errno.h>
|
||||
#include <linux/err.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/rbtree.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/mtd/mtd.h>
|
||||
#include <linux/mtd/ubi.h>
|
||||
#include <linux/log2.h>
|
||||
|
||||
#define crc32(seed, data, length) crc32_no_comp(seed, (unsigned char const *)data, length)
|
||||
|
||||
#define DPRINTK(format, args...) \
|
||||
do { \
|
||||
printf("%s[%d]: " format "\n", __func__, __LINE__, ##args); \
|
||||
} while (0)
|
||||
|
||||
/* configurable */
|
||||
#define CONFIG_MTD_UBI_WL_THRESHOLD 4096
|
||||
#define CONFIG_MTD_UBI_BEB_RESERVE 1
|
||||
#define UBI_IO_DEBUG 0
|
||||
|
||||
/* debug options (Linux: drivers/mtd/ubi/Kconfig.debug) */
|
||||
#undef CONFIG_MTD_UBI_DEBUG
|
||||
#undef CONFIG_MTD_UBI_DEBUG_PARANOID
|
||||
#undef CONFIG_MTD_UBI_DEBUG_MSG
|
||||
#undef CONFIG_MTD_UBI_DEBUG_MSG_EBA
|
||||
#undef CONFIG_MTD_UBI_DEBUG_MSG_WL
|
||||
#undef CONFIG_MTD_UBI_DEBUG_MSG_IO
|
||||
#undef CONFIG_MTD_UBI_DEBUG_MSG_BLD
|
||||
#define CONFIG_MTD_UBI_DEBUG_DISABLE_BGT
|
||||
|
||||
/* build.c */
|
||||
#define get_device(...)
|
||||
#define put_device(...)
|
||||
#define ubi_sysfs_init(...) 0
|
||||
#define ubi_sysfs_close(...) do { } while (0)
|
||||
|
||||
/* FIXME */
|
||||
#define MKDEV(...) 0
|
||||
#define MAJOR(dev) 0
|
||||
#define MINOR(dev) 0
|
||||
|
||||
#define alloc_chrdev_region(...) 0
|
||||
#define unregister_chrdev_region(...)
|
||||
|
||||
#define class_create(...) __builtin_return_address(0)
|
||||
#define class_create_file(...) 0
|
||||
#define class_remove_file(...)
|
||||
#define class_destroy(...)
|
||||
#define misc_register(...) 0
|
||||
#define misc_deregister(...)
|
||||
|
||||
/* vmt.c */
|
||||
#define device_register(...) 0
|
||||
#define volume_sysfs_init(...) 0
|
||||
#define volume_sysfs_close(...) do { } while (0)
|
||||
|
||||
/* kapi.c */
|
||||
|
||||
/* eba.c */
|
||||
|
||||
/* io.c */
|
||||
#define init_waitqueue_head(...) do { } while (0)
|
||||
#define wait_event_interruptible(...) 0
|
||||
#define wake_up_interruptible(...) do { } while (0)
|
||||
#define print_hex_dump(...) do { } while (0)
|
||||
#define dump_stack(...) do { } while (0)
|
||||
|
||||
/* wl.c */
|
||||
#define task_pid_nr(x) 0
|
||||
#define set_freezable(...) do { } while (0)
|
||||
#define try_to_freeze(...) 0
|
||||
#define set_current_state(...) do { } while (0)
|
||||
#define kthread_should_stop(...) 0
|
||||
#define schedule() do { } while (0)
|
||||
|
||||
/* upd.c */
|
||||
static inline unsigned long copy_from_user(void *dest, const void *src,
|
||||
unsigned long count)
|
||||
{
|
||||
memcpy((void *)dest, (void *)src, count);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* common */
|
||||
typedef int spinlock_t;
|
||||
typedef int wait_queue_head_t;
|
||||
#define spin_lock_init(...)
|
||||
#define spin_lock(...)
|
||||
#define spin_unlock(...)
|
||||
|
||||
#define mutex_init(...)
|
||||
#define mutex_lock(...)
|
||||
#define mutex_unlock(...)
|
||||
|
||||
#define init_rwsem(...) do { } while (0)
|
||||
#define down_read(...) do { } while (0)
|
||||
#define down_write(...) do { } while (0)
|
||||
#define down_write_trylock(...) 1
|
||||
#define up_read(...) do { } while (0)
|
||||
#define up_write(...) do { } while (0)
|
||||
|
||||
struct kmem_cache { int i; };
|
||||
#define kmem_cache_create(...) 1
|
||||
#define kmem_cache_alloc(obj, gfp) malloc(sizeof(struct ubi_wl_entry))
|
||||
#define kmem_cache_free(obj, size) free(size)
|
||||
#define kmem_cache_destroy(...)
|
||||
|
||||
#define cond_resched() do { } while (0)
|
||||
#define yield() do { } while (0)
|
||||
|
||||
#define GFP_KERNEL 0
|
||||
#define GFP_NOFS 1
|
||||
|
||||
#define __init
|
||||
#define __exit
|
||||
|
||||
#define kthread_create(...) __builtin_return_address(0)
|
||||
#define kthread_stop(...) do { } while (0)
|
||||
#define wake_up_process(...) do { } while (0)
|
||||
|
||||
#define BUS_ID_SIZE 20
|
||||
|
||||
struct rw_semaphore { int i; };
|
||||
struct device {
|
||||
struct device *parent;
|
||||
struct class *class;
|
||||
char bus_id[BUS_ID_SIZE]; /* position on parent bus */
|
||||
dev_t devt; /* dev_t, creates the sysfs "dev" */
|
||||
void (*release)(struct device *dev);
|
||||
};
|
||||
struct mutex { int i; };
|
||||
struct kernel_param { int i; };
|
||||
|
||||
struct cdev_ {
|
||||
int owner;
|
||||
dev_t dev;
|
||||
};
|
||||
#define cdev_init(...) do { } while (0)
|
||||
#define cdev_add(...) 0
|
||||
#define cdev_del(...) do { } while (0)
|
||||
|
||||
#define MAX_ERRNO 4095
|
||||
|
||||
/* module */
|
||||
#define THIS_MODULE 0
|
||||
#define try_module_get(...) 1
|
||||
#define module_put(...) do { } while (0)
|
||||
#define module_init(...)
|
||||
#define module_exit(...)
|
||||
#define module_param_call(...)
|
||||
#define MODULE_PARM_DESC(...)
|
||||
#define MODULE_VERSION(...)
|
||||
|
||||
#ifndef __UBIFS_H__
|
||||
#include "ubi.h"
|
||||
#endif
|
||||
|
||||
/* functions */
|
||||
extern int ubi_mtd_param_parse(const char *val, struct kernel_param *kp);
|
||||
extern int ubi_init(void);
|
||||
extern void ubi_exit(void);
|
||||
|
||||
extern struct ubi_device *ubi_devices[];
|
||||
|
||||
#endif
|
|
@ -1,646 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) International Business Machines Corp., 2006
|
||||
* Copyright (c) Nokia Corporation, 2006, 2007
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* Author: Artem Bityutskiy (Битюцкий Артём)
|
||||
*/
|
||||
|
||||
#ifndef __UBI_UBI_H__
|
||||
#define __UBI_UBI_H__
|
||||
|
||||
#ifdef UBI_LINUX
|
||||
#include <linux/init.h>
|
||||
#include <linux/types.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/rbtree.h>
|
||||
#include <linux/sched.h>
|
||||
#include <linux/wait.h>
|
||||
#include <linux/mutex.h>
|
||||
#include <linux/rwsem.h>
|
||||
#include <linux/spinlock.h>
|
||||
#include <linux/fs.h>
|
||||
#include <linux/cdev.h>
|
||||
#include <linux/device.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/mtd/mtd.h>
|
||||
#include <linux/mtd/ubi.h>
|
||||
#endif
|
||||
|
||||
#include <linux/types.h>
|
||||
#include <linux/list.h>
|
||||
#include <linux/rbtree.h>
|
||||
#include <linux/string.h>
|
||||
#include <linux/mtd/mtd.h>
|
||||
#include <linux/mtd/ubi.h>
|
||||
|
||||
#include <mtd/ubi-media.h>
|
||||
|
||||
#include "scan.h"
|
||||
#include "debug.h"
|
||||
|
||||
/* Maximum number of supported UBI devices */
|
||||
#define UBI_MAX_DEVICES 32
|
||||
|
||||
/* UBI name used for character devices, sysfs, etc */
|
||||
#define UBI_NAME_STR "ubi"
|
||||
|
||||
/* Normal UBI messages */
|
||||
#define ubi_msg(fmt, ...) printk(KERN_NOTICE "UBI: " fmt "\n", ##__VA_ARGS__)
|
||||
/* UBI warning messages */
|
||||
#define ubi_warn(fmt, ...) printk(KERN_WARNING "UBI warning: %s: " fmt "\n", \
|
||||
__func__, ##__VA_ARGS__)
|
||||
/* UBI error messages */
|
||||
#define ubi_err(fmt, ...) printk(KERN_ERR "UBI error: %s: " fmt "\n", \
|
||||
__func__, ##__VA_ARGS__)
|
||||
|
||||
/* Lowest number PEBs reserved for bad PEB handling */
|
||||
#define MIN_RESEVED_PEBS 2
|
||||
|
||||
/* Background thread name pattern */
|
||||
#define UBI_BGT_NAME_PATTERN "ubi_bgt%dd"
|
||||
|
||||
/* This marker in the EBA table means that the LEB is um-mapped */
|
||||
#define UBI_LEB_UNMAPPED -1
|
||||
|
||||
/*
|
||||
* In case of errors, UBI tries to repeat the operation several times before
|
||||
* returning error. The below constant defines how many times UBI re-tries.
|
||||
*/
|
||||
#define UBI_IO_RETRIES 3
|
||||
|
||||
/*
|
||||
* Error codes returned by the I/O unit.
|
||||
*
|
||||
* UBI_IO_PEB_EMPTY: the physical eraseblock is empty, i.e. it contains only
|
||||
* 0xFF bytes
|
||||
* UBI_IO_PEB_FREE: the physical eraseblock is free, i.e. it contains only a
|
||||
* valid erase counter header, and the rest are %0xFF bytes
|
||||
* UBI_IO_BAD_EC_HDR: the erase counter header is corrupted (bad magic or CRC)
|
||||
* UBI_IO_BAD_VID_HDR: the volume identifier header is corrupted (bad magic or
|
||||
* CRC)
|
||||
* UBI_IO_BITFLIPS: bit-flips were detected and corrected
|
||||
*/
|
||||
enum {
|
||||
UBI_IO_PEB_EMPTY = 1,
|
||||
UBI_IO_PEB_FREE,
|
||||
UBI_IO_BAD_EC_HDR,
|
||||
UBI_IO_BAD_VID_HDR,
|
||||
UBI_IO_BITFLIPS
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ubi_wl_entry - wear-leveling entry.
|
||||
* @rb: link in the corresponding RB-tree
|
||||
* @ec: erase counter
|
||||
* @pnum: physical eraseblock number
|
||||
*
|
||||
* This data structure is used in the WL unit. Each physical eraseblock has a
|
||||
* corresponding &struct wl_entry object which may be kept in different
|
||||
* RB-trees. See WL unit for details.
|
||||
*/
|
||||
struct ubi_wl_entry {
|
||||
struct rb_node rb;
|
||||
int ec;
|
||||
int pnum;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ubi_ltree_entry - an entry in the lock tree.
|
||||
* @rb: links RB-tree nodes
|
||||
* @vol_id: volume ID of the locked logical eraseblock
|
||||
* @lnum: locked logical eraseblock number
|
||||
* @users: how many tasks are using this logical eraseblock or wait for it
|
||||
* @mutex: read/write mutex to implement read/write access serialization to
|
||||
* the (@vol_id, @lnum) logical eraseblock
|
||||
*
|
||||
* This data structure is used in the EBA unit to implement per-LEB locking.
|
||||
* When a logical eraseblock is being locked - corresponding
|
||||
* &struct ubi_ltree_entry object is inserted to the lock tree (@ubi->ltree).
|
||||
* See EBA unit for details.
|
||||
*/
|
||||
struct ubi_ltree_entry {
|
||||
struct rb_node rb;
|
||||
int vol_id;
|
||||
int lnum;
|
||||
int users;
|
||||
struct rw_semaphore mutex;
|
||||
};
|
||||
|
||||
struct ubi_volume_desc;
|
||||
|
||||
/**
|
||||
* struct ubi_volume - UBI volume description data structure.
|
||||
* @dev: device object to make use of the the Linux device model
|
||||
* @cdev: character device object to create character device
|
||||
* @ubi: reference to the UBI device description object
|
||||
* @vol_id: volume ID
|
||||
* @ref_count: volume reference count
|
||||
* @readers: number of users holding this volume in read-only mode
|
||||
* @writers: number of users holding this volume in read-write mode
|
||||
* @exclusive: whether somebody holds this volume in exclusive mode
|
||||
*
|
||||
* @reserved_pebs: how many physical eraseblocks are reserved for this volume
|
||||
* @vol_type: volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME)
|
||||
* @usable_leb_size: logical eraseblock size without padding
|
||||
* @used_ebs: how many logical eraseblocks in this volume contain data
|
||||
* @last_eb_bytes: how many bytes are stored in the last logical eraseblock
|
||||
* @used_bytes: how many bytes of data this volume contains
|
||||
* @alignment: volume alignment
|
||||
* @data_pad: how many bytes are not used at the end of physical eraseblocks to
|
||||
* satisfy the requested alignment
|
||||
* @name_len: volume name length
|
||||
* @name: volume name
|
||||
*
|
||||
* @upd_ebs: how many eraseblocks are expected to be updated
|
||||
* @ch_lnum: LEB number which is being changing by the atomic LEB change
|
||||
* operation
|
||||
* @ch_dtype: data persistency type which is being changing by the atomic LEB
|
||||
* change operation
|
||||
* @upd_bytes: how many bytes are expected to be received for volume update or
|
||||
* atomic LEB change
|
||||
* @upd_received: how many bytes were already received for volume update or
|
||||
* atomic LEB change
|
||||
* @upd_buf: update buffer which is used to collect update data or data for
|
||||
* atomic LEB change
|
||||
*
|
||||
* @eba_tbl: EBA table of this volume (LEB->PEB mapping)
|
||||
* @checked: %1 if this static volume was checked
|
||||
* @corrupted: %1 if the volume is corrupted (static volumes only)
|
||||
* @upd_marker: %1 if the update marker is set for this volume
|
||||
* @updating: %1 if the volume is being updated
|
||||
* @changing_leb: %1 if the atomic LEB change ioctl command is in progress
|
||||
*
|
||||
* @gluebi_desc: gluebi UBI volume descriptor
|
||||
* @gluebi_refcount: reference count of the gluebi MTD device
|
||||
* @gluebi_mtd: MTD device description object of the gluebi MTD device
|
||||
*
|
||||
* The @corrupted field indicates that the volume's contents is corrupted.
|
||||
* Since UBI protects only static volumes, this field is not relevant to
|
||||
* dynamic volumes - it is user's responsibility to assure their data
|
||||
* integrity.
|
||||
*
|
||||
* The @upd_marker flag indicates that this volume is either being updated at
|
||||
* the moment or is damaged because of an unclean reboot.
|
||||
*/
|
||||
struct ubi_volume {
|
||||
struct device dev;
|
||||
struct cdev cdev;
|
||||
struct ubi_device *ubi;
|
||||
int vol_id;
|
||||
int ref_count;
|
||||
int readers;
|
||||
int writers;
|
||||
int exclusive;
|
||||
|
||||
int reserved_pebs;
|
||||
int vol_type;
|
||||
int usable_leb_size;
|
||||
int used_ebs;
|
||||
int last_eb_bytes;
|
||||
long long used_bytes;
|
||||
int alignment;
|
||||
int data_pad;
|
||||
int name_len;
|
||||
char name[UBI_VOL_NAME_MAX+1];
|
||||
|
||||
int upd_ebs;
|
||||
int ch_lnum;
|
||||
int ch_dtype;
|
||||
long long upd_bytes;
|
||||
long long upd_received;
|
||||
void *upd_buf;
|
||||
|
||||
int *eba_tbl;
|
||||
unsigned int checked:1;
|
||||
unsigned int corrupted:1;
|
||||
unsigned int upd_marker:1;
|
||||
unsigned int updating:1;
|
||||
unsigned int changing_leb:1;
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_GLUEBI
|
||||
/*
|
||||
* Gluebi-related stuff may be compiled out.
|
||||
* TODO: this should not be built into UBI but should be a separate
|
||||
* ubimtd driver which works on top of UBI and emulates MTD devices.
|
||||
*/
|
||||
struct ubi_volume_desc *gluebi_desc;
|
||||
int gluebi_refcount;
|
||||
struct mtd_info gluebi_mtd;
|
||||
#endif
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ubi_volume_desc - descriptor of the UBI volume returned when it is
|
||||
* opened.
|
||||
* @vol: reference to the corresponding volume description object
|
||||
* @mode: open mode (%UBI_READONLY, %UBI_READWRITE, or %UBI_EXCLUSIVE)
|
||||
*/
|
||||
struct ubi_volume_desc {
|
||||
struct ubi_volume *vol;
|
||||
int mode;
|
||||
};
|
||||
|
||||
struct ubi_wl_entry;
|
||||
|
||||
/**
|
||||
* struct ubi_device - UBI device description structure
|
||||
* @dev: UBI device object to use the the Linux device model
|
||||
* @cdev: character device object to create character device
|
||||
* @ubi_num: UBI device number
|
||||
* @ubi_name: UBI device name
|
||||
* @vol_count: number of volumes in this UBI device
|
||||
* @volumes: volumes of this UBI device
|
||||
* @volumes_lock: protects @volumes, @rsvd_pebs, @avail_pebs, beb_rsvd_pebs,
|
||||
* @beb_rsvd_level, @bad_peb_count, @good_peb_count, @vol_count,
|
||||
* @vol->readers, @vol->writers, @vol->exclusive,
|
||||
* @vol->ref_count, @vol->mapping and @vol->eba_tbl.
|
||||
* @ref_count: count of references on the UBI device
|
||||
*
|
||||
* @rsvd_pebs: count of reserved physical eraseblocks
|
||||
* @avail_pebs: count of available physical eraseblocks
|
||||
* @beb_rsvd_pebs: how many physical eraseblocks are reserved for bad PEB
|
||||
* handling
|
||||
* @beb_rsvd_level: normal level of PEBs reserved for bad PEB handling
|
||||
*
|
||||
* @autoresize_vol_id: ID of the volume which has to be auto-resized at the end
|
||||
* of UBI ititializetion
|
||||
* @vtbl_slots: how many slots are available in the volume table
|
||||
* @vtbl_size: size of the volume table in bytes
|
||||
* @vtbl: in-RAM volume table copy
|
||||
* @volumes_mutex: protects on-flash volume table and serializes volume
|
||||
* changes, like creation, deletion, update, resize
|
||||
*
|
||||
* @max_ec: current highest erase counter value
|
||||
* @mean_ec: current mean erase counter value
|
||||
*
|
||||
* @global_sqnum: global sequence number
|
||||
* @ltree_lock: protects the lock tree and @global_sqnum
|
||||
* @ltree: the lock tree
|
||||
* @alc_mutex: serializes "atomic LEB change" operations
|
||||
*
|
||||
* @used: RB-tree of used physical eraseblocks
|
||||
* @free: RB-tree of free physical eraseblocks
|
||||
* @scrub: RB-tree of physical eraseblocks which need scrubbing
|
||||
* @prot: protection trees
|
||||
* @prot.pnum: protection tree indexed by physical eraseblock numbers
|
||||
* @prot.aec: protection tree indexed by absolute erase counter value
|
||||
* @wl_lock: protects the @used, @free, @prot, @lookuptbl, @abs_ec, @move_from,
|
||||
* @move_to, @move_to_put @erase_pending, @wl_scheduled, and @works
|
||||
* fields
|
||||
* @move_mutex: serializes eraseblock moves
|
||||
* @wl_scheduled: non-zero if the wear-leveling was scheduled
|
||||
* @lookuptbl: a table to quickly find a &struct ubi_wl_entry object for any
|
||||
* physical eraseblock
|
||||
* @abs_ec: absolute erase counter
|
||||
* @move_from: physical eraseblock from where the data is being moved
|
||||
* @move_to: physical eraseblock where the data is being moved to
|
||||
* @move_to_put: if the "to" PEB was put
|
||||
* @works: list of pending works
|
||||
* @works_count: count of pending works
|
||||
* @bgt_thread: background thread description object
|
||||
* @thread_enabled: if the background thread is enabled
|
||||
* @bgt_name: background thread name
|
||||
*
|
||||
* @flash_size: underlying MTD device size (in bytes)
|
||||
* @peb_count: count of physical eraseblocks on the MTD device
|
||||
* @peb_size: physical eraseblock size
|
||||
* @bad_peb_count: count of bad physical eraseblocks
|
||||
* @good_peb_count: count of good physical eraseblocks
|
||||
* @min_io_size: minimal input/output unit size of the underlying MTD device
|
||||
* @hdrs_min_io_size: minimal I/O unit size used for VID and EC headers
|
||||
* @ro_mode: if the UBI device is in read-only mode
|
||||
* @leb_size: logical eraseblock size
|
||||
* @leb_start: starting offset of logical eraseblocks within physical
|
||||
* eraseblocks
|
||||
* @ec_hdr_alsize: size of the EC header aligned to @hdrs_min_io_size
|
||||
* @vid_hdr_alsize: size of the VID header aligned to @hdrs_min_io_size
|
||||
* @vid_hdr_offset: starting offset of the volume identifier header (might be
|
||||
* unaligned)
|
||||
* @vid_hdr_aloffset: starting offset of the VID header aligned to
|
||||
* @hdrs_min_io_size
|
||||
* @vid_hdr_shift: contains @vid_hdr_offset - @vid_hdr_aloffset
|
||||
* @bad_allowed: whether the MTD device admits of bad physical eraseblocks or
|
||||
* not
|
||||
* @mtd: MTD device descriptor
|
||||
*
|
||||
* @peb_buf1: a buffer of PEB size used for different purposes
|
||||
* @peb_buf2: another buffer of PEB size used for different purposes
|
||||
* @buf_mutex: proptects @peb_buf1 and @peb_buf2
|
||||
* @dbg_peb_buf: buffer of PEB size used for debugging
|
||||
* @dbg_buf_mutex: proptects @dbg_peb_buf
|
||||
*/
|
||||
struct ubi_device {
|
||||
struct cdev cdev;
|
||||
struct device dev;
|
||||
int ubi_num;
|
||||
char ubi_name[sizeof(UBI_NAME_STR)+5];
|
||||
int vol_count;
|
||||
struct ubi_volume *volumes[UBI_MAX_VOLUMES+UBI_INT_VOL_COUNT];
|
||||
spinlock_t volumes_lock;
|
||||
int ref_count;
|
||||
|
||||
int rsvd_pebs;
|
||||
int avail_pebs;
|
||||
int beb_rsvd_pebs;
|
||||
int beb_rsvd_level;
|
||||
|
||||
int autoresize_vol_id;
|
||||
int vtbl_slots;
|
||||
int vtbl_size;
|
||||
struct ubi_vtbl_record *vtbl;
|
||||
struct mutex volumes_mutex;
|
||||
|
||||
int max_ec;
|
||||
/* TODO: mean_ec is not updated run-time, fix */
|
||||
int mean_ec;
|
||||
|
||||
/* EBA unit's stuff */
|
||||
unsigned long long global_sqnum;
|
||||
spinlock_t ltree_lock;
|
||||
struct rb_root ltree;
|
||||
struct mutex alc_mutex;
|
||||
|
||||
/* Wear-leveling unit's stuff */
|
||||
struct rb_root used;
|
||||
struct rb_root free;
|
||||
struct rb_root scrub;
|
||||
struct {
|
||||
struct rb_root pnum;
|
||||
struct rb_root aec;
|
||||
} prot;
|
||||
spinlock_t wl_lock;
|
||||
struct mutex move_mutex;
|
||||
struct rw_semaphore work_sem;
|
||||
int wl_scheduled;
|
||||
struct ubi_wl_entry **lookuptbl;
|
||||
unsigned long long abs_ec;
|
||||
struct ubi_wl_entry *move_from;
|
||||
struct ubi_wl_entry *move_to;
|
||||
int move_to_put;
|
||||
struct list_head works;
|
||||
int works_count;
|
||||
struct task_struct *bgt_thread;
|
||||
int thread_enabled;
|
||||
char bgt_name[sizeof(UBI_BGT_NAME_PATTERN)+2];
|
||||
|
||||
/* I/O unit's stuff */
|
||||
long long flash_size;
|
||||
int peb_count;
|
||||
int peb_size;
|
||||
int bad_peb_count;
|
||||
int good_peb_count;
|
||||
int min_io_size;
|
||||
int hdrs_min_io_size;
|
||||
int ro_mode;
|
||||
int leb_size;
|
||||
int leb_start;
|
||||
int ec_hdr_alsize;
|
||||
int vid_hdr_alsize;
|
||||
int vid_hdr_offset;
|
||||
int vid_hdr_aloffset;
|
||||
int vid_hdr_shift;
|
||||
int bad_allowed;
|
||||
struct mtd_info *mtd;
|
||||
|
||||
void *peb_buf1;
|
||||
void *peb_buf2;
|
||||
struct mutex buf_mutex;
|
||||
struct mutex ckvol_mutex;
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG
|
||||
void *dbg_peb_buf;
|
||||
struct mutex dbg_buf_mutex;
|
||||
#endif
|
||||
};
|
||||
|
||||
extern struct kmem_cache *ubi_wl_entry_slab;
|
||||
extern struct file_operations ubi_ctrl_cdev_operations;
|
||||
extern struct file_operations ubi_cdev_operations;
|
||||
extern struct file_operations ubi_vol_cdev_operations;
|
||||
extern struct class *ubi_class;
|
||||
extern struct mutex ubi_devices_mutex;
|
||||
|
||||
/* vtbl.c */
|
||||
int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,
|
||||
struct ubi_vtbl_record *vtbl_rec);
|
||||
int ubi_read_volume_table(struct ubi_device *ubi, struct ubi_scan_info *si);
|
||||
|
||||
/* vmt.c */
|
||||
int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req);
|
||||
int ubi_remove_volume(struct ubi_volume_desc *desc);
|
||||
int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs);
|
||||
int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol);
|
||||
void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol);
|
||||
|
||||
/* upd.c */
|
||||
int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
long long bytes);
|
||||
int ubi_finish_update(struct ubi_device *ubi, struct ubi_volume *vol);
|
||||
int ubi_more_update_data(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
const void __user *buf, int count);
|
||||
int ubi_start_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
const struct ubi_leb_change_req *req);
|
||||
int ubi_more_leb_change_data(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
const void __user *buf, int count);
|
||||
|
||||
/* misc.c */
|
||||
int ubi_calc_data_len(const struct ubi_device *ubi, const void *buf, int length);
|
||||
int ubi_check_volume(struct ubi_device *ubi, int vol_id);
|
||||
void ubi_calculate_reserved(struct ubi_device *ubi);
|
||||
|
||||
/* gluebi.c */
|
||||
#ifdef CONFIG_MTD_UBI_GLUEBI
|
||||
int ubi_create_gluebi(struct ubi_device *ubi, struct ubi_volume *vol);
|
||||
int ubi_destroy_gluebi(struct ubi_volume *vol);
|
||||
void ubi_gluebi_updated(struct ubi_volume *vol);
|
||||
#else
|
||||
#define ubi_create_gluebi(ubi, vol) 0
|
||||
#define ubi_destroy_gluebi(vol) 0
|
||||
#define ubi_gluebi_updated(vol)
|
||||
#endif
|
||||
|
||||
/* eba.c */
|
||||
int ubi_eba_unmap_leb(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
int lnum);
|
||||
int ubi_eba_read_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
|
||||
void *buf, int offset, int len, int check);
|
||||
int ubi_eba_write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
|
||||
const void *buf, int offset, int len, int dtype);
|
||||
int ubi_eba_write_leb_st(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
int lnum, const void *buf, int len, int dtype,
|
||||
int used_ebs);
|
||||
int ubi_eba_atomic_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
int lnum, const void *buf, int len, int dtype);
|
||||
int ubi_eba_copy_leb(struct ubi_device *ubi, int from, int to,
|
||||
struct ubi_vid_hdr *vid_hdr);
|
||||
int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si);
|
||||
void ubi_eba_close(const struct ubi_device *ubi);
|
||||
|
||||
/* wl.c */
|
||||
int ubi_wl_get_peb(struct ubi_device *ubi, int dtype);
|
||||
int ubi_wl_put_peb(struct ubi_device *ubi, int pnum, int torture);
|
||||
int ubi_wl_flush(struct ubi_device *ubi);
|
||||
int ubi_wl_scrub_peb(struct ubi_device *ubi, int pnum);
|
||||
int ubi_wl_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si);
|
||||
void ubi_wl_close(struct ubi_device *ubi);
|
||||
int ubi_thread(void *u);
|
||||
|
||||
/* io.c */
|
||||
int ubi_io_read(const struct ubi_device *ubi, void *buf, int pnum, int offset,
|
||||
int len);
|
||||
int ubi_io_write(struct ubi_device *ubi, const void *buf, int pnum, int offset,
|
||||
int len);
|
||||
int ubi_io_sync_erase(struct ubi_device *ubi, int pnum, int torture);
|
||||
int ubi_io_is_bad(const struct ubi_device *ubi, int pnum);
|
||||
int ubi_io_mark_bad(const struct ubi_device *ubi, int pnum);
|
||||
int ubi_io_read_ec_hdr(struct ubi_device *ubi, int pnum,
|
||||
struct ubi_ec_hdr *ec_hdr, int verbose);
|
||||
int ubi_io_write_ec_hdr(struct ubi_device *ubi, int pnum,
|
||||
struct ubi_ec_hdr *ec_hdr);
|
||||
int ubi_io_read_vid_hdr(struct ubi_device *ubi, int pnum,
|
||||
struct ubi_vid_hdr *vid_hdr, int verbose);
|
||||
int ubi_io_write_vid_hdr(struct ubi_device *ubi, int pnum,
|
||||
struct ubi_vid_hdr *vid_hdr);
|
||||
|
||||
/* build.c */
|
||||
int ubi_attach_mtd_dev(struct mtd_info *mtd, int ubi_num, int vid_hdr_offset);
|
||||
int ubi_detach_mtd_dev(struct mtd_info *mtd, int anyway);
|
||||
struct ubi_device *ubi_get_device(int ubi_num);
|
||||
void ubi_put_device(struct ubi_device *ubi);
|
||||
struct ubi_device *ubi_get_by_major(int major);
|
||||
int ubi_major2num(int major);
|
||||
|
||||
/* cdev.c */
|
||||
int ubi_cdev_add(struct ubi_device *ubi);
|
||||
void ubi_cdev_remove(struct ubi_device *ubi);
|
||||
int ubi_volume_cdev_add(struct ubi_device *ubi, struct ubi_volume *vol);
|
||||
void ubi_volume_cdev_remove(struct ubi_volume *vol);
|
||||
|
||||
/*
|
||||
* ubi_rb_for_each_entry - walk an RB-tree.
|
||||
* @rb: a pointer to type 'struct rb_node' to to use as a loop counter
|
||||
* @pos: a pointer to RB-tree entry type to use as a loop counter
|
||||
* @root: RB-tree's root
|
||||
* @member: the name of the 'struct rb_node' within the RB-tree entry
|
||||
*/
|
||||
#define ubi_rb_for_each_entry(rb, pos, root, member) \
|
||||
for (rb = rb_first(root), \
|
||||
pos = (rb ? container_of(rb, typeof(*pos), member) : NULL); \
|
||||
rb; \
|
||||
rb = rb_next(rb), pos = container_of(rb, typeof(*pos), member))
|
||||
|
||||
/**
|
||||
* ubi_zalloc_vid_hdr - allocate a volume identifier header object.
|
||||
* @ubi: UBI device description object
|
||||
* @gfp_flags: GFP flags to allocate with
|
||||
*
|
||||
* This function returns a pointer to the newly allocated and zero-filled
|
||||
* volume identifier header object in case of success and %NULL in case of
|
||||
* failure.
|
||||
*/
|
||||
static inline struct ubi_vid_hdr *
|
||||
ubi_zalloc_vid_hdr(const struct ubi_device *ubi, unsigned int gfp_flags)
|
||||
{
|
||||
void *vid_hdr;
|
||||
|
||||
vid_hdr = kzalloc(ubi->vid_hdr_alsize, gfp_flags);
|
||||
if (!vid_hdr)
|
||||
return NULL;
|
||||
|
||||
/*
|
||||
* VID headers may be stored at un-aligned flash offsets, so we shift
|
||||
* the pointer.
|
||||
*/
|
||||
return vid_hdr + ubi->vid_hdr_shift;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_free_vid_hdr - free a volume identifier header object.
|
||||
* @ubi: UBI device description object
|
||||
* @vid_hdr: the object to free
|
||||
*/
|
||||
static inline void ubi_free_vid_hdr(const struct ubi_device *ubi,
|
||||
struct ubi_vid_hdr *vid_hdr)
|
||||
{
|
||||
void *p = vid_hdr;
|
||||
|
||||
if (!p)
|
||||
return;
|
||||
|
||||
kfree(p - ubi->vid_hdr_shift);
|
||||
}
|
||||
|
||||
/*
|
||||
* This function is equivalent to 'ubi_io_read()', but @offset is relative to
|
||||
* the beginning of the logical eraseblock, not to the beginning of the
|
||||
* physical eraseblock.
|
||||
*/
|
||||
static inline int ubi_io_read_data(const struct ubi_device *ubi, void *buf,
|
||||
int pnum, int offset, int len)
|
||||
{
|
||||
ubi_assert(offset >= 0);
|
||||
return ubi_io_read(ubi, buf, pnum, offset + ubi->leb_start, len);
|
||||
}
|
||||
|
||||
/*
|
||||
* This function is equivalent to 'ubi_io_write()', but @offset is relative to
|
||||
* the beginning of the logical eraseblock, not to the beginning of the
|
||||
* physical eraseblock.
|
||||
*/
|
||||
static inline int ubi_io_write_data(struct ubi_device *ubi, const void *buf,
|
||||
int pnum, int offset, int len)
|
||||
{
|
||||
ubi_assert(offset >= 0);
|
||||
return ubi_io_write(ubi, buf, pnum, offset + ubi->leb_start, len);
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_ro_mode - switch to read-only mode.
|
||||
* @ubi: UBI device description object
|
||||
*/
|
||||
static inline void ubi_ro_mode(struct ubi_device *ubi)
|
||||
{
|
||||
if (!ubi->ro_mode) {
|
||||
ubi->ro_mode = 1;
|
||||
ubi_warn("switch to read-only mode");
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* vol_id2idx - get table index by volume ID.
|
||||
* @ubi: UBI device description object
|
||||
* @vol_id: volume ID
|
||||
*/
|
||||
static inline int vol_id2idx(const struct ubi_device *ubi, int vol_id)
|
||||
{
|
||||
if (vol_id >= UBI_INTERNAL_VOL_START)
|
||||
return vol_id - UBI_INTERNAL_VOL_START + ubi->vtbl_slots;
|
||||
else
|
||||
return vol_id;
|
||||
}
|
||||
|
||||
/**
|
||||
* idx2vol_id - get volume ID by table index.
|
||||
* @ubi: UBI device description object
|
||||
* @idx: table index
|
||||
*/
|
||||
static inline int idx2vol_id(const struct ubi_device *ubi, int idx)
|
||||
{
|
||||
if (idx >= ubi->vtbl_slots)
|
||||
return idx - ubi->vtbl_slots + UBI_INTERNAL_VOL_START;
|
||||
else
|
||||
return idx;
|
||||
}
|
||||
|
||||
#endif /* !__UBI_UBI_H__ */
|
|
@ -1,442 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) International Business Machines Corp., 2006
|
||||
* Copyright (c) Nokia Corporation, 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.
|
||||
*
|
||||
*
|
||||
* Author: Artem Bityutskiy (Битюцкий Артём)
|
||||
*
|
||||
* Jan 2007: Alexander Schmidt, hacked per-volume update.
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file contains implementation of the volume update and atomic LEB change
|
||||
* functionality.
|
||||
*
|
||||
* The update operation is based on the per-volume update marker which is
|
||||
* stored in the volume table. The update marker is set before the update
|
||||
* starts, and removed after the update has been finished. So if the update was
|
||||
* interrupted by an unclean re-boot or due to some other reasons, the update
|
||||
* marker stays on the flash media and UBI finds it when it attaches the MTD
|
||||
* device next time. If the update marker is set for a volume, the volume is
|
||||
* treated as damaged and most I/O operations are prohibited. Only a new update
|
||||
* operation is allowed.
|
||||
*
|
||||
* Note, in general it is possible to implement the update operation as a
|
||||
* transaction with a roll-back capability.
|
||||
*/
|
||||
|
||||
#ifdef UBI_LINUX
|
||||
#include <linux/err.h>
|
||||
#include <asm/uaccess.h>
|
||||
#include <asm/div64.h>
|
||||
#endif
|
||||
|
||||
#include "ubi-barebox.h"
|
||||
#include "ubi.h"
|
||||
|
||||
/**
|
||||
* set_update_marker - set update marker.
|
||||
* @ubi: UBI device description object
|
||||
* @vol: volume description object
|
||||
*
|
||||
* This function sets the update marker flag for volume @vol. Returns zero
|
||||
* in case of success and a negative error code in case of failure.
|
||||
*/
|
||||
static int set_update_marker(struct ubi_device *ubi, struct ubi_volume *vol)
|
||||
{
|
||||
int err;
|
||||
struct ubi_vtbl_record vtbl_rec;
|
||||
|
||||
dbg_msg("set update marker for volume %d", vol->vol_id);
|
||||
|
||||
if (vol->upd_marker) {
|
||||
ubi_assert(ubi->vtbl[vol->vol_id].upd_marker);
|
||||
dbg_msg("already set");
|
||||
return 0;
|
||||
}
|
||||
|
||||
memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id],
|
||||
sizeof(struct ubi_vtbl_record));
|
||||
vtbl_rec.upd_marker = 1;
|
||||
|
||||
mutex_lock(&ubi->volumes_mutex);
|
||||
err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec);
|
||||
mutex_unlock(&ubi->volumes_mutex);
|
||||
vol->upd_marker = 1;
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* clear_update_marker - clear update marker.
|
||||
* @ubi: UBI device description object
|
||||
* @vol: volume description object
|
||||
* @bytes: new data size in bytes
|
||||
*
|
||||
* This function clears the update marker for volume @vol, sets new volume
|
||||
* data size and clears the "corrupted" flag (static volumes only). Returns
|
||||
* zero in case of success and a negative error code in case of failure.
|
||||
*/
|
||||
static int clear_update_marker(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
long long bytes)
|
||||
{
|
||||
int err;
|
||||
uint64_t tmp;
|
||||
struct ubi_vtbl_record vtbl_rec;
|
||||
|
||||
dbg_msg("clear update marker for volume %d", vol->vol_id);
|
||||
|
||||
memcpy(&vtbl_rec, &ubi->vtbl[vol->vol_id],
|
||||
sizeof(struct ubi_vtbl_record));
|
||||
ubi_assert(vol->upd_marker && vtbl_rec.upd_marker);
|
||||
vtbl_rec.upd_marker = 0;
|
||||
|
||||
if (vol->vol_type == UBI_STATIC_VOLUME) {
|
||||
vol->corrupted = 0;
|
||||
vol->used_bytes = tmp = bytes;
|
||||
vol->last_eb_bytes = do_div(tmp, vol->usable_leb_size);
|
||||
vol->used_ebs = tmp;
|
||||
if (vol->last_eb_bytes)
|
||||
vol->used_ebs += 1;
|
||||
else
|
||||
vol->last_eb_bytes = vol->usable_leb_size;
|
||||
}
|
||||
|
||||
mutex_lock(&ubi->volumes_mutex);
|
||||
err = ubi_change_vtbl_record(ubi, vol->vol_id, &vtbl_rec);
|
||||
mutex_unlock(&ubi->volumes_mutex);
|
||||
vol->upd_marker = 0;
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_start_update - start volume update.
|
||||
* @ubi: UBI device description object
|
||||
* @vol: volume description object
|
||||
* @bytes: update bytes
|
||||
*
|
||||
* This function starts volume update operation. If @bytes is zero, the volume
|
||||
* is just wiped out. Returns zero in case of success and a negative error code
|
||||
* in case of failure.
|
||||
*/
|
||||
int ubi_start_update(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
long long bytes)
|
||||
{
|
||||
int i, err;
|
||||
uint64_t tmp;
|
||||
|
||||
dbg_msg("start update of volume %d, %llu bytes", vol->vol_id, bytes);
|
||||
ubi_assert(!vol->updating && !vol->changing_leb);
|
||||
vol->updating = 1;
|
||||
|
||||
err = set_update_marker(ubi, vol);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
/* Before updating - wipe out the volume */
|
||||
for (i = 0; i < vol->reserved_pebs; i++) {
|
||||
err = ubi_eba_unmap_leb(ubi, vol, i);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
|
||||
if (bytes == 0) {
|
||||
err = clear_update_marker(ubi, vol, 0);
|
||||
if (err)
|
||||
return err;
|
||||
err = ubi_wl_flush(ubi);
|
||||
if (!err)
|
||||
vol->updating = 0;
|
||||
}
|
||||
|
||||
vol->upd_buf = vmalloc(ubi->leb_size);
|
||||
if (!vol->upd_buf)
|
||||
return -ENOMEM;
|
||||
|
||||
tmp = bytes;
|
||||
vol->upd_ebs = !!do_div(tmp, vol->usable_leb_size);
|
||||
vol->upd_ebs += tmp;
|
||||
vol->upd_bytes = bytes;
|
||||
vol->upd_received = 0;
|
||||
return 0;
|
||||
}
|
||||
|
||||
int ubi_finish_update(struct ubi_device *ubi, struct ubi_volume *vol)
|
||||
{
|
||||
int err;
|
||||
|
||||
/* The update is finished, clear the update marker */
|
||||
err = clear_update_marker(ubi, vol, vol->upd_bytes);
|
||||
if (err)
|
||||
return err;
|
||||
err = ubi_wl_flush(ubi);
|
||||
if (err == 0) {
|
||||
vol->updating = 0;
|
||||
vfree(vol->upd_buf);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_start_leb_change - start atomic LEB change.
|
||||
* @ubi: UBI device description object
|
||||
* @vol: volume description object
|
||||
* @req: operation request
|
||||
*
|
||||
* This function starts atomic LEB change operation. Returns zero in case of
|
||||
* success and a negative error code in case of failure.
|
||||
*/
|
||||
int ubi_start_leb_change(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
const struct ubi_leb_change_req *req)
|
||||
{
|
||||
ubi_assert(!vol->updating && !vol->changing_leb);
|
||||
|
||||
dbg_msg("start changing LEB %d:%d, %u bytes",
|
||||
vol->vol_id, req->lnum, req->bytes);
|
||||
if (req->bytes == 0)
|
||||
return ubi_eba_atomic_leb_change(ubi, vol, req->lnum, NULL, 0,
|
||||
req->dtype);
|
||||
|
||||
vol->upd_bytes = req->bytes;
|
||||
vol->upd_received = 0;
|
||||
vol->changing_leb = 1;
|
||||
vol->ch_lnum = req->lnum;
|
||||
vol->ch_dtype = req->dtype;
|
||||
|
||||
vol->upd_buf = vmalloc(req->bytes);
|
||||
if (!vol->upd_buf)
|
||||
return -ENOMEM;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* write_leb - write update data.
|
||||
* @ubi: UBI device description object
|
||||
* @vol: volume description object
|
||||
* @lnum: logical eraseblock number
|
||||
* @buf: data to write
|
||||
* @len: data size
|
||||
* @used_ebs: how many logical eraseblocks will this volume contain (static
|
||||
* volumes only)
|
||||
*
|
||||
* This function writes update data to corresponding logical eraseblock. In
|
||||
* case of dynamic volume, this function checks if the data contains 0xFF bytes
|
||||
* at the end. If yes, the 0xFF bytes are cut and not written. So if the whole
|
||||
* buffer contains only 0xFF bytes, the LEB is left unmapped.
|
||||
*
|
||||
* The reason why we skip the trailing 0xFF bytes in case of dynamic volume is
|
||||
* that we want to make sure that more data may be appended to the logical
|
||||
* eraseblock in future. Indeed, writing 0xFF bytes may have side effects and
|
||||
* this PEB won't be writable anymore. So if one writes the file-system image
|
||||
* to the UBI volume where 0xFFs mean free space - UBI makes sure this free
|
||||
* space is writable after the update.
|
||||
*
|
||||
* We do not do this for static volumes because they are read-only. But this
|
||||
* also cannot be done because we have to store per-LEB CRC and the correct
|
||||
* data length.
|
||||
*
|
||||
* This function returns zero in case of success and a negative error code in
|
||||
* case of failure.
|
||||
*/
|
||||
static int write_leb(struct ubi_device *ubi, struct ubi_volume *vol, int lnum,
|
||||
void *buf, int len, int used_ebs)
|
||||
{
|
||||
int err;
|
||||
|
||||
if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
|
||||
int l = ALIGN(len, ubi->min_io_size);
|
||||
|
||||
memset(buf + len, 0xFF, l - len);
|
||||
len = ubi_calc_data_len(ubi, buf, l);
|
||||
if (len == 0) {
|
||||
dbg_msg("all %d bytes contain 0xFF - skip", len);
|
||||
return 0;
|
||||
}
|
||||
|
||||
err = ubi_eba_write_leb(ubi, vol, lnum, buf, 0, len, UBI_UNKNOWN);
|
||||
} else {
|
||||
/*
|
||||
* When writing static volume, and this is the last logical
|
||||
* eraseblock, the length (@len) does not have to be aligned to
|
||||
* the minimal flash I/O unit. The 'ubi_eba_write_leb_st()'
|
||||
* function accepts exact (unaligned) length and stores it in
|
||||
* the VID header. And it takes care of proper alignment by
|
||||
* padding the buffer. Here we just make sure the padding will
|
||||
* contain zeros, not random trash.
|
||||
*/
|
||||
memset(buf + len, 0, vol->usable_leb_size - len);
|
||||
err = ubi_eba_write_leb_st(ubi, vol, lnum, buf, len,
|
||||
UBI_UNKNOWN, used_ebs);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_more_update_data - write more update data.
|
||||
* @vol: volume description object
|
||||
* @buf: write data (user-space memory buffer)
|
||||
* @count: how much bytes to write
|
||||
*
|
||||
* This function writes more data to the volume which is being updated. It may
|
||||
* be called arbitrary number of times until all the update data arriveis. This
|
||||
* function returns %0 in case of success, number of bytes written during the
|
||||
* last call if the whole volume update has been successfully finished, and a
|
||||
* negative error code in case of failure.
|
||||
*/
|
||||
int ubi_more_update_data(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
const void __user *buf, int count)
|
||||
{
|
||||
uint64_t tmp;
|
||||
int lnum, offs, err = 0, len, to_write = count;
|
||||
|
||||
dbg_msg("write %d of %lld bytes, %lld already passed",
|
||||
count, vol->upd_bytes, vol->upd_received);
|
||||
|
||||
if (ubi->ro_mode)
|
||||
return -EROFS;
|
||||
|
||||
tmp = vol->upd_received;
|
||||
offs = do_div(tmp, vol->usable_leb_size);
|
||||
lnum = tmp;
|
||||
|
||||
if (vol->upd_received + count > vol->upd_bytes)
|
||||
to_write = count = vol->upd_bytes - vol->upd_received;
|
||||
|
||||
/*
|
||||
* When updating volumes, we accumulate whole logical eraseblock of
|
||||
* data and write it at once.
|
||||
*/
|
||||
if (offs != 0) {
|
||||
/*
|
||||
* This is a write to the middle of the logical eraseblock. We
|
||||
* copy the data to our update buffer and wait for more data or
|
||||
* flush it if the whole eraseblock is written or the update
|
||||
* is finished.
|
||||
*/
|
||||
|
||||
len = vol->usable_leb_size - offs;
|
||||
if (len > count)
|
||||
len = count;
|
||||
|
||||
err = copy_from_user(vol->upd_buf + offs, buf, len);
|
||||
if (err)
|
||||
return -EFAULT;
|
||||
|
||||
if (offs + len == vol->usable_leb_size) {
|
||||
int flush_len = offs + len;
|
||||
|
||||
/*
|
||||
* OK, we gathered the whole eraseblock, it's time to flush
|
||||
* the buffer.
|
||||
*/
|
||||
ubi_assert(flush_len <= vol->usable_leb_size);
|
||||
err = write_leb(ubi, vol, lnum, vol->upd_buf, flush_len,
|
||||
vol->upd_ebs);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
|
||||
vol->upd_received += len;
|
||||
count -= len;
|
||||
buf += len;
|
||||
lnum += 1;
|
||||
}
|
||||
|
||||
/*
|
||||
* If we've got more to write, let's continue. At this point we know we
|
||||
* are starting from the beginning of an eraseblock.
|
||||
*/
|
||||
while (count) {
|
||||
if (count > vol->usable_leb_size)
|
||||
len = vol->usable_leb_size;
|
||||
else
|
||||
len = count;
|
||||
|
||||
err = copy_from_user(vol->upd_buf, buf, len);
|
||||
if (err)
|
||||
return -EFAULT;
|
||||
|
||||
if (len == vol->usable_leb_size ||
|
||||
vol->upd_received + len == vol->upd_bytes) {
|
||||
err = write_leb(ubi, vol, lnum, vol->upd_buf,
|
||||
len, vol->upd_ebs);
|
||||
if (err)
|
||||
break;
|
||||
}
|
||||
|
||||
vol->upd_received += len;
|
||||
count -= len;
|
||||
lnum += 1;
|
||||
buf += len;
|
||||
}
|
||||
|
||||
ubi_assert(vol->upd_received <= vol->upd_bytes);
|
||||
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_more_leb_change_data - accept more data for atomic LEB change.
|
||||
* @vol: volume description object
|
||||
* @buf: write data (user-space memory buffer)
|
||||
* @count: how much bytes to write
|
||||
*
|
||||
* This function accepts more data to the volume which is being under the
|
||||
* "atomic LEB change" operation. It may be called arbitrary number of times
|
||||
* until all data arrives. This function returns %0 in case of success, number
|
||||
* of bytes written during the last call if the whole "atomic LEB change"
|
||||
* operation has been successfully finished, and a negative error code in case
|
||||
* of failure.
|
||||
*/
|
||||
int ubi_more_leb_change_data(struct ubi_device *ubi, struct ubi_volume *vol,
|
||||
const void __user *buf, int count)
|
||||
{
|
||||
int err;
|
||||
|
||||
dbg_msg("write %d of %lld bytes, %lld already passed",
|
||||
count, vol->upd_bytes, vol->upd_received);
|
||||
|
||||
if (ubi->ro_mode)
|
||||
return -EROFS;
|
||||
|
||||
if (vol->upd_received + count > vol->upd_bytes)
|
||||
count = vol->upd_bytes - vol->upd_received;
|
||||
|
||||
err = copy_from_user(vol->upd_buf + vol->upd_received, buf, count);
|
||||
if (err)
|
||||
return -EFAULT;
|
||||
|
||||
vol->upd_received += count;
|
||||
|
||||
if (vol->upd_received == vol->upd_bytes) {
|
||||
int len = ALIGN((int)vol->upd_bytes, ubi->min_io_size);
|
||||
|
||||
memset(vol->upd_buf + vol->upd_bytes, 0xFF, len - vol->upd_bytes);
|
||||
len = ubi_calc_data_len(ubi, vol->upd_buf, len);
|
||||
err = ubi_eba_atomic_leb_change(ubi, vol, vol->ch_lnum,
|
||||
vol->upd_buf, len, UBI_UNKNOWN);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
|
||||
ubi_assert(vol->upd_received <= vol->upd_bytes);
|
||||
if (vol->upd_received == vol->upd_bytes) {
|
||||
vol->changing_leb = 0;
|
||||
err = count;
|
||||
vfree(vol->upd_buf);
|
||||
}
|
||||
|
||||
return err;
|
||||
}
|
|
@ -1,863 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* Author: Artem Bityutskiy (Битюцкий Артём)
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file contains implementation of volume creation, deletion, updating and
|
||||
* resizing.
|
||||
*/
|
||||
|
||||
#ifdef UBI_LINUX
|
||||
#include <linux/err.h>
|
||||
#include <asm/div64.h>
|
||||
#endif
|
||||
|
||||
#include "ubi-barebox.h"
|
||||
#include "ubi.h"
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
|
||||
static void paranoid_check_volumes(struct ubi_device *ubi);
|
||||
#else
|
||||
#define paranoid_check_volumes(ubi)
|
||||
#endif
|
||||
|
||||
#ifdef UBI_LINUX
|
||||
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;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* 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);
|
||||
}
|
||||
|
||||
#ifdef UBI_LINUX
|
||||
/**
|
||||
* 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);
|
||||
}
|
||||
#endif
|
||||
|
||||
/**
|
||||
* 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->volumes_mutex locked.
|
||||
*/
|
||||
int ubi_create_volume(struct ubi_device *ubi, struct ubi_mkvol_req *req)
|
||||
{
|
||||
int i, err, vol_id = req->vol_id, dont_free = 0;
|
||||
struct ubi_volume *vol;
|
||||
struct ubi_vtbl_record vtbl_rec;
|
||||
uint64_t bytes;
|
||||
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_msg("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) {
|
||||
dbg_err("out of volume IDs");
|
||||
err = -ENFILE;
|
||||
goto out_unlock;
|
||||
}
|
||||
req->vol_id = vol_id;
|
||||
}
|
||||
|
||||
dbg_msg("volume ID %d, %llu bytes, type %d, name %s",
|
||||
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]) {
|
||||
dbg_err("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)) {
|
||||
dbg_err("volume \"%s\" exists (ID %d)", req->name, i);
|
||||
goto out_unlock;
|
||||
}
|
||||
|
||||
/* Calculate how many eraseblocks are requested */
|
||||
vol->usable_leb_size = ubi->leb_size - ubi->leb_size % req->alignment;
|
||||
bytes = req->bytes;
|
||||
if (do_div(bytes, vol->usable_leb_size))
|
||||
vol->reserved_pebs = 1;
|
||||
vol->reserved_pebs += bytes;
|
||||
|
||||
/* Reserve physical eraseblocks */
|
||||
if (vol->reserved_pebs > ubi->avail_pebs) {
|
||||
dbg_err("not enough PEBs, only %d available", ubi->avail_pebs);
|
||||
err = -ENOSPC;
|
||||
goto out_unlock;
|
||||
}
|
||||
ubi->avail_pebs -= vol->reserved_pebs;
|
||||
ubi->rsvd_pebs += vol->reserved_pebs;
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
|
||||
vol->vol_id = vol_id;
|
||||
vol->alignment = req->alignment;
|
||||
vol->data_pad = ubi->leb_size % vol->alignment;
|
||||
vol->vol_type = req->vol_type;
|
||||
vol->name_len = req->name_len;
|
||||
memcpy(vol->name, req->name, vol->name_len + 1);
|
||||
vol->ubi = ubi;
|
||||
|
||||
/*
|
||||
* Finish all pending erases because there may be some LEBs belonging
|
||||
* to the same volume ID.
|
||||
*/
|
||||
err = ubi_wl_flush(ubi);
|
||||
if (err)
|
||||
goto out_acc;
|
||||
|
||||
vol->eba_tbl = kmalloc(vol->reserved_pebs * sizeof(int), GFP_KERNEL);
|
||||
if (!vol->eba_tbl) {
|
||||
err = -ENOMEM;
|
||||
goto out_acc;
|
||||
}
|
||||
|
||||
for (i = 0; i < vol->reserved_pebs; i++)
|
||||
vol->eba_tbl[i] = UBI_LEB_UNMAPPED;
|
||||
|
||||
if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
|
||||
vol->used_ebs = vol->reserved_pebs;
|
||||
vol->last_eb_bytes = vol->usable_leb_size;
|
||||
vol->used_bytes =
|
||||
(long long)vol->used_ebs * vol->usable_leb_size;
|
||||
} else {
|
||||
bytes = vol->used_bytes;
|
||||
vol->last_eb_bytes = do_div(bytes, vol->usable_leb_size);
|
||||
vol->used_ebs = bytes;
|
||||
if (vol->last_eb_bytes)
|
||||
vol->used_ebs += 1;
|
||||
else
|
||||
vol->last_eb_bytes = vol->usable_leb_size;
|
||||
}
|
||||
|
||||
/* Register character device for the volume */
|
||||
cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
|
||||
#ifdef UBI_LINUX
|
||||
vol->cdev.owner = THIS_MODULE;
|
||||
#endif
|
||||
dev = MKDEV(MAJOR(ubi->cdev.dev), vol_id + 1);
|
||||
err = ubi_volume_cdev_add(ubi, vol);
|
||||
if (err) {
|
||||
ubi_err("cannot add character device");
|
||||
goto out_mapping;
|
||||
}
|
||||
|
||||
err = ubi_create_gluebi(ubi, vol);
|
||||
if (err)
|
||||
goto out_cdev;
|
||||
|
||||
vol->dev.release = vol_release;
|
||||
vol->dev.parent = &ubi->dev;
|
||||
vol->dev.devt = dev;
|
||||
vol->dev.class = ubi_class;
|
||||
|
||||
sprintf(&vol->dev.bus_id[0], "%s_%d", ubi->ubi_name, vol->vol_id);
|
||||
err = device_register(&vol->dev);
|
||||
if (err) {
|
||||
ubi_err("cannot register device");
|
||||
goto out_gluebi;
|
||||
}
|
||||
|
||||
err = volume_sysfs_init(ubi, vol);
|
||||
if (err)
|
||||
goto out_sysfs;
|
||||
|
||||
/* Fill volume table record */
|
||||
memset(&vtbl_rec, 0, sizeof(struct ubi_vtbl_record));
|
||||
vtbl_rec.reserved_pebs = cpu_to_be32(vol->reserved_pebs);
|
||||
vtbl_rec.alignment = cpu_to_be32(vol->alignment);
|
||||
vtbl_rec.data_pad = cpu_to_be32(vol->data_pad);
|
||||
vtbl_rec.name_len = cpu_to_be16(vol->name_len);
|
||||
if (vol->vol_type == UBI_DYNAMIC_VOLUME)
|
||||
vtbl_rec.vol_type = UBI_VID_DYNAMIC;
|
||||
else
|
||||
vtbl_rec.vol_type = UBI_VID_STATIC;
|
||||
memcpy(vtbl_rec.name, vol->name, vol->name_len + 1);
|
||||
|
||||
err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
|
||||
if (err)
|
||||
goto out_sysfs;
|
||||
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
ubi->volumes[vol_id] = vol;
|
||||
ubi->vol_count += 1;
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
|
||||
paranoid_check_volumes(ubi);
|
||||
return 0;
|
||||
|
||||
out_sysfs:
|
||||
/*
|
||||
* We have registered our device, we should not free the volume*
|
||||
* description object in this function in case of an error - it is
|
||||
* freed by the release function.
|
||||
*
|
||||
* Get device reference to prevent the release function from being
|
||||
* called just after sysfs has been closed.
|
||||
*/
|
||||
dont_free = 1;
|
||||
get_device(&vol->dev);
|
||||
volume_sysfs_close(vol);
|
||||
out_gluebi:
|
||||
if (ubi_destroy_gluebi(vol))
|
||||
dbg_err("cannot destroy gluebi for volume %d:%d",
|
||||
ubi->ubi_num, vol_id);
|
||||
out_cdev:
|
||||
ubi_volume_cdev_remove(vol);
|
||||
out_mapping:
|
||||
kfree(vol->eba_tbl);
|
||||
out_acc:
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
ubi->rsvd_pebs -= vol->reserved_pebs;
|
||||
ubi->avail_pebs += vol->reserved_pebs;
|
||||
out_unlock:
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
if (dont_free)
|
||||
put_device(&vol->dev);
|
||||
else
|
||||
kfree(vol);
|
||||
ubi_err("cannot create volume %d, error %d", vol_id, err);
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_remove_volume - remove volume.
|
||||
* @desc: volume descriptor
|
||||
*
|
||||
* This function removes volume described by @desc. The volume has to be opened
|
||||
* in "exclusive" mode. Returns zero in case of success and a negative error
|
||||
* code in case of failure. The caller has to have the @ubi->volumes_mutex
|
||||
* locked.
|
||||
*/
|
||||
int ubi_remove_volume(struct ubi_volume_desc *desc)
|
||||
{
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
struct ubi_device *ubi = vol->ubi;
|
||||
int i, err, vol_id = vol->vol_id, reserved_pebs = vol->reserved_pebs;
|
||||
|
||||
dbg_msg("remove UBI volume %d", vol_id);
|
||||
ubi_assert(desc->mode == UBI_EXCLUSIVE);
|
||||
ubi_assert(vol == ubi->volumes[vol_id]);
|
||||
|
||||
if (ubi->ro_mode)
|
||||
return -EROFS;
|
||||
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
if (vol->ref_count > 1) {
|
||||
/*
|
||||
* The volume is busy, probably someone is reading one of its
|
||||
* sysfs files.
|
||||
*/
|
||||
err = -EBUSY;
|
||||
goto out_unlock;
|
||||
}
|
||||
ubi->volumes[vol_id] = NULL;
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
|
||||
err = ubi_destroy_gluebi(vol);
|
||||
if (err)
|
||||
goto out_err;
|
||||
|
||||
err = ubi_change_vtbl_record(ubi, vol_id, NULL);
|
||||
if (err)
|
||||
goto out_err;
|
||||
|
||||
for (i = 0; i < vol->reserved_pebs; i++) {
|
||||
err = ubi_eba_unmap_leb(ubi, vol, i);
|
||||
if (err)
|
||||
goto out_err;
|
||||
}
|
||||
|
||||
kfree(vol->eba_tbl);
|
||||
vol->eba_tbl = NULL;
|
||||
ubi_volume_cdev_remove(vol);
|
||||
volume_sysfs_close(vol);
|
||||
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
ubi->rsvd_pebs -= reserved_pebs;
|
||||
ubi->avail_pebs += reserved_pebs;
|
||||
i = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
|
||||
if (i > 0) {
|
||||
i = ubi->avail_pebs >= i ? i : ubi->avail_pebs;
|
||||
ubi->avail_pebs -= i;
|
||||
ubi->rsvd_pebs += i;
|
||||
ubi->beb_rsvd_pebs += i;
|
||||
if (i > 0)
|
||||
ubi_msg("reserve more %d PEBs", i);
|
||||
}
|
||||
ubi->vol_count -= 1;
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
|
||||
paranoid_check_volumes(ubi);
|
||||
return 0;
|
||||
|
||||
out_err:
|
||||
ubi_err("cannot remove volume %d, error %d", vol_id, err);
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
ubi->volumes[vol_id] = vol;
|
||||
out_unlock:
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_resize_volume - re-size volume.
|
||||
* @desc: volume descriptor
|
||||
* @reserved_pebs: new size in physical eraseblocks
|
||||
*
|
||||
* This function re-sizes the volume and returns zero in case of success, and a
|
||||
* negative error code in case of failure. The caller has to have the
|
||||
* @ubi->volumes_mutex locked.
|
||||
*/
|
||||
int ubi_resize_volume(struct ubi_volume_desc *desc, int reserved_pebs)
|
||||
{
|
||||
int i, err, pebs, *new_mapping;
|
||||
struct ubi_volume *vol = desc->vol;
|
||||
struct ubi_device *ubi = vol->ubi;
|
||||
struct ubi_vtbl_record vtbl_rec;
|
||||
int vol_id = vol->vol_id;
|
||||
|
||||
if (ubi->ro_mode)
|
||||
return -EROFS;
|
||||
|
||||
dbg_msg("re-size volume %d to from %d to %d PEBs",
|
||||
vol_id, vol->reserved_pebs, reserved_pebs);
|
||||
|
||||
if (vol->vol_type == UBI_STATIC_VOLUME &&
|
||||
reserved_pebs < vol->used_ebs) {
|
||||
dbg_err("too small size %d, %d LEBs contain data",
|
||||
reserved_pebs, vol->used_ebs);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/* If the size is the same, we have nothing to do */
|
||||
if (reserved_pebs == vol->reserved_pebs)
|
||||
return 0;
|
||||
|
||||
new_mapping = kmalloc(reserved_pebs * sizeof(int), GFP_KERNEL);
|
||||
if (!new_mapping)
|
||||
return -ENOMEM;
|
||||
|
||||
for (i = 0; i < reserved_pebs; i++)
|
||||
new_mapping[i] = UBI_LEB_UNMAPPED;
|
||||
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
if (vol->ref_count > 1) {
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
err = -EBUSY;
|
||||
goto out_free;
|
||||
}
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
|
||||
/* Reserve physical eraseblocks */
|
||||
pebs = reserved_pebs - vol->reserved_pebs;
|
||||
if (pebs > 0) {
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
if (pebs > ubi->avail_pebs) {
|
||||
dbg_err("not enough PEBs: requested %d, available %d",
|
||||
pebs, ubi->avail_pebs);
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
err = -ENOSPC;
|
||||
goto out_free;
|
||||
}
|
||||
ubi->avail_pebs -= pebs;
|
||||
ubi->rsvd_pebs += pebs;
|
||||
for (i = 0; i < vol->reserved_pebs; i++)
|
||||
new_mapping[i] = vol->eba_tbl[i];
|
||||
kfree(vol->eba_tbl);
|
||||
vol->eba_tbl = new_mapping;
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
}
|
||||
|
||||
/* Change volume table record */
|
||||
memcpy(&vtbl_rec, &ubi->vtbl[vol_id], sizeof(struct ubi_vtbl_record));
|
||||
vtbl_rec.reserved_pebs = cpu_to_be32(reserved_pebs);
|
||||
err = ubi_change_vtbl_record(ubi, vol_id, &vtbl_rec);
|
||||
if (err)
|
||||
goto out_acc;
|
||||
|
||||
if (pebs < 0) {
|
||||
for (i = 0; i < -pebs; i++) {
|
||||
err = ubi_eba_unmap_leb(ubi, vol, reserved_pebs + i);
|
||||
if (err)
|
||||
goto out_acc;
|
||||
}
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
ubi->rsvd_pebs += pebs;
|
||||
ubi->avail_pebs -= pebs;
|
||||
pebs = ubi->beb_rsvd_level - ubi->beb_rsvd_pebs;
|
||||
if (pebs > 0) {
|
||||
pebs = ubi->avail_pebs >= pebs ? pebs : ubi->avail_pebs;
|
||||
ubi->avail_pebs -= pebs;
|
||||
ubi->rsvd_pebs += pebs;
|
||||
ubi->beb_rsvd_pebs += pebs;
|
||||
if (pebs > 0)
|
||||
ubi_msg("reserve more %d PEBs", pebs);
|
||||
}
|
||||
for (i = 0; i < reserved_pebs; i++)
|
||||
new_mapping[i] = vol->eba_tbl[i];
|
||||
kfree(vol->eba_tbl);
|
||||
vol->eba_tbl = new_mapping;
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
}
|
||||
|
||||
vol->reserved_pebs = reserved_pebs;
|
||||
if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
|
||||
vol->used_ebs = reserved_pebs;
|
||||
vol->last_eb_bytes = vol->usable_leb_size;
|
||||
vol->used_bytes =
|
||||
(long long)vol->used_ebs * vol->usable_leb_size;
|
||||
}
|
||||
|
||||
paranoid_check_volumes(ubi);
|
||||
return 0;
|
||||
|
||||
out_acc:
|
||||
if (pebs > 0) {
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
ubi->rsvd_pebs -= pebs;
|
||||
ubi->avail_pebs += pebs;
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
}
|
||||
out_free:
|
||||
kfree(new_mapping);
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_add_volume - add volume.
|
||||
* @ubi: UBI device description object
|
||||
* @vol: volume description object
|
||||
*
|
||||
* This function adds an existing volume and initializes all its data
|
||||
* structures. Returns zero in case of success and a negative error code in
|
||||
* case of failure.
|
||||
*/
|
||||
int ubi_add_volume(struct ubi_device *ubi, struct ubi_volume *vol)
|
||||
{
|
||||
int err, vol_id = vol->vol_id;
|
||||
dev_t dev;
|
||||
|
||||
dbg_msg("add volume %d", vol_id);
|
||||
ubi_dbg_dump_vol_info(vol);
|
||||
|
||||
/* Register character device for the volume */
|
||||
cdev_init(&vol->cdev, &ubi_vol_cdev_operations);
|
||||
#ifdef UBI_LINUX
|
||||
vol->cdev.owner = THIS_MODULE;
|
||||
#endif
|
||||
dev = MKDEV(MAJOR(ubi->cdev.dev), vol->vol_id + 1);
|
||||
err = ubi_volume_cdev_add(ubi, vol);
|
||||
if (err) {
|
||||
ubi_err("cannot add character device for volume %d, error %d",
|
||||
vol_id, err);
|
||||
return err;
|
||||
}
|
||||
|
||||
err = ubi_create_gluebi(ubi, vol);
|
||||
if (err)
|
||||
goto out_cdev;
|
||||
|
||||
vol->dev.release = vol_release;
|
||||
vol->dev.parent = &ubi->dev;
|
||||
vol->dev.devt = dev;
|
||||
vol->dev.class = ubi_class;
|
||||
sprintf(&vol->dev.bus_id[0], "%s_%d", ubi->ubi_name, vol->vol_id);
|
||||
err = device_register(&vol->dev);
|
||||
if (err)
|
||||
goto out_gluebi;
|
||||
|
||||
err = volume_sysfs_init(ubi, vol);
|
||||
if (err) {
|
||||
ubi_volume_cdev_remove(vol);
|
||||
err = ubi_destroy_gluebi(vol);
|
||||
volume_sysfs_close(vol);
|
||||
return err;
|
||||
}
|
||||
|
||||
paranoid_check_volumes(ubi);
|
||||
return 0;
|
||||
|
||||
out_gluebi:
|
||||
err = ubi_destroy_gluebi(vol);
|
||||
out_cdev:
|
||||
ubi_volume_cdev_remove(vol);
|
||||
return err;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_free_volume - free volume.
|
||||
* @ubi: UBI device description object
|
||||
* @vol: volume description object
|
||||
*
|
||||
* This function frees all resources for volume @vol but does not remove it.
|
||||
* Used only when the UBI device is detached.
|
||||
*/
|
||||
void ubi_free_volume(struct ubi_device *ubi, struct ubi_volume *vol)
|
||||
{
|
||||
int err;
|
||||
|
||||
dbg_msg("free volume %d", vol->vol_id);
|
||||
|
||||
ubi->volumes[vol->vol_id] = NULL;
|
||||
err = ubi_destroy_gluebi(vol);
|
||||
ubi_volume_cdev_remove(vol);
|
||||
volume_sysfs_close(vol);
|
||||
}
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
|
||||
|
||||
/**
|
||||
* paranoid_check_volume - check volume information.
|
||||
* @ubi: UBI device description object
|
||||
* @vol_id: volume ID
|
||||
*/
|
||||
static void paranoid_check_volume(struct ubi_device *ubi, int vol_id)
|
||||
{
|
||||
int idx = vol_id2idx(ubi, vol_id);
|
||||
int reserved_pebs, alignment, data_pad, vol_type, name_len, upd_marker;
|
||||
const struct ubi_volume *vol;
|
||||
long long n;
|
||||
const char *name;
|
||||
|
||||
spin_lock(&ubi->volumes_lock);
|
||||
reserved_pebs = be32_to_cpu(ubi->vtbl[vol_id].reserved_pebs);
|
||||
vol = ubi->volumes[idx];
|
||||
|
||||
if (!vol) {
|
||||
if (reserved_pebs) {
|
||||
ubi_err("no volume info, but volume exists");
|
||||
goto fail;
|
||||
}
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
return;
|
||||
}
|
||||
|
||||
if (vol->exclusive) {
|
||||
/*
|
||||
* The volume may be being created at the moment, do not check
|
||||
* it (e.g., it may be in the middle of ubi_create_volume().
|
||||
*/
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
return;
|
||||
}
|
||||
|
||||
if (vol->reserved_pebs < 0 || vol->alignment < 0 || vol->data_pad < 0 ||
|
||||
vol->name_len < 0) {
|
||||
ubi_err("negative values");
|
||||
goto fail;
|
||||
}
|
||||
if (vol->alignment > ubi->leb_size || vol->alignment == 0) {
|
||||
ubi_err("bad alignment");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
n = vol->alignment & (ubi->min_io_size - 1);
|
||||
if (vol->alignment != 1 && n) {
|
||||
ubi_err("alignment is not multiple of min I/O unit");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
n = ubi->leb_size % vol->alignment;
|
||||
if (vol->data_pad != n) {
|
||||
ubi_err("bad data_pad, has to be %lld", n);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (vol->vol_type != UBI_DYNAMIC_VOLUME &&
|
||||
vol->vol_type != UBI_STATIC_VOLUME) {
|
||||
ubi_err("bad vol_type");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (vol->upd_marker && vol->corrupted) {
|
||||
dbg_err("update marker and corrupted simultaneously");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (vol->reserved_pebs > ubi->good_peb_count) {
|
||||
ubi_err("too large reserved_pebs");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
n = ubi->leb_size - vol->data_pad;
|
||||
if (vol->usable_leb_size != ubi->leb_size - vol->data_pad) {
|
||||
ubi_err("bad usable_leb_size, has to be %lld", n);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (vol->name_len > UBI_VOL_NAME_MAX) {
|
||||
ubi_err("too long volume name, max is %d", UBI_VOL_NAME_MAX);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
if (!vol->name) {
|
||||
ubi_err("NULL volume name");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
n = strnlen(vol->name, vol->name_len + 1);
|
||||
if (n != vol->name_len) {
|
||||
ubi_err("bad name_len %lld", n);
|
||||
goto fail;
|
||||
}
|
||||
|
||||
n = (long long)vol->used_ebs * vol->usable_leb_size;
|
||||
if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
|
||||
if (vol->corrupted) {
|
||||
ubi_err("corrupted dynamic volume");
|
||||
goto fail;
|
||||
}
|
||||
if (vol->used_ebs != vol->reserved_pebs) {
|
||||
ubi_err("bad used_ebs");
|
||||
goto fail;
|
||||
}
|
||||
if (vol->last_eb_bytes != vol->usable_leb_size) {
|
||||
ubi_err("bad last_eb_bytes");
|
||||
goto fail;
|
||||
}
|
||||
if (vol->used_bytes != n) {
|
||||
ubi_err("bad used_bytes");
|
||||
goto fail;
|
||||
}
|
||||
} else {
|
||||
if (vol->used_ebs < 0 || vol->used_ebs > vol->reserved_pebs) {
|
||||
ubi_err("bad used_ebs");
|
||||
goto fail;
|
||||
}
|
||||
if (vol->last_eb_bytes < 0 ||
|
||||
vol->last_eb_bytes > vol->usable_leb_size) {
|
||||
ubi_err("bad last_eb_bytes");
|
||||
goto fail;
|
||||
}
|
||||
if (vol->used_bytes < 0 || vol->used_bytes > n ||
|
||||
vol->used_bytes < n - vol->usable_leb_size) {
|
||||
ubi_err("bad used_bytes");
|
||||
goto fail;
|
||||
}
|
||||
}
|
||||
|
||||
alignment = be32_to_cpu(ubi->vtbl[vol_id].alignment);
|
||||
data_pad = be32_to_cpu(ubi->vtbl[vol_id].data_pad);
|
||||
name_len = be16_to_cpu(ubi->vtbl[vol_id].name_len);
|
||||
upd_marker = ubi->vtbl[vol_id].upd_marker;
|
||||
name = &ubi->vtbl[vol_id].name[0];
|
||||
if (ubi->vtbl[vol_id].vol_type == UBI_VID_DYNAMIC)
|
||||
vol_type = UBI_DYNAMIC_VOLUME;
|
||||
else
|
||||
vol_type = UBI_STATIC_VOLUME;
|
||||
|
||||
if (alignment != vol->alignment || data_pad != vol->data_pad ||
|
||||
upd_marker != vol->upd_marker || vol_type != vol->vol_type ||
|
||||
name_len!= vol->name_len || strncmp(name, vol->name, name_len)) {
|
||||
ubi_err("volume info is different");
|
||||
goto fail;
|
||||
}
|
||||
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
return;
|
||||
|
||||
fail:
|
||||
ubi_err("paranoid check failed for volume %d", vol_id);
|
||||
ubi_dbg_dump_vol_info(vol);
|
||||
ubi_dbg_dump_vtbl_record(&ubi->vtbl[vol_id], vol_id);
|
||||
spin_unlock(&ubi->volumes_lock);
|
||||
BUG();
|
||||
}
|
||||
|
||||
/**
|
||||
* paranoid_check_volumes - check information about all volumes.
|
||||
* @ubi: UBI device description object
|
||||
*/
|
||||
static void paranoid_check_volumes(struct ubi_device *ubi)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ubi->vtbl_slots; i++)
|
||||
paranoid_check_volume(ubi, i);
|
||||
}
|
||||
#endif
|
|
@ -1,834 +0,0 @@
|
|||
/*
|
||||
* Copyright (c) International Business Machines Corp., 2006
|
||||
* Copyright (c) Nokia Corporation, 2006, 2007
|
||||
*
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* Author: Artem Bityutskiy (Битюцкий Артём)
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file includes volume table manipulation code. The volume table is an
|
||||
* on-flash table containing volume meta-data like name, number of reserved
|
||||
* physical eraseblocks, type, etc. The volume table is stored in the so-called
|
||||
* "layout volume".
|
||||
*
|
||||
* The layout volume is an internal volume which is organized as follows. It
|
||||
* consists of two logical eraseblocks - LEB 0 and LEB 1. Each logical
|
||||
* eraseblock stores one volume table copy, i.e. LEB 0 and LEB 1 duplicate each
|
||||
* other. This redundancy guarantees robustness to unclean reboots. The volume
|
||||
* table is basically an array of volume table records. Each record contains
|
||||
* full information about the volume and protected by a CRC checksum.
|
||||
*
|
||||
* The volume table is changed, it is first changed in RAM. Then LEB 0 is
|
||||
* erased, and the updated volume table is written back to LEB 0. Then same for
|
||||
* LEB 1. This scheme guarantees recoverability from unclean reboots.
|
||||
*
|
||||
* In this UBI implementation the on-flash volume table does not contain any
|
||||
* information about how many data static volumes contain. This information may
|
||||
* be found from the scanning data.
|
||||
*
|
||||
* But it would still be beneficial to store this information in the volume
|
||||
* table. For example, suppose we have a static volume X, and all its physical
|
||||
* eraseblocks became bad for some reasons. Suppose we are attaching the
|
||||
* corresponding MTD device, the scanning has found no logical eraseblocks
|
||||
* corresponding to the volume X. According to the volume table volume X does
|
||||
* exist. So we don't know whether it is just empty or all its physical
|
||||
* eraseblocks went bad. So we cannot alarm the user about this corruption.
|
||||
*
|
||||
* The volume table also stores so-called "update marker", which is used for
|
||||
* volume updates. Before updating the volume, the update marker is set, and
|
||||
* after the update operation is finished, the update marker is cleared. So if
|
||||
* the update operation was interrupted (e.g. by an unclean reboot) - the
|
||||
* update marker is still there and we know that the volume's contents is
|
||||
* damaged.
|
||||
*/
|
||||
|
||||
#ifdef UBI_LINUX
|
||||
#include <linux/crc32.h>
|
||||
#include <linux/err.h>
|
||||
#include <asm/div64.h>
|
||||
#endif
|
||||
|
||||
#include "ubi-barebox.h"
|
||||
#include "ubi.h"
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
|
||||
static void paranoid_vtbl_check(const struct ubi_device *ubi);
|
||||
#else
|
||||
#define paranoid_vtbl_check(ubi)
|
||||
#endif
|
||||
|
||||
/* Empty volume table record */
|
||||
static struct ubi_vtbl_record empty_vtbl_record;
|
||||
|
||||
/**
|
||||
* ubi_change_vtbl_record - change volume table record.
|
||||
* @ubi: UBI device description object
|
||||
* @idx: table index to change
|
||||
* @vtbl_rec: new volume table record
|
||||
*
|
||||
* This function changes volume table record @idx. If @vtbl_rec is %NULL, empty
|
||||
* volume table record is written. The caller does not have to calculate CRC of
|
||||
* the record as it is done by this function. Returns zero in case of success
|
||||
* and a negative error code in case of failure.
|
||||
*/
|
||||
int ubi_change_vtbl_record(struct ubi_device *ubi, int idx,
|
||||
struct ubi_vtbl_record *vtbl_rec)
|
||||
{
|
||||
int i, err;
|
||||
uint32_t crc;
|
||||
struct ubi_volume *layout_vol;
|
||||
|
||||
ubi_assert(idx >= 0 && idx < ubi->vtbl_slots);
|
||||
layout_vol = ubi->volumes[vol_id2idx(ubi, UBI_LAYOUT_VOLUME_ID)];
|
||||
|
||||
if (!vtbl_rec)
|
||||
vtbl_rec = &empty_vtbl_record;
|
||||
else {
|
||||
crc = crc32(UBI_CRC32_INIT, vtbl_rec, UBI_VTBL_RECORD_SIZE_CRC);
|
||||
vtbl_rec->crc = cpu_to_be32(crc);
|
||||
}
|
||||
|
||||
memcpy(&ubi->vtbl[idx], vtbl_rec, sizeof(struct ubi_vtbl_record));
|
||||
for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {
|
||||
err = ubi_eba_unmap_leb(ubi, layout_vol, i);
|
||||
if (err)
|
||||
return err;
|
||||
|
||||
err = ubi_eba_write_leb(ubi, layout_vol, i, ubi->vtbl, 0,
|
||||
ubi->vtbl_size, UBI_LONGTERM);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
|
||||
paranoid_vtbl_check(ubi);
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* vtbl_check - check if volume table is not corrupted and contains sensible
|
||||
* data.
|
||||
* @ubi: UBI device description object
|
||||
* @vtbl: volume table
|
||||
*
|
||||
* This function returns zero if @vtbl is all right, %1 if CRC is incorrect,
|
||||
* and %-EINVAL if it contains inconsistent data.
|
||||
*/
|
||||
static int vtbl_check(const struct ubi_device *ubi,
|
||||
const struct ubi_vtbl_record *vtbl)
|
||||
{
|
||||
int i, n, reserved_pebs, alignment, data_pad, vol_type, name_len;
|
||||
int upd_marker, err;
|
||||
uint32_t crc;
|
||||
const char *name;
|
||||
|
||||
for (i = 0; i < ubi->vtbl_slots; i++) {
|
||||
cond_resched();
|
||||
|
||||
reserved_pebs = be32_to_cpu(vtbl[i].reserved_pebs);
|
||||
alignment = be32_to_cpu(vtbl[i].alignment);
|
||||
data_pad = be32_to_cpu(vtbl[i].data_pad);
|
||||
upd_marker = vtbl[i].upd_marker;
|
||||
vol_type = vtbl[i].vol_type;
|
||||
name_len = be16_to_cpu(vtbl[i].name_len);
|
||||
name = (const char *) &vtbl[i].name[0];
|
||||
|
||||
crc = crc32(UBI_CRC32_INIT, &vtbl[i], UBI_VTBL_RECORD_SIZE_CRC);
|
||||
if (be32_to_cpu(vtbl[i].crc) != crc) {
|
||||
ubi_err("bad CRC at record %u: %#08x, not %#08x",
|
||||
i, crc, be32_to_cpu(vtbl[i].crc));
|
||||
ubi_dbg_dump_vtbl_record(&vtbl[i], i);
|
||||
return 1;
|
||||
}
|
||||
|
||||
if (reserved_pebs == 0) {
|
||||
if (memcmp(&vtbl[i], &empty_vtbl_record,
|
||||
UBI_VTBL_RECORD_SIZE)) {
|
||||
err = 2;
|
||||
goto bad;
|
||||
}
|
||||
continue;
|
||||
}
|
||||
|
||||
if (reserved_pebs < 0 || alignment < 0 || data_pad < 0 ||
|
||||
name_len < 0) {
|
||||
err = 3;
|
||||
goto bad;
|
||||
}
|
||||
|
||||
if (alignment > ubi->leb_size || alignment == 0) {
|
||||
err = 4;
|
||||
goto bad;
|
||||
}
|
||||
|
||||
n = alignment & (ubi->min_io_size - 1);
|
||||
if (alignment != 1 && n) {
|
||||
err = 5;
|
||||
goto bad;
|
||||
}
|
||||
|
||||
n = ubi->leb_size % alignment;
|
||||
if (data_pad != n) {
|
||||
dbg_err("bad data_pad, has to be %d", n);
|
||||
err = 6;
|
||||
goto bad;
|
||||
}
|
||||
|
||||
if (vol_type != UBI_VID_DYNAMIC && vol_type != UBI_VID_STATIC) {
|
||||
err = 7;
|
||||
goto bad;
|
||||
}
|
||||
|
||||
if (upd_marker != 0 && upd_marker != 1) {
|
||||
err = 8;
|
||||
goto bad;
|
||||
}
|
||||
|
||||
if (reserved_pebs > ubi->good_peb_count) {
|
||||
dbg_err("too large reserved_pebs, good PEBs %d",
|
||||
ubi->good_peb_count);
|
||||
err = 9;
|
||||
goto bad;
|
||||
}
|
||||
|
||||
if (name_len > UBI_VOL_NAME_MAX) {
|
||||
err = 10;
|
||||
goto bad;
|
||||
}
|
||||
|
||||
if (name[0] == '\0') {
|
||||
err = 11;
|
||||
goto bad;
|
||||
}
|
||||
|
||||
if (name_len != strnlen(name, name_len + 1)) {
|
||||
err = 12;
|
||||
goto bad;
|
||||
}
|
||||
}
|
||||
|
||||
/* Checks that all names are unique */
|
||||
for (i = 0; i < ubi->vtbl_slots - 1; i++) {
|
||||
for (n = i + 1; n < ubi->vtbl_slots; n++) {
|
||||
int len1 = be16_to_cpu(vtbl[i].name_len);
|
||||
int len2 = be16_to_cpu(vtbl[n].name_len);
|
||||
|
||||
if (len1 > 0 && len1 == len2 &&
|
||||
!strncmp((char *)vtbl[i].name, (char *)vtbl[n].name, len1)) {
|
||||
ubi_err("volumes %d and %d have the same name"
|
||||
" \"%s\"", i, n, vtbl[i].name);
|
||||
ubi_dbg_dump_vtbl_record(&vtbl[i], i);
|
||||
ubi_dbg_dump_vtbl_record(&vtbl[n], n);
|
||||
return -EINVAL;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
|
||||
bad:
|
||||
ubi_err("volume table check failed: record %d, error %d", i, err);
|
||||
ubi_dbg_dump_vtbl_record(&vtbl[i], i);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* create_vtbl - create a copy of volume table.
|
||||
* @ubi: UBI device description object
|
||||
* @si: scanning information
|
||||
* @copy: number of the volume table copy
|
||||
* @vtbl: contents of the volume table
|
||||
*
|
||||
* This function returns zero in case of success and a negative error code in
|
||||
* case of failure.
|
||||
*/
|
||||
static int create_vtbl(struct ubi_device *ubi, struct ubi_scan_info *si,
|
||||
int copy, void *vtbl)
|
||||
{
|
||||
int err, tries = 0;
|
||||
static struct ubi_vid_hdr *vid_hdr;
|
||||
struct ubi_scan_volume *sv;
|
||||
struct ubi_scan_leb *new_seb, *old_seb = NULL;
|
||||
|
||||
ubi_msg("create volume table (copy #%d)", copy + 1);
|
||||
|
||||
vid_hdr = ubi_zalloc_vid_hdr(ubi, GFP_KERNEL);
|
||||
if (!vid_hdr)
|
||||
return -ENOMEM;
|
||||
|
||||
/*
|
||||
* Check if there is a logical eraseblock which would have to contain
|
||||
* this volume table copy was found during scanning. It has to be wiped
|
||||
* out.
|
||||
*/
|
||||
sv = ubi_scan_find_sv(si, UBI_LAYOUT_VOLUME_ID);
|
||||
if (sv)
|
||||
old_seb = ubi_scan_find_seb(sv, copy);
|
||||
|
||||
retry:
|
||||
new_seb = ubi_scan_get_free_peb(ubi, si);
|
||||
if (IS_ERR(new_seb)) {
|
||||
err = PTR_ERR(new_seb);
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
vid_hdr->vol_type = UBI_VID_DYNAMIC;
|
||||
vid_hdr->vol_id = cpu_to_be32(UBI_LAYOUT_VOLUME_ID);
|
||||
vid_hdr->compat = UBI_LAYOUT_VOLUME_COMPAT;
|
||||
vid_hdr->data_size = vid_hdr->used_ebs =
|
||||
vid_hdr->data_pad = cpu_to_be32(0);
|
||||
vid_hdr->lnum = cpu_to_be32(copy);
|
||||
vid_hdr->sqnum = cpu_to_be64(++si->max_sqnum);
|
||||
vid_hdr->leb_ver = cpu_to_be32(old_seb ? old_seb->leb_ver + 1: 0);
|
||||
|
||||
/* The EC header is already there, write the VID header */
|
||||
err = ubi_io_write_vid_hdr(ubi, new_seb->pnum, vid_hdr);
|
||||
if (err)
|
||||
goto write_error;
|
||||
|
||||
/* Write the layout volume contents */
|
||||
err = ubi_io_write_data(ubi, vtbl, new_seb->pnum, 0, ubi->vtbl_size);
|
||||
if (err)
|
||||
goto write_error;
|
||||
|
||||
/*
|
||||
* And add it to the scanning information. Don't delete the old
|
||||
* @old_seb as it will be deleted and freed in 'ubi_scan_add_used()'.
|
||||
*/
|
||||
err = ubi_scan_add_used(ubi, si, new_seb->pnum, new_seb->ec,
|
||||
vid_hdr, 0);
|
||||
kfree(new_seb);
|
||||
ubi_free_vid_hdr(ubi, vid_hdr);
|
||||
return err;
|
||||
|
||||
write_error:
|
||||
if (err == -EIO && ++tries <= 5) {
|
||||
/*
|
||||
* Probably this physical eraseblock went bad, try to pick
|
||||
* another one.
|
||||
*/
|
||||
list_add_tail(&new_seb->u.list, &si->corr);
|
||||
goto retry;
|
||||
}
|
||||
kfree(new_seb);
|
||||
out_free:
|
||||
ubi_free_vid_hdr(ubi, vid_hdr);
|
||||
return err;
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* process_lvol - process the layout volume.
|
||||
* @ubi: UBI device description object
|
||||
* @si: scanning information
|
||||
* @sv: layout volume scanning information
|
||||
*
|
||||
* This function is responsible for reading the layout volume, ensuring it is
|
||||
* not corrupted, and recovering from corruptions if needed. Returns volume
|
||||
* table in case of success and a negative error code in case of failure.
|
||||
*/
|
||||
static struct ubi_vtbl_record *process_lvol(struct ubi_device *ubi,
|
||||
struct ubi_scan_info *si,
|
||||
struct ubi_scan_volume *sv)
|
||||
{
|
||||
int err;
|
||||
struct rb_node *rb;
|
||||
struct ubi_scan_leb *seb;
|
||||
struct ubi_vtbl_record *leb[UBI_LAYOUT_VOLUME_EBS] = { NULL, NULL };
|
||||
int leb_corrupted[UBI_LAYOUT_VOLUME_EBS] = {1, 1};
|
||||
|
||||
/*
|
||||
* UBI goes through the following steps when it changes the layout
|
||||
* volume:
|
||||
* a. erase LEB 0;
|
||||
* b. write new data to LEB 0;
|
||||
* c. erase LEB 1;
|
||||
* d. write new data to LEB 1.
|
||||
*
|
||||
* Before the change, both LEBs contain the same data.
|
||||
*
|
||||
* Due to unclean reboots, the contents of LEB 0 may be lost, but there
|
||||
* should LEB 1. So it is OK if LEB 0 is corrupted while LEB 1 is not.
|
||||
* Similarly, LEB 1 may be lost, but there should be LEB 0. And
|
||||
* finally, unclean reboots may result in a situation when neither LEB
|
||||
* 0 nor LEB 1 are corrupted, but they are different. In this case, LEB
|
||||
* 0 contains more recent information.
|
||||
*
|
||||
* So the plan is to first check LEB 0. Then
|
||||
* a. if LEB 0 is OK, it must be containing the most resent data; then
|
||||
* we compare it with LEB 1, and if they are different, we copy LEB
|
||||
* 0 to LEB 1;
|
||||
* b. if LEB 0 is corrupted, but LEB 1 has to be OK, and we copy LEB 1
|
||||
* to LEB 0.
|
||||
*/
|
||||
|
||||
dbg_msg("check layout volume");
|
||||
|
||||
/* Read both LEB 0 and LEB 1 into memory */
|
||||
ubi_rb_for_each_entry(rb, seb, &sv->root, u.rb) {
|
||||
leb[seb->lnum] = vmalloc(ubi->vtbl_size);
|
||||
if (!leb[seb->lnum]) {
|
||||
err = -ENOMEM;
|
||||
goto out_free;
|
||||
}
|
||||
memset(leb[seb->lnum], 0, ubi->vtbl_size);
|
||||
|
||||
err = ubi_io_read_data(ubi, leb[seb->lnum], seb->pnum, 0,
|
||||
ubi->vtbl_size);
|
||||
if (err == UBI_IO_BITFLIPS || err == -EBADMSG)
|
||||
/*
|
||||
* Scrub the PEB later. Note, -EBADMSG indicates an
|
||||
* uncorrectable ECC error, but we have our own CRC and
|
||||
* the data will be checked later. If the data is OK,
|
||||
* the PEB will be scrubbed (because we set
|
||||
* seb->scrub). If the data is not OK, the contents of
|
||||
* the PEB will be recovered from the second copy, and
|
||||
* seb->scrub will be cleared in
|
||||
* 'ubi_scan_add_used()'.
|
||||
*/
|
||||
seb->scrub = 1;
|
||||
else if (err)
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
err = -EINVAL;
|
||||
if (leb[0]) {
|
||||
leb_corrupted[0] = vtbl_check(ubi, leb[0]);
|
||||
if (leb_corrupted[0] < 0)
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
if (!leb_corrupted[0]) {
|
||||
/* LEB 0 is OK */
|
||||
if (leb[1])
|
||||
leb_corrupted[1] = memcmp(leb[0], leb[1], ubi->vtbl_size);
|
||||
if (leb_corrupted[1]) {
|
||||
ubi_warn("volume table copy #2 is corrupted");
|
||||
err = create_vtbl(ubi, si, 1, leb[0]);
|
||||
if (err)
|
||||
goto out_free;
|
||||
ubi_msg("volume table was restored");
|
||||
}
|
||||
|
||||
/* Both LEB 1 and LEB 2 are OK and consistent */
|
||||
vfree(leb[1]);
|
||||
return leb[0];
|
||||
} else {
|
||||
/* LEB 0 is corrupted or does not exist */
|
||||
if (leb[1]) {
|
||||
leb_corrupted[1] = vtbl_check(ubi, leb[1]);
|
||||
if (leb_corrupted[1] < 0)
|
||||
goto out_free;
|
||||
}
|
||||
if (leb_corrupted[1]) {
|
||||
/* Both LEB 0 and LEB 1 are corrupted */
|
||||
ubi_err("both volume tables are corrupted");
|
||||
goto out_free;
|
||||
}
|
||||
|
||||
ubi_warn("volume table copy #1 is corrupted");
|
||||
err = create_vtbl(ubi, si, 0, leb[1]);
|
||||
if (err)
|
||||
goto out_free;
|
||||
ubi_msg("volume table was restored");
|
||||
|
||||
vfree(leb[0]);
|
||||
return leb[1];
|
||||
}
|
||||
|
||||
out_free:
|
||||
vfree(leb[0]);
|
||||
vfree(leb[1]);
|
||||
return ERR_PTR(err);
|
||||
}
|
||||
|
||||
/**
|
||||
* create_empty_lvol - create empty layout volume.
|
||||
* @ubi: UBI device description object
|
||||
* @si: scanning information
|
||||
*
|
||||
* This function returns volume table contents in case of success and a
|
||||
* negative error code in case of failure.
|
||||
*/
|
||||
static struct ubi_vtbl_record *create_empty_lvol(struct ubi_device *ubi,
|
||||
struct ubi_scan_info *si)
|
||||
{
|
||||
int i;
|
||||
struct ubi_vtbl_record *vtbl;
|
||||
|
||||
vtbl = vmalloc(ubi->vtbl_size);
|
||||
if (!vtbl)
|
||||
return ERR_PTR(-ENOMEM);
|
||||
memset(vtbl, 0, ubi->vtbl_size);
|
||||
|
||||
for (i = 0; i < ubi->vtbl_slots; i++)
|
||||
memcpy(&vtbl[i], &empty_vtbl_record, UBI_VTBL_RECORD_SIZE);
|
||||
|
||||
for (i = 0; i < UBI_LAYOUT_VOLUME_EBS; i++) {
|
||||
int err;
|
||||
|
||||
err = create_vtbl(ubi, si, i, vtbl);
|
||||
if (err) {
|
||||
vfree(vtbl);
|
||||
return ERR_PTR(err);
|
||||
}
|
||||
}
|
||||
|
||||
return vtbl;
|
||||
}
|
||||
|
||||
/**
|
||||
* init_volumes - initialize volume information for existing volumes.
|
||||
* @ubi: UBI device description object
|
||||
* @si: scanning information
|
||||
* @vtbl: volume table
|
||||
*
|
||||
* This function allocates volume description objects for existing volumes.
|
||||
* Returns zero in case of success and a negative error code in case of
|
||||
* failure.
|
||||
*/
|
||||
static int init_volumes(struct ubi_device *ubi, const struct ubi_scan_info *si,
|
||||
const struct ubi_vtbl_record *vtbl)
|
||||
{
|
||||
int i, reserved_pebs = 0;
|
||||
struct ubi_scan_volume *sv;
|
||||
struct ubi_volume *vol;
|
||||
|
||||
for (i = 0; i < ubi->vtbl_slots; i++) {
|
||||
cond_resched();
|
||||
|
||||
if (be32_to_cpu(vtbl[i].reserved_pebs) == 0)
|
||||
continue; /* Empty record */
|
||||
|
||||
vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
|
||||
if (!vol)
|
||||
return -ENOMEM;
|
||||
|
||||
vol->reserved_pebs = be32_to_cpu(vtbl[i].reserved_pebs);
|
||||
vol->alignment = be32_to_cpu(vtbl[i].alignment);
|
||||
vol->data_pad = be32_to_cpu(vtbl[i].data_pad);
|
||||
vol->vol_type = vtbl[i].vol_type == UBI_VID_DYNAMIC ?
|
||||
UBI_DYNAMIC_VOLUME : UBI_STATIC_VOLUME;
|
||||
vol->name_len = be16_to_cpu(vtbl[i].name_len);
|
||||
vol->usable_leb_size = ubi->leb_size - vol->data_pad;
|
||||
memcpy(vol->name, vtbl[i].name, vol->name_len);
|
||||
vol->name[vol->name_len] = '\0';
|
||||
vol->vol_id = i;
|
||||
|
||||
if (vtbl[i].flags & UBI_VTBL_AUTORESIZE_FLG) {
|
||||
/* Auto re-size flag may be set only for one volume */
|
||||
if (ubi->autoresize_vol_id != -1) {
|
||||
ubi_err("more then one auto-resize volume (%d "
|
||||
"and %d)", ubi->autoresize_vol_id, i);
|
||||
kfree(vol);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ubi->autoresize_vol_id = i;
|
||||
}
|
||||
|
||||
ubi_assert(!ubi->volumes[i]);
|
||||
ubi->volumes[i] = vol;
|
||||
ubi->vol_count += 1;
|
||||
vol->ubi = ubi;
|
||||
reserved_pebs += vol->reserved_pebs;
|
||||
|
||||
/*
|
||||
* In case of dynamic volume UBI knows nothing about how many
|
||||
* data is stored there. So assume the whole volume is used.
|
||||
*/
|
||||
if (vol->vol_type == UBI_DYNAMIC_VOLUME) {
|
||||
vol->used_ebs = vol->reserved_pebs;
|
||||
vol->last_eb_bytes = vol->usable_leb_size;
|
||||
vol->used_bytes =
|
||||
(long long)vol->used_ebs * vol->usable_leb_size;
|
||||
continue;
|
||||
}
|
||||
|
||||
/* Static volumes only */
|
||||
sv = ubi_scan_find_sv(si, i);
|
||||
if (!sv) {
|
||||
/*
|
||||
* No eraseblocks belonging to this volume found. We
|
||||
* don't actually know whether this static volume is
|
||||
* completely corrupted or just contains no data. And
|
||||
* we cannot know this as long as data size is not
|
||||
* stored on flash. So we just assume the volume is
|
||||
* empty. FIXME: this should be handled.
|
||||
*/
|
||||
continue;
|
||||
}
|
||||
|
||||
if (sv->leb_count != sv->used_ebs) {
|
||||
/*
|
||||
* We found a static volume which misses several
|
||||
* eraseblocks. Treat it as corrupted.
|
||||
*/
|
||||
ubi_warn("static volume %d misses %d LEBs - corrupted",
|
||||
sv->vol_id, sv->used_ebs - sv->leb_count);
|
||||
vol->corrupted = 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
vol->used_ebs = sv->used_ebs;
|
||||
vol->used_bytes =
|
||||
(long long)(vol->used_ebs - 1) * vol->usable_leb_size;
|
||||
vol->used_bytes += sv->last_data_size;
|
||||
vol->last_eb_bytes = sv->last_data_size;
|
||||
}
|
||||
|
||||
/* And add the layout volume */
|
||||
vol = kzalloc(sizeof(struct ubi_volume), GFP_KERNEL);
|
||||
if (!vol)
|
||||
return -ENOMEM;
|
||||
|
||||
vol->reserved_pebs = UBI_LAYOUT_VOLUME_EBS;
|
||||
vol->alignment = 1;
|
||||
vol->vol_type = UBI_DYNAMIC_VOLUME;
|
||||
vol->name_len = sizeof(UBI_LAYOUT_VOLUME_NAME) - 1;
|
||||
memcpy(vol->name, UBI_LAYOUT_VOLUME_NAME, vol->name_len + 1);
|
||||
vol->usable_leb_size = ubi->leb_size;
|
||||
vol->used_ebs = vol->reserved_pebs;
|
||||
vol->last_eb_bytes = vol->reserved_pebs;
|
||||
vol->used_bytes =
|
||||
(long long)vol->used_ebs * (ubi->leb_size - vol->data_pad);
|
||||
vol->vol_id = UBI_LAYOUT_VOLUME_ID;
|
||||
vol->ref_count = 1;
|
||||
|
||||
ubi_assert(!ubi->volumes[i]);
|
||||
ubi->volumes[vol_id2idx(ubi, vol->vol_id)] = vol;
|
||||
reserved_pebs += vol->reserved_pebs;
|
||||
ubi->vol_count += 1;
|
||||
vol->ubi = ubi;
|
||||
|
||||
if (reserved_pebs > ubi->avail_pebs)
|
||||
ubi_err("not enough PEBs, required %d, available %d",
|
||||
reserved_pebs, ubi->avail_pebs);
|
||||
ubi->rsvd_pebs += reserved_pebs;
|
||||
ubi->avail_pebs -= reserved_pebs;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* check_sv - check volume scanning information.
|
||||
* @vol: UBI volume description object
|
||||
* @sv: volume scanning information
|
||||
*
|
||||
* This function returns zero if the volume scanning information is consistent
|
||||
* to the data read from the volume tabla, and %-EINVAL if not.
|
||||
*/
|
||||
static int check_sv(const struct ubi_volume *vol,
|
||||
const struct ubi_scan_volume *sv)
|
||||
{
|
||||
int err;
|
||||
|
||||
if (sv->highest_lnum >= vol->reserved_pebs) {
|
||||
err = 1;
|
||||
goto bad;
|
||||
}
|
||||
if (sv->leb_count > vol->reserved_pebs) {
|
||||
err = 2;
|
||||
goto bad;
|
||||
}
|
||||
if (sv->vol_type != vol->vol_type) {
|
||||
err = 3;
|
||||
goto bad;
|
||||
}
|
||||
if (sv->used_ebs > vol->reserved_pebs) {
|
||||
err = 4;
|
||||
goto bad;
|
||||
}
|
||||
if (sv->data_pad != vol->data_pad) {
|
||||
err = 5;
|
||||
goto bad;
|
||||
}
|
||||
return 0;
|
||||
|
||||
bad:
|
||||
ubi_err("bad scanning information, error %d", err);
|
||||
ubi_dbg_dump_sv(sv);
|
||||
ubi_dbg_dump_vol_info(vol);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
/**
|
||||
* check_scanning_info - check that scanning information.
|
||||
* @ubi: UBI device description object
|
||||
* @si: scanning information
|
||||
*
|
||||
* Even though we protect on-flash data by CRC checksums, we still don't trust
|
||||
* the media. This function ensures that scanning information is consistent to
|
||||
* the information read from the volume table. Returns zero if the scanning
|
||||
* information is OK and %-EINVAL if it is not.
|
||||
*/
|
||||
static int check_scanning_info(const struct ubi_device *ubi,
|
||||
struct ubi_scan_info *si)
|
||||
{
|
||||
int err, i;
|
||||
struct ubi_scan_volume *sv;
|
||||
struct ubi_volume *vol;
|
||||
|
||||
if (si->vols_found > UBI_INT_VOL_COUNT + ubi->vtbl_slots) {
|
||||
ubi_err("scanning found %d volumes, maximum is %d + %d",
|
||||
si->vols_found, UBI_INT_VOL_COUNT, ubi->vtbl_slots);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
if (si->highest_vol_id >= ubi->vtbl_slots + UBI_INT_VOL_COUNT &&
|
||||
si->highest_vol_id < UBI_INTERNAL_VOL_START) {
|
||||
ubi_err("too large volume ID %d found by scanning",
|
||||
si->highest_vol_id);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
for (i = 0; i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++) {
|
||||
cond_resched();
|
||||
|
||||
sv = ubi_scan_find_sv(si, i);
|
||||
vol = ubi->volumes[i];
|
||||
if (!vol) {
|
||||
if (sv)
|
||||
ubi_scan_rm_volume(si, sv);
|
||||
continue;
|
||||
}
|
||||
|
||||
if (vol->reserved_pebs == 0) {
|
||||
ubi_assert(i < ubi->vtbl_slots);
|
||||
|
||||
if (!sv)
|
||||
continue;
|
||||
|
||||
/*
|
||||
* During scanning we found a volume which does not
|
||||
* exist according to the information in the volume
|
||||
* table. This must have happened due to an unclean
|
||||
* reboot while the volume was being removed. Discard
|
||||
* these eraseblocks.
|
||||
*/
|
||||
ubi_msg("finish volume %d removal", sv->vol_id);
|
||||
ubi_scan_rm_volume(si, sv);
|
||||
} else if (sv) {
|
||||
err = check_sv(vol, sv);
|
||||
if (err)
|
||||
return err;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* ubi_read_volume_table - read volume table.
|
||||
* information.
|
||||
* @ubi: UBI device description object
|
||||
* @si: scanning information
|
||||
*
|
||||
* This function reads volume table, checks it, recover from errors if needed,
|
||||
* or creates it if needed. Returns zero in case of success and a negative
|
||||
* error code in case of failure.
|
||||
*/
|
||||
int ubi_read_volume_table(struct ubi_device *ubi, struct ubi_scan_info *si)
|
||||
{
|
||||
int i, err;
|
||||
struct ubi_scan_volume *sv;
|
||||
|
||||
empty_vtbl_record.crc = cpu_to_be32(0xf116c36b);
|
||||
|
||||
/*
|
||||
* The number of supported volumes is limited by the eraseblock size
|
||||
* and by the UBI_MAX_VOLUMES constant.
|
||||
*/
|
||||
ubi->vtbl_slots = ubi->leb_size / UBI_VTBL_RECORD_SIZE;
|
||||
if (ubi->vtbl_slots > UBI_MAX_VOLUMES)
|
||||
ubi->vtbl_slots = UBI_MAX_VOLUMES;
|
||||
|
||||
ubi->vtbl_size = ubi->vtbl_slots * UBI_VTBL_RECORD_SIZE;
|
||||
ubi->vtbl_size = ALIGN(ubi->vtbl_size, ubi->min_io_size);
|
||||
|
||||
sv = ubi_scan_find_sv(si, UBI_LAYOUT_VOLUME_ID);
|
||||
if (!sv) {
|
||||
/*
|
||||
* No logical eraseblocks belonging to the layout volume were
|
||||
* found. This could mean that the flash is just empty. In
|
||||
* this case we create empty layout volume.
|
||||
*
|
||||
* But if flash is not empty this must be a corruption or the
|
||||
* MTD device just contains garbage.
|
||||
*/
|
||||
if (si->is_empty) {
|
||||
ubi->vtbl = create_empty_lvol(ubi, si);
|
||||
if (IS_ERR(ubi->vtbl))
|
||||
return PTR_ERR(ubi->vtbl);
|
||||
} else {
|
||||
ubi_err("the layout volume was not found");
|
||||
return -EINVAL;
|
||||
}
|
||||
} else {
|
||||
if (sv->leb_count > UBI_LAYOUT_VOLUME_EBS) {
|
||||
/* This must not happen with proper UBI images */
|
||||
dbg_err("too many LEBs (%d) in layout volume",
|
||||
sv->leb_count);
|
||||
return -EINVAL;
|
||||
}
|
||||
|
||||
ubi->vtbl = process_lvol(ubi, si, sv);
|
||||
if (IS_ERR(ubi->vtbl))
|
||||
return PTR_ERR(ubi->vtbl);
|
||||
}
|
||||
|
||||
ubi->avail_pebs = ubi->good_peb_count;
|
||||
|
||||
/*
|
||||
* The layout volume is OK, initialize the corresponding in-RAM data
|
||||
* structures.
|
||||
*/
|
||||
err = init_volumes(ubi, si, ubi->vtbl);
|
||||
if (err)
|
||||
goto out_free;
|
||||
|
||||
/*
|
||||
* Get sure that the scanning information is consistent to the
|
||||
* information stored in the volume table.
|
||||
*/
|
||||
err = check_scanning_info(ubi, si);
|
||||
if (err)
|
||||
goto out_free;
|
||||
|
||||
return 0;
|
||||
|
||||
out_free:
|
||||
vfree(ubi->vtbl);
|
||||
for (i = 0; i < ubi->vtbl_slots + UBI_INT_VOL_COUNT; i++)
|
||||
if (ubi->volumes[i]) {
|
||||
kfree(ubi->volumes[i]);
|
||||
ubi->volumes[i] = NULL;
|
||||
}
|
||||
return err;
|
||||
}
|
||||
|
||||
#ifdef CONFIG_MTD_UBI_DEBUG_PARANOID
|
||||
|
||||
/**
|
||||
* paranoid_vtbl_check - check volume table.
|
||||
* @ubi: UBI device description object
|
||||
*/
|
||||
static void paranoid_vtbl_check(const struct ubi_device *ubi)
|
||||
{
|
||||
if (vtbl_check(ubi, ubi->vtbl)) {
|
||||
ubi_err("paranoid check failed");
|
||||
BUG();
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* CONFIG_MTD_UBI_DEBUG_PARANOID */
|
1672
drivers/mtd/ubi/wl.c
1672
drivers/mtd/ubi/wl.c
File diff suppressed because it is too large
Load Diff
|
@ -1,183 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*
|
||||
*
|
||||
* Author: Artem Bityutskiy (Битюцкий Артём)
|
||||
*/
|
||||
|
||||
#ifndef __LINUX_UBI_H__
|
||||
#define __LINUX_UBI_H__
|
||||
|
||||
/* #include <asm/ioctl.h> */
|
||||
#include <linux/types.h>
|
||||
#include <mtd/ubi-user.h>
|
||||
|
||||
/*
|
||||
* enum ubi_open_mode - UBI volume open mode constants.
|
||||
*
|
||||
* UBI_READONLY: read-only mode
|
||||
* UBI_READWRITE: read-write mode
|
||||
* UBI_EXCLUSIVE: exclusive mode
|
||||
*/
|
||||
enum {
|
||||
UBI_READONLY = 1,
|
||||
UBI_READWRITE,
|
||||
UBI_EXCLUSIVE
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ubi_volume_info - UBI volume description data structure.
|
||||
* @vol_id: volume ID
|
||||
* @ubi_num: UBI device number this volume belongs to
|
||||
* @size: how many physical eraseblocks are reserved for this volume
|
||||
* @used_bytes: how many bytes of data this volume contains
|
||||
* @used_ebs: how many physical eraseblocks of this volume actually contain any
|
||||
* data
|
||||
* @vol_type: volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME)
|
||||
* @corrupted: non-zero if the volume is corrupted (static volumes only)
|
||||
* @upd_marker: non-zero if the volume has update marker set
|
||||
* @alignment: volume alignment
|
||||
* @usable_leb_size: how many bytes are available in logical eraseblocks of
|
||||
* this volume
|
||||
* @name_len: volume name length
|
||||
* @name: volume name
|
||||
* @cdev: UBI volume character device major and minor numbers
|
||||
*
|
||||
* The @corrupted flag is only relevant to static volumes and is always zero
|
||||
* for dynamic ones. This is because UBI does not care about dynamic volume
|
||||
* data protection and only cares about protecting static volume data.
|
||||
*
|
||||
* The @upd_marker flag is set if the volume update operation was interrupted.
|
||||
* Before touching the volume data during the update operation, UBI first sets
|
||||
* the update marker flag for this volume. If the volume update operation was
|
||||
* further interrupted, the update marker indicates this. If the update marker
|
||||
* is set, the contents of the volume is certainly damaged and a new volume
|
||||
* update operation has to be started.
|
||||
*
|
||||
* To put it differently, @corrupted and @upd_marker fields have different
|
||||
* semantics:
|
||||
* o the @corrupted flag means that this static volume is corrupted for some
|
||||
* reasons, but not because an interrupted volume update
|
||||
* o the @upd_marker field means that the volume is damaged because of an
|
||||
* interrupted update operation.
|
||||
*
|
||||
* I.e., the @corrupted flag is never set if the @upd_marker flag is set.
|
||||
*
|
||||
* The @used_bytes and @used_ebs fields are only really needed for static
|
||||
* volumes and contain the number of bytes stored in this static volume and how
|
||||
* many eraseblock this data occupies. In case of dynamic volumes, the
|
||||
* @used_bytes field is equivalent to @size*@usable_leb_size, and the @used_ebs
|
||||
* field is equivalent to @size.
|
||||
*
|
||||
* In general, logical eraseblock size is a property of the UBI device, not
|
||||
* of the UBI volume. Indeed, the logical eraseblock size depends on the
|
||||
* physical eraseblock size and on how much bytes UBI headers consume. But
|
||||
* because of the volume alignment (@alignment), the usable size of logical
|
||||
* eraseblocks if a volume may be less. The following equation is true:
|
||||
* @usable_leb_size = LEB size - (LEB size mod @alignment),
|
||||
* where LEB size is the logical eraseblock size defined by the UBI device.
|
||||
*
|
||||
* The alignment is multiple to the minimal flash input/output unit size or %1
|
||||
* if all the available space is used.
|
||||
*
|
||||
* To put this differently, alignment may be considered is a way to change
|
||||
* volume logical eraseblock sizes.
|
||||
*/
|
||||
struct ubi_volume_info {
|
||||
int ubi_num;
|
||||
int vol_id;
|
||||
int size;
|
||||
long long used_bytes;
|
||||
int used_ebs;
|
||||
int vol_type;
|
||||
int corrupted;
|
||||
int upd_marker;
|
||||
int alignment;
|
||||
int usable_leb_size;
|
||||
int name_len;
|
||||
const char *name;
|
||||
struct cdev *cdev;
|
||||
};
|
||||
|
||||
/**
|
||||
* struct ubi_device_info - UBI device description data structure.
|
||||
* @ubi_num: ubi device number
|
||||
* @leb_size: logical eraseblock size on this UBI device
|
||||
* @min_io_size: minimal I/O unit size
|
||||
* @ro_mode: if this device is in read-only mode
|
||||
* @cdev: UBI character device major and minor numbers
|
||||
*
|
||||
* Note, @leb_size is the logical eraseblock size offered by the UBI device.
|
||||
* Volumes of this UBI device may have smaller logical eraseblock size if their
|
||||
* alignment is not equivalent to %1.
|
||||
*/
|
||||
struct ubi_device_info {
|
||||
int ubi_num;
|
||||
int leb_size;
|
||||
int min_io_size;
|
||||
int ro_mode;
|
||||
struct cdev *cdev;
|
||||
};
|
||||
|
||||
/* UBI descriptor given to users when they open UBI volumes */
|
||||
struct ubi_volume_desc;
|
||||
|
||||
int ubi_get_device_info(int ubi_num, struct ubi_device_info *di);
|
||||
void ubi_get_volume_info(struct ubi_volume_desc *desc,
|
||||
struct ubi_volume_info *vi);
|
||||
struct ubi_volume_desc *ubi_open_volume(int ubi_num, int vol_id, int mode);
|
||||
struct ubi_volume_desc *ubi_open_volume_nm(int ubi_num, const char *name,
|
||||
int mode);
|
||||
void ubi_close_volume(struct ubi_volume_desc *desc);
|
||||
int ubi_leb_read(struct ubi_volume_desc *desc, int lnum, char *buf, int offset,
|
||||
int len, int check);
|
||||
int ubi_leb_write(struct ubi_volume_desc *desc, int lnum, const void *buf,
|
||||
int offset, int len, int dtype);
|
||||
int ubi_leb_change(struct ubi_volume_desc *desc, int lnum, const void *buf,
|
||||
int len, int dtype);
|
||||
int ubi_leb_erase(struct ubi_volume_desc *desc, int lnum);
|
||||
int ubi_leb_unmap(struct ubi_volume_desc *desc, int lnum);
|
||||
int ubi_leb_map(struct ubi_volume_desc *desc, int lnum, int dtype);
|
||||
int ubi_is_mapped(struct ubi_volume_desc *desc, int lnum);
|
||||
|
||||
/*
|
||||
* This function is the same as the 'ubi_leb_read()' function, but it does not
|
||||
* provide the checking capability.
|
||||
*/
|
||||
static inline int ubi_read(struct ubi_volume_desc *desc, int lnum, char *buf,
|
||||
int offset, int len)
|
||||
{
|
||||
return ubi_leb_read(desc, lnum, buf, offset, len, 0);
|
||||
}
|
||||
|
||||
/*
|
||||
* This function is the same as the 'ubi_leb_write()' functions, but it does
|
||||
* not have the data type argument.
|
||||
*/
|
||||
static inline int ubi_write(struct ubi_volume_desc *desc, int lnum,
|
||||
const void *buf, int offset, int len)
|
||||
{
|
||||
return ubi_leb_write(desc, lnum, buf, offset, len, UBI_UNKNOWN);
|
||||
}
|
||||
|
||||
/*
|
||||
* This function is the same as the 'ubi_leb_change()' functions, but it does
|
||||
* not have the data type argument.
|
||||
*/
|
||||
static inline int ubi_change(struct ubi_volume_desc *desc, int lnum,
|
||||
const void *buf, int len)
|
||||
{
|
||||
return ubi_leb_change(desc, lnum, buf, len, UBI_UNKNOWN);
|
||||
}
|
||||
|
||||
#endif /* !__LINUX_UBI_H__ */
|
|
@ -1,374 +0,0 @@
|
|||
/*
|
||||
* 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.
|
||||
*
|
||||
* Authors: Artem Bityutskiy (Битюцкий Артём)
|
||||
* Thomas Gleixner
|
||||
* Frank Haverkamp
|
||||
* Oliver Lohmann
|
||||
* Andreas Arnez
|
||||
*/
|
||||
|
||||
/*
|
||||
* This file defines the layout of UBI headers and all the other UBI on-flash
|
||||
* data structures.
|
||||
*/
|
||||
|
||||
#ifndef __UBI_MEDIA_H__
|
||||
#define __UBI_MEDIA_H__
|
||||
|
||||
#include <asm/byteorder.h>
|
||||
|
||||
/* The version of UBI images supported by this implementation */
|
||||
#define UBI_VERSION 1
|
||||
|
||||
/* The highest erase counter value supported by this implementation */
|
||||
#define UBI_MAX_ERASECOUNTER 0x7FFFFFFF
|
||||
|
||||
/* The initial CRC32 value used when calculating CRC checksums */
|
||||
#define UBI_CRC32_INIT 0xFFFFFFFFU
|
||||
|
||||
/* Erase counter header magic number (ASCII "UBI#") */
|
||||
#define UBI_EC_HDR_MAGIC 0x55424923
|
||||
/* Volume identifier header magic number (ASCII "UBI!") */
|
||||
#define UBI_VID_HDR_MAGIC 0x55424921
|
||||
|
||||
/*
|
||||
* Volume type constants used in the volume identifier header.
|
||||
*
|
||||
* @UBI_VID_DYNAMIC: dynamic volume
|
||||
* @UBI_VID_STATIC: static volume
|
||||
*/
|
||||
enum {
|
||||
UBI_VID_DYNAMIC = 1,
|
||||
UBI_VID_STATIC = 2
|
||||
};
|
||||
|
||||
/*
|
||||
* Volume flags used in the volume table record.
|
||||
*
|
||||
* @UBI_VTBL_AUTORESIZE_FLG: auto-resize this volume
|
||||
*
|
||||
* %UBI_VTBL_AUTORESIZE_FLG flag can be set only for one volume in the volume
|
||||
* table. UBI automatically re-sizes the volume which has this flag and makes
|
||||
* the volume to be of largest possible size. This means that if after the
|
||||
* initialization UBI finds out that there are available physical eraseblocks
|
||||
* present on the device, it automatically appends all of them to the volume
|
||||
* (the physical eraseblocks reserved for bad eraseblocks handling and other
|
||||
* reserved physical eraseblocks are not taken). So, if there is a volume with
|
||||
* the %UBI_VTBL_AUTORESIZE_FLG flag set, the amount of available logical
|
||||
* eraseblocks will be zero after UBI is loaded, because all of them will be
|
||||
* reserved for this volume. Note, the %UBI_VTBL_AUTORESIZE_FLG bit is cleared
|
||||
* after the volume had been initialized.
|
||||
*
|
||||
* The auto-resize feature is useful for device production purposes. For
|
||||
* example, different NAND flash chips may have different amount of initial bad
|
||||
* eraseblocks, depending of particular chip instance. Manufacturers of NAND
|
||||
* chips usually guarantee that the amount of initial bad eraseblocks does not
|
||||
* exceed certain percent, e.g. 2%. When one creates an UBI image which will be
|
||||
* flashed to the end devices in production, he does not know the exact amount
|
||||
* of good physical eraseblocks the NAND chip on the device will have, but this
|
||||
* number is required to calculate the volume sized and put them to the volume
|
||||
* table of the UBI image. In this case, one of the volumes (e.g., the one
|
||||
* which will store the root file system) is marked as "auto-resizable", and
|
||||
* UBI will adjust its size on the first boot if needed.
|
||||
*
|
||||
* Note, first UBI reserves some amount of physical eraseblocks for bad
|
||||
* eraseblock handling, and then re-sizes the volume, not vice-versa. This
|
||||
* means that the pool of reserved physical eraseblocks will always be present.
|
||||
*/
|
||||
enum {
|
||||
UBI_VTBL_AUTORESIZE_FLG = 0x01,
|
||||
};
|
||||
|
||||
/*
|
||||
* Compatibility constants used by internal volumes.
|
||||
*
|
||||
* @UBI_COMPAT_DELETE: delete this internal volume before anything is written
|
||||
* to the flash
|
||||
* @UBI_COMPAT_RO: attach this device in read-only mode
|
||||
* @UBI_COMPAT_PRESERVE: preserve this internal volume - do not touch its
|
||||
* physical eraseblocks, don't allow the wear-leveling
|
||||
* sub-system to move them
|
||||
* @UBI_COMPAT_REJECT: reject this UBI image
|
||||
*/
|
||||
enum {
|
||||
UBI_COMPAT_DELETE = 1,
|
||||
UBI_COMPAT_RO = 2,
|
||||
UBI_COMPAT_PRESERVE = 4,
|
||||
UBI_COMPAT_REJECT = 5
|
||||
};
|
||||
|
||||
/* Sizes of UBI headers */
|
||||
#define UBI_EC_HDR_SIZE sizeof(struct ubi_ec_hdr)
|
||||
#define UBI_VID_HDR_SIZE sizeof(struct ubi_vid_hdr)
|
||||
|
||||
/* Sizes of UBI headers without the ending CRC */
|
||||
#define UBI_EC_HDR_SIZE_CRC (UBI_EC_HDR_SIZE - sizeof(__be32))
|
||||
#define UBI_VID_HDR_SIZE_CRC (UBI_VID_HDR_SIZE - sizeof(__be32))
|
||||
|
||||
/**
|
||||
* struct ubi_ec_hdr - UBI erase counter header.
|
||||
* @magic: erase counter header magic number (%UBI_EC_HDR_MAGIC)
|
||||
* @version: version of UBI implementation which is supposed to accept this
|
||||
* UBI image
|
||||
* @padding1: reserved for future, zeroes
|
||||
* @ec: the erase counter
|
||||
* @vid_hdr_offset: where the VID header starts
|
||||
* @data_offset: where the user data start
|
||||
* @image_seq: image sequence number
|
||||
* @padding2: reserved for future, zeroes
|
||||
* @hdr_crc: erase counter header CRC checksum
|
||||
*
|
||||
* The erase counter header takes 64 bytes and has a plenty of unused space for
|
||||
* future usage. The unused fields are zeroed. The @version field is used to
|
||||
* indicate the version of UBI implementation which is supposed to be able to
|
||||
* work with this UBI image. If @version is greater than the current UBI
|
||||
* version, the image is rejected. This may be useful in future if something
|
||||
* is changed radically. This field is duplicated in the volume identifier
|
||||
* header.
|
||||
*
|
||||
* The @vid_hdr_offset and @data_offset fields contain the offset of the the
|
||||
* volume identifier header and user data, relative to the beginning of the
|
||||
* physical eraseblock. These values have to be the same for all physical
|
||||
* eraseblocks.
|
||||
*
|
||||
* The @image_seq field is used to validate a UBI image that has been prepared
|
||||
* for a UBI device. The @image_seq value can be any value, but it must be the
|
||||
* same on all eraseblocks. UBI will ensure that all new erase counter headers
|
||||
* also contain this value, and will check the value when scanning at start-up.
|
||||
* One way to make use of @image_seq is to increase its value by one every time
|
||||
* an image is flashed over an existing image, then, if the flashing does not
|
||||
* complete, UBI will detect the error when scanning.
|
||||
*/
|
||||
struct ubi_ec_hdr {
|
||||
__be32 magic;
|
||||
__u8 version;
|
||||
__u8 padding1[3];
|
||||
__be64 ec; /* Warning: the current limit is 31-bit anyway! */
|
||||
__be32 vid_hdr_offset;
|
||||
__be32 data_offset;
|
||||
__be32 image_seq;
|
||||
__u8 padding2[32];
|
||||
__be32 hdr_crc;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
/**
|
||||
* struct ubi_vid_hdr - on-flash UBI volume identifier header.
|
||||
* @magic: volume identifier header magic number (%UBI_VID_HDR_MAGIC)
|
||||
* @version: UBI implementation version which is supposed to accept this UBI
|
||||
* image (%UBI_VERSION)
|
||||
* @vol_type: volume type (%UBI_VID_DYNAMIC or %UBI_VID_STATIC)
|
||||
* @copy_flag: if this logical eraseblock was copied from another physical
|
||||
* eraseblock (for wear-leveling reasons)
|
||||
* @compat: compatibility of this volume (%0, %UBI_COMPAT_DELETE,
|
||||
* %UBI_COMPAT_IGNORE, %UBI_COMPAT_PRESERVE, or %UBI_COMPAT_REJECT)
|
||||
* @vol_id: ID of this volume
|
||||
* @lnum: logical eraseblock number
|
||||
* @padding1: reserved for future, zeroes
|
||||
* @data_size: how many bytes of data this logical eraseblock contains
|
||||
* @used_ebs: total number of used logical eraseblocks in this volume
|
||||
* @data_pad: how many bytes at the end of this physical eraseblock are not
|
||||
* used
|
||||
* @data_crc: CRC checksum of the data stored in this logical eraseblock
|
||||
* @padding2: reserved for future, zeroes
|
||||
* @sqnum: sequence number
|
||||
* @padding3: reserved for future, zeroes
|
||||
* @hdr_crc: volume identifier header CRC checksum
|
||||
*
|
||||
* The @sqnum is the value of the global sequence counter at the time when this
|
||||
* VID header was created. The global sequence counter is incremented each time
|
||||
* UBI writes a new VID header to the flash, i.e. when it maps a logical
|
||||
* eraseblock to a new physical eraseblock. The global sequence counter is an
|
||||
* unsigned 64-bit integer and we assume it never overflows. The @sqnum
|
||||
* (sequence number) is used to distinguish between older and newer versions of
|
||||
* logical eraseblocks.
|
||||
*
|
||||
* There are 2 situations when there may be more than one physical eraseblock
|
||||
* corresponding to the same logical eraseblock, i.e., having the same @vol_id
|
||||
* and @lnum values in the volume identifier header. Suppose we have a logical
|
||||
* eraseblock L and it is mapped to the physical eraseblock P.
|
||||
*
|
||||
* 1. Because UBI may erase physical eraseblocks asynchronously, the following
|
||||
* situation is possible: L is asynchronously erased, so P is scheduled for
|
||||
* erasure, then L is written to,i.e. mapped to another physical eraseblock P1,
|
||||
* so P1 is written to, then an unclean reboot happens. Result - there are 2
|
||||
* physical eraseblocks P and P1 corresponding to the same logical eraseblock
|
||||
* L. But P1 has greater sequence number, so UBI picks P1 when it attaches the
|
||||
* flash.
|
||||
*
|
||||
* 2. From time to time UBI moves logical eraseblocks to other physical
|
||||
* eraseblocks for wear-leveling reasons. If, for example, UBI moves L from P
|
||||
* to P1, and an unclean reboot happens before P is physically erased, there
|
||||
* are two physical eraseblocks P and P1 corresponding to L and UBI has to
|
||||
* select one of them when the flash is attached. The @sqnum field says which
|
||||
* PEB is the original (obviously P will have lower @sqnum) and the copy. But
|
||||
* it is not enough to select the physical eraseblock with the higher sequence
|
||||
* number, because the unclean reboot could have happen in the middle of the
|
||||
* copying process, so the data in P is corrupted. It is also not enough to
|
||||
* just select the physical eraseblock with lower sequence number, because the
|
||||
* data there may be old (consider a case if more data was added to P1 after
|
||||
* the copying). Moreover, the unclean reboot may happen when the erasure of P
|
||||
* was just started, so it result in unstable P, which is "mostly" OK, but
|
||||
* still has unstable bits.
|
||||
*
|
||||
* UBI uses the @copy_flag field to indicate that this logical eraseblock is a
|
||||
* copy. UBI also calculates data CRC when the data is moved and stores it at
|
||||
* the @data_crc field of the copy (P1). So when UBI needs to pick one physical
|
||||
* eraseblock of two (P or P1), the @copy_flag of the newer one (P1) is
|
||||
* examined. If it is cleared, the situation* is simple and the newer one is
|
||||
* picked. If it is set, the data CRC of the copy (P1) is examined. If the CRC
|
||||
* checksum is correct, this physical eraseblock is selected (P1). Otherwise
|
||||
* the older one (P) is selected.
|
||||
*
|
||||
* There are 2 sorts of volumes in UBI: user volumes and internal volumes.
|
||||
* Internal volumes are not seen from outside and are used for various internal
|
||||
* UBI purposes. In this implementation there is only one internal volume - the
|
||||
* layout volume. Internal volumes are the main mechanism of UBI extensions.
|
||||
* For example, in future one may introduce a journal internal volume. Internal
|
||||
* volumes have their own reserved range of IDs.
|
||||
*
|
||||
* The @compat field is only used for internal volumes and contains the "degree
|
||||
* of their compatibility". It is always zero for user volumes. This field
|
||||
* provides a mechanism to introduce UBI extensions and to be still compatible
|
||||
* with older UBI binaries. For example, if someone introduced a journal in
|
||||
* future, he would probably use %UBI_COMPAT_DELETE compatibility for the
|
||||
* journal volume. And in this case, older UBI binaries, which know nothing
|
||||
* about the journal volume, would just delete this volume and work perfectly
|
||||
* fine. This is similar to what Ext2fs does when it is fed by an Ext3fs image
|
||||
* - it just ignores the Ext3fs journal.
|
||||
*
|
||||
* The @data_crc field contains the CRC checksum of the contents of the logical
|
||||
* eraseblock if this is a static volume. In case of dynamic volumes, it does
|
||||
* not contain the CRC checksum as a rule. The only exception is when the
|
||||
* data of the physical eraseblock was moved by the wear-leveling sub-system,
|
||||
* then the wear-leveling sub-system calculates the data CRC and stores it in
|
||||
* the @data_crc field. And of course, the @copy_flag is %in this case.
|
||||
*
|
||||
* The @data_size field is used only for static volumes because UBI has to know
|
||||
* how many bytes of data are stored in this eraseblock. For dynamic volumes,
|
||||
* this field usually contains zero. The only exception is when the data of the
|
||||
* physical eraseblock was moved to another physical eraseblock for
|
||||
* wear-leveling reasons. In this case, UBI calculates CRC checksum of the
|
||||
* contents and uses both @data_crc and @data_size fields. In this case, the
|
||||
* @data_size field contains data size.
|
||||
*
|
||||
* The @used_ebs field is used only for static volumes and indicates how many
|
||||
* eraseblocks the data of the volume takes. For dynamic volumes this field is
|
||||
* not used and always contains zero.
|
||||
*
|
||||
* The @data_pad is calculated when volumes are created using the alignment
|
||||
* parameter. So, effectively, the @data_pad field reduces the size of logical
|
||||
* eraseblocks of this volume. This is very handy when one uses block-oriented
|
||||
* software (say, cramfs) on top of the UBI volume.
|
||||
*/
|
||||
struct ubi_vid_hdr {
|
||||
__be32 magic;
|
||||
__u8 version;
|
||||
__u8 vol_type;
|
||||
__u8 copy_flag;
|
||||
__u8 compat;
|
||||
__be32 vol_id;
|
||||
__be32 lnum;
|
||||
__be32 leb_ver;
|
||||
__be32 data_size;
|
||||
__be32 used_ebs;
|
||||
__be32 data_pad;
|
||||
__be32 data_crc;
|
||||
__u8 padding2[4];
|
||||
__be64 sqnum;
|
||||
__u8 padding3[12];
|
||||
__be32 hdr_crc;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
/* Internal UBI volumes count */
|
||||
#define UBI_INT_VOL_COUNT 1
|
||||
|
||||
/*
|
||||
* Starting ID of internal volumes. There is reserved room for 4096 internal
|
||||
* volumes.
|
||||
*/
|
||||
#define UBI_INTERNAL_VOL_START (0x7FFFFFFF - 4096)
|
||||
|
||||
/* The layout volume contains the volume table */
|
||||
|
||||
#define UBI_LAYOUT_VOLUME_ID UBI_INTERNAL_VOL_START
|
||||
#define UBI_LAYOUT_VOLUME_TYPE UBI_VID_DYNAMIC
|
||||
#define UBI_LAYOUT_VOLUME_ALIGN 1
|
||||
#define UBI_LAYOUT_VOLUME_EBS 2
|
||||
#define UBI_LAYOUT_VOLUME_NAME "layout volume"
|
||||
#define UBI_LAYOUT_VOLUME_COMPAT UBI_COMPAT_REJECT
|
||||
|
||||
/* The maximum number of volumes per one UBI device */
|
||||
#define UBI_MAX_VOLUMES 128
|
||||
|
||||
/* The maximum volume name length */
|
||||
#define UBI_VOL_NAME_MAX 127
|
||||
|
||||
/* Size of the volume table record */
|
||||
#define UBI_VTBL_RECORD_SIZE sizeof(struct ubi_vtbl_record)
|
||||
|
||||
/* Size of the volume table record without the ending CRC */
|
||||
#define UBI_VTBL_RECORD_SIZE_CRC (UBI_VTBL_RECORD_SIZE - sizeof(__be32))
|
||||
|
||||
/**
|
||||
* struct ubi_vtbl_record - a record in the volume table.
|
||||
* @reserved_pebs: how many physical eraseblocks are reserved for this volume
|
||||
* @alignment: volume alignment
|
||||
* @data_pad: how many bytes are unused at the end of the each physical
|
||||
* eraseblock to satisfy the requested alignment
|
||||
* @vol_type: volume type (%UBI_DYNAMIC_VOLUME or %UBI_STATIC_VOLUME)
|
||||
* @upd_marker: if volume update was started but not finished
|
||||
* @name_len: volume name length
|
||||
* @name: the volume name
|
||||
* @flags: volume flags (%UBI_VTBL_AUTORESIZE_FLG)
|
||||
* @padding: reserved, zeroes
|
||||
* @crc: a CRC32 checksum of the record
|
||||
*
|
||||
* The volume table records are stored in the volume table, which is stored in
|
||||
* the layout volume. The layout volume consists of 2 logical eraseblock, each
|
||||
* of which contains a copy of the volume table (i.e., the volume table is
|
||||
* duplicated). The volume table is an array of &struct ubi_vtbl_record
|
||||
* objects indexed by the volume ID.
|
||||
*
|
||||
* If the size of the logical eraseblock is large enough to fit
|
||||
* %UBI_MAX_VOLUMES records, the volume table contains %UBI_MAX_VOLUMES
|
||||
* records. Otherwise, it contains as many records as it can fit (i.e., size of
|
||||
* logical eraseblock divided by sizeof(struct ubi_vtbl_record)).
|
||||
*
|
||||
* The @upd_marker flag is used to implement volume update. It is set to %1
|
||||
* before update and set to %0 after the update. So if the update operation was
|
||||
* interrupted, UBI knows that the volume is corrupted.
|
||||
*
|
||||
* The @alignment field is specified when the volume is created and cannot be
|
||||
* later changed. It may be useful, for example, when a block-oriented file
|
||||
* system works on top of UBI. The @data_pad field is calculated using the
|
||||
* logical eraseblock size and @alignment. The alignment must be multiple to the
|
||||
* minimal flash I/O unit. If @alignment is 1, all the available space of
|
||||
* the physical eraseblocks is used.
|
||||
*
|
||||
* Empty records contain all zeroes and the CRC checksum of those zeroes.
|
||||
*/
|
||||
struct ubi_vtbl_record {
|
||||
__be32 reserved_pebs;
|
||||
__be32 alignment;
|
||||
__be32 data_pad;
|
||||
__u8 vol_type;
|
||||
__u8 upd_marker;
|
||||
__be16 name_len;
|
||||
__u8 name[UBI_VOL_NAME_MAX+1];
|
||||
__u8 flags;
|
||||
__u8 padding[23];
|
||||
__be32 crc;
|
||||
} __attribute__ ((packed));
|
||||
|
||||
#endif /* !__UBI_MEDIA_H__ */
|
Loading…
Reference in New Issue