[PATCH 22/44 take 2] [UBI] background thread unit implementation

Artem Bityutskiy
2007-02-17T17:04:57Z

diff -auNrp tmp-from/drivers/mtd/ubi/background.c tmp-to/drivers/mtd/ubi/background.c
--- tmp-from/drivers/mtd/ubi/background.c 1970-01-01 02:00:00.000000000 +0200
+++ tmp-to/drivers/mtd/ubi/background.c 2007-02-17 18:07:27.000000000 +0200
@@ -0,0 +1,352 @@
+/*
+ * 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
+ *
+ * Authors: Thomas Gleixner, Artem B. Bityutskiy
+ */
+
+#include <linux/string.h>
+#include <linux/sched.h>
+#include <linux/completion.h>
+#include <linux/spinlock.h>
+#include <linux/mutex.h>
+#include <linux/freezer.h>
+#include "ubi.h"
+#include "alloc.h"
+#include "debug.h"
+#include "background.h"
+#include "eba.h"
+
+/* Background thread name pattern */
+#define BGT_NAME_PATTERN "ubi_bgt%dd"
+
+/* Highest number of pending works */
+#define BGT_MAX_PENDING_WORKS 0x7FFFFFFF
+
+/*
+ * Maximum number of consecutive background thread failures which is enough to
+ * disable the thread.
+ */
+#define BGT_MAX_FAILURES 32
+
+int ubi_bgt_schedule(const struct ubi_info *ubi, struct ubi_bgt_work *wrk)
+{
+ int err = 0;
+ struct ubi_bgt_info *bgt = ubi->bgt;
+
+retry:
+ spin_lock(&bgt->lock);
+ dbg_bgt("%s: schedule work %p (func %p, priv %p)",
+ bgt->bgt_name, wrk, wrk->func, wrk->priv);
+
+ if (unlikely(!bgt->task)) {
+ ubi_err("task \"%s\" was killed", bgt->bgt_name);
+ spin_unlock(&bgt->lock);
+ return -ENODEV;
+ }
+
+ if (unlikely(bgt->pending_works_count == BGT_MAX_PENDING_WORKS)) {
+ /* Too many pending works */
+ spin_unlock(&bgt->lock);
+ dbg_bgt("pending queue is too long, do a work now");
+ err = ubi_bgt_do_work(ubi);
+ if (unlikely(err))
+ goto out;
+
+ cond_resched();
+ goto retry;
+ }
+
+ list_add_tail(&wrk->list, &bgt->pending_works);
+ bgt->pending_works_count += 1;
+
+ if (!bgt->active_work && likely(bgt->enabled))
+ wake_up_process(bgt->task);
+
+out:
+ spin_unlock(&bgt->lock);
+ return err;
+}
+
+int ubi_bgt_reschedule(const struct ubi_info *ubi, struct ubi_bgt_work *wrk)
+{
+ struct ubi_bgt_info *bgt = ubi->bgt;
+
+ spin_lock(&bgt->lock);
+ dbg_bgt("%s: re-schedule work %p (func %p, priv %p)",
+ bgt->bgt_name, wrk, wrk->func, wrk->priv);
+
+ if (unlikely(!bgt->task)) {
+ ubi_err("task \"%s\" was killed", bgt->bgt_name);
+ spin_unlock(&bgt->lock);
+ return -ENODEV;
+ }
+
+ list_add_tail(&wrk->list, &bgt->pending_works);
+ bgt->pending_works_count += 1;
+
+ if (!bgt->active_work && likely(bgt->enabled))
+ wake_up_process(bgt->task);
+ spin_unlock(&bgt->lock);
+ return 0;
+}
+
+int ubi_bgt_enable(const struct ubi_info *ubi)
+{
+ struct ubi_bgt_info *bgt = ubi->bgt;
+
+ spin_lock(&bgt->lock);
+ dbg_bgt("enable \"%s\"", bgt->bgt_name);
+
+ if (!bgt->task) {
+ ubi_err("task \"%s\" was killed", bgt->bgt_name);
+ spin_unlock(&bgt->lock);
+ return -ENODEV;
+ }
+
+ bgt->enabled = 1;
+ wake_up_process(bgt->task);
+ spin_unlock(&bgt->lock);
+ return 0;
+}
+
+void ubi_bgt_disable(const struct ubi_info *ubi)
+{
+ struct ubi_bgt_info *bgt = ubi->bgt;
+
+ spin_lock(&bgt->lock);
+ dbg_bgt("disable \"%s\"", bgt->bgt_name);
+ bgt->enabled = 0;
+ spin_unlock(&bgt->lock);
+}
+
+void ubi_bgt_kill_thread(const struct ubi_info *ubi)
+{
+ struct ubi_bgt_info *bgt = ubi->bgt;
+
+ dbg_bgt("disable \"%s\"", bgt->bgt_name);
+ if (bgt->task) {
+ send_sig(SIGKILL, bgt->task, 1);
+ wait_for_completion(&bgt->thread_stop);
+ }
+}
+
+int ubi_bgt_do_work(const struct ubi_info *ubi)
+{
+ int err;
+ struct ubi_bgt_work *wrk;
+ struct ubi_bgt_info *bgt = ubi->bgt;
+
+ mutex_lock(&bgt->wrk_mutex);
+
+ spin_lock(&bgt->lock);
+
+ if (unlikely(bgt->pending_works_count == 0)) {
+ err = 0;
+ goto out;
+ }
+
+ bgt->active_work = wrk = list_entry(bgt->pending_works.next,
+ struct ubi_bgt_work, list);
+ list_del(&wrk->list);
+ bgt->pending_works_count -= 1;
+ ubi_assert(bgt->pending_works_count >= 0);
+ spin_unlock(&bgt->lock);
+
+ /*
+ * Call the worker function. Do not touch the work structure
+ * after this call as it will have been freed or reused by that
+ * time by the worker function.
+ */
+ dbg_bgt("%s: do work %p (func %p, priv %p)",
+ bgt->bgt_name, wrk, wrk->func, wrk->priv);
+
+ err = wrk->func(ubi, wrk, 0);
+ if (unlikely(err))
+ ubi_err("a work failed with error code %d", err);
+
+ spin_lock(&bgt->lock);
+ bgt->active_work = NULL;
+out:
+ spin_unlock(&bgt->lock);
+ mutex_unlock(&bgt->wrk_mutex);
+ return err;
+}
+
+/**
+ * ubi_thread - UBI background thread.
+ *
+ * @u: the UBI device description object pointer
+ */
+static int ubi_thread(void *u)
+{
+ int failures = 0;
+ const struct ubi_info *ubi = u;
+ struct ubi_bgt_info *bgt = ubi->bgt;
+
+ daemonize(bgt->bgt_name);
+ allow_signal(SIGKILL);
+ allow_signal(SIGSTOP);
+
+ ubi_msg("background thread \"%s\" started, PID %d",
+ bgt->bgt_name, current->pid);
+
+ bgt->task = current;
+ complete(&bgt->thread_start);
+ set_current_state(TASK_INTERRUPTIBLE);
+ schedule();
+
+ for (;;) {
+ cond_resched();
+
+ if (unlikely(!bgt->enabled) ||
+ list_empty(&bgt->pending_works)) {
+ set_current_state(TASK_INTERRUPTIBLE);
+ schedule();
+ }
+
+ if (try_to_freeze())
+ continue;
+
+ while (signal_pending(current)) {
+ siginfo_t info;
+ unsigned long nr;
+
+ nr = dequeue_signal_lock(current, &current->blocked,
+ &info);
+ if (nr == SIGKILL)
+ goto out;
+ if (nr == SIGSTOP) {
+ bgt->enabled = !bgt->enabled;
+ ubi_msg("%s the background thread",
+ bgt->enabled ? "enable" : "disable");
+ }
+ }
+
+ spin_lock(&bgt->lock);
+ while (bgt->pending_works_count > 0 && likely(bgt->enabled)) {
+ int err;
+
+ ubi_assert(!list_empty(&bgt->pending_works));
+ spin_unlock(&bgt->lock);
+
+ cond_resched();
+
+ err = ubi_bgt_do_work(ubi);
+ if (unlikely(err)) {
+ ubi_err("%s: work failed with error code %d",
+ bgt->bgt_name, err);
+ if (failures++ > BGT_MAX_FAILURES) {
+ /*
+ * Too many failures, disable the
+ * thread and switch to read-only mode.
+ */
+ ubi_msg("%d consecutive failures, "
+ "disable the background thread",
+ BGT_MAX_FAILURES);
+ ubi_bgt_disable(ubi);
+ ubi_eba_ro_mode(ubi);
+ break;
+ } else
+ failures = 0;
+ }
+
+ spin_lock(&bgt->lock);
+ }
+ spin_unlock(&bgt->lock);
+ }
+
+out:
+ dbg_bgt("killing background thread \"%s\"", bgt->bgt_name);
+
+ /* Cancel all pending works before exiting */
+ spin_lock(&bgt->lock);
+ bgt->task = NULL;
+
+ bgt->enabled = 0;
+ while (!list_empty(&bgt->pending_works)) {
+ struct ubi_bgt_work *wrk;
+
+ wrk = list_entry(bgt->pending_works.next, struct ubi_bgt_work,
+ list);
+ list_del(&wrk->list);
+ bgt->pending_works_count -= 1;
+ spin_unlock(&bgt->lock);
+ wrk->func(ubi, wrk, 1);
+ spin_lock(&bgt->lock);
+ }
+ spin_unlock(&bgt->lock);
+
+ complete_and_exit(&bgt->thread_stop, 0);
+}
+
+int ubi_bgt_init(struct ubi_info *ubi)
+{
+ int err;
+ pid_t pid;
+ struct ubi_bgt_info *bgt;
+
+ dbg_bgt("initialize the UBI background thread unit");
+
+ bgt = ubi_kzalloc(sizeof(struct ubi_bgt_info));
+ if (!bgt)
+ return -ENOMEM;
+ ubi->bgt = bgt;
+
+ init_completion(&bgt->thread_start);
+ init_completion(&bgt->thread_stop);
+ INIT_LIST_HEAD(&bgt->pending_works);
+ spin_lock_init(&bgt->lock);
+ mutex_init(&bgt->wrk_mutex);
+
+ bgt->bgt_name = ubi_kmalloc(sizeof(BGT_NAME_PATTERN) + 20);
+ if (!bgt->bgt_name) {
+ err = -ENOMEM;
+ goto out_bgt;
+ }
+ sprintf(bgt->bgt_name, BGT_NAME_PATTERN, ubi->ubi_num);
+
+ pid = kernel_thread(ubi_thread, ubi, CLONE_FS | CLONE_FILES);
+ if (pid < 0) {
+ err = pid;
+ ubi_err("cannot spawn \"%s\", error %d", bgt->bgt_name, err);
+ goto out_name;
+ }
+
+ wait_for_completion(&bgt->thread_start);
+ dbg_bgt("the UBI background thread unit is initialized");
+ return 0;
+
+out_name:
+ ubi_kfree(bgt->bgt_name);
+out_bgt:
+ ubi_kfree(bgt);
+ return err;
+}
+
+void ubi_bgt_close(struct ubi_info *ubi)
+{
+ struct ubi_bgt_info *bgt = ubi->bgt;
+
+ dbg_bgt("close the UBI background thread unit");
+
+ ubi_assert(!bgt->enabled);
+ ubi_assert(bgt->pending_works_count == 0);
+ ubi_assert(list_empty(&bgt->pending_works));
+
+ ubi_kfree(bgt->bgt_name);
+ ubi_kfree(bgt);
+}