1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3 * Intel MIC Platform Software Stack (MPSS)
4 *
5 * Copyright(c) 2015 Intel Corporation.
6 *
7 * Intel MIC Coprocessor State Management (COSM) Driver
8 */
9 #include <linux/kthread.h>
10 #include <linux/sched/signal.h>
11
12 #include "cosm_main.h"
13
14 /*
15 * The COSM driver uses SCIF to communicate between the management node and the
16 * MIC cards. SCIF is used to (a) Send a shutdown command to the card (b)
17 * receive a shutdown status back from the card upon completion of shutdown and
18 * (c) receive periodic heartbeat messages from the card used to deduce if the
19 * card has crashed.
20 *
21 * A COSM server consisting of a SCIF listening endpoint waits for incoming
22 * connections from the card. Upon acceptance of the connection, a separate
23 * work-item is scheduled to handle SCIF message processing for that card. The
24 * life-time of this work-item is therefore the time from which the connection
25 * from a card is accepted to the time at which the connection is closed. A new
26 * work-item starts each time the card boots and is alive till the card (a)
27 * shuts down (b) is reset (c) crashes (d) cosm_client driver on the card is
28 * unloaded.
29 *
30 * From the point of view of COSM interactions with SCIF during card
31 * shutdown, reset and crash are as follows:
32 *
33 * Card shutdown
34 * -------------
35 * 1. COSM client on the card invokes orderly_poweroff() in response to SHUTDOWN
36 * message from the host.
37 * 2. Card driver shutdown callback invokes scif_unregister_device(..) resulting
38 * in scif_remove(..) getting called on the card
39 * 3. scif_remove -> scif_stop -> scif_handle_remove_node ->
40 * scif_peer_unregister_device -> device_unregister for the host peer device
41 * 4. During device_unregister remove(..) method of cosm_client is invoked which
42 * closes the COSM SCIF endpoint on the card. This results in a SCIF_DISCNCT
43 * message being sent to host SCIF. SCIF_DISCNCT message processing on the
44 * host SCIF sets the host COSM SCIF endpoint state to DISCONNECTED and wakes
45 * up the host COSM thread blocked in scif_poll(..) resulting in
46 * scif_poll(..) returning EPOLLHUP.
47 * 5. On the card, scif_peer_release_dev is next called which results in an
48 * SCIF_EXIT message being sent to the host and after receiving the
49 * SCIF_EXIT_ACK from the host the peer device teardown on the card is
50 * complete.
51 * 6. As part of the SCIF_EXIT message processing on the host, host sends a
52 * SCIF_REMOVE_NODE to itself corresponding to the card being removed. This
53 * starts a similar SCIF peer device teardown sequence on the host
54 * corresponding to the card being shut down.
55 *
56 * Card reset
57 * ----------
58 * The case of interest here is when the card has not been previously shut down
59 * since most of the steps below are skipped in that case:
60
61 * 1. cosm_stop(..) invokes hw_ops->stop(..) method of the base PCIe driver
62 * which unregisters the SCIF HW device resulting in scif_remove(..) being
63 * called on the host.
64 * 2. scif_remove(..) calls scif_disconnect_node(..) which results in a
65 * SCIF_EXIT message being sent to the card.
66 * 3. The card executes scif_stop() as part of SCIF_EXIT message
67 * processing. This results in the COSM endpoint on the card being closed and
68 * the SCIF host peer device on the card getting unregistered similar to
69 * steps 3, 4 and 5 for the card shutdown case above. scif_poll(..) on the
70 * host returns EPOLLHUP as a result.
71 * 4. On the host, card peer device unregister and SCIF HW remove(..) also
72 * subsequently complete.
73 *
74 * Card crash
75 * ----------
76 * If a reset is issued after the card has crashed, there is no SCIF_DISCNT
77 * message from the card which would result in scif_poll(..) returning
78 * EPOLLHUP. In this case when the host SCIF driver sends a SCIF_REMOVE_NODE
79 * message to itself resulting in the card SCIF peer device being unregistered,
80 * this results in a scif_peer_release_dev -> scif_cleanup_scifdev->
81 * scif_invalidate_ep call sequence which sets the endpoint state to
82 * DISCONNECTED and results in scif_poll(..) returning EPOLLHUP.
83 */
84
85 #define COSM_SCIF_BACKLOG 16
86 #define COSM_HEARTBEAT_CHECK_DELTA_SEC 10
87 #define COSM_HEARTBEAT_TIMEOUT_SEC \
88 (COSM_HEARTBEAT_SEND_SEC + COSM_HEARTBEAT_CHECK_DELTA_SEC)
89 #define COSM_HEARTBEAT_TIMEOUT_MSEC (COSM_HEARTBEAT_TIMEOUT_SEC * MSEC_PER_SEC)
90
91 static struct task_struct *server_thread;
92 static scif_epd_t listen_epd;
93
94 /* Publish MIC card's shutdown status to user space MIC daemon */
95 static void cosm_update_mic_status(struct cosm_device *cdev)
96 {
97 if (cdev->shutdown_status_int != MIC_NOP) {
98 cosm_set_shutdown_status(cdev, cdev->shutdown_status_int);
99 cdev->shutdown_status_int = MIC_NOP;
100 }
101 }
102
103 /* Store MIC card's shutdown status internally when it is received */
104 static void cosm_shutdown_status_int(struct cosm_device *cdev,
105 enum mic_status shutdown_status)
106 {
107 switch (shutdown_status) {
108 case MIC_HALTED:
109 case MIC_POWER_OFF:
110 case MIC_RESTART:
111 case MIC_CRASHED:
112 break;
113 default:
114 dev_err(&cdev->dev, "%s %d Unexpected shutdown_status %d\n",
115 __func__, __LINE__, shutdown_status);
116 return;
117 };
118 cdev->shutdown_status_int = shutdown_status;
119 cdev->heartbeat_watchdog_enable = false;
120
121 if (cdev->state != MIC_SHUTTING_DOWN)
122 cosm_set_state(cdev, MIC_SHUTTING_DOWN);
123 }
124
125 /* Non-blocking recv. Read and process all available messages */
126 static void cosm_scif_recv(struct cosm_device *cdev)
127 {
128 struct cosm_msg msg;
129 int rc;
130
131 while (1) {
132 rc = scif_recv(cdev->epd, &msg, sizeof(msg), 0);
133 if (!rc) {
134 break;
135 } else if (rc < 0) {
136 dev_dbg(&cdev->dev, "%s: %d rc %d\n",
137 __func__, __LINE__, rc);
138 break;
139 }
140 dev_dbg(&cdev->dev, "%s: %d rc %d id 0x%llx\n",
141 __func__, __LINE__, rc, msg.id);
142
143 switch (msg.id) {
144 case COSM_MSG_SHUTDOWN_STATUS:
145 cosm_shutdown_status_int(cdev, msg.shutdown_status);
146 break;
147 case COSM_MSG_HEARTBEAT:
148 /* Nothing to do, heartbeat only unblocks scif_poll */
149 break;
150 default:
151 dev_err(&cdev->dev, "%s: %d unknown msg.id %lld\n",
152 __func__, __LINE__, msg.id);
153 break;
154 }
155 }
156 }
157
158 /* Publish crashed status for this MIC card */
159 static void cosm_set_crashed(struct cosm_device *cdev)
160 {
161 dev_err(&cdev->dev, "node alive timeout\n");
162 cosm_shutdown_status_int(cdev, MIC_CRASHED);
163 cosm_update_mic_status(cdev);
164 }
165
166 /* Send host time to the MIC card to sync system time between host and MIC */
167 static void cosm_send_time(struct cosm_device *cdev)
168 {
169 struct cosm_msg msg = { .id = COSM_MSG_SYNC_TIME };
170 struct timespec64 ts;
171 int rc;
172
173 ktime_get_real_ts64(&ts);
174 msg.timespec.tv_sec = ts.tv_sec;
175 msg.timespec.tv_nsec = ts.tv_nsec;
176
177 rc = scif_send(cdev->epd, &msg, sizeof(msg), SCIF_SEND_BLOCK);
178 if (rc < 0)
179 dev_err(&cdev->dev, "%s %d scif_send failed rc %d\n",
180 __func__, __LINE__, rc);
181 }
182
183 /*
184 * Close this cosm_device's endpoint after its peer endpoint on the card has
185 * been closed. In all cases except MIC card crash EPOLLHUP on the host is
186 * triggered by the client's endpoint being closed.
187 */
188 static void cosm_scif_close(struct cosm_device *cdev)
189 {
190 /*
191 * Because SHUTDOWN_STATUS message is sent by the MIC cards in the
192 * reboot notifier when shutdown is still not complete, we notify mpssd
193 * to reset the card when SCIF endpoint is closed.
194 */
195 cosm_update_mic_status(cdev);
196 scif_close(cdev->epd);
197 cdev->epd = NULL;
198 dev_dbg(&cdev->dev, "%s %d\n", __func__, __LINE__);
199 }
200
201 /*
202 * Set card state to ONLINE when a new SCIF connection from a MIC card is
203 * received. Normally the state is BOOTING when the connection comes in, but can
204 * be ONLINE if cosm_client driver on the card was unloaded and then reloaded.
205 */
206 static int cosm_set_online(struct cosm_device *cdev)
207 {
208 int rc = 0;
209
210 if (MIC_BOOTING == cdev->state || MIC_ONLINE == cdev->state) {
211 cdev->heartbeat_watchdog_enable = cdev->sysfs_heartbeat_enable;
212 cdev->epd = cdev->newepd;
213 if (cdev->state == MIC_BOOTING)
214 cosm_set_state(cdev, MIC_ONLINE);
215 cosm_send_time(cdev);
216 dev_dbg(&cdev->dev, "%s %d\n", __func__, __LINE__);
217 } else {
218 dev_warn(&cdev->dev, "%s %d not going online in state: %s\n",
219 __func__, __LINE__, cosm_state_string[cdev->state]);
220 rc = -EINVAL;
221 }
222 /* Drop reference acquired by bus_find_device in the server thread */
223 put_device(&cdev->dev);
224 return rc;
225 }
226
227 /*
228 * Work function for handling work for a SCIF connection from a particular MIC
229 * card. It first sets the card state to ONLINE and then calls scif_poll to
230 * block on activity such as incoming messages on the SCIF endpoint. When the
231 * endpoint is closed, the work function exits, completing its life cycle, from
232 * MIC card boot to card shutdown/reset/crash.
233 */
234 void cosm_scif_work(struct work_struct *work)
235 {
236 struct cosm_device *cdev = container_of(work, struct cosm_device,
237 scif_work);
238 struct scif_pollepd pollepd;
239 int rc;
240
241 mutex_lock(&cdev->cosm_mutex);
242 if (cosm_set_online(cdev))
243 goto exit;
244
245 while (1) {
246 pollepd.epd = cdev->epd;
247 pollepd.events = EPOLLIN;
248
249 /* Drop the mutex before blocking in scif_poll(..) */
250 mutex_unlock(&cdev->cosm_mutex);
251 /* poll(..) with timeout on our endpoint */
252 rc = scif_poll(&pollepd, 1, COSM_HEARTBEAT_TIMEOUT_MSEC);
253 mutex_lock(&cdev->cosm_mutex);
254 if (rc < 0) {
255 dev_err(&cdev->dev, "%s %d scif_poll rc %d\n",
256 __func__, __LINE__, rc);
257 continue;
258 }
259
260 /* There is a message from the card */
261 if (pollepd.revents & EPOLLIN)
262 cosm_scif_recv(cdev);
263
264 /* The peer endpoint is closed or this endpoint disconnected */
265 if (pollepd.revents & EPOLLHUP) {
266 cosm_scif_close(cdev);
267 break;
268 }
269
270 /* Did we timeout from poll? */
271 if (!rc && cdev->heartbeat_watchdog_enable)
272 cosm_set_crashed(cdev);
273 }
274 exit:
275 dev_dbg(&cdev->dev, "%s %d exiting\n", __func__, __LINE__);
276 mutex_unlock(&cdev->cosm_mutex);
277 }
278
279 /*
280 * COSM SCIF server thread function. Accepts incoming SCIF connections from MIC
281 * cards, finds the correct cosm_device to associate that connection with and
282 * schedules individual work items for each MIC card.
283 */
284 static int cosm_scif_server(void *unused)
285 {
286 struct cosm_device *cdev;
287 scif_epd_t newepd;
288 struct scif_port_id port_id;
289 int rc;
290
291 allow_signal(SIGKILL);
292
293 while (!kthread_should_stop()) {
294 rc = scif_accept(listen_epd, &port_id, &newepd,
295 SCIF_ACCEPT_SYNC);
296 if (rc < 0) {
297 if (-ERESTARTSYS != rc)
298 pr_err("%s %d rc %d\n", __func__, __LINE__, rc);
299 continue;
300 }
301
302 /*
303 * Associate the incoming connection with a particular
304 * cosm_device, COSM device ID == SCIF node ID - 1
305 */
306 cdev = cosm_find_cdev_by_id(port_id.node - 1);
307 if (!cdev)
308 continue;
309 cdev->newepd = newepd;
310 schedule_work(&cdev->scif_work);
311 }
312
313 pr_debug("%s %d Server thread stopped\n", __func__, __LINE__);
314 return 0;
315 }
316
317 static int cosm_scif_listen(void)
318 {
319 int rc;
320
321 listen_epd = scif_open();
322 if (!listen_epd) {
323 pr_err("%s %d scif_open failed\n", __func__, __LINE__);
324 return -ENOMEM;
325 }
326
327 rc = scif_bind(listen_epd, SCIF_COSM_LISTEN_PORT);
328 if (rc < 0) {
329 pr_err("%s %d scif_bind failed rc %d\n",
330 __func__, __LINE__, rc);
331 goto err;
332 }
333
334 rc = scif_listen(listen_epd, COSM_SCIF_BACKLOG);
335 if (rc < 0) {
336 pr_err("%s %d scif_listen rc %d\n", __func__, __LINE__, rc);
337 goto err;
338 }
339 pr_debug("%s %d listen_epd set up\n", __func__, __LINE__);
340 return 0;
341 err:
342 scif_close(listen_epd);
343 listen_epd = NULL;
344 return rc;
345 }
346
347 static void cosm_scif_listen_exit(void)
348 {
349 pr_debug("%s %d closing listen_epd\n", __func__, __LINE__);
350 if (listen_epd) {
351 scif_close(listen_epd);
352 listen_epd = NULL;
353 }
354 }
355
356 /*
357 * Create a listening SCIF endpoint and a server kthread which accepts incoming
358 * SCIF connections from MIC cards
359 */
360 int cosm_scif_init(void)
361 {
362 int rc = cosm_scif_listen();
363
364 if (rc) {
365 pr_err("%s %d cosm_scif_listen rc %d\n",
366 __func__, __LINE__, rc);
367 goto err;
368 }
369
370 server_thread = kthread_run(cosm_scif_server, NULL, "cosm_server");
371 if (IS_ERR(server_thread)) {
372 rc = PTR_ERR(server_thread);
373 pr_err("%s %d kthread_run rc %d\n", __func__, __LINE__, rc);
374 goto listen_exit;
375 }
376 return 0;
377 listen_exit:
378 cosm_scif_listen_exit();
379 err:
380 return rc;
381 }
382
383 /* Stop the running server thread and close the listening SCIF endpoint */
384 void cosm_scif_exit(void)
385 {
386 int rc;
387
388 if (!IS_ERR_OR_NULL(server_thread)) {
389 rc = send_sig(SIGKILL, server_thread, 0);
390 if (rc) {
391 pr_err("%s %d send_sig rc %d\n",
392 __func__, __LINE__, rc);
393 return;
394 }
395 kthread_stop(server_thread);
396 }
397
398 cosm_scif_listen_exit();
399 }