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
->id
.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
->id
.id
, &msg
->id
)) {
135 if (likely(!test_bit(0, &__cbq
->work
.pending
) &&
136 __cbq
->data
.ddata
== NULL
)) {
137 __cbq
->data
.callback_priv
= msg
;
139 __cbq
->data
.ddata
= data
;
140 __cbq
->data
.destruct_data
= destruct_data
;
142 if (queue_work(dev
->cbdev
->cn_queue
,
146 struct work_struct
*w
;
147 struct cn_callback_data
*d
;
149 w
= kzalloc(sizeof(*w
) + sizeof(*d
), GFP_ATOMIC
);
151 d
= (struct cn_callback_data
*)(w
+1);
153 d
->callback_priv
= msg
;
154 d
->callback
= __cbq
->data
.callback
;
156 d
->destruct_data
= destruct_data
;
159 INIT_LIST_HEAD(&w
->entry
);
161 w
->func
= &cn_queue_wrapper
;
163 init_timer(&w
->timer
);
165 if (queue_work(dev
->cbdev
->cn_queue
, w
))
177 spin_unlock_bh(&dev
->cbdev
->queue_lock
);
183 * Skb receive helper - checks skb and msg size and calls callback
186 static int __cn_rx_skb(struct sk_buff
*skb
, struct nlmsghdr
*nlh
)
188 u32 pid
, uid
, seq
, group
;
191 pid
= NETLINK_CREDS(skb
)->pid
;
192 uid
= NETLINK_CREDS(skb
)->uid
;
193 seq
= nlh
->nlmsg_seq
;
194 group
= NETLINK_CB((skb
)).dst_group
;
195 msg
= NLMSG_DATA(nlh
);
197 return cn_call_callback(msg
, (void (*)(void *))kfree_skb
, skb
);
201 * Main netlink receiving function.
203 * It checks skb and netlink header sizes and calls the skb receive
204 * helper with a shared skb.
206 static void cn_rx_skb(struct sk_buff
*__skb
)
208 struct nlmsghdr
*nlh
;
213 skb
= skb_get(__skb
);
215 if (skb
->len
>= NLMSG_SPACE(0)) {
216 nlh
= (struct nlmsghdr
*)skb
->data
;
218 if (nlh
->nlmsg_len
< sizeof(struct cn_msg
) ||
219 skb
->len
< nlh
->nlmsg_len
||
220 nlh
->nlmsg_len
> CONNECTOR_MAX_MSG_SIZE
) {
225 len
= NLMSG_ALIGN(nlh
->nlmsg_len
);
229 err
= __cn_rx_skb(skb
, nlh
);
239 * Netlink socket input callback - dequeues the skbs and calls the
240 * main netlink receiving function.
242 static void cn_input(struct sock
*sk
, int len
)
246 while ((skb
= skb_dequeue(&sk
->sk_receive_queue
)) != NULL
)
251 * Notification routing.
253 * Gets id and checks if there are notification request for it's idx
254 * and val. If there are such requests notify the listeners with the
255 * given notify event.
258 static void cn_notify(struct cb_id
*id
, u32 notify_event
)
260 struct cn_ctl_entry
*ent
;
263 list_for_each_entry(ent
, ¬ify_list
, notify_entry
) {
265 struct cn_notify_req
*req
;
266 struct cn_ctl_msg
*ctl
= ent
->msg
;
267 int idx_found
, val_found
;
269 idx_found
= val_found
= 0;
271 req
= (struct cn_notify_req
*)ctl
->data
;
272 for (i
= 0; i
< ctl
->idx_notify_num
; ++i
, ++req
) {
273 if (id
->idx
>= req
->first
&&
274 id
->idx
< req
->first
+ req
->range
) {
280 for (i
= 0; i
< ctl
->val_notify_num
; ++i
, ++req
) {
281 if (id
->val
>= req
->first
&&
282 id
->val
< req
->first
+ req
->range
) {
288 if (idx_found
&& val_found
) {
289 struct cn_msg m
= { .ack
= notify_event
, };
291 memcpy(&m
.id
, id
, sizeof(m
.id
));
292 cn_netlink_send(&m
, ctl
->group
, GFP_KERNEL
);
299 * Callback add routing - adds callback with given ID and name.
300 * If there is registered callback with the same ID it will not be added.
304 int cn_add_callback(struct cb_id
*id
, char *name
, void (*callback
)(void *))
307 struct cn_dev
*dev
= &cdev
;
309 err
= cn_queue_add_callback(dev
->cbdev
, name
, id
, callback
);
319 * Callback remove routing - removes callback
321 * If there is no registered callback with given
322 * ID nothing happens.
324 * May sleep while waiting for reference counter to become zero.
326 void cn_del_callback(struct cb_id
*id
)
328 struct cn_dev
*dev
= &cdev
;
330 cn_queue_del_callback(dev
->cbdev
, id
);
335 * Checks two connector's control messages to be the same.
336 * Returns 1 if they are the same or if the first one is corrupted.
338 static int cn_ctl_msg_equals(struct cn_ctl_msg
*m1
, struct cn_ctl_msg
*m2
)
341 struct cn_notify_req
*req1
, *req2
;
343 if (m1
->idx_notify_num
!= m2
->idx_notify_num
)
346 if (m1
->val_notify_num
!= m2
->val_notify_num
)
349 if (m1
->len
!= m2
->len
)
352 if ((m1
->idx_notify_num
+ m1
->val_notify_num
) * sizeof(*req1
) !=
356 req1
= (struct cn_notify_req
*)m1
->data
;
357 req2
= (struct cn_notify_req
*)m2
->data
;
359 for (i
= 0; i
< m1
->idx_notify_num
; ++i
) {
360 if (req1
->first
!= req2
->first
|| req1
->range
!= req2
->range
)
366 for (i
= 0; i
< m1
->val_notify_num
; ++i
) {
367 if (req1
->first
!= req2
->first
|| req1
->range
!= req2
->range
)
377 * Main connector device's callback.
379 * Used for notification of a request's processing.
381 static void cn_callback(void *data
)
383 struct cn_msg
*msg
= data
;
384 struct cn_ctl_msg
*ctl
;
385 struct cn_ctl_entry
*ent
;
388 if (msg
->len
< sizeof(*ctl
))
391 ctl
= (struct cn_ctl_msg
*)msg
->data
;
393 size
= (sizeof(*ctl
) + ((ctl
->idx_notify_num
+
394 ctl
->val_notify_num
) *
395 sizeof(struct cn_notify_req
)));
397 if (msg
->len
!= size
)
400 if (ctl
->len
+ sizeof(*ctl
) != msg
->len
)
404 * Remove notification.
406 if (ctl
->group
== 0) {
407 struct cn_ctl_entry
*n
;
410 list_for_each_entry_safe(ent
, n
, ¬ify_list
, notify_entry
) {
411 if (cn_ctl_msg_equals(ent
->msg
, ctl
)) {
412 list_del(&ent
->notify_entry
);
421 size
+= sizeof(*ent
);
423 ent
= kzalloc(size
, GFP_KERNEL
);
427 ent
->msg
= (struct cn_ctl_msg
*)(ent
+ 1);
429 memcpy(ent
->msg
, ctl
, size
- sizeof(*ent
));
432 list_add(&ent
->notify_entry
, ¬ify_list
);
436 static int __init
cn_init(void)
438 struct cn_dev
*dev
= &cdev
;
441 dev
->input
= cn_input
;
442 dev
->id
.idx
= cn_idx
;
443 dev
->id
.val
= cn_val
;
445 dev
->nls
= netlink_kernel_create(NETLINK_CONNECTOR
,
446 CN_NETLINK_USERS
+ 0xf,
447 dev
->input
, THIS_MODULE
);
451 dev
->cbdev
= cn_queue_alloc_dev("cqueue", dev
->nls
);
453 if (dev
->nls
->sk_socket
)
454 sock_release(dev
->nls
->sk_socket
);
458 err
= cn_add_callback(&dev
->id
, "connector", &cn_callback
);
460 cn_queue_free_dev(dev
->cbdev
);
461 if (dev
->nls
->sk_socket
)
462 sock_release(dev
->nls
->sk_socket
);
466 cn_already_initialized
= 1;
471 static void __exit
cn_fini(void)
473 struct cn_dev
*dev
= &cdev
;
475 cn_already_initialized
= 0;
477 cn_del_callback(&dev
->id
);
478 cn_queue_free_dev(dev
->cbdev
);
479 if (dev
->nls
->sk_socket
)
480 sock_release(dev
->nls
->sk_socket
);
483 module_init(cn_init
);
484 module_exit(cn_fini
);
486 EXPORT_SYMBOL_GPL(cn_add_callback
);
487 EXPORT_SYMBOL_GPL(cn_del_callback
);
488 EXPORT_SYMBOL_GPL(cn_netlink_send
);