[PATCH 32/44 take 2] [UBI] accounting unit implementation

[Artem Bityutskiy <dedekind@infradead.org>]

diff -auNrp tmp-from/drivers/mtd/ubi/account.c tmp-to/drivers/mtd/ubi/account.c
--- tmp-from/drivers/mtd/ubi/account.c	1970-01-01 02:00:00.000000000 +0200
+++ tmp-to/drivers/mtd/ubi/account.c	2007-02-17 18:07:27.000000000 +0200
@@ -0,0 +1,286 @@
+/*
+ * Copyright (c) International Business Machines Corp., 2006
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
+ * the GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ *
+ * Author: Artem B. Bityutskiy
+ */
+
+#include <linux/sched.h>
+#include <linux/string.h>
+#include <linux/spinlock.h>
+#include <linux/err.h>
+#include <linux/types.h>
+#include <mtd/ubi-header.h>
+#include "ubi.h"
+#include "vtbl.h"
+#include "account.h"
+#include "scan.h"
+#include "alloc.h"
+#include "badeb.h"
+#include "io.h"
+#include "debug.h"
+
+int ubi_acc_mkvol(const struct ubi_info *ubi, int reserved_pebs)
+{
+	struct ubi_acc_info *acc = ubi->acc;
+
+	dbg_acc("reserve %d PEBs for a new volume (uvol_count %d"
+		"rsvd_pebs %d, avail_pebs %d)", reserved_pebs,
+		acc->uvol_count, acc->rsvd_pebs, acc->avail_pebs);
+	ubi_assert(reserved_pebs > 0);
+
+	spin_lock(&acc->lock);
+	if (acc->uvol_count + 1 > acc->max_volumes) {
+		dbg_err("no room for the volume");
+		goto out;
+	}
+	if (reserved_pebs > acc->avail_pebs) {
+		dbg_err("no enough PEBs");
+		goto out;
+	}
+	acc->uvol_count += 1;
+	acc->avail_pebs -= reserved_pebs;
+	acc->rsvd_pebs += reserved_pebs;
+	ubi_assert(acc->avail_pebs >= 0);
+	spin_unlock(&acc->lock);
+	return 0;
+
+out:
+	spin_unlock(&acc->lock);
+	return -ENOSPC;
+}
+
+void ubi_acc_rmvol(const struct ubi_info *ubi, int reserved_pebs)
+{
+	struct ubi_acc_info *acc = ubi->acc;
+
+	dbg_acc("remove volume and get back %d PEBs (uvol_count %d, "
+		"rsvd_pebs %d, avail_pebs %d)", reserved_pebs,
+		acc->uvol_count, acc->rsvd_pebs, acc->avail_pebs);
+	ubi_assert(reserved_pebs > 0 && reserved_pebs <= acc->rsvd_pebs);
+
+	spin_lock(&acc->lock);
+	acc->uvol_count -= 1;
+	acc->avail_pebs += reserved_pebs;
+	acc->rsvd_pebs -= reserved_pebs;
+	ubi_assert(acc->uvol_count >= 0);
+	ubi_assert(acc->rsvd_pebs >= 0);
+	spin_unlock(&acc->lock);
+
+	/* Take care about PEBs reserved for bad PEB handling */
+	ubi_beb_maintain_reserved(ubi);
+}
+
+int ubi_acc_reserve(const struct ubi_info *ubi, int pebs)
+{
+	struct ubi_acc_info *acc = ubi->acc;
+
+	dbg_acc("reserve %d PEBs (rsvd_pebs %d, avail_pebs %d)",
+		pebs, acc->rsvd_pebs, acc->avail_pebs);
+	ubi_assert(pebs > 0);
+
+	spin_lock(&acc->lock);
+	if (unlikely(pebs > acc->avail_pebs)) {
+		dbg_err("no enough PEBs");
+		spin_unlock(&acc->lock);
+		return -ENOSPC;
+	}
+	acc->avail_pebs -= pebs;
+	acc->rsvd_pebs += pebs;
+	spin_unlock(&acc->lock);
+	return 0;
+}
+
+void ubi_acc_free(const struct ubi_info *ubi, int pebs)
+{
+	struct ubi_acc_info *acc = ubi->acc;
+
+	dbg_acc("free %d PEBs (rsvd_pebs %d, avail_pebs %d)",
+		pebs, acc->rsvd_pebs, acc->avail_pebs);
+	spin_lock(&acc->lock);
+	ubi_assert(pebs > 0 && pebs <= acc->rsvd_pebs);
+	acc->rsvd_pebs -= pebs;
+	acc->avail_pebs += pebs;
+	spin_unlock(&acc->lock);
+}
+
+static int acc_info_check(const struct ubi_info *ubi,
+			  const struct ubi_scan_info *si);
+
+int ubi_acc_init_scan(struct ubi_info *ubi, struct ubi_scan_info *si)
+{
+	int err, i;
+	struct ubi_acc_info *acc;
+	const struct ubi_vtbl_vtr *vtr;
+	const struct ubi_vtbl_info *vtbl = ubi->vtbl;
+	const struct ubi_io_info *io = ubi->io;
+
+	dbg_acc("initialize the accounting unit");
+
+	acc = ubi_kzalloc(sizeof(struct ubi_acc_info));
+	if (!acc)
+		return -ENOMEM;
+	ubi->acc = acc;
+
+	spin_lock_init(&acc->lock);
+	acc->ivol_count = UBI_INT_VOL_COUNT;
+
+	for (i = 0; i < acc->ivol_count; i++) {
+		cond_resched();
+		vtr = ubi_vtbl_get_vtr(ubi, UBI_INTERNAL_VOL_START + i);
+		ubi_assert(!IS_ERR(vtr));
+		acc->rsvd_pebs += vtr->reserved_pebs;
+	}
+
+	/*
+	 * The maximum number of volumes may be less then the volume table
+	 * fits if there are too few available eraseblocks on the flash.
+	 */
+	acc->max_volumes = vtbl->vt_slots;
+	i = io->good_peb_count - acc->rsvd_pebs;
+	if (i <= 0) {
+		ubi_err("too small flash, at least %d good physical eraseblock"
+			" needed", acc->rsvd_pebs + 1);
+		err = -EINVAL;
+		goto out_acc;
+	}
+
+	if (acc->max_volumes > i)
+		acc->max_volumes = i;
+
+	for (i = 0; i < acc->max_volumes; i++) {
+		cond_resched();
+		vtr = ubi_vtbl_get_vtr(ubi, i);
+		if (IS_ERR(vtr))
+			continue;
+		acc->uvol_count += 1;
+		acc->rsvd_pebs += vtr->reserved_pebs;
+	}
+
+	acc->rsvd_pebs += si->alien_peb_count;
+	acc->avail_pebs = io->good_peb_count - acc->rsvd_pebs;
+
+	/* Check accounting information sanity and consistency */
+	err = acc_info_check(ubi, si);
+	if (err)
+		goto out_acc;
+
+	dbg_acc("uvol_count %d, ivol_count %d, avail_pebs %d rsvd_pebs %d "
+		"max_volumes %d", acc->uvol_count, acc->ivol_count,
+		acc->avail_pebs, acc->rsvd_pebs, acc->max_volumes);
+	return 0;
+
+out_acc:
+	ubi_kfree(acc);
+	return err;
+}
+
+void ubi_acc_close(const struct ubi_info *ubi)
+{
+	dbg_acc("close the accounting unit");
+	ubi_kfree(ubi->acc);
+}
+
+/**
+ * acc_info_check - check sanity and consistency of accounting information.
+ *
+ * @ubi: the UBI device description object
+ * @si: a pointer to the scanning information which must be consistent to accounting
+ * information
+ *
+ * As we try not to trust the data we read from the flash media, we have to
+ * check that the accounting information is sane and consistent, as it is
+ * formed using on-flash information. This function returns zero if all is fine
+ * and a negative error code if some inconsistency was found.
+ */
+static int acc_info_check(const struct ubi_info *ubi,
+			  const struct ubi_scan_info *si)
+{
+	int i;
+	const struct ubi_vtbl_vtr *vtr;
+	const struct ubi_acc_info *acc = ubi->acc;
+	const struct ubi_vtbl_info *vtbl = ubi->vtbl;
+	const struct ubi_io_info *io = ubi->io;
+
+	if (acc->avail_pebs < 0 || acc->rsvd_pebs < 0 || acc->uvol_count < 0 ||
+	    acc->ivol_count < 0) {
+		dbg_err("negative values");
+		goto bad;
+	}
+
+	if (acc->avail_pebs > io->good_peb_count) {
+		dbg_err("bad avail_pebs");
+		goto bad;
+	}
+
+	if (acc->rsvd_pebs > io->good_peb_count) {
+		dbg_err("bad rsvd_pebs");
+		goto bad;
+	}
+
+	if (acc->avail_pebs + acc->rsvd_pebs != io->good_peb_count) {
+		dbg_err("accounting error");
+		goto bad;
+	}
+
+	if (acc->max_volumes > vtbl->vt_slots) {
+		dbg_err("bad max_volumes");
+		goto bad;
+	}
+
+	if (acc->ivol_count + acc->uvol_count > acc->max_volumes) {
+		dbg_err("vol. count (%d + %d) > max_volumes",
+			acc->ivol_count, acc->uvol_count);
+		goto bad;
+	}
+
+	/*
+	 * Ensure that there are no volumes which exceed acc->max_volumes
+	 * exist.
+	 */
+	for (i = acc->max_volumes; i < vtbl->vt_slots; i++) {
+		cond_resched();
+		vtr = ubi_vtbl_get_vtr(ubi, i);
+		if (unlikely(!IS_ERR(vtr))) {
+			dbg_err("volume %d exists", i);
+			goto bad;
+		}
+	}
+
+	if (si->vols_found > acc->ivol_count + acc->uvol_count) {
+		dbg_err("scanning found volumes %d > %d + %d",
+			si->vols_found, acc->ivol_count, acc->uvol_count);
+		goto bad;
+	}
+
+	if (si->highest_vol_id >= acc->max_volumes &&
+	    si->highest_vol_id < UBI_INTERNAL_VOL_START) {
+		dbg_err("too large volume ID %d found by scanning",
+			si->highest_vol_id);
+		goto bad;
+	}
+
+	return 0;
+
+bad:
+	ubi_err("accounting check failed");
+	dbg_err("uvol_count %d, ivol_count %d, avail_pebs %d, rsvd_pebs %d "
+		"io->good_peb_count %d, max_volumes %d, vtbl->vt_slots %d",
+		acc->uvol_count, acc->ivol_count, acc->avail_pebs,
+		acc->rsvd_pebs, io->good_peb_count, acc->max_volumes,
+		vtbl->vt_slots);
+	return -EINVAL;
+}