Whamcloud - gitweb
LU-9014 test: handle separate MGS in conf-sanity test_72()
[fs/lustre-release.git] / lnet / selftest / timer.c
1 /*
2  * GPL HEADER START
3  *
4  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 only,
8  * as published by the Free Software Foundation.
9  *
10  * This program is distributed in the hope that it will be useful, but
11  * WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13  * General Public License version 2 for more details (a copy is included
14  * in the LICENSE file that accompanied this code).
15  *
16  * You should have received a copy of the GNU General Public License
17  * version 2 along with this program; If not, see
18  * http://www.gnu.org/licenses/gpl-2.0.html
19  *
20  * GPL HEADER END
21  */
22 /*
23  * Copyright (c) 2007, 2010, Oracle and/or its affiliates. All rights reserved.
24  * Use is subject to license terms.
25  *
26  * Copyright (c) 2011, 2013, Intel Corporation.
27  */
28 /*
29  * This file is part of Lustre, http://www.lustre.org/
30  * Lustre is a trademark of Sun Microsystems, Inc.
31  *
32  * lnet/selftest/timer.c
33  *
34  * Author: Isaac Huang <isaac@clusterfs.com>
35  */
36
37 #define DEBUG_SUBSYSTEM S_LNET
38
39 #include "selftest.h"
40
41
42 /*
43  * Timers are implemented as a sorted queue of expiry times. The queue
44  * is slotted, with each slot holding timers which expire in a
45  * 2**STTIMER_MINPOLL (8) second period. The timers in each slot are
46  * sorted by increasing expiry time. The number of slots is 2**7 (128),
47  * to cover a time period of 1024 seconds into the future before wrapping.
48  */
49 #define STTIMER_MINPOLL        3   /* log2 min poll interval (8 s) */
50 #define STTIMER_SLOTTIME       (1 << STTIMER_MINPOLL)
51 #define STTIMER_SLOTTIMEMASK   (~(STTIMER_SLOTTIME - 1))
52 #define STTIMER_NSLOTS         (1 << 7)
53 #define STTIMER_SLOT(t)        (&stt_data.stt_hash[(((t) >> STTIMER_MINPOLL) & \
54                                                     (STTIMER_NSLOTS - 1))])
55
56 static struct st_timer_data {
57         spinlock_t              stt_lock;
58         /* start time of the slot processed previously */
59         cfs_time_t              stt_prev_slot;
60         struct list_head        stt_hash[STTIMER_NSLOTS];
61         int                     stt_shuttingdown;
62         wait_queue_head_t       stt_waitq;
63         int                     stt_nthreads;
64 } stt_data;
65
66 void
67 stt_add_timer(stt_timer_t *timer)
68 {
69         struct list_head *pos;
70
71         spin_lock(&stt_data.stt_lock);
72
73         LASSERT(stt_data.stt_nthreads > 0);
74         LASSERT(!stt_data.stt_shuttingdown);
75         LASSERT(timer->stt_func != NULL);
76         LASSERT(list_empty(&timer->stt_list));
77         LASSERT(timer->stt_expires > ktime_get_real_seconds());
78
79         /* a simple insertion sort */
80         list_for_each_prev(pos, STTIMER_SLOT(timer->stt_expires)) {
81                 stt_timer_t *old = list_entry(pos, stt_timer_t, stt_list);
82
83                 if (timer->stt_expires >= old->stt_expires)
84                         break;
85         }
86         list_add(&timer->stt_list, pos);
87
88         spin_unlock(&stt_data.stt_lock);
89 }
90
91 /*
92  * The function returns whether it has deactivated a pending timer or not.
93  * (ie. del_timer() of an inactive timer returns 0, del_timer() of an
94  * active timer returns 1.)
95  *
96  * CAVEAT EMPTOR:
97  * When 0 is returned, it is possible that timer->stt_func _is_ running on
98  * another CPU.
99  */
100 int
101 stt_del_timer(stt_timer_t *timer)
102 {
103         int ret = 0;
104
105         spin_lock(&stt_data.stt_lock);
106
107         LASSERT(stt_data.stt_nthreads > 0);
108         LASSERT(!stt_data.stt_shuttingdown);
109
110         if (!list_empty(&timer->stt_list)) {
111                 ret = 1;
112                 list_del_init(&timer->stt_list);
113         }
114
115         spin_unlock(&stt_data.stt_lock);
116         return ret;
117 }
118
119 /* called with stt_data.stt_lock held */
120 static int
121 stt_expire_list(struct list_head *slot, time64_t now)
122 {
123         int          expired = 0;
124         stt_timer_t *timer;
125
126         while (!list_empty(slot)) {
127                 timer = list_entry(slot->next, stt_timer_t, stt_list);
128
129                 if (timer->stt_expires > now)
130                         break;
131
132                 list_del_init(&timer->stt_list);
133                 spin_unlock(&stt_data.stt_lock);
134
135                 expired++;
136                 (*timer->stt_func) (timer->stt_data);
137
138                 spin_lock(&stt_data.stt_lock);
139         }
140
141         return expired;
142 }
143
144 static int
145 stt_check_timers(cfs_time_t *last)
146 {
147         int expired = 0;
148         time64_t now;
149         cfs_time_t this_slot;
150
151         now = ktime_get_real_seconds();
152         this_slot = now & STTIMER_SLOTTIMEMASK;
153
154         spin_lock(&stt_data.stt_lock);
155
156         while (cfs_time_aftereq(this_slot, *last)) {
157                 expired += stt_expire_list(STTIMER_SLOT(this_slot), now);
158                 this_slot = cfs_time_sub(this_slot, STTIMER_SLOTTIME);
159         }
160
161         *last = now & STTIMER_SLOTTIMEMASK;
162         spin_unlock(&stt_data.stt_lock);
163         return expired;
164 }
165
166
167 static int
168 stt_timer_main (void *arg)
169 {
170         int rc = 0;
171
172         cfs_block_allsigs();
173
174         while (!stt_data.stt_shuttingdown) {
175                 stt_check_timers(&stt_data.stt_prev_slot);
176
177                 rc = wait_event_timeout(stt_data.stt_waitq,
178                                         stt_data.stt_shuttingdown,
179                                         cfs_time_seconds(STTIMER_SLOTTIME));
180         }
181
182         spin_lock(&stt_data.stt_lock);
183         stt_data.stt_nthreads--;
184         spin_unlock(&stt_data.stt_lock);
185         return rc;
186 }
187
188 static int
189 stt_start_timer_thread (void)
190 {
191         struct task_struct *task;
192
193         LASSERT(!stt_data.stt_shuttingdown);
194
195         task = kthread_run(stt_timer_main, NULL, "st_timer");
196         if (IS_ERR(task))
197                 return PTR_ERR(task);
198
199         spin_lock(&stt_data.stt_lock);
200         stt_data.stt_nthreads++;
201         spin_unlock(&stt_data.stt_lock);
202         return 0;
203 }
204
205
206 int
207 stt_startup (void)
208 {
209         int rc = 0;
210         int i;
211
212         stt_data.stt_shuttingdown = 0;
213         stt_data.stt_prev_slot = ktime_get_real_seconds() & STTIMER_SLOTTIMEMASK;
214
215         spin_lock_init(&stt_data.stt_lock);
216         for (i = 0; i < STTIMER_NSLOTS; i++)
217                 INIT_LIST_HEAD(&stt_data.stt_hash[i]);
218
219         stt_data.stt_nthreads = 0;
220         init_waitqueue_head(&stt_data.stt_waitq);
221         rc = stt_start_timer_thread();
222         if (rc != 0)
223                 CERROR ("Can't spawn timer thread: %d\n", rc);
224
225         return rc;
226 }
227
228 void
229 stt_shutdown(void)
230 {
231         int i;
232
233         spin_lock(&stt_data.stt_lock);
234
235         for (i = 0; i < STTIMER_NSLOTS; i++)
236                 LASSERT(list_empty(&stt_data.stt_hash[i]));
237
238         stt_data.stt_shuttingdown = 1;
239
240         wake_up(&stt_data.stt_waitq);
241         lst_wait_until(stt_data.stt_nthreads == 0, stt_data.stt_lock,
242                        "waiting for %d threads to terminate\n",
243                        stt_data.stt_nthreads);
244
245         spin_unlock(&stt_data.stt_lock);
246 }