1 /****************************************************************************** 2 ******************************************************************************* 3 ** 4 ** Copyright (C) Sistina Software, Inc. 1997-2003 All rights reserved. 5 ** Copyright (C) 2004-2005 Red Hat, Inc. All rights reserved. 6 ** 7 ** This copyrighted material is made available to anyone wishing to use, 8 ** modify, copy, or redistribute it subject to the terms and conditions 9 ** of the GNU General Public License v.2. 10 ** 11 ******************************************************************************* 12 ******************************************************************************/ 13 14 #include "dlm_internal.h" 15 #include "lock.h" 16 #include "user.h" 17 #include "ast.h" 18 19 #define WAKE_ASTS 0 20 21 static struct list_head ast_queue; 22 static spinlock_t ast_queue_lock; 23 static struct task_struct * astd_task; 24 static unsigned long astd_wakeflags; 25 static struct mutex astd_running; 26 27 28 void dlm_del_ast(struct dlm_lkb *lkb) 29 { 30 spin_lock(&ast_queue_lock); 31 if (lkb->lkb_ast_type & (AST_COMP | AST_BAST)) 32 list_del(&lkb->lkb_astqueue); 33 spin_unlock(&ast_queue_lock); 34 } 35 36 void dlm_add_ast(struct dlm_lkb *lkb, int type) 37 { 38 if (lkb->lkb_flags & DLM_IFL_USER) { 39 dlm_user_add_ast(lkb, type); 40 return; 41 } 42 DLM_ASSERT(lkb->lkb_astaddr != DLM_FAKE_USER_AST, dlm_print_lkb(lkb);); 43 44 spin_lock(&ast_queue_lock); 45 if (!(lkb->lkb_ast_type & (AST_COMP | AST_BAST))) { 46 kref_get(&lkb->lkb_ref); 47 list_add_tail(&lkb->lkb_astqueue, &ast_queue); 48 } 49 lkb->lkb_ast_type |= type; 50 spin_unlock(&ast_queue_lock); 51 52 set_bit(WAKE_ASTS, &astd_wakeflags); 53 wake_up_process(astd_task); 54 } 55 56 static void process_asts(void) 57 { 58 struct dlm_ls *ls = NULL; 59 struct dlm_rsb *r = NULL; 60 struct dlm_lkb *lkb; 61 void (*cast) (long param); 62 void (*bast) (long param, int mode); 63 int type = 0, found, bmode; 64 65 for (;;) { 66 found = 0; 67 spin_lock(&ast_queue_lock); 68 list_for_each_entry(lkb, &ast_queue, lkb_astqueue) { 69 r = lkb->lkb_resource; 70 ls = r->res_ls; 71 72 if (dlm_locking_stopped(ls)) 73 continue; 74 75 list_del(&lkb->lkb_astqueue); 76 type = lkb->lkb_ast_type; 77 lkb->lkb_ast_type = 0; 78 found = 1; 79 break; 80 } 81 spin_unlock(&ast_queue_lock); 82 83 if (!found) 84 break; 85 86 cast = lkb->lkb_astaddr; 87 bast = lkb->lkb_bastaddr; 88 bmode = lkb->lkb_bastmode; 89 90 if ((type & AST_COMP) && cast) 91 cast(lkb->lkb_astparam); 92 93 /* FIXME: Is it safe to look at lkb_grmode here 94 without doing a lock_rsb() ? 95 Look at other checks in v1 to avoid basts. */ 96 97 if ((type & AST_BAST) && bast) 98 if (!dlm_modes_compat(lkb->lkb_grmode, bmode)) 99 bast(lkb->lkb_astparam, bmode); 100 101 /* this removes the reference added by dlm_add_ast 102 and may result in the lkb being freed */ 103 dlm_put_lkb(lkb); 104 105 schedule(); 106 } 107 } 108 109 static inline int no_asts(void) 110 { 111 int ret; 112 113 spin_lock(&ast_queue_lock); 114 ret = list_empty(&ast_queue); 115 spin_unlock(&ast_queue_lock); 116 return ret; 117 } 118 119 static int dlm_astd(void *data) 120 { 121 while (!kthread_should_stop()) { 122 set_current_state(TASK_INTERRUPTIBLE); 123 if (!test_bit(WAKE_ASTS, &astd_wakeflags)) 124 schedule(); 125 set_current_state(TASK_RUNNING); 126 127 mutex_lock(&astd_running); 128 if (test_and_clear_bit(WAKE_ASTS, &astd_wakeflags)) 129 process_asts(); 130 mutex_unlock(&astd_running); 131 } 132 return 0; 133 } 134 135 void dlm_astd_wake(void) 136 { 137 if (!no_asts()) { 138 set_bit(WAKE_ASTS, &astd_wakeflags); 139 wake_up_process(astd_task); 140 } 141 } 142 143 int dlm_astd_start(void) 144 { 145 struct task_struct *p; 146 int error = 0; 147 148 INIT_LIST_HEAD(&ast_queue); 149 spin_lock_init(&ast_queue_lock); 150 mutex_init(&astd_running); 151 152 p = kthread_run(dlm_astd, NULL, "dlm_astd"); 153 if (IS_ERR(p)) 154 error = PTR_ERR(p); 155 else 156 astd_task = p; 157 return error; 158 } 159 160 void dlm_astd_stop(void) 161 { 162 kthread_stop(astd_task); 163 } 164 165 void dlm_astd_suspend(void) 166 { 167 mutex_lock(&astd_running); 168 } 169 170 void dlm_astd_resume(void) 171 { 172 mutex_unlock(&astd_running); 173 } 174 175