2 * Copyright (c) 2015, Sony Mobile Communications Inc.
3 * Copyright (c) 2013, The Linux Foundation. All rights reserved.
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 and
7 * only version 2 as published by the Free Software Foundation.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 #include <linux/module.h>
15 #include <linux/netlink.h>
16 #include <linux/qrtr.h>
17 #include <linux/termios.h> /* For TIOCINQ/OUTQ */
23 #define QRTR_PROTO_VER 1
26 #define QRTR_MIN_EPH_SOCKET 0x4000
27 #define QRTR_MAX_EPH_SOCKET 0x7fff
33 QRTR_TYPE_NEW_SERVER
= 4,
34 QRTR_TYPE_DEL_SERVER
= 5,
35 QRTR_TYPE_DEL_CLIENT
= 6,
36 QRTR_TYPE_RESUME_TX
= 7,
42 * struct qrtr_hdr - (I|R)PCrouter packet header
43 * @version: protocol version
44 * @type: packet type; one of QRTR_TYPE_*
45 * @src_node_id: source node
46 * @src_port_id: source port
47 * @confirm_rx: boolean; whether a resume-tx packet should be send in reply
48 * @size: length of packet, excluding this header
49 * @dst_node_id: destination node
50 * @dst_port_id: destination port
63 #define QRTR_HDR_SIZE sizeof(struct qrtr_hdr)
66 /* WARNING: sk must be the first member */
68 struct sockaddr_qrtr us
;
69 struct sockaddr_qrtr peer
;
72 static inline struct qrtr_sock
*qrtr_sk(struct sock
*sk
)
74 BUILD_BUG_ON(offsetof(struct qrtr_sock
, sk
) != 0);
75 return container_of(sk
, struct qrtr_sock
, sk
);
78 static unsigned int qrtr_local_nid
= -1;
81 static RADIX_TREE(qrtr_nodes
, GFP_KERNEL
);
83 static LIST_HEAD(qrtr_all_nodes
);
84 /* lock for qrtr_nodes, qrtr_all_nodes and node reference */
85 static DEFINE_MUTEX(qrtr_node_lock
);
87 /* local port allocation management */
88 static DEFINE_IDR(qrtr_ports
);
89 static DEFINE_MUTEX(qrtr_port_lock
);
92 * struct qrtr_node - endpoint node
93 * @ep_lock: lock for endpoint management and callbacks
95 * @ref: reference count for node
97 * @rx_queue: receive queue
98 * @work: scheduled work struct for recv work
99 * @item: list item for broadcast list
102 struct mutex ep_lock
;
103 struct qrtr_endpoint
*ep
;
107 struct sk_buff_head rx_queue
;
108 struct work_struct work
;
109 struct list_head item
;
112 static int qrtr_local_enqueue(struct qrtr_node
*node
, struct sk_buff
*skb
);
113 static int qrtr_bcast_enqueue(struct qrtr_node
*node
, struct sk_buff
*skb
);
115 /* Release node resources and free the node.
117 * Do not call directly, use qrtr_node_release. To be used with
118 * kref_put_mutex. As such, the node mutex is expected to be locked on call.
120 static void __qrtr_node_release(struct kref
*kref
)
122 struct qrtr_node
*node
= container_of(kref
, struct qrtr_node
, ref
);
124 if (node
->nid
!= QRTR_EP_NID_AUTO
)
125 radix_tree_delete(&qrtr_nodes
, node
->nid
);
127 list_del(&node
->item
);
128 mutex_unlock(&qrtr_node_lock
);
130 skb_queue_purge(&node
->rx_queue
);
134 /* Increment reference to node. */
135 static struct qrtr_node
*qrtr_node_acquire(struct qrtr_node
*node
)
138 kref_get(&node
->ref
);
142 /* Decrement reference to node and release as necessary. */
143 static void qrtr_node_release(struct qrtr_node
*node
)
147 kref_put_mutex(&node
->ref
, __qrtr_node_release
, &qrtr_node_lock
);
150 /* Pass an outgoing packet socket buffer to the endpoint driver. */
151 static int qrtr_node_enqueue(struct qrtr_node
*node
, struct sk_buff
*skb
)
155 mutex_lock(&node
->ep_lock
);
157 rc
= node
->ep
->xmit(node
->ep
, skb
);
160 mutex_unlock(&node
->ep_lock
);
165 /* Lookup node by id.
167 * callers must release with qrtr_node_release()
169 static struct qrtr_node
*qrtr_node_lookup(unsigned int nid
)
171 struct qrtr_node
*node
;
173 mutex_lock(&qrtr_node_lock
);
174 node
= radix_tree_lookup(&qrtr_nodes
, nid
);
175 node
= qrtr_node_acquire(node
);
176 mutex_unlock(&qrtr_node_lock
);
181 /* Assign node id to node.
183 * This is mostly useful for automatic node id assignment, based on
184 * the source id in the incoming packet.
186 static void qrtr_node_assign(struct qrtr_node
*node
, unsigned int nid
)
188 if (node
->nid
!= QRTR_EP_NID_AUTO
|| nid
== QRTR_EP_NID_AUTO
)
191 mutex_lock(&qrtr_node_lock
);
192 radix_tree_insert(&qrtr_nodes
, nid
, node
);
194 mutex_unlock(&qrtr_node_lock
);
198 * qrtr_endpoint_post() - post incoming data
199 * @ep: endpoint handle
200 * @data: data pointer
201 * @len: size of data in bytes
203 * Return: 0 on success; negative error code on failure
205 int qrtr_endpoint_post(struct qrtr_endpoint
*ep
, const void *data
, size_t len
)
207 struct qrtr_node
*node
= ep
->node
;
208 const struct qrtr_hdr
*phdr
= data
;
216 if (len
< QRTR_HDR_SIZE
|| len
& 3)
219 ver
= le32_to_cpu(phdr
->version
);
220 size
= le32_to_cpu(phdr
->size
);
221 type
= le32_to_cpu(phdr
->type
);
222 dst
= le32_to_cpu(phdr
->dst_port_id
);
224 psize
= (size
+ 3) & ~3;
226 if (ver
!= QRTR_PROTO_VER
)
229 if (len
!= psize
+ QRTR_HDR_SIZE
)
232 if (dst
!= QRTR_PORT_CTRL
&& type
!= QRTR_TYPE_DATA
)
235 skb
= netdev_alloc_skb(NULL
, len
);
239 skb_reset_transport_header(skb
);
240 skb_put_data(skb
, data
, len
);
242 skb_queue_tail(&node
->rx_queue
, skb
);
243 schedule_work(&node
->work
);
247 EXPORT_SYMBOL_GPL(qrtr_endpoint_post
);
249 static struct sk_buff
*qrtr_alloc_ctrl_packet(u32 type
, size_t pkt_len
,
250 u32 src_node
, u32 dst_node
)
252 struct qrtr_hdr
*hdr
;
255 skb
= alloc_skb(QRTR_HDR_SIZE
+ pkt_len
, GFP_KERNEL
);
258 skb_reset_transport_header(skb
);
260 hdr
= skb_put(skb
, QRTR_HDR_SIZE
);
261 hdr
->version
= cpu_to_le32(QRTR_PROTO_VER
);
262 hdr
->type
= cpu_to_le32(type
);
263 hdr
->src_node_id
= cpu_to_le32(src_node
);
264 hdr
->src_port_id
= cpu_to_le32(QRTR_PORT_CTRL
);
265 hdr
->confirm_rx
= cpu_to_le32(0);
266 hdr
->size
= cpu_to_le32(pkt_len
);
267 hdr
->dst_node_id
= cpu_to_le32(dst_node
);
268 hdr
->dst_port_id
= cpu_to_le32(QRTR_PORT_CTRL
);
273 /* Allocate and construct a resume-tx packet. */
274 static struct sk_buff
*qrtr_alloc_resume_tx(u32 src_node
,
275 u32 dst_node
, u32 port
)
277 const int pkt_len
= 20;
281 skb
= qrtr_alloc_ctrl_packet(QRTR_TYPE_RESUME_TX
, pkt_len
,
286 buf
= skb_put_zero(skb
, pkt_len
);
287 buf
[0] = cpu_to_le32(QRTR_TYPE_RESUME_TX
);
288 buf
[1] = cpu_to_le32(src_node
);
289 buf
[2] = cpu_to_le32(port
);
294 /* Allocate and construct a BYE message to signal remote termination */
295 static struct sk_buff
*qrtr_alloc_local_bye(u32 src_node
)
297 const int pkt_len
= 20;
301 skb
= qrtr_alloc_ctrl_packet(QRTR_TYPE_BYE
, pkt_len
,
302 src_node
, qrtr_local_nid
);
306 buf
= skb_put_zero(skb
, pkt_len
);
307 buf
[0] = cpu_to_le32(QRTR_TYPE_BYE
);
312 static struct sk_buff
*qrtr_alloc_del_client(struct sockaddr_qrtr
*sq
)
314 const int pkt_len
= 20;
318 skb
= qrtr_alloc_ctrl_packet(QRTR_TYPE_DEL_CLIENT
, pkt_len
,
319 sq
->sq_node
, QRTR_NODE_BCAST
);
323 buf
= skb_put_zero(skb
, pkt_len
);
324 buf
[0] = cpu_to_le32(QRTR_TYPE_DEL_CLIENT
);
325 buf
[1] = cpu_to_le32(sq
->sq_node
);
326 buf
[2] = cpu_to_le32(sq
->sq_port
);
331 static struct qrtr_sock
*qrtr_port_lookup(int port
);
332 static void qrtr_port_put(struct qrtr_sock
*ipc
);
334 /* Handle and route a received packet.
336 * This will auto-reply with resume-tx packet as necessary.
338 static void qrtr_node_rx_work(struct work_struct
*work
)
340 struct qrtr_node
*node
= container_of(work
, struct qrtr_node
, work
);
343 while ((skb
= skb_dequeue(&node
->rx_queue
)) != NULL
) {
344 const struct qrtr_hdr
*phdr
;
345 u32 dst_node
, dst_port
;
346 struct qrtr_sock
*ipc
;
350 phdr
= (const struct qrtr_hdr
*)skb_transport_header(skb
);
351 src_node
= le32_to_cpu(phdr
->src_node_id
);
352 dst_node
= le32_to_cpu(phdr
->dst_node_id
);
353 dst_port
= le32_to_cpu(phdr
->dst_port_id
);
354 confirm
= !!phdr
->confirm_rx
;
356 qrtr_node_assign(node
, src_node
);
358 ipc
= qrtr_port_lookup(dst_port
);
362 if (sock_queue_rcv_skb(&ipc
->sk
, skb
))
369 skb
= qrtr_alloc_resume_tx(dst_node
, node
->nid
, dst_port
);
372 if (qrtr_node_enqueue(node
, skb
))
379 * qrtr_endpoint_register() - register a new endpoint
380 * @ep: endpoint to register
381 * @nid: desired node id; may be QRTR_EP_NID_AUTO for auto-assignment
382 * Return: 0 on success; negative error code on failure
384 * The specified endpoint must have the xmit function pointer set on call.
386 int qrtr_endpoint_register(struct qrtr_endpoint
*ep
, unsigned int nid
)
388 struct qrtr_node
*node
;
390 if (!ep
|| !ep
->xmit
)
393 node
= kzalloc(sizeof(*node
), GFP_KERNEL
);
397 INIT_WORK(&node
->work
, qrtr_node_rx_work
);
398 kref_init(&node
->ref
);
399 mutex_init(&node
->ep_lock
);
400 skb_queue_head_init(&node
->rx_queue
);
401 node
->nid
= QRTR_EP_NID_AUTO
;
404 qrtr_node_assign(node
, nid
);
406 mutex_lock(&qrtr_node_lock
);
407 list_add(&node
->item
, &qrtr_all_nodes
);
408 mutex_unlock(&qrtr_node_lock
);
413 EXPORT_SYMBOL_GPL(qrtr_endpoint_register
);
416 * qrtr_endpoint_unregister - unregister endpoint
417 * @ep: endpoint to unregister
419 void qrtr_endpoint_unregister(struct qrtr_endpoint
*ep
)
421 struct qrtr_node
*node
= ep
->node
;
424 mutex_lock(&node
->ep_lock
);
426 mutex_unlock(&node
->ep_lock
);
428 /* Notify the local controller about the event */
429 skb
= qrtr_alloc_local_bye(node
->nid
);
431 qrtr_local_enqueue(NULL
, skb
);
433 qrtr_node_release(node
);
436 EXPORT_SYMBOL_GPL(qrtr_endpoint_unregister
);
438 /* Lookup socket by port.
440 * Callers must release with qrtr_port_put()
442 static struct qrtr_sock
*qrtr_port_lookup(int port
)
444 struct qrtr_sock
*ipc
;
446 if (port
== QRTR_PORT_CTRL
)
449 mutex_lock(&qrtr_port_lock
);
450 ipc
= idr_find(&qrtr_ports
, port
);
453 mutex_unlock(&qrtr_port_lock
);
458 /* Release acquired socket. */
459 static void qrtr_port_put(struct qrtr_sock
*ipc
)
464 /* Remove port assignment. */
465 static void qrtr_port_remove(struct qrtr_sock
*ipc
)
468 int port
= ipc
->us
.sq_port
;
470 skb
= qrtr_alloc_del_client(&ipc
->us
);
472 skb_set_owner_w(skb
, &ipc
->sk
);
473 qrtr_bcast_enqueue(NULL
, skb
);
476 if (port
== QRTR_PORT_CTRL
)
479 __sock_put(&ipc
->sk
);
481 mutex_lock(&qrtr_port_lock
);
482 idr_remove(&qrtr_ports
, port
);
483 mutex_unlock(&qrtr_port_lock
);
486 /* Assign port number to socket.
488 * Specify port in the integer pointed to by port, and it will be adjusted
489 * on return as necesssary.
492 * 0: Assign ephemeral port in [QRTR_MIN_EPH_SOCKET, QRTR_MAX_EPH_SOCKET]
493 * <QRTR_MIN_EPH_SOCKET: Specified; requires CAP_NET_ADMIN
494 * >QRTR_MIN_EPH_SOCKET: Specified; available to all
496 static int qrtr_port_assign(struct qrtr_sock
*ipc
, int *port
)
500 mutex_lock(&qrtr_port_lock
);
502 rc
= idr_alloc(&qrtr_ports
, ipc
,
503 QRTR_MIN_EPH_SOCKET
, QRTR_MAX_EPH_SOCKET
+ 1,
507 } else if (*port
< QRTR_MIN_EPH_SOCKET
&& !capable(CAP_NET_ADMIN
)) {
509 } else if (*port
== QRTR_PORT_CTRL
) {
510 rc
= idr_alloc(&qrtr_ports
, ipc
, 0, 1, GFP_ATOMIC
);
512 rc
= idr_alloc(&qrtr_ports
, ipc
, *port
, *port
+ 1, GFP_ATOMIC
);
516 mutex_unlock(&qrtr_port_lock
);
528 /* Reset all non-control ports */
529 static void qrtr_reset_ports(void)
531 struct qrtr_sock
*ipc
;
534 mutex_lock(&qrtr_port_lock
);
535 idr_for_each_entry(&qrtr_ports
, ipc
, id
) {
536 /* Don't reset control port */
541 ipc
->sk
.sk_err
= ENETRESET
;
542 ipc
->sk
.sk_error_report(&ipc
->sk
);
545 mutex_unlock(&qrtr_port_lock
);
548 /* Bind socket to address.
550 * Socket should be locked upon call.
552 static int __qrtr_bind(struct socket
*sock
,
553 const struct sockaddr_qrtr
*addr
, int zapped
)
555 struct qrtr_sock
*ipc
= qrtr_sk(sock
->sk
);
556 struct sock
*sk
= sock
->sk
;
561 if (!zapped
&& addr
->sq_port
== ipc
->us
.sq_port
)
564 port
= addr
->sq_port
;
565 rc
= qrtr_port_assign(ipc
, &port
);
569 /* unbind previous, if any */
571 qrtr_port_remove(ipc
);
572 ipc
->us
.sq_port
= port
;
574 sock_reset_flag(sk
, SOCK_ZAPPED
);
576 /* Notify all open ports about the new controller */
577 if (port
== QRTR_PORT_CTRL
)
583 /* Auto bind to an ephemeral port. */
584 static int qrtr_autobind(struct socket
*sock
)
586 struct sock
*sk
= sock
->sk
;
587 struct sockaddr_qrtr addr
;
589 if (!sock_flag(sk
, SOCK_ZAPPED
))
592 addr
.sq_family
= AF_QIPCRTR
;
593 addr
.sq_node
= qrtr_local_nid
;
596 return __qrtr_bind(sock
, &addr
, 1);
599 /* Bind socket to specified sockaddr. */
600 static int qrtr_bind(struct socket
*sock
, struct sockaddr
*saddr
, int len
)
602 DECLARE_SOCKADDR(struct sockaddr_qrtr
*, addr
, saddr
);
603 struct qrtr_sock
*ipc
= qrtr_sk(sock
->sk
);
604 struct sock
*sk
= sock
->sk
;
607 if (len
< sizeof(*addr
) || addr
->sq_family
!= AF_QIPCRTR
)
610 if (addr
->sq_node
!= ipc
->us
.sq_node
)
614 rc
= __qrtr_bind(sock
, addr
, sock_flag(sk
, SOCK_ZAPPED
));
620 /* Queue packet to local peer socket. */
621 static int qrtr_local_enqueue(struct qrtr_node
*node
, struct sk_buff
*skb
)
623 const struct qrtr_hdr
*phdr
;
624 struct qrtr_sock
*ipc
;
626 phdr
= (const struct qrtr_hdr
*)skb_transport_header(skb
);
628 ipc
= qrtr_port_lookup(le32_to_cpu(phdr
->dst_port_id
));
629 if (!ipc
|| &ipc
->sk
== skb
->sk
) { /* do not send to self */
634 if (sock_queue_rcv_skb(&ipc
->sk
, skb
)) {
645 /* Queue packet for broadcast. */
646 static int qrtr_bcast_enqueue(struct qrtr_node
*node
, struct sk_buff
*skb
)
648 struct sk_buff
*skbn
;
650 mutex_lock(&qrtr_node_lock
);
651 list_for_each_entry(node
, &qrtr_all_nodes
, item
) {
652 skbn
= skb_clone(skb
, GFP_KERNEL
);
655 skb_set_owner_w(skbn
, skb
->sk
);
656 qrtr_node_enqueue(node
, skbn
);
658 mutex_unlock(&qrtr_node_lock
);
660 qrtr_local_enqueue(node
, skb
);
665 static int qrtr_sendmsg(struct socket
*sock
, struct msghdr
*msg
, size_t len
)
667 DECLARE_SOCKADDR(struct sockaddr_qrtr
*, addr
, msg
->msg_name
);
668 int (*enqueue_fn
)(struct qrtr_node
*, struct sk_buff
*);
669 struct qrtr_sock
*ipc
= qrtr_sk(sock
->sk
);
670 struct sock
*sk
= sock
->sk
;
671 struct qrtr_node
*node
;
672 struct qrtr_hdr
*hdr
;
677 if (msg
->msg_flags
& ~(MSG_DONTWAIT
))
686 if (msg
->msg_namelen
< sizeof(*addr
)) {
691 if (addr
->sq_family
!= AF_QIPCRTR
) {
696 rc
= qrtr_autobind(sock
);
701 } else if (sk
->sk_state
== TCP_ESTABLISHED
) {
709 if (addr
->sq_node
== QRTR_NODE_BCAST
) {
710 enqueue_fn
= qrtr_bcast_enqueue
;
711 } else if (addr
->sq_node
== ipc
->us
.sq_node
) {
712 enqueue_fn
= qrtr_local_enqueue
;
714 enqueue_fn
= qrtr_node_enqueue
;
715 node
= qrtr_node_lookup(addr
->sq_node
);
722 plen
= (len
+ 3) & ~3;
723 skb
= sock_alloc_send_skb(sk
, plen
+ QRTR_HDR_SIZE
,
724 msg
->msg_flags
& MSG_DONTWAIT
, &rc
);
728 skb_reset_transport_header(skb
);
729 skb_put(skb
, len
+ QRTR_HDR_SIZE
);
731 hdr
= (struct qrtr_hdr
*)skb_transport_header(skb
);
732 hdr
->version
= cpu_to_le32(QRTR_PROTO_VER
);
733 hdr
->src_node_id
= cpu_to_le32(ipc
->us
.sq_node
);
734 hdr
->src_port_id
= cpu_to_le32(ipc
->us
.sq_port
);
735 hdr
->confirm_rx
= cpu_to_le32(0);
736 hdr
->size
= cpu_to_le32(len
);
737 hdr
->dst_node_id
= cpu_to_le32(addr
->sq_node
);
738 hdr
->dst_port_id
= cpu_to_le32(addr
->sq_port
);
740 rc
= skb_copy_datagram_from_iter(skb
, QRTR_HDR_SIZE
,
741 &msg
->msg_iter
, len
);
748 rc
= skb_pad(skb
, plen
- len
);
751 skb_put(skb
, plen
- len
);
754 if (ipc
->us
.sq_port
== QRTR_PORT_CTRL
) {
761 /* control messages already require the type as 'command' */
762 skb_copy_bits(skb
, QRTR_HDR_SIZE
, &hdr
->type
, 4);
764 hdr
->type
= cpu_to_le32(QRTR_TYPE_DATA
);
767 rc
= enqueue_fn(node
, skb
);
772 qrtr_node_release(node
);
778 static int qrtr_recvmsg(struct socket
*sock
, struct msghdr
*msg
,
779 size_t size
, int flags
)
781 DECLARE_SOCKADDR(struct sockaddr_qrtr
*, addr
, msg
->msg_name
);
782 const struct qrtr_hdr
*phdr
;
783 struct sock
*sk
= sock
->sk
;
789 if (sock_flag(sk
, SOCK_ZAPPED
)) {
791 return -EADDRNOTAVAIL
;
794 skb
= skb_recv_datagram(sk
, flags
& ~MSG_DONTWAIT
,
795 flags
& MSG_DONTWAIT
, &rc
);
801 phdr
= (const struct qrtr_hdr
*)skb_transport_header(skb
);
802 copied
= le32_to_cpu(phdr
->size
);
805 msg
->msg_flags
|= MSG_TRUNC
;
808 rc
= skb_copy_datagram_msg(skb
, QRTR_HDR_SIZE
, msg
, copied
);
814 addr
->sq_family
= AF_QIPCRTR
;
815 addr
->sq_node
= le32_to_cpu(phdr
->src_node_id
);
816 addr
->sq_port
= le32_to_cpu(phdr
->src_port_id
);
817 msg
->msg_namelen
= sizeof(*addr
);
821 skb_free_datagram(sk
, skb
);
827 static int qrtr_connect(struct socket
*sock
, struct sockaddr
*saddr
,
830 DECLARE_SOCKADDR(struct sockaddr_qrtr
*, addr
, saddr
);
831 struct qrtr_sock
*ipc
= qrtr_sk(sock
->sk
);
832 struct sock
*sk
= sock
->sk
;
835 if (len
< sizeof(*addr
) || addr
->sq_family
!= AF_QIPCRTR
)
840 sk
->sk_state
= TCP_CLOSE
;
841 sock
->state
= SS_UNCONNECTED
;
843 rc
= qrtr_autobind(sock
);
850 sock
->state
= SS_CONNECTED
;
851 sk
->sk_state
= TCP_ESTABLISHED
;
858 static int qrtr_getname(struct socket
*sock
, struct sockaddr
*saddr
,
861 struct qrtr_sock
*ipc
= qrtr_sk(sock
->sk
);
862 struct sockaddr_qrtr qaddr
;
863 struct sock
*sk
= sock
->sk
;
867 if (sk
->sk_state
!= TCP_ESTABLISHED
) {
878 *len
= sizeof(qaddr
);
879 qaddr
.sq_family
= AF_QIPCRTR
;
881 memcpy(saddr
, &qaddr
, sizeof(qaddr
));
886 static int qrtr_ioctl(struct socket
*sock
, unsigned int cmd
, unsigned long arg
)
888 void __user
*argp
= (void __user
*)arg
;
889 struct qrtr_sock
*ipc
= qrtr_sk(sock
->sk
);
890 struct sock
*sk
= sock
->sk
;
891 struct sockaddr_qrtr
*sq
;
901 len
= sk
->sk_sndbuf
- sk_wmem_alloc_get(sk
);
904 rc
= put_user(len
, (int __user
*)argp
);
907 skb
= skb_peek(&sk
->sk_receive_queue
);
909 len
= skb
->len
- QRTR_HDR_SIZE
;
910 rc
= put_user(len
, (int __user
*)argp
);
913 if (copy_from_user(&ifr
, argp
, sizeof(ifr
))) {
918 sq
= (struct sockaddr_qrtr
*)&ifr
.ifr_addr
;
920 if (copy_to_user(argp
, &ifr
, sizeof(ifr
))) {
926 rc
= sock_get_timestamp(sk
, argp
);
949 static int qrtr_release(struct socket
*sock
)
951 struct sock
*sk
= sock
->sk
;
952 struct qrtr_sock
*ipc
;
960 sk
->sk_shutdown
= SHUTDOWN_MASK
;
961 if (!sock_flag(sk
, SOCK_DEAD
))
962 sk
->sk_state_change(sk
);
964 sock_set_flag(sk
, SOCK_DEAD
);
967 if (!sock_flag(sk
, SOCK_ZAPPED
))
968 qrtr_port_remove(ipc
);
970 skb_queue_purge(&sk
->sk_receive_queue
);
978 static const struct proto_ops qrtr_proto_ops
= {
979 .owner
= THIS_MODULE
,
980 .family
= AF_QIPCRTR
,
982 .connect
= qrtr_connect
,
983 .socketpair
= sock_no_socketpair
,
984 .accept
= sock_no_accept
,
985 .listen
= sock_no_listen
,
986 .sendmsg
= qrtr_sendmsg
,
987 .recvmsg
= qrtr_recvmsg
,
988 .getname
= qrtr_getname
,
990 .poll
= datagram_poll
,
991 .shutdown
= sock_no_shutdown
,
992 .setsockopt
= sock_no_setsockopt
,
993 .getsockopt
= sock_no_getsockopt
,
994 .release
= qrtr_release
,
995 .mmap
= sock_no_mmap
,
996 .sendpage
= sock_no_sendpage
,
999 static struct proto qrtr_proto
= {
1001 .owner
= THIS_MODULE
,
1002 .obj_size
= sizeof(struct qrtr_sock
),
1005 static int qrtr_create(struct net
*net
, struct socket
*sock
,
1006 int protocol
, int kern
)
1008 struct qrtr_sock
*ipc
;
1011 if (sock
->type
!= SOCK_DGRAM
)
1014 sk
= sk_alloc(net
, AF_QIPCRTR
, GFP_KERNEL
, &qrtr_proto
, kern
);
1018 sock_set_flag(sk
, SOCK_ZAPPED
);
1020 sock_init_data(sock
, sk
);
1021 sock
->ops
= &qrtr_proto_ops
;
1024 ipc
->us
.sq_family
= AF_QIPCRTR
;
1025 ipc
->us
.sq_node
= qrtr_local_nid
;
1026 ipc
->us
.sq_port
= 0;
1031 static const struct nla_policy qrtr_policy
[IFA_MAX
+ 1] = {
1032 [IFA_LOCAL
] = { .type
= NLA_U32
},
1035 static int qrtr_addr_doit(struct sk_buff
*skb
, struct nlmsghdr
*nlh
,
1036 struct netlink_ext_ack
*extack
)
1038 struct nlattr
*tb
[IFA_MAX
+ 1];
1039 struct ifaddrmsg
*ifm
;
1042 if (!netlink_capable(skb
, CAP_NET_ADMIN
))
1045 if (!netlink_capable(skb
, CAP_SYS_ADMIN
))
1050 rc
= nlmsg_parse(nlh
, sizeof(*ifm
), tb
, IFA_MAX
, qrtr_policy
, extack
);
1054 ifm
= nlmsg_data(nlh
);
1058 qrtr_local_nid
= nla_get_u32(tb
[IFA_LOCAL
]);
1062 static const struct net_proto_family qrtr_family
= {
1063 .owner
= THIS_MODULE
,
1064 .family
= AF_QIPCRTR
,
1065 .create
= qrtr_create
,
1068 static int __init
qrtr_proto_init(void)
1072 rc
= proto_register(&qrtr_proto
, 1);
1076 rc
= sock_register(&qrtr_family
);
1078 proto_unregister(&qrtr_proto
);
1082 rtnl_register(PF_QIPCRTR
, RTM_NEWADDR
, qrtr_addr_doit
, NULL
, 0);
1086 module_init(qrtr_proto_init
);
1088 static void __exit
qrtr_proto_fini(void)
1090 rtnl_unregister(PF_QIPCRTR
, RTM_NEWADDR
);
1091 sock_unregister(qrtr_family
.family
);
1092 proto_unregister(&qrtr_proto
);
1094 module_exit(qrtr_proto_fini
);
1096 MODULE_DESCRIPTION("Qualcomm IPC-router driver");
1097 MODULE_LICENSE("GPL v2");