[CONNECTOR]: fix sparse gfp nocast warnings
[linux-2.6.git] / drivers / connector / connector.c
1 /*
2  *      connector.c
3  * 
4  * 2004-2005 Copyright (c) Evgeniy Polyakov <johnpol@2ka.mipt.ru>
5  * All rights reserved.
6  * 
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.
11  *
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.
16  *
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
20  */
21
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>
29
30 #include <net/sock.h>
31
32 MODULE_LICENSE("GPL");
33 MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
34 MODULE_DESCRIPTION("Generic userspace <-> kernelspace connector.");
35
36 static u32 cn_idx = CN_IDX_CONNECTOR;
37 static u32 cn_val = CN_VAL_CONNECTOR;
38
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.");
43
44 static DECLARE_MUTEX(notify_lock);
45 static LIST_HEAD(notify_list);
46
47 static struct cn_dev cdev;
48
49 int cn_already_initialized = 0;
50
51 /*
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.
56  *
57  * Sequence number is incremented with each message to be sent.
58  *
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.
62  *
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.
65  *
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
69  * a new message.
70  *
71  */
72 int cn_netlink_send(struct cn_msg *msg, u32 __group,
73                     unsigned int __nocast gfp_mask)
74 {
75         struct cn_callback_entry *__cbq;
76         unsigned int size;
77         struct sk_buff *skb;
78         struct nlmsghdr *nlh;
79         struct cn_msg *data;
80         struct cn_dev *dev = &cdev;
81         u32 group = 0;
82         int found = 0;
83
84         if (!__group) {
85                 spin_lock_bh(&dev->cbdev->queue_lock);
86                 list_for_each_entry(__cbq, &dev->cbdev->queue_list,
87                                     callback_entry) {
88                         if (cn_cb_equal(&__cbq->id.id, &msg->id)) {
89                                 found = 1;
90                                 group = __cbq->group;
91                         }
92                 }
93                 spin_unlock_bh(&dev->cbdev->queue_lock);
94
95                 if (!found)
96                         return -ENODEV;
97         } else {
98                 group = __group;
99         }
100
101         size = NLMSG_SPACE(sizeof(*msg) + msg->len);
102
103         skb = alloc_skb(size, gfp_mask);
104         if (!skb)
105                 return -ENOMEM;
106
107         nlh = NLMSG_PUT(skb, 0, msg->seq, NLMSG_DONE, size - sizeof(*nlh));
108
109         data = NLMSG_DATA(nlh);
110
111         memcpy(data, msg, sizeof(*data) + msg->len);
112
113         NETLINK_CB(skb).dst_group = group;
114
115         netlink_broadcast(dev->nls, skb, 0, group, gfp_mask);
116
117         return 0;
118
119 nlmsg_failure:
120         kfree_skb(skb);
121         return -EINVAL;
122 }
123
124 /*
125  * Callback helper - queues work and setup destructor for given data.
126  */
127 static int cn_call_callback(struct cn_msg *msg, void (*destruct_data)(void *), void *data)
128 {
129         struct cn_callback_entry *__cbq;
130         struct cn_dev *dev = &cdev;
131         int err = -ENODEV;
132
133         spin_lock_bh(&dev->cbdev->queue_lock);
134         list_for_each_entry(__cbq, &dev->cbdev->queue_list, callback_entry) {
135                 if (cn_cb_equal(&__cbq->id.id, &msg->id)) {
136                         if (likely(!test_bit(0, &__cbq->work.pending) &&
137                                         __cbq->data.ddata == NULL)) {
138                                 __cbq->data.callback_priv = msg;
139
140                                 __cbq->data.ddata = data;
141                                 __cbq->data.destruct_data = destruct_data;
142
143                                 if (queue_work(dev->cbdev->cn_queue,
144                                                 &__cbq->work))
145                                         err = 0;
146                         } else {
147                                 struct work_struct *w;
148                                 struct cn_callback_data *d;
149                                 
150                                 w = kzalloc(sizeof(*w) + sizeof(*d), GFP_ATOMIC);
151                                 if (w) {
152                                         d = (struct cn_callback_data *)(w+1);
153
154                                         d->callback_priv = msg;
155                                         d->callback = __cbq->data.callback;
156                                         d->ddata = data;
157                                         d->destruct_data = destruct_data;
158                                         d->free = w;
159
160                                         INIT_LIST_HEAD(&w->entry);
161                                         w->pending = 0;
162                                         w->func = &cn_queue_wrapper;
163                                         w->data = d;
164                                         init_timer(&w->timer);
165                                         
166                                         if (queue_work(dev->cbdev->cn_queue, w))
167                                                 err = 0;
168                                         else {
169                                                 kfree(w);
170                                                 err = -EINVAL;
171                                         }
172                                 } else
173                                         err = -ENOMEM;
174                         }
175                         break;
176                 }
177         }
178         spin_unlock_bh(&dev->cbdev->queue_lock);
179
180         return err;
181 }
182
183 /*
184  * Skb receive helper - checks skb and msg size and calls callback
185  * helper.
186  */
187 static int __cn_rx_skb(struct sk_buff *skb, struct nlmsghdr *nlh)
188 {
189         u32 pid, uid, seq, group;
190         struct cn_msg *msg;
191
192         pid = NETLINK_CREDS(skb)->pid;
193         uid = NETLINK_CREDS(skb)->uid;
194         seq = nlh->nlmsg_seq;
195         group = NETLINK_CB((skb)).dst_group;
196         msg = NLMSG_DATA(nlh);
197
198         return cn_call_callback(msg, (void (*)(void *))kfree_skb, skb);
199 }
200
201 /*
202  * Main netlink receiving function.
203  *
204  * It checks skb and netlink header sizes and calls the skb receive
205  * helper with a shared skb.
206  */
207 static void cn_rx_skb(struct sk_buff *__skb)
208 {
209         struct nlmsghdr *nlh;
210         u32 len;
211         int err;
212         struct sk_buff *skb;
213
214         skb = skb_get(__skb);
215
216         if (skb->len >= NLMSG_SPACE(0)) {
217                 nlh = (struct nlmsghdr *)skb->data;
218
219                 if (nlh->nlmsg_len < sizeof(struct cn_msg) ||
220                     skb->len < nlh->nlmsg_len ||
221                     nlh->nlmsg_len > CONNECTOR_MAX_MSG_SIZE) {
222                         kfree_skb(skb);
223                         goto out;
224                 }
225
226                 len = NLMSG_ALIGN(nlh->nlmsg_len);
227                 if (len > skb->len)
228                         len = skb->len;
229
230                 err = __cn_rx_skb(skb, nlh);
231                 if (err < 0)
232                         kfree_skb(skb);
233         }
234
235 out:
236         kfree_skb(__skb);
237 }
238
239 /*
240  * Netlink socket input callback - dequeues the skbs and calls the
241  * main netlink receiving function.
242  */
243 static void cn_input(struct sock *sk, int len)
244 {
245         struct sk_buff *skb;
246
247         while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL)
248                 cn_rx_skb(skb);
249 }
250
251 /*
252  * Notification routing.
253  *
254  * Gets id and checks if there are notification request for it's idx
255  * and val.  If there are such requests notify the listeners with the
256  * given notify event.
257  *
258  */
259 static void cn_notify(struct cb_id *id, u32 notify_event)
260 {
261         struct cn_ctl_entry *ent;
262
263         down(&notify_lock);
264         list_for_each_entry(ent, &notify_list, notify_entry) {
265                 int i;
266                 struct cn_notify_req *req;
267                 struct cn_ctl_msg *ctl = ent->msg;
268                 int idx_found, val_found;
269
270                 idx_found = val_found = 0;
271
272                 req = (struct cn_notify_req *)ctl->data;
273                 for (i = 0; i < ctl->idx_notify_num; ++i, ++req) {
274                         if (id->idx >= req->first && 
275                                         id->idx < req->first + req->range) {
276                                 idx_found = 1;
277                                 break;
278                         }
279                 }
280
281                 for (i = 0; i < ctl->val_notify_num; ++i, ++req) {
282                         if (id->val >= req->first && 
283                                         id->val < req->first + req->range) {
284                                 val_found = 1;
285                                 break;
286                         }
287                 }
288
289                 if (idx_found && val_found) {
290                         struct cn_msg m = { .ack = notify_event, };
291
292                         memcpy(&m.id, id, sizeof(m.id));
293                         cn_netlink_send(&m, ctl->group, GFP_KERNEL);
294                 }
295         }
296         up(&notify_lock);
297 }
298
299 /*
300  * Callback add routing - adds callback with given ID and name.
301  * If there is registered callback with the same ID it will not be added.
302  *
303  * May sleep.
304  */
305 int cn_add_callback(struct cb_id *id, char *name, void (*callback)(void *))
306 {
307         int err;
308         struct cn_dev *dev = &cdev;
309
310         err = cn_queue_add_callback(dev->cbdev, name, id, callback);
311         if (err)
312                 return err;
313
314         cn_notify(id, 0);
315
316         return 0;
317 }
318
319 /*
320  * Callback remove routing - removes callback
321  * with given ID.
322  * If there is no registered callback with given
323  * ID nothing happens.
324  *
325  * May sleep while waiting for reference counter to become zero.
326  */
327 void cn_del_callback(struct cb_id *id)
328 {
329         struct cn_dev *dev = &cdev;
330
331         cn_queue_del_callback(dev->cbdev, id);
332         cn_notify(id, 1);
333 }
334
335 /*
336  * Checks two connector's control messages to be the same.
337  * Returns 1 if they are the same or if the first one is corrupted.
338  */
339 static int cn_ctl_msg_equals(struct cn_ctl_msg *m1, struct cn_ctl_msg *m2)
340 {
341         int i;
342         struct cn_notify_req *req1, *req2;
343
344         if (m1->idx_notify_num != m2->idx_notify_num)
345                 return 0;
346
347         if (m1->val_notify_num != m2->val_notify_num)
348                 return 0;
349
350         if (m1->len != m2->len)
351                 return 0;
352
353         if ((m1->idx_notify_num + m1->val_notify_num) * sizeof(*req1) !=
354             m1->len)
355                 return 1;
356
357         req1 = (struct cn_notify_req *)m1->data;
358         req2 = (struct cn_notify_req *)m2->data;
359
360         for (i = 0; i < m1->idx_notify_num; ++i) {
361                 if (req1->first != req2->first || req1->range != req2->range)
362                         return 0;
363                 req1++;
364                 req2++;
365         }
366
367         for (i = 0; i < m1->val_notify_num; ++i) {
368                 if (req1->first != req2->first || req1->range != req2->range)
369                         return 0;
370                 req1++;
371                 req2++;
372         }
373
374         return 1;
375 }
376
377 /*
378  * Main connector device's callback.
379  *
380  * Used for notification of a request's processing.
381  */
382 static void cn_callback(void *data)
383 {
384         struct cn_msg *msg = data;
385         struct cn_ctl_msg *ctl;
386         struct cn_ctl_entry *ent;
387         u32 size;
388
389         if (msg->len < sizeof(*ctl))
390                 return;
391
392         ctl = (struct cn_ctl_msg *)msg->data;
393
394         size = (sizeof(*ctl) + ((ctl->idx_notify_num +
395                                  ctl->val_notify_num) *
396                                 sizeof(struct cn_notify_req)));
397
398         if (msg->len != size)
399                 return;
400
401         if (ctl->len + sizeof(*ctl) != msg->len)
402                 return;
403
404         /*
405          * Remove notification.
406          */
407         if (ctl->group == 0) {
408                 struct cn_ctl_entry *n;
409
410                 down(&notify_lock);
411                 list_for_each_entry_safe(ent, n, &notify_list, notify_entry) {
412                         if (cn_ctl_msg_equals(ent->msg, ctl)) {
413                                 list_del(&ent->notify_entry);
414                                 kfree(ent);
415                         }
416                 }
417                 up(&notify_lock);
418
419                 return;
420         }
421
422         size += sizeof(*ent);
423
424         ent = kzalloc(size, GFP_KERNEL);
425         if (!ent)
426                 return;
427
428         ent->msg = (struct cn_ctl_msg *)(ent + 1);
429
430         memcpy(ent->msg, ctl, size - sizeof(*ent));
431
432         down(&notify_lock);
433         list_add(&ent->notify_entry, &notify_list);
434         up(&notify_lock);
435 }
436
437 static int __init cn_init(void)
438 {
439         struct cn_dev *dev = &cdev;
440         int err;
441
442         dev->input = cn_input;
443         dev->id.idx = cn_idx;
444         dev->id.val = cn_val;
445
446         dev->nls = netlink_kernel_create(NETLINK_CONNECTOR,
447                                          CN_NETLINK_USERS + 0xf,
448                                          dev->input, THIS_MODULE);
449         if (!dev->nls)
450                 return -EIO;
451
452         dev->cbdev = cn_queue_alloc_dev("cqueue", dev->nls);
453         if (!dev->cbdev) {
454                 if (dev->nls->sk_socket)
455                         sock_release(dev->nls->sk_socket);
456                 return -EINVAL;
457         }
458
459         err = cn_add_callback(&dev->id, "connector", &cn_callback);
460         if (err) {
461                 cn_queue_free_dev(dev->cbdev);
462                 if (dev->nls->sk_socket)
463                         sock_release(dev->nls->sk_socket);
464                 return -EINVAL;
465         }
466
467         cn_already_initialized = 1;
468
469         return 0;
470 }
471
472 static void __exit cn_fini(void)
473 {
474         struct cn_dev *dev = &cdev;
475
476         cn_already_initialized = 0;
477
478         cn_del_callback(&dev->id);
479         cn_queue_free_dev(dev->cbdev);
480         if (dev->nls->sk_socket)
481                 sock_release(dev->nls->sk_socket);
482 }
483
484 module_init(cn_init);
485 module_exit(cn_fini);
486
487 EXPORT_SYMBOL_GPL(cn_add_callback);
488 EXPORT_SYMBOL_GPL(cn_del_callback);
489 EXPORT_SYMBOL_GPL(cn_netlink_send);