4 * 2004-2005 Copyright (c) Evgeniy Polyakov <johnpol@2ka.mipt.ru>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include <linux/kernel.h>
23 #include <linux/module.h>
24 #include <linux/list.h>
25 #include <linux/skbuff.h>
26 #include <linux/netlink.h>
27 #include <linux/moduleparam.h>
28 #include <linux/connector.h>
32 MODULE_LICENSE("GPL");
33 MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
34 MODULE_DESCRIPTION("Generic userspace <-> kernelspace connector.");
36 static u32 cn_idx
= CN_IDX_CONNECTOR
;
37 static u32 cn_val
= CN_VAL_CONNECTOR
;
39 module_param(cn_idx
, uint
, 0);
40 module_param(cn_val
, uint
, 0);
41 MODULE_PARM_DESC(cn_idx
, "Connector's main device idx.");
42 MODULE_PARM_DESC(cn_val
, "Connector's main device val.");
44 static DECLARE_MUTEX(notify_lock
);
45 static LIST_HEAD(notify_list
);
47 static struct cn_dev cdev
;
49 int cn_already_initialized
= 0;
52 * msg->seq and msg->ack are used to determine message genealogy.
53 * When someone sends message it puts there locally unique sequence
54 * and random acknowledge numbers. Sequence number may be copied into
55 * nlmsghdr->nlmsg_seq too.
57 * Sequence number is incremented with each message to be sent.
59 * If we expect reply to our message then the sequence number in
60 * received message MUST be the same as in original message, and
61 * acknowledge number MUST be the same + 1.
63 * If we receive a message and its sequence number is not equal to the
64 * one we are expecting then it is a new message.
66 * If we receive a message and its sequence number is the same as one
67 * we are expecting but it's acknowledgement number is not equal to
68 * the acknowledgement number in the original message + 1, then it is
72 int cn_netlink_send(struct cn_msg
*msg
, u32 __group
, int gfp_mask
)
74 struct cn_callback_entry
*__cbq
;
79 struct cn_dev
*dev
= &cdev
;
84 spin_lock_bh(&dev
->cbdev
->queue_lock
);
85 list_for_each_entry(__cbq
, &dev
->cbdev
->queue_list
,
87 if (cn_cb_equal(&__cbq
->cb
->id
, &msg
->id
)) {
92 spin_unlock_bh(&dev
->cbdev
->queue_lock
);
100 size
= NLMSG_SPACE(sizeof(*msg
) + msg
->len
);
102 skb
= alloc_skb(size
, gfp_mask
);
106 nlh
= NLMSG_PUT(skb
, 0, msg
->seq
, NLMSG_DONE
, size
- sizeof(*nlh
));
108 data
= NLMSG_DATA(nlh
);
110 memcpy(data
, msg
, sizeof(*data
) + msg
->len
);
112 NETLINK_CB(skb
).dst_group
= group
;
114 netlink_broadcast(dev
->nls
, skb
, 0, group
, gfp_mask
);
124 * Callback helper - queues work and setup destructor for given data.
126 static int cn_call_callback(struct cn_msg
*msg
, void (*destruct_data
)(void *), void *data
)
128 struct cn_callback_entry
*__cbq
;
129 struct cn_dev
*dev
= &cdev
;
132 spin_lock_bh(&dev
->cbdev
->queue_lock
);
133 list_for_each_entry(__cbq
, &dev
->cbdev
->queue_list
, callback_entry
) {
134 if (cn_cb_equal(&__cbq
->cb
->id
, &msg
->id
)) {
136 * Let's scream if there is some magic and the
137 * data will arrive asynchronously here.
138 * [i.e. netlink messages will be queued].
139 * After the first warning I will fix it
140 * quickly, but now I think it is
141 * impossible. --zbr (2004_04_27).
143 if (likely(!test_bit(0, &__cbq
->work
.pending
) &&
144 __cbq
->ddata
== NULL
)) {
145 __cbq
->cb
->priv
= msg
;
148 __cbq
->destruct_data
= destruct_data
;
150 if (queue_work(dev
->cbdev
->cn_queue
,
154 printk("%s: cbq->data=%p, "
155 "work->pending=%08lx.\n",
156 __func__
, __cbq
->ddata
,
157 __cbq
->work
.pending
);
163 spin_unlock_bh(&dev
->cbdev
->queue_lock
);
165 return found
? 0 : -ENODEV
;
169 * Skb receive helper - checks skb and msg size and calls callback
172 static int __cn_rx_skb(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
174 u32 pid
, uid
, seq
, group
;
177 pid
= NETLINK_CREDS(skb
)->pid
;
178 uid
= NETLINK_CREDS(skb
)->uid
;
179 seq
= nlh
->nlmsg_seq
;
180 group
= NETLINK_CB((skb
)).dst_group
;
181 msg
= NLMSG_DATA(nlh
);
183 return cn_call_callback(msg
, (void (*)(void *))kfree_skb
, skb
);
187 * Main netlink receiving function.
189 * It checks skb and netlink header sizes and calls the skb receive
190 * helper with a shared skb.
192 static void cn_rx_skb(struct sk_buff
*__skb
)
194 struct nlmsghdr
*nlh
;
199 skb
= skb_get(__skb
);
201 if (skb
->len
>= NLMSG_SPACE(0)) {
202 nlh
= (struct nlmsghdr
*)skb
->data
;
204 if (nlh
->nlmsg_len
< sizeof(struct cn_msg
) ||
205 skb
->len
< nlh
->nlmsg_len
||
206 nlh
->nlmsg_len
> CONNECTOR_MAX_MSG_SIZE
) {
211 len
= NLMSG_ALIGN(nlh
->nlmsg_len
);
215 err
= __cn_rx_skb(skb
, nlh
);
225 * Netlink socket input callback - dequeues the skbs and calls the
226 * main netlink receiving function.
228 static void cn_input(struct sock
*sk
, int len
)
232 while ((skb
= skb_dequeue(&sk
->sk_receive_queue
)) != NULL
)
237 * Notification routing.
239 * Gets id and checks if there are notification request for it's idx
240 * and val. If there are such requests notify the listeners with the
241 * given notify event.
244 static void cn_notify(struct cb_id
*id
, u32 notify_event
)
246 struct cn_ctl_entry
*ent
;
249 list_for_each_entry(ent
, ¬ify_list
, notify_entry
) {
251 struct cn_notify_req
*req
;
252 struct cn_ctl_msg
*ctl
= ent
->msg
;
253 int idx_found
, val_found
;
255 idx_found
= val_found
= 0;
257 req
= (struct cn_notify_req
*)ctl
->data
;
258 for (i
= 0; i
< ctl
->idx_notify_num
; ++i
, ++req
) {
259 if (id
->idx
>= req
->first
&&
260 id
->idx
< req
->first
+ req
->range
) {
266 for (i
= 0; i
< ctl
->val_notify_num
; ++i
, ++req
) {
267 if (id
->val
>= req
->first
&&
268 id
->val
< req
->first
+ req
->range
) {
274 if (idx_found
&& val_found
) {
275 struct cn_msg m
= { .ack
= notify_event
, };
277 memcpy(&m
.id
, id
, sizeof(m
.id
));
278 cn_netlink_send(&m
, ctl
->group
, GFP_KERNEL
);
285 * Callback add routing - adds callback with given ID and name.
286 * If there is registered callback with the same ID it will not be added.
290 int cn_add_callback(struct cb_id
*id
, char *name
, void (*callback
)(void *))
293 struct cn_dev
*dev
= &cdev
;
294 struct cn_callback
*cb
;
296 cb
= kzalloc(sizeof(*cb
), GFP_KERNEL
);
300 scnprintf(cb
->name
, sizeof(cb
->name
), "%s", name
);
302 memcpy(&cb
->id
, id
, sizeof(cb
->id
));
303 cb
->callback
= callback
;
305 err
= cn_queue_add_callback(dev
->cbdev
, cb
);
317 * Callback remove routing - removes callback
319 * If there is no registered callback with given
320 * ID nothing happens.
322 * May sleep while waiting for reference counter to become zero.
324 void cn_del_callback(struct cb_id
*id
)
326 struct cn_dev
*dev
= &cdev
;
328 cn_queue_del_callback(dev
->cbdev
, id
);
333 * Checks two connector's control messages to be the same.
334 * Returns 1 if they are the same or if the first one is corrupted.
336 static int cn_ctl_msg_equals(struct cn_ctl_msg
*m1
, struct cn_ctl_msg
*m2
)
339 struct cn_notify_req
*req1
, *req2
;
341 if (m1
->idx_notify_num
!= m2
->idx_notify_num
)
344 if (m1
->val_notify_num
!= m2
->val_notify_num
)
347 if (m1
->len
!= m2
->len
)
350 if ((m1
->idx_notify_num
+ m1
->val_notify_num
) * sizeof(*req1
) !=
354 req1
= (struct cn_notify_req
*)m1
->data
;
355 req2
= (struct cn_notify_req
*)m2
->data
;
357 for (i
= 0; i
< m1
->idx_notify_num
; ++i
) {
358 if (req1
->first
!= req2
->first
|| req1
->range
!= req2
->range
)
364 for (i
= 0; i
< m1
->val_notify_num
; ++i
) {
365 if (req1
->first
!= req2
->first
|| req1
->range
!= req2
->range
)
375 * Main connector device's callback.
377 * Used for notification of a request's processing.
379 static void cn_callback(void *data
)
381 struct cn_msg
*msg
= data
;
382 struct cn_ctl_msg
*ctl
;
383 struct cn_ctl_entry
*ent
;
386 if (msg
->len
< sizeof(*ctl
))
389 ctl
= (struct cn_ctl_msg
*)msg
->data
;
391 size
= (sizeof(*ctl
) + ((ctl
->idx_notify_num
+
392 ctl
->val_notify_num
) *
393 sizeof(struct cn_notify_req
)));
395 if (msg
->len
!= size
)
398 if (ctl
->len
+ sizeof(*ctl
) != msg
->len
)
402 * Remove notification.
404 if (ctl
->group
== 0) {
405 struct cn_ctl_entry
*n
;
408 list_for_each_entry_safe(ent
, n
, ¬ify_list
, notify_entry
) {
409 if (cn_ctl_msg_equals(ent
->msg
, ctl
)) {
410 list_del(&ent
->notify_entry
);
419 size
+= sizeof(*ent
);
421 ent
= kzalloc(size
, GFP_KERNEL
);
425 ent
->msg
= (struct cn_ctl_msg
*)(ent
+ 1);
427 memcpy(ent
->msg
, ctl
, size
- sizeof(*ent
));
430 list_add(&ent
->notify_entry
, ¬ify_list
);
434 static int __init
cn_init(void)
436 struct cn_dev
*dev
= &cdev
;
439 dev
->input
= cn_input
;
440 dev
->id
.idx
= cn_idx
;
441 dev
->id
.val
= cn_val
;
443 dev
->nls
= netlink_kernel_create(NETLINK_CONNECTOR
,
444 CN_NETLINK_USERS
+ 0xf,
445 dev
->input
, THIS_MODULE
);
449 dev
->cbdev
= cn_queue_alloc_dev("cqueue", dev
->nls
);
451 if (dev
->nls
->sk_socket
)
452 sock_release(dev
->nls
->sk_socket
);
456 err
= cn_add_callback(&dev
->id
, "connector", &cn_callback
);
458 cn_queue_free_dev(dev
->cbdev
);
459 if (dev
->nls
->sk_socket
)
460 sock_release(dev
->nls
->sk_socket
);
464 cn_already_initialized
= 1;
469 static void __exit
cn_fini(void)
471 struct cn_dev
*dev
= &cdev
;
473 cn_already_initialized
= 0;
475 cn_del_callback(&dev
->id
);
476 cn_queue_free_dev(dev
->cbdev
);
477 if (dev
->nls
->sk_socket
)
478 sock_release(dev
->nls
->sk_socket
);
481 module_init(cn_init
);
482 module_exit(cn_fini
);
484 EXPORT_SYMBOL_GPL(cn_add_callback
);
485 EXPORT_SYMBOL_GPL(cn_del_callback
);
486 EXPORT_SYMBOL_GPL(cn_netlink_send
);