lustre/llite/commit_callback.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  *  The daemon that causes completed but not committed transactions
   5  *   on the MDS to be flushed periodically when they are committed.
   6  *   A gratuitous getattr RPC is made to the MDS to discover the
   7  *   last committed record.
   8  *
   9  *  Lustre High Availability Daemon
  10  *
  11  *  Copyright (C) 2001, 2002 Cluster File Systems, Inc.
  12  *
  13  *  This code is issued under the GNU General Public License.
  14  *  See the file COPYING in this distribution
  15  *
  16  *  by Peter Braam <braam@clusterfs.com>
  17  *
  18  */
  19
  20 #define EXPORT_SYMTAB
  21
  22 #include <linux/version.h>
  23 #include <linux/module.h>
  24 #include <linux/fs.h>
  25 #include <linux/stat.h>
  26 #include <linux/sched.h>
  27 #include <linux/smp_lock.h>
  28 #include <linux/kmod.h>
  29 #include <linux/quotaops.h>
  30 #include <asm/unistd.h>
  31 #include <asm/uaccess.h>
  32
  33 #define DEBUG_SUBSYSTEM S_LLITE
  34
  35 #include <linux/lustre_lite.h>
  36 #include <linux/lustre_lib.h>
  37
  38 static int ll_commitcbd_check_event(struct ll_sb_info *sbi)
  39 {
  40         int rc = 0;
  41         ENTRY;
  42
  43         spin_lock(&sbi->ll_commitcbd_lock);
  44         if (sbi->ll_commitcbd_flags & LL_COMMITCBD_STOPPING) {
  45                 GOTO(out, rc = 1);
  46         }
  47
  48  out:
  49         spin_unlock(&sbi->ll_commitcbd_lock);
  50         RETURN(rc);
  51 }
  52
  53 static int ll_commitcbd_main(void *arg)
  54 {
  55         struct ll_sb_info *sbi = (struct ll_sb_info *)arg;
  56
  57         ENTRY;
  58
  59         lock_kernel();
  60         daemonize();
  61         spin_lock_irq(&current->sigmask_lock);
  62         sigfillset(&current->blocked);
  63         recalc_sigpending(current);
  64         spin_unlock_irq(&current->sigmask_lock);
  65
  66         sprintf(current->comm, "lustre_commitcbd");
  67         unlock_kernel();
  68
  69         /* Record that the  thread is running */
  70         sbi->ll_commitcbd_waketime = CURRENT_TIME;
  71         sbi->ll_commitcbd_timeout = 10 * HZ;
  72         sbi->ll_commitcbd_thread = current;
  73         sbi->ll_commitcbd_flags =  LL_COMMITCBD_RUNNING;
  74         wake_up(&sbi->ll_commitcbd_ctl_waitq);
  75
  76         /* And now, loop forever on requests */
  77         while (1) {
  78                 wait_event(sbi->ll_commitcbd_waitq,
  79                            ll_commitcbd_check_event(sbi));
  80
  81                 spin_lock(&sbi->ll_commitcbd_lock);
  82                 if (sbi->ll_commitcbd_flags & LL_COMMITCBD_STOPPING) {
  83                         spin_unlock(&sbi->ll_commitcbd_lock);
  84                         CERROR("lustre_commitd quitting\n");
  85                         EXIT;
  86                         break;
  87                 }
  88
  89                 schedule_timeout(sbi->ll_commitcbd_timeout);
  90                 CERROR("commit callback daemon woken up - FIXME\n");
  91                 spin_unlock(&sbi->ll_commitcbd_lock);
  92         }
  93
  94         sbi->ll_commitcbd_thread = NULL;
  95         sbi->ll_commitcbd_flags = LL_COMMITCBD_STOPPED;
  96         wake_up(&sbi->ll_commitcbd_ctl_waitq);
  97         CDEBUG(D_NET, "commit callback daemon exiting %d\n", current->pid);
  98         RETURN(0);
  99 }
 100
 101
 102
 103 int ll_commitcbd_setup(struct ll_sb_info *sbi)
 104 {
 105         int rc;
 106         ENTRY;
 107
 108         rc = kernel_thread(ll_commitcbd_main, (void *) sbi,
 109                            CLONE_VM | CLONE_FS | CLONE_FILES);
 110         if (rc < 0) {
 111                 CERROR("cannot start thread\n");
 112                 RETURN(rc);
 113         }
 114         wait_event(sbi->ll_commitcbd_ctl_waitq,
 115                    sbi->ll_commitcbd_flags & LL_COMMITCBD_RUNNING);
 116         RETURN(0);
 117 }
 118
 119
 120 int ll_commitcbd_cleanup(struct ll_sb_info *sbi)
 121 {
 122         sbi->ll_commitcbd_flags = LL_COMMITCBD_STOPPING;
 123
 124         wake_up(&sbi->ll_commitcbd_waitq);
 125         wait_event(sbi->ll_commitcbd_ctl_waitq,
 126                    sbi->ll_commitcbd_flags & LL_COMMITCBD_STOPPED);
 127         RETURN(0);
 128 }