From patchwork Sun May 13 08:47:37 2012 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joel Reardon X-Patchwork-Id: 158810 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Received: from merlin.infradead.org (merlin.infradead.org [IPv6:2001:4978:20e::2]) (using TLSv1 with cipher DHE-RSA-AES256-SHA (256/256 bits)) (Client did not present a certificate) by ozlabs.org (Postfix) with ESMTPS id 7A731B700B for ; Sun, 13 May 2012 18:54:24 +1000 (EST) Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.76 #1 (Red Hat Linux)) id 1STUSz-0000wR-H8; Sun, 13 May 2012 08:47:49 +0000 Received: from [78.46.68.141] (helo=eristoteles.iwoars.net) by merlin.infradead.org with smtp (Exim 4.76 #1 (Red Hat Linux)) id 1STUSr-0000vs-GD for linux-mtd@lists.infradead.org; Sun, 13 May 2012 08:47:42 +0000 Received: (qmail 1275 invoked by uid 5144); 13 May 2012 10:47:37 +0200 Received: from localhost (sendmail-bs@127.0.0.1) by localhost with SMTP; 13 May 2012 10:47:37 +0200 Date: Sun, 13 May 2012 10:47:37 +0200 (CEST) From: Joel Reardon X-X-Sender: joel@eristoteles.iwoars.net To: Artem Bityutskiy Subject: [patch] UBI: add means to clear ubi work queue for particular lnums In-Reply-To: Message-ID: References: User-Agent: Alpine 2.00 (DEB 1167 2008-08-23) MIME-Version: 1.0 X-Spam-Note: CRM114 invocation failed X-Spam-Score: -0.8 (/) X-Spam-Report: SpamAssassin version 3.3.2 on merlin.infradead.org summary: Content analysis details: (-0.8 points) pts rule name description ---- ---------------------- -------------------------------------------------- -1.9 BAYES_00 BODY: Bayes spam probability is 0 to 1% [score: 0.0000] 0.8 RDNS_NONE Delivered to internal network by a host with no rDNS 0.3 FROM_12LTRDOM From a 12-letter domain Cc: linux-mtd@lists.infradead.org, linux-kernel@vger.kernel.org X-BeenThere: linux-mtd@lists.infradead.org X-Mailman-Version: 2.1.14 Precedence: list List-Id: Linux MTD discussion mailing list List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: linux-mtd-bounces@lists.infradead.org Errors-To: linux-mtd-bounces+incoming=patchwork.ozlabs.org@lists.infradead.org This is the second part of a patch to allow UBI to force the erasure of particular logical eraseblock numbers. In this patch, a new function, ubi_lnum_purge, is added that allows the caller to synchronously erase all unmapped erase blocks whose LEB number corresponds to the parameter. This requires a previous patch that stores the LEB number in struct ubi_work. This was tested by disabling the call to do_work in ubi thread, which results in the work queue remaining unless explicitly called to remove. UBIFS was changed to call ubifs_leb_change 50 times for three different LEBs. Then the new function was called to clear the queue for the three differnt LEB numbers one at a time. The work queue was dumped each time and the selective removal of the particular LEB numbers was observed. Calls to down_read(&ubi->work_sem) are not being done (unlike in do_work).. I'm not sure exactly where its needed / what it does, so perhaps someone can enlighten me. Signed-off-by: Joel Reardon --- drivers/mtd/ubi/kapi.c | 31 +++++++++++++++++++++++++++++++ drivers/mtd/ubi/ubi.h | 1 + drivers/mtd/ubi/wl.c | 35 +++++++++++++++++++++++++++++++++++ include/linux/mtd/ubi.h | 1 + 4 files changed, 68 insertions(+), 0 deletions(-) diff --git a/drivers/mtd/ubi/kapi.c b/drivers/mtd/ubi/kapi.c index 9fdb353..bfd4e22 100644 --- a/drivers/mtd/ubi/kapi.c +++ b/drivers/mtd/ubi/kapi.c @@ -720,6 +720,37 @@ int ubi_sync(int ubi_num) } EXPORT_SYMBOL_GPL(ubi_sync); +/** + * ubi_lnum_purge - synchronously erase unmapped PEBs by LEB number. + * @ubi_num: UBI device to erase PEBs + * @lnum: the LEB number to erase old unmapped PEBs. + * + * This function is designed to offer a means to ensure that the contents of + * old, unmapped LEBs are securely erased without having to flush the entire + * work queue of all erase blocks that need erasure. Simply erasing the block + * at the time of unmapped is insufficient, as the wear-levelling subsystem + * may have already moved the contents. This function navigates the list of + * erase blocks that need erasures, and performs an immediate and synchronous + * erasure of any erase block that has held data for this particular @lnum. + * This may include eraseblocks that held older versions of the same @lnum. + * Returns zero in case of success and a negative error code in case of + * failure. + */ +int ubi_lnum_purge(int ubi_num, int lnum) +{ + int err; + struct ubi_device *ubi; + + ubi = ubi_get_device(ubi_num); + if (!ubi) + return -ENODEV; + + err = ubi_wl_flush_lnum(ubi, lnum); + ubi_put_device(ubi); + return err; +} +EXPORT_SYMBOL_GPL(ubi_lnum_purge); + BLOCKING_NOTIFIER_HEAD(ubi_notifiers); /** diff --git a/drivers/mtd/ubi/ubi.h b/drivers/mtd/ubi/ubi.h index 14443a0..e1a29ea 100644 --- a/drivers/mtd/ubi/ubi.h +++ b/drivers/mtd/ubi/ubi.h @@ -539,6 +539,7 @@ int ubi_eba_init_scan(struct ubi_device *ubi, struct ubi_scan_info *si); 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 lnum); int ubi_wl_flush(struct ubi_device *ubi); +int ubi_wl_flush_lnum(struct ubi_device *ubi, int lnum); 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); diff --git a/drivers/mtd/ubi/wl.c b/drivers/mtd/ubi/wl.c index 7f6dd7e..bc8111d 100644 --- a/drivers/mtd/ubi/wl.c +++ b/drivers/mtd/ubi/wl.c @@ -1278,6 +1278,41 @@ retry: } /** + * ubi_wl_flush_lnum - flush all pending works associated with a LEB number + * @ubi: UBI device description object + * @lnum: the LEB number only for which work should be synchronously executed + * + * This function executes all pending works for PEBs whose associated with a + * particular LEB number. This function returns zero in case of success and a + * negative error code in case of failure. + */ +int ubi_wl_flush_lnum(struct ubi_device *ubi, int lnum) +{ + int err = 0; + struct ubi_work *wrk, *tmp; + + /* For each pending work, if it corresponds to the parameter @lnum, + * then execute the work. + */ + dbg_wl("flush lnum %d", lnum); + list_for_each_entry_safe(wrk, tmp, &ubi->works, list) { + if (wrk->lnum == lnum) { + spin_lock(&ubi->wl_lock); + list_del(&wrk->list); + ubi->works_count -= 1; + ubi_assert(ubi->works_count >= 0); + spin_unlock(&ubi->wl_lock); + + err = wrk->func(ubi, wrk, 0); + if (err) + ubi_err("work failed with error code %d", err); + } + } + + return err; +} + +/** * ubi_wl_flush - flush all pending works. * @ubi: UBI device description object * diff --git a/include/linux/mtd/ubi.h b/include/linux/mtd/ubi.h index db4836b..1d1b6a1 100644 --- a/include/linux/mtd/ubi.h +++ b/include/linux/mtd/ubi.h @@ -216,6 +216,7 @@ 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); int ubi_sync(int ubi_num); +int ubi_lnum_purge(int ubi_num, int lnum); /* * This function is the same as the 'ubi_leb_read()' function, but it does not