Lines Matching defs:pdr
43 /* control access to pdr lookup/indack lists */
75 struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
80 pdr->locator_addr.sq_family = AF_QIPCRTR;
81 pdr->locator_addr.sq_node = svc->node;
82 pdr->locator_addr.sq_port = svc->port;
84 mutex_lock(&pdr->lock);
85 pdr->locator_init_complete = true;
86 mutex_unlock(&pdr->lock);
89 mutex_lock(&pdr->list_lock);
90 list_for_each_entry(pds, &pdr->lookups, node) {
92 schedule_work(&pdr->locator_work);
94 mutex_unlock(&pdr->list_lock);
102 struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
105 mutex_lock(&pdr->lock);
106 pdr->locator_init_complete = false;
107 mutex_unlock(&pdr->lock);
109 pdr->locator_addr.sq_node = 0;
110 pdr->locator_addr.sq_port = 0;
118 static int pdr_register_listener(struct pdr_handle *pdr,
127 ret = qmi_txn_init(&pdr->notifier_hdl, &txn,
136 ret = qmi_send_request(&pdr->notifier_hdl, &pds->addr,
166 struct pdr_handle *pdr = container_of(work, struct pdr_handle,
171 mutex_lock(&pdr->list_lock);
172 list_for_each_entry(pds, &pdr->lookups, node) {
178 ret = pdr_register_listener(pdr, pds, true);
189 mutex_lock(&pdr->status_lock);
190 pdr->status(pds->state, pds->service_path, pdr->priv);
191 mutex_unlock(&pdr->status_lock);
193 mutex_unlock(&pdr->list_lock);
199 struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
203 mutex_lock(&pdr->list_lock);
204 list_for_each_entry(pds, &pdr->lookups, node) {
212 queue_work(pdr->notifier_wq, &pdr->notifier_work);
215 mutex_unlock(&pdr->list_lock);
223 struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
227 mutex_lock(&pdr->list_lock);
228 list_for_each_entry(pds, &pdr->lookups, node) {
235 queue_work(pdr->notifier_wq, &pdr->notifier_work);
238 mutex_unlock(&pdr->list_lock);
246 static int pdr_send_indack_msg(struct pdr_handle *pdr, struct pdr_service *pds,
254 ret = qmi_txn_init(&pdr->notifier_hdl, &txn, servreg_set_ack_resp_ei,
262 ret = qmi_send_request(&pdr->notifier_hdl, &pds->addr,
275 struct pdr_handle *pdr = container_of(work, struct pdr_handle,
280 list_for_each_entry_safe(ind, tmp, &pdr->indack_list, node) {
283 mutex_lock(&pdr->status_lock);
285 pdr->status(pds->state, pds->service_path, pdr->priv);
286 mutex_unlock(&pdr->status_lock);
289 pdr_send_indack_msg(pdr, pds, ind->transaction_id);
291 mutex_lock(&pdr->list_lock);
293 mutex_unlock(&pdr->list_lock);
303 struct pdr_handle *pdr = container_of(qmi, struct pdr_handle,
313 mutex_lock(&pdr->list_lock);
314 list_for_each_entry(iter, &pdr->lookups, node) {
321 mutex_unlock(&pdr->list_lock);
338 mutex_lock(&pdr->list_lock);
339 list_add_tail(&ind->node, &pdr->indack_list);
340 mutex_unlock(&pdr->list_lock);
342 queue_work(pdr->indack_wq, &pdr->indack_work);
358 struct pdr_handle *pdr)
363 ret = qmi_txn_init(&pdr->locator_hdl, &txn,
368 ret = qmi_send_request(&pdr->locator_hdl,
369 &pdr->locator_addr,
395 static int pdr_locate_service(struct pdr_handle *pdr, struct pdr_service *pds)
414 ret = pdr_get_domain_list(&req, resp, pdr);
446 static void pdr_notify_lookup_failure(struct pdr_handle *pdr,
458 mutex_lock(&pdr->status_lock);
459 pdr->status(pds->state, pds->service_path, pdr->priv);
460 mutex_unlock(&pdr->status_lock);
466 struct pdr_handle *pdr = container_of(work, struct pdr_handle,
472 mutex_lock(&pdr->lock);
473 if (!pdr->locator_init_complete) {
474 mutex_unlock(&pdr->lock);
478 mutex_unlock(&pdr->lock);
480 mutex_lock(&pdr->list_lock);
481 list_for_each_entry_safe(pds, tmp, &pdr->lookups, node) {
485 ret = pdr_locate_service(pdr, pds);
487 pdr_notify_lookup_failure(pdr, pds, ret);
491 ret = qmi_add_lookup(&pdr->notifier_hdl, pds->service, 1,
494 pdr_notify_lookup_failure(pdr, pds, ret);
500 mutex_unlock(&pdr->list_lock);
505 * @pdr: PDR client handle
509 * Registering a pdr lookup allows for tracking the life cycle of the PD.
514 struct pdr_service *pdr_add_lookup(struct pdr_handle *pdr,
521 if (IS_ERR_OR_NULL(pdr))
537 mutex_lock(&pdr->list_lock);
538 list_for_each_entry(tmp, &pdr->lookups, node) {
542 mutex_unlock(&pdr->list_lock);
547 list_add(&pds->node, &pdr->lookups);
548 mutex_unlock(&pdr->list_lock);
550 schedule_work(&pdr->locator_work);
561 * @pdr: PDR client handle
568 int pdr_restart_pd(struct pdr_handle *pdr, struct pdr_service *pds)
577 if (IS_ERR_OR_NULL(pdr) || IS_ERR_OR_NULL(pds))
580 mutex_lock(&pdr->list_lock);
581 list_for_each_entry(tmp, &pdr->lookups, node) {
593 mutex_unlock(&pdr->list_lock);
598 ret = qmi_txn_init(&pdr->notifier_hdl, &txn,
604 ret = qmi_send_request(&pdr->notifier_hdl, &addr,
652 struct pdr_handle *pdr;
658 pdr = kzalloc(sizeof(*pdr), GFP_KERNEL);
659 if (!pdr)
662 pdr->status = status;
663 pdr->priv = priv;
665 mutex_init(&pdr->status_lock);
666 mutex_init(&pdr->list_lock);
667 mutex_init(&pdr->lock);
669 INIT_LIST_HEAD(&pdr->lookups);
670 INIT_LIST_HEAD(&pdr->indack_list);
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);
676 pdr->notifier_wq = create_singlethread_workqueue("pdr_notifier_wq");
677 if (!pdr->notifier_wq) {
682 pdr->indack_wq = alloc_ordered_workqueue("pdr_indack_wq", WQ_HIGHPRI);
683 if (!pdr->indack_wq) {
688 ret = qmi_handle_init(&pdr->locator_hdl,
694 ret = qmi_add_lookup(&pdr->locator_hdl, SERVREG_LOCATOR_SERVICE, 1, 1);
698 ret = qmi_handle_init(&pdr->notifier_hdl,
705 return pdr;
708 qmi_handle_release(&pdr->locator_hdl);
710 destroy_workqueue(pdr->indack_wq);
712 destroy_workqueue(pdr->notifier_wq);
714 kfree(pdr);
722 * @pdr: PDR client handle
726 void pdr_handle_release(struct pdr_handle *pdr)
730 if (IS_ERR_OR_NULL(pdr))
733 mutex_lock(&pdr->list_lock);
734 list_for_each_entry_safe(pds, tmp, &pdr->lookups, node) {
738 mutex_unlock(&pdr->list_lock);
740 cancel_work_sync(&pdr->locator_work);
741 cancel_work_sync(&pdr->notifier_work);
742 cancel_work_sync(&pdr->indack_work);
744 destroy_workqueue(pdr->notifier_wq);
745 destroy_workqueue(pdr->indack_wq);
747 qmi_handle_release(&pdr->locator_hdl);
748 qmi_handle_release(&pdr->notifier_hdl);
750 kfree(pdr);