Doug / smarc-fsl-linux-kernel

Download as
Browse Code ยป

Commit 9631d79e815197dbe90080aedfbab6de41218d85

Authored by Hong zhi guo
Committed by David S. Miller
1 parent e07ebea0cc
Exists in smarc-l5.0.0_1.0.0-ga and in 5 other branches imx_3.10.17_1.0.1_ga, imx_3.10.53_1.1.0_ga, imx_3.14.28_1.0.0_ga, smarc-imx_3.10.53_1.1.0_ga, smarc-imx_3.14.28_1.0.0_ga

connector: replace obsolete NLMSG_* with type safe nlmsg_* 

Signed-off-by: Hong Zhiguo <honkiko@gmail.com>
Acked-by: Thomas Graf <tgraf@suug.ch>
Signed-off-by: David S. Miller <davem@davemloft.net>

Showing 1 changed file with 6 additions and 6 deletions Inline Diff

drivers/connector/connector.c
Diff comments   View file @ 9631d79
1 /* 1 /*
2 * connector.c 2 * connector.c
3 * 3 *
4 * 2004+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net> 4 * 2004+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
5 * All rights reserved. 5 * All rights reserved.
6 * 6 *
7 * This program is free software; you can redistribute it and/or modify 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 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 9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version. 10 * (at your option) any later version.
11 * 11 *
12 * This program is distributed in the hope that it will be useful, 12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details. 15 * GNU General Public License for more details.
16 * 16 *
17 * You should have received a copy of the GNU General Public License 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 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 19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */ 20 */
21 21
22 #include <linux/kernel.h> 22 #include <linux/kernel.h>
23 #include <linux/module.h> 23 #include <linux/module.h>
24 #include <linux/list.h> 24 #include <linux/list.h>
25 #include <linux/skbuff.h> 25 #include <linux/skbuff.h>
26 #include <linux/netlink.h> 26 #include <net/netlink.h>
27 #include <linux/moduleparam.h> 27 #include <linux/moduleparam.h>
28 #include <linux/connector.h> 28 #include <linux/connector.h>
29 #include <linux/slab.h> 29 #include <linux/slab.h>
30 #include <linux/mutex.h> 30 #include <linux/mutex.h>
31 #include <linux/proc_fs.h> 31 #include <linux/proc_fs.h>
32 #include <linux/spinlock.h> 32 #include <linux/spinlock.h>
33 33
34 #include <net/sock.h> 34 #include <net/sock.h>
35 35
36 MODULE_LICENSE("GPL"); 36 MODULE_LICENSE("GPL");
37 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>"); 37 MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
38 MODULE_DESCRIPTION("Generic userspace <-> kernelspace connector."); 38 MODULE_DESCRIPTION("Generic userspace <-> kernelspace connector.");
39 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_CONNECTOR); 39 MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_CONNECTOR);
40 40
41 static struct cn_dev cdev; 41 static struct cn_dev cdev;
42 42
43 static int cn_already_initialized; 43 static int cn_already_initialized;
44 44
45 /* 45 /*
46 * msg->seq and msg->ack are used to determine message genealogy. 46 * msg->seq and msg->ack are used to determine message genealogy.
47 * When someone sends message it puts there locally unique sequence 47 * When someone sends message it puts there locally unique sequence
48 * and random acknowledge numbers. Sequence number may be copied into 48 * and random acknowledge numbers. Sequence number may be copied into
49 * nlmsghdr->nlmsg_seq too. 49 * nlmsghdr->nlmsg_seq too.
50 * 50 *
51 * Sequence number is incremented with each message to be sent. 51 * Sequence number is incremented with each message to be sent.
52 * 52 *
53 * If we expect reply to our message then the sequence number in 53 * If we expect reply to our message then the sequence number in
54 * received message MUST be the same as in original message, and 54 * received message MUST be the same as in original message, and
55 * acknowledge number MUST be the same + 1. 55 * acknowledge number MUST be the same + 1.
56 * 56 *
57 * If we receive a message and its sequence number is not equal to the 57 * If we receive a message and its sequence number is not equal to the
58 * one we are expecting then it is a new message. 58 * one we are expecting then it is a new message.
59 * 59 *
60 * If we receive a message and its sequence number is the same as one 60 * If we receive a message and its sequence number is the same as one
61 * we are expecting but it's acknowledgement number is not equal to 61 * we are expecting but it's acknowledgement number is not equal to
62 * the acknowledgement number in the original message + 1, then it is 62 * the acknowledgement number in the original message + 1, then it is
63 * a new message. 63 * a new message.
64 * 64 *
65 */ 65 */
66 int cn_netlink_send(struct cn_msg *msg, u32 __group, gfp_t gfp_mask) 66 int cn_netlink_send(struct cn_msg *msg, u32 __group, gfp_t gfp_mask)
67 { 67 {
68 struct cn_callback_entry *__cbq; 68 struct cn_callback_entry *__cbq;
69 unsigned int size; 69 unsigned int size;
70 struct sk_buff *skb; 70 struct sk_buff *skb;
71 struct nlmsghdr *nlh; 71 struct nlmsghdr *nlh;
72 struct cn_msg *data; 72 struct cn_msg *data;
73 struct cn_dev *dev = &cdev; 73 struct cn_dev *dev = &cdev;
74 u32 group = 0; 74 u32 group = 0;
75 int found = 0; 75 int found = 0;
76 76
77 if (!__group) { 77 if (!__group) {
78 spin_lock_bh(&dev->cbdev->queue_lock); 78 spin_lock_bh(&dev->cbdev->queue_lock);
79 list_for_each_entry(__cbq, &dev->cbdev->queue_list, 79 list_for_each_entry(__cbq, &dev->cbdev->queue_list,
80 callback_entry) { 80 callback_entry) {
81 if (cn_cb_equal(&__cbq->id.id, &msg->id)) { 81 if (cn_cb_equal(&__cbq->id.id, &msg->id)) {
82 found = 1; 82 found = 1;
83 group = __cbq->group; 83 group = __cbq->group;
84 break; 84 break;
85 } 85 }
86 } 86 }
87 spin_unlock_bh(&dev->cbdev->queue_lock); 87 spin_unlock_bh(&dev->cbdev->queue_lock);
88 88
89 if (!found) 89 if (!found)
90 return -ENODEV; 90 return -ENODEV;
91 } else { 91 } else {
92 group = __group; 92 group = __group;
93 } 93 }
94 94
95 if (!netlink_has_listeners(dev->nls, group)) 95 if (!netlink_has_listeners(dev->nls, group))
96 return -ESRCH; 96 return -ESRCH;
97 97
98 size = NLMSG_SPACE(sizeof(*msg) + msg->len); 98 size = sizeof(*msg) + msg->len;
99 99
100 skb = alloc_skb(size, gfp_mask); 100 skb = nlmsg_new(size, gfp_mask);
101 if (!skb) 101 if (!skb)
102 return -ENOMEM; 102 return -ENOMEM;
103 103
104 nlh = nlmsg_put(skb, 0, msg->seq, NLMSG_DONE, size - sizeof(*nlh), 0); 104 nlh = nlmsg_put(skb, 0, msg->seq, NLMSG_DONE, size, 0);
105 if (!nlh) { 105 if (!nlh) {
106 kfree_skb(skb); 106 kfree_skb(skb);
107 return -EMSGSIZE; 107 return -EMSGSIZE;
108 } 108 }
109 109
110 data = nlmsg_data(nlh); 110 data = nlmsg_data(nlh);
111 111
112 memcpy(data, msg, sizeof(*data) + msg->len); 112 memcpy(data, msg, sizeof(*data) + msg->len);
113 113
114 NETLINK_CB(skb).dst_group = group; 114 NETLINK_CB(skb).dst_group = group;
115 115
116 return netlink_broadcast(dev->nls, skb, 0, group, gfp_mask); 116 return netlink_broadcast(dev->nls, skb, 0, group, gfp_mask);
117 } 117 }
118 EXPORT_SYMBOL_GPL(cn_netlink_send); 118 EXPORT_SYMBOL_GPL(cn_netlink_send);
119 119
120 /* 120 /*
121 * Callback helper - queues work and setup destructor for given data. 121 * Callback helper - queues work and setup destructor for given data.
122 */ 122 */
123 static int cn_call_callback(struct sk_buff *skb) 123 static int cn_call_callback(struct sk_buff *skb)
124 { 124 {
125 struct cn_callback_entry *i, *cbq = NULL; 125 struct cn_callback_entry *i, *cbq = NULL;
126 struct cn_dev *dev = &cdev; 126 struct cn_dev *dev = &cdev;
127 struct cn_msg *msg = NLMSG_DATA(nlmsg_hdr(skb)); 127 struct cn_msg *msg = nlmsg_data(nlmsg_hdr(skb));
128 struct netlink_skb_parms *nsp = &NETLINK_CB(skb); 128 struct netlink_skb_parms *nsp = &NETLINK_CB(skb);
129 int err = -ENODEV; 129 int err = -ENODEV;
130 130
131 spin_lock_bh(&dev->cbdev->queue_lock); 131 spin_lock_bh(&dev->cbdev->queue_lock);
132 list_for_each_entry(i, &dev->cbdev->queue_list, callback_entry) { 132 list_for_each_entry(i, &dev->cbdev->queue_list, callback_entry) {
133 if (cn_cb_equal(&i->id.id, &msg->id)) { 133 if (cn_cb_equal(&i->id.id, &msg->id)) {
134 atomic_inc(&i->refcnt); 134 atomic_inc(&i->refcnt);
135 cbq = i; 135 cbq = i;
136 break; 136 break;
137 } 137 }
138 } 138 }
139 spin_unlock_bh(&dev->cbdev->queue_lock); 139 spin_unlock_bh(&dev->cbdev->queue_lock);
140 140
141 if (cbq != NULL) { 141 if (cbq != NULL) {
142 err = 0; 142 err = 0;
143 cbq->callback(msg, nsp); 143 cbq->callback(msg, nsp);
144 kfree_skb(skb); 144 kfree_skb(skb);
145 cn_queue_release_callback(cbq); 145 cn_queue_release_callback(cbq);
146 err = 0; 146 err = 0;
147 } 147 }
148 148
149 return err; 149 return err;
150 } 150 }
151 151
152 /* 152 /*
153 * Main netlink receiving function. 153 * Main netlink receiving function.
154 * 154 *
155 * It checks skb, netlink header and msg sizes, and calls callback helper. 155 * It checks skb, netlink header and msg sizes, and calls callback helper.
156 */ 156 */
157 static void cn_rx_skb(struct sk_buff *__skb) 157 static void cn_rx_skb(struct sk_buff *__skb)
158 { 158 {
159 struct nlmsghdr *nlh; 159 struct nlmsghdr *nlh;
160 int err; 160 int err;
161 struct sk_buff *skb; 161 struct sk_buff *skb;
162 162
163 skb = skb_get(__skb); 163 skb = skb_get(__skb);
164 164
165 if (skb->len >= NLMSG_SPACE(0)) { 165 if (skb->len >= NLMSG_HDRLEN) {
166 nlh = nlmsg_hdr(skb); 166 nlh = nlmsg_hdr(skb);
167 167
168 if (nlh->nlmsg_len < sizeof(struct cn_msg) || 168 if (nlh->nlmsg_len < sizeof(struct cn_msg) ||
169 skb->len < nlh->nlmsg_len || 169 skb->len < nlh->nlmsg_len ||
170 nlh->nlmsg_len > CONNECTOR_MAX_MSG_SIZE) { 170 nlh->nlmsg_len > CONNECTOR_MAX_MSG_SIZE) {
171 kfree_skb(skb); 171 kfree_skb(skb);
172 return; 172 return;
173 } 173 }
174 174
175 err = cn_call_callback(skb); 175 err = cn_call_callback(skb);
176 if (err < 0) 176 if (err < 0)
177 kfree_skb(skb); 177 kfree_skb(skb);
178 } 178 }
179 } 179 }
180 180
181 /* 181 /*
182 * Callback add routing - adds callback with given ID and name. 182 * Callback add routing - adds callback with given ID and name.
183 * If there is registered callback with the same ID it will not be added. 183 * If there is registered callback with the same ID it will not be added.
184 * 184 *
185 * May sleep. 185 * May sleep.
186 */ 186 */
187 int cn_add_callback(struct cb_id *id, const char *name, 187 int cn_add_callback(struct cb_id *id, const char *name,
188 void (*callback)(struct cn_msg *, 188 void (*callback)(struct cn_msg *,
189 struct netlink_skb_parms *)) 189 struct netlink_skb_parms *))
190 { 190 {
191 int err; 191 int err;
192 struct cn_dev *dev = &cdev; 192 struct cn_dev *dev = &cdev;
193 193
194 if (!cn_already_initialized) 194 if (!cn_already_initialized)
195 return -EAGAIN; 195 return -EAGAIN;
196 196
197 err = cn_queue_add_callback(dev->cbdev, name, id, callback); 197 err = cn_queue_add_callback(dev->cbdev, name, id, callback);
198 if (err) 198 if (err)
199 return err; 199 return err;
200 200
201 return 0; 201 return 0;
202 } 202 }
203 EXPORT_SYMBOL_GPL(cn_add_callback); 203 EXPORT_SYMBOL_GPL(cn_add_callback);
204 204
205 /* 205 /*
206 * Callback remove routing - removes callback 206 * Callback remove routing - removes callback
207 * with given ID. 207 * with given ID.
208 * If there is no registered callback with given 208 * If there is no registered callback with given
209 * ID nothing happens. 209 * ID nothing happens.
210 * 210 *
211 * May sleep while waiting for reference counter to become zero. 211 * May sleep while waiting for reference counter to become zero.
212 */ 212 */
213 void cn_del_callback(struct cb_id *id) 213 void cn_del_callback(struct cb_id *id)
214 { 214 {
215 struct cn_dev *dev = &cdev; 215 struct cn_dev *dev = &cdev;
216 216
217 cn_queue_del_callback(dev->cbdev, id); 217 cn_queue_del_callback(dev->cbdev, id);
218 } 218 }
219 EXPORT_SYMBOL_GPL(cn_del_callback); 219 EXPORT_SYMBOL_GPL(cn_del_callback);
220 220
221 static int cn_proc_show(struct seq_file *m, void *v) 221 static int cn_proc_show(struct seq_file *m, void *v)
222 { 222 {
223 struct cn_queue_dev *dev = cdev.cbdev; 223 struct cn_queue_dev *dev = cdev.cbdev;
224 struct cn_callback_entry *cbq; 224 struct cn_callback_entry *cbq;
225 225
226 seq_printf(m, "Name ID\n"); 226 seq_printf(m, "Name ID\n");
227 227
228 spin_lock_bh(&dev->queue_lock); 228 spin_lock_bh(&dev->queue_lock);
229 229
230 list_for_each_entry(cbq, &dev->queue_list, callback_entry) { 230 list_for_each_entry(cbq, &dev->queue_list, callback_entry) {
231 seq_printf(m, "%-15s %u:%u\n", 231 seq_printf(m, "%-15s %u:%u\n",
232 cbq->id.name, 232 cbq->id.name,
233 cbq->id.id.idx, 233 cbq->id.id.idx,
234 cbq->id.id.val); 234 cbq->id.id.val);
235 } 235 }
236 236
237 spin_unlock_bh(&dev->queue_lock); 237 spin_unlock_bh(&dev->queue_lock);
238 238
239 return 0; 239 return 0;
240 } 240 }
241 241
242 static int cn_proc_open(struct inode *inode, struct file *file) 242 static int cn_proc_open(struct inode *inode, struct file *file)
243 { 243 {
244 return single_open(file, cn_proc_show, NULL); 244 return single_open(file, cn_proc_show, NULL);
245 } 245 }
246 246
247 static const struct file_operations cn_file_ops = { 247 static const struct file_operations cn_file_ops = {
248 .owner = THIS_MODULE, 248 .owner = THIS_MODULE,
249 .open = cn_proc_open, 249 .open = cn_proc_open,
250 .read = seq_read, 250 .read = seq_read,
251 .llseek = seq_lseek, 251 .llseek = seq_lseek,
252 .release = single_release 252 .release = single_release
253 }; 253 };
254 254
255 static struct cn_dev cdev = { 255 static struct cn_dev cdev = {
256 .input = cn_rx_skb, 256 .input = cn_rx_skb,
257 }; 257 };
258 258
259 static int cn_init(void) 259 static int cn_init(void)
260 { 260 {
261 struct cn_dev *dev = &cdev; 261 struct cn_dev *dev = &cdev;
262 struct netlink_kernel_cfg cfg = { 262 struct netlink_kernel_cfg cfg = {
263 .groups = CN_NETLINK_USERS + 0xf, 263 .groups = CN_NETLINK_USERS + 0xf,
264 .input = dev->input, 264 .input = dev->input,
265 }; 265 };
266 266
267 dev->nls = netlink_kernel_create(&init_net, NETLINK_CONNECTOR, &cfg); 267 dev->nls = netlink_kernel_create(&init_net, NETLINK_CONNECTOR, &cfg);
268 if (!dev->nls) 268 if (!dev->nls)
269 return -EIO; 269 return -EIO;
270 270
271 dev->cbdev = cn_queue_alloc_dev("cqueue", dev->nls); 271 dev->cbdev = cn_queue_alloc_dev("cqueue", dev->nls);
272 if (!dev->cbdev) { 272 if (!dev->cbdev) {
273 netlink_kernel_release(dev->nls); 273 netlink_kernel_release(dev->nls);
274 return -EINVAL; 274 return -EINVAL;
275 } 275 }
276 276
277 cn_already_initialized = 1; 277 cn_already_initialized = 1;
278 278
279 proc_create("connector", S_IRUGO, init_net.proc_net, &cn_file_ops); 279 proc_create("connector", S_IRUGO, init_net.proc_net, &cn_file_ops);
280 280
281 return 0; 281 return 0;
282 } 282 }
283 283
284 static void cn_fini(void) 284 static void cn_fini(void)
285 { 285 {
286 struct cn_dev *dev = &cdev; 286 struct cn_dev *dev = &cdev;
287 287
288 cn_already_initialized = 0; 288 cn_already_initialized = 0;
289 289
290 remove_proc_entry("connector", init_net.proc_net); 290 remove_proc_entry("connector", init_net.proc_net);
291 291
292 cn_queue_free_dev(dev->cbdev); 292 cn_queue_free_dev(dev->cbdev);
293 netlink_kernel_release(dev->nls); 293 netlink_kernel_release(dev->nls);
294 } 294 }
295 295
296 subsys_initcall(cn_init); 296 subsys_initcall(cn_init);
297 module_exit(cn_fini); 297 module_exit(cn_fini);
298 298