1 files changed, 185 insertions, 30 deletions
diff --git a/drivers/w1/w1_netlink.c b/drivers/w1/w1_netlink.c
index 328645da7972..d48f3acdb8a2 100644
--- a/drivers/w1/w1_netlink.c
+++ b/drivers/w1/w1_netlink.c
@@ -21,6 +21,7 @@
 #include <linux/skbuff.h>
 #include <linux/netlink.h>
+#include <linux/connector.h>
 #include "w1.h"
 #include "w1_log.h"
@@ -29,50 +30,204 @@
 #ifndef NETLINK_DISABLED
 void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *msg)
 {
-        unsigned int size;
+        char buf[sizeof(struct cn_msg) + sizeof(struct w1_netlink_msg)];
-        struct sk_buff *skb;
+        struct cn_msg *m = (struct cn_msg *)buf;
-        struct w1_netlink_msg *data;
+        struct w1_netlink_msg *w = (struct w1_netlink_msg *)(m+1);
-        struct nlmsghdr *nlh;
-        if (!dev->nls)
+        memset(buf, 0, sizeof(buf));
-                return;
-        size = NLMSG_SPACE(sizeof(struct w1_netlink_msg));
+        m->id.idx = CN_W1_IDX;
+        m->id.val = CN_W1_VAL;
-        skb = alloc_skb(size, GFP_ATOMIC);
+        m->seq = dev->seq++;
-        if (!skb) {
+        m->len = sizeof(struct w1_netlink_msg);
-                dev_err(&dev->dev, "skb_alloc() failed.\n");
-                return;
-        }
-        nlh = NLMSG_PUT(skb, 0, dev->seq++, NLMSG_DONE, size - sizeof(*nlh));
+        memcpy(w, msg, sizeof(struct w1_netlink_msg));
-        data = (struct w1_netlink_msg *)NLMSG_DATA(nlh);
+        cn_netlink_send(m, 0, GFP_KERNEL);
+}
-        memcpy(data, msg, sizeof(struct w1_netlink_msg));
+static int w1_process_command_master(struct w1_master *dev, struct cn_msg *msg,
+                struct w1_netlink_msg *hdr, struct w1_netlink_cmd *cmd)
+{
+        dev_dbg(&dev->dev, "%s: %s: cmd=%02x, len=%u.\n",
+                __func__, dev->name, cmd->cmd, cmd->len);
-        NETLINK_CB(skb).dst_group = dev->groups;
+        if (cmd->cmd != W1_CMD_SEARCH && cmd->cmd != W1_CMD_ALARM_SEARCH)
-        netlink_broadcast(dev->nls, skb, 0, dev->groups, GFP_ATOMIC);
+                return -EINVAL;
-nlmsg_failure:
+        w1_search_process(dev, (cmd->cmd == W1_CMD_ALARM_SEARCH)?W1_ALARM_SEARCH:W1_SEARCH);
-        return;
+        return 0;
 }
-int dev_init_netlink(struct w1_master *dev)
+static int w1_send_read_reply(struct w1_slave *sl, struct cn_msg *msg,
+                struct w1_netlink_msg *hdr, struct w1_netlink_cmd *cmd)
 {
-        dev->nls = netlink_kernel_create(NETLINK_W1, 1, NULL, THIS_MODULE);
+        void *data;
-        if (!dev->nls) {
+        struct w1_netlink_msg *h;
-                printk(KERN_ERR "Failed to create new netlink socket(%u) for w1 master %s.\n",
+        struct w1_netlink_cmd *c;
-                        NETLINK_W1, dev->dev.bus_id);
+        struct cn_msg *cm;
+        int err;
+        data = kzalloc(sizeof(struct cn_msg) +
+                        sizeof(struct w1_netlink_msg) +
+                        sizeof(struct w1_netlink_cmd) +
+                        cmd->len, GFP_KERNEL);
+        if (!data)
+                return -ENOMEM;
+        cm = (struct cn_msg *)(data);
+        h = (struct w1_netlink_msg *)(cm + 1);
+        c = (struct w1_netlink_cmd *)(h + 1);
+        memcpy(cm, msg, sizeof(struct cn_msg));
+        memcpy(h, hdr, sizeof(struct w1_netlink_msg));
+        memcpy(c, cmd, sizeof(struct w1_netlink_cmd));
+        cm->ack = msg->seq+1;
+        cm->len = sizeof(struct w1_netlink_msg) + sizeof(struct w1_netlink_cmd) + cmd->len;
+        h->len = sizeof(struct w1_netlink_cmd) + cmd->len;
+        memcpy(c->data, cmd->data, c->len);
+        err = cn_netlink_send(cm, 0, GFP_KERNEL);
+        kfree(data);
+        return err;
+}
+static int w1_process_command_slave(struct w1_slave *sl, struct cn_msg *msg,
+                struct w1_netlink_msg *hdr, struct w1_netlink_cmd *cmd)
+{
+        int err = 0;
+        dev_dbg(&sl->master->dev, "%s: %02x.%012llx.%02x: cmd=%02x, len=%u.\n",
+                __func__, sl->reg_num.family, (unsigned long long)sl->reg_num.id, sl->reg_num.crc,
+                cmd->cmd, cmd->len);
+        switch (cmd->cmd) {
+                case W1_CMD_READ:
+                        w1_read_block(sl->master, cmd->data, cmd->len);
+                        w1_send_read_reply(sl, msg, hdr, cmd);
+                        break;
+                case W1_CMD_WRITE:
+                        w1_write_block(sl->master, cmd->data, cmd->len);
+                        break;
+                case W1_CMD_SEARCH:
+                case W1_CMD_ALARM_SEARCH:
+                        w1_search_process(sl->master,
+                                        (cmd->cmd == W1_CMD_ALARM_SEARCH)?W1_ALARM_SEARCH:W1_SEARCH);
+                        break;
+                default:
+                        err = -1;
+                        break;
        }
-        return 0;
+        return err;
+}
+static void w1_cn_callback(void *data)
+{
+        struct cn_msg *msg = data;
+        struct w1_netlink_msg *m = (struct w1_netlink_msg *)(msg + 1);
+        struct w1_netlink_cmd *cmd;
+        struct w1_slave *sl;
+        struct w1_master *dev;
+        int err = 0;
+        while (msg->len && !err) {
+                struct w1_reg_num id;
+                u16 mlen = m->len;
+                u8 *cmd_data = m->data;
+                dev = NULL;
+                sl = NULL;
+                memcpy(&id, m->id.id, sizeof(id));
+#if 0
+                printk("%s: %02x.%012llx.%02x: type=%02x, len=%u.\n",
+                                __func__, id.family, (unsigned long long)id.id, id.crc, m->type, m->len);
+#endif
+                if (m->len + sizeof(struct w1_netlink_msg) > msg->len) {
+                        err = -E2BIG;
+                        break;
+                }
+                if (!mlen)
+                        goto out_cont;
+                if (m->type == W1_MASTER_CMD) {
+                        dev = w1_search_master_id(m->id.mst.id);
+                } else if (m->type == W1_SLAVE_CMD) {
+                        sl = w1_search_slave(&id);
+                        if (sl)
+                                dev = sl->master;
+                }
+                if (!dev) {
+                        err = -ENODEV;
+                        goto out_cont;
+                }
+                down(&dev->mutex);
+                if (sl && w1_reset_select_slave(sl)) {
+                        err = -ENODEV;
+                        goto out_up;
+                }
+                while (mlen) {
+                        cmd = (struct w1_netlink_cmd *)cmd_data;
+                        if (cmd->len + sizeof(struct w1_netlink_cmd) > mlen) {
+                                err = -E2BIG;
+                                break;
+                        }
+                        if (sl)
+                                w1_process_command_slave(sl, msg, m, cmd);
+                        else
+                                w1_process_command_master(dev, msg, m, cmd);
+                        cmd_data += cmd->len + sizeof(struct w1_netlink_cmd);
+                        mlen -= cmd->len + sizeof(struct w1_netlink_cmd);
+                }
+out_up:
+                atomic_dec(&dev->refcnt);
+                if (sl)
+                        atomic_dec(&sl->refcnt);
+                up(&dev->mutex);
+out_cont:
+                msg->len -= sizeof(struct w1_netlink_msg) + m->len;
+                m = (struct w1_netlink_msg *)(((u8 *)m) + sizeof(struct w1_netlink_msg) + m->len);
+                /*
+                 * Let's allow requests for nonexisting devices.
+                 */
+                if (err == -ENODEV)
+                        err = 0;
+        }
+#if 0
+        if (err) {
+                printk("%s: malformed message. Dropping.\n", __func__);
+        }
+#endif
 }
-void dev_fini_netlink(struct w1_master *dev)
+int w1_init_netlink(void)
 {
-        if (dev->nls && dev->nls->sk_socket)
+        struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
-                sock_release(dev->nls->sk_socket);
+        return cn_add_callback(&w1_id, "w1", &w1_cn_callback);
+}
+void w1_fini_netlink(void)
+{
+        struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
+        cn_del_callback(&w1_id);
 }
 #else
 #warning Netlink support is disabled. Please compile with NET support enabled.
@@ -81,12 +236,12 @@ void w1_netlink_send(struct w1_master *dev, struct w1_netlink_msg *msg)
 {
 }
-int dev_init_netlink(struct w1_master *dev)
+int w1_init_netlink(void)
 {
        return 0;
 }
-void dev_fini_netlink(struct w1_master *dev)
+void w1_fini_netlink(void)
 {
 }
 #endif

diff --git a/drivers/w1/w1_netlink.c b/drivers/w1/w1_netlink.c index 328645da7972..d48f3acdb8a2 100644 --- a/drivers/w1/w1_netlink.c +++ b/drivers/w1/w1_netlink.c
@@ -21,6 +21,7 @@
21		21
22	#include <linux/skbuff.h>	22	#include <linux/skbuff.h>
23	#include <linux/netlink.h>	23	#include <linux/netlink.h>
		24	#include <linux/connector.h>
24		25
25	#include "w1.h"	26	#include "w1.h"
26	#include "w1_log.h"	27	#include "w1_log.h"
@@ -29,50 +30,204 @@
29	#ifndef NETLINK_DISABLED	30	#ifndef NETLINK_DISABLED
30	void w1_netlink_send(struct w1_master dev, struct w1_netlink_msg msg)	31	void w1_netlink_send(struct w1_master dev, struct w1_netlink_msg msg)
31	{	32	{
32	unsigned int size;	33	char buf[sizeof(struct cn_msg) + sizeof(struct w1_netlink_msg)];
33	struct sk_buff *skb;	34	struct cn_msg m = (struct cn_msg )buf;
34	struct w1_netlink_msg *data;	35	struct w1_netlink_msg w = (struct w1_netlink_msg )(m+1);
35	struct nlmsghdr *nlh;
36		36
37	if (!dev->nls)	37	memset(buf, 0, sizeof(buf));
38	return;
39		38
40	size = NLMSG_SPACE(sizeof(struct w1_netlink_msg));	39	m->id.idx = CN_W1_IDX;
		40	m->id.val = CN_W1_VAL;
41		41
42	skb = alloc_skb(size, GFP_ATOMIC);	42	m->seq = dev->seq++;
43	if (!skb) {	43	m->len = sizeof(struct w1_netlink_msg);
44	dev_err(&dev->dev, "skb_alloc() failed.\n");
45	return;
46	}
47		44
48	nlh = NLMSG_PUT(skb, 0, dev->seq++, NLMSG_DONE, size - sizeof(*nlh));	45	memcpy(w, msg, sizeof(struct w1_netlink_msg));
49		46
50	data = (struct w1_netlink_msg *)NLMSG_DATA(nlh);	47	cn_netlink_send(m, 0, GFP_KERNEL);
		48	}
51		49
52	memcpy(data, msg, sizeof(struct w1_netlink_msg));	50	static int w1_process_command_master(struct w1_master dev, struct cn_msg msg,
		51	struct w1_netlink_msg hdr, struct w1_netlink_cmd cmd)
		52	{
		53	dev_dbg(&dev->dev, "%s: %s: cmd=%02x, len=%u.\n",
		54	__func__, dev->name, cmd->cmd, cmd->len);
53		55
54	NETLINK_CB(skb).dst_group = dev->groups;	56	if (cmd->cmd != W1_CMD_SEARCH && cmd->cmd != W1_CMD_ALARM_SEARCH)
55	netlink_broadcast(dev->nls, skb, 0, dev->groups, GFP_ATOMIC);	57	return -EINVAL;
56		58
57	nlmsg_failure:	59	w1_search_process(dev, (cmd->cmd == W1_CMD_ALARM_SEARCH)?W1_ALARM_SEARCH:W1_SEARCH);
58	return;	60	return 0;
59	}	61	}
60		62
61	int dev_init_netlink(struct w1_master *dev)	63	static int w1_send_read_reply(struct w1_slave sl, struct cn_msg msg,
		64	struct w1_netlink_msg hdr, struct w1_netlink_cmd cmd)
62	{	65	{
63	dev->nls = netlink_kernel_create(NETLINK_W1, 1, NULL, THIS_MODULE);	66	void *data;
64	if (!dev->nls) {	67	struct w1_netlink_msg *h;
65	printk(KERN_ERR "Failed to create new netlink socket(%u) for w1 master %s.\n",	68	struct w1_netlink_cmd *c;
66	NETLINK_W1, dev->dev.bus_id);	69	struct cn_msg *cm;
		70	int err;
		71
		72	data = kzalloc(sizeof(struct cn_msg) +
		73	sizeof(struct w1_netlink_msg) +
		74	sizeof(struct w1_netlink_cmd) +
		75	cmd->len, GFP_KERNEL);
		76	if (!data)
		77	return -ENOMEM;
		78
		79	cm = (struct cn_msg *)(data);
		80	h = (struct w1_netlink_msg *)(cm + 1);
		81	c = (struct w1_netlink_cmd *)(h + 1);
		82
		83	memcpy(cm, msg, sizeof(struct cn_msg));
		84	memcpy(h, hdr, sizeof(struct w1_netlink_msg));
		85	memcpy(c, cmd, sizeof(struct w1_netlink_cmd));
		86
		87	cm->ack = msg->seq+1;
		88	cm->len = sizeof(struct w1_netlink_msg) + sizeof(struct w1_netlink_cmd) + cmd->len;
		89
		90	h->len = sizeof(struct w1_netlink_cmd) + cmd->len;
		91
		92	memcpy(c->data, cmd->data, c->len);
		93
		94	err = cn_netlink_send(cm, 0, GFP_KERNEL);
		95
		96	kfree(data);
		97
		98	return err;
		99	}
		100
		101	static int w1_process_command_slave(struct w1_slave sl, struct cn_msg msg,
		102	struct w1_netlink_msg hdr, struct w1_netlink_cmd cmd)
		103	{
		104	int err = 0;
		105
		106	dev_dbg(&sl->master->dev, "%s: %02x.%012llx.%02x: cmd=%02x, len=%u.\n",
		107	__func__, sl->reg_num.family, (unsigned long long)sl->reg_num.id, sl->reg_num.crc,
		108	cmd->cmd, cmd->len);
		109
		110	switch (cmd->cmd) {
		111	case W1_CMD_READ:
		112	w1_read_block(sl->master, cmd->data, cmd->len);
		113	w1_send_read_reply(sl, msg, hdr, cmd);
		114	break;
		115	case W1_CMD_WRITE:
		116	w1_write_block(sl->master, cmd->data, cmd->len);
		117	break;
		118	case W1_CMD_SEARCH:
		119	case W1_CMD_ALARM_SEARCH:
		120	w1_search_process(sl->master,
		121	(cmd->cmd == W1_CMD_ALARM_SEARCH)?W1_ALARM_SEARCH:W1_SEARCH);
		122	break;
		123	default:
		124	err = -1;
		125	break;
67	}	126	}
68		127
69	return 0;	128	return err;
		129	}
		130
		131	static void w1_cn_callback(void *data)
		132	{
		133	struct cn_msg *msg = data;
		134	struct w1_netlink_msg m = (struct w1_netlink_msg )(msg + 1);
		135	struct w1_netlink_cmd *cmd;
		136	struct w1_slave *sl;
		137	struct w1_master *dev;
		138	int err = 0;
		139
		140	while (msg->len && !err) {
		141	struct w1_reg_num id;
		142	u16 mlen = m->len;
		143	u8 *cmd_data = m->data;
		144
		145	dev = NULL;
		146	sl = NULL;
		147
		148	memcpy(&id, m->id.id, sizeof(id));
		149	#if 0
		150	printk("%s: %02x.%012llx.%02x: type=%02x, len=%u.\n",
		151	__func__, id.family, (unsigned long long)id.id, id.crc, m->type, m->len);
		152	#endif
		153	if (m->len + sizeof(struct w1_netlink_msg) > msg->len) {
		154	err = -E2BIG;
		155	break;
		156	}
		157
		158	if (!mlen)
		159	goto out_cont;
		160
		161	if (m->type == W1_MASTER_CMD) {
		162	dev = w1_search_master_id(m->id.mst.id);
		163	} else if (m->type == W1_SLAVE_CMD) {
		164	sl = w1_search_slave(&id);
		165	if (sl)
		166	dev = sl->master;
		167	}
		168
		169	if (!dev) {
		170	err = -ENODEV;
		171	goto out_cont;
		172	}
		173
		174	down(&dev->mutex);
		175
		176	if (sl && w1_reset_select_slave(sl)) {
		177	err = -ENODEV;
		178	goto out_up;
		179	}
		180
		181	while (mlen) {
		182	cmd = (struct w1_netlink_cmd *)cmd_data;
		183
		184	if (cmd->len + sizeof(struct w1_netlink_cmd) > mlen) {
		185	err = -E2BIG;
		186	break;
		187	}
		188
		189	if (sl)
		190	w1_process_command_slave(sl, msg, m, cmd);
		191	else
		192	w1_process_command_master(dev, msg, m, cmd);
		193
		194	cmd_data += cmd->len + sizeof(struct w1_netlink_cmd);
		195	mlen -= cmd->len + sizeof(struct w1_netlink_cmd);
		196	}
		197	out_up:
		198	atomic_dec(&dev->refcnt);
		199	if (sl)
		200	atomic_dec(&sl->refcnt);
		201	up(&dev->mutex);
		202	out_cont:
		203	msg->len -= sizeof(struct w1_netlink_msg) + m->len;
		204	m = (struct w1_netlink_msg )(((u8 )m) + sizeof(struct w1_netlink_msg) + m->len);
		205
		206	/*
		207	* Let's allow requests for nonexisting devices.
		208	*/
		209	if (err == -ENODEV)
		210	err = 0;
		211	}
		212	#if 0
		213	if (err) {
		214	printk("%s: malformed message. Dropping.\n", __func__);
		215	}
		216	#endif
70	}	217	}
71		218
72	void dev_fini_netlink(struct w1_master *dev)	219	int w1_init_netlink(void)
73	{	220	{
74	if (dev->nls && dev->nls->sk_socket)	221	struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
75	sock_release(dev->nls->sk_socket);	222
		223	return cn_add_callback(&w1_id, "w1", &w1_cn_callback);
		224	}
		225
		226	void w1_fini_netlink(void)
		227	{
		228	struct cb_id w1_id = {.idx = CN_W1_IDX, .val = CN_W1_VAL};
		229
		230	cn_del_callback(&w1_id);
76	}	231	}
77	#else	232	#else
78	#warning Netlink support is disabled. Please compile with NET support enabled.	233	#warning Netlink support is disabled. Please compile with NET support enabled.
@@ -81,12 +236,12 @@ void w1_netlink_send(struct w1_master dev, struct w1_netlink_msg msg)
81	{	236	{
82	}	237	}
83		238
84	int dev_init_netlink(struct w1_master *dev)	239	int w1_init_netlink(void)
85	{	240	{
86	return 0;	241	return 0;
87	}	242	}
88		243
89	void dev_fini_netlink(struct w1_master *dev)	244	void w1_fini_netlink(void)
90	{	245	{
91	}	246	}
92	#endif	247	#endif