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,
314 mutex_lock(&pdr->list_lock);
315 list_for_each_entry(pds, &pdr->lookups, node) {
322 mutex_unlock(&pdr->list_lock);
339 mutex_lock(&pdr->list_lock);
340 list_add_tail(&ind->node, &pdr->indack_list);
341 mutex_unlock(&pdr->list_lock);
343 queue_work(pdr->indack_wq, &pdr->indack_work);
359 struct pdr_handle *pdr)
364 ret = qmi_txn_init(&pdr->locator_hdl, &txn,
369 ret = qmi_send_request(&pdr->locator_hdl,
370 &pdr->locator_addr,
396 static int pdr_locate_service(struct pdr_handle *pdr, struct pdr_service *pds)
415 ret = pdr_get_domain_list(&req, resp, pdr);
447 static void pdr_notify_lookup_failure(struct pdr_handle *pdr,
459 mutex_lock(&pdr->status_lock);
460 pdr->status(pds->state, pds->service_path, pdr->priv);
461 mutex_unlock(&pdr->status_lock);
467 struct pdr_handle *pdr = container_of(work, struct pdr_handle,
473 mutex_lock(&pdr->lock);
474 if (!pdr->locator_init_complete) {
475 mutex_unlock(&pdr->lock);
479 mutex_unlock(&pdr->lock);
481 mutex_lock(&pdr->list_lock);
482 list_for_each_entry_safe(pds, tmp, &pdr->lookups, node) {
486 ret = pdr_locate_service(pdr, pds);
488 pdr_notify_lookup_failure(pdr, pds, ret);
492 ret = qmi_add_lookup(&pdr->notifier_hdl, pds->service, 1,
495 pdr_notify_lookup_failure(pdr, pds, ret);
501 mutex_unlock(&pdr->list_lock);
506 * @pdr: PDR client handle
510 * Registering a pdr lookup allows for tracking the life cycle of the PD.
515 struct pdr_service *pdr_add_lookup(struct pdr_handle *pdr,
522 if (IS_ERR_OR_NULL(pdr))
538 mutex_lock(&pdr->list_lock);
539 list_for_each_entry(tmp, &pdr->lookups, node) {
543 mutex_unlock(&pdr->list_lock);
548 list_add(&pds->node, &pdr->lookups);
549 mutex_unlock(&pdr->list_lock);
551 schedule_work(&pdr->locator_work);
562 * @pdr: PDR client handle
569 int pdr_restart_pd(struct pdr_handle *pdr, struct pdr_service *pds)
578 if (IS_ERR_OR_NULL(pdr) || IS_ERR_OR_NULL(pds))
581 mutex_lock(&pdr->list_lock);
582 list_for_each_entry(tmp, &pdr->lookups, node) {
594 mutex_unlock(&pdr->list_lock);
599 ret = qmi_txn_init(&pdr->notifier_hdl, &txn,
605 ret = qmi_send_request(&pdr->notifier_hdl, &addr,
653 struct pdr_handle *pdr;
659 pdr = kzalloc(sizeof(*pdr), GFP_KERNEL);
660 if (!pdr)
663 pdr->status = status;
664 pdr->priv = priv;
666 mutex_init(&pdr->status_lock);
667 mutex_init(&pdr->list_lock);
668 mutex_init(&pdr->lock);
670 INIT_LIST_HEAD(&pdr->lookups);
671 INIT_LIST_HEAD(&pdr->indack_list);
673 INIT_WORK(&pdr->locator_work, pdr_locator_work);
674 INIT_WORK(&pdr->notifier_work, pdr_notifier_work);
675 INIT_WORK(&pdr->indack_work, pdr_indack_work);
677 pdr->notifier_wq = create_singlethread_workqueue("pdr_notifier_wq");
678 if (!pdr->notifier_wq) {
683 pdr->indack_wq = alloc_ordered_workqueue("pdr_indack_wq", WQ_HIGHPRI);
684 if (!pdr->indack_wq) {
689 ret = qmi_handle_init(&pdr->locator_hdl,
695 ret = qmi_add_lookup(&pdr->locator_hdl, SERVREG_LOCATOR_SERVICE, 1, 1);
699 ret = qmi_handle_init(&pdr->notifier_hdl,
706 return pdr;
709 qmi_handle_release(&pdr->locator_hdl);
711 destroy_workqueue(pdr->indack_wq);
713 destroy_workqueue(pdr->notifier_wq);
715 kfree(pdr);
723 * @pdr: PDR client handle
727 void pdr_handle_release(struct pdr_handle *pdr)
731 if (IS_ERR_OR_NULL(pdr))
734 mutex_lock(&pdr->list_lock);
735 list_for_each_entry_safe(pds, tmp, &pdr->lookups, node) {
739 mutex_unlock(&pdr->list_lock);
741 cancel_work_sync(&pdr->locator_work);
742 cancel_work_sync(&pdr->notifier_work);
743 cancel_work_sync(&pdr->indack_work);
745 destroy_workqueue(pdr->notifier_wq);
746 destroy_workqueue(pdr->indack_wq);
748 qmi_handle_release(&pdr->locator_hdl);
749 qmi_handle_release(&pdr->notifier_hdl);
751 kfree(pdr);