1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Copyright (C) 2020 The Linux Foundation. All rights reserved.
4  */
5 
6 #include <linux/kernel.h>
7 #include <linux/module.h>
8 #include <linux/slab.h>
9 #include <linux/string.h>
10 #include <linux/workqueue.h>
11 
12 #include "pdr_internal.h"
13 
14 struct pdr_service {
15 	char service_name[SERVREG_NAME_LENGTH + 1];
16 	char service_path[SERVREG_NAME_LENGTH + 1];
17 
18 	struct sockaddr_qrtr addr;
19 
20 	unsigned int instance;
21 	unsigned int service;
22 	u8 service_data_valid;
23 	u32 service_data;
24 	int state;
25 
26 	bool need_notifier_register;
27 	bool need_notifier_remove;
28 	bool need_locator_lookup;
29 	bool service_connected;
30 
31 	struct list_head node;
32 };
33 
34 struct pdr_handle {
35 	struct qmi_handle locator_hdl;
36 	struct qmi_handle notifier_hdl;
37 
38 	struct sockaddr_qrtr locator_addr;
39 
40 	struct list_head lookups;
41 	struct list_head indack_list;
42 
43 	/* control access to pdr lookup/indack lists */
44 	struct mutex list_lock;
45 
46 	/* serialize pd status invocation */
47 	struct mutex status_lock;
48 
49 	/* control access to the locator state */
50 	struct mutex lock;
51 
52 	bool locator_init_complete;
53 
54 	struct work_struct locator_work;
55 	struct work_struct notifier_work;
56 	struct work_struct indack_work;
57 
58 	struct workqueue_struct *notifier_wq;
59 	struct workqueue_struct *indack_wq;
60 
61 	void (*status)(int state, char *service_path, void *priv);
62 	void *priv;
63 };
64 
65 struct pdr_list_node {
66 	enum servreg_service_state curr_state;
67 	u16 transaction_id;
68 	struct pdr_service *pds;
69 	struct list_head node;
70 };
71 
pdr_locator_new_server(struct qmi_handle * qmi,struct qmi_service * svc)72 static int pdr_locator_new_server(struct qmi_handle *qmi,
73 				  struct qmi_service *svc)
74 {
75 	struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
76 					      locator_hdl);
77 	struct pdr_service *pds;
78 
79 	/* Create a local client port for QMI communication */
80 	pdr->locator_addr.sq_family = AF_QIPCRTR;
81 	pdr->locator_addr.sq_node = svc->node;
82 	pdr->locator_addr.sq_port = svc->port;
83 
84 	mutex_lock(&pdr->lock);
85 	pdr->locator_init_complete = true;
86 	mutex_unlock(&pdr->lock);
87 
88 	/* Service pending lookup requests */
89 	mutex_lock(&pdr->list_lock);
90 	list_for_each_entry(pds, &pdr->lookups, node) {
91 		if (pds->need_locator_lookup)
92 			schedule_work(&pdr->locator_work);
93 	}
94 	mutex_unlock(&pdr->list_lock);
95 
96 	return 0;
97 }
98 
pdr_locator_del_server(struct qmi_handle * qmi,struct qmi_service * svc)99 static void pdr_locator_del_server(struct qmi_handle *qmi,
100 				   struct qmi_service *svc)
101 {
102 	struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
103 					      locator_hdl);
104 
105 	mutex_lock(&pdr->lock);
106 	pdr->locator_init_complete = false;
107 	mutex_unlock(&pdr->lock);
108 
109 	pdr->locator_addr.sq_node = 0;
110 	pdr->locator_addr.sq_port = 0;
111 }
112 
113 static const struct qmi_ops pdr_locator_ops = {
114 	.new_server = pdr_locator_new_server,
115 	.del_server = pdr_locator_del_server,
116 };
117 
pdr_register_listener(struct pdr_handle * pdr,struct pdr_service * pds,bool enable)118 static int pdr_register_listener(struct pdr_handle *pdr,
119 				 struct pdr_service *pds,
120 				 bool enable)
121 {
122 	struct servreg_register_listener_resp resp;
123 	struct servreg_register_listener_req req;
124 	struct qmi_txn txn;
125 	int ret;
126 
127 	ret = qmi_txn_init(&pdr->notifier_hdl, &txn,
128 			   servreg_register_listener_resp_ei,
129 			   &resp);
130 	if (ret < 0)
131 		return ret;
132 
133 	req.enable = enable;
134 	strscpy(req.service_path, pds->service_path, sizeof(req.service_path));
135 
136 	ret = qmi_send_request(&pdr->notifier_hdl, &pds->addr,
137 			       &txn, SERVREG_REGISTER_LISTENER_REQ,
138 			       SERVREG_REGISTER_LISTENER_REQ_LEN,
139 			       servreg_register_listener_req_ei,
140 			       &req);
141 	if (ret < 0) {
142 		qmi_txn_cancel(&txn);
143 		return ret;
144 	}
145 
146 	ret = qmi_txn_wait(&txn, 5 * HZ);
147 	if (ret < 0) {
148 		pr_err("PDR: %s register listener txn wait failed: %d\n",
149 		       pds->service_path, ret);
150 		return ret;
151 	}
152 
153 	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
154 		pr_err("PDR: %s register listener failed: 0x%x\n",
155 		       pds->service_path, resp.resp.error);
156 		return -EREMOTEIO;
157 	}
158 
159 	pds->state = resp.curr_state;
160 
161 	return 0;
162 }
163 
pdr_notifier_work(struct work_struct * work)164 static void pdr_notifier_work(struct work_struct *work)
165 {
166 	struct pdr_handle *pdr = container_of(work, struct pdr_handle,
167 					      notifier_work);
168 	struct pdr_service *pds;
169 	int ret;
170 
171 	mutex_lock(&pdr->list_lock);
172 	list_for_each_entry(pds, &pdr->lookups, node) {
173 		if (pds->service_connected) {
174 			if (!pds->need_notifier_register)
175 				continue;
176 
177 			pds->need_notifier_register = false;
178 			ret = pdr_register_listener(pdr, pds, true);
179 			if (ret < 0)
180 				pds->state = SERVREG_SERVICE_STATE_DOWN;
181 		} else {
182 			if (!pds->need_notifier_remove)
183 				continue;
184 
185 			pds->need_notifier_remove = false;
186 			pds->state = SERVREG_SERVICE_STATE_DOWN;
187 		}
188 
189 		mutex_lock(&pdr->status_lock);
190 		pdr->status(pds->state, pds->service_path, pdr->priv);
191 		mutex_unlock(&pdr->status_lock);
192 	}
193 	mutex_unlock(&pdr->list_lock);
194 }
195 
pdr_notifier_new_server(struct qmi_handle * qmi,struct qmi_service * svc)196 static int pdr_notifier_new_server(struct qmi_handle *qmi,
197 				   struct qmi_service *svc)
198 {
199 	struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
200 					      notifier_hdl);
201 	struct pdr_service *pds;
202 
203 	mutex_lock(&pdr->list_lock);
204 	list_for_each_entry(pds, &pdr->lookups, node) {
205 		if (pds->service == svc->service &&
206 		    pds->instance == svc->instance) {
207 			pds->service_connected = true;
208 			pds->need_notifier_register = true;
209 			pds->addr.sq_family = AF_QIPCRTR;
210 			pds->addr.sq_node = svc->node;
211 			pds->addr.sq_port = svc->port;
212 			queue_work(pdr->notifier_wq, &pdr->notifier_work);
213 		}
214 	}
215 	mutex_unlock(&pdr->list_lock);
216 
217 	return 0;
218 }
219 
pdr_notifier_del_server(struct qmi_handle * qmi,struct qmi_service * svc)220 static void pdr_notifier_del_server(struct qmi_handle *qmi,
221 				    struct qmi_service *svc)
222 {
223 	struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
224 					      notifier_hdl);
225 	struct pdr_service *pds;
226 
227 	mutex_lock(&pdr->list_lock);
228 	list_for_each_entry(pds, &pdr->lookups, node) {
229 		if (pds->service == svc->service &&
230 		    pds->instance == svc->instance) {
231 			pds->service_connected = false;
232 			pds->need_notifier_remove = true;
233 			pds->addr.sq_node = 0;
234 			pds->addr.sq_port = 0;
235 			queue_work(pdr->notifier_wq, &pdr->notifier_work);
236 		}
237 	}
238 	mutex_unlock(&pdr->list_lock);
239 }
240 
241 static const struct qmi_ops pdr_notifier_ops = {
242 	.new_server = pdr_notifier_new_server,
243 	.del_server = pdr_notifier_del_server,
244 };
245 
pdr_send_indack_msg(struct pdr_handle * pdr,struct pdr_service * pds,u16 tid)246 static int pdr_send_indack_msg(struct pdr_handle *pdr, struct pdr_service *pds,
247 			       u16 tid)
248 {
249 	struct servreg_set_ack_resp resp;
250 	struct servreg_set_ack_req req;
251 	struct qmi_txn txn;
252 	int ret;
253 
254 	ret = qmi_txn_init(&pdr->notifier_hdl, &txn, servreg_set_ack_resp_ei,
255 			   &resp);
256 	if (ret < 0)
257 		return ret;
258 
259 	req.transaction_id = tid;
260 	strscpy(req.service_path, pds->service_path, sizeof(req.service_path));
261 
262 	ret = qmi_send_request(&pdr->notifier_hdl, &pds->addr,
263 			       &txn, SERVREG_SET_ACK_REQ,
264 			       SERVREG_SET_ACK_REQ_LEN,
265 			       servreg_set_ack_req_ei,
266 			       &req);
267 
268 	/* Skip waiting for response */
269 	qmi_txn_cancel(&txn);
270 	return ret;
271 }
272 
pdr_indack_work(struct work_struct * work)273 static void pdr_indack_work(struct work_struct *work)
274 {
275 	struct pdr_handle *pdr = container_of(work, struct pdr_handle,
276 					      indack_work);
277 	struct pdr_list_node *ind, *tmp;
278 	struct pdr_service *pds;
279 
280 	list_for_each_entry_safe(ind, tmp, &pdr->indack_list, node) {
281 		pds = ind->pds;
282 
283 		mutex_lock(&pdr->status_lock);
284 		pds->state = ind->curr_state;
285 		pdr->status(pds->state, pds->service_path, pdr->priv);
286 		mutex_unlock(&pdr->status_lock);
287 
288 		/* Ack the indication after clients release the PD resources */
289 		pdr_send_indack_msg(pdr, pds, ind->transaction_id);
290 
291 		mutex_lock(&pdr->list_lock);
292 		list_del(&ind->node);
293 		mutex_unlock(&pdr->list_lock);
294 
295 		kfree(ind);
296 	}
297 }
298 
pdr_indication_cb(struct qmi_handle * qmi,struct sockaddr_qrtr * sq,struct qmi_txn * txn,const void * data)299 static void pdr_indication_cb(struct qmi_handle *qmi,
300 			      struct sockaddr_qrtr *sq,
301 			      struct qmi_txn *txn, const void *data)
302 {
303 	struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
304 					      notifier_hdl);
305 	const struct servreg_state_updated_ind *ind_msg = data;
306 	struct pdr_list_node *ind;
307 	struct pdr_service *pds = NULL, *iter;
308 
309 	if (!ind_msg || !ind_msg->service_path[0] ||
310 	    strlen(ind_msg->service_path) > SERVREG_NAME_LENGTH)
311 		return;
312 
313 	mutex_lock(&pdr->list_lock);
314 	list_for_each_entry(iter, &pdr->lookups, node) {
315 		if (strcmp(iter->service_path, ind_msg->service_path))
316 			continue;
317 
318 		pds = iter;
319 		break;
320 	}
321 	mutex_unlock(&pdr->list_lock);
322 
323 	if (!pds)
324 		return;
325 
326 	pr_info("PDR: Indication received from %s, state: 0x%x, trans-id: %d\n",
327 		ind_msg->service_path, ind_msg->curr_state,
328 		ind_msg->transaction_id);
329 
330 	ind = kzalloc(sizeof(*ind), GFP_KERNEL);
331 	if (!ind)
332 		return;
333 
334 	ind->transaction_id = ind_msg->transaction_id;
335 	ind->curr_state = ind_msg->curr_state;
336 	ind->pds = pds;
337 
338 	mutex_lock(&pdr->list_lock);
339 	list_add_tail(&ind->node, &pdr->indack_list);
340 	mutex_unlock(&pdr->list_lock);
341 
342 	queue_work(pdr->indack_wq, &pdr->indack_work);
343 }
344 
345 static const struct qmi_msg_handler qmi_indication_handler[] = {
346 	{
347 		.type = QMI_INDICATION,
348 		.msg_id = SERVREG_STATE_UPDATED_IND_ID,
349 		.ei = servreg_state_updated_ind_ei,
350 		.decoded_size = sizeof(struct servreg_state_updated_ind),
351 		.fn = pdr_indication_cb,
352 	},
353 	{}
354 };
355 
pdr_get_domain_list(struct servreg_get_domain_list_req * req,struct servreg_get_domain_list_resp * resp,struct pdr_handle * pdr)356 static int pdr_get_domain_list(struct servreg_get_domain_list_req *req,
357 			       struct servreg_get_domain_list_resp *resp,
358 			       struct pdr_handle *pdr)
359 {
360 	struct qmi_txn txn;
361 	int ret;
362 
363 	ret = qmi_txn_init(&pdr->locator_hdl, &txn,
364 			   servreg_get_domain_list_resp_ei, resp);
365 	if (ret < 0)
366 		return ret;
367 
368 	ret = qmi_send_request(&pdr->locator_hdl,
369 			       &pdr->locator_addr,
370 			       &txn, SERVREG_GET_DOMAIN_LIST_REQ,
371 			       SERVREG_GET_DOMAIN_LIST_REQ_MAX_LEN,
372 			       servreg_get_domain_list_req_ei,
373 			       req);
374 	if (ret < 0) {
375 		qmi_txn_cancel(&txn);
376 		return ret;
377 	}
378 
379 	ret = qmi_txn_wait(&txn, 5 * HZ);
380 	if (ret < 0) {
381 		pr_err("PDR: %s get domain list txn wait failed: %d\n",
382 		       req->service_name, ret);
383 		return ret;
384 	}
385 
386 	if (resp->resp.result != QMI_RESULT_SUCCESS_V01) {
387 		pr_err("PDR: %s get domain list failed: 0x%x\n",
388 		       req->service_name, resp->resp.error);
389 		return -EREMOTEIO;
390 	}
391 
392 	return 0;
393 }
394 
pdr_locate_service(struct pdr_handle * pdr,struct pdr_service * pds)395 static int pdr_locate_service(struct pdr_handle *pdr, struct pdr_service *pds)
396 {
397 	struct servreg_get_domain_list_resp *resp;
398 	struct servreg_get_domain_list_req req;
399 	struct servreg_location_entry *entry;
400 	int domains_read = 0;
401 	int ret, i;
402 
403 	resp = kzalloc(sizeof(*resp), GFP_KERNEL);
404 	if (!resp)
405 		return -ENOMEM;
406 
407 	/* Prepare req message */
408 	strscpy(req.service_name, pds->service_name, sizeof(req.service_name));
409 	req.domain_offset_valid = true;
410 	req.domain_offset = 0;
411 
412 	do {
413 		req.domain_offset = domains_read;
414 		ret = pdr_get_domain_list(&req, resp, pdr);
415 		if (ret < 0)
416 			goto out;
417 
418 		for (i = domains_read; i < resp->domain_list_len; i++) {
419 			entry = &resp->domain_list[i];
420 
421 			if (strnlen(entry->name, sizeof(entry->name)) == sizeof(entry->name))
422 				continue;
423 
424 			if (!strcmp(entry->name, pds->service_path)) {
425 				pds->service_data_valid = entry->service_data_valid;
426 				pds->service_data = entry->service_data;
427 				pds->instance = entry->instance;
428 				goto out;
429 			}
430 		}
431 
432 		/* Update ret to indicate that the service is not yet found */
433 		ret = -ENXIO;
434 
435 		/* Always read total_domains from the response msg */
436 		if (resp->domain_list_len > resp->total_domains)
437 			resp->domain_list_len = resp->total_domains;
438 
439 		domains_read += resp->domain_list_len;
440 	} while (domains_read < resp->total_domains);
441 out:
442 	kfree(resp);
443 	return ret;
444 }
445 
pdr_notify_lookup_failure(struct pdr_handle * pdr,struct pdr_service * pds,int err)446 static void pdr_notify_lookup_failure(struct pdr_handle *pdr,
447 				      struct pdr_service *pds,
448 				      int err)
449 {
450 	pr_err("PDR: service lookup for %s failed: %d\n",
451 	       pds->service_name, err);
452 
453 	if (err == -ENXIO)
454 		return;
455 
456 	list_del(&pds->node);
457 	pds->state = SERVREG_LOCATOR_ERR;
458 	mutex_lock(&pdr->status_lock);
459 	pdr->status(pds->state, pds->service_path, pdr->priv);
460 	mutex_unlock(&pdr->status_lock);
461 	kfree(pds);
462 }
463 
pdr_locator_work(struct work_struct * work)464 static void pdr_locator_work(struct work_struct *work)
465 {
466 	struct pdr_handle *pdr = container_of(work, struct pdr_handle,
467 					      locator_work);
468 	struct pdr_service *pds, *tmp;
469 	int ret = 0;
470 
471 	/* Bail out early if the SERVREG LOCATOR QMI service is not up */
472 	mutex_lock(&pdr->lock);
473 	if (!pdr->locator_init_complete) {
474 		mutex_unlock(&pdr->lock);
475 		pr_debug("PDR: SERVICE LOCATOR service not available\n");
476 		return;
477 	}
478 	mutex_unlock(&pdr->lock);
479 
480 	mutex_lock(&pdr->list_lock);
481 	list_for_each_entry_safe(pds, tmp, &pdr->lookups, node) {
482 		if (!pds->need_locator_lookup)
483 			continue;
484 
485 		ret = pdr_locate_service(pdr, pds);
486 		if (ret < 0) {
487 			pdr_notify_lookup_failure(pdr, pds, ret);
488 			continue;
489 		}
490 
491 		ret = qmi_add_lookup(&pdr->notifier_hdl, pds->service, 1,
492 				     pds->instance);
493 		if (ret < 0) {
494 			pdr_notify_lookup_failure(pdr, pds, ret);
495 			continue;
496 		}
497 
498 		pds->need_locator_lookup = false;
499 	}
500 	mutex_unlock(&pdr->list_lock);
501 }
502 
503 /**
504  * pdr_add_lookup() - register a tracking request for a PD
505  * @pdr:		PDR client handle
506  * @service_name:	service name of the tracking request
507  * @service_path:	service path of the tracking request
508  *
509  * Registering a pdr lookup allows for tracking the life cycle of the PD.
510  *
511  * Return: pdr_service object on success, ERR_PTR on failure. -EALREADY is
512  * returned if a lookup is already in progress for the given service path.
513  */
pdr_add_lookup(struct pdr_handle * pdr,const char * service_name,const char * service_path)514 struct pdr_service *pdr_add_lookup(struct pdr_handle *pdr,
515 				   const char *service_name,
516 				   const char *service_path)
517 {
518 	struct pdr_service *pds, *tmp;
519 	int ret;
520 
521 	if (IS_ERR_OR_NULL(pdr))
522 		return ERR_PTR(-EINVAL);
523 
524 	if (!service_name || strlen(service_name) > SERVREG_NAME_LENGTH ||
525 	    !service_path || strlen(service_path) > SERVREG_NAME_LENGTH)
526 		return ERR_PTR(-EINVAL);
527 
528 	pds = kzalloc(sizeof(*pds), GFP_KERNEL);
529 	if (!pds)
530 		return ERR_PTR(-ENOMEM);
531 
532 	pds->service = SERVREG_NOTIFIER_SERVICE;
533 	strscpy(pds->service_name, service_name, sizeof(pds->service_name));
534 	strscpy(pds->service_path, service_path, sizeof(pds->service_path));
535 	pds->need_locator_lookup = true;
536 
537 	mutex_lock(&pdr->list_lock);
538 	list_for_each_entry(tmp, &pdr->lookups, node) {
539 		if (strcmp(tmp->service_path, service_path))
540 			continue;
541 
542 		mutex_unlock(&pdr->list_lock);
543 		ret = -EALREADY;
544 		goto err;
545 	}
546 
547 	list_add(&pds->node, &pdr->lookups);
548 	mutex_unlock(&pdr->list_lock);
549 
550 	schedule_work(&pdr->locator_work);
551 
552 	return pds;
553 err:
554 	kfree(pds);
555 	return ERR_PTR(ret);
556 }
557 EXPORT_SYMBOL(pdr_add_lookup);
558 
559 /**
560  * pdr_restart_pd() - restart PD
561  * @pdr:	PDR client handle
562  * @pds:	PD service handle
563  *
564  * Restarts the PD tracked by the PDR client handle for a given service path.
565  *
566  * Return: 0 on success, negative errno on failure.
567  */
pdr_restart_pd(struct pdr_handle * pdr,struct pdr_service * pds)568 int pdr_restart_pd(struct pdr_handle *pdr, struct pdr_service *pds)
569 {
570 	struct servreg_restart_pd_resp resp;
571 	struct servreg_restart_pd_req req = { 0 };
572 	struct sockaddr_qrtr addr;
573 	struct pdr_service *tmp;
574 	struct qmi_txn txn;
575 	int ret;
576 
577 	if (IS_ERR_OR_NULL(pdr) || IS_ERR_OR_NULL(pds))
578 		return -EINVAL;
579 
580 	mutex_lock(&pdr->list_lock);
581 	list_for_each_entry(tmp, &pdr->lookups, node) {
582 		if (tmp != pds)
583 			continue;
584 
585 		if (!pds->service_connected)
586 			break;
587 
588 		/* Prepare req message */
589 		strscpy(req.service_path, pds->service_path, sizeof(req.service_path));
590 		addr = pds->addr;
591 		break;
592 	}
593 	mutex_unlock(&pdr->list_lock);
594 
595 	if (!req.service_path[0])
596 		return -EINVAL;
597 
598 	ret = qmi_txn_init(&pdr->notifier_hdl, &txn,
599 			   servreg_restart_pd_resp_ei,
600 			   &resp);
601 	if (ret < 0)
602 		return ret;
603 
604 	ret = qmi_send_request(&pdr->notifier_hdl, &addr,
605 			       &txn, SERVREG_RESTART_PD_REQ,
606 			       SERVREG_RESTART_PD_REQ_MAX_LEN,
607 			       servreg_restart_pd_req_ei, &req);
608 	if (ret < 0) {
609 		qmi_txn_cancel(&txn);
610 		return ret;
611 	}
612 
613 	ret = qmi_txn_wait(&txn, 5 * HZ);
614 	if (ret < 0) {
615 		pr_err("PDR: %s PD restart txn wait failed: %d\n",
616 		       req.service_path, ret);
617 		return ret;
618 	}
619 
620 	/* Check response if PDR is disabled */
621 	if (resp.resp.result == QMI_RESULT_FAILURE_V01 &&
622 	    resp.resp.error == QMI_ERR_DISABLED_V01) {
623 		pr_err("PDR: %s PD restart is disabled: 0x%x\n",
624 		       req.service_path, resp.resp.error);
625 		return -EOPNOTSUPP;
626 	}
627 
628 	/* Check the response for other error case*/
629 	if (resp.resp.result != QMI_RESULT_SUCCESS_V01) {
630 		pr_err("PDR: %s request for PD restart failed: 0x%x\n",
631 		       req.service_path, resp.resp.error);
632 		return -EREMOTEIO;
633 	}
634 
635 	return 0;
636 }
637 EXPORT_SYMBOL(pdr_restart_pd);
638 
639 /**
640  * pdr_handle_alloc() - initialize the PDR client handle
641  * @status:	function to be called on PD state change
642  * @priv:	handle for client's use
643  *
644  * Initializes the PDR client handle to allow for tracking/restart of PDs.
645  *
646  * Return: pdr_handle object on success, ERR_PTR on failure.
647  */
pdr_handle_alloc(void (* status)(int state,char * service_path,void * priv),void * priv)648 struct pdr_handle *pdr_handle_alloc(void (*status)(int state,
649 						   char *service_path,
650 						   void *priv), void *priv)
651 {
652 	struct pdr_handle *pdr;
653 	int ret;
654 
655 	if (!status)
656 		return ERR_PTR(-EINVAL);
657 
658 	pdr = kzalloc(sizeof(*pdr), GFP_KERNEL);
659 	if (!pdr)
660 		return ERR_PTR(-ENOMEM);
661 
662 	pdr->status = status;
663 	pdr->priv = priv;
664 
665 	mutex_init(&pdr->status_lock);
666 	mutex_init(&pdr->list_lock);
667 	mutex_init(&pdr->lock);
668 
669 	INIT_LIST_HEAD(&pdr->lookups);
670 	INIT_LIST_HEAD(&pdr->indack_list);
671 
672 	INIT_WORK(&pdr->locator_work, pdr_locator_work);
673 	INIT_WORK(&pdr->notifier_work, pdr_notifier_work);
674 	INIT_WORK(&pdr->indack_work, pdr_indack_work);
675 
676 	pdr->notifier_wq = create_singlethread_workqueue("pdr_notifier_wq");
677 	if (!pdr->notifier_wq) {
678 		ret = -ENOMEM;
679 		goto free_pdr_handle;
680 	}
681 
682 	pdr->indack_wq = alloc_ordered_workqueue("pdr_indack_wq", WQ_HIGHPRI);
683 	if (!pdr->indack_wq) {
684 		ret = -ENOMEM;
685 		goto destroy_notifier;
686 	}
687 
688 	ret = qmi_handle_init(&pdr->locator_hdl,
689 			      SERVREG_GET_DOMAIN_LIST_RESP_MAX_LEN,
690 			      &pdr_locator_ops, NULL);
691 	if (ret < 0)
692 		goto destroy_indack;
693 
694 	ret = qmi_add_lookup(&pdr->locator_hdl, SERVREG_LOCATOR_SERVICE, 1, 1);
695 	if (ret < 0)
696 		goto release_qmi_handle;
697 
698 	ret = qmi_handle_init(&pdr->notifier_hdl,
699 			      SERVREG_STATE_UPDATED_IND_MAX_LEN,
700 			      &pdr_notifier_ops,
701 			      qmi_indication_handler);
702 	if (ret < 0)
703 		goto release_qmi_handle;
704 
705 	return pdr;
706 
707 release_qmi_handle:
708 	qmi_handle_release(&pdr->locator_hdl);
709 destroy_indack:
710 	destroy_workqueue(pdr->indack_wq);
711 destroy_notifier:
712 	destroy_workqueue(pdr->notifier_wq);
713 free_pdr_handle:
714 	kfree(pdr);
715 
716 	return ERR_PTR(ret);
717 }
718 EXPORT_SYMBOL(pdr_handle_alloc);
719 
720 /**
721  * pdr_handle_release() - release the PDR client handle
722  * @pdr:	PDR client handle
723  *
724  * Cleans up pending tracking requests and releases the underlying qmi handles.
725  */
pdr_handle_release(struct pdr_handle * pdr)726 void pdr_handle_release(struct pdr_handle *pdr)
727 {
728 	struct pdr_service *pds, *tmp;
729 
730 	if (IS_ERR_OR_NULL(pdr))
731 		return;
732 
733 	mutex_lock(&pdr->list_lock);
734 	list_for_each_entry_safe(pds, tmp, &pdr->lookups, node) {
735 		list_del(&pds->node);
736 		kfree(pds);
737 	}
738 	mutex_unlock(&pdr->list_lock);
739 
740 	cancel_work_sync(&pdr->locator_work);
741 	cancel_work_sync(&pdr->notifier_work);
742 	cancel_work_sync(&pdr->indack_work);
743 
744 	destroy_workqueue(pdr->notifier_wq);
745 	destroy_workqueue(pdr->indack_wq);
746 
747 	qmi_handle_release(&pdr->locator_hdl);
748 	qmi_handle_release(&pdr->notifier_hdl);
749 
750 	kfree(pdr);
751 }
752 EXPORT_SYMBOL(pdr_handle_release);
753 
754 MODULE_LICENSE("GPL v2");
755 MODULE_DESCRIPTION("Qualcomm Protection Domain Restart helpers");
756