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