1 /*
2 * Copyright (c) 2016 Mellanox Technologies Ltd. All rights reserved.
3 * Copyright (c) 2015 System Fabric Works, Inc. All rights reserved.
4 *
5 * This software is available to you under a choice of one of two
6 * licenses. You may choose to be licensed under the terms of the GNU
7 * General Public License (GPL) Version 2, available from the file
8 * COPYING in the main directory of this source tree, or the
9 * OpenIB.org BSD license below:
10 *
11 * Redistribution and use in source and binary forms, with or
12 * without modification, are permitted provided that the following
13 * conditions are met:
14 *
15 * - Redistributions of source code must retain the above
16 * copyright notice, this list of conditions and the following
17 * disclaimer.
18 *
19 * - Redistributions in binary form must reproduce the above
20 * copyright notice, this list of conditions and the following
21 * disclaimer in the documentation and/or other materials
22 * provided with the distribution.
23 *
24 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
25 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
26 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
27 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
28 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
29 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
30 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
31 * SOFTWARE.
32 */
33
34 #include <linux/kernel.h>
35 #include <linux/interrupt.h>
36 #include <linux/hardirq.h>
37
38 #include "rxe_task.h"
39
40 int __rxe_do_task(struct rxe_task *task)
41
42 {
43 int ret;
44
45 while ((ret = task->func(task->arg)) == 0)
46 ;
47
48 task->ret = ret;
49
50 return ret;
51 }
52
53 /*
54 * this locking is due to a potential race where
55 * a second caller finds the task already running
56 * but looks just after the last call to func
57 */
58 void rxe_do_task(unsigned long data)
59 {
60 int cont;
61 int ret;
62 unsigned long flags;
63 struct rxe_task *task = (struct rxe_task *)data;
64
65 spin_lock_irqsave(&task->state_lock, flags);
66 switch (task->state) {
67 case TASK_STATE_START:
68 task->state = TASK_STATE_BUSY;
69 spin_unlock_irqrestore(&task->state_lock, flags);
70 break;
71
72 case TASK_STATE_BUSY:
73 task->state = TASK_STATE_ARMED;
74 /* fall through */
75 case TASK_STATE_ARMED:
76 spin_unlock_irqrestore(&task->state_lock, flags);
77 return;
78
79 default:
80 spin_unlock_irqrestore(&task->state_lock, flags);
81 pr_warn("%s failed with bad state %d\n", __func__, task->state);
82 return;
83 }
84
85 do {
86 cont = 0;
87 ret = task->func(task->arg);
88
89 spin_lock_irqsave(&task->state_lock, flags);
90 switch (task->state) {
91 case TASK_STATE_BUSY:
92 if (ret)
93 task->state = TASK_STATE_START;
94 else
95 cont = 1;
96 break;
97
98 /* soneone tried to run the task since the last time we called
99 * func, so we will call one more time regardless of the
100 * return value
101 */
102 case TASK_STATE_ARMED:
103 task->state = TASK_STATE_BUSY;
104 cont = 1;
105 break;
106
107 default:
108 pr_warn("%s failed with bad state %d\n", __func__,
109 task->state);
110 }
111 spin_unlock_irqrestore(&task->state_lock, flags);
112 } while (cont);
113
114 task->ret = ret;
115 }
116
117 int rxe_init_task(void *obj, struct rxe_task *task,
118 void *arg, int (*func)(void *), char *name)
119 {
120 task->obj = obj;
121 task->arg = arg;
122 task->func = func;
123 snprintf(task->name, sizeof(task->name), "%s", name);
124 task->destroyed = false;
125
126 tasklet_init(&task->tasklet, rxe_do_task, (unsigned long)task);
127
128 task->state = TASK_STATE_START;
129 spin_lock_init(&task->state_lock);
130
131 return 0;
132 }
133
134 void rxe_cleanup_task(struct rxe_task *task)
135 {
136 unsigned long flags;
137 bool idle;
138
139 /*
140 * Mark the task, then wait for it to finish. It might be
141 * running in a non-tasklet (direct call) context.
142 */
143 task->destroyed = true;
144
145 do {
146 spin_lock_irqsave(&task->state_lock, flags);
147 idle = (task->state == TASK_STATE_START);
148 spin_unlock_irqrestore(&task->state_lock, flags);
149 } while (!idle);
150
151 tasklet_kill(&task->tasklet);
152 }
153
154 void rxe_run_task(struct rxe_task *task, int sched)
155 {
156 if (task->destroyed)
157 return;
158
159 if (sched)
160 tasklet_schedule(&task->tasklet);
161 else
162 rxe_do_task((unsigned long)task);
163 }
164
165 void rxe_disable_task(struct rxe_task *task)
166 {
167 tasklet_disable(&task->tasklet);
168 }
169
170 void rxe_enable_task(struct rxe_task *task)
171 {
172 tasklet_enable(&task->tasklet);
173 }