connector.c 6.8 KB
Newer Older
E
Evgeniy Polyakov 已提交
1 2
/*
 * 	connector.c
3
 *
4
 * 2004+ Copyright (c) Evgeniy Polyakov <zbr@ioremap.net>
E
Evgeniy Polyakov 已提交
5
 * All rights reserved.
6
 *
E
Evgeniy Polyakov 已提交
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/list.h>
#include <linux/skbuff.h>
#include <linux/netlink.h>
#include <linux/moduleparam.h>
#include <linux/connector.h>
29
#include <linux/slab.h>
30
#include <linux/mutex.h>
31 32
#include <linux/proc_fs.h>
#include <linux/spinlock.h>
E
Evgeniy Polyakov 已提交
33 34 35 36

#include <net/sock.h>

MODULE_LICENSE("GPL");
37
MODULE_AUTHOR("Evgeniy Polyakov <zbr@ioremap.net>");
E
Evgeniy Polyakov 已提交
38
MODULE_DESCRIPTION("Generic userspace <-> kernelspace connector.");
S
Stephen Hemminger 已提交
39
MODULE_ALIAS_NET_PF_PROTO(PF_NETLINK, NETLINK_CONNECTOR);
E
Evgeniy Polyakov 已提交
40 41 42

static struct cn_dev cdev;

43
static int cn_already_initialized;
E
Evgeniy Polyakov 已提交
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65

/*
 * msg->seq and msg->ack are used to determine message genealogy.
 * When someone sends message it puts there locally unique sequence
 * and random acknowledge numbers.  Sequence number may be copied into
 * nlmsghdr->nlmsg_seq too.
 *
 * Sequence number is incremented with each message to be sent.
 *
 * If we expect reply to our message then the sequence number in
 * received message MUST be the same as in original message, and
 * acknowledge number MUST be the same + 1.
 *
 * If we receive a message and its sequence number is not equal to the
 * one we are expecting then it is a new message.
 *
 * If we receive a message and its sequence number is the same as one
 * we are expecting but it's acknowledgement number is not equal to
 * the acknowledgement number in the original message + 1, then it is
 * a new message.
 *
 */
A
Al Viro 已提交
66
int cn_netlink_send(struct cn_msg *msg, u32 __group, gfp_t gfp_mask)
E
Evgeniy Polyakov 已提交
67 68 69 70 71 72 73 74 75 76 77 78 79 80
{
	struct cn_callback_entry *__cbq;
	unsigned int size;
	struct sk_buff *skb;
	struct nlmsghdr *nlh;
	struct cn_msg *data;
	struct cn_dev *dev = &cdev;
	u32 group = 0;
	int found = 0;

	if (!__group) {
		spin_lock_bh(&dev->cbdev->queue_lock);
		list_for_each_entry(__cbq, &dev->cbdev->queue_list,
				    callback_entry) {
81
			if (cn_cb_equal(&__cbq->id.id, &msg->id)) {
E
Evgeniy Polyakov 已提交
82 83
				found = 1;
				group = __cbq->group;
84
				break;
E
Evgeniy Polyakov 已提交
85 86 87 88 89 90 91 92 93 94
			}
		}
		spin_unlock_bh(&dev->cbdev->queue_lock);

		if (!found)
			return -ENODEV;
	} else {
		group = __group;
	}

95 96 97
	if (!netlink_has_listeners(dev->nls, group))
		return -ESRCH;

E
Evgeniy Polyakov 已提交
98 99 100 101 102 103 104 105 106 107 108 109 110 111
	size = NLMSG_SPACE(sizeof(*msg) + msg->len);

	skb = alloc_skb(size, gfp_mask);
	if (!skb)
		return -ENOMEM;

	nlh = NLMSG_PUT(skb, 0, msg->seq, NLMSG_DONE, size - sizeof(*nlh));

	data = NLMSG_DATA(nlh);

	memcpy(data, msg, sizeof(*data) + msg->len);

	NETLINK_CB(skb).dst_group = group;

112
	return netlink_broadcast(dev->nls, skb, 0, group, gfp_mask);
E
Evgeniy Polyakov 已提交
113 114 115 116 117

nlmsg_failure:
	kfree_skb(skb);
	return -EINVAL;
}
A
Andrew Morton 已提交
118
EXPORT_SYMBOL_GPL(cn_netlink_send);
E
Evgeniy Polyakov 已提交
119 120 121 122

/*
 * Callback helper - queues work and setup destructor for given data.
 */
123
static int cn_call_callback(struct sk_buff *skb)
E
Evgeniy Polyakov 已提交
124
{
125
	struct cn_callback_entry *i, *cbq = NULL;
E
Evgeniy Polyakov 已提交
126
	struct cn_dev *dev = &cdev;
127
	struct cn_msg *msg = NLMSG_DATA(nlmsg_hdr(skb));
128
	struct netlink_skb_parms *nsp = &NETLINK_CB(skb);
129
	int err = -ENODEV;
E
Evgeniy Polyakov 已提交
130 131

	spin_lock_bh(&dev->cbdev->queue_lock);
132 133 134 135
	list_for_each_entry(i, &dev->cbdev->queue_list, callback_entry) {
		if (cn_cb_equal(&i->id.id, &msg->id)) {
			atomic_inc(&i->refcnt);
			cbq = i;
E
Evgeniy Polyakov 已提交
136 137 138 139 140
			break;
		}
	}
	spin_unlock_bh(&dev->cbdev->queue_lock);

141 142 143 144 145 146
	if (cbq != NULL) {
		cbq->callback(msg, nsp);
		kfree_skb(skb);
		cn_queue_release_callback(cbq);
	}

147
	return err;
E
Evgeniy Polyakov 已提交
148 149 150 151 152
}

/*
 * Main netlink receiving function.
 *
153
 * It checks skb, netlink header and msg sizes, and calls callback helper.
E
Evgeniy Polyakov 已提交
154 155 156 157 158 159 160 161 162 163
 */
static void cn_rx_skb(struct sk_buff *__skb)
{
	struct nlmsghdr *nlh;
	int err;
	struct sk_buff *skb;

	skb = skb_get(__skb);

	if (skb->len >= NLMSG_SPACE(0)) {
164
		nlh = nlmsg_hdr(skb);
E
Evgeniy Polyakov 已提交
165 166 167 168 169

		if (nlh->nlmsg_len < sizeof(struct cn_msg) ||
		    skb->len < nlh->nlmsg_len ||
		    nlh->nlmsg_len > CONNECTOR_MAX_MSG_SIZE) {
			kfree_skb(skb);
170
			return;
E
Evgeniy Polyakov 已提交
171 172
		}

173
		err = cn_call_callback(skb);
E
Evgeniy Polyakov 已提交
174 175 176 177 178 179 180 181 182 183 184
		if (err < 0)
			kfree_skb(skb);
	}
}

/*
 * Callback add routing - adds callback with given ID and name.
 * If there is registered callback with the same ID it will not be added.
 *
 * May sleep.
 */
185
int cn_add_callback(struct cb_id *id, const char *name,
186
		    void (*callback)(struct cn_msg *, struct netlink_skb_parms *))
E
Evgeniy Polyakov 已提交
187 188 189 190
{
	int err;
	struct cn_dev *dev = &cdev;

191 192 193
	if (!cn_already_initialized)
		return -EAGAIN;

194 195
	err = cn_queue_add_callback(dev->cbdev, name, id, callback);
	if (err)
E
Evgeniy Polyakov 已提交
196 197 198 199
		return err;

	return 0;
}
A
Andrew Morton 已提交
200
EXPORT_SYMBOL_GPL(cn_add_callback);
E
Evgeniy Polyakov 已提交
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215

/*
 * Callback remove routing - removes callback
 * with given ID.
 * If there is no registered callback with given
 * ID nothing happens.
 *
 * May sleep while waiting for reference counter to become zero.
 */
void cn_del_callback(struct cb_id *id)
{
	struct cn_dev *dev = &cdev;

	cn_queue_del_callback(dev->cbdev, id);
}
A
Andrew Morton 已提交
216
EXPORT_SYMBOL_GPL(cn_del_callback);
E
Evgeniy Polyakov 已提交
217

218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
static int cn_proc_show(struct seq_file *m, void *v)
{
	struct cn_queue_dev *dev = cdev.cbdev;
	struct cn_callback_entry *cbq;

	seq_printf(m, "Name            ID\n");

	spin_lock_bh(&dev->queue_lock);

	list_for_each_entry(cbq, &dev->queue_list, callback_entry) {
		seq_printf(m, "%-15s %u:%u\n",
			   cbq->id.name,
			   cbq->id.id.idx,
			   cbq->id.id.val);
	}

	spin_unlock_bh(&dev->queue_lock);

	return 0;
}

static int cn_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, cn_proc_show, NULL);
}

static const struct file_operations cn_file_ops = {
	.owner   = THIS_MODULE,
	.open    = cn_proc_open,
	.read    = seq_read,
	.llseek  = seq_lseek,
	.release = single_release
};

252
static int __devinit cn_init(void)
E
Evgeniy Polyakov 已提交
253 254 255
{
	struct cn_dev *dev = &cdev;

256
	dev->input = cn_rx_skb;
E
Evgeniy Polyakov 已提交
257

258
	dev->nls = netlink_kernel_create(&init_net, NETLINK_CONNECTOR,
E
Evgeniy Polyakov 已提交
259
					 CN_NETLINK_USERS + 0xf,
260
					 dev->input, NULL, THIS_MODULE);
E
Evgeniy Polyakov 已提交
261 262 263 264 265
	if (!dev->nls)
		return -EIO;

	dev->cbdev = cn_queue_alloc_dev("cqueue", dev->nls);
	if (!dev->cbdev) {
266
		netlink_kernel_release(dev->nls);
E
Evgeniy Polyakov 已提交
267 268
		return -EINVAL;
	}
269

270
	cn_already_initialized = 1;
E
Evgeniy Polyakov 已提交
271

272 273
	proc_net_fops_create(&init_net, "connector", S_IRUGO, &cn_file_ops);

E
Evgeniy Polyakov 已提交
274 275 276
	return 0;
}

277
static void __devexit cn_fini(void)
E
Evgeniy Polyakov 已提交
278 279 280 281 282
{
	struct cn_dev *dev = &cdev;

	cn_already_initialized = 0;

283 284
	proc_net_remove(&init_net, "connector");

E
Evgeniy Polyakov 已提交
285
	cn_queue_free_dev(dev->cbdev);
286
	netlink_kernel_release(dev->nls);
E
Evgeniy Polyakov 已提交
287 288
}

289
subsys_initcall(cn_init);
E
Evgeniy Polyakov 已提交
290
module_exit(cn_fini);