aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat
-rw-r--r--Documentation/connector/cn_test.c194
-rw-r--r--Documentation/connector/connector.txt133
-rw-r--r--drivers/Kconfig2
-rw-r--r--drivers/Makefile2
-rw-r--r--drivers/connector/Kconfig13
-rw-r--r--drivers/connector/Makefile3
-rw-r--r--drivers/connector/cn_queue.c173
-rw-r--r--drivers/connector/connector.c486
-rw-r--r--drivers/net/bnx2.c2
-rw-r--r--drivers/net/hamradio/6pack.c2
-rw-r--r--drivers/net/hamradio/baycom_epp.c17
-rw-r--r--drivers/net/hamradio/bpqether.c2
-rw-r--r--drivers/net/hamradio/dmascc.c10
-rw-r--r--drivers/net/hamradio/hdlcdrv.c16
-rw-r--r--drivers/net/hamradio/mkiss.c2
-rw-r--r--drivers/net/hamradio/scc.c2
-rw-r--r--drivers/net/hamradio/yam.c28
-rw-r--r--drivers/net/tg3.c10
-rw-r--r--include/linux/connector.h158
-rw-r--r--include/linux/netlink.h1
-rw-r--r--include/linux/sysctl.h3
-rw-r--r--include/net/ax25.h31
-rw-r--r--include/net/netrom.h32
-rw-r--r--net/ax25/af_ax25.c46
-rw-r--r--net/ax25/ax25_ip.c6
-rw-r--r--net/core/pktgen.c13
-rw-r--r--net/dccp/ccids/ccid3.c8
-rw-r--r--net/ipv4/ipconfig.c6
-rw-r--r--net/irda/ircomm/ircomm_tty.c9
-rw-r--r--net/netrom/af_netrom.c28
-rw-r--r--net/netrom/nr_dev.c54
-rw-r--r--net/netrom/nr_in.c15
-rw-r--r--net/netrom/nr_subr.c7
-rw-r--r--net/netrom/sysctl_net_netrom.c12
-rw-r--r--net/rose/af_rose.c8
-rw-r--r--net/rose/rose_dev.c2
-rw-r--r--net/sunrpc/svcsock.c3
37 files changed, 1359 insertions, 180 deletions
diff --git a/Documentation/connector/cn_test.c b/Documentation/connector/cn_test.c
new file mode 100644
index 000000000000..b7de82e9c0e0
--- /dev/null
+++ b/Documentation/connector/cn_test.c
@@ -0,0 +1,194 @@
1/*
2 * cn_test.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/moduleparam.h>
25#include <linux/skbuff.h>
26#include <linux/timer.h>
27
28#include "connector.h"
29
30static struct cb_id cn_test_id = { 0x123, 0x456 };
31static char cn_test_name[] = "cn_test";
32static struct sock *nls;
33static struct timer_list cn_test_timer;
34
35void cn_test_callback(void *data)
36{
37 struct cn_msg *msg = (struct cn_msg *)data;
38
39 printk("%s: %lu: idx=%x, val=%x, seq=%u, ack=%u, len=%d: %s.\n",
40 __func__, jiffies, msg->id.idx, msg->id.val,
41 msg->seq, msg->ack, msg->len, (char *)msg->data);
42}
43
44static int cn_test_want_notify(void)
45{
46 struct cn_ctl_msg *ctl;
47 struct cn_notify_req *req;
48 struct cn_msg *msg = NULL;
49 int size, size0;
50 struct sk_buff *skb;
51 struct nlmsghdr *nlh;
52 u32 group = 1;
53
54 size0 = sizeof(*msg) + sizeof(*ctl) + 3 * sizeof(*req);
55
56 size = NLMSG_SPACE(size0);
57
58 skb = alloc_skb(size, GFP_ATOMIC);
59 if (!skb) {
60 printk(KERN_ERR "Failed to allocate new skb with size=%u.\n",
61 size);
62
63 return -ENOMEM;
64 }
65
66 nlh = NLMSG_PUT(skb, 0, 0x123, NLMSG_DONE, size - sizeof(*nlh));
67
68 msg = (struct cn_msg *)NLMSG_DATA(nlh);
69
70 memset(msg, 0, size0);
71
72 msg->id.idx = -1;
73 msg->id.val = -1;
74 msg->seq = 0x123;
75 msg->ack = 0x345;
76 msg->len = size0 - sizeof(*msg);
77
78 ctl = (struct cn_ctl_msg *)(msg + 1);
79
80 ctl->idx_notify_num = 1;
81 ctl->val_notify_num = 2;
82 ctl->group = group;
83 ctl->len = msg->len - sizeof(*ctl);
84
85 req = (struct cn_notify_req *)(ctl + 1);
86
87 /*
88 * Idx.
89 */
90 req->first = cn_test_id.idx;
91 req->range = 10;
92
93 /*
94 * Val 0.
95 */
96 req++;
97 req->first = cn_test_id.val;
98 req->range = 10;
99
100 /*
101 * Val 1.
102 */
103 req++;
104 req->first = cn_test_id.val + 20;
105 req->range = 10;
106
107 NETLINK_CB(skb).dst_groups = ctl->group;
108 //netlink_broadcast(nls, skb, 0, ctl->group, GFP_ATOMIC);
109 netlink_unicast(nls, skb, 0, 0);
110
111 printk(KERN_INFO "Request was sent. Group=0x%x.\n", ctl->group);
112
113 return 0;
114
115nlmsg_failure:
116 printk(KERN_ERR "Failed to send %u.%u\n", msg->seq, msg->ack);
117 kfree_skb(skb);
118 return -EINVAL;
119}
120
121static u32 cn_test_timer_counter;
122static void cn_test_timer_func(unsigned long __data)
123{
124 struct cn_msg *m;
125 char data[32];
126
127 m = kmalloc(sizeof(*m) + sizeof(data), GFP_ATOMIC);
128 if (m) {
129 memset(m, 0, sizeof(*m) + sizeof(data));
130
131 memcpy(&m->id, &cn_test_id, sizeof(m->id));
132 m->seq = cn_test_timer_counter;
133 m->len = sizeof(data);
134
135 m->len =
136 scnprintf(data, sizeof(data), "counter = %u",
137 cn_test_timer_counter) + 1;
138
139 memcpy(m + 1, data, m->len);
140
141 cn_netlink_send(m, 0, gfp_any());
142 kfree(m);
143 }
144
145 cn_test_timer_counter++;
146
147 mod_timer(&cn_test_timer, jiffies + HZ);
148}
149
150static int cn_test_init(void)
151{
152 int err;
153
154 err = cn_add_callback(&cn_test_id, cn_test_name, cn_test_callback);
155 if (err)
156 goto err_out;
157 cn_test_id.val++;
158 err = cn_add_callback(&cn_test_id, cn_test_name, cn_test_callback);
159 if (err) {
160 cn_del_callback(&cn_test_id);
161 goto err_out;
162 }
163
164 init_timer(&cn_test_timer);
165 cn_test_timer.function = cn_test_timer_func;
166 cn_test_timer.expires = jiffies + HZ;
167 cn_test_timer.data = 0;
168 add_timer(&cn_test_timer);
169
170 return 0;
171
172 err_out:
173 if (nls && nls->sk_socket)
174 sock_release(nls->sk_socket);
175
176 return err;
177}
178
179static void cn_test_fini(void)
180{
181 del_timer_sync(&cn_test_timer);
182 cn_del_callback(&cn_test_id);
183 cn_test_id.val--;
184 cn_del_callback(&cn_test_id);
185 if (nls && nls->sk_socket)
186 sock_release(nls->sk_socket);
187}
188
189module_init(cn_test_init);
190module_exit(cn_test_fini);
191
192MODULE_LICENSE("GPL");
193MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
194MODULE_DESCRIPTION("Connector's test module");
diff --git a/Documentation/connector/connector.txt b/Documentation/connector/connector.txt
new file mode 100644
index 000000000000..54a0a14bfbe3
--- /dev/null
+++ b/Documentation/connector/connector.txt
@@ -0,0 +1,133 @@
1/*****************************************/
2Kernel Connector.
3/*****************************************/
4
5Kernel connector - new netlink based userspace <-> kernel space easy
6to use communication module.
7
8Connector driver adds possibility to connect various agents using
9netlink based network. One must register callback and
10identifier. When driver receives special netlink message with
11appropriate identifier, appropriate callback will be called.
12
13From the userspace point of view it's quite straightforward:
14
15 socket();
16 bind();
17 send();
18 recv();
19
20But if kernelspace want to use full power of such connections, driver
21writer must create special sockets, must know about struct sk_buff
22handling... Connector allows any kernelspace agents to use netlink
23based networking for inter-process communication in a significantly
24easier way:
25
26int cn_add_callback(struct cb_id *id, char *name, void (*callback) (void *));
27void cn_netlink_send(struct cn_msg *msg, u32 __group, int gfp_mask);
28
29struct cb_id
30{
31 __u32 idx;
32 __u32 val;
33};
34
35idx and val are unique identifiers which must be registered in
36connector.h for in-kernel usage. void (*callback) (void *) - is a
37callback function which will be called when message with above idx.val
38will be received by connector core. Argument for that function must
39be dereferenced to struct cn_msg *.
40
41struct cn_msg
42{
43 struct cb_id id;
44
45 __u32 seq;
46 __u32 ack;
47
48 __u32 len; /* Length of the following data */
49 __u8 data[0];
50};
51
52/*****************************************/
53Connector interfaces.
54/*****************************************/
55
56int cn_add_callback(struct cb_id *id, char *name, void (*callback) (void *));
57
58Registers new callback with connector core.
59
60struct cb_id *id - unique connector's user identifier.
61 It must be registered in connector.h for legal in-kernel users.
62char *name - connector's callback symbolic name.
63void (*callback) (void *) - connector's callback.
64 Argument must be dereferenced to struct cn_msg *.
65
66void cn_del_callback(struct cb_id *id);
67
68Unregisters new callback with connector core.
69
70struct cb_id *id - unique connector's user identifier.
71
72void cn_netlink_send(struct cn_msg *msg, u32 __groups, int gfp_mask);
73
74Sends message to the specified groups. It can be safely called from
75any context, but may silently fail under strong memory pressure.
76
77struct cn_msg * - message header(with attached data).
78u32 __group - destination group.
79 If __group is zero, then appropriate group will
80 be searched through all registered connector users,
81 and message will be delivered to the group which was
82 created for user with the same ID as in msg.
83 If __group is not zero, then message will be delivered
84 to the specified group.
85int gfp_mask - GFP mask.
86
87Note: When registering new callback user, connector core assigns
88netlink group to the user which is equal to it's id.idx.
89
90/*****************************************/
91Protocol description.
92/*****************************************/
93
94Current offers transport layer with fixed header. Recommended
95protocol which uses such header is following:
96
97msg->seq and msg->ack are used to determine message genealogy. When
98someone sends message it puts there locally unique sequence and random
99acknowledge numbers. Sequence number may be copied into
100nlmsghdr->nlmsg_seq too.
101
102Sequence number is incremented with each message to be sent.
103
104If we expect reply to our message, then sequence number in received
105message MUST be the same as in original message, and acknowledge
106number MUST be the same + 1.
107
108If we receive message and it's sequence number is not equal to one we
109are expecting, then it is new message. If we receive message and it's
110sequence number is the same as one we are expecting, but it's
111acknowledge is not equal acknowledge number in original message + 1,
112then it is new message.
113
114Obviously, protocol header contains above id.
115
116connector allows event notification in the following form: kernel
117driver or userspace process can ask connector to notify it when
118selected id's will be turned on or off(registered or unregistered it's
119callback). It is done by sending special command to connector
120driver(it also registers itself with id={-1, -1}).
121
122As example of usage Documentation/connector now contains cn_test.c -
123testing module which uses connector to request notification and to
124send messages.
125
126/*****************************************/
127Reliability.
128/*****************************************/
129
130Netlink itself is not reliable protocol, that means that messages can
131be lost due to memory pressure or process' receiving queue overflowed,
132so caller is warned must be prepared. That is why struct cn_msg [main
133connector's message header] contains u32 seq and u32 ack fields.
diff --git a/drivers/Kconfig b/drivers/Kconfig
index 46d655fab115..48f446d3c671 100644
--- a/drivers/Kconfig
+++ b/drivers/Kconfig
@@ -4,6 +4,8 @@ menu "Device Drivers"
4 4
5source "drivers/base/Kconfig" 5source "drivers/base/Kconfig"
6 6
7source "drivers/connector/Kconfig"
8
7source "drivers/mtd/Kconfig" 9source "drivers/mtd/Kconfig"
8 10
9source "drivers/parport/Kconfig" 11source "drivers/parport/Kconfig"
diff --git a/drivers/Makefile b/drivers/Makefile
index 86c8654a0ca9..1a109a6dd953 100644
--- a/drivers/Makefile
+++ b/drivers/Makefile
@@ -17,6 +17,8 @@ obj-$(CONFIG_PNP) += pnp/
17# default. 17# default.
18obj-y += char/ 18obj-y += char/
19 19
20obj-$(CONFIG_CONNECTOR) += connector/
21
20# i810fb and intelfb depend on char/agp/ 22# i810fb and intelfb depend on char/agp/
21obj-$(CONFIG_FB_I810) += video/i810/ 23obj-$(CONFIG_FB_I810) += video/i810/
22obj-$(CONFIG_FB_INTEL) += video/intelfb/ 24obj-$(CONFIG_FB_INTEL) += video/intelfb/
diff --git a/drivers/connector/Kconfig b/drivers/connector/Kconfig
new file mode 100644
index 000000000000..0bc2059c1e08
--- /dev/null
+++ b/drivers/connector/Kconfig
@@ -0,0 +1,13 @@
1menu "Connector - unified userspace <-> kernelspace linker"
2
3config CONNECTOR
4 tristate "Connector - unified userspace <-> kernelspace linker"
5 depends on NET
6 ---help---
7 This is unified userspace <-> kernelspace connector working on top
8 of the netlink socket protocol.
9
10 Connector support can also be built as a module. If so, the module
11 will be called cn.ko.
12
13endmenu
diff --git a/drivers/connector/Makefile b/drivers/connector/Makefile
new file mode 100644
index 000000000000..12ca79e8234d
--- /dev/null
+++ b/drivers/connector/Makefile
@@ -0,0 +1,3 @@
1obj-$(CONFIG_CONNECTOR) += cn.o
2
3cn-y += cn_queue.o connector.o
diff --git a/drivers/connector/cn_queue.c b/drivers/connector/cn_queue.c
new file mode 100644
index 000000000000..966632182e2d
--- /dev/null
+++ b/drivers/connector/cn_queue.c
@@ -0,0 +1,173 @@
1/*
2 * cn_queue.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
23#include <linux/kernel.h>
24#include <linux/module.h>
25#include <linux/list.h>
26#include <linux/workqueue.h>
27#include <linux/spinlock.h>
28#include <linux/slab.h>
29#include <linux/skbuff.h>
30#include <linux/suspend.h>
31#include <linux/connector.h>
32#include <linux/delay.h>
33
34static void cn_queue_wrapper(void *data)
35{
36 struct cn_callback_entry *cbq = data;
37
38 cbq->cb->callback(cbq->cb->priv);
39 cbq->destruct_data(cbq->ddata);
40 cbq->ddata = NULL;
41}
42
43static struct cn_callback_entry *cn_queue_alloc_callback_entry(struct cn_callback *cb)
44{
45 struct cn_callback_entry *cbq;
46
47 cbq = kzalloc(sizeof(*cbq), GFP_KERNEL);
48 if (!cbq) {
49 printk(KERN_ERR "Failed to create new callback queue.\n");
50 return NULL;
51 }
52
53 cbq->cb = cb;
54 INIT_WORK(&cbq->work, &cn_queue_wrapper, cbq);
55 return cbq;
56}
57
58static void cn_queue_free_callback(struct cn_callback_entry *cbq)
59{
60 cancel_delayed_work(&cbq->work);
61 flush_workqueue(cbq->pdev->cn_queue);
62
63 kfree(cbq);
64}
65
66int cn_cb_equal(struct cb_id *i1, struct cb_id *i2)
67{
68 return ((i1->idx == i2->idx) && (i1->val == i2->val));
69}
70
71int cn_queue_add_callback(struct cn_queue_dev *dev, struct cn_callback *cb)
72{
73 struct cn_callback_entry *cbq, *__cbq;
74 int found = 0;
75
76 cbq = cn_queue_alloc_callback_entry(cb);
77 if (!cbq)
78 return -ENOMEM;
79
80 atomic_inc(&dev->refcnt);
81 cbq->pdev = dev;
82
83 spin_lock_bh(&dev->queue_lock);
84 list_for_each_entry(__cbq, &dev->queue_list, callback_entry) {
85 if (cn_cb_equal(&__cbq->cb->id, &cb->id)) {
86 found = 1;
87 break;
88 }
89 }
90 if (!found)
91 list_add_tail(&cbq->callback_entry, &dev->queue_list);
92 spin_unlock_bh(&dev->queue_lock);
93
94 if (found) {
95 atomic_dec(&dev->refcnt);
96 cn_queue_free_callback(cbq);
97 return -EINVAL;
98 }
99
100 cbq->nls = dev->nls;
101 cbq->seq = 0;
102 cbq->group = cbq->cb->id.idx;
103
104 return 0;
105}
106
107void cn_queue_del_callback(struct cn_queue_dev *dev, struct cb_id *id)
108{
109 struct cn_callback_entry *cbq, *n;
110 int found = 0;
111
112 spin_lock_bh(&dev->queue_lock);
113 list_for_each_entry_safe(cbq, n, &dev->queue_list, callback_entry) {
114 if (cn_cb_equal(&cbq->cb->id, id)) {
115 list_del(&cbq->callback_entry);
116 found = 1;
117 break;
118 }
119 }
120 spin_unlock_bh(&dev->queue_lock);
121
122 if (found) {
123 cn_queue_free_callback(cbq);
124 atomic_dec_and_test(&dev->refcnt);
125 }
126}
127
128struct cn_queue_dev *cn_queue_alloc_dev(char *name, struct sock *nls)
129{
130 struct cn_queue_dev *dev;
131
132 dev = kzalloc(sizeof(*dev), GFP_KERNEL);
133 if (!dev)
134 return NULL;
135
136 snprintf(dev->name, sizeof(dev->name), "%s", name);
137 atomic_set(&dev->refcnt, 0);
138 INIT_LIST_HEAD(&dev->queue_list);
139 spin_lock_init(&dev->queue_lock);
140
141 dev->nls = nls;
142 dev->netlink_groups = 0;
143
144 dev->cn_queue = create_workqueue(dev->name);
145 if (!dev->cn_queue) {
146 kfree(dev);
147 return NULL;
148 }
149
150 return dev;
151}
152
153void cn_queue_free_dev(struct cn_queue_dev *dev)
154{
155 struct cn_callback_entry *cbq, *n;
156
157 flush_workqueue(dev->cn_queue);
158 destroy_workqueue(dev->cn_queue);
159
160 spin_lock_bh(&dev->queue_lock);
161 list_for_each_entry_safe(cbq, n, &dev->queue_list, callback_entry)
162 list_del(&cbq->callback_entry);
163 spin_unlock_bh(&dev->queue_lock);
164
165 while (atomic_read(&dev->refcnt)) {
166 printk(KERN_INFO "Waiting for %s to become free: refcnt=%d.\n",
167 dev->name, atomic_read(&dev->refcnt));
168 msleep(1000);
169 }
170
171 kfree(dev);
172 dev = NULL;
173}
diff --git a/drivers/connector/connector.c b/drivers/connector/connector.c
new file mode 100644
index 000000000000..aaf6d468a8b9
--- /dev/null
+++ b/drivers/connector/connector.c
@@ -0,0 +1,486 @@
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
32MODULE_LICENSE("GPL");
33MODULE_AUTHOR("Evgeniy Polyakov <johnpol@2ka.mipt.ru>");
34MODULE_DESCRIPTION("Generic userspace <-> kernelspace connector.");
35
36static u32 cn_idx = CN_IDX_CONNECTOR;
37static u32 cn_val = CN_VAL_CONNECTOR;
38
39module_param(cn_idx, uint, 0);
40module_param(cn_val, uint, 0);
41MODULE_PARM_DESC(cn_idx, "Connector's main device idx.");
42MODULE_PARM_DESC(cn_val, "Connector's main device val.");
43
44static DECLARE_MUTEX(notify_lock);
45static LIST_HEAD(notify_list);
46
47static struct cn_dev cdev;
48
49int 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 */
72int cn_netlink_send(struct cn_msg *msg, u32 __group, int gfp_mask)
73{
74 struct cn_callback_entry *__cbq;
75 unsigned int size;
76 struct sk_buff *skb;
77 struct nlmsghdr *nlh;
78 struct cn_msg *data;
79 struct cn_dev *dev = &cdev;
80 u32 group = 0;
81 int found = 0;
82
83 if (!__group) {
84 spin_lock_bh(&dev->cbdev->queue_lock);
85 list_for_each_entry(__cbq, &dev->cbdev->queue_list,
86 callback_entry) {
87 if (cn_cb_equal(&__cbq->cb->id, &msg->id)) {
88 found = 1;
89 group = __cbq->group;
90 }
91 }
92 spin_unlock_bh(&dev->cbdev->queue_lock);
93
94 if (!found)
95 return -ENODEV;
96 } else {
97 group = __group;
98 }
99
100 size = NLMSG_SPACE(sizeof(*msg) + msg->len);
101
102 skb = alloc_skb(size, gfp_mask);
103 if (!skb)
104 return -ENOMEM;
105
106 nlh = NLMSG_PUT(skb, 0, msg->seq, NLMSG_DONE, size - sizeof(*nlh));
107
108 data = NLMSG_DATA(nlh);
109
110 memcpy(data, msg, sizeof(*data) + msg->len);
111
112 NETLINK_CB(skb).dst_group = group;
113
114 netlink_broadcast(dev->nls, skb, 0, group, gfp_mask);
115
116 return 0;
117
118nlmsg_failure:
119 kfree_skb(skb);
120 return -EINVAL;
121}
122
123/*
124 * Callback helper - queues work and setup destructor for given data.
125 */
126static int cn_call_callback(struct cn_msg *msg, void (*destruct_data)(void *), void *data)
127{
128 struct cn_callback_entry *__cbq;
129 struct cn_dev *dev = &cdev;
130 int found = 0;
131
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->cb->id, &msg->id)) {
135 /*
136 * Let's scream if there is some magic and the
137 * data will arrive asynchronously here.
138 * [i.e. netlink messages will be queued].
139 * After the first warning I will fix it
140 * quickly, but now I think it is
141 * impossible. --zbr (2004_04_27).
142 */
143 if (likely(!test_bit(0, &__cbq->work.pending) &&
144 __cbq->ddata == NULL)) {
145 __cbq->cb->priv = msg;
146
147 __cbq->ddata = data;
148 __cbq->destruct_data = destruct_data;
149
150 if (queue_work(dev->cbdev->cn_queue,
151 &__cbq->work))
152 found = 1;
153 } else {
154 printk("%s: cbq->data=%p, "
155 "work->pending=%08lx.\n",
156 __func__, __cbq->ddata,
157 __cbq->work.pending);
158 WARN_ON(1);
159 }
160 break;
161 }
162 }
163 spin_unlock_bh(&dev->cbdev->queue_lock);
164
165 return found ? 0 : -ENODEV;
166}
167
168/*
169 * Skb receive helper - checks skb and msg size and calls callback
170 * helper.
171 */
172static int __cn_rx_skb(struct sk_buff *skb, struct nlmsghdr *nlh)
173{
174 u32 pid, uid, seq, group;
175 struct cn_msg *msg;
176
177 pid = NETLINK_CREDS(skb)->pid;
178 uid = NETLINK_CREDS(skb)->uid;
179 seq = nlh->nlmsg_seq;
180 group = NETLINK_CB((skb)).dst_group;
181 msg = NLMSG_DATA(nlh);
182
183 return cn_call_callback(msg, (void (*)(void *))kfree_skb, skb);
184}
185
186/*
187 * Main netlink receiving function.
188 *
189 * It checks skb and netlink header sizes and calls the skb receive
190 * helper with a shared skb.
191 */
192static void cn_rx_skb(struct sk_buff *__skb)
193{
194 struct nlmsghdr *nlh;
195 u32 len;
196 int err;
197 struct sk_buff *skb;
198
199 skb = skb_get(__skb);
200
201 if (skb->len >= NLMSG_SPACE(0)) {
202 nlh = (struct nlmsghdr *)skb->data;
203
204 if (nlh->nlmsg_len < sizeof(struct cn_msg) ||
205 skb->len < nlh->nlmsg_len ||
206 nlh->nlmsg_len > CONNECTOR_MAX_MSG_SIZE) {
207 kfree_skb(skb);
208 goto out;
209 }
210
211 len = NLMSG_ALIGN(nlh->nlmsg_len);
212 if (len > skb->len)
213 len = skb->len;
214
215 err = __cn_rx_skb(skb, nlh);
216 if (err < 0)
217 kfree_skb(skb);
218 }
219
220out:
221 kfree_skb(__skb);
222}
223
224/*
225 * Netlink socket input callback - dequeues the skbs and calls the
226 * main netlink receiving function.
227 */
228static void cn_input(struct sock *sk, int len)
229{
230 struct sk_buff *skb;
231
232 while ((skb = skb_dequeue(&sk->sk_receive_queue)) != NULL)
233 cn_rx_skb(skb);
234}
235
236/*
237 * Notification routing.
238 *
239 * Gets id and checks if there are notification request for it's idx
240 * and val. If there are such requests notify the listeners with the
241 * given notify event.
242 *
243 */
244static void cn_notify(struct cb_id *id, u32 notify_event)
245{
246 struct cn_ctl_entry *ent;
247
248 down(&notify_lock);
249 list_for_each_entry(ent, &notify_list, notify_entry) {
250 int i;
251 struct cn_notify_req *req;
252 struct cn_ctl_msg *ctl = ent->msg;
253 int idx_found, val_found;
254
255 idx_found = val_found = 0;
256
257 req = (struct cn_notify_req *)ctl->data;
258 for (i = 0; i < ctl->idx_notify_num; ++i, ++req) {
259 if (id->idx >= req->first &&
260 id->idx < req->first + req->range) {
261 idx_found = 1;
262 break;
263 }
264 }
265
266 for (i = 0; i < ctl->val_notify_num; ++i, ++req) {
267 if (id->val >= req->first &&
268 id->val < req->first + req->range) {
269 val_found = 1;
270 break;
271 }
272 }
273
274 if (idx_found && val_found) {
275 struct cn_msg m = { .ack = notify_event, };
276
277 memcpy(&m.id, id, sizeof(m.id));
278 cn_netlink_send(&m, ctl->group, GFP_KERNEL);
279 }
280 }
281 up(&notify_lock);
282}
283
284/*
285 * Callback add routing - adds callback with given ID and name.
286 * If there is registered callback with the same ID it will not be added.
287 *
288 * May sleep.
289 */
290int cn_add_callback(struct cb_id *id, char *name, void (*callback)(void *))
291{
292 int err;
293 struct cn_dev *dev = &cdev;
294 struct cn_callback *cb;
295
296 cb = kzalloc(sizeof(*cb), GFP_KERNEL);
297 if (!cb)
298 return -ENOMEM;
299
300 scnprintf(cb->name, sizeof(cb->name), "%s", name);
301
302 memcpy(&cb->id, id, sizeof(cb->id));
303 cb->callback = callback;
304
305 err = cn_queue_add_callback(dev->cbdev, cb);
306 if (err) {
307 kfree(cb);
308 return err;
309 }
310
311 cn_notify(id, 0);
312
313 return 0;
314}
315
316/*
317 * Callback remove routing - removes callback
318 * with given ID.
319 * If there is no registered callback with given
320 * ID nothing happens.
321 *
322 * May sleep while waiting for reference counter to become zero.
323 */
324void cn_del_callback(struct cb_id *id)
325{
326 struct cn_dev *dev = &cdev;
327
328 cn_queue_del_callback(dev->cbdev, id);
329 cn_notify(id, 1);
330}
331
332/*
333 * Checks two connector's control messages to be the same.
334 * Returns 1 if they are the same or if the first one is corrupted.
335 */
336static int cn_ctl_msg_equals(struct cn_ctl_msg *m1, struct cn_ctl_msg *m2)
337{
338 int i;
339 struct cn_notify_req *req1, *req2;
340
341 if (m1->idx_notify_num != m2->idx_notify_num)
342 return 0;
343
344 if (m1->val_notify_num != m2->val_notify_num)
345 return 0;
346
347 if (m1->len != m2->len)
348 return 0;
349
350 if ((m1->idx_notify_num + m1->val_notify_num) * sizeof(*req1) !=
351 m1->len)
352 return 1;
353
354 req1 = (struct cn_notify_req *)m1->data;
355 req2 = (struct cn_notify_req *)m2->data;
356
357 for (i = 0; i < m1->idx_notify_num; ++i) {
358 if (req1->first != req2->first || req1->range != req2->range)
359 return 0;
360 req1++;
361 req2++;
362 }
363
364 for (i = 0; i < m1->val_notify_num; ++i) {
365 if (req1->first != req2->first || req1->range != req2->range)
366 return 0;
367 req1++;
368 req2++;
369 }
370
371 return 1;
372}
373
374/*
375 * Main connector device's callback.
376 *
377 * Used for notification of a request's processing.
378 */
379static void cn_callback(void *data)
380{
381 struct cn_msg *msg = data;
382 struct cn_ctl_msg *ctl;
383 struct cn_ctl_entry *ent;
384 u32 size;
385
386 if (msg->len < sizeof(*ctl))
387 return;
388
389 ctl = (struct cn_ctl_msg *)msg->data;
390
391 size = (sizeof(*ctl) + ((ctl->idx_notify_num +
392 ctl->val_notify_num) *
393 sizeof(struct cn_notify_req)));
394
395 if (msg->len != size)
396 return;
397
398 if (ctl->len + sizeof(*ctl) != msg->len)
399 return;
400
401 /*
402 * Remove notification.
403 */
404 if (ctl->group == 0) {
405 struct cn_ctl_entry *n;
406
407 down(&notify_lock);
408 list_for_each_entry_safe(ent, n, &notify_list, notify_entry) {
409 if (cn_ctl_msg_equals(ent->msg, ctl)) {
410 list_del(&ent->notify_entry);
411 kfree(ent);
412 }
413 }
414 up(&notify_lock);
415
416 return;
417 }
418
419 size += sizeof(*ent);
420
421 ent = kzalloc(size, GFP_KERNEL);
422 if (!ent)
423 return;
424
425 ent->msg = (struct cn_ctl_msg *)(ent + 1);
426
427 memcpy(ent->msg, ctl, size - sizeof(*ent));
428
429 down(&notify_lock);
430 list_add(&ent->notify_entry, &notify_list);
431 up(&notify_lock);
432}
433
434static int __init cn_init(void)
435{
436 struct cn_dev *dev = &cdev;
437 int err;
438
439 dev->input = cn_input;
440 dev->id.idx = cn_idx;
441 dev->id.val = cn_val;
442
443 dev->nls = netlink_kernel_create(NETLINK_CONNECTOR,
444 CN_NETLINK_USERS + 0xf,
445 dev->input, THIS_MODULE);
446 if (!dev->nls)
447 return -EIO;
448
449 dev->cbdev = cn_queue_alloc_dev("cqueue", dev->nls);
450 if (!dev->cbdev) {
451 if (dev->nls->sk_socket)
452 sock_release(dev->nls->sk_socket);
453 return -EINVAL;
454 }
455
456 err = cn_add_callback(&dev->id, "connector", &cn_callback);
457 if (err) {
458 cn_queue_free_dev(dev->cbdev);
459 if (dev->nls->sk_socket)
460 sock_release(dev->nls->sk_socket);
461 return -EINVAL;
462 }
463
464 cn_already_initialized = 1;
465
466 return 0;
467}
468
469static void __exit cn_fini(void)
470{
471 struct cn_dev *dev = &cdev;
472
473 cn_already_initialized = 0;
474
475 cn_del_callback(&dev->id);
476 cn_queue_free_dev(dev->cbdev);
477 if (dev->nls->sk_socket)
478 sock_release(dev->nls->sk_socket);
479}
480
481module_init(cn_init);
482module_exit(cn_fini);
483
484EXPORT_SYMBOL_GPL(cn_add_callback);
485EXPORT_SYMBOL_GPL(cn_del_callback);
486EXPORT_SYMBOL_GPL(cn_netlink_send);
diff --git a/drivers/net/bnx2.c b/drivers/net/bnx2.c
index 83598e32179c..3a2ace01e444 100644
--- a/drivers/net/bnx2.c
+++ b/drivers/net/bnx2.c
@@ -5015,6 +5015,7 @@ static struct ethtool_ops bnx2_ethtool_ops = {
5015 .phys_id = bnx2_phys_id, 5015 .phys_id = bnx2_phys_id,
5016 .get_stats_count = bnx2_get_stats_count, 5016 .get_stats_count = bnx2_get_stats_count,
5017 .get_ethtool_stats = bnx2_get_ethtool_stats, 5017 .get_ethtool_stats = bnx2_get_ethtool_stats,
5018 .get_perm_addr = ethtool_op_get_perm_addr,
5018}; 5019};
5019 5020
5020/* Called with rtnl_lock */ 5021/* Called with rtnl_lock */
@@ -5442,6 +5443,7 @@ bnx2_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
5442 pci_set_drvdata(pdev, dev); 5443 pci_set_drvdata(pdev, dev);
5443 5444
5444 memcpy(dev->dev_addr, bp->mac_addr, 6); 5445 memcpy(dev->dev_addr, bp->mac_addr, 6);
5446 memcpy(dev->perm_addr, bp->mac_addr, 6);
5445 bp->name = board_info[ent->driver_data].name, 5447 bp->name = board_info[ent->driver_data].name,
5446 printk(KERN_INFO "%s: %s (%c%d) PCI%s %s %dMHz found at mem %lx, " 5448 printk(KERN_INFO "%s: %s (%c%d) PCI%s %s %dMHz found at mem %lx, "
5447 "IRQ %d, ", 5449 "IRQ %d, ",
diff --git a/drivers/net/hamradio/6pack.c b/drivers/net/hamradio/6pack.c
index 0b230222bfea..90999867a32c 100644
--- a/drivers/net/hamradio/6pack.c
+++ b/drivers/net/hamradio/6pack.c
@@ -293,7 +293,7 @@ static int sp_header(struct sk_buff *skb, struct net_device *dev,
293{ 293{
294#ifdef CONFIG_INET 294#ifdef CONFIG_INET
295 if (type != htons(ETH_P_AX25)) 295 if (type != htons(ETH_P_AX25))
296 return ax25_encapsulate(skb, dev, type, daddr, saddr, len); 296 return ax25_hard_header(skb, dev, type, daddr, saddr, len);
297#endif 297#endif
298 return 0; 298 return 0;
299} 299}
diff --git a/drivers/net/hamradio/baycom_epp.c b/drivers/net/hamradio/baycom_epp.c
index 5298096afbdb..e4188d082f01 100644
--- a/drivers/net/hamradio/baycom_epp.c
+++ b/drivers/net/hamradio/baycom_epp.c
@@ -40,7 +40,7 @@
40 40
41/*****************************************************************************/ 41/*****************************************************************************/
42 42
43#include <linux/config.h> 43#include <linux/crc-ccitt.h>
44#include <linux/module.h> 44#include <linux/module.h>
45#include <linux/kernel.h> 45#include <linux/kernel.h>
46#include <linux/init.h> 46#include <linux/init.h>
@@ -48,18 +48,12 @@
48#include <linux/workqueue.h> 48#include <linux/workqueue.h>
49#include <linux/fs.h> 49#include <linux/fs.h>
50#include <linux/parport.h> 50#include <linux/parport.h>
51#include <linux/smp_lock.h>
52#include <asm/uaccess.h>
53#include <linux/if_arp.h> 51#include <linux/if_arp.h>
54#include <linux/kmod.h>
55#include <linux/hdlcdrv.h> 52#include <linux/hdlcdrv.h>
56#include <linux/baycom.h> 53#include <linux/baycom.h>
57#include <linux/jiffies.h> 54#include <linux/jiffies.h>
58#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
59/* prototypes for ax25_encapsulate and ax25_rebuild_header */
60#include <net/ax25.h> 55#include <net/ax25.h>
61#endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */ 56#include <asm/uaccess.h>
62#include <linux/crc-ccitt.h>
63 57
64/* --------------------------------------------------------------------- */ 58/* --------------------------------------------------------------------- */
65 59
@@ -1177,13 +1171,8 @@ static void baycom_probe(struct net_device *dev)
1177 /* Fill in the fields of the device structure */ 1171 /* Fill in the fields of the device structure */
1178 bc->skb = NULL; 1172 bc->skb = NULL;
1179 1173
1180#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 1174 dev->hard_header = ax25_hard_header;
1181 dev->hard_header = ax25_encapsulate;
1182 dev->rebuild_header = ax25_rebuild_header; 1175 dev->rebuild_header = ax25_rebuild_header;
1183#else /* CONFIG_AX25 || CONFIG_AX25_MODULE */
1184 dev->hard_header = NULL;
1185 dev->rebuild_header = NULL;
1186#endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
1187 dev->set_mac_address = baycom_set_mac_address; 1176 dev->set_mac_address = baycom_set_mac_address;
1188 1177
1189 dev->type = ARPHRD_AX25; /* AF_AX25 device */ 1178 dev->type = ARPHRD_AX25; /* AF_AX25 device */
diff --git a/drivers/net/hamradio/bpqether.c b/drivers/net/hamradio/bpqether.c
index 2946e037a9b1..1756f0ed54cc 100644
--- a/drivers/net/hamradio/bpqether.c
+++ b/drivers/net/hamradio/bpqether.c
@@ -488,7 +488,7 @@ static void bpq_setup(struct net_device *dev)
488 dev->flags = 0; 488 dev->flags = 0;
489 489
490#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 490#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
491 dev->hard_header = ax25_encapsulate; 491 dev->hard_header = ax25_hard_header;
492 dev->rebuild_header = ax25_rebuild_header; 492 dev->rebuild_header = ax25_rebuild_header;
493#endif 493#endif
494 494
diff --git a/drivers/net/hamradio/dmascc.c b/drivers/net/hamradio/dmascc.c
index f515245a3fd0..3be3f916643a 100644
--- a/drivers/net/hamradio/dmascc.c
+++ b/drivers/net/hamradio/dmascc.c
@@ -449,12 +449,12 @@ module_exit(dmascc_exit);
449static void dev_setup(struct net_device *dev) 449static void dev_setup(struct net_device *dev)
450{ 450{
451 dev->type = ARPHRD_AX25; 451 dev->type = ARPHRD_AX25;
452 dev->hard_header_len = 73; 452 dev->hard_header_len = AX25_MAX_HEADER_LEN;
453 dev->mtu = 1500; 453 dev->mtu = 1500;
454 dev->addr_len = 7; 454 dev->addr_len = AX25_ADDR_LEN;
455 dev->tx_queue_len = 64; 455 dev->tx_queue_len = 64;
456 memcpy(dev->broadcast, ax25_broadcast, 7); 456 memcpy(dev->broadcast, ax25_broadcast, AX25_ADDR_LEN);
457 memcpy(dev->dev_addr, ax25_test, 7); 457 memcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);
458} 458}
459 459
460static int __init setup_adapter(int card_base, int type, int n) 460static int __init setup_adapter(int card_base, int type, int n)
@@ -600,7 +600,7 @@ static int __init setup_adapter(int card_base, int type, int n)
600 dev->do_ioctl = scc_ioctl; 600 dev->do_ioctl = scc_ioctl;
601 dev->hard_start_xmit = scc_send_packet; 601 dev->hard_start_xmit = scc_send_packet;
602 dev->get_stats = scc_get_stats; 602 dev->get_stats = scc_get_stats;
603 dev->hard_header = ax25_encapsulate; 603 dev->hard_header = ax25_hard_header;
604 dev->rebuild_header = ax25_rebuild_header; 604 dev->rebuild_header = ax25_rebuild_header;
605 dev->set_mac_address = scc_set_mac_address; 605 dev->set_mac_address = scc_set_mac_address;
606 } 606 }
diff --git a/drivers/net/hamradio/hdlcdrv.c b/drivers/net/hamradio/hdlcdrv.c
index b4c836e4fe86..dacc7687b97f 100644
--- a/drivers/net/hamradio/hdlcdrv.c
+++ b/drivers/net/hamradio/hdlcdrv.c
@@ -42,7 +42,6 @@
42 42
43/*****************************************************************************/ 43/*****************************************************************************/
44 44
45#include <linux/config.h>
46#include <linux/module.h> 45#include <linux/module.h>
47#include <linux/types.h> 46#include <linux/types.h>
48#include <linux/net.h> 47#include <linux/net.h>
@@ -52,20 +51,14 @@
52#include <linux/errno.h> 51#include <linux/errno.h>
53#include <linux/init.h> 52#include <linux/init.h>
54#include <linux/bitops.h> 53#include <linux/bitops.h>
55#include <asm/uaccess.h>
56 54
57#include <linux/netdevice.h> 55#include <linux/netdevice.h>
58#include <linux/if_arp.h> 56#include <linux/if_arp.h>
59#include <linux/etherdevice.h>
60#include <linux/skbuff.h> 57#include <linux/skbuff.h>
61#include <linux/hdlcdrv.h> 58#include <linux/hdlcdrv.h>
62/* prototypes for ax25_encapsulate and ax25_rebuild_header */
63#include <net/ax25.h> 59#include <net/ax25.h>
60#include <asm/uaccess.h>
64 61
65/* make genksyms happy */
66#include <linux/ip.h>
67#include <linux/udp.h>
68#include <linux/tcp.h>
69#include <linux/crc-ccitt.h> 62#include <linux/crc-ccitt.h>
70 63
71/* --------------------------------------------------------------------- */ 64/* --------------------------------------------------------------------- */
@@ -708,13 +701,8 @@ static void hdlcdrv_setup(struct net_device *dev)
708 701
709 s->skb = NULL; 702 s->skb = NULL;
710 703
711#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 704 dev->hard_header = ax25_hard_header;
712 dev->hard_header = ax25_encapsulate;
713 dev->rebuild_header = ax25_rebuild_header; 705 dev->rebuild_header = ax25_rebuild_header;
714#else /* CONFIG_AX25 || CONFIG_AX25_MODULE */
715 dev->hard_header = NULL;
716 dev->rebuild_header = NULL;
717#endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
718 dev->set_mac_address = hdlcdrv_set_mac_address; 706 dev->set_mac_address = hdlcdrv_set_mac_address;
719 707
720 dev->type = ARPHRD_AX25; /* AF_AX25 device */ 708 dev->type = ARPHRD_AX25; /* AF_AX25 device */
diff --git a/drivers/net/hamradio/mkiss.c b/drivers/net/hamradio/mkiss.c
index 63b1a2b86acb..d9fe64b46f4b 100644
--- a/drivers/net/hamradio/mkiss.c
+++ b/drivers/net/hamradio/mkiss.c
@@ -500,7 +500,7 @@ static int ax_header(struct sk_buff *skb, struct net_device *dev, unsigned short
500{ 500{
501#ifdef CONFIG_INET 501#ifdef CONFIG_INET
502 if (type != htons(ETH_P_AX25)) 502 if (type != htons(ETH_P_AX25))
503 return ax25_encapsulate(skb, dev, type, daddr, saddr, len); 503 return ax25_hard_header(skb, dev, type, daddr, saddr, len);
504#endif 504#endif
505 return 0; 505 return 0;
506} 506}
diff --git a/drivers/net/hamradio/scc.c b/drivers/net/hamradio/scc.c
index c27e417f32bf..6ace0e914fd1 100644
--- a/drivers/net/hamradio/scc.c
+++ b/drivers/net/hamradio/scc.c
@@ -1557,7 +1557,7 @@ static void scc_net_setup(struct net_device *dev)
1557 dev->stop = scc_net_close; 1557 dev->stop = scc_net_close;
1558 1558
1559 dev->hard_start_xmit = scc_net_tx; 1559 dev->hard_start_xmit = scc_net_tx;
1560 dev->hard_header = ax25_encapsulate; 1560 dev->hard_header = ax25_hard_header;
1561 dev->rebuild_header = ax25_rebuild_header; 1561 dev->rebuild_header = ax25_rebuild_header;
1562 dev->set_mac_address = scc_net_set_mac_address; 1562 dev->set_mac_address = scc_net_set_mac_address;
1563 dev->get_stats = scc_net_get_stats; 1563 dev->get_stats = scc_net_get_stats;
diff --git a/drivers/net/hamradio/yam.c b/drivers/net/hamradio/yam.c
index f52ee3162c51..fe22479eb202 100644
--- a/drivers/net/hamradio/yam.c
+++ b/drivers/net/hamradio/yam.c
@@ -60,15 +60,7 @@
60#include <linux/if_arp.h> 60#include <linux/if_arp.h>
61#include <linux/etherdevice.h> 61#include <linux/etherdevice.h>
62#include <linux/skbuff.h> 62#include <linux/skbuff.h>
63#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE)
64/* prototypes for ax25_encapsulate and ax25_rebuild_header */
65#include <net/ax25.h> 63#include <net/ax25.h>
66#endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
67
68/* make genksyms happy */
69#include <linux/ip.h>
70#include <linux/udp.h>
71#include <linux/tcp.h>
72 64
73#include <linux/kernel.h> 65#include <linux/kernel.h>
74#include <linux/proc_fs.h> 66#include <linux/proc_fs.h>
@@ -1116,23 +1108,17 @@ static void yam_setup(struct net_device *dev)
1116 1108
1117 skb_queue_head_init(&yp->send_queue); 1109 skb_queue_head_init(&yp->send_queue);
1118 1110
1119#if defined(CONFIG_AX25) || defined(CONFIG_AX25_MODULE) 1111 dev->hard_header = ax25_hard_header;
1120 dev->hard_header = ax25_encapsulate;
1121 dev->rebuild_header = ax25_rebuild_header; 1112 dev->rebuild_header = ax25_rebuild_header;
1122#else /* CONFIG_AX25 || CONFIG_AX25_MODULE */
1123 dev->hard_header = NULL;
1124 dev->rebuild_header = NULL;
1125#endif /* CONFIG_AX25 || CONFIG_AX25_MODULE */
1126 1113
1127 dev->set_mac_address = yam_set_mac_address; 1114 dev->set_mac_address = yam_set_mac_address;
1128 1115
1129 dev->type = ARPHRD_AX25; /* AF_AX25 device */ 1116 dev->type = ARPHRD_AX25;
1130 dev->hard_header_len = 73; /* We do digipeaters now */ 1117 dev->hard_header_len = AX25_MAX_HEADER_LEN;
1131 dev->mtu = 256; /* AX25 is the default */ 1118 dev->mtu = AX25_MTU;
1132 dev->addr_len = 7; /* sizeof an ax.25 address */ 1119 dev->addr_len = AX25_ADDR_LEN;
1133 memcpy(dev->broadcast, ax25_bcast, 7); 1120 memcpy(dev->broadcast, ax25_bcast, AX25_ADDR_LEN);
1134 memcpy(dev->dev_addr, ax25_test, 7); 1121 memcpy(dev->dev_addr, ax25_test, AX25_ADDR_LEN);
1135
1136} 1122}
1137 1123
1138static int __init yam_init_driver(void) 1124static int __init yam_init_driver(void)
diff --git a/drivers/net/tg3.c b/drivers/net/tg3.c
index dc57352e5a97..7599f52e15b3 100644
--- a/drivers/net/tg3.c
+++ b/drivers/net/tg3.c
@@ -6893,8 +6893,7 @@ static struct net_device_stats *tg3_get_stats(struct net_device *dev)
6893 get_stat64(&hw_stats->tx_octets); 6893 get_stat64(&hw_stats->tx_octets);
6894 6894
6895 stats->rx_errors = old_stats->rx_errors + 6895 stats->rx_errors = old_stats->rx_errors +
6896 get_stat64(&hw_stats->rx_errors) + 6896 get_stat64(&hw_stats->rx_errors);
6897 get_stat64(&hw_stats->rx_discards);
6898 stats->tx_errors = old_stats->tx_errors + 6897 stats->tx_errors = old_stats->tx_errors +
6899 get_stat64(&hw_stats->tx_errors) + 6898 get_stat64(&hw_stats->tx_errors) +
6900 get_stat64(&hw_stats->tx_mac_errors) + 6899 get_stat64(&hw_stats->tx_mac_errors) +
@@ -6922,6 +6921,9 @@ static struct net_device_stats *tg3_get_stats(struct net_device *dev)
6922 stats->rx_crc_errors = old_stats->rx_crc_errors + 6921 stats->rx_crc_errors = old_stats->rx_crc_errors +
6923 calc_crc_errors(tp); 6922 calc_crc_errors(tp);
6924 6923
6924 stats->rx_missed_errors = old_stats->rx_missed_errors +
6925 get_stat64(&hw_stats->rx_discards);
6926
6925 return stats; 6927 return stats;
6926} 6928}
6927 6929
@@ -8303,6 +8305,7 @@ static struct ethtool_ops tg3_ethtool_ops = {
8303 .get_ethtool_stats = tg3_get_ethtool_stats, 8305 .get_ethtool_stats = tg3_get_ethtool_stats,
8304 .get_coalesce = tg3_get_coalesce, 8306 .get_coalesce = tg3_get_coalesce,
8305 .set_coalesce = tg3_set_coalesce, 8307 .set_coalesce = tg3_set_coalesce,
8308 .get_perm_addr = ethtool_op_get_perm_addr,
8306}; 8309};
8307 8310
8308static void __devinit tg3_get_eeprom_size(struct tg3 *tp) 8311static void __devinit tg3_get_eeprom_size(struct tg3 *tp)
@@ -9781,6 +9784,7 @@ static int __devinit tg3_get_macaddr_sparc(struct tg3 *tp)
9781 if (prom_getproplen(node, "local-mac-address") == 6) { 9784 if (prom_getproplen(node, "local-mac-address") == 6) {
9782 prom_getproperty(node, "local-mac-address", 9785 prom_getproperty(node, "local-mac-address",
9783 dev->dev_addr, 6); 9786 dev->dev_addr, 6);
9787 memcpy(dev->perm_addr, dev->dev_addr, 6);
9784 return 0; 9788 return 0;
9785 } 9789 }
9786 } 9790 }
@@ -9792,6 +9796,7 @@ static int __devinit tg3_get_default_macaddr_sparc(struct tg3 *tp)
9792 struct net_device *dev = tp->dev; 9796 struct net_device *dev = tp->dev;
9793 9797
9794 memcpy(dev->dev_addr, idprom->id_ethaddr, 6); 9798 memcpy(dev->dev_addr, idprom->id_ethaddr, 6);
9799 memcpy(dev->perm_addr, idprom->id_ethaddr, 6);
9795 return 0; 9800 return 0;
9796} 9801}
9797#endif 9802#endif
@@ -9861,6 +9866,7 @@ static int __devinit tg3_get_device_address(struct tg3 *tp)
9861#endif 9866#endif
9862 return -EINVAL; 9867 return -EINVAL;
9863 } 9868 }
9869 memcpy(dev->perm_addr, dev->dev_addr, dev->addr_len);
9864 return 0; 9870 return 0;
9865} 9871}
9866 9872
diff --git a/include/linux/connector.h b/include/linux/connector.h
new file mode 100644
index 000000000000..96de26301f84
--- /dev/null
+++ b/include/linux/connector.h
@@ -0,0 +1,158 @@
1/*
2 * connector.h
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#ifndef __CONNECTOR_H
23#define __CONNECTOR_H
24
25#include <asm/types.h>
26
27#define CN_IDX_CONNECTOR 0xffffffff
28#define CN_VAL_CONNECTOR 0xffffffff
29
30#define CN_NETLINK_USERS 1
31
32/*
33 * Maximum connector's message size.
34 */
35#define CONNECTOR_MAX_MSG_SIZE 1024
36
37/*
38 * idx and val are unique identifiers which
39 * are used for message routing and
40 * must be registered in connector.h for in-kernel usage.
41 */
42
43struct cb_id {
44 __u32 idx;
45 __u32 val;
46};
47
48struct cn_msg {
49 struct cb_id id;
50
51 __u32 seq;
52 __u32 ack;
53
54 __u16 len; /* Length of the following data */
55 __u16 flags;
56 __u8 data[0];
57};
58
59/*
60 * Notify structure - requests notification about
61 * registering/unregistering idx/val in range [first, first+range].
62 */
63struct cn_notify_req {
64 __u32 first;
65 __u32 range;
66};
67
68/*
69 * Main notification control message
70 * *_notify_num - number of appropriate cn_notify_req structures after
71 * this struct.
72 * group - notification receiver's idx.
73 * len - total length of the attached data.
74 */
75struct cn_ctl_msg {
76 __u32 idx_notify_num;
77 __u32 val_notify_num;
78 __u32 group;
79 __u32 len;
80 __u8 data[0];
81};
82
83#ifdef __KERNEL__
84
85#include <asm/atomic.h>
86
87#include <linux/list.h>
88#include <linux/workqueue.h>
89
90#include <net/sock.h>
91
92#define CN_CBQ_NAMELEN 32
93
94struct cn_queue_dev {
95 atomic_t refcnt;
96 unsigned char name[CN_CBQ_NAMELEN];
97
98 struct workqueue_struct *cn_queue;
99
100 struct list_head queue_list;
101 spinlock_t queue_lock;
102
103 int netlink_groups;
104 struct sock *nls;
105};
106
107struct cn_callback {
108 unsigned char name[CN_CBQ_NAMELEN];
109
110 struct cb_id id;
111 void (*callback) (void *);
112 void *priv;
113};
114
115struct cn_callback_entry {
116 struct list_head callback_entry;
117 struct cn_callback *cb;
118 struct work_struct work;
119 struct cn_queue_dev *pdev;
120
121 void (*destruct_data) (void *);
122 void *ddata;
123
124 int seq, group;
125 struct sock *nls;
126};
127
128struct cn_ctl_entry {
129 struct list_head notify_entry;
130 struct cn_ctl_msg *msg;
131};
132
133struct cn_dev {
134 struct cb_id id;
135
136 u32 seq, groups;
137 struct sock *nls;
138 void (*input) (struct sock * sk, int len);
139
140 struct cn_queue_dev *cbdev;
141};
142
143int cn_add_callback(struct cb_id *, char *, void (*callback) (void *));
144void cn_del_callback(struct cb_id *);
145int cn_netlink_send(struct cn_msg *, u32, int);
146
147int cn_queue_add_callback(struct cn_queue_dev *dev, struct cn_callback *cb);
148void cn_queue_del_callback(struct cn_queue_dev *dev, struct cb_id *id);
149
150struct cn_queue_dev *cn_queue_alloc_dev(char *name, struct sock *);
151void cn_queue_free_dev(struct cn_queue_dev *dev);
152
153int cn_cb_equal(struct cb_id *, struct cb_id *);
154
155extern int cn_already_initialized;
156
157#endif /* __KERNEL__ */
158#endif /* __CONNECTOR_H */
diff --git a/include/linux/netlink.h b/include/linux/netlink.h
index 167518668936..7bbd25970c9e 100644
--- a/include/linux/netlink.h
+++ b/include/linux/netlink.h
@@ -15,6 +15,7 @@
15#define NETLINK_ISCSI 8 /* Open-iSCSI */ 15#define NETLINK_ISCSI 8 /* Open-iSCSI */
16#define NETLINK_AUDIT 9 /* auditing */ 16#define NETLINK_AUDIT 9 /* auditing */
17#define NETLINK_FIB_LOOKUP 10 17#define NETLINK_FIB_LOOKUP 10
18#define NETLINK_CONNECTOR 11
18#define NETLINK_NETFILTER 12 /* netfilter subsystem */ 19#define NETLINK_NETFILTER 12 /* netfilter subsystem */
19#define NETLINK_IP6_FW 13 20#define NETLINK_IP6_FW 13
20#define NETLINK_DNRTMSG 14 /* DECnet routing messages */ 21#define NETLINK_DNRTMSG 14 /* DECnet routing messages */
diff --git a/include/linux/sysctl.h b/include/linux/sysctl.h
index 532a6c5c24e9..3a29a9f9b451 100644
--- a/include/linux/sysctl.h
+++ b/include/linux/sysctl.h
@@ -544,7 +544,8 @@ enum {
544 NET_NETROM_TRANSPORT_REQUESTED_WINDOW_SIZE=8, 544 NET_NETROM_TRANSPORT_REQUESTED_WINDOW_SIZE=8,
545 NET_NETROM_TRANSPORT_NO_ACTIVITY_TIMEOUT=9, 545 NET_NETROM_TRANSPORT_NO_ACTIVITY_TIMEOUT=9,
546 NET_NETROM_ROUTING_CONTROL=10, 546 NET_NETROM_ROUTING_CONTROL=10,
547 NET_NETROM_LINK_FAILS_COUNT=11 547 NET_NETROM_LINK_FAILS_COUNT=11,
548 NET_NETROM_RESET=12
548}; 549};
549 550
550/* /proc/sys/net/ax25 */ 551/* /proc/sys/net/ax25 */
diff --git a/include/net/ax25.h b/include/net/ax25.h
index 227d3378decd..9dbcd9e51c00 100644
--- a/include/net/ax25.h
+++ b/include/net/ax25.h
@@ -26,11 +26,20 @@
26 26
27/* AX.25 Protocol IDs */ 27/* AX.25 Protocol IDs */
28#define AX25_P_ROSE 0x01 28#define AX25_P_ROSE 0x01
29#define AX25_P_IP 0xCC 29#define AX25_P_VJCOMP 0x06 /* Compressed TCP/IP packet */
30#define AX25_P_ARP 0xCD 30 /* Van Jacobsen (RFC 1144) */
31#define AX25_P_TEXT 0xF0 31#define AX25_P_VJUNCOMP 0x07 /* Uncompressed TCP/IP packet */
32#define AX25_P_NETROM 0xCF 32 /* Van Jacobsen (RFC 1144) */
33#define AX25_P_SEGMENT 0x08 33#define AX25_P_SEGMENT 0x08 /* Segmentation fragment */
34#define AX25_P_TEXNET 0xc3 /* TEXTNET datagram protocol */
35#define AX25_P_LQ 0xc4 /* Link Quality Protocol */
36#define AX25_P_ATALK 0xca /* Appletalk */
37#define AX25_P_ATALK_ARP 0xcb /* Appletalk ARP */
38#define AX25_P_IP 0xcc /* ARPA Internet Protocol */
39#define AX25_P_ARP 0xcd /* ARPA Adress Resolution */
40#define AX25_P_FLEXNET 0xce /* FlexNet */
41#define AX25_P_NETROM 0xcf /* NET/ROM */
42#define AX25_P_TEXT 0xF0 /* No layer 3 protocol impl. */
34 43
35/* AX.25 Segment control values */ 44/* AX.25 Segment control values */
36#define AX25_SEG_REM 0x7F 45#define AX25_SEG_REM 0x7F
@@ -88,11 +97,11 @@
88/* Define Link State constants. */ 97/* Define Link State constants. */
89 98
90enum { 99enum {
91 AX25_STATE_0, 100 AX25_STATE_0, /* Listening */
92 AX25_STATE_1, 101 AX25_STATE_1, /* SABM sent */
93 AX25_STATE_2, 102 AX25_STATE_2, /* DISC sent */
94 AX25_STATE_3, 103 AX25_STATE_3, /* Established */
95 AX25_STATE_4 104 AX25_STATE_4 /* Recovery */
96}; 105};
97 106
98#define AX25_MODULUS 8 /* Standard AX.25 modulus */ 107#define AX25_MODULUS 8 /* Standard AX.25 modulus */
@@ -319,7 +328,7 @@ extern int ax25_rx_iframe(ax25_cb *, struct sk_buff *);
319extern int ax25_kiss_rcv(struct sk_buff *, struct net_device *, struct packet_type *, struct net_device *); 328extern int ax25_kiss_rcv(struct sk_buff *, struct net_device *, struct packet_type *, struct net_device *);
320 329
321/* ax25_ip.c */ 330/* ax25_ip.c */
322extern int ax25_encapsulate(struct sk_buff *, struct net_device *, unsigned short, void *, void *, unsigned int); 331extern int ax25_hard_header(struct sk_buff *, struct net_device *, unsigned short, void *, void *, unsigned int);
323extern int ax25_rebuild_header(struct sk_buff *); 332extern int ax25_rebuild_header(struct sk_buff *);
324 333
325/* ax25_out.c */ 334/* ax25_out.c */
diff --git a/include/net/netrom.h b/include/net/netrom.h
index 45f2c7616d8b..a6bf6e0f606a 100644
--- a/include/net/netrom.h
+++ b/include/net/netrom.h
@@ -6,6 +6,7 @@
6 6
7#ifndef _NETROM_H 7#ifndef _NETROM_H
8#define _NETROM_H 8#define _NETROM_H
9
9#include <linux/netrom.h> 10#include <linux/netrom.h>
10#include <linux/list.h> 11#include <linux/list.h>
11#include <net/sock.h> 12#include <net/sock.h>
@@ -22,6 +23,7 @@
22#define NR_DISCACK 0x04 23#define NR_DISCACK 0x04
23#define NR_INFO 0x05 24#define NR_INFO 0x05
24#define NR_INFOACK 0x06 25#define NR_INFOACK 0x06
26#define NR_RESET 0x07
25 27
26#define NR_CHOKE_FLAG 0x80 28#define NR_CHOKE_FLAG 0x80
27#define NR_NAK_FLAG 0x40 29#define NR_NAK_FLAG 0x40
@@ -51,11 +53,16 @@ enum {
51#define NR_DEFAULT_TTL 16 /* Default Time To Live - 16 */ 53#define NR_DEFAULT_TTL 16 /* Default Time To Live - 16 */
52#define NR_DEFAULT_ROUTING 1 /* Is routing enabled ? */ 54#define NR_DEFAULT_ROUTING 1 /* Is routing enabled ? */
53#define NR_DEFAULT_FAILS 2 /* Link fails until route fails */ 55#define NR_DEFAULT_FAILS 2 /* Link fails until route fails */
56#define NR_DEFAULT_RESET 0 /* Sent / accept reset cmds? */
54 57
55#define NR_MODULUS 256 58#define NR_MODULUS 256
56#define NR_MAX_WINDOW_SIZE 127 /* Maximum Window Allowable - 127 */ 59#define NR_MAX_WINDOW_SIZE 127 /* Maximum Window Allowable - 127 */
57#define NR_MAX_PACKET_SIZE 236 /* Maximum Packet Length - 236 */ 60#define NR_MAX_PACKET_SIZE 236 /* Maximum Packet Length - 236 */
58 61
62struct nr_private {
63 struct net_device_stats stats;
64};
65
59struct nr_sock { 66struct nr_sock {
60 struct sock sock; 67 struct sock sock;
61 ax25_address user_addr, source_addr, dest_addr; 68 ax25_address user_addr, source_addr, dest_addr;
@@ -176,6 +183,8 @@ extern int sysctl_netrom_transport_requested_window_size;
176extern int sysctl_netrom_transport_no_activity_timeout; 183extern int sysctl_netrom_transport_no_activity_timeout;
177extern int sysctl_netrom_routing_control; 184extern int sysctl_netrom_routing_control;
178extern int sysctl_netrom_link_fails_count; 185extern int sysctl_netrom_link_fails_count;
186extern int sysctl_netrom_reset_circuit;
187
179extern int nr_rx_frame(struct sk_buff *, struct net_device *); 188extern int nr_rx_frame(struct sk_buff *, struct net_device *);
180extern void nr_destroy_socket(struct sock *); 189extern void nr_destroy_socket(struct sock *);
181 190
@@ -218,7 +227,28 @@ extern void nr_requeue_frames(struct sock *);
218extern int nr_validate_nr(struct sock *, unsigned short); 227extern int nr_validate_nr(struct sock *, unsigned short);
219extern int nr_in_rx_window(struct sock *, unsigned short); 228extern int nr_in_rx_window(struct sock *, unsigned short);
220extern void nr_write_internal(struct sock *, int); 229extern void nr_write_internal(struct sock *, int);
221extern void nr_transmit_refusal(struct sk_buff *, int); 230
231extern void __nr_transmit_reply(struct sk_buff *skb, int mine,
232 unsigned char cmdflags);
233
234/*
235 * This routine is called when a Connect Acknowledge with the Choke Flag
236 * set is needed to refuse a connection.
237 */
238#define nr_transmit_refusal(skb, mine) \
239do { \
240 __nr_transmit_reply((skb), (mine), NR_CONNACK | NR_CHOKE_FLAG); \
241} while (0)
242
243/*
244 * This routine is called when we don't have a circuit matching an incoming
245 * NET/ROM packet. This is an G8PZT Xrouter extension.
246 */
247#define nr_transmit_reset(skb, mine) \
248do { \
249 __nr_transmit_reply((skb), (mine), NR_RESET); \
250} while (0)
251
222extern void nr_disconnect(struct sock *, int); 252extern void nr_disconnect(struct sock *, int);
223 253
224/* nr_timer.c */ 254/* nr_timer.c */
diff --git a/net/ax25/af_ax25.c b/net/ax25/af_ax25.c
index ed705ddad56b..8e37e71e34ff 100644
--- a/net/ax25/af_ax25.c
+++ b/net/ax25/af_ax25.c
@@ -1695,16 +1695,12 @@ static int ax25_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1695 /* These two are safe on a single CPU system as only user tasks fiddle here */ 1695 /* These two are safe on a single CPU system as only user tasks fiddle here */
1696 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) 1696 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1697 amount = skb->len; 1697 amount = skb->len;
1698 res = put_user(amount, (int __user *)argp); 1698 res = put_user(amount, (int __user *) argp);
1699 break; 1699 break;
1700 } 1700 }
1701 1701
1702 case SIOCGSTAMP: 1702 case SIOCGSTAMP:
1703 if (sk != NULL) { 1703 res = sock_get_timestamp(sk, argp);
1704 res = sock_get_timestamp(sk, argp);
1705 break;
1706 }
1707 res = -EINVAL;
1708 break; 1704 break;
1709 1705
1710 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */ 1706 case SIOCAX25ADDUID: /* Add a uid to the uid/call map table */
@@ -1951,24 +1947,24 @@ static struct net_proto_family ax25_family_ops = {
1951}; 1947};
1952 1948
1953static struct proto_ops ax25_proto_ops = { 1949static struct proto_ops ax25_proto_ops = {
1954 .family = PF_AX25, 1950 .family = PF_AX25,
1955 .owner = THIS_MODULE, 1951 .owner = THIS_MODULE,
1956 .release = ax25_release, 1952 .release = ax25_release,
1957 .bind = ax25_bind, 1953 .bind = ax25_bind,
1958 .connect = ax25_connect, 1954 .connect = ax25_connect,
1959 .socketpair = sock_no_socketpair, 1955 .socketpair = sock_no_socketpair,
1960 .accept = ax25_accept, 1956 .accept = ax25_accept,
1961 .getname = ax25_getname, 1957 .getname = ax25_getname,
1962 .poll = datagram_poll, 1958 .poll = datagram_poll,
1963 .ioctl = ax25_ioctl, 1959 .ioctl = ax25_ioctl,
1964 .listen = ax25_listen, 1960 .listen = ax25_listen,
1965 .shutdown = ax25_shutdown, 1961 .shutdown = ax25_shutdown,
1966 .setsockopt = ax25_setsockopt, 1962 .setsockopt = ax25_setsockopt,
1967 .getsockopt = ax25_getsockopt, 1963 .getsockopt = ax25_getsockopt,
1968 .sendmsg = ax25_sendmsg, 1964 .sendmsg = ax25_sendmsg,
1969 .recvmsg = ax25_recvmsg, 1965 .recvmsg = ax25_recvmsg,
1970 .mmap = sock_no_mmap, 1966 .mmap = sock_no_mmap,
1971 .sendpage = sock_no_sendpage, 1967 .sendpage = sock_no_sendpage,
1972}; 1968};
1973 1969
1974/* 1970/*
@@ -1984,7 +1980,7 @@ static struct notifier_block ax25_dev_notifier = {
1984 .notifier_call =ax25_device_event, 1980 .notifier_call =ax25_device_event,
1985}; 1981};
1986 1982
1987EXPORT_SYMBOL(ax25_encapsulate); 1983EXPORT_SYMBOL(ax25_hard_header);
1988EXPORT_SYMBOL(ax25_rebuild_header); 1984EXPORT_SYMBOL(ax25_rebuild_header);
1989EXPORT_SYMBOL(ax25_findbyuid); 1985EXPORT_SYMBOL(ax25_findbyuid);
1990EXPORT_SYMBOL(ax25_find_cb); 1986EXPORT_SYMBOL(ax25_find_cb);
diff --git a/net/ax25/ax25_ip.c b/net/ax25/ax25_ip.c
index bba0173e2d65..d643dac3eccc 100644
--- a/net/ax25/ax25_ip.c
+++ b/net/ax25/ax25_ip.c
@@ -47,7 +47,7 @@
47 47
48#ifdef CONFIG_INET 48#ifdef CONFIG_INET
49 49
50int ax25_encapsulate(struct sk_buff *skb, struct net_device *dev, unsigned short type, void *daddr, void *saddr, unsigned len) 50int ax25_hard_header(struct sk_buff *skb, struct net_device *dev, unsigned short type, void *daddr, void *saddr, unsigned len)
51{ 51{
52 unsigned char *buff; 52 unsigned char *buff;
53 53
@@ -88,7 +88,7 @@ int ax25_encapsulate(struct sk_buff *skb, struct net_device *dev, unsigned short
88 *buff++ = AX25_P_ARP; 88 *buff++ = AX25_P_ARP;
89 break; 89 break;
90 default: 90 default:
91 printk(KERN_ERR "AX.25: ax25_encapsulate - wrong protocol type 0x%2.2x\n", type); 91 printk(KERN_ERR "AX.25: ax25_hard_header - wrong protocol type 0x%2.2x\n", type);
92 *buff++ = 0; 92 *buff++ = 0;
93 break; 93 break;
94 } 94 }
@@ -209,7 +209,7 @@ put:
209 209
210#else /* INET */ 210#else /* INET */
211 211
212int ax25_encapsulate(struct sk_buff *skb, struct net_device *dev, unsigned short type, void *daddr, void *saddr, unsigned len) 212int ax25_hard_header(struct sk_buff *skb, struct net_device *dev, unsigned short type, void *daddr, void *saddr, unsigned len)
213{ 213{
214 return -AX25_HEADER_LEN; 214 return -AX25_HEADER_LEN;
215} 215}
diff --git a/net/core/pktgen.c b/net/core/pktgen.c
index b3ad49fa7d78..ef430b1e8e42 100644
--- a/net/core/pktgen.c
+++ b/net/core/pktgen.c
@@ -1452,8 +1452,7 @@ static int proc_thread_write(struct file *file, const char __user *user_buffer,
1452 thread_lock(); 1452 thread_lock();
1453 t->control |= T_REMDEV; 1453 t->control |= T_REMDEV;
1454 thread_unlock(); 1454 thread_unlock();
1455 current->state = TASK_INTERRUPTIBLE; 1455 schedule_timeout_interruptible(msecs_to_jiffies(125)); /* Propagate thread->control */
1456 schedule_timeout(HZ/8); /* Propagate thread->control */
1457 ret = count; 1456 ret = count;
1458 sprintf(pg_result, "OK: rem_device_all"); 1457 sprintf(pg_result, "OK: rem_device_all");
1459 goto out; 1458 goto out;
@@ -1716,10 +1715,9 @@ static void spin(struct pktgen_dev *pkt_dev, __u64 spin_until_us)
1716 printk(KERN_INFO "sleeping for %d\n", (int)(spin_until_us - now)); 1715 printk(KERN_INFO "sleeping for %d\n", (int)(spin_until_us - now));
1717 while (now < spin_until_us) { 1716 while (now < spin_until_us) {
1718 /* TODO: optimise sleeping behavior */ 1717 /* TODO: optimise sleeping behavior */
1719 if (spin_until_us - now > (1000000/HZ)+1) { 1718 if (spin_until_us - now > jiffies_to_usecs(1)+1)
1720 current->state = TASK_INTERRUPTIBLE; 1719 schedule_timeout_interruptible(1);
1721 schedule_timeout(1); 1720 else if (spin_until_us - now > 100) {
1722 } else if (spin_until_us - now > 100) {
1723 do_softirq(); 1721 do_softirq();
1724 if (!pkt_dev->running) 1722 if (!pkt_dev->running)
1725 return; 1723 return;
@@ -2449,8 +2447,7 @@ static void pktgen_run_all_threads(void)
2449 } 2447 }
2450 thread_unlock(); 2448 thread_unlock();
2451 2449
2452 current->state = TASK_INTERRUPTIBLE; 2450 schedule_timeout_interruptible(msecs_to_jiffies(125)); /* Propagate thread->control */
2453 schedule_timeout(HZ/8); /* Propagate thread->control */
2454 2451
2455 pktgen_wait_all_threads_run(); 2452 pktgen_wait_all_threads_run();
2456} 2453}
diff --git a/net/dccp/ccids/ccid3.c b/net/dccp/ccids/ccid3.c
index e05f4f955eee..38aa84986118 100644
--- a/net/dccp/ccids/ccid3.c
+++ b/net/dccp/ccids/ccid3.c
@@ -1095,6 +1095,10 @@ static void ccid3_hc_rx_get_info(struct sock *sk, struct tcp_info *info)
1095{ 1095{
1096 const struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk); 1096 const struct ccid3_hc_rx_sock *hcrx = ccid3_hc_rx_sk(sk);
1097 1097
1098 /* Listen socks doesn't have a private CCID block */
1099 if (sk->sk_state == DCCP_LISTEN)
1100 return;
1101
1098 BUG_ON(hcrx == NULL); 1102 BUG_ON(hcrx == NULL);
1099 1103
1100 info->tcpi_ca_state = hcrx->ccid3hcrx_state; 1104 info->tcpi_ca_state = hcrx->ccid3hcrx_state;
@@ -1106,6 +1110,10 @@ static void ccid3_hc_tx_get_info(struct sock *sk, struct tcp_info *info)
1106{ 1110{
1107 const struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk); 1111 const struct ccid3_hc_tx_sock *hctx = ccid3_hc_tx_sk(sk);
1108 1112
1113 /* Listen socks doesn't have a private CCID block */
1114 if (sk->sk_state == DCCP_LISTEN)
1115 return;
1116
1109 BUG_ON(hctx == NULL); 1117 BUG_ON(hctx == NULL);
1110 1118
1111 info->tcpi_rto = hctx->ccid3hctx_t_rto; 1119 info->tcpi_rto = hctx->ccid3hctx_t_rto;
diff --git a/net/ipv4/ipconfig.c b/net/ipv4/ipconfig.c
index 953129d392d2..e8674baaa8d9 100644
--- a/net/ipv4/ipconfig.c
+++ b/net/ipv4/ipconfig.c
@@ -1103,10 +1103,8 @@ static int __init ic_dynamic(void)
1103#endif 1103#endif
1104 1104
1105 jiff = jiffies + (d->next ? CONF_INTER_TIMEOUT : timeout); 1105 jiff = jiffies + (d->next ? CONF_INTER_TIMEOUT : timeout);
1106 while (time_before(jiffies, jiff) && !ic_got_reply) { 1106 while (time_before(jiffies, jiff) && !ic_got_reply)
1107 set_current_state(TASK_UNINTERRUPTIBLE); 1107 schedule_timeout_uninterruptible(1);
1108 schedule_timeout(1);
1109 }
1110#ifdef IPCONFIG_DHCP 1108#ifdef IPCONFIG_DHCP
1111 /* DHCP isn't done until we get a DHCPACK. */ 1109 /* DHCP isn't done until we get a DHCPACK. */
1112 if ((ic_got_reply & IC_BOOTP) 1110 if ((ic_got_reply & IC_BOOTP)
diff --git a/net/irda/ircomm/ircomm_tty.c b/net/irda/ircomm/ircomm_tty.c
index 5d1e61168eb7..6f20b4206e08 100644
--- a/net/irda/ircomm/ircomm_tty.c
+++ b/net/irda/ircomm/ircomm_tty.c
@@ -567,10 +567,8 @@ static void ircomm_tty_close(struct tty_struct *tty, struct file *filp)
567 self->tty = NULL; 567 self->tty = NULL;
568 568
569 if (self->blocked_open) { 569 if (self->blocked_open) {
570 if (self->close_delay) { 570 if (self->close_delay)
571 current->state = TASK_INTERRUPTIBLE; 571 schedule_timeout_interruptible(self->close_delay);
572 schedule_timeout(self->close_delay);
573 }
574 wake_up_interruptible(&self->open_wait); 572 wake_up_interruptible(&self->open_wait);
575 } 573 }
576 574
@@ -863,8 +861,7 @@ static void ircomm_tty_wait_until_sent(struct tty_struct *tty, int timeout)
863 spin_lock_irqsave(&self->spinlock, flags); 861 spin_lock_irqsave(&self->spinlock, flags);
864 while (self->tx_skb && self->tx_skb->len) { 862 while (self->tx_skb && self->tx_skb->len) {
865 spin_unlock_irqrestore(&self->spinlock, flags); 863 spin_unlock_irqrestore(&self->spinlock, flags);
866 current->state = TASK_INTERRUPTIBLE; 864 schedule_timeout_interruptible(poll_time);
867 schedule_timeout(poll_time);
868 spin_lock_irqsave(&self->spinlock, flags); 865 spin_lock_irqsave(&self->spinlock, flags);
869 if (signal_pending(current)) 866 if (signal_pending(current))
870 break; 867 break;
diff --git a/net/netrom/af_netrom.c b/net/netrom/af_netrom.c
index f4578c759ffc..e5d82d711cae 100644
--- a/net/netrom/af_netrom.c
+++ b/net/netrom/af_netrom.c
@@ -56,6 +56,7 @@ int sysctl_netrom_transport_requested_window_size = NR_DEFAULT_WINDOW;
56int sysctl_netrom_transport_no_activity_timeout = NR_DEFAULT_IDLE; 56int sysctl_netrom_transport_no_activity_timeout = NR_DEFAULT_IDLE;
57int sysctl_netrom_routing_control = NR_DEFAULT_ROUTING; 57int sysctl_netrom_routing_control = NR_DEFAULT_ROUTING;
58int sysctl_netrom_link_fails_count = NR_DEFAULT_FAILS; 58int sysctl_netrom_link_fails_count = NR_DEFAULT_FAILS;
59int sysctl_netrom_reset_circuit = NR_DEFAULT_RESET;
59 60
60static unsigned short circuit = 0x101; 61static unsigned short circuit = 0x101;
61 62
@@ -908,17 +909,17 @@ int nr_rx_frame(struct sk_buff *skb, struct net_device *dev)
908 if (frametype != NR_CONNREQ) { 909 if (frametype != NR_CONNREQ) {
909 /* 910 /*
910 * Here it would be nice to be able to send a reset but 911 * Here it would be nice to be able to send a reset but
911 * NET/ROM doesn't have one. The following hack would 912 * NET/ROM doesn't have one. We've tried to extend the protocol
912 * have been a way to extend the protocol but apparently 913 * by sending NR_CONNACK | NR_CHOKE_FLAGS replies but that
913 * it kills BPQ boxes... :-( 914 * apparently kills BPQ boxes... :-(
915 * So now we try to follow the established behaviour of
916 * G8PZT's Xrouter which is sending packets with command type 7
917 * as an extension of the protocol.
914 */ 918 */
915#if 0 919 if (sysctl_netrom_reset_circuit &&
916 /* 920 (frametype != NR_RESET || flags != 0))
917 * Never reply to a CONNACK/CHOKE. 921 nr_transmit_reset(skb, 1);
918 */ 922
919 if (frametype != NR_CONNACK || flags != NR_CHOKE_FLAG)
920 nr_transmit_refusal(skb, 1);
921#endif
922 return 0; 923 return 0;
923 } 924 }
924 925
@@ -1187,9 +1188,7 @@ static int nr_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1187 } 1188 }
1188 1189
1189 case SIOCGSTAMP: 1190 case SIOCGSTAMP:
1190 ret = -EINVAL; 1191 ret = sock_get_timestamp(sk, argp);
1191 if (sk != NULL)
1192 ret = sock_get_timestamp(sk, argp);
1193 release_sock(sk); 1192 release_sock(sk);
1194 return ret; 1193 return ret;
1195 1194
@@ -1393,8 +1392,7 @@ static int __init nr_proto_init(void)
1393 struct net_device *dev; 1392 struct net_device *dev;
1394 1393
1395 sprintf(name, "nr%d", i); 1394 sprintf(name, "nr%d", i);
1396 dev = alloc_netdev(sizeof(struct net_device_stats), name, 1395 dev = alloc_netdev(sizeof(struct nr_private), name, nr_setup);
1397 nr_setup);
1398 if (!dev) { 1396 if (!dev) {
1399 printk(KERN_ERR "NET/ROM: nr_proto_init - unable to allocate device structure\n"); 1397 printk(KERN_ERR "NET/ROM: nr_proto_init - unable to allocate device structure\n");
1400 goto fail; 1398 goto fail;
diff --git a/net/netrom/nr_dev.c b/net/netrom/nr_dev.c
index 263da4c26494..4e66eef9a034 100644
--- a/net/netrom/nr_dev.c
+++ b/net/netrom/nr_dev.c
@@ -47,7 +47,7 @@ int nr_rx_ip(struct sk_buff *skb, struct net_device *dev)
47 struct net_device_stats *stats = netdev_priv(dev); 47 struct net_device_stats *stats = netdev_priv(dev);
48 48
49 if (!netif_running(dev)) { 49 if (!netif_running(dev)) {
50 stats->rx_errors++; 50 stats->rx_dropped++;
51 return 0; 51 return 0;
52 } 52 }
53 53
@@ -71,15 +71,10 @@ int nr_rx_ip(struct sk_buff *skb, struct net_device *dev)
71 71
72static int nr_rebuild_header(struct sk_buff *skb) 72static int nr_rebuild_header(struct sk_buff *skb)
73{ 73{
74 struct net_device *dev = skb->dev;
75 struct net_device_stats *stats = netdev_priv(dev);
76 struct sk_buff *skbn;
77 unsigned char *bp = skb->data; 74 unsigned char *bp = skb->data;
78 int len;
79 75
80 if (arp_find(bp + 7, skb)) { 76 if (arp_find(bp + 7, skb))
81 return 1; 77 return 1;
82 }
83 78
84 bp[6] &= ~AX25_CBIT; 79 bp[6] &= ~AX25_CBIT;
85 bp[6] &= ~AX25_EBIT; 80 bp[6] &= ~AX25_EBIT;
@@ -90,27 +85,7 @@ static int nr_rebuild_header(struct sk_buff *skb)
90 bp[6] |= AX25_EBIT; 85 bp[6] |= AX25_EBIT;
91 bp[6] |= AX25_SSSID_SPARE; 86 bp[6] |= AX25_SSSID_SPARE;
92 87
93 if ((skbn = skb_clone(skb, GFP_ATOMIC)) == NULL) { 88 return 0;
94 kfree_skb(skb);
95 return 1;
96 }
97
98 if (skb->sk != NULL)
99 skb_set_owner_w(skbn, skb->sk);
100
101 kfree_skb(skb);
102
103 len = skbn->len;
104
105 if (!nr_route_frame(skbn, NULL)) {
106 kfree_skb(skbn);
107 stats->tx_errors++;
108 }
109
110 stats->tx_packets++;
111 stats->tx_bytes += len;
112
113 return 1;
114} 89}
115 90
116#else 91#else
@@ -185,15 +160,27 @@ static int nr_close(struct net_device *dev)
185 160
186static int nr_xmit(struct sk_buff *skb, struct net_device *dev) 161static int nr_xmit(struct sk_buff *skb, struct net_device *dev)
187{ 162{
188 struct net_device_stats *stats = netdev_priv(dev); 163 struct nr_private *nr = netdev_priv(dev);
189 dev_kfree_skb(skb); 164 struct net_device_stats *stats = &nr->stats;
190 stats->tx_errors++; 165 unsigned int len = skb->len;
166
167 if (!nr_route_frame(skb, NULL)) {
168 kfree_skb(skb);
169 stats->tx_errors++;
170 return 0;
171 }
172
173 stats->tx_packets++;
174 stats->tx_bytes += len;
175
191 return 0; 176 return 0;
192} 177}
193 178
194static struct net_device_stats *nr_get_stats(struct net_device *dev) 179static struct net_device_stats *nr_get_stats(struct net_device *dev)
195{ 180{
196 return netdev_priv(dev); 181 struct nr_private *nr = netdev_priv(dev);
182
183 return &nr->stats;
197} 184}
198 185
199void nr_setup(struct net_device *dev) 186void nr_setup(struct net_device *dev)
@@ -208,12 +195,11 @@ void nr_setup(struct net_device *dev)
208 dev->hard_header_len = NR_NETWORK_LEN + NR_TRANSPORT_LEN; 195 dev->hard_header_len = NR_NETWORK_LEN + NR_TRANSPORT_LEN;
209 dev->addr_len = AX25_ADDR_LEN; 196 dev->addr_len = AX25_ADDR_LEN;
210 dev->type = ARPHRD_NETROM; 197 dev->type = ARPHRD_NETROM;
211 dev->tx_queue_len = 40;
212 dev->rebuild_header = nr_rebuild_header; 198 dev->rebuild_header = nr_rebuild_header;
213 dev->set_mac_address = nr_set_mac_address; 199 dev->set_mac_address = nr_set_mac_address;
214 200
215 /* New-style flags. */ 201 /* New-style flags. */
216 dev->flags = 0; 202 dev->flags = IFF_NOARP;
217 203
218 dev->get_stats = nr_get_stats; 204 dev->get_stats = nr_get_stats;
219} 205}
diff --git a/net/netrom/nr_in.c b/net/netrom/nr_in.c
index 64b81a796907..004e8599b8fe 100644
--- a/net/netrom/nr_in.c
+++ b/net/netrom/nr_in.c
@@ -98,6 +98,11 @@ static int nr_state1_machine(struct sock *sk, struct sk_buff *skb,
98 nr_disconnect(sk, ECONNREFUSED); 98 nr_disconnect(sk, ECONNREFUSED);
99 break; 99 break;
100 100
101 case NR_RESET:
102 if (sysctl_netrom_reset_circuit);
103 nr_disconnect(sk, ECONNRESET);
104 break;
105
101 default: 106 default:
102 break; 107 break;
103 } 108 }
@@ -124,6 +129,11 @@ static int nr_state2_machine(struct sock *sk, struct sk_buff *skb,
124 nr_disconnect(sk, 0); 129 nr_disconnect(sk, 0);
125 break; 130 break;
126 131
132 case NR_RESET:
133 if (sysctl_netrom_reset_circuit);
134 nr_disconnect(sk, ECONNRESET);
135 break;
136
127 default: 137 default:
128 break; 138 break;
129 } 139 }
@@ -254,6 +264,11 @@ static int nr_state3_machine(struct sock *sk, struct sk_buff *skb, int frametype
254 } 264 }
255 break; 265 break;
256 266
267 case NR_RESET:
268 if (sysctl_netrom_reset_circuit);
269 nr_disconnect(sk, ECONNRESET);
270 break;
271
257 default: 272 default:
258 break; 273 break;
259 } 274 }
diff --git a/net/netrom/nr_subr.c b/net/netrom/nr_subr.c
index 587bed2674bf..bcb9946b4f56 100644
--- a/net/netrom/nr_subr.c
+++ b/net/netrom/nr_subr.c
@@ -210,10 +210,9 @@ void nr_write_internal(struct sock *sk, int frametype)
210} 210}
211 211
212/* 212/*
213 * This routine is called when a Connect Acknowledge with the Choke Flag 213 * This routine is called to send an error reply.
214 * set is needed to refuse a connection.
215 */ 214 */
216void nr_transmit_refusal(struct sk_buff *skb, int mine) 215void __nr_transmit_reply(struct sk_buff *skb, int mine, unsigned char cmdflags)
217{ 216{
218 struct sk_buff *skbn; 217 struct sk_buff *skbn;
219 unsigned char *dptr; 218 unsigned char *dptr;
@@ -254,7 +253,7 @@ void nr_transmit_refusal(struct sk_buff *skb, int mine)
254 *dptr++ = 0; 253 *dptr++ = 0;
255 } 254 }
256 255
257 *dptr++ = NR_CONNACK | NR_CHOKE_FLAG; 256 *dptr++ = cmdflags;
258 *dptr++ = 0; 257 *dptr++ = 0;
259 258
260 if (!nr_route_frame(skbn, NULL)) 259 if (!nr_route_frame(skbn, NULL))
diff --git a/net/netrom/sysctl_net_netrom.c b/net/netrom/sysctl_net_netrom.c
index c9ed50382ea7..6bb8dda849dc 100644
--- a/net/netrom/sysctl_net_netrom.c
+++ b/net/netrom/sysctl_net_netrom.c
@@ -30,6 +30,7 @@ static int min_idle[] = {0 * HZ};
30static int max_idle[] = {65535 * HZ}; 30static int max_idle[] = {65535 * HZ};
31static int min_route[] = {0}, max_route[] = {1}; 31static int min_route[] = {0}, max_route[] = {1};
32static int min_fails[] = {1}, max_fails[] = {10}; 32static int min_fails[] = {1}, max_fails[] = {10};
33static int min_reset[] = {0}, max_reset[] = {1};
33 34
34static struct ctl_table_header *nr_table_header; 35static struct ctl_table_header *nr_table_header;
35 36
@@ -155,6 +156,17 @@ static ctl_table nr_table[] = {
155 .extra1 = &min_fails, 156 .extra1 = &min_fails,
156 .extra2 = &max_fails 157 .extra2 = &max_fails
157 }, 158 },
159 {
160 .ctl_name = NET_NETROM_RESET,
161 .procname = "reset",
162 .data = &sysctl_netrom_reset_circuit,
163 .maxlen = sizeof(int),
164 .mode = 0644,
165 .proc_handler = &proc_dointvec_minmax,
166 .strategy = &sysctl_intvec,
167 .extra1 = &min_reset,
168 .extra2 = &max_reset
169 },
158 { .ctl_name = 0 } 170 { .ctl_name = 0 }
159}; 171};
160 172
diff --git a/net/rose/af_rose.c b/net/rose/af_rose.c
index 3077878ed4f0..5acb1680524a 100644
--- a/net/rose/af_rose.c
+++ b/net/rose/af_rose.c
@@ -1243,7 +1243,7 @@ static int rose_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1243 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc); 1243 amount = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
1244 if (amount < 0) 1244 if (amount < 0)
1245 amount = 0; 1245 amount = 0;
1246 return put_user(amount, (unsigned int __user *)argp); 1246 return put_user(amount, (unsigned int __user *) argp);
1247 } 1247 }
1248 1248
1249 case TIOCINQ: { 1249 case TIOCINQ: {
@@ -1252,13 +1252,11 @@ static int rose_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1252 /* These two are safe on a single CPU system as only user tasks fiddle here */ 1252 /* These two are safe on a single CPU system as only user tasks fiddle here */
1253 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) 1253 if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
1254 amount = skb->len; 1254 amount = skb->len;
1255 return put_user(amount, (unsigned int __user *)argp); 1255 return put_user(amount, (unsigned int __user *) argp);
1256 } 1256 }
1257 1257
1258 case SIOCGSTAMP: 1258 case SIOCGSTAMP:
1259 if (sk != NULL) 1259 return sock_get_timestamp(sk, (struct timeval __user *) argp);
1260 return sock_get_timestamp(sk, (struct timeval __user *)argp);
1261 return -EINVAL;
1262 1260
1263 case SIOCGIFADDR: 1261 case SIOCGIFADDR:
1264 case SIOCSIFADDR: 1262 case SIOCSIFADDR:
diff --git a/net/rose/rose_dev.c b/net/rose/rose_dev.c
index a8ed9a1d09f9..d297af737d10 100644
--- a/net/rose/rose_dev.c
+++ b/net/rose/rose_dev.c
@@ -149,6 +149,6 @@ void rose_setup(struct net_device *dev)
149 dev->set_mac_address = rose_set_mac_address; 149 dev->set_mac_address = rose_set_mac_address;
150 150
151 /* New-style flags. */ 151 /* New-style flags. */
152 dev->flags = 0; 152 dev->flags = IFF_NOARP;
153 dev->get_stats = rose_get_stats; 153 dev->get_stats = rose_get_stats;
154} 154}
diff --git a/net/sunrpc/svcsock.c b/net/sunrpc/svcsock.c
index 05fe2e735538..51885b5f744e 100644
--- a/net/sunrpc/svcsock.c
+++ b/net/sunrpc/svcsock.c
@@ -1170,8 +1170,7 @@ svc_recv(struct svc_serv *serv, struct svc_rqst *rqstp, long timeout)
1170 while (rqstp->rq_arghi < pages) { 1170 while (rqstp->rq_arghi < pages) {
1171 struct page *p = alloc_page(GFP_KERNEL); 1171 struct page *p = alloc_page(GFP_KERNEL);
1172 if (!p) { 1172 if (!p) {
1173 set_current_state(TASK_UNINTERRUPTIBLE); 1173 schedule_timeout_uninterruptible(msecs_to_jiffies(500));
1174 schedule_timeout(HZ/2);
1175 continue; 1174 continue;
1176 } 1175 }
1177 rqstp->rq_argpages[rqstp->rq_arghi++] = p; 1176 rqstp->rq_argpages[rqstp->rq_arghi++] = p;
generated by cgit v1.2.2 (git 2.25.0) at 2024-11-21 07:32:50 -0500