1 // SPDX-License-Identifier: GPL-2.0 OR Linux-OpenIB
2 /*
3  * Copyright (c) 2016 Mellanox Technologies Ltd. All rights reserved.
4  * Copyright (c) 2015 System Fabric Works, Inc. All rights reserved.
5  */
6 
7 #include "rxe.h"
8 
9 int __rxe_do_task(struct rxe_task *task)
10 
11 {
12 	int ret;
13 
14 	while ((ret = task->func(task->arg)) == 0)
15 		;
16 
17 	task->ret = ret;
18 
19 	return ret;
20 }
21 
22 /*
23  * this locking is due to a potential race where
24  * a second caller finds the task already running
25  * but looks just after the last call to func
26  */
27 static void do_task(struct tasklet_struct *t)
28 {
29 	int cont;
30 	int ret;
31 	struct rxe_task *task = from_tasklet(task, t, tasklet);
32 	struct rxe_qp *qp = (struct rxe_qp *)task->arg;
33 	unsigned int iterations = RXE_MAX_ITERATIONS;
34 
35 	spin_lock_bh(&task->lock);
36 	switch (task->state) {
37 	case TASK_STATE_START:
38 		task->state = TASK_STATE_BUSY;
39 		spin_unlock_bh(&task->lock);
40 		break;
41 
42 	case TASK_STATE_BUSY:
43 		task->state = TASK_STATE_ARMED;
44 		fallthrough;
45 	case TASK_STATE_ARMED:
46 		spin_unlock_bh(&task->lock);
47 		return;
48 
49 	default:
50 		spin_unlock_bh(&task->lock);
51 		rxe_dbg_qp(qp, "failed with bad state %d\n", task->state);
52 		return;
53 	}
54 
55 	do {
56 		cont = 0;
57 		ret = task->func(task->arg);
58 
59 		spin_lock_bh(&task->lock);
60 		switch (task->state) {
61 		case TASK_STATE_BUSY:
62 			if (ret) {
63 				task->state = TASK_STATE_START;
64 			} else if (iterations--) {
65 				cont = 1;
66 			} else {
67 				/* reschedule the tasklet and exit
68 				 * the loop to give up the cpu
69 				 */
70 				tasklet_schedule(&task->tasklet);
71 				task->state = TASK_STATE_START;
72 			}
73 			break;
74 
75 		/* someone tried to run the task since the last time we called
76 		 * func, so we will call one more time regardless of the
77 		 * return value
78 		 */
79 		case TASK_STATE_ARMED:
80 			task->state = TASK_STATE_BUSY;
81 			cont = 1;
82 			break;
83 
84 		default:
85 			rxe_dbg_qp(qp, "failed with bad state %d\n",
86 					task->state);
87 		}
88 		spin_unlock_bh(&task->lock);
89 	} while (cont);
90 
91 	task->ret = ret;
92 }
93 
94 int rxe_init_task(struct rxe_task *task, void *arg, int (*func)(void *))
95 {
96 	task->arg	= arg;
97 	task->func	= func;
98 	task->destroyed	= false;
99 
100 	tasklet_setup(&task->tasklet, do_task);
101 
102 	task->state = TASK_STATE_START;
103 	spin_lock_init(&task->lock);
104 
105 	return 0;
106 }
107 
108 void rxe_cleanup_task(struct rxe_task *task)
109 {
110 	bool idle;
111 
112 	/*
113 	 * Mark the task, then wait for it to finish. It might be
114 	 * running in a non-tasklet (direct call) context.
115 	 */
116 	task->destroyed = true;
117 
118 	do {
119 		spin_lock_bh(&task->lock);
120 		idle = (task->state == TASK_STATE_START);
121 		spin_unlock_bh(&task->lock);
122 	} while (!idle);
123 
124 	tasklet_kill(&task->tasklet);
125 }
126 
127 void rxe_run_task(struct rxe_task *task)
128 {
129 	if (task->destroyed)
130 		return;
131 
132 	do_task(&task->tasklet);
133 }
134 
135 void rxe_sched_task(struct rxe_task *task)
136 {
137 	if (task->destroyed)
138 		return;
139 
140 	tasklet_schedule(&task->tasklet);
141 }
142 
143 void rxe_disable_task(struct rxe_task *task)
144 {
145 	tasklet_disable(&task->tasklet);
146 }
147 
148 void rxe_enable_task(struct rxe_task *task)
149 {
150 	tasklet_enable(&task->tasklet);
151 }
152