Loading...
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2017 Linaro Ltd.
4 */
5#include <linux/kernel.h>
6#include <linux/module.h>
7#include <linux/device.h>
8#include <linux/qrtr.h>
9#include <linux/net.h>
10#include <linux/completion.h>
11#include <linux/idr.h>
12#include <linux/string.h>
13#include <net/sock.h>
14#include <linux/workqueue.h>
15#include <trace/events/sock.h>
16#include <linux/soc/qcom/qmi.h>
17
18static struct socket *qmi_sock_create(struct qmi_handle *qmi,
19 struct sockaddr_qrtr *sq);
20
21/**
22 * qmi_recv_new_server() - handler of NEW_SERVER control message
23 * @qmi: qmi handle
24 * @service: service id of the new server
25 * @instance: instance id of the new server
26 * @node: node of the new server
27 * @port: port of the new server
28 *
29 * Calls the new_server callback to inform the client about a newly registered
30 * server matching the currently registered service lookup.
31 */
32static void qmi_recv_new_server(struct qmi_handle *qmi,
33 unsigned int service, unsigned int instance,
34 unsigned int node, unsigned int port)
35{
36 struct qmi_ops *ops = &qmi->ops;
37 struct qmi_service *svc;
38 int ret;
39
40 if (!ops->new_server)
41 return;
42
43 /* Ignore EOF marker */
44 if (!node && !port)
45 return;
46
47 svc = kzalloc(sizeof(*svc), GFP_KERNEL);
48 if (!svc)
49 return;
50
51 svc->service = service;
52 svc->version = instance & 0xff;
53 svc->instance = instance >> 8;
54 svc->node = node;
55 svc->port = port;
56
57 ret = ops->new_server(qmi, svc);
58 if (ret < 0)
59 kfree(svc);
60 else
61 list_add(&svc->list_node, &qmi->lookup_results);
62}
63
64/**
65 * qmi_recv_del_server() - handler of DEL_SERVER control message
66 * @qmi: qmi handle
67 * @node: node of the dying server, a value of -1 matches all nodes
68 * @port: port of the dying server, a value of -1 matches all ports
69 *
70 * Calls the del_server callback for each previously seen server, allowing the
71 * client to react to the disappearing server.
72 */
73static void qmi_recv_del_server(struct qmi_handle *qmi,
74 unsigned int node, unsigned int port)
75{
76 struct qmi_ops *ops = &qmi->ops;
77 struct qmi_service *svc;
78 struct qmi_service *tmp;
79
80 list_for_each_entry_safe(svc, tmp, &qmi->lookup_results, list_node) {
81 if (node != -1 && svc->node != node)
82 continue;
83 if (port != -1 && svc->port != port)
84 continue;
85
86 if (ops->del_server)
87 ops->del_server(qmi, svc);
88
89 list_del(&svc->list_node);
90 kfree(svc);
91 }
92}
93
94/**
95 * qmi_recv_bye() - handler of BYE control message
96 * @qmi: qmi handle
97 * @node: id of the dying node
98 *
99 * Signals the client that all previously registered services on this node are
100 * now gone and then calls the bye callback to allow the client further
101 * cleaning up resources associated with this remote.
102 */
103static void qmi_recv_bye(struct qmi_handle *qmi,
104 unsigned int node)
105{
106 struct qmi_ops *ops = &qmi->ops;
107
108 qmi_recv_del_server(qmi, node, -1);
109
110 if (ops->bye)
111 ops->bye(qmi, node);
112}
113
114/**
115 * qmi_recv_del_client() - handler of DEL_CLIENT control message
116 * @qmi: qmi handle
117 * @node: node of the dying client
118 * @port: port of the dying client
119 *
120 * Signals the client about a dying client, by calling the del_client callback.
121 */
122static void qmi_recv_del_client(struct qmi_handle *qmi,
123 unsigned int node, unsigned int port)
124{
125 struct qmi_ops *ops = &qmi->ops;
126
127 if (ops->del_client)
128 ops->del_client(qmi, node, port);
129}
130
131static void qmi_recv_ctrl_pkt(struct qmi_handle *qmi,
132 const void *buf, size_t len)
133{
134 const struct qrtr_ctrl_pkt *pkt = buf;
135
136 if (len < sizeof(struct qrtr_ctrl_pkt)) {
137 pr_debug("ignoring short control packet\n");
138 return;
139 }
140
141 switch (le32_to_cpu(pkt->cmd)) {
142 case QRTR_TYPE_BYE:
143 qmi_recv_bye(qmi, le32_to_cpu(pkt->client.node));
144 break;
145 case QRTR_TYPE_NEW_SERVER:
146 qmi_recv_new_server(qmi,
147 le32_to_cpu(pkt->server.service),
148 le32_to_cpu(pkt->server.instance),
149 le32_to_cpu(pkt->server.node),
150 le32_to_cpu(pkt->server.port));
151 break;
152 case QRTR_TYPE_DEL_SERVER:
153 qmi_recv_del_server(qmi,
154 le32_to_cpu(pkt->server.node),
155 le32_to_cpu(pkt->server.port));
156 break;
157 case QRTR_TYPE_DEL_CLIENT:
158 qmi_recv_del_client(qmi,
159 le32_to_cpu(pkt->client.node),
160 le32_to_cpu(pkt->client.port));
161 break;
162 }
163}
164
165static void qmi_send_new_lookup(struct qmi_handle *qmi, struct qmi_service *svc)
166{
167 struct qrtr_ctrl_pkt pkt;
168 struct sockaddr_qrtr sq;
169 struct msghdr msg = { };
170 struct kvec iv = { &pkt, sizeof(pkt) };
171 int ret;
172
173 memset(&pkt, 0, sizeof(pkt));
174 pkt.cmd = cpu_to_le32(QRTR_TYPE_NEW_LOOKUP);
175 pkt.server.service = cpu_to_le32(svc->service);
176 pkt.server.instance = cpu_to_le32(svc->version | svc->instance << 8);
177
178 sq.sq_family = qmi->sq.sq_family;
179 sq.sq_node = qmi->sq.sq_node;
180 sq.sq_port = QRTR_PORT_CTRL;
181
182 msg.msg_name = &sq;
183 msg.msg_namelen = sizeof(sq);
184
185 mutex_lock(&qmi->sock_lock);
186 if (qmi->sock) {
187 ret = kernel_sendmsg(qmi->sock, &msg, &iv, 1, sizeof(pkt));
188 if (ret < 0)
189 pr_err("failed to send lookup registration: %d\n", ret);
190 }
191 mutex_unlock(&qmi->sock_lock);
192}
193
194/**
195 * qmi_add_lookup() - register a new lookup with the name service
196 * @qmi: qmi handle
197 * @service: service id of the request
198 * @version: version number of the request
199 * @instance: instance id of the request
200 *
201 * Registering a lookup query with the name server will cause the name server
202 * to send NEW_SERVER and DEL_SERVER control messages to this socket as
203 * matching services are registered.
204 *
205 * Return: 0 on success, negative errno on failure.
206 */
207int qmi_add_lookup(struct qmi_handle *qmi, unsigned int service,
208 unsigned int version, unsigned int instance)
209{
210 struct qmi_service *svc;
211
212 svc = kzalloc(sizeof(*svc), GFP_KERNEL);
213 if (!svc)
214 return -ENOMEM;
215
216 svc->service = service;
217 svc->version = version;
218 svc->instance = instance;
219
220 list_add(&svc->list_node, &qmi->lookups);
221
222 qmi_send_new_lookup(qmi, svc);
223
224 return 0;
225}
226EXPORT_SYMBOL_GPL(qmi_add_lookup);
227
228static void qmi_send_new_server(struct qmi_handle *qmi, struct qmi_service *svc)
229{
230 struct qrtr_ctrl_pkt pkt;
231 struct sockaddr_qrtr sq;
232 struct msghdr msg = { };
233 struct kvec iv = { &pkt, sizeof(pkt) };
234 int ret;
235
236 memset(&pkt, 0, sizeof(pkt));
237 pkt.cmd = cpu_to_le32(QRTR_TYPE_NEW_SERVER);
238 pkt.server.service = cpu_to_le32(svc->service);
239 pkt.server.instance = cpu_to_le32(svc->version | svc->instance << 8);
240 pkt.server.node = cpu_to_le32(qmi->sq.sq_node);
241 pkt.server.port = cpu_to_le32(qmi->sq.sq_port);
242
243 sq.sq_family = qmi->sq.sq_family;
244 sq.sq_node = qmi->sq.sq_node;
245 sq.sq_port = QRTR_PORT_CTRL;
246
247 msg.msg_name = &sq;
248 msg.msg_namelen = sizeof(sq);
249
250 mutex_lock(&qmi->sock_lock);
251 if (qmi->sock) {
252 ret = kernel_sendmsg(qmi->sock, &msg, &iv, 1, sizeof(pkt));
253 if (ret < 0)
254 pr_err("send service registration failed: %d\n", ret);
255 }
256 mutex_unlock(&qmi->sock_lock);
257}
258
259/**
260 * qmi_add_server() - register a service with the name service
261 * @qmi: qmi handle
262 * @service: type of the service
263 * @instance: instance of the service
264 * @version: version of the service
265 *
266 * Register a new service with the name service. This allows clients to find
267 * and start sending messages to the client associated with @qmi.
268 *
269 * Return: 0 on success, negative errno on failure.
270 */
271int qmi_add_server(struct qmi_handle *qmi, unsigned int service,
272 unsigned int version, unsigned int instance)
273{
274 struct qmi_service *svc;
275
276 svc = kzalloc(sizeof(*svc), GFP_KERNEL);
277 if (!svc)
278 return -ENOMEM;
279
280 svc->service = service;
281 svc->version = version;
282 svc->instance = instance;
283
284 list_add(&svc->list_node, &qmi->services);
285
286 qmi_send_new_server(qmi, svc);
287
288 return 0;
289}
290EXPORT_SYMBOL_GPL(qmi_add_server);
291
292/**
293 * qmi_txn_init() - allocate transaction id within the given QMI handle
294 * @qmi: QMI handle
295 * @txn: transaction context
296 * @ei: description of how to decode a matching response (optional)
297 * @c_struct: pointer to the object to decode the response into (optional)
298 *
299 * This allocates a transaction id within the QMI handle. If @ei and @c_struct
300 * are specified any responses to this transaction will be decoded as described
301 * by @ei into @c_struct.
302 *
303 * A client calling qmi_txn_init() must call either qmi_txn_wait() or
304 * qmi_txn_cancel() to free up the allocated resources.
305 *
306 * Return: Transaction id on success, negative errno on failure.
307 */
308int qmi_txn_init(struct qmi_handle *qmi, struct qmi_txn *txn,
309 const struct qmi_elem_info *ei, void *c_struct)
310{
311 int ret;
312
313 memset(txn, 0, sizeof(*txn));
314
315 mutex_init(&txn->lock);
316 init_completion(&txn->completion);
317 txn->qmi = qmi;
318 txn->ei = ei;
319 txn->dest = c_struct;
320
321 mutex_lock(&qmi->txn_lock);
322 ret = idr_alloc_cyclic(&qmi->txns, txn, 0, U16_MAX, GFP_KERNEL);
323 if (ret < 0)
324 pr_err("failed to allocate transaction id\n");
325
326 txn->id = ret;
327 mutex_unlock(&qmi->txn_lock);
328
329 return ret;
330}
331EXPORT_SYMBOL_GPL(qmi_txn_init);
332
333/**
334 * qmi_txn_wait() - wait for a response on a transaction
335 * @txn: transaction handle
336 * @timeout: timeout, in jiffies
337 *
338 * If the transaction is decoded by the means of @ei and @c_struct the return
339 * value will be the returned value of qmi_decode_message(), otherwise it's up
340 * to the specified message handler to fill out the result.
341 *
342 * Return: the transaction response on success, negative errno on failure.
343 */
344int qmi_txn_wait(struct qmi_txn *txn, unsigned long timeout)
345{
346 struct qmi_handle *qmi = txn->qmi;
347 int ret;
348
349 ret = wait_for_completion_timeout(&txn->completion, timeout);
350
351 mutex_lock(&qmi->txn_lock);
352 mutex_lock(&txn->lock);
353 idr_remove(&qmi->txns, txn->id);
354 mutex_unlock(&txn->lock);
355 mutex_unlock(&qmi->txn_lock);
356
357 if (ret == 0)
358 return -ETIMEDOUT;
359 else
360 return txn->result;
361}
362EXPORT_SYMBOL_GPL(qmi_txn_wait);
363
364/**
365 * qmi_txn_cancel() - cancel an ongoing transaction
366 * @txn: transaction id
367 */
368void qmi_txn_cancel(struct qmi_txn *txn)
369{
370 struct qmi_handle *qmi = txn->qmi;
371
372 mutex_lock(&qmi->txn_lock);
373 mutex_lock(&txn->lock);
374 idr_remove(&qmi->txns, txn->id);
375 mutex_unlock(&txn->lock);
376 mutex_unlock(&qmi->txn_lock);
377}
378EXPORT_SYMBOL_GPL(qmi_txn_cancel);
379
380/**
381 * qmi_invoke_handler() - find and invoke a handler for a message
382 * @qmi: qmi handle
383 * @sq: sockaddr of the sender
384 * @txn: transaction object for the message
385 * @buf: buffer containing the message
386 * @len: length of @buf
387 *
388 * Find handler and invoke handler for the incoming message.
389 */
390static void qmi_invoke_handler(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
391 struct qmi_txn *txn, const void *buf, size_t len)
392{
393 const struct qmi_msg_handler *handler;
394 const struct qmi_header *hdr = buf;
395 void *dest;
396 int ret;
397
398 if (!qmi->handlers)
399 return;
400
401 for (handler = qmi->handlers; handler->fn; handler++) {
402 if (handler->type == hdr->type &&
403 handler->msg_id == hdr->msg_id)
404 break;
405 }
406
407 if (!handler->fn)
408 return;
409
410 dest = kzalloc(handler->decoded_size, GFP_KERNEL);
411 if (!dest)
412 return;
413
414 ret = qmi_decode_message(buf, len, handler->ei, dest);
415 if (ret < 0)
416 pr_err("failed to decode incoming message\n");
417 else
418 handler->fn(qmi, sq, txn, dest);
419
420 kfree(dest);
421}
422
423/**
424 * qmi_handle_net_reset() - invoked to handle ENETRESET on a QMI handle
425 * @qmi: the QMI context
426 *
427 * As a result of registering a name service with the QRTR all open sockets are
428 * flagged with ENETRESET and this function will be called. The typical case is
429 * the initial boot, where this signals that the local node id has been
430 * configured and as such any bound sockets needs to be rebound. So close the
431 * socket, inform the client and re-initialize the socket.
432 *
433 * For clients it's generally sufficient to react to the del_server callbacks,
434 * but server code is expected to treat the net_reset callback as a "bye" from
435 * all nodes.
436 *
437 * Finally the QMI handle will send out registration requests for any lookups
438 * and services.
439 */
440static void qmi_handle_net_reset(struct qmi_handle *qmi)
441{
442 struct sockaddr_qrtr sq;
443 struct qmi_service *svc;
444 struct socket *sock;
445
446 sock = qmi_sock_create(qmi, &sq);
447 if (IS_ERR(sock))
448 return;
449
450 mutex_lock(&qmi->sock_lock);
451 sock_release(qmi->sock);
452 qmi->sock = NULL;
453 mutex_unlock(&qmi->sock_lock);
454
455 qmi_recv_del_server(qmi, -1, -1);
456
457 if (qmi->ops.net_reset)
458 qmi->ops.net_reset(qmi);
459
460 mutex_lock(&qmi->sock_lock);
461 qmi->sock = sock;
462 qmi->sq = sq;
463 mutex_unlock(&qmi->sock_lock);
464
465 list_for_each_entry(svc, &qmi->lookups, list_node)
466 qmi_send_new_lookup(qmi, svc);
467
468 list_for_each_entry(svc, &qmi->services, list_node)
469 qmi_send_new_server(qmi, svc);
470}
471
472static void qmi_handle_message(struct qmi_handle *qmi,
473 struct sockaddr_qrtr *sq,
474 const void *buf, size_t len)
475{
476 const struct qmi_header *hdr;
477 struct qmi_txn tmp_txn;
478 struct qmi_txn *txn = NULL;
479 int ret;
480
481 if (len < sizeof(*hdr)) {
482 pr_err("ignoring short QMI packet\n");
483 return;
484 }
485
486 hdr = buf;
487
488 /* If this is a response, find the matching transaction handle */
489 if (hdr->type == QMI_RESPONSE) {
490 mutex_lock(&qmi->txn_lock);
491 txn = idr_find(&qmi->txns, hdr->txn_id);
492
493 /* Ignore unexpected responses */
494 if (!txn) {
495 mutex_unlock(&qmi->txn_lock);
496 return;
497 }
498
499 mutex_lock(&txn->lock);
500 mutex_unlock(&qmi->txn_lock);
501
502 if (txn->dest && txn->ei) {
503 ret = qmi_decode_message(buf, len, txn->ei, txn->dest);
504 if (ret < 0)
505 pr_err("failed to decode incoming message\n");
506
507 txn->result = ret;
508 complete(&txn->completion);
509 } else {
510 qmi_invoke_handler(qmi, sq, txn, buf, len);
511 }
512
513 mutex_unlock(&txn->lock);
514 } else {
515 /* Create a txn based on the txn_id of the incoming message */
516 memset(&tmp_txn, 0, sizeof(tmp_txn));
517 tmp_txn.id = hdr->txn_id;
518
519 qmi_invoke_handler(qmi, sq, &tmp_txn, buf, len);
520 }
521}
522
523static void qmi_data_ready_work(struct work_struct *work)
524{
525 struct qmi_handle *qmi = container_of(work, struct qmi_handle, work);
526 struct qmi_ops *ops = &qmi->ops;
527 struct sockaddr_qrtr sq;
528 struct msghdr msg = { .msg_name = &sq, .msg_namelen = sizeof(sq) };
529 struct kvec iv;
530 ssize_t msglen;
531
532 for (;;) {
533 iv.iov_base = qmi->recv_buf;
534 iv.iov_len = qmi->recv_buf_size;
535
536 mutex_lock(&qmi->sock_lock);
537 if (qmi->sock)
538 msglen = kernel_recvmsg(qmi->sock, &msg, &iv, 1,
539 iv.iov_len, MSG_DONTWAIT);
540 else
541 msglen = -EPIPE;
542 mutex_unlock(&qmi->sock_lock);
543 if (msglen == -EAGAIN)
544 break;
545
546 if (msglen == -ENETRESET) {
547 qmi_handle_net_reset(qmi);
548
549 /* The old qmi->sock is gone, our work is done */
550 break;
551 }
552
553 if (msglen < 0) {
554 pr_err("qmi recvmsg failed: %zd\n", msglen);
555 break;
556 }
557
558 if (sq.sq_node == qmi->sq.sq_node &&
559 sq.sq_port == QRTR_PORT_CTRL) {
560 qmi_recv_ctrl_pkt(qmi, qmi->recv_buf, msglen);
561 } else if (ops->msg_handler) {
562 ops->msg_handler(qmi, &sq, qmi->recv_buf, msglen);
563 } else {
564 qmi_handle_message(qmi, &sq, qmi->recv_buf, msglen);
565 }
566 }
567}
568
569static void qmi_data_ready(struct sock *sk)
570{
571 struct qmi_handle *qmi = sk->sk_user_data;
572
573 trace_sk_data_ready(sk);
574
575 /*
576 * This will be NULL if we receive data while being in
577 * qmi_handle_release()
578 */
579 if (!qmi)
580 return;
581
582 queue_work(qmi->wq, &qmi->work);
583}
584
585static struct socket *qmi_sock_create(struct qmi_handle *qmi,
586 struct sockaddr_qrtr *sq)
587{
588 struct socket *sock;
589 int ret;
590
591 ret = sock_create_kern(&init_net, AF_QIPCRTR, SOCK_DGRAM,
592 PF_QIPCRTR, &sock);
593 if (ret < 0)
594 return ERR_PTR(ret);
595
596 ret = kernel_getsockname(sock, (struct sockaddr *)sq);
597 if (ret < 0) {
598 sock_release(sock);
599 return ERR_PTR(ret);
600 }
601
602 sock->sk->sk_user_data = qmi;
603 sock->sk->sk_data_ready = qmi_data_ready;
604 sock->sk->sk_error_report = qmi_data_ready;
605
606 return sock;
607}
608
609/**
610 * qmi_handle_init() - initialize a QMI client handle
611 * @qmi: QMI handle to initialize
612 * @recv_buf_size: maximum size of incoming message
613 * @ops: reference to callbacks for QRTR notifications
614 * @handlers: NULL-terminated list of QMI message handlers
615 *
616 * This initializes the QMI client handle to allow sending and receiving QMI
617 * messages. As messages are received the appropriate handler will be invoked.
618 *
619 * Return: 0 on success, negative errno on failure.
620 */
621int qmi_handle_init(struct qmi_handle *qmi, size_t recv_buf_size,
622 const struct qmi_ops *ops,
623 const struct qmi_msg_handler *handlers)
624{
625 int ret;
626
627 mutex_init(&qmi->txn_lock);
628 mutex_init(&qmi->sock_lock);
629
630 idr_init(&qmi->txns);
631
632 INIT_LIST_HEAD(&qmi->lookups);
633 INIT_LIST_HEAD(&qmi->lookup_results);
634 INIT_LIST_HEAD(&qmi->services);
635
636 INIT_WORK(&qmi->work, qmi_data_ready_work);
637
638 qmi->handlers = handlers;
639 if (ops)
640 qmi->ops = *ops;
641
642 /* Make room for the header */
643 recv_buf_size += sizeof(struct qmi_header);
644 /* Must also be sufficient to hold a control packet */
645 if (recv_buf_size < sizeof(struct qrtr_ctrl_pkt))
646 recv_buf_size = sizeof(struct qrtr_ctrl_pkt);
647
648 qmi->recv_buf_size = recv_buf_size;
649 qmi->recv_buf = kzalloc(recv_buf_size, GFP_KERNEL);
650 if (!qmi->recv_buf)
651 return -ENOMEM;
652
653 qmi->wq = alloc_ordered_workqueue("qmi_msg_handler", 0);
654 if (!qmi->wq) {
655 ret = -ENOMEM;
656 goto err_free_recv_buf;
657 }
658
659 qmi->sock = qmi_sock_create(qmi, &qmi->sq);
660 if (IS_ERR(qmi->sock)) {
661 if (PTR_ERR(qmi->sock) == -EAFNOSUPPORT) {
662 ret = -EPROBE_DEFER;
663 } else {
664 pr_err("failed to create QMI socket\n");
665 ret = PTR_ERR(qmi->sock);
666 }
667 goto err_destroy_wq;
668 }
669
670 return 0;
671
672err_destroy_wq:
673 destroy_workqueue(qmi->wq);
674err_free_recv_buf:
675 kfree(qmi->recv_buf);
676
677 return ret;
678}
679EXPORT_SYMBOL_GPL(qmi_handle_init);
680
681/**
682 * qmi_handle_release() - release the QMI client handle
683 * @qmi: QMI client handle
684 *
685 * This closes the underlying socket and stops any handling of QMI messages.
686 */
687void qmi_handle_release(struct qmi_handle *qmi)
688{
689 struct socket *sock = qmi->sock;
690 struct qmi_service *svc, *tmp;
691
692 sock->sk->sk_user_data = NULL;
693 cancel_work_sync(&qmi->work);
694
695 qmi_recv_del_server(qmi, -1, -1);
696
697 mutex_lock(&qmi->sock_lock);
698 sock_release(sock);
699 qmi->sock = NULL;
700 mutex_unlock(&qmi->sock_lock);
701
702 destroy_workqueue(qmi->wq);
703
704 idr_destroy(&qmi->txns);
705
706 kfree(qmi->recv_buf);
707
708 /* Free registered lookup requests */
709 list_for_each_entry_safe(svc, tmp, &qmi->lookups, list_node) {
710 list_del(&svc->list_node);
711 kfree(svc);
712 }
713
714 /* Free registered service information */
715 list_for_each_entry_safe(svc, tmp, &qmi->services, list_node) {
716 list_del(&svc->list_node);
717 kfree(svc);
718 }
719}
720EXPORT_SYMBOL_GPL(qmi_handle_release);
721
722/**
723 * qmi_send_message() - send a QMI message
724 * @qmi: QMI client handle
725 * @sq: destination sockaddr
726 * @txn: transaction object to use for the message
727 * @type: type of message to send
728 * @msg_id: message id
729 * @len: max length of the QMI message
730 * @ei: QMI message description
731 * @c_struct: object to be encoded
732 *
733 * This function encodes @c_struct using @ei into a message of type @type,
734 * with @msg_id and @txn into a buffer of maximum size @len, and sends this to
735 * @sq.
736 *
737 * Return: 0 on success, negative errno on failure.
738 */
739static ssize_t qmi_send_message(struct qmi_handle *qmi,
740 struct sockaddr_qrtr *sq, struct qmi_txn *txn,
741 int type, int msg_id, size_t len,
742 const struct qmi_elem_info *ei,
743 const void *c_struct)
744{
745 struct msghdr msghdr = {};
746 struct kvec iv;
747 void *msg;
748 int ret;
749
750 msg = qmi_encode_message(type,
751 msg_id, &len,
752 txn->id, ei,
753 c_struct);
754 if (IS_ERR(msg))
755 return PTR_ERR(msg);
756
757 iv.iov_base = msg;
758 iv.iov_len = len;
759
760 if (sq) {
761 msghdr.msg_name = sq;
762 msghdr.msg_namelen = sizeof(*sq);
763 }
764
765 mutex_lock(&qmi->sock_lock);
766 if (qmi->sock) {
767 ret = kernel_sendmsg(qmi->sock, &msghdr, &iv, 1, len);
768 if (ret < 0)
769 pr_err("failed to send QMI message\n");
770 } else {
771 ret = -EPIPE;
772 }
773 mutex_unlock(&qmi->sock_lock);
774
775 kfree(msg);
776
777 return ret < 0 ? ret : 0;
778}
779
780/**
781 * qmi_send_request() - send a request QMI message
782 * @qmi: QMI client handle
783 * @sq: destination sockaddr
784 * @txn: transaction object to use for the message
785 * @msg_id: message id
786 * @len: max length of the QMI message
787 * @ei: QMI message description
788 * @c_struct: object to be encoded
789 *
790 * Return: 0 on success, negative errno on failure.
791 */
792ssize_t qmi_send_request(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
793 struct qmi_txn *txn, int msg_id, size_t len,
794 const struct qmi_elem_info *ei, const void *c_struct)
795{
796 return qmi_send_message(qmi, sq, txn, QMI_REQUEST, msg_id, len, ei,
797 c_struct);
798}
799EXPORT_SYMBOL_GPL(qmi_send_request);
800
801/**
802 * qmi_send_response() - send a response QMI message
803 * @qmi: QMI client handle
804 * @sq: destination sockaddr
805 * @txn: transaction object to use for the message
806 * @msg_id: message id
807 * @len: max length of the QMI message
808 * @ei: QMI message description
809 * @c_struct: object to be encoded
810 *
811 * Return: 0 on success, negative errno on failure.
812 */
813ssize_t qmi_send_response(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
814 struct qmi_txn *txn, int msg_id, size_t len,
815 const struct qmi_elem_info *ei, const void *c_struct)
816{
817 return qmi_send_message(qmi, sq, txn, QMI_RESPONSE, msg_id, len, ei,
818 c_struct);
819}
820EXPORT_SYMBOL_GPL(qmi_send_response);
821
822/**
823 * qmi_send_indication() - send an indication QMI message
824 * @qmi: QMI client handle
825 * @sq: destination sockaddr
826 * @msg_id: message id
827 * @len: max length of the QMI message
828 * @ei: QMI message description
829 * @c_struct: object to be encoded
830 *
831 * Return: 0 on success, negative errno on failure.
832 */
833ssize_t qmi_send_indication(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
834 int msg_id, size_t len,
835 const struct qmi_elem_info *ei,
836 const void *c_struct)
837{
838 struct qmi_txn txn;
839 ssize_t rval;
840 int ret;
841
842 ret = qmi_txn_init(qmi, &txn, NULL, NULL);
843 if (ret < 0)
844 return ret;
845
846 rval = qmi_send_message(qmi, sq, &txn, QMI_INDICATION, msg_id, len, ei,
847 c_struct);
848
849 /* We don't care about future messages on this txn */
850 qmi_txn_cancel(&txn);
851
852 return rval;
853}
854EXPORT_SYMBOL_GPL(qmi_send_indication);
1// SPDX-License-Identifier: GPL-2.0
2/*
3 * Copyright (C) 2017 Linaro Ltd.
4 */
5#include <linux/kernel.h>
6#include <linux/module.h>
7#include <linux/device.h>
8#include <linux/qrtr.h>
9#include <linux/net.h>
10#include <linux/completion.h>
11#include <linux/idr.h>
12#include <linux/string.h>
13#include <net/sock.h>
14#include <linux/workqueue.h>
15#include <linux/soc/qcom/qmi.h>
16
17static struct socket *qmi_sock_create(struct qmi_handle *qmi,
18 struct sockaddr_qrtr *sq);
19
20/**
21 * qmi_recv_new_server() - handler of NEW_SERVER control message
22 * @qmi: qmi handle
23 * @service: service id of the new server
24 * @instance: instance id of the new server
25 * @node: node of the new server
26 * @port: port of the new server
27 *
28 * Calls the new_server callback to inform the client about a newly registered
29 * server matching the currently registered service lookup.
30 */
31static void qmi_recv_new_server(struct qmi_handle *qmi,
32 unsigned int service, unsigned int instance,
33 unsigned int node, unsigned int port)
34{
35 struct qmi_ops *ops = &qmi->ops;
36 struct qmi_service *svc;
37 int ret;
38
39 if (!ops->new_server)
40 return;
41
42 /* Ignore EOF marker */
43 if (!node && !port)
44 return;
45
46 svc = kzalloc(sizeof(*svc), GFP_KERNEL);
47 if (!svc)
48 return;
49
50 svc->service = service;
51 svc->version = instance & 0xff;
52 svc->instance = instance >> 8;
53 svc->node = node;
54 svc->port = port;
55
56 ret = ops->new_server(qmi, svc);
57 if (ret < 0)
58 kfree(svc);
59 else
60 list_add(&svc->list_node, &qmi->lookup_results);
61}
62
63/**
64 * qmi_recv_del_server() - handler of DEL_SERVER control message
65 * @qmi: qmi handle
66 * @node: node of the dying server, a value of -1 matches all nodes
67 * @port: port of the dying server, a value of -1 matches all ports
68 *
69 * Calls the del_server callback for each previously seen server, allowing the
70 * client to react to the disappearing server.
71 */
72static void qmi_recv_del_server(struct qmi_handle *qmi,
73 unsigned int node, unsigned int port)
74{
75 struct qmi_ops *ops = &qmi->ops;
76 struct qmi_service *svc;
77 struct qmi_service *tmp;
78
79 list_for_each_entry_safe(svc, tmp, &qmi->lookup_results, list_node) {
80 if (node != -1 && svc->node != node)
81 continue;
82 if (port != -1 && svc->port != port)
83 continue;
84
85 if (ops->del_server)
86 ops->del_server(qmi, svc);
87
88 list_del(&svc->list_node);
89 kfree(svc);
90 }
91}
92
93/**
94 * qmi_recv_bye() - handler of BYE control message
95 * @qmi: qmi handle
96 * @node: id of the dying node
97 *
98 * Signals the client that all previously registered services on this node are
99 * now gone and then calls the bye callback to allow the client client further
100 * cleaning up resources associated with this remote.
101 */
102static void qmi_recv_bye(struct qmi_handle *qmi,
103 unsigned int node)
104{
105 struct qmi_ops *ops = &qmi->ops;
106
107 qmi_recv_del_server(qmi, node, -1);
108
109 if (ops->bye)
110 ops->bye(qmi, node);
111}
112
113/**
114 * qmi_recv_del_client() - handler of DEL_CLIENT control message
115 * @qmi: qmi handle
116 * @node: node of the dying client
117 * @port: port of the dying client
118 *
119 * Signals the client about a dying client, by calling the del_client callback.
120 */
121static void qmi_recv_del_client(struct qmi_handle *qmi,
122 unsigned int node, unsigned int port)
123{
124 struct qmi_ops *ops = &qmi->ops;
125
126 if (ops->del_client)
127 ops->del_client(qmi, node, port);
128}
129
130static void qmi_recv_ctrl_pkt(struct qmi_handle *qmi,
131 const void *buf, size_t len)
132{
133 const struct qrtr_ctrl_pkt *pkt = buf;
134
135 if (len < sizeof(struct qrtr_ctrl_pkt)) {
136 pr_debug("ignoring short control packet\n");
137 return;
138 }
139
140 switch (le32_to_cpu(pkt->cmd)) {
141 case QRTR_TYPE_BYE:
142 qmi_recv_bye(qmi, le32_to_cpu(pkt->client.node));
143 break;
144 case QRTR_TYPE_NEW_SERVER:
145 qmi_recv_new_server(qmi,
146 le32_to_cpu(pkt->server.service),
147 le32_to_cpu(pkt->server.instance),
148 le32_to_cpu(pkt->server.node),
149 le32_to_cpu(pkt->server.port));
150 break;
151 case QRTR_TYPE_DEL_SERVER:
152 qmi_recv_del_server(qmi,
153 le32_to_cpu(pkt->server.node),
154 le32_to_cpu(pkt->server.port));
155 break;
156 case QRTR_TYPE_DEL_CLIENT:
157 qmi_recv_del_client(qmi,
158 le32_to_cpu(pkt->client.node),
159 le32_to_cpu(pkt->client.port));
160 break;
161 }
162}
163
164static void qmi_send_new_lookup(struct qmi_handle *qmi, struct qmi_service *svc)
165{
166 struct qrtr_ctrl_pkt pkt;
167 struct sockaddr_qrtr sq;
168 struct msghdr msg = { };
169 struct kvec iv = { &pkt, sizeof(pkt) };
170 int ret;
171
172 memset(&pkt, 0, sizeof(pkt));
173 pkt.cmd = cpu_to_le32(QRTR_TYPE_NEW_LOOKUP);
174 pkt.server.service = cpu_to_le32(svc->service);
175 pkt.server.instance = cpu_to_le32(svc->version | svc->instance << 8);
176
177 sq.sq_family = qmi->sq.sq_family;
178 sq.sq_node = qmi->sq.sq_node;
179 sq.sq_port = QRTR_PORT_CTRL;
180
181 msg.msg_name = &sq;
182 msg.msg_namelen = sizeof(sq);
183
184 mutex_lock(&qmi->sock_lock);
185 if (qmi->sock) {
186 ret = kernel_sendmsg(qmi->sock, &msg, &iv, 1, sizeof(pkt));
187 if (ret < 0)
188 pr_err("failed to send lookup registration: %d\n", ret);
189 }
190 mutex_unlock(&qmi->sock_lock);
191}
192
193/**
194 * qmi_add_lookup() - register a new lookup with the name service
195 * @qmi: qmi handle
196 * @service: service id of the request
197 * @instance: instance id of the request
198 * @version: version number of the request
199 *
200 * Registering a lookup query with the name server will cause the name server
201 * to send NEW_SERVER and DEL_SERVER control messages to this socket as
202 * matching services are registered.
203 *
204 * Return: 0 on success, negative errno on failure.
205 */
206int qmi_add_lookup(struct qmi_handle *qmi, unsigned int service,
207 unsigned int version, unsigned int instance)
208{
209 struct qmi_service *svc;
210
211 svc = kzalloc(sizeof(*svc), GFP_KERNEL);
212 if (!svc)
213 return -ENOMEM;
214
215 svc->service = service;
216 svc->version = version;
217 svc->instance = instance;
218
219 list_add(&svc->list_node, &qmi->lookups);
220
221 qmi_send_new_lookup(qmi, svc);
222
223 return 0;
224}
225EXPORT_SYMBOL(qmi_add_lookup);
226
227static void qmi_send_new_server(struct qmi_handle *qmi, struct qmi_service *svc)
228{
229 struct qrtr_ctrl_pkt pkt;
230 struct sockaddr_qrtr sq;
231 struct msghdr msg = { };
232 struct kvec iv = { &pkt, sizeof(pkt) };
233 int ret;
234
235 memset(&pkt, 0, sizeof(pkt));
236 pkt.cmd = cpu_to_le32(QRTR_TYPE_NEW_SERVER);
237 pkt.server.service = cpu_to_le32(svc->service);
238 pkt.server.instance = cpu_to_le32(svc->version | svc->instance << 8);
239 pkt.server.node = cpu_to_le32(qmi->sq.sq_node);
240 pkt.server.port = cpu_to_le32(qmi->sq.sq_port);
241
242 sq.sq_family = qmi->sq.sq_family;
243 sq.sq_node = qmi->sq.sq_node;
244 sq.sq_port = QRTR_PORT_CTRL;
245
246 msg.msg_name = &sq;
247 msg.msg_namelen = sizeof(sq);
248
249 mutex_lock(&qmi->sock_lock);
250 if (qmi->sock) {
251 ret = kernel_sendmsg(qmi->sock, &msg, &iv, 1, sizeof(pkt));
252 if (ret < 0)
253 pr_err("send service registration failed: %d\n", ret);
254 }
255 mutex_unlock(&qmi->sock_lock);
256}
257
258/**
259 * qmi_add_server() - register a service with the name service
260 * @qmi: qmi handle
261 * @service: type of the service
262 * @instance: instance of the service
263 * @version: version of the service
264 *
265 * Register a new service with the name service. This allows clients to find
266 * and start sending messages to the client associated with @qmi.
267 *
268 * Return: 0 on success, negative errno on failure.
269 */
270int qmi_add_server(struct qmi_handle *qmi, unsigned int service,
271 unsigned int version, unsigned int instance)
272{
273 struct qmi_service *svc;
274
275 svc = kzalloc(sizeof(*svc), GFP_KERNEL);
276 if (!svc)
277 return -ENOMEM;
278
279 svc->service = service;
280 svc->version = version;
281 svc->instance = instance;
282
283 list_add(&svc->list_node, &qmi->services);
284
285 qmi_send_new_server(qmi, svc);
286
287 return 0;
288}
289EXPORT_SYMBOL(qmi_add_server);
290
291/**
292 * qmi_txn_init() - allocate transaction id within the given QMI handle
293 * @qmi: QMI handle
294 * @txn: transaction context
295 * @ei: description of how to decode a matching response (optional)
296 * @c_struct: pointer to the object to decode the response into (optional)
297 *
298 * This allocates a transaction id within the QMI handle. If @ei and @c_struct
299 * are specified any responses to this transaction will be decoded as described
300 * by @ei into @c_struct.
301 *
302 * A client calling qmi_txn_init() must call either qmi_txn_wait() or
303 * qmi_txn_cancel() to free up the allocated resources.
304 *
305 * Return: Transaction id on success, negative errno on failure.
306 */
307int qmi_txn_init(struct qmi_handle *qmi, struct qmi_txn *txn,
308 struct qmi_elem_info *ei, void *c_struct)
309{
310 int ret;
311
312 memset(txn, 0, sizeof(*txn));
313
314 mutex_init(&txn->lock);
315 init_completion(&txn->completion);
316 txn->qmi = qmi;
317 txn->ei = ei;
318 txn->dest = c_struct;
319
320 mutex_lock(&qmi->txn_lock);
321 ret = idr_alloc_cyclic(&qmi->txns, txn, 0, INT_MAX, GFP_KERNEL);
322 if (ret < 0)
323 pr_err("failed to allocate transaction id\n");
324
325 txn->id = ret;
326 mutex_unlock(&qmi->txn_lock);
327
328 return ret;
329}
330EXPORT_SYMBOL(qmi_txn_init);
331
332/**
333 * qmi_txn_wait() - wait for a response on a transaction
334 * @txn: transaction handle
335 * @timeout: timeout, in jiffies
336 *
337 * If the transaction is decoded by the means of @ei and @c_struct the return
338 * value will be the returned value of qmi_decode_message(), otherwise it's up
339 * to the specified message handler to fill out the result.
340 *
341 * Return: the transaction response on success, negative errno on failure.
342 */
343int qmi_txn_wait(struct qmi_txn *txn, unsigned long timeout)
344{
345 struct qmi_handle *qmi = txn->qmi;
346 int ret;
347
348 ret = wait_for_completion_interruptible_timeout(&txn->completion,
349 timeout);
350
351 mutex_lock(&qmi->txn_lock);
352 mutex_lock(&txn->lock);
353 idr_remove(&qmi->txns, txn->id);
354 mutex_unlock(&txn->lock);
355 mutex_unlock(&qmi->txn_lock);
356
357 if (ret < 0)
358 return ret;
359 else if (ret == 0)
360 return -ETIMEDOUT;
361 else
362 return txn->result;
363}
364EXPORT_SYMBOL(qmi_txn_wait);
365
366/**
367 * qmi_txn_cancel() - cancel an ongoing transaction
368 * @txn: transaction id
369 */
370void qmi_txn_cancel(struct qmi_txn *txn)
371{
372 struct qmi_handle *qmi = txn->qmi;
373
374 mutex_lock(&qmi->txn_lock);
375 mutex_lock(&txn->lock);
376 idr_remove(&qmi->txns, txn->id);
377 mutex_unlock(&txn->lock);
378 mutex_unlock(&qmi->txn_lock);
379}
380EXPORT_SYMBOL(qmi_txn_cancel);
381
382/**
383 * qmi_invoke_handler() - find and invoke a handler for a message
384 * @qmi: qmi handle
385 * @sq: sockaddr of the sender
386 * @txn: transaction object for the message
387 * @buf: buffer containing the message
388 * @len: length of @buf
389 *
390 * Find handler and invoke handler for the incoming message.
391 */
392static void qmi_invoke_handler(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
393 struct qmi_txn *txn, const void *buf, size_t len)
394{
395 const struct qmi_msg_handler *handler;
396 const struct qmi_header *hdr = buf;
397 void *dest;
398 int ret;
399
400 if (!qmi->handlers)
401 return;
402
403 for (handler = qmi->handlers; handler->fn; handler++) {
404 if (handler->type == hdr->type &&
405 handler->msg_id == hdr->msg_id)
406 break;
407 }
408
409 if (!handler->fn)
410 return;
411
412 dest = kzalloc(handler->decoded_size, GFP_KERNEL);
413 if (!dest)
414 return;
415
416 ret = qmi_decode_message(buf, len, handler->ei, dest);
417 if (ret < 0)
418 pr_err("failed to decode incoming message\n");
419 else
420 handler->fn(qmi, sq, txn, dest);
421
422 kfree(dest);
423}
424
425/**
426 * qmi_handle_net_reset() - invoked to handle ENETRESET on a QMI handle
427 * @qmi: the QMI context
428 *
429 * As a result of registering a name service with the QRTR all open sockets are
430 * flagged with ENETRESET and this function will be called. The typical case is
431 * the initial boot, where this signals that the local node id has been
432 * configured and as such any bound sockets needs to be rebound. So close the
433 * socket, inform the client and re-initialize the socket.
434 *
435 * For clients it's generally sufficient to react to the del_server callbacks,
436 * but server code is expected to treat the net_reset callback as a "bye" from
437 * all nodes.
438 *
439 * Finally the QMI handle will send out registration requests for any lookups
440 * and services.
441 */
442static void qmi_handle_net_reset(struct qmi_handle *qmi)
443{
444 struct sockaddr_qrtr sq;
445 struct qmi_service *svc;
446 struct socket *sock;
447
448 sock = qmi_sock_create(qmi, &sq);
449 if (IS_ERR(sock))
450 return;
451
452 mutex_lock(&qmi->sock_lock);
453 sock_release(qmi->sock);
454 qmi->sock = NULL;
455 mutex_unlock(&qmi->sock_lock);
456
457 qmi_recv_del_server(qmi, -1, -1);
458
459 if (qmi->ops.net_reset)
460 qmi->ops.net_reset(qmi);
461
462 mutex_lock(&qmi->sock_lock);
463 qmi->sock = sock;
464 qmi->sq = sq;
465 mutex_unlock(&qmi->sock_lock);
466
467 list_for_each_entry(svc, &qmi->lookups, list_node)
468 qmi_send_new_lookup(qmi, svc);
469
470 list_for_each_entry(svc, &qmi->services, list_node)
471 qmi_send_new_server(qmi, svc);
472}
473
474static void qmi_handle_message(struct qmi_handle *qmi,
475 struct sockaddr_qrtr *sq,
476 const void *buf, size_t len)
477{
478 const struct qmi_header *hdr;
479 struct qmi_txn tmp_txn;
480 struct qmi_txn *txn = NULL;
481 int ret;
482
483 if (len < sizeof(*hdr)) {
484 pr_err("ignoring short QMI packet\n");
485 return;
486 }
487
488 hdr = buf;
489
490 /* If this is a response, find the matching transaction handle */
491 if (hdr->type == QMI_RESPONSE) {
492 mutex_lock(&qmi->txn_lock);
493 txn = idr_find(&qmi->txns, hdr->txn_id);
494
495 /* Ignore unexpected responses */
496 if (!txn) {
497 mutex_unlock(&qmi->txn_lock);
498 return;
499 }
500
501 mutex_lock(&txn->lock);
502 mutex_unlock(&qmi->txn_lock);
503
504 if (txn->dest && txn->ei) {
505 ret = qmi_decode_message(buf, len, txn->ei, txn->dest);
506 if (ret < 0)
507 pr_err("failed to decode incoming message\n");
508
509 txn->result = ret;
510 complete(&txn->completion);
511 } else {
512 qmi_invoke_handler(qmi, sq, txn, buf, len);
513 }
514
515 mutex_unlock(&txn->lock);
516 } else {
517 /* Create a txn based on the txn_id of the incoming message */
518 memset(&tmp_txn, 0, sizeof(tmp_txn));
519 tmp_txn.id = hdr->txn_id;
520
521 qmi_invoke_handler(qmi, sq, &tmp_txn, buf, len);
522 }
523}
524
525static void qmi_data_ready_work(struct work_struct *work)
526{
527 struct qmi_handle *qmi = container_of(work, struct qmi_handle, work);
528 struct qmi_ops *ops = &qmi->ops;
529 struct sockaddr_qrtr sq;
530 struct msghdr msg = { .msg_name = &sq, .msg_namelen = sizeof(sq) };
531 struct kvec iv;
532 ssize_t msglen;
533
534 for (;;) {
535 iv.iov_base = qmi->recv_buf;
536 iv.iov_len = qmi->recv_buf_size;
537
538 mutex_lock(&qmi->sock_lock);
539 if (qmi->sock)
540 msglen = kernel_recvmsg(qmi->sock, &msg, &iv, 1,
541 iv.iov_len, MSG_DONTWAIT);
542 else
543 msglen = -EPIPE;
544 mutex_unlock(&qmi->sock_lock);
545 if (msglen == -EAGAIN)
546 break;
547
548 if (msglen == -ENETRESET) {
549 qmi_handle_net_reset(qmi);
550
551 /* The old qmi->sock is gone, our work is done */
552 break;
553 }
554
555 if (msglen < 0) {
556 pr_err("qmi recvmsg failed: %zd\n", msglen);
557 break;
558 }
559
560 if (sq.sq_node == qmi->sq.sq_node &&
561 sq.sq_port == QRTR_PORT_CTRL) {
562 qmi_recv_ctrl_pkt(qmi, qmi->recv_buf, msglen);
563 } else if (ops->msg_handler) {
564 ops->msg_handler(qmi, &sq, qmi->recv_buf, msglen);
565 } else {
566 qmi_handle_message(qmi, &sq, qmi->recv_buf, msglen);
567 }
568 }
569}
570
571static void qmi_data_ready(struct sock *sk)
572{
573 struct qmi_handle *qmi = sk->sk_user_data;
574
575 /*
576 * This will be NULL if we receive data while being in
577 * qmi_handle_release()
578 */
579 if (!qmi)
580 return;
581
582 queue_work(qmi->wq, &qmi->work);
583}
584
585static struct socket *qmi_sock_create(struct qmi_handle *qmi,
586 struct sockaddr_qrtr *sq)
587{
588 struct socket *sock;
589 int ret;
590
591 ret = sock_create_kern(&init_net, AF_QIPCRTR, SOCK_DGRAM,
592 PF_QIPCRTR, &sock);
593 if (ret < 0)
594 return ERR_PTR(ret);
595
596 ret = kernel_getsockname(sock, (struct sockaddr *)sq);
597 if (ret < 0) {
598 sock_release(sock);
599 return ERR_PTR(ret);
600 }
601
602 sock->sk->sk_user_data = qmi;
603 sock->sk->sk_data_ready = qmi_data_ready;
604 sock->sk->sk_error_report = qmi_data_ready;
605
606 return sock;
607}
608
609/**
610 * qmi_handle_init() - initialize a QMI client handle
611 * @qmi: QMI handle to initialize
612 * @recv_buf_size: maximum size of incoming message
613 * @ops: reference to callbacks for QRTR notifications
614 * @handlers: NULL-terminated list of QMI message handlers
615 *
616 * This initializes the QMI client handle to allow sending and receiving QMI
617 * messages. As messages are received the appropriate handler will be invoked.
618 *
619 * Return: 0 on success, negative errno on failure.
620 */
621int qmi_handle_init(struct qmi_handle *qmi, size_t recv_buf_size,
622 const struct qmi_ops *ops,
623 const struct qmi_msg_handler *handlers)
624{
625 int ret;
626
627 mutex_init(&qmi->txn_lock);
628 mutex_init(&qmi->sock_lock);
629
630 idr_init(&qmi->txns);
631
632 INIT_LIST_HEAD(&qmi->lookups);
633 INIT_LIST_HEAD(&qmi->lookup_results);
634 INIT_LIST_HEAD(&qmi->services);
635
636 INIT_WORK(&qmi->work, qmi_data_ready_work);
637
638 qmi->handlers = handlers;
639 if (ops)
640 qmi->ops = *ops;
641
642 if (recv_buf_size < sizeof(struct qrtr_ctrl_pkt))
643 recv_buf_size = sizeof(struct qrtr_ctrl_pkt);
644 else
645 recv_buf_size += sizeof(struct qmi_header);
646
647 qmi->recv_buf_size = recv_buf_size;
648 qmi->recv_buf = kzalloc(recv_buf_size, GFP_KERNEL);
649 if (!qmi->recv_buf)
650 return -ENOMEM;
651
652 qmi->wq = alloc_workqueue("qmi_msg_handler", WQ_UNBOUND, 1);
653 if (!qmi->wq) {
654 ret = -ENOMEM;
655 goto err_free_recv_buf;
656 }
657
658 qmi->sock = qmi_sock_create(qmi, &qmi->sq);
659 if (IS_ERR(qmi->sock)) {
660 pr_err("failed to create QMI socket\n");
661 ret = PTR_ERR(qmi->sock);
662 goto err_destroy_wq;
663 }
664
665 return 0;
666
667err_destroy_wq:
668 destroy_workqueue(qmi->wq);
669err_free_recv_buf:
670 kfree(qmi->recv_buf);
671
672 return ret;
673}
674EXPORT_SYMBOL(qmi_handle_init);
675
676/**
677 * qmi_handle_release() - release the QMI client handle
678 * @qmi: QMI client handle
679 *
680 * This closes the underlying socket and stops any handling of QMI messages.
681 */
682void qmi_handle_release(struct qmi_handle *qmi)
683{
684 struct socket *sock = qmi->sock;
685 struct qmi_service *svc, *tmp;
686
687 sock->sk->sk_user_data = NULL;
688 cancel_work_sync(&qmi->work);
689
690 qmi_recv_del_server(qmi, -1, -1);
691
692 mutex_lock(&qmi->sock_lock);
693 sock_release(sock);
694 qmi->sock = NULL;
695 mutex_unlock(&qmi->sock_lock);
696
697 destroy_workqueue(qmi->wq);
698
699 idr_destroy(&qmi->txns);
700
701 kfree(qmi->recv_buf);
702
703 /* Free registered lookup requests */
704 list_for_each_entry_safe(svc, tmp, &qmi->lookups, list_node) {
705 list_del(&svc->list_node);
706 kfree(svc);
707 }
708
709 /* Free registered service information */
710 list_for_each_entry_safe(svc, tmp, &qmi->services, list_node) {
711 list_del(&svc->list_node);
712 kfree(svc);
713 }
714}
715EXPORT_SYMBOL(qmi_handle_release);
716
717/**
718 * qmi_send_message() - send a QMI message
719 * @qmi: QMI client handle
720 * @sq: destination sockaddr
721 * @txn: transaction object to use for the message
722 * @type: type of message to send
723 * @msg_id: message id
724 * @len: max length of the QMI message
725 * @ei: QMI message description
726 * @c_struct: object to be encoded
727 *
728 * This function encodes @c_struct using @ei into a message of type @type,
729 * with @msg_id and @txn into a buffer of maximum size @len, and sends this to
730 * @sq.
731 *
732 * Return: 0 on success, negative errno on failure.
733 */
734static ssize_t qmi_send_message(struct qmi_handle *qmi,
735 struct sockaddr_qrtr *sq, struct qmi_txn *txn,
736 int type, int msg_id, size_t len,
737 struct qmi_elem_info *ei, const void *c_struct)
738{
739 struct msghdr msghdr = {};
740 struct kvec iv;
741 void *msg;
742 int ret;
743
744 msg = qmi_encode_message(type,
745 msg_id, &len,
746 txn->id, ei,
747 c_struct);
748 if (IS_ERR(msg))
749 return PTR_ERR(msg);
750
751 iv.iov_base = msg;
752 iv.iov_len = len;
753
754 if (sq) {
755 msghdr.msg_name = sq;
756 msghdr.msg_namelen = sizeof(*sq);
757 }
758
759 mutex_lock(&qmi->sock_lock);
760 if (qmi->sock) {
761 ret = kernel_sendmsg(qmi->sock, &msghdr, &iv, 1, len);
762 if (ret < 0)
763 pr_err("failed to send QMI message\n");
764 } else {
765 ret = -EPIPE;
766 }
767 mutex_unlock(&qmi->sock_lock);
768
769 kfree(msg);
770
771 return ret < 0 ? ret : 0;
772}
773
774/**
775 * qmi_send_request() - send a request QMI message
776 * @qmi: QMI client handle
777 * @sq: destination sockaddr
778 * @txn: transaction object to use for the message
779 * @msg_id: message id
780 * @len: max length of the QMI message
781 * @ei: QMI message description
782 * @c_struct: object to be encoded
783 *
784 * Return: 0 on success, negative errno on failure.
785 */
786ssize_t qmi_send_request(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
787 struct qmi_txn *txn, int msg_id, size_t len,
788 struct qmi_elem_info *ei, const void *c_struct)
789{
790 return qmi_send_message(qmi, sq, txn, QMI_REQUEST, msg_id, len, ei,
791 c_struct);
792}
793EXPORT_SYMBOL(qmi_send_request);
794
795/**
796 * qmi_send_response() - send a response QMI message
797 * @qmi: QMI client handle
798 * @sq: destination sockaddr
799 * @txn: transaction object to use for the message
800 * @msg_id: message id
801 * @len: max length of the QMI message
802 * @ei: QMI message description
803 * @c_struct: object to be encoded
804 *
805 * Return: 0 on success, negative errno on failure.
806 */
807ssize_t qmi_send_response(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
808 struct qmi_txn *txn, int msg_id, size_t len,
809 struct qmi_elem_info *ei, const void *c_struct)
810{
811 return qmi_send_message(qmi, sq, txn, QMI_RESPONSE, msg_id, len, ei,
812 c_struct);
813}
814EXPORT_SYMBOL(qmi_send_response);
815
816/**
817 * qmi_send_indication() - send an indication QMI message
818 * @qmi: QMI client handle
819 * @sq: destination sockaddr
820 * @msg_id: message id
821 * @len: max length of the QMI message
822 * @ei: QMI message description
823 * @c_struct: object to be encoded
824 *
825 * Return: 0 on success, negative errno on failure.
826 */
827ssize_t qmi_send_indication(struct qmi_handle *qmi, struct sockaddr_qrtr *sq,
828 int msg_id, size_t len, struct qmi_elem_info *ei,
829 const void *c_struct)
830{
831 struct qmi_txn txn;
832 ssize_t rval;
833 int ret;
834
835 ret = qmi_txn_init(qmi, &txn, NULL, NULL);
836 if (ret < 0)
837 return ret;
838
839 rval = qmi_send_message(qmi, sq, &txn, QMI_INDICATION, msg_id, len, ei,
840 c_struct);
841
842 /* We don't care about future messages on this txn */
843 qmi_txn_cancel(&txn);
844
845 return rval;
846}
847EXPORT_SYMBOL(qmi_send_indication);