Doug / smarc-fsl-linux-kernel | Embedian Git Server

Commit 35a2af94c7ce7130ca292c68b1d27fcfdb648f6b

Authored by Peter Zijlstra 2013-10-02 17:22:33 +0800

Committed by Ingo Molnar 2013-10-04 16:16:25 +0800

Exists in smarc-imx_3.14.28_1.0.0_ga and in 1 other branch

sched/wait: Make the __wait_event*() interface more friendly

Change all __wait_event*() implementations to match the corresponding
wait_event*() signature for convenience.

In particular this does away with the weird 'ret' logic. Since there
are __wait_event*() users this requires we update them too.

Reviewed-by: Oleg Nesterov <oleg@redhat.com>
Signed-off-by: Peter Zijlstra <peterz@infradead.org>
Link: http://lkml.kernel.org/r/20131002092529.042563462@infradead.org
Signed-off-by: Ingo Molnar <mingo@kernel.org>

Showing 5 changed files with 73 additions and 81 deletions Inline Diff

arch/mips/kernel/rtlx.c
include/linux/tty.h
include/linux/wait.h
net/irda/af_irda.c
net/netfilter/ipvs/ip_vs_sync.c

arch/mips/kernel/rtlx.c

Diff comments View file @ 35a2af9

1	/*	1	/*
2	* Copyright (C) 2005 MIPS Technologies, Inc. All rights reserved.	2	* Copyright (C) 2005 MIPS Technologies, Inc. All rights reserved.
3	* Copyright (C) 2005, 06 Ralf Baechle (ralf@linux-mips.org)	3	* Copyright (C) 2005, 06 Ralf Baechle (ralf@linux-mips.org)
4	*	4	*
5	* This program is free software; you can distribute it and/or modify it	5	* This program is free software; you can distribute it and/or modify it
6	* under the terms of the GNU General Public License (Version 2) as	6	* under the terms of the GNU General Public License (Version 2) as
7	* published by the Free Software Foundation.	7	* published by the Free Software Foundation.
8	*	8	*
9	* This program is distributed in the hope it will be useful, but WITHOUT	9	* This program is distributed in the hope it will be useful, but WITHOUT
10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or	10	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License	11	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
12	* for more details.	12	* for more details.
13	*	13	*
14	* You should have received a copy of the GNU General Public License along	14	* You should have received a copy of the GNU General Public License along
15	* with this program; if not, write to the Free Software Foundation, Inc.,	15	* with this program; if not, write to the Free Software Foundation, Inc.,
16	* 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.	16	* 59 Temple Place - Suite 330, Boston MA 02111-1307, USA.
17	*	17	*
18	*/	18	*/
19		19
20	#include <linux/device.h>	20	#include <linux/device.h>
21	#include <linux/kernel.h>	21	#include <linux/kernel.h>
22	#include <linux/fs.h>	22	#include <linux/fs.h>
23	#include <linux/init.h>	23	#include <linux/init.h>
24	#include <asm/uaccess.h>	24	#include <asm/uaccess.h>
25	#include <linux/list.h>	25	#include <linux/list.h>
26	#include <linux/vmalloc.h>	26	#include <linux/vmalloc.h>
27	#include <linux/elf.h>	27	#include <linux/elf.h>
28	#include <linux/seq_file.h>	28	#include <linux/seq_file.h>
29	#include <linux/syscalls.h>	29	#include <linux/syscalls.h>
30	#include <linux/moduleloader.h>	30	#include <linux/moduleloader.h>
31	#include <linux/interrupt.h>	31	#include <linux/interrupt.h>
32	#include <linux/poll.h>	32	#include <linux/poll.h>
33	#include <linux/sched.h>	33	#include <linux/sched.h>
34	#include <linux/wait.h>	34	#include <linux/wait.h>
35	#include <asm/mipsmtregs.h>	35	#include <asm/mipsmtregs.h>
36	#include <asm/mips_mt.h>	36	#include <asm/mips_mt.h>
37	#include <asm/cacheflush.h>	37	#include <asm/cacheflush.h>
38	#include <linux/atomic.h>	38	#include <linux/atomic.h>
39	#include <asm/cpu.h>	39	#include <asm/cpu.h>
40	#include <asm/processor.h>	40	#include <asm/processor.h>
41	#include <asm/vpe.h>	41	#include <asm/vpe.h>
42	#include <asm/rtlx.h>	42	#include <asm/rtlx.h>
43	#include <asm/setup.h>	43	#include <asm/setup.h>
44		44
45	static struct rtlx_info *rtlx;	45	static struct rtlx_info *rtlx;
46	static int major;	46	static int major;
47	static char module_name[] = "rtlx";	47	static char module_name[] = "rtlx";
48		48
49	static struct chan_waitqueues {	49	static struct chan_waitqueues {
50	wait_queue_head_t rt_queue;	50	wait_queue_head_t rt_queue;
51	wait_queue_head_t lx_queue;	51	wait_queue_head_t lx_queue;
52	atomic_t in_open;	52	atomic_t in_open;
53	struct mutex mutex;	53	struct mutex mutex;
54	} channel_wqs[RTLX_CHANNELS];	54	} channel_wqs[RTLX_CHANNELS];
55		55
56	static struct vpe_notifications notify;	56	static struct vpe_notifications notify;
57	static int sp_stopping;	57	static int sp_stopping;
58		58
59	extern void *vpe_get_shared(int index);	59	extern void *vpe_get_shared(int index);
60		60
61	static void rtlx_dispatch(void)	61	static void rtlx_dispatch(void)
62	{	62	{
63	do_IRQ(MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ);	63	do_IRQ(MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ);
64	}	64	}
65		65
66		66
67	/* Interrupt handler may be called before rtlx_init has otherwise had	67	/* Interrupt handler may be called before rtlx_init has otherwise had
68	a chance to run.	68	a chance to run.
69	*/	69	*/
70	static irqreturn_t rtlx_interrupt(int irq, void *dev_id)	70	static irqreturn_t rtlx_interrupt(int irq, void *dev_id)
71	{	71	{
72	unsigned int vpeflags;	72	unsigned int vpeflags;
73	unsigned long flags;	73	unsigned long flags;
74	int i;	74	int i;
75		75
76	/* Ought not to be strictly necessary for SMTC builds */	76	/* Ought not to be strictly necessary for SMTC builds */
77	local_irq_save(flags);	77	local_irq_save(flags);
78	vpeflags = dvpe();	78	vpeflags = dvpe();
79	set_c0_status(0x100 << MIPS_CPU_RTLX_IRQ);	79	set_c0_status(0x100 << MIPS_CPU_RTLX_IRQ);
80	irq_enable_hazard();	80	irq_enable_hazard();
81	evpe(vpeflags);	81	evpe(vpeflags);
82	local_irq_restore(flags);	82	local_irq_restore(flags);
83		83
84	for (i = 0; i < RTLX_CHANNELS; i++) {	84	for (i = 0; i < RTLX_CHANNELS; i++) {
85	wake_up(&channel_wqs[i].lx_queue);	85	wake_up(&channel_wqs[i].lx_queue);
86	wake_up(&channel_wqs[i].rt_queue);	86	wake_up(&channel_wqs[i].rt_queue);
87	}	87	}
88		88
89	return IRQ_HANDLED;	89	return IRQ_HANDLED;
90	}	90	}
91		91
92	static void __used dump_rtlx(void)	92	static void __used dump_rtlx(void)
93	{	93	{
94	int i;	94	int i;
95		95
96	printk("id 0x%lx state %d\n", rtlx->id, rtlx->state);	96	printk("id 0x%lx state %d\n", rtlx->id, rtlx->state);
97		97
98	for (i = 0; i < RTLX_CHANNELS; i++) {	98	for (i = 0; i < RTLX_CHANNELS; i++) {
99	struct rtlx_channel *chan = &rtlx->channel[i];	99	struct rtlx_channel *chan = &rtlx->channel[i];
100		100
101	printk(" rt_state %d lx_state %d buffer_size %d\n",	101	printk(" rt_state %d lx_state %d buffer_size %d\n",
102	chan->rt_state, chan->lx_state, chan->buffer_size);	102	chan->rt_state, chan->lx_state, chan->buffer_size);
103		103
104	printk(" rt_read %d rt_write %d\n",	104	printk(" rt_read %d rt_write %d\n",
105	chan->rt_read, chan->rt_write);	105	chan->rt_read, chan->rt_write);
106		106
107	printk(" lx_read %d lx_write %d\n",	107	printk(" lx_read %d lx_write %d\n",
108	chan->lx_read, chan->lx_write);	108	chan->lx_read, chan->lx_write);
109		109
110	printk(" rt_buffer <%s>\n", chan->rt_buffer);	110	printk(" rt_buffer <%s>\n", chan->rt_buffer);
111	printk(" lx_buffer <%s>\n", chan->lx_buffer);	111	printk(" lx_buffer <%s>\n", chan->lx_buffer);
112	}	112	}
113	}	113	}
114		114
115	/* call when we have the address of the shared structure from the SP side. */	115	/* call when we have the address of the shared structure from the SP side. */
116	static int rtlx_init(struct rtlx_info *rtlxi)	116	static int rtlx_init(struct rtlx_info *rtlxi)
117	{	117	{
118	if (rtlxi->id != RTLX_ID) {	118	if (rtlxi->id != RTLX_ID) {
119	printk(KERN_ERR "no valid RTLX id at 0x%p 0x%lx\n",	119	printk(KERN_ERR "no valid RTLX id at 0x%p 0x%lx\n",
120	rtlxi, rtlxi->id);	120	rtlxi, rtlxi->id);
121	return -ENOEXEC;	121	return -ENOEXEC;
122	}	122	}
123		123
124	rtlx = rtlxi;	124	rtlx = rtlxi;
125		125
126	return 0;	126	return 0;
127	}	127	}
128		128
129	/* notifications */	129	/* notifications */
130	static void starting(int vpe)	130	static void starting(int vpe)
131	{	131	{
132	int i;	132	int i;
133	sp_stopping = 0;	133	sp_stopping = 0;
134		134
135	/* force a reload of rtlx */	135	/* force a reload of rtlx */
136	rtlx=NULL;	136	rtlx=NULL;
137		137
138	/* wake up any sleeping rtlx_open's */	138	/* wake up any sleeping rtlx_open's */
139	for (i = 0; i < RTLX_CHANNELS; i++)	139	for (i = 0; i < RTLX_CHANNELS; i++)
140	wake_up_interruptible(&channel_wqs[i].lx_queue);	140	wake_up_interruptible(&channel_wqs[i].lx_queue);
141	}	141	}
142		142
143	static void stopping(int vpe)	143	static void stopping(int vpe)
144	{	144	{
145	int i;	145	int i;
146		146
147	sp_stopping = 1;	147	sp_stopping = 1;
148	for (i = 0; i < RTLX_CHANNELS; i++)	148	for (i = 0; i < RTLX_CHANNELS; i++)
149	wake_up_interruptible(&channel_wqs[i].lx_queue);	149	wake_up_interruptible(&channel_wqs[i].lx_queue);
150	}	150	}
151		151
152		152
153	int rtlx_open(int index, int can_sleep)	153	int rtlx_open(int index, int can_sleep)
154	{	154	{
155	struct rtlx_info **p;	155	struct rtlx_info **p;
156	struct rtlx_channel *chan;	156	struct rtlx_channel *chan;
157	enum rtlx_state state;	157	enum rtlx_state state;
158	int ret = 0;	158	int ret = 0;
159		159
160	if (index >= RTLX_CHANNELS) {	160	if (index >= RTLX_CHANNELS) {
161	printk(KERN_DEBUG "rtlx_open index out of range\n");	161	printk(KERN_DEBUG "rtlx_open index out of range\n");
162	return -ENOSYS;	162	return -ENOSYS;
163	}	163	}
164		164
165	if (atomic_inc_return(&channel_wqs[index].in_open) > 1) {	165	if (atomic_inc_return(&channel_wqs[index].in_open) > 1) {
166	printk(KERN_DEBUG "rtlx_open channel %d already opened\n",	166	printk(KERN_DEBUG "rtlx_open channel %d already opened\n",
167	index);	167	index);
168	ret = -EBUSY;	168	ret = -EBUSY;
169	goto out_fail;	169	goto out_fail;
170	}	170	}
171		171
172	if (rtlx == NULL) {	172	if (rtlx == NULL) {
173	if( (p = vpe_get_shared(tclimit)) == NULL) {	173	if( (p = vpe_get_shared(tclimit)) == NULL) {
174	if (can_sleep) {	174	if (can_sleep) {
175	__wait_event_interruptible(channel_wqs[index].lx_queue,	175	ret = __wait_event_interruptible(
176	(p = vpe_get_shared(tclimit)), ret);	176	channel_wqs[index].lx_queue,
		177	(p = vpe_get_shared(tclimit)));
177	if (ret)	178	if (ret)
178	goto out_fail;	179	goto out_fail;
179	} else {	180	} else {
180	printk(KERN_DEBUG "No SP program loaded, and device "	181	printk(KERN_DEBUG "No SP program loaded, and device "
181	"opened with O_NONBLOCK\n");	182	"opened with O_NONBLOCK\n");
182	ret = -ENOSYS;	183	ret = -ENOSYS;
183	goto out_fail;	184	goto out_fail;
184	}	185	}
185	}	186	}
186		187
187	smp_rmb();	188	smp_rmb();
188	if (*p == NULL) {	189	if (*p == NULL) {
189	if (can_sleep) {	190	if (can_sleep) {
190	DEFINE_WAIT(wait);	191	DEFINE_WAIT(wait);
191		192
192	for (;;) {	193	for (;;) {
193	prepare_to_wait(	194	prepare_to_wait(
194	&channel_wqs[index].lx_queue,	195	&channel_wqs[index].lx_queue,
195	&wait, TASK_INTERRUPTIBLE);	196	&wait, TASK_INTERRUPTIBLE);
196	smp_rmb();	197	smp_rmb();
197	if (*p != NULL)	198	if (*p != NULL)
198	break;	199	break;
199	if (!signal_pending(current)) {	200	if (!signal_pending(current)) {
200	schedule();	201	schedule();
201	continue;	202	continue;
202	}	203	}
203	ret = -ERESTARTSYS;	204	ret = -ERESTARTSYS;
204	goto out_fail;	205	goto out_fail;
205	}	206	}
206	finish_wait(&channel_wqs[index].lx_queue, &wait);	207	finish_wait(&channel_wqs[index].lx_queue, &wait);
207	} else {	208	} else {
208	pr_err(" *vpe_get_shared is NULL. "	209	pr_err(" *vpe_get_shared is NULL. "
209	"Has an SP program been loaded?\n");	210	"Has an SP program been loaded?\n");
210	ret = -ENOSYS;	211	ret = -ENOSYS;
211	goto out_fail;	212	goto out_fail;
212	}	213	}
213	}	214	}
214		215
215	if ((unsigned int)*p < KSEG0) {	216	if ((unsigned int)*p < KSEG0) {
216	printk(KERN_WARNING "vpe_get_shared returned an "	217	printk(KERN_WARNING "vpe_get_shared returned an "
217	"invalid pointer maybe an error code %d\n",	218	"invalid pointer maybe an error code %d\n",
218	(int)*p);	219	(int)*p);
219	ret = -ENOSYS;	220	ret = -ENOSYS;
220	goto out_fail;	221	goto out_fail;
221	}	222	}
222		223
223	if ((ret = rtlx_init(*p)) < 0)	224	if ((ret = rtlx_init(*p)) < 0)
224	goto out_ret;	225	goto out_ret;
225	}	226	}
226		227
227	chan = &rtlx->channel[index];	228	chan = &rtlx->channel[index];
228		229
229	state = xchg(&chan->lx_state, RTLX_STATE_OPENED);	230	state = xchg(&chan->lx_state, RTLX_STATE_OPENED);
230	if (state == RTLX_STATE_OPENED) {	231	if (state == RTLX_STATE_OPENED) {
231	ret = -EBUSY;	232	ret = -EBUSY;
232	goto out_fail;	233	goto out_fail;
233	}	234	}
234		235
235	out_fail:	236	out_fail:
236	smp_mb();	237	smp_mb();
237	atomic_dec(&channel_wqs[index].in_open);	238	atomic_dec(&channel_wqs[index].in_open);
238	smp_mb();	239	smp_mb();
239		240
240	out_ret:	241	out_ret:
241	return ret;	242	return ret;
242	}	243	}
243		244
244	int rtlx_release(int index)	245	int rtlx_release(int index)
245	{	246	{
246	if (rtlx == NULL) {	247	if (rtlx == NULL) {
247	pr_err("rtlx_release() with null rtlx\n");	248	pr_err("rtlx_release() with null rtlx\n");
248	return 0;	249	return 0;
249	}	250	}
250	rtlx->channel[index].lx_state = RTLX_STATE_UNUSED;	251	rtlx->channel[index].lx_state = RTLX_STATE_UNUSED;
251	return 0;	252	return 0;
252	}	253	}
253		254
254	unsigned int rtlx_read_poll(int index, int can_sleep)	255	unsigned int rtlx_read_poll(int index, int can_sleep)
255	{	256	{
256	struct rtlx_channel *chan;	257	struct rtlx_channel *chan;
257		258
258	if (rtlx == NULL)	259	if (rtlx == NULL)
259	return 0;	260	return 0;
260		261
261	chan = &rtlx->channel[index];	262	chan = &rtlx->channel[index];
262		263
263	/* data available to read? */	264	/* data available to read? */
264	if (chan->lx_read == chan->lx_write) {	265	if (chan->lx_read == chan->lx_write) {
265	if (can_sleep) {	266	if (can_sleep) {
266	int ret = 0;	267	int ret = __wait_event_interruptible(
267		268	channel_wqs[index].lx_queue,
268	__wait_event_interruptible(channel_wqs[index].lx_queue,
269	(chan->lx_read != chan->lx_write) \|\|	269	(chan->lx_read != chan->lx_write) \|\|
270	sp_stopping, ret);	270	sp_stopping);
271	if (ret)	271	if (ret)
272	return ret;	272	return ret;
273		273
274	if (sp_stopping)	274	if (sp_stopping)
275	return 0;	275	return 0;
276	} else	276	} else
277	return 0;	277	return 0;
278	}	278	}
279		279
280	return (chan->lx_write + chan->buffer_size - chan->lx_read)	280	return (chan->lx_write + chan->buffer_size - chan->lx_read)
281	% chan->buffer_size;	281	% chan->buffer_size;
282	}	282	}
283		283
284	static inline int write_spacefree(int read, int write, int size)	284	static inline int write_spacefree(int read, int write, int size)
285	{	285	{
286	if (read == write) {	286	if (read == write) {
287	/*	287	/*
288	* Never fill the buffer completely, so indexes are always	288	* Never fill the buffer completely, so indexes are always
289	* equal if empty and only empty, or !equal if data available	289	* equal if empty and only empty, or !equal if data available
290	*/	290	*/
291	return size - 1;	291	return size - 1;
292	}	292	}
293		293
294	return ((read + size - write) % size) - 1;	294	return ((read + size - write) % size) - 1;
295	}	295	}
296		296
297	unsigned int rtlx_write_poll(int index)	297	unsigned int rtlx_write_poll(int index)
298	{	298	{
299	struct rtlx_channel *chan = &rtlx->channel[index];	299	struct rtlx_channel *chan = &rtlx->channel[index];
300		300
301	return write_spacefree(chan->rt_read, chan->rt_write,	301	return write_spacefree(chan->rt_read, chan->rt_write,
302	chan->buffer_size);	302	chan->buffer_size);
303	}	303	}
304		304
305	ssize_t rtlx_read(int index, void __user *buff, size_t count)	305	ssize_t rtlx_read(int index, void __user *buff, size_t count)
306	{	306	{
307	size_t lx_write, fl = 0L;	307	size_t lx_write, fl = 0L;
308	struct rtlx_channel *lx;	308	struct rtlx_channel *lx;
309	unsigned long failed;	309	unsigned long failed;
310		310
311	if (rtlx == NULL)	311	if (rtlx == NULL)
312	return -ENOSYS;	312	return -ENOSYS;
313		313
314	lx = &rtlx->channel[index];	314	lx = &rtlx->channel[index];
315		315
316	mutex_lock(&channel_wqs[index].mutex);	316	mutex_lock(&channel_wqs[index].mutex);
317	smp_rmb();	317	smp_rmb();
318	lx_write = lx->lx_write;	318	lx_write = lx->lx_write;
319		319
320	/* find out how much in total */	320	/* find out how much in total */
321	count = min(count,	321	count = min(count,
322	(size_t)(lx_write + lx->buffer_size - lx->lx_read)	322	(size_t)(lx_write + lx->buffer_size - lx->lx_read)
323	% lx->buffer_size);	323	% lx->buffer_size);
324		324
325	/* then how much from the read pointer onwards */	325	/* then how much from the read pointer onwards */
326	fl = min(count, (size_t)lx->buffer_size - lx->lx_read);	326	fl = min(count, (size_t)lx->buffer_size - lx->lx_read);
327		327
328	failed = copy_to_user(buff, lx->lx_buffer + lx->lx_read, fl);	328	failed = copy_to_user(buff, lx->lx_buffer + lx->lx_read, fl);
329	if (failed)	329	if (failed)
330	goto out;	330	goto out;
331		331
332	/* and if there is anything left at the beginning of the buffer */	332	/* and if there is anything left at the beginning of the buffer */
333	if (count - fl)	333	if (count - fl)
334	failed = copy_to_user(buff + fl, lx->lx_buffer, count - fl);	334	failed = copy_to_user(buff + fl, lx->lx_buffer, count - fl);
335		335
336	out:	336	out:
337	count -= failed;	337	count -= failed;
338		338
339	smp_wmb();	339	smp_wmb();
340	lx->lx_read = (lx->lx_read + count) % lx->buffer_size;	340	lx->lx_read = (lx->lx_read + count) % lx->buffer_size;
341	smp_wmb();	341	smp_wmb();
342	mutex_unlock(&channel_wqs[index].mutex);	342	mutex_unlock(&channel_wqs[index].mutex);
343		343
344	return count;	344	return count;
345	}	345	}
346		346
347	ssize_t rtlx_write(int index, const void __user *buffer, size_t count)	347	ssize_t rtlx_write(int index, const void __user *buffer, size_t count)
348	{	348	{
349	struct rtlx_channel *rt;	349	struct rtlx_channel *rt;
350	unsigned long failed;	350	unsigned long failed;
351	size_t rt_read;	351	size_t rt_read;
352	size_t fl;	352	size_t fl;
353		353
354	if (rtlx == NULL)	354	if (rtlx == NULL)
355	return(-ENOSYS);	355	return(-ENOSYS);
356		356
357	rt = &rtlx->channel[index];	357	rt = &rtlx->channel[index];
358		358
359	mutex_lock(&channel_wqs[index].mutex);	359	mutex_lock(&channel_wqs[index].mutex);
360	smp_rmb();	360	smp_rmb();
361	rt_read = rt->rt_read;	361	rt_read = rt->rt_read;
362		362
363	/* total number of bytes to copy */	363	/* total number of bytes to copy */
364	count = min(count, (size_t)write_spacefree(rt_read, rt->rt_write,	364	count = min(count, (size_t)write_spacefree(rt_read, rt->rt_write,
365	rt->buffer_size));	365	rt->buffer_size));
366		366
367	/* first bit from write pointer to the end of the buffer, or count */	367	/* first bit from write pointer to the end of the buffer, or count */
368	fl = min(count, (size_t) rt->buffer_size - rt->rt_write);	368	fl = min(count, (size_t) rt->buffer_size - rt->rt_write);
369		369
370	failed = copy_from_user(rt->rt_buffer + rt->rt_write, buffer, fl);	370	failed = copy_from_user(rt->rt_buffer + rt->rt_write, buffer, fl);
371	if (failed)	371	if (failed)
372	goto out;	372	goto out;
373		373
374	/* if there's any left copy to the beginning of the buffer */	374	/* if there's any left copy to the beginning of the buffer */
375	if (count - fl) {	375	if (count - fl) {
376	failed = copy_from_user(rt->rt_buffer, buffer + fl, count - fl);	376	failed = copy_from_user(rt->rt_buffer, buffer + fl, count - fl);
377	}	377	}
378		378
379	out:	379	out:
380	count -= failed;	380	count -= failed;
381		381
382	smp_wmb();	382	smp_wmb();
383	rt->rt_write = (rt->rt_write + count) % rt->buffer_size;	383	rt->rt_write = (rt->rt_write + count) % rt->buffer_size;
384	smp_wmb();	384	smp_wmb();
385	mutex_unlock(&channel_wqs[index].mutex);	385	mutex_unlock(&channel_wqs[index].mutex);
386		386
387	return count;	387	return count;
388	}	388	}
389		389
390		390
391	static int file_open(struct inode inode, struct file filp)	391	static int file_open(struct inode inode, struct file filp)
392	{	392	{
393	return rtlx_open(iminor(inode), (filp->f_flags & O_NONBLOCK) ? 0 : 1);	393	return rtlx_open(iminor(inode), (filp->f_flags & O_NONBLOCK) ? 0 : 1);
394	}	394	}
395		395
396	static int file_release(struct inode inode, struct file filp)	396	static int file_release(struct inode inode, struct file filp)
397	{	397	{
398	return rtlx_release(iminor(inode));	398	return rtlx_release(iminor(inode));
399	}	399	}
400		400
401	static unsigned int file_poll(struct file file, poll_table wait)	401	static unsigned int file_poll(struct file file, poll_table wait)
402	{	402	{
403	int minor = iminor(file_inode(file));	403	int minor = iminor(file_inode(file));
404	unsigned int mask = 0;	404	unsigned int mask = 0;
405		405
406	poll_wait(file, &channel_wqs[minor].rt_queue, wait);	406	poll_wait(file, &channel_wqs[minor].rt_queue, wait);
407	poll_wait(file, &channel_wqs[minor].lx_queue, wait);	407	poll_wait(file, &channel_wqs[minor].lx_queue, wait);
408		408
409	if (rtlx == NULL)	409	if (rtlx == NULL)
410	return 0;	410	return 0;
411		411
412	/* data available to read? */	412	/* data available to read? */
413	if (rtlx_read_poll(minor, 0))	413	if (rtlx_read_poll(minor, 0))
414	mask \|= POLLIN \| POLLRDNORM;	414	mask \|= POLLIN \| POLLRDNORM;
415		415
416	/* space to write */	416	/* space to write */
417	if (rtlx_write_poll(minor))	417	if (rtlx_write_poll(minor))
418	mask \|= POLLOUT \| POLLWRNORM;	418	mask \|= POLLOUT \| POLLWRNORM;
419		419
420	return mask;	420	return mask;
421	}	421	}
422		422
423	static ssize_t file_read(struct file file, char __user buffer, size_t count,	423	static ssize_t file_read(struct file file, char __user buffer, size_t count,
424	loff_t * ppos)	424	loff_t * ppos)
425	{	425	{
426	int minor = iminor(file_inode(file));	426	int minor = iminor(file_inode(file));
427		427
428	/* data available? */	428	/* data available? */
429	if (!rtlx_read_poll(minor, (file->f_flags & O_NONBLOCK) ? 0 : 1)) {	429	if (!rtlx_read_poll(minor, (file->f_flags & O_NONBLOCK) ? 0 : 1)) {
430	return 0; // -EAGAIN makes cat whinge	430	return 0; // -EAGAIN makes cat whinge
431	}	431	}
432		432
433	return rtlx_read(minor, buffer, count);	433	return rtlx_read(minor, buffer, count);
434	}	434	}
435		435
436	static ssize_t file_write(struct file file, const char __user buffer,	436	static ssize_t file_write(struct file file, const char __user buffer,
437	size_t count, loff_t * ppos)	437	size_t count, loff_t * ppos)
438	{	438	{
439	int minor = iminor(file_inode(file));	439	int minor = iminor(file_inode(file));
440		440
441	/* any space left... */	441	/* any space left... */
442	if (!rtlx_write_poll(minor)) {	442	if (!rtlx_write_poll(minor)) {
443	int ret = 0;	443	int ret;
444		444
445	if (file->f_flags & O_NONBLOCK)	445	if (file->f_flags & O_NONBLOCK)
446	return -EAGAIN;	446	return -EAGAIN;
447		447
448	__wait_event_interruptible(channel_wqs[minor].rt_queue,	448	ret = __wait_event_interruptible(channel_wqs[minor].rt_queue,
449	rtlx_write_poll(minor),	449	rtlx_write_poll(minor));
450	ret);
451	if (ret)	450	if (ret)
452	return ret;	451	return ret;
453	}	452	}
454		453
455	return rtlx_write(minor, buffer, count);	454	return rtlx_write(minor, buffer, count);
456	}	455	}
457		456
458	static const struct file_operations rtlx_fops = {	457	static const struct file_operations rtlx_fops = {
459	.owner = THIS_MODULE,	458	.owner = THIS_MODULE,
460	.open = file_open,	459	.open = file_open,
461	.release = file_release,	460	.release = file_release,
462	.write = file_write,	461	.write = file_write,
463	.read = file_read,	462	.read = file_read,
464	.poll = file_poll,	463	.poll = file_poll,
465	.llseek = noop_llseek,	464	.llseek = noop_llseek,
466	};	465	};
467		466
468	static struct irqaction rtlx_irq = {	467	static struct irqaction rtlx_irq = {
469	.handler = rtlx_interrupt,	468	.handler = rtlx_interrupt,
470	.name = "RTLX",	469	.name = "RTLX",
471	};	470	};
472		471
473	static int rtlx_irq_num = MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ;	472	static int rtlx_irq_num = MIPS_CPU_IRQ_BASE + MIPS_CPU_RTLX_IRQ;
474		473
475	static char register_chrdev_failed[] __initdata =	474	static char register_chrdev_failed[] __initdata =
476	KERN_ERR "rtlx_module_init: unable to register device\n";	475	KERN_ERR "rtlx_module_init: unable to register device\n";
477		476
478	static int __init rtlx_module_init(void)	477	static int __init rtlx_module_init(void)
479	{	478	{
480	struct device *dev;	479	struct device *dev;
481	int i, err;	480	int i, err;
482		481
483	if (!cpu_has_mipsmt) {	482	if (!cpu_has_mipsmt) {
484	printk("VPE loader: not a MIPS MT capable processor\n");	483	printk("VPE loader: not a MIPS MT capable processor\n");
485	return -ENODEV;	484	return -ENODEV;
486	}	485	}
487		486
488	if (tclimit == 0) {	487	if (tclimit == 0) {
489	printk(KERN_WARNING "No TCs reserved for AP/SP, not "	488	printk(KERN_WARNING "No TCs reserved for AP/SP, not "
490	"initializing RTLX.\nPass maxtcs=<n> argument as kernel "	489	"initializing RTLX.\nPass maxtcs=<n> argument as kernel "
491	"argument\n");	490	"argument\n");
492		491
493	return -ENODEV;	492	return -ENODEV;
494	}	493	}
495		494
496	major = register_chrdev(0, module_name, &rtlx_fops);	495	major = register_chrdev(0, module_name, &rtlx_fops);
497	if (major < 0) {	496	if (major < 0) {
498	printk(register_chrdev_failed);	497	printk(register_chrdev_failed);
499	return major;	498	return major;
500	}	499	}
501		500
502	/* initialise the wait queues */	501	/* initialise the wait queues */
503	for (i = 0; i < RTLX_CHANNELS; i++) {	502	for (i = 0; i < RTLX_CHANNELS; i++) {
504	init_waitqueue_head(&channel_wqs[i].rt_queue);	503	init_waitqueue_head(&channel_wqs[i].rt_queue);
505	init_waitqueue_head(&channel_wqs[i].lx_queue);	504	init_waitqueue_head(&channel_wqs[i].lx_queue);
506	atomic_set(&channel_wqs[i].in_open, 0);	505	atomic_set(&channel_wqs[i].in_open, 0);
507	mutex_init(&channel_wqs[i].mutex);	506	mutex_init(&channel_wqs[i].mutex);
508		507
509	dev = device_create(mt_class, NULL, MKDEV(major, i), NULL,	508	dev = device_create(mt_class, NULL, MKDEV(major, i), NULL,
510	"%s%d", module_name, i);	509	"%s%d", module_name, i);
511	if (IS_ERR(dev)) {	510	if (IS_ERR(dev)) {
512	err = PTR_ERR(dev);	511	err = PTR_ERR(dev);
513	goto out_chrdev;	512	goto out_chrdev;
514	}	513	}
515	}	514	}
516		515
517	/* set up notifiers */	516	/* set up notifiers */
518	notify.start = starting;	517	notify.start = starting;
519	notify.stop = stopping;	518	notify.stop = stopping;
520	vpe_notify(tclimit, &notify);	519	vpe_notify(tclimit, &notify);
521		520
522	if (cpu_has_vint)	521	if (cpu_has_vint)
523	set_vi_handler(MIPS_CPU_RTLX_IRQ, rtlx_dispatch);	522	set_vi_handler(MIPS_CPU_RTLX_IRQ, rtlx_dispatch);
524	else {	523	else {
525	pr_err("APRP RTLX init on non-vectored-interrupt processor\n");	524	pr_err("APRP RTLX init on non-vectored-interrupt processor\n");
526	err = -ENODEV;	525	err = -ENODEV;
527	goto out_chrdev;	526	goto out_chrdev;
528	}	527	}
529		528
530	rtlx_irq.dev_id = rtlx;	529	rtlx_irq.dev_id = rtlx;
531	setup_irq(rtlx_irq_num, &rtlx_irq);	530	setup_irq(rtlx_irq_num, &rtlx_irq);
532		531
533	return 0;	532	return 0;
534		533
535	out_chrdev:	534	out_chrdev:
536	for (i = 0; i < RTLX_CHANNELS; i++)	535	for (i = 0; i < RTLX_CHANNELS; i++)
537	device_destroy(mt_class, MKDEV(major, i));	536	device_destroy(mt_class, MKDEV(major, i));
538		537
539	return err;	538	return err;
540	}	539	}
541		540
542	static void __exit rtlx_module_exit(void)	541	static void __exit rtlx_module_exit(void)
543	{	542	{
544	int i;	543	int i;
545		544
546	for (i = 0; i < RTLX_CHANNELS; i++)	545	for (i = 0; i < RTLX_CHANNELS; i++)
547	device_destroy(mt_class, MKDEV(major, i));	546	device_destroy(mt_class, MKDEV(major, i));
548		547
549	unregister_chrdev(major, module_name);	548	unregister_chrdev(major, module_name);
550	}	549	}
551		550
552	module_init(rtlx_module_init);	551	module_init(rtlx_module_init);
553	module_exit(rtlx_module_exit);	552	module_exit(rtlx_module_exit);
554		553
555	MODULE_DESCRIPTION("MIPS RTLX");	554	MODULE_DESCRIPTION("MIPS RTLX");
556	MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");	555	MODULE_AUTHOR("Elizabeth Oldham, MIPS Technologies, Inc.");
557	MODULE_LICENSE("GPL");	556	MODULE_LICENSE("GPL");

include/linux/tty.h

Diff comments View file @ 35a2af9

include/linux/wait.h

Diff comments View file @ 35a2af9

 #ifndef _LINUX_WAIT_H
 #define _LINUX_WAIT_H
 #include <linux/list.h>
 #include <linux/stddef.h>
 #include <linux/spinlock.h>
 #include <asm/current.h>
 #include <uapi/linux/wait.h>
 typedef struct __wait_queue wait_queue_t;
 typedef int (*wait_queue_func_t)(wait_queue_t *wait, unsigned mode, int flags, void *key);
 int default_wake_function(wait_queue_t *wait, unsigned mode, int flags, void *key);
 struct __wait_queue {
 	unsigned int flags;
 #define WQ_FLAG_EXCLUSIVE	0x01
 	void *private;
 	wait_queue_func_t func;
 	struct list_head task_list;
 };
 struct wait_bit_key {
 	void *flags;
 	int bit_nr;
 #define WAIT_ATOMIC_T_BIT_NR -1
 };
 struct wait_bit_queue {
 	struct wait_bit_key key;
 	wait_queue_t wait;
 };
 struct __wait_queue_head {
 	spinlock_t lock;
 	struct list_head task_list;
 };
 typedef struct __wait_queue_head wait_queue_head_t;
 struct task_struct;
 /*
  * Macros for declaration and initialisaton of the datatypes
  */
 #define __WAITQUEUE_INITIALIZER(name, tsk) {				\
 	.private	= tsk,						\
 	.func		= default_wake_function,			\
 	.task_list	= { NULL, NULL } }
 #define DECLARE_WAITQUEUE(name, tsk)					\
 	wait_queue_t name = __WAITQUEUE_INITIALIZER(name, tsk)
 #define __WAIT_QUEUE_HEAD_INITIALIZER(name) {				\
 	.lock		= __SPIN_LOCK_UNLOCKED(name.lock),		\
 	.task_list	= { &(name).task_list, &(name).task_list } }
 #define DECLARE_WAIT_QUEUE_HEAD(name) \
 	wait_queue_head_t name = __WAIT_QUEUE_HEAD_INITIALIZER(name)
 #define __WAIT_BIT_KEY_INITIALIZER(word, bit)				\
 	{ .flags = word, .bit_nr = bit, }
 #define __WAIT_ATOMIC_T_KEY_INITIALIZER(p)				\
 	{ .flags = p, .bit_nr = WAIT_ATOMIC_T_BIT_NR, }
 extern void __init_waitqueue_head(wait_queue_head_t *q, const char *name, struct lock_class_key *);
 #define init_waitqueue_head(q)				\
 	do {						\
 		static struct lock_class_key __key;	\
 							\
 		__init_waitqueue_head((q), #q, &__key);	\
 	} while (0)
 #ifdef CONFIG_LOCKDEP
 # define __WAIT_QUEUE_HEAD_INIT_ONSTACK(name) \
 	({ init_waitqueue_head(&name); name; })
 # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) \
 	wait_queue_head_t name = __WAIT_QUEUE_HEAD_INIT_ONSTACK(name)
 #else
 # define DECLARE_WAIT_QUEUE_HEAD_ONSTACK(name) DECLARE_WAIT_QUEUE_HEAD(name)
 #endif
 static inline void init_waitqueue_entry(wait_queue_t *q, struct task_struct *p)
 {
 	q->flags = 0;
 	q->private = p;
 	q->func = default_wake_function;
 }
 static inline void init_waitqueue_func_entry(wait_queue_t *q,
 					wait_queue_func_t func)
 {
 	q->flags = 0;
 	q->private = NULL;
 	q->func = func;
 }
 static inline int waitqueue_active(wait_queue_head_t *q)
 {
 	return !list_empty(&q->task_list);
 }
 extern void add_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
 extern void add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t *wait);
 extern void remove_wait_queue(wait_queue_head_t *q, wait_queue_t *wait);
 static inline void __add_wait_queue(wait_queue_head_t *head, wait_queue_t *new)
 {
 	list_add(&new->task_list, &head->task_list);
 }
 /*
  * Used for wake-one threads:
  */
 static inline void __add_wait_queue_exclusive(wait_queue_head_t *q,
 					      wait_queue_t *wait)
 {
 	wait->flags |= WQ_FLAG_EXCLUSIVE;
 	__add_wait_queue(q, wait);
 }
 static inline void __add_wait_queue_tail(wait_queue_head_t *head,
 					 wait_queue_t *new)
 {
 	list_add_tail(&new->task_list, &head->task_list);
 }
 static inline void __add_wait_queue_tail_exclusive(wait_queue_head_t *q,
 					      wait_queue_t *wait)
 {
 	wait->flags |= WQ_FLAG_EXCLUSIVE;
 	__add_wait_queue_tail(q, wait);
 }
 static inline void __remove_wait_queue(wait_queue_head_t *head,
 							wait_queue_t *old)
 {
 	list_del(&old->task_list);
 }
 void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr, void *key);
 void __wake_up_locked_key(wait_queue_head_t *q, unsigned int mode, void *key);
 void __wake_up_sync_key(wait_queue_head_t *q, unsigned int mode, int nr,
 			void *key);
 void __wake_up_locked(wait_queue_head_t *q, unsigned int mode, int nr);
 void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr);
 void __wake_up_bit(wait_queue_head_t *, void *, int);
 int __wait_on_bit(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
 int __wait_on_bit_lock(wait_queue_head_t *, struct wait_bit_queue *, int (*)(void *), unsigned);
 void wake_up_bit(void *, int);
 void wake_up_atomic_t(atomic_t *);
 int out_of_line_wait_on_bit(void *, int, int (*)(void *), unsigned);
 int out_of_line_wait_on_bit_lock(void *, int, int (*)(void *), unsigned);
 int out_of_line_wait_on_atomic_t(atomic_t *, int (*)(atomic_t *), unsigned);
 wait_queue_head_t *bit_waitqueue(void *, int);
 #define wake_up(x)			__wake_up(x, TASK_NORMAL, 1, NULL)
 #define wake_up_nr(x, nr)		__wake_up(x, TASK_NORMAL, nr, NULL)
 #define wake_up_all(x)			__wake_up(x, TASK_NORMAL, 0, NULL)
 #define wake_up_locked(x)		__wake_up_locked((x), TASK_NORMAL, 1)
 #define wake_up_all_locked(x)		__wake_up_locked((x), TASK_NORMAL, 0)
 #define wake_up_interruptible(x)	__wake_up(x, TASK_INTERRUPTIBLE, 1, NULL)
 #define wake_up_interruptible_nr(x, nr)	__wake_up(x, TASK_INTERRUPTIBLE, nr, NULL)
 #define wake_up_interruptible_all(x)	__wake_up(x, TASK_INTERRUPTIBLE, 0, NULL)
 #define wake_up_interruptible_sync(x)	__wake_up_sync((x), TASK_INTERRUPTIBLE, 1)
 /*
  * Wakeup macros to be used to report events to the targets.
  */
 #define wake_up_poll(x, m)				\
 	__wake_up(x, TASK_NORMAL, 1, (void *) (m))
 #define wake_up_locked_poll(x, m)				\
 	__wake_up_locked_key((x), TASK_NORMAL, (void *) (m))
 #define wake_up_interruptible_poll(x, m)			\
 	__wake_up(x, TASK_INTERRUPTIBLE, 1, (void *) (m))
 #define wake_up_interruptible_sync_poll(x, m)				\
 	__wake_up_sync_key((x), TASK_INTERRUPTIBLE, 1, (void *) (m))
-#define ___wait_cond_timeout(condition, ret)				\
+#define ___wait_cond_timeout(condition)					\
 ({									\
  	bool __cond = (condition);					\
- 	if (__cond && !ret)						\
+ 	if (__cond && !__ret)						\
- 		ret = 1;						\
+ 		__ret = 1;						\
- 	__cond || !ret;							\
+ 	__cond || !__ret;						\
 })
 #define ___wait_signal_pending(state)					\
 	((state == TASK_INTERRUPTIBLE && signal_pending(current)) ||	\
 	 (state == TASK_KILLABLE && fatal_signal_pending(current)))
-#define ___wait_nop_ret		int ret __always_unused
 #define ___wait_event(wq, condition, state, exclusive, ret, cmd)	\
-do {									\
+({									\
 	__label__ __out;						\
 	DEFINE_WAIT(__wait);						\
+	long __ret = ret;						\
 									\
 	for (;;) {							\
 		if (exclusive)						\
 			prepare_to_wait_exclusive(&wq, &__wait, state); \
 		else							\
 			prepare_to_wait(&wq, &__wait, state);		\
 									\
 		if (condition)						\
 			break;						\
 									\
 		if (___wait_signal_pending(state)) {			\
-			ret = -ERESTARTSYS;				\
+			__ret = -ERESTARTSYS;				\
 			if (exclusive) {				\
 				abort_exclusive_wait(&wq, &__wait, 	\
 						     state, NULL); 	\
 				goto __out;				\
 			}						\
 			break;						\
 		}							\
 									\
 		cmd;							\
 	}								\
 	finish_wait(&wq, &__wait);					\
-__out:	;								\
+__out:	__ret;								\
-} while (0)
+})
 #define __wait_event(wq, condition) 					\
-	___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0,		\
+	(void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0,	\
-		      ___wait_nop_ret, schedule())
+			    schedule())
 /**
  * wait_event - sleep until a condition gets true
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  *
  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
  * @condition evaluates to true. The @condition is checked each time
  * the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  */
 #define wait_event(wq, condition) 					\
 do {									\
 	if (condition)	 						\
 		break;							\
 	__wait_event(wq, condition);					\
 } while (0)
-#define __wait_event_timeout(wq, condition, ret)			\
+#define __wait_event_timeout(wq, condition, timeout)			\
-	___wait_event(wq, ___wait_cond_timeout(condition, ret), 	\
+	___wait_event(wq, ___wait_cond_timeout(condition),		\
-		      TASK_UNINTERRUPTIBLE, 0, ret,			\
+		      TASK_UNINTERRUPTIBLE, 0, timeout,			\
-		      ret = schedule_timeout(ret))
+		      __ret = schedule_timeout(__ret))
 /**
  * wait_event_timeout - sleep until a condition gets true or a timeout elapses
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  * @timeout: timeout, in jiffies
  *
  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
  * @condition evaluates to true. The @condition is checked each time
  * the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * The function returns 0 if the @timeout elapsed, or the remaining
  * jiffies (at least 1) if the @condition evaluated to %true before
  * the @timeout elapsed.
  */
 #define wait_event_timeout(wq, condition, timeout)			\
 ({									\
 	long __ret = timeout;						\
 	if (!(condition)) 						\
-		__wait_event_timeout(wq, condition, __ret);		\
+		__ret = __wait_event_timeout(wq, condition, timeout);	\
 	__ret;								\
 })
-#define __wait_event_interruptible(wq, condition, ret)			\
+#define __wait_event_interruptible(wq, condition)			\
-	___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, ret,	\
+	___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0,		\
 		      schedule())
 /**
  * wait_event_interruptible - sleep until a condition gets true
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  *
  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  * @condition evaluates to true or a signal is received.
  * The @condition is checked each time the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * The function will return -ERESTARTSYS if it was interrupted by a
  * signal and 0 if @condition evaluated to true.
  */
 #define wait_event_interruptible(wq, condition)				\
 ({									\
 	int __ret = 0;							\
 	if (!(condition))						\
-		__wait_event_interruptible(wq, condition, __ret);	\
+		__ret = __wait_event_interruptible(wq, condition);	\
 	__ret;								\
 })
-#define __wait_event_interruptible_timeout(wq, condition, ret)		\
+#define __wait_event_interruptible_timeout(wq, condition, timeout)	\
-	___wait_event(wq, ___wait_cond_timeout(condition, ret),		\
+	___wait_event(wq, ___wait_cond_timeout(condition),		\
-		      TASK_INTERRUPTIBLE, 0, ret,			\
+		      TASK_INTERRUPTIBLE, 0, timeout,			\
-		      ret = schedule_timeout(ret))
+		      __ret = schedule_timeout(__ret))
 /**
  * wait_event_interruptible_timeout - sleep until a condition gets true or a timeout elapses
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  * @timeout: timeout, in jiffies
  *
  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  * @condition evaluates to true or a signal is received.
  * The @condition is checked each time the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * Returns:
  * 0 if the @timeout elapsed, -%ERESTARTSYS if it was interrupted by
  * a signal, or the remaining jiffies (at least 1) if the @condition
  * evaluated to %true before the @timeout elapsed.
  */
 #define wait_event_interruptible_timeout(wq, condition, timeout)	\
 ({									\
 	long __ret = timeout;						\
 	if (!(condition))						\
-		__wait_event_interruptible_timeout(wq, condition, __ret); \
+		__ret = __wait_event_interruptible_timeout(wq, 		\
+						condition, timeout);	\
 	__ret;								\
 })
 #define __wait_event_hrtimeout(wq, condition, timeout, state)		\
 ({									\
 	int __ret = 0;							\
 	struct hrtimer_sleeper __t;					\
 									\
 	hrtimer_init_on_stack(&__t.timer, CLOCK_MONOTONIC,		\
 			      HRTIMER_MODE_REL);			\
 	hrtimer_init_sleeper(&__t, current);				\
 	if ((timeout).tv64 != KTIME_MAX)				\
 		hrtimer_start_range_ns(&__t.timer, timeout,		\
 				       current->timer_slack_ns,		\
 				       HRTIMER_MODE_REL);		\
 									\
-	___wait_event(wq, condition, state, 0, __ret,			\
+	__ret = ___wait_event(wq, condition, state, 0, 0,		\
 		if (!__t.task) {					\
 			__ret = -ETIME;					\
 			break;						\
 		}							\
 		schedule());						\
 									\
 	hrtimer_cancel(&__t.timer);					\
 	destroy_hrtimer_on_stack(&__t.timer);				\
 	__ret;								\
 })
 /**
  * wait_event_hrtimeout - sleep until a condition gets true or a timeout elapses
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  * @timeout: timeout, as a ktime_t
  *
  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
  * @condition evaluates to true or a signal is received.
  * The @condition is checked each time the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * The function returns 0 if @condition became true, or -ETIME if the timeout
  * elapsed.
  */
 #define wait_event_hrtimeout(wq, condition, timeout)			\
 ({									\
 	int __ret = 0;							\
 	if (!(condition))						\
 		__ret = __wait_event_hrtimeout(wq, condition, timeout,	\
 					       TASK_UNINTERRUPTIBLE);	\
 	__ret;								\
 })
 /**
  * wait_event_interruptible_hrtimeout - sleep until a condition gets true or a timeout elapses
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  * @timeout: timeout, as a ktime_t
  *
  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  * @condition evaluates to true or a signal is received.
  * The @condition is checked each time the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * The function returns 0 if @condition became true, -ERESTARTSYS if it was
  * interrupted by a signal, or -ETIME if the timeout elapsed.
  */
 #define wait_event_interruptible_hrtimeout(wq, condition, timeout)	\
 ({									\
 	long __ret = 0;							\
 	if (!(condition))						\
 		__ret = __wait_event_hrtimeout(wq, condition, timeout,	\
 					       TASK_INTERRUPTIBLE);	\
 	__ret;								\
 })
-#define __wait_event_interruptible_exclusive(wq, condition, ret)	\
+#define __wait_event_interruptible_exclusive(wq, condition)		\
-	___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, ret,	\
+	___wait_event(wq, condition, TASK_INTERRUPTIBLE, 1, 0,		\
 		      schedule())
 #define wait_event_interruptible_exclusive(wq, condition)		\
 ({									\
 	int __ret = 0;							\
 	if (!(condition))						\
-		__wait_event_interruptible_exclusive(wq, condition, __ret);\
+		__ret = __wait_event_interruptible_exclusive(wq, condition);\
 	__ret;								\
 })
 #define __wait_event_interruptible_locked(wq, condition, exclusive, irq) \
 ({									\
 	int __ret = 0;							\
 	DEFINE_WAIT(__wait);						\
 	if (exclusive)							\
 		__wait.flags |= WQ_FLAG_EXCLUSIVE;			\
 	do {								\
 		if (likely(list_empty(&__wait.task_list)))		\
 			__add_wait_queue_tail(&(wq), &__wait);		\
 		set_current_state(TASK_INTERRUPTIBLE);			\
 		if (signal_pending(current)) {				\
 			__ret = -ERESTARTSYS;				\
 			break;						\
 		}							\
 		if (irq)						\
 			spin_unlock_irq(&(wq).lock);			\
 		else							\
 			spin_unlock(&(wq).lock);			\
 		schedule();						\
 		if (irq)						\
 			spin_lock_irq(&(wq).lock);			\
 		else							\
 			spin_lock(&(wq).lock);				\
 	} while (!(condition));						\
 	__remove_wait_queue(&(wq), &__wait);				\
 	__set_current_state(TASK_RUNNING);				\
 	__ret;								\
 })
 /**
  * wait_event_interruptible_locked - sleep until a condition gets true
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  *
  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  * @condition evaluates to true or a signal is received.
  * The @condition is checked each time the waitqueue @wq is woken up.
  *
  * It must be called with wq.lock being held.  This spinlock is
  * unlocked while sleeping but @condition testing is done while lock
  * is held and when this macro exits the lock is held.
  *
  * The lock is locked/unlocked using spin_lock()/spin_unlock()
  * functions which must match the way they are locked/unlocked outside
  * of this macro.
  *
  * wake_up_locked() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * The function will return -ERESTARTSYS if it was interrupted by a
  * signal and 0 if @condition evaluated to true.
  */
 #define wait_event_interruptible_locked(wq, condition)			\
 	((condition)							\
 	 ? 0 : __wait_event_interruptible_locked(wq, condition, 0, 0))
 /**
  * wait_event_interruptible_locked_irq - sleep until a condition gets true
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  *
  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  * @condition evaluates to true or a signal is received.
  * The @condition is checked each time the waitqueue @wq is woken up.
  *
  * It must be called with wq.lock being held.  This spinlock is
  * unlocked while sleeping but @condition testing is done while lock
  * is held and when this macro exits the lock is held.
  *
  * The lock is locked/unlocked using spin_lock_irq()/spin_unlock_irq()
  * functions which must match the way they are locked/unlocked outside
  * of this macro.
  *
  * wake_up_locked() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * The function will return -ERESTARTSYS if it was interrupted by a
  * signal and 0 if @condition evaluated to true.
  */
 #define wait_event_interruptible_locked_irq(wq, condition)		\
 	((condition)							\
 	 ? 0 : __wait_event_interruptible_locked(wq, condition, 0, 1))
 /**
  * wait_event_interruptible_exclusive_locked - sleep exclusively until a condition gets true
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  *
  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  * @condition evaluates to true or a signal is received.
  * The @condition is checked each time the waitqueue @wq is woken up.
  *
  * It must be called with wq.lock being held.  This spinlock is
  * unlocked while sleeping but @condition testing is done while lock
  * is held and when this macro exits the lock is held.
  *
  * The lock is locked/unlocked using spin_lock()/spin_unlock()
  * functions which must match the way they are locked/unlocked outside
  * of this macro.
  *
  * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag
  * set thus when other process waits process on the list if this
  * process is awaken further processes are not considered.
  *
  * wake_up_locked() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * The function will return -ERESTARTSYS if it was interrupted by a
  * signal and 0 if @condition evaluated to true.
  */
 #define wait_event_interruptible_exclusive_locked(wq, condition)	\
 	((condition)							\
 	 ? 0 : __wait_event_interruptible_locked(wq, condition, 1, 0))
 /**
  * wait_event_interruptible_exclusive_locked_irq - sleep until a condition gets true
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  *
  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  * @condition evaluates to true or a signal is received.
  * The @condition is checked each time the waitqueue @wq is woken up.
  *
  * It must be called with wq.lock being held.  This spinlock is
  * unlocked while sleeping but @condition testing is done while lock
  * is held and when this macro exits the lock is held.
  *
  * The lock is locked/unlocked using spin_lock_irq()/spin_unlock_irq()
  * functions which must match the way they are locked/unlocked outside
  * of this macro.
  *
  * The process is put on the wait queue with an WQ_FLAG_EXCLUSIVE flag
  * set thus when other process waits process on the list if this
  * process is awaken further processes are not considered.
  *
  * wake_up_locked() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * The function will return -ERESTARTSYS if it was interrupted by a
  * signal and 0 if @condition evaluated to true.
  */
 #define wait_event_interruptible_exclusive_locked_irq(wq, condition)	\
 	((condition)							\
 	 ? 0 : __wait_event_interruptible_locked(wq, condition, 1, 1))
-#define __wait_event_killable(wq, condition, ret)			\
+#define __wait_event_killable(wq, condition)				\
-	___wait_event(wq, condition, TASK_KILLABLE, 0, ret, schedule())
+	___wait_event(wq, condition, TASK_KILLABLE, 0, 0, schedule())
 /**
  * wait_event_killable - sleep until a condition gets true
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  *
  * The process is put to sleep (TASK_KILLABLE) until the
  * @condition evaluates to true or a signal is received.
  * The @condition is checked each time the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * The function will return -ERESTARTSYS if it was interrupted by a
  * signal and 0 if @condition evaluated to true.
  */
 #define wait_event_killable(wq, condition)				\
 ({									\
 	int __ret = 0;							\
 	if (!(condition))						\
-		__wait_event_killable(wq, condition, __ret);		\
+		__ret = __wait_event_killable(wq, condition);		\
 	__ret;								\
 })
 #define __wait_event_lock_irq(wq, condition, lock, cmd)			\
-	___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0,		\
+	(void)___wait_event(wq, condition, TASK_UNINTERRUPTIBLE, 0, 0,	\
-		      ___wait_nop_ret,					\
+			    spin_unlock_irq(&lock);			\
-		      spin_unlock_irq(&lock);				\
+			    cmd;					\
-		      cmd;						\
+			    schedule();					\
-		      schedule();					\
+			    spin_lock_irq(&lock))
-		      spin_lock_irq(&lock))
 /**
  * wait_event_lock_irq_cmd - sleep until a condition gets true. The
  *			     condition is checked under the lock. This
  *			     is expected to be called with the lock
  *			     taken.
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  * @lock: a locked spinlock_t, which will be released before cmd
  *	  and schedule() and reacquired afterwards.
  * @cmd: a command which is invoked outside the critical section before
  *	 sleep
  *
  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
  * @condition evaluates to true. The @condition is checked each time
  * the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * This is supposed to be called while holding the lock. The lock is
  * dropped before invoking the cmd and going to sleep and is reacquired
  * afterwards.
  */
 #define wait_event_lock_irq_cmd(wq, condition, lock, cmd)		\
 do {									\
 	if (condition)							\
 		break;							\
 	__wait_event_lock_irq(wq, condition, lock, cmd);		\
 } while (0)
 /**
  * wait_event_lock_irq - sleep until a condition gets true. The
  *			 condition is checked under the lock. This
  *			 is expected to be called with the lock
  *			 taken.
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  * @lock: a locked spinlock_t, which will be released before schedule()
  *	  and reacquired afterwards.
  *
  * The process is put to sleep (TASK_UNINTERRUPTIBLE) until the
  * @condition evaluates to true. The @condition is checked each time
  * the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * This is supposed to be called while holding the lock. The lock is
  * dropped before going to sleep and is reacquired afterwards.
  */
 #define wait_event_lock_irq(wq, condition, lock)			\
 do {									\
 	if (condition)							\
 		break;							\
 	__wait_event_lock_irq(wq, condition, lock, );			\
 } while (0)
-#define __wait_event_interruptible_lock_irq(wq, condition, lock, ret, cmd) \
+#define __wait_event_interruptible_lock_irq(wq, condition, lock, cmd)	\
-	___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, ret,	   \
+	___wait_event(wq, condition, TASK_INTERRUPTIBLE, 0, 0,	   	\
-		      spin_unlock_irq(&lock);				   \
+		      spin_unlock_irq(&lock);				\
-		      cmd;						   \
+		      cmd;						\
-		      schedule();					   \
+		      schedule();					\
 		      spin_lock_irq(&lock))
 /**
  * wait_event_interruptible_lock_irq_cmd - sleep until a condition gets true.
  *		The condition is checked under the lock. This is expected to
  *		be called with the lock taken.
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  * @lock: a locked spinlock_t, which will be released before cmd and
  *	  schedule() and reacquired afterwards.
  * @cmd: a command which is invoked outside the critical section before
  *	 sleep
  *
  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  * @condition evaluates to true or a signal is received. The @condition is
  * checked each time the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * This is supposed to be called while holding the lock. The lock is
  * dropped before invoking the cmd and going to sleep and is reacquired
  * afterwards.
  *
  * The macro will return -ERESTARTSYS if it was interrupted by a signal
  * and 0 if @condition evaluated to true.
  */
 #define wait_event_interruptible_lock_irq_cmd(wq, condition, lock, cmd)	\
 ({									\
 	int __ret = 0;							\
-									\
 	if (!(condition))						\
-		__wait_event_interruptible_lock_irq(wq, condition,	\
+		__ret = __wait_event_interruptible_lock_irq(wq, 	\
-						    lock, __ret, cmd);	\
+						condition, lock, cmd);	\
 	__ret;								\
 })
 /**
  * wait_event_interruptible_lock_irq - sleep until a condition gets true.
  *		The condition is checked under the lock. This is expected
  *		to be called with the lock taken.
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  * @lock: a locked spinlock_t, which will be released before schedule()
  *	  and reacquired afterwards.
  *
  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  * @condition evaluates to true or signal is received. The @condition is
  * checked each time the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * This is supposed to be called while holding the lock. The lock is
  * dropped before going to sleep and is reacquired afterwards.
  *
  * The macro will return -ERESTARTSYS if it was interrupted by a signal
  * and 0 if @condition evaluated to true.
  */
 #define wait_event_interruptible_lock_irq(wq, condition, lock)		\
 ({									\
 	int __ret = 0;							\
-									\
 	if (!(condition))						\
-		__wait_event_interruptible_lock_irq(wq, condition,	\
+		__ret = __wait_event_interruptible_lock_irq(wq,		\
-						    lock, __ret, );	\
+						condition, lock,)	\
 	__ret;								\
 })
-#define __wait_event_interruptible_lock_irq_timeout(wq, condition, lock, ret) \
+#define __wait_event_interruptible_lock_irq_timeout(wq, condition, 	\
-	___wait_event(wq, ___wait_cond_timeout(condition, ret),		      \
+						    lock, timeout) 	\
-		      TASK_INTERRUPTIBLE, 0, ret,	      		      \
+	___wait_event(wq, ___wait_cond_timeout(condition),		\
-		      spin_unlock_irq(&lock);				      \
+		      TASK_INTERRUPTIBLE, 0, ret,	      		\
-		      ret = schedule_timeout(ret);			      \
+		      spin_unlock_irq(&lock);				\
+		      __ret = schedule_timeout(__ret);			\
 		      spin_lock_irq(&lock));
 /**
  * wait_event_interruptible_lock_irq_timeout - sleep until a condition gets true or a timeout elapses.
  *		The condition is checked under the lock. This is expected
  *		to be called with the lock taken.
  * @wq: the waitqueue to wait on
  * @condition: a C expression for the event to wait for
  * @lock: a locked spinlock_t, which will be released before schedule()
  *	  and reacquired afterwards.
  * @timeout: timeout, in jiffies
  *
  * The process is put to sleep (TASK_INTERRUPTIBLE) until the
  * @condition evaluates to true or signal is received. The @condition is
  * checked each time the waitqueue @wq is woken up.
  *
  * wake_up() has to be called after changing any variable that could
  * change the result of the wait condition.
  *
  * This is supposed to be called while holding the lock. The lock is
  * dropped before going to sleep and is reacquired afterwards.
  *
  * The function returns 0 if the @timeout elapsed, -ERESTARTSYS if it
  * was interrupted by a signal, and the remaining jiffies otherwise
  * if the condition evaluated to true before the timeout elapsed.
  */
 #define wait_event_interruptible_lock_irq_timeout(wq, condition, lock,	\
 						  timeout)		\
 ({									\
-	int __ret = timeout;						\
+	long __ret = timeout;						\
-									\
 	if (!(condition))						\
-		__wait_event_interruptible_lock_irq_timeout(		\
+		__ret = __wait_event_interruptible_lock_irq_timeout(	\
-					wq, condition, lock, __ret);	\
+					wq, condition, lock, timeout);	\
 	__ret;								\
 })
 /*
  * These are the old interfaces to sleep waiting for an event.
  * They are racy.  DO NOT use them, use the wait_event* interfaces above.
  * We plan to remove these interfaces.
  */
 extern void sleep_on(wait_queue_head_t *q);
 extern long sleep_on_timeout(wait_queue_head_t *q,
 				      signed long timeout);
 extern void interruptible_sleep_on(wait_queue_head_t *q);
 extern long interruptible_sleep_on_timeout(wait_queue_head_t *q,
 					   signed long timeout);
 /*
  * Waitqueues which are removed from the waitqueue_head at wakeup time
  */
 void prepare_to_wait(wait_queue_head_t *q, wait_queue_t *wait, int state);
 void prepare_to_wait_exclusive(wait_queue_head_t *q, wait_queue_t *wait, int state);
 void finish_wait(wait_queue_head_t *q, wait_queue_t *wait);
 void abort_exclusive_wait(wait_queue_head_t *q, wait_queue_t *wait,
 			unsigned int mode, void *key);
 int autoremove_wake_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
 int wake_bit_function(wait_queue_t *wait, unsigned mode, int sync, void *key);
 #define DEFINE_WAIT_FUNC(name, function)				\
 	wait_queue_t name = {						\
 		.private	= current,				\
 		.func		= function,				\
 		.task_list	= LIST_HEAD_INIT((name).task_list),	\
 	}
 #define DEFINE_WAIT(name) DEFINE_WAIT_FUNC(name, autoremove_wake_function)
 #define DEFINE_WAIT_BIT(name, word, bit)				\
 	struct wait_bit_queue name = {					\
 		.key = __WAIT_BIT_KEY_INITIALIZER(word, bit),		\
 		.wait	= {						\
 			.private	= current,			\
 			.func		= wake_bit_function,		\
 			.task_list	=				\
 				LIST_HEAD_INIT((name).wait.task_list),	\
 		},							\
 	}
 #define init_wait(wait)							\
 	do {								\
 		(wait)->private = current;				\
 		(wait)->func = autoremove_wake_function;		\
 		INIT_LIST_HEAD(&(wait)->task_list);			\
 		(wait)->flags = 0;					\
 	} while (0)
 /**
  * wait_on_bit - wait for a bit to be cleared
  * @word: the word being waited on, a kernel virtual address
  * @bit: the bit of the word being waited on
  * @action: the function used to sleep, which may take special actions
  * @mode: the task state to sleep in
  *
  * There is a standard hashed waitqueue table for generic use. This
  * is the part of the hashtable's accessor API that waits on a bit.
  * For instance, if one were to have waiters on a bitflag, one would
  * call wait_on_bit() in threads waiting for the bit to clear.
  * One uses wait_on_bit() where one is waiting for the bit to clear,
  * but has no intention of setting it.
  */
 static inline int wait_on_bit(void *word, int bit,
 				int (*action)(void *), unsigned mode)
 {
 	if (!test_bit(bit, word))
 		return 0;
 	return out_of_line_wait_on_bit(word, bit, action, mode);
 }
 /**
  * wait_on_bit_lock - wait for a bit to be cleared, when wanting to set it
  * @word: the word being waited on, a kernel virtual address
  * @bit: the bit of the word being waited on
  * @action: the function used to sleep, which may take special actions
  * @mode: the task state to sleep in
  *
  * There is a standard hashed waitqueue table for generic use. This
  * is the part of the hashtable's accessor API that waits on a bit
  * when one intends to set it, for instance, trying to lock bitflags.
  * For instance, if one were to have waiters trying to set bitflag
  * and waiting for it to clear before setting it, one would call
  * wait_on_bit() in threads waiting to be able to set the bit.
  * One uses wait_on_bit_lock() where one is waiting for the bit to
  * clear with the intention of setting it, and when done, clearing it.
  */
 static inline int wait_on_bit_lock(void *word, int bit,
 				int (*action)(void *), unsigned mode)
 {
 	if (!test_and_set_bit(bit, word))
 		return 0;
 	return out_of_line_wait_on_bit_lock(word, bit, action, mode);
 }
 /**
  * wait_on_atomic_t - Wait for an atomic_t to become 0
  * @val: The atomic value being waited on, a kernel virtual address
  * @action: the function used to sleep, which may take special actions
  * @mode: the task state to sleep in
  *
  * Wait for an atomic_t to become 0.  We abuse the bit-wait waitqueue table for
  * the purpose of getting a waitqueue, but we set the key to a bit number
  * outside of the target 'word'.
  */
 static inline
 int wait_on_atomic_t(atomic_t *val, int (*action)(atomic_t *), unsigned mode)
 {
 	if (atomic_read(val) == 0)
 		return 0;
 	return out_of_line_wait_on_atomic_t(val, action, mode);
 }

net/irda/af_irda.c

Diff comments View file @ 35a2af9

 /*********************************************************************
  *
  * Filename:      af_irda.c
  * Version:       0.9
  * Description:   IrDA sockets implementation
  * Status:        Stable
  * Author:        Dag Brattli <dagb@cs.uit.no>
  * Created at:    Sun May 31 10:12:43 1998
  * Modified at:   Sat Dec 25 21:10:23 1999
  * Modified by:   Dag Brattli <dag@brattli.net>
  * Sources:       af_netroom.c, af_ax25.c, af_rose.c, af_x25.c etc.
  *
  *     Copyright (c) 1999 Dag Brattli <dagb@cs.uit.no>
  *     Copyright (c) 1999-2003 Jean Tourrilhes <jt@hpl.hp.com>
  *     All Rights Reserved.
  *
  *     This program is free software; you can redistribute it and/or
  *     modify it under the terms of the GNU General Public License as
  *     published by the Free Software Foundation; either version 2 of
  *     the License, or (at your option) any later version.
  *
  *     This program is distributed in the hope that it will be useful,
  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  *     GNU General Public License for more details.
  *
  *     You should have received a copy of the GNU General Public License
  *     along with this program; if not, write to the Free Software
  *     Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  *     MA 02111-1307 USA
  *
  *     Linux-IrDA now supports four different types of IrDA sockets:
  *
  *     o SOCK_STREAM:    TinyTP connections with SAR disabled. The
  *                       max SDU size is 0 for conn. of this type
  *     o SOCK_SEQPACKET: TinyTP connections with SAR enabled. TTP may
  *                       fragment the messages, but will preserve
  *                       the message boundaries
  *     o SOCK_DGRAM:     IRDAPROTO_UNITDATA: TinyTP connections with Unitdata
  *                       (unreliable) transfers
  *                       IRDAPROTO_ULTRA: Connectionless and unreliable data
  *
  ********************************************************************/
 #include <linux/capability.h>
 #include <linux/module.h>
 #include <linux/types.h>
 #include <linux/socket.h>
 #include <linux/sockios.h>
 #include <linux/slab.h>
 #include <linux/init.h>
 #include <linux/net.h>
 #include <linux/irda.h>
 #include <linux/poll.h>
 #include <asm/ioctls.h>		/* TIOCOUTQ, TIOCINQ */
 #include <asm/uaccess.h>
 #include <net/sock.h>
 #include <net/tcp_states.h>
 #include <net/irda/af_irda.h>
 static int irda_create(struct net *net, struct socket *sock, int protocol, int kern);
 static const struct proto_ops irda_stream_ops;
 static const struct proto_ops irda_seqpacket_ops;
 static const struct proto_ops irda_dgram_ops;
 #ifdef CONFIG_IRDA_ULTRA
 static const struct proto_ops irda_ultra_ops;
 #define ULTRA_MAX_DATA 382
 #endif /* CONFIG_IRDA_ULTRA */
 #define IRDA_MAX_HEADER (TTP_MAX_HEADER)
 /*
  * Function irda_data_indication (instance, sap, skb)
  *
  *    Received some data from TinyTP. Just queue it on the receive queue
  *
  */
 static int irda_data_indication(void *instance, void *sap, struct sk_buff *skb)
 {
 	struct irda_sock *self;
 	struct sock *sk;
 	int err;
 	IRDA_DEBUG(3, "%s()\n", __func__);
 	self = instance;
 	sk = instance;
 	err = sock_queue_rcv_skb(sk, skb);
 	if (err) {
 		IRDA_DEBUG(1, "%s(), error: no more mem!\n", __func__);
 		self->rx_flow = FLOW_STOP;
 		/* When we return error, TTP will need to requeue the skb */
 		return err;
 	}
 	return 0;
 }
 /*
  * Function irda_disconnect_indication (instance, sap, reason, skb)
  *
  *    Connection has been closed. Check reason to find out why
  *
  */
 static void irda_disconnect_indication(void *instance, void *sap,
 				       LM_REASON reason, struct sk_buff *skb)
 {
 	struct irda_sock *self;
 	struct sock *sk;
 	self = instance;
 	IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 	/* Don't care about it, but let's not leak it */
 	if(skb)
 		dev_kfree_skb(skb);
 	sk = instance;
 	if (sk == NULL) {
 		IRDA_DEBUG(0, "%s(%p) : BUG : sk is NULL\n",
 			   __func__, self);
 		return;
 	}
 	/* Prevent race conditions with irda_release() and irda_shutdown() */
 	bh_lock_sock(sk);
 	if (!sock_flag(sk, SOCK_DEAD) && sk->sk_state != TCP_CLOSE) {
 		sk->sk_state     = TCP_CLOSE;
 		sk->sk_shutdown |= SEND_SHUTDOWN;
 		sk->sk_state_change(sk);
 		/* Close our TSAP.
 		 * If we leave it open, IrLMP put it back into the list of
 		 * unconnected LSAPs. The problem is that any incoming request
 		 * can then be matched to this socket (and it will be, because
 		 * it is at the head of the list). This would prevent any
 		 * listening socket waiting on the same TSAP to get those
 		 * requests. Some apps forget to close sockets, or hang to it
 		 * a bit too long, so we may stay in this dead state long
 		 * enough to be noticed...
 		 * Note : all socket function do check sk->sk_state, so we are
 		 * safe...
 		 * Jean II
 		 */
 		if (self->tsap) {
 			irttp_close_tsap(self->tsap);
 			self->tsap = NULL;
 		}
 	}
 	bh_unlock_sock(sk);
 	/* Note : once we are there, there is not much you want to do
 	 * with the socket anymore, apart from closing it.
 	 * For example, bind() and connect() won't reset sk->sk_err,
 	 * sk->sk_shutdown and sk->sk_flags to valid values...
 	 * Jean II
 	 */
 }
 /*
  * Function irda_connect_confirm (instance, sap, qos, max_sdu_size, skb)
  *
  *    Connections has been confirmed by the remote device
  *
  */
 static void irda_connect_confirm(void *instance, void *sap,
 				 struct qos_info *qos,
 				 __u32 max_sdu_size, __u8 max_header_size,
 				 struct sk_buff *skb)
 {
 	struct irda_sock *self;
 	struct sock *sk;
 	self = instance;
 	IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 	sk = instance;
 	if (sk == NULL) {
 		dev_kfree_skb(skb);
 		return;
 	}
 	dev_kfree_skb(skb);
 	// Should be ??? skb_queue_tail(&sk->sk_receive_queue, skb);
 	/* How much header space do we need to reserve */
 	self->max_header_size = max_header_size;
 	/* IrTTP max SDU size in transmit direction */
 	self->max_sdu_size_tx = max_sdu_size;
 	/* Find out what the largest chunk of data that we can transmit is */
 	switch (sk->sk_type) {
 	case SOCK_STREAM:
 		if (max_sdu_size != 0) {
 			IRDA_ERROR("%s: max_sdu_size must be 0\n",
 				   __func__);
 			return;
 		}
 		self->max_data_size = irttp_get_max_seg_size(self->tsap);
 		break;
 	case SOCK_SEQPACKET:
 		if (max_sdu_size == 0) {
 			IRDA_ERROR("%s: max_sdu_size cannot be 0\n",
 				   __func__);
 			return;
 		}
 		self->max_data_size = max_sdu_size;
 		break;
 	default:
 		self->max_data_size = irttp_get_max_seg_size(self->tsap);
 	}
 	IRDA_DEBUG(2, "%s(), max_data_size=%d\n", __func__,
 		   self->max_data_size);
 	memcpy(&self->qos_tx, qos, sizeof(struct qos_info));
 	/* We are now connected! */
 	sk->sk_state = TCP_ESTABLISHED;
 	sk->sk_state_change(sk);
 }
 /*
  * Function irda_connect_indication(instance, sap, qos, max_sdu_size, userdata)
  *
  *    Incoming connection
  *
  */
 static void irda_connect_indication(void *instance, void *sap,
 				    struct qos_info *qos, __u32 max_sdu_size,
 				    __u8 max_header_size, struct sk_buff *skb)
 {
 	struct irda_sock *self;
 	struct sock *sk;
 	self = instance;
 	IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 	sk = instance;
 	if (sk == NULL) {
 		dev_kfree_skb(skb);
 		return;
 	}
 	/* How much header space do we need to reserve */
 	self->max_header_size = max_header_size;
 	/* IrTTP max SDU size in transmit direction */
 	self->max_sdu_size_tx = max_sdu_size;
 	/* Find out what the largest chunk of data that we can transmit is */
 	switch (sk->sk_type) {
 	case SOCK_STREAM:
 		if (max_sdu_size != 0) {
 			IRDA_ERROR("%s: max_sdu_size must be 0\n",
 				   __func__);
 			kfree_skb(skb);
 			return;
 		}
 		self->max_data_size = irttp_get_max_seg_size(self->tsap);
 		break;
 	case SOCK_SEQPACKET:
 		if (max_sdu_size == 0) {
 			IRDA_ERROR("%s: max_sdu_size cannot be 0\n",
 				   __func__);
 			kfree_skb(skb);
 			return;
 		}
 		self->max_data_size = max_sdu_size;
 		break;
 	default:
 		self->max_data_size = irttp_get_max_seg_size(self->tsap);
 	}
 	IRDA_DEBUG(2, "%s(), max_data_size=%d\n", __func__,
 		   self->max_data_size);
 	memcpy(&self->qos_tx, qos, sizeof(struct qos_info));
 	skb_queue_tail(&sk->sk_receive_queue, skb);
 	sk->sk_state_change(sk);
 }
 /*
  * Function irda_connect_response (handle)
  *
  *    Accept incoming connection
  *
  */
 static void irda_connect_response(struct irda_sock *self)
 {
 	struct sk_buff *skb;
 	IRDA_DEBUG(2, "%s()\n", __func__);
 	skb = alloc_skb(TTP_MAX_HEADER + TTP_SAR_HEADER, GFP_KERNEL);
 	if (skb == NULL) {
 		IRDA_DEBUG(0, "%s() Unable to allocate sk_buff!\n",
 			   __func__);
 		return;
 	}
 	/* Reserve space for MUX_CONTROL and LAP header */
 	skb_reserve(skb, IRDA_MAX_HEADER);
 	irttp_connect_response(self->tsap, self->max_sdu_size_rx, skb);
 }
 /*
  * Function irda_flow_indication (instance, sap, flow)
  *
  *    Used by TinyTP to tell us if it can accept more data or not
  *
  */
 static void irda_flow_indication(void *instance, void *sap, LOCAL_FLOW flow)
 {
 	struct irda_sock *self;
 	struct sock *sk;
 	IRDA_DEBUG(2, "%s()\n", __func__);
 	self = instance;
 	sk = instance;
 	BUG_ON(sk == NULL);
 	switch (flow) {
 	case FLOW_STOP:
 		IRDA_DEBUG(1, "%s(), IrTTP wants us to slow down\n",
 			   __func__);
 		self->tx_flow = flow;
 		break;
 	case FLOW_START:
 		self->tx_flow = flow;
 		IRDA_DEBUG(1, "%s(), IrTTP wants us to start again\n",
 			   __func__);
 		wake_up_interruptible(sk_sleep(sk));
 		break;
 	default:
 		IRDA_DEBUG(0, "%s(), Unknown flow command!\n", __func__);
 		/* Unknown flow command, better stop */
 		self->tx_flow = flow;
 		break;
 	}
 }
 /*
  * Function irda_getvalue_confirm (obj_id, value, priv)
  *
  *    Got answer from remote LM-IAS, just pass object to requester...
  *
  * Note : duplicate from above, but we need our own version that
  * doesn't touch the dtsap_sel and save the full value structure...
  */
 static void irda_getvalue_confirm(int result, __u16 obj_id,
 				  struct ias_value *value, void *priv)
 {
 	struct irda_sock *self;
 	self = priv;
 	if (!self) {
 		IRDA_WARNING("%s: lost myself!\n", __func__);
 		return;
 	}
 	IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 	/* We probably don't need to make any more queries */
 	iriap_close(self->iriap);
 	self->iriap = NULL;
 	/* Check if request succeeded */
 	if (result != IAS_SUCCESS) {
 		IRDA_DEBUG(1, "%s(), IAS query failed! (%d)\n", __func__,
 			   result);
 		self->errno = result;	/* We really need it later */
 		/* Wake up any processes waiting for result */
 		wake_up_interruptible(&self->query_wait);
 		return;
 	}
 	/* Pass the object to the caller (so the caller must delete it) */
 	self->ias_result = value;
 	self->errno = 0;
 	/* Wake up any processes waiting for result */
 	wake_up_interruptible(&self->query_wait);
 }
 /*
  * Function irda_selective_discovery_indication (discovery)
  *
  *    Got a selective discovery indication from IrLMP.
  *
  * IrLMP is telling us that this node is new and matching our hint bit
  * filter. Wake up any process waiting for answer...
  */
 static void irda_selective_discovery_indication(discinfo_t *discovery,
 						DISCOVERY_MODE mode,
 						void *priv)
 {
 	struct irda_sock *self;
 	IRDA_DEBUG(2, "%s()\n", __func__);
 	self = priv;
 	if (!self) {
 		IRDA_WARNING("%s: lost myself!\n", __func__);
 		return;
 	}
 	/* Pass parameter to the caller */
 	self->cachedaddr = discovery->daddr;
 	/* Wake up process if its waiting for device to be discovered */
 	wake_up_interruptible(&self->query_wait);
 }
 /*
  * Function irda_discovery_timeout (priv)
  *
  *    Timeout in the selective discovery process
  *
  * We were waiting for a node to be discovered, but nothing has come up
  * so far. Wake up the user and tell him that we failed...
  */
 static void irda_discovery_timeout(u_long priv)
 {
 	struct irda_sock *self;
 	IRDA_DEBUG(2, "%s()\n", __func__);
 	self = (struct irda_sock *) priv;
 	BUG_ON(self == NULL);
 	/* Nothing for the caller */
 	self->cachelog = NULL;
 	self->cachedaddr = 0;
 	self->errno = -ETIME;
 	/* Wake up process if its still waiting... */
 	wake_up_interruptible(&self->query_wait);
 }
 /*
  * Function irda_open_tsap (self)
  *
  *    Open local Transport Service Access Point (TSAP)
  *
  */
 static int irda_open_tsap(struct irda_sock *self, __u8 tsap_sel, char *name)
 {
 	notify_t notify;
 	if (self->tsap) {
 		IRDA_DEBUG(0, "%s: busy!\n", __func__);
 		return -EBUSY;
 	}
 	/* Initialize callbacks to be used by the IrDA stack */
 	irda_notify_init(&notify);
 	notify.connect_confirm       = irda_connect_confirm;
 	notify.connect_indication    = irda_connect_indication;
 	notify.disconnect_indication = irda_disconnect_indication;
 	notify.data_indication       = irda_data_indication;
 	notify.udata_indication	     = irda_data_indication;
 	notify.flow_indication       = irda_flow_indication;
 	notify.instance = self;
 	strncpy(notify.name, name, NOTIFY_MAX_NAME);
 	self->tsap = irttp_open_tsap(tsap_sel, DEFAULT_INITIAL_CREDIT,
 				     &notify);
 	if (self->tsap == NULL) {
 		IRDA_DEBUG(0, "%s(), Unable to allocate TSAP!\n",
 			   __func__);
 		return -ENOMEM;
 	}
 	/* Remember which TSAP selector we actually got */
 	self->stsap_sel = self->tsap->stsap_sel;
 	return 0;
 }
 /*
  * Function irda_open_lsap (self)
  *
  *    Open local Link Service Access Point (LSAP). Used for opening Ultra
  *    sockets
  */
 #ifdef CONFIG_IRDA_ULTRA
 static int irda_open_lsap(struct irda_sock *self, int pid)
 {
 	notify_t notify;
 	if (self->lsap) {
 		IRDA_WARNING("%s(), busy!\n", __func__);
 		return -EBUSY;
 	}
 	/* Initialize callbacks to be used by the IrDA stack */
 	irda_notify_init(&notify);
 	notify.udata_indication	= irda_data_indication;
 	notify.instance = self;
 	strncpy(notify.name, "Ultra", NOTIFY_MAX_NAME);
 	self->lsap = irlmp_open_lsap(LSAP_CONNLESS, &notify, pid);
 	if (self->lsap == NULL) {
 		IRDA_DEBUG( 0, "%s(), Unable to allocate LSAP!\n", __func__);
 		return -ENOMEM;
 	}
 	return 0;
 }
 #endif /* CONFIG_IRDA_ULTRA */
 /*
  * Function irda_find_lsap_sel (self, name)
  *
  *    Try to lookup LSAP selector in remote LM-IAS
  *
  * Basically, we start a IAP query, and then go to sleep. When the query
  * return, irda_getvalue_confirm will wake us up, and we can examine the
  * result of the query...
  * Note that in some case, the query fail even before we go to sleep,
  * creating some races...
  */
 static int irda_find_lsap_sel(struct irda_sock *self, char *name)
 {
 	IRDA_DEBUG(2, "%s(%p, %s)\n", __func__, self, name);
 	if (self->iriap) {
 		IRDA_WARNING("%s(): busy with a previous query\n",
 			     __func__);
 		return -EBUSY;
 	}
 	self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
 				 irda_getvalue_confirm);
 	if(self->iriap == NULL)
 		return -ENOMEM;
 	/* Treat unexpected wakeup as disconnect */
 	self->errno = -EHOSTUNREACH;
 	/* Query remote LM-IAS */
 	iriap_getvaluebyclass_request(self->iriap, self->saddr, self->daddr,
 				      name, "IrDA:TinyTP:LsapSel");
 	/* Wait for answer, if not yet finished (or failed) */
 	if (wait_event_interruptible(self->query_wait, (self->iriap==NULL)))
 		/* Treat signals as disconnect */
 		return -EHOSTUNREACH;
 	/* Check what happened */
 	if (self->errno)
 	{
 		/* Requested object/attribute doesn't exist */
 		if((self->errno == IAS_CLASS_UNKNOWN) ||
 		   (self->errno == IAS_ATTRIB_UNKNOWN))
 			return -EADDRNOTAVAIL;
 		else
 			return -EHOSTUNREACH;
 	}
 	/* Get the remote TSAP selector */
 	switch (self->ias_result->type) {
 	case IAS_INTEGER:
 		IRDA_DEBUG(4, "%s() int=%d\n",
 			   __func__, self->ias_result->t.integer);
 		if (self->ias_result->t.integer != -1)
 			self->dtsap_sel = self->ias_result->t.integer;
 		else
 			self->dtsap_sel = 0;
 		break;
 	default:
 		self->dtsap_sel = 0;
 		IRDA_DEBUG(0, "%s(), bad type!\n", __func__);
 		break;
 	}
 	if (self->ias_result)
 		irias_delete_value(self->ias_result);
 	if (self->dtsap_sel)
 		return 0;
 	return -EADDRNOTAVAIL;
 }
 /*
  * Function irda_discover_daddr_and_lsap_sel (self, name)
  *
  *    This try to find a device with the requested service.
  *
  * It basically look into the discovery log. For each address in the list,
  * it queries the LM-IAS of the device to find if this device offer
  * the requested service.
  * If there is more than one node supporting the service, we complain
  * to the user (it should move devices around).
  * The, we set both the destination address and the lsap selector to point
  * on the service on the unique device we have found.
  *
  * Note : this function fails if there is more than one device in range,
  * because IrLMP doesn't disconnect the LAP when the last LSAP is closed.
  * Moreover, we would need to wait the LAP disconnection...
  */
 static int irda_discover_daddr_and_lsap_sel(struct irda_sock *self, char *name)
 {
 	discinfo_t *discoveries;	/* Copy of the discovery log */
 	int	number;			/* Number of nodes in the log */
 	int	i;
 	int	err = -ENETUNREACH;
 	__u32	daddr = DEV_ADDR_ANY;	/* Address we found the service on */
 	__u8	dtsap_sel = 0x0;	/* TSAP associated with it */
 	IRDA_DEBUG(2, "%s(), name=%s\n", __func__, name);
 	/* Ask lmp for the current discovery log
 	 * Note : we have to use irlmp_get_discoveries(), as opposed
 	 * to play with the cachelog directly, because while we are
 	 * making our ias query, le log might change... */
 	discoveries = irlmp_get_discoveries(&number, self->mask.word,
 					    self->nslots);
 	/* Check if the we got some results */
 	if (discoveries == NULL)
 		return -ENETUNREACH;	/* No nodes discovered */
 	/*
 	 * Now, check all discovered devices (if any), and connect
 	 * client only about the services that the client is
 	 * interested in...
 	 */
 	for(i = 0; i < number; i++) {
 		/* Try the address in the log */
 		self->daddr = discoveries[i].daddr;
 		self->saddr = 0x0;
 		IRDA_DEBUG(1, "%s(), trying daddr = %08x\n",
 			   __func__, self->daddr);
 		/* Query remote LM-IAS for this service */
 		err = irda_find_lsap_sel(self, name);
 		switch (err) {
 		case 0:
 			/* We found the requested service */
 			if(daddr != DEV_ADDR_ANY) {
 				IRDA_DEBUG(1, "%s(), discovered service ''%s'' in two different devices !!!\n",
 					   __func__, name);
 				self->daddr = DEV_ADDR_ANY;
 				kfree(discoveries);
 				return -ENOTUNIQ;
 			}
 			/* First time we found that one, save it ! */
 			daddr = self->daddr;
 			dtsap_sel = self->dtsap_sel;
 			break;
 		case -EADDRNOTAVAIL:
 			/* Requested service simply doesn't exist on this node */
 			break;
 		default:
 			/* Something bad did happen :-( */
 			IRDA_DEBUG(0, "%s(), unexpected IAS query failure\n", __func__);
 			self->daddr = DEV_ADDR_ANY;
 			kfree(discoveries);
 			return -EHOSTUNREACH;
 			break;
 		}
 	}
 	/* Cleanup our copy of the discovery log */
 	kfree(discoveries);
 	/* Check out what we found */
 	if(daddr == DEV_ADDR_ANY) {
 		IRDA_DEBUG(1, "%s(), cannot discover service ''%s'' in any device !!!\n",
 			   __func__, name);
 		self->daddr = DEV_ADDR_ANY;
 		return -EADDRNOTAVAIL;
 	}
 	/* Revert back to discovered device & service */
 	self->daddr = daddr;
 	self->saddr = 0x0;
 	self->dtsap_sel = dtsap_sel;
 	IRDA_DEBUG(1, "%s(), discovered requested service ''%s'' at address %08x\n",
 		   __func__, name, self->daddr);
 	return 0;
 }
 /*
  * Function irda_getname (sock, uaddr, uaddr_len, peer)
  *
  *    Return the our own, or peers socket address (sockaddr_irda)
  *
  */
 static int irda_getname(struct socket *sock, struct sockaddr *uaddr,
 			int *uaddr_len, int peer)
 {
 	struct sockaddr_irda saddr;
 	struct sock *sk = sock->sk;
 	struct irda_sock *self = irda_sk(sk);
 	memset(&saddr, 0, sizeof(saddr));
 	if (peer) {
 		if (sk->sk_state != TCP_ESTABLISHED)
 			return -ENOTCONN;
 		saddr.sir_family = AF_IRDA;
 		saddr.sir_lsap_sel = self->dtsap_sel;
 		saddr.sir_addr = self->daddr;
 	} else {
 		saddr.sir_family = AF_IRDA;
 		saddr.sir_lsap_sel = self->stsap_sel;
 		saddr.sir_addr = self->saddr;
 	}
 	IRDA_DEBUG(1, "%s(), tsap_sel = %#x\n", __func__, saddr.sir_lsap_sel);
 	IRDA_DEBUG(1, "%s(), addr = %08x\n", __func__, saddr.sir_addr);
 	/* uaddr_len come to us uninitialised */
 	*uaddr_len = sizeof (struct sockaddr_irda);
 	memcpy(uaddr, &saddr, *uaddr_len);
 	return 0;
 }
 /*
  * Function irda_listen (sock, backlog)
  *
  *    Just move to the listen state
  *
  */
 static int irda_listen(struct socket *sock, int backlog)
 {
 	struct sock *sk = sock->sk;
 	int err = -EOPNOTSUPP;
 	IRDA_DEBUG(2, "%s()\n", __func__);
 	lock_sock(sk);
 	if ((sk->sk_type != SOCK_STREAM) && (sk->sk_type != SOCK_SEQPACKET) &&
 	    (sk->sk_type != SOCK_DGRAM))
 		goto out;
 	if (sk->sk_state != TCP_LISTEN) {
 		sk->sk_max_ack_backlog = backlog;
 		sk->sk_state           = TCP_LISTEN;
 		err = 0;
 	}
 out:
 	release_sock(sk);
 	return err;
 }
 /*
  * Function irda_bind (sock, uaddr, addr_len)
  *
  *    Used by servers to register their well known TSAP
  *
  */
 static int irda_bind(struct socket *sock, struct sockaddr *uaddr, int addr_len)
 {
 	struct sock *sk = sock->sk;
 	struct sockaddr_irda *addr = (struct sockaddr_irda *) uaddr;
 	struct irda_sock *self = irda_sk(sk);
 	int err;
 	IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 	if (addr_len != sizeof(struct sockaddr_irda))
 		return -EINVAL;
 	lock_sock(sk);
 #ifdef CONFIG_IRDA_ULTRA
 	/* Special care for Ultra sockets */
 	if ((sk->sk_type == SOCK_DGRAM) &&
 	    (sk->sk_protocol == IRDAPROTO_ULTRA)) {
 		self->pid = addr->sir_lsap_sel;
 		err = -EOPNOTSUPP;
 		if (self->pid & 0x80) {
 			IRDA_DEBUG(0, "%s(), extension in PID not supp!\n", __func__);
 			goto out;
 		}
 		err = irda_open_lsap(self, self->pid);
 		if (err < 0)
 			goto out;
 		/* Pretend we are connected */
 		sock->state = SS_CONNECTED;
 		sk->sk_state   = TCP_ESTABLISHED;
 		err = 0;
 		goto out;
 	}
 #endif /* CONFIG_IRDA_ULTRA */
 	self->ias_obj = irias_new_object(addr->sir_name, jiffies);
 	err = -ENOMEM;
 	if (self->ias_obj == NULL)
 		goto out;
 	err = irda_open_tsap(self, addr->sir_lsap_sel, addr->sir_name);
 	if (err < 0) {
 		irias_delete_object(self->ias_obj);
 		self->ias_obj = NULL;
 		goto out;
 	}
 	/*  Register with LM-IAS */
 	irias_add_integer_attrib(self->ias_obj, "IrDA:TinyTP:LsapSel",
 				 self->stsap_sel, IAS_KERNEL_ATTR);
 	irias_insert_object(self->ias_obj);
 	err = 0;
 out:
 	release_sock(sk);
 	return err;
 }
 /*
  * Function irda_accept (sock, newsock, flags)
  *
  *    Wait for incoming connection
  *
  */
 static int irda_accept(struct socket *sock, struct socket *newsock, int flags)
 {
 	struct sock *sk = sock->sk;
 	struct irda_sock *new, *self = irda_sk(sk);
 	struct sock *newsk;
 	struct sk_buff *skb;
 	int err;
 	IRDA_DEBUG(2, "%s()\n", __func__);
 	err = irda_create(sock_net(sk), newsock, sk->sk_protocol, 0);
 	if (err)
 		return err;
 	err = -EINVAL;
 	lock_sock(sk);
 	if (sock->state != SS_UNCONNECTED)
 		goto out;
 	if ((sk = sock->sk) == NULL)
 		goto out;
 	err = -EOPNOTSUPP;
 	if ((sk->sk_type != SOCK_STREAM) && (sk->sk_type != SOCK_SEQPACKET) &&
 	    (sk->sk_type != SOCK_DGRAM))
 		goto out;
 	err = -EINVAL;
 	if (sk->sk_state != TCP_LISTEN)
 		goto out;
 	/*
 	 *	The read queue this time is holding sockets ready to use
 	 *	hooked into the SABM we saved
 	 */
 	/*
 	 * We can perform the accept only if there is incoming data
 	 * on the listening socket.
 	 * So, we will block the caller until we receive any data.
 	 * If the caller was waiting on select() or poll() before
 	 * calling us, the data is waiting for us ;-)
 	 * Jean II
 	 */
 	while (1) {
 		skb = skb_dequeue(&sk->sk_receive_queue);
 		if (skb)
 			break;
 		/* Non blocking operation */
 		err = -EWOULDBLOCK;
 		if (flags & O_NONBLOCK)
 			goto out;
 		err = wait_event_interruptible(*(sk_sleep(sk)),
 					skb_peek(&sk->sk_receive_queue));
 		if (err)
 			goto out;
 	}
 	newsk = newsock->sk;
 	err = -EIO;
 	if (newsk == NULL)
 		goto out;
 	newsk->sk_state = TCP_ESTABLISHED;
 	new = irda_sk(newsk);
 	/* Now attach up the new socket */
 	new->tsap = irttp_dup(self->tsap, new);
 	err = -EPERM; /* value does not seem to make sense. -arnd */
 	if (!new->tsap) {
 		IRDA_DEBUG(0, "%s(), dup failed!\n", __func__);
 		kfree_skb(skb);
 		goto out;
 	}
 	new->stsap_sel = new->tsap->stsap_sel;
 	new->dtsap_sel = new->tsap->dtsap_sel;
 	new->saddr = irttp_get_saddr(new->tsap);
 	new->daddr = irttp_get_daddr(new->tsap);
 	new->max_sdu_size_tx = self->max_sdu_size_tx;
 	new->max_sdu_size_rx = self->max_sdu_size_rx;
 	new->max_data_size   = self->max_data_size;
 	new->max_header_size = self->max_header_size;
 	memcpy(&new->qos_tx, &self->qos_tx, sizeof(struct qos_info));
 	/* Clean up the original one to keep it in listen state */
 	irttp_listen(self->tsap);
 	kfree_skb(skb);
 	sk->sk_ack_backlog--;
 	newsock->state = SS_CONNECTED;
 	irda_connect_response(new);
 	err = 0;
 out:
 	release_sock(sk);
 	return err;
 }
 /*
  * Function irda_connect (sock, uaddr, addr_len, flags)
  *
  *    Connect to a IrDA device
  *
  * The main difference with a "standard" connect is that with IrDA we need
  * to resolve the service name into a TSAP selector (in TCP, port number
  * doesn't have to be resolved).
  * Because of this service name resolution, we can offer "auto-connect",
  * where we connect to a service without specifying a destination address.
  *
  * Note : by consulting "errno", the user space caller may learn the cause
  * of the failure. Most of them are visible in the function, others may come
  * from subroutines called and are listed here :
  *	o EBUSY : already processing a connect
  *	o EHOSTUNREACH : bad addr->sir_addr argument
  *	o EADDRNOTAVAIL : bad addr->sir_name argument
  *	o ENOTUNIQ : more than one node has addr->sir_name (auto-connect)
  *	o ENETUNREACH : no node found on the network (auto-connect)
  */
 static int irda_connect(struct socket *sock, struct sockaddr *uaddr,
 			int addr_len, int flags)
 {
 	struct sock *sk = sock->sk;
 	struct sockaddr_irda *addr = (struct sockaddr_irda *) uaddr;
 	struct irda_sock *self = irda_sk(sk);
 	int err;
 	IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 	lock_sock(sk);
 	/* Don't allow connect for Ultra sockets */
 	err = -ESOCKTNOSUPPORT;
 	if ((sk->sk_type == SOCK_DGRAM) && (sk->sk_protocol == IRDAPROTO_ULTRA))
 		goto out;
 	if (sk->sk_state == TCP_ESTABLISHED && sock->state == SS_CONNECTING) {
 		sock->state = SS_CONNECTED;
 		err = 0;
 		goto out;   /* Connect completed during a ERESTARTSYS event */
 	}
 	if (sk->sk_state == TCP_CLOSE && sock->state == SS_CONNECTING) {
 		sock->state = SS_UNCONNECTED;
 		err = -ECONNREFUSED;
 		goto out;
 	}
 	err = -EISCONN;      /* No reconnect on a seqpacket socket */
 	if (sk->sk_state == TCP_ESTABLISHED)
 		goto out;
 	sk->sk_state   = TCP_CLOSE;
 	sock->state = SS_UNCONNECTED;
 	err = -EINVAL;
 	if (addr_len != sizeof(struct sockaddr_irda))
 		goto out;
 	/* Check if user supplied any destination device address */
 	if ((!addr->sir_addr) || (addr->sir_addr == DEV_ADDR_ANY)) {
 		/* Try to find one suitable */
 		err = irda_discover_daddr_and_lsap_sel(self, addr->sir_name);
 		if (err) {
 			IRDA_DEBUG(0, "%s(), auto-connect failed!\n", __func__);
 			goto out;
 		}
 	} else {
 		/* Use the one provided by the user */
 		self->daddr = addr->sir_addr;
 		IRDA_DEBUG(1, "%s(), daddr = %08x\n", __func__, self->daddr);
 		/* If we don't have a valid service name, we assume the
 		 * user want to connect on a specific LSAP. Prevent
 		 * the use of invalid LSAPs (IrLMP 1.1 p10). Jean II */
 		if((addr->sir_name[0] != '\0') ||
 		   (addr->sir_lsap_sel >= 0x70)) {
 			/* Query remote LM-IAS using service name */
 			err = irda_find_lsap_sel(self, addr->sir_name);
 			if (err) {
 				IRDA_DEBUG(0, "%s(), connect failed!\n", __func__);
 				goto out;
 			}
 		} else {
 			/* Directly connect to the remote LSAP
 			 * specified by the sir_lsap field.
 			 * Please use with caution, in IrDA LSAPs are
 			 * dynamic and there is no "well-known" LSAP. */
 			self->dtsap_sel = addr->sir_lsap_sel;
 		}
 	}
 	/* Check if we have opened a local TSAP */
 	if (!self->tsap)
 		irda_open_tsap(self, LSAP_ANY, addr->sir_name);
 	/* Move to connecting socket, start sending Connect Requests */
 	sock->state = SS_CONNECTING;
 	sk->sk_state   = TCP_SYN_SENT;
 	/* Connect to remote device */
 	err = irttp_connect_request(self->tsap, self->dtsap_sel,
 				    self->saddr, self->daddr, NULL,
 				    self->max_sdu_size_rx, NULL);
 	if (err) {
 		IRDA_DEBUG(0, "%s(), connect failed!\n", __func__);
 		goto out;
 	}
 	/* Now the loop */
 	err = -EINPROGRESS;
 	if (sk->sk_state != TCP_ESTABLISHED && (flags & O_NONBLOCK))
 		goto out;
 	err = -ERESTARTSYS;
 	if (wait_event_interruptible(*(sk_sleep(sk)),
 				     (sk->sk_state != TCP_SYN_SENT)))
 		goto out;
 	if (sk->sk_state != TCP_ESTABLISHED) {
 		sock->state = SS_UNCONNECTED;
 		if (sk->sk_prot->disconnect(sk, flags))
 			sock->state = SS_DISCONNECTING;
 		err = sock_error(sk);
 		if (!err)
 			err = -ECONNRESET;
 		goto out;
 	}
 	sock->state = SS_CONNECTED;
 	/* At this point, IrLMP has assigned our source address */
 	self->saddr = irttp_get_saddr(self->tsap);
 	err = 0;
 out:
 	release_sock(sk);
 	return err;
 }
 static struct proto irda_proto = {
 	.name	  = "IRDA",
 	.owner	  = THIS_MODULE,
 	.obj_size = sizeof(struct irda_sock),
 };
 /*
  * Function irda_create (sock, protocol)
  *
  *    Create IrDA socket
  *
  */
 static int irda_create(struct net *net, struct socket *sock, int protocol,
 		       int kern)
 {
 	struct sock *sk;
 	struct irda_sock *self;
 	IRDA_DEBUG(2, "%s()\n", __func__);
 	if (net != &init_net)
 		return -EAFNOSUPPORT;
 	/* Check for valid socket type */
 	switch (sock->type) {
 	case SOCK_STREAM:     /* For TTP connections with SAR disabled */
 	case SOCK_SEQPACKET:  /* For TTP connections with SAR enabled */
 	case SOCK_DGRAM:      /* For TTP Unitdata or LMP Ultra transfers */
 		break;
 	default:
 		return -ESOCKTNOSUPPORT;
 	}
 	/* Allocate networking socket */
 	sk = sk_alloc(net, PF_IRDA, GFP_KERNEL, &irda_proto);
 	if (sk == NULL)
 		return -ENOMEM;
 	self = irda_sk(sk);
 	IRDA_DEBUG(2, "%s() : self is %p\n", __func__, self);
 	init_waitqueue_head(&self->query_wait);
 	switch (sock->type) {
 	case SOCK_STREAM:
 		sock->ops = &irda_stream_ops;
 		self->max_sdu_size_rx = TTP_SAR_DISABLE;
 		break;
 	case SOCK_SEQPACKET:
 		sock->ops = &irda_seqpacket_ops;
 		self->max_sdu_size_rx = TTP_SAR_UNBOUND;
 		break;
 	case SOCK_DGRAM:
 		switch (protocol) {
 #ifdef CONFIG_IRDA_ULTRA
 		case IRDAPROTO_ULTRA:
 			sock->ops = &irda_ultra_ops;
 			/* Initialise now, because we may send on unbound
 			 * sockets. Jean II */
 			self->max_data_size = ULTRA_MAX_DATA - LMP_PID_HEADER;
 			self->max_header_size = IRDA_MAX_HEADER + LMP_PID_HEADER;
 			break;
 #endif /* CONFIG_IRDA_ULTRA */
 		case IRDAPROTO_UNITDATA:
 			sock->ops = &irda_dgram_ops;
 			/* We let Unitdata conn. be like seqpack conn. */
 			self->max_sdu_size_rx = TTP_SAR_UNBOUND;
 			break;
 		default:
 			sk_free(sk);
 			return -ESOCKTNOSUPPORT;
 		}
 		break;
 	default:
 		sk_free(sk);
 		return -ESOCKTNOSUPPORT;
 	}
 	/* Initialise networking socket struct */
 	sock_init_data(sock, sk);	/* Note : set sk->sk_refcnt to 1 */
 	sk->sk_family = PF_IRDA;
 	sk->sk_protocol = protocol;
 	/* Register as a client with IrLMP */
 	self->ckey = irlmp_register_client(0, NULL, NULL, NULL);
 	self->mask.word = 0xffff;
 	self->rx_flow = self->tx_flow = FLOW_START;
 	self->nslots = DISCOVERY_DEFAULT_SLOTS;
 	self->daddr = DEV_ADDR_ANY;	/* Until we get connected */
 	self->saddr = 0x0;		/* so IrLMP assign us any link */
 	return 0;
 }
 /*
  * Function irda_destroy_socket (self)
  *
  *    Destroy socket
  *
  */
 static void irda_destroy_socket(struct irda_sock *self)
 {
 	IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 	/* Unregister with IrLMP */
 	irlmp_unregister_client(self->ckey);
 	irlmp_unregister_service(self->skey);
 	/* Unregister with LM-IAS */
 	if (self->ias_obj) {
 		irias_delete_object(self->ias_obj);
 		self->ias_obj = NULL;
 	}
 	if (self->iriap) {
 		iriap_close(self->iriap);
 		self->iriap = NULL;
 	}
 	if (self->tsap) {
 		irttp_disconnect_request(self->tsap, NULL, P_NORMAL);
 		irttp_close_tsap(self->tsap);
 		self->tsap = NULL;
 	}
 #ifdef CONFIG_IRDA_ULTRA
 	if (self->lsap) {
 		irlmp_close_lsap(self->lsap);
 		self->lsap = NULL;
 	}
 #endif /* CONFIG_IRDA_ULTRA */
 }
 /*
  * Function irda_release (sock)
  */
 static int irda_release(struct socket *sock)
 {
 	struct sock *sk = sock->sk;
 	IRDA_DEBUG(2, "%s()\n", __func__);
 	if (sk == NULL)
 		return 0;
 	lock_sock(sk);
 	sk->sk_state       = TCP_CLOSE;
 	sk->sk_shutdown   |= SEND_SHUTDOWN;
 	sk->sk_state_change(sk);
 	/* Destroy IrDA socket */
 	irda_destroy_socket(irda_sk(sk));
 	sock_orphan(sk);
 	sock->sk   = NULL;
 	release_sock(sk);
 	/* Purge queues (see sock_init_data()) */
 	skb_queue_purge(&sk->sk_receive_queue);
 	/* Destroy networking socket if we are the last reference on it,
 	 * i.e. if(sk->sk_refcnt == 0) -> sk_free(sk) */
 	sock_put(sk);
 	/* Notes on socket locking and deallocation... - Jean II
 	 * In theory we should put pairs of sock_hold() / sock_put() to
 	 * prevent the socket to be destroyed whenever there is an
 	 * outstanding request or outstanding incoming packet or event.
 	 *
 	 * 1) This may include IAS request, both in connect and getsockopt.
 	 * Unfortunately, the situation is a bit more messy than it looks,
 	 * because we close iriap and kfree(self) above.
 	 *
 	 * 2) This may include selective discovery in getsockopt.
 	 * Same stuff as above, irlmp registration and self are gone.
 	 *
 	 * Probably 1 and 2 may not matter, because it's all triggered
 	 * by a process and the socket layer already prevent the
 	 * socket to go away while a process is holding it, through
 	 * sockfd_put() and fput()...
 	 *
 	 * 3) This may include deferred TSAP closure. In particular,
 	 * we may receive a late irda_disconnect_indication()
 	 * Fortunately, (tsap_cb *)->close_pend should protect us
 	 * from that.
 	 *
 	 * I did some testing on SMP, and it looks solid. And the socket
 	 * memory leak is now gone... - Jean II
 	 */
 	return 0;
 }
 /*
  * Function irda_sendmsg (iocb, sock, msg, len)
  *
  *    Send message down to TinyTP. This function is used for both STREAM and
  *    SEQPACK services. This is possible since it forces the client to
  *    fragment the message if necessary
  */
 static int irda_sendmsg(struct kiocb *iocb, struct socket *sock,
 			struct msghdr *msg, size_t len)
 {
 	struct sock *sk = sock->sk;
 	struct irda_sock *self;
 	struct sk_buff *skb;
 	int err = -EPIPE;
 	IRDA_DEBUG(4, "%s(), len=%zd\n", __func__, len);
 	/* Note : socket.c set MSG_EOR on SEQPACKET sockets */
 	if (msg->msg_flags & ~(MSG_DONTWAIT | MSG_EOR | MSG_CMSG_COMPAT |
 			       MSG_NOSIGNAL)) {
 		return -EINVAL;
 	}
 	lock_sock(sk);
 	if (sk->sk_shutdown & SEND_SHUTDOWN)
 		goto out_err;
 	if (sk->sk_state != TCP_ESTABLISHED) {
 		err = -ENOTCONN;
 		goto out;
 	}
 	self = irda_sk(sk);
 	/* Check if IrTTP is wants us to slow down */
 	if (wait_event_interruptible(*(sk_sleep(sk)),
 	    (self->tx_flow != FLOW_STOP  ||  sk->sk_state != TCP_ESTABLISHED))) {
 		err = -ERESTARTSYS;
 		goto out;
 	}
 	/* Check if we are still connected */
 	if (sk->sk_state != TCP_ESTABLISHED) {
 		err = -ENOTCONN;
 		goto out;
 	}
 	/* Check that we don't send out too big frames */
 	if (len > self->max_data_size) {
 		IRDA_DEBUG(2, "%s(), Chopping frame from %zd to %d bytes!\n",
 			   __func__, len, self->max_data_size);
 		len = self->max_data_size;
 	}
 	skb = sock_alloc_send_skb(sk, len + self->max_header_size + 16,
 				  msg->msg_flags & MSG_DONTWAIT, &err);
 	if (!skb)
 		goto out_err;
 	skb_reserve(skb, self->max_header_size + 16);
 	skb_reset_transport_header(skb);
 	skb_put(skb, len);
 	err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len);
 	if (err) {
 		kfree_skb(skb);
 		goto out_err;
 	}
 	/*
 	 * Just send the message to TinyTP, and let it deal with possible
 	 * errors. No need to duplicate all that here
 	 */
 	err = irttp_data_request(self->tsap, skb);
 	if (err) {
 		IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err);
 		goto out_err;
 	}
 	release_sock(sk);
 	/* Tell client how much data we actually sent */
 	return len;
 out_err:
 	err = sk_stream_error(sk, msg->msg_flags, err);
 out:
 	release_sock(sk);
 	return err;
 }
 /*
  * Function irda_recvmsg_dgram (iocb, sock, msg, size, flags)
  *
  *    Try to receive message and copy it to user. The frame is discarded
  *    after being read, regardless of how much the user actually read
  */
 static int irda_recvmsg_dgram(struct kiocb *iocb, struct socket *sock,
 			      struct msghdr *msg, size_t size, int flags)
 {
 	struct sock *sk = sock->sk;
 	struct irda_sock *self = irda_sk(sk);
 	struct sk_buff *skb;
 	size_t copied;
 	int err;
 	IRDA_DEBUG(4, "%s()\n", __func__);
 	msg->msg_namelen = 0;
 	skb = skb_recv_datagram(sk, flags & ~MSG_DONTWAIT,
 				flags & MSG_DONTWAIT, &err);
 	if (!skb)
 		return err;
 	skb_reset_transport_header(skb);
 	copied = skb->len;
 	if (copied > size) {
 		IRDA_DEBUG(2, "%s(), Received truncated frame (%zd < %zd)!\n",
 			   __func__, copied, size);
 		copied = size;
 		msg->msg_flags |= MSG_TRUNC;
 	}
 	skb_copy_datagram_iovec(skb, 0, msg->msg_iov, copied);
 	skb_free_datagram(sk, skb);
 	/*
 	 *  Check if we have previously stopped IrTTP and we know
 	 *  have more free space in our rx_queue. If so tell IrTTP
 	 *  to start delivering frames again before our rx_queue gets
 	 *  empty
 	 */
 	if (self->rx_flow == FLOW_STOP) {
 		if ((atomic_read(&sk->sk_rmem_alloc) << 2) <= sk->sk_rcvbuf) {
 			IRDA_DEBUG(2, "%s(), Starting IrTTP\n", __func__);
 			self->rx_flow = FLOW_START;
 			irttp_flow_request(self->tsap, FLOW_START);
 		}
 	}
 	return copied;
 }
 /*
  * Function irda_recvmsg_stream (iocb, sock, msg, size, flags)
  */
 static int irda_recvmsg_stream(struct kiocb *iocb, struct socket *sock,
 			       struct msghdr *msg, size_t size, int flags)
 {
 	struct sock *sk = sock->sk;
 	struct irda_sock *self = irda_sk(sk);
 	int noblock = flags & MSG_DONTWAIT;
 	size_t copied = 0;
 	int target, err;
 	long timeo;
 	IRDA_DEBUG(3, "%s()\n", __func__);
 	if ((err = sock_error(sk)) < 0)
 		return err;
 	if (sock->flags & __SO_ACCEPTCON)
 		return -EINVAL;
 	err =-EOPNOTSUPP;
 	if (flags & MSG_OOB)
 		return -EOPNOTSUPP;
 	err = 0;
 	target = sock_rcvlowat(sk, flags & MSG_WAITALL, size);
 	timeo = sock_rcvtimeo(sk, noblock);
 	msg->msg_namelen = 0;
 	do {
 		int chunk;
 		struct sk_buff *skb = skb_dequeue(&sk->sk_receive_queue);
 		if (skb == NULL) {
 			DEFINE_WAIT(wait);
 			err = 0;
 			if (copied >= target)
 				break;
 			prepare_to_wait_exclusive(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
 			/*
 			 *	POSIX 1003.1g mandates this order.
 			 */
 			err = sock_error(sk);
 			if (err)
 				;
 			else if (sk->sk_shutdown & RCV_SHUTDOWN)
 				;
 			else if (noblock)
 				err = -EAGAIN;
 			else if (signal_pending(current))
 				err = sock_intr_errno(timeo);
 			else if (sk->sk_state != TCP_ESTABLISHED)
 				err = -ENOTCONN;
 			else if (skb_peek(&sk->sk_receive_queue) == NULL)
 				/* Wait process until data arrives */
 				schedule();
 			finish_wait(sk_sleep(sk), &wait);
 			if (err)
 				return err;
 			if (sk->sk_shutdown & RCV_SHUTDOWN)
 				break;
 			continue;
 		}
 		chunk = min_t(unsigned int, skb->len, size);
 		if (memcpy_toiovec(msg->msg_iov, skb->data, chunk)) {
 			skb_queue_head(&sk->sk_receive_queue, skb);
 			if (copied == 0)
 				copied = -EFAULT;
 			break;
 		}
 		copied += chunk;
 		size -= chunk;
 		/* Mark read part of skb as used */
 		if (!(flags & MSG_PEEK)) {
 			skb_pull(skb, chunk);
 			/* put the skb back if we didn't use it up.. */
 			if (skb->len) {
 				IRDA_DEBUG(1, "%s(), back on q!\n",
 					   __func__);
 				skb_queue_head(&sk->sk_receive_queue, skb);
 				break;
 			}
 			kfree_skb(skb);
 		} else {
 			IRDA_DEBUG(0, "%s() questionable!?\n", __func__);
 			/* put message back and return */
 			skb_queue_head(&sk->sk_receive_queue, skb);
 			break;
 		}
 	} while (size);
 	/*
 	 *  Check if we have previously stopped IrTTP and we know
 	 *  have more free space in our rx_queue. If so tell IrTTP
 	 *  to start delivering frames again before our rx_queue gets
 	 *  empty
 	 */
 	if (self->rx_flow == FLOW_STOP) {
 		if ((atomic_read(&sk->sk_rmem_alloc) << 2) <= sk->sk_rcvbuf) {
 			IRDA_DEBUG(2, "%s(), Starting IrTTP\n", __func__);
 			self->rx_flow = FLOW_START;
 			irttp_flow_request(self->tsap, FLOW_START);
 		}
 	}
 	return copied;
 }
 /*
  * Function irda_sendmsg_dgram (iocb, sock, msg, len)
  *
  *    Send message down to TinyTP for the unreliable sequenced
  *    packet service...
  *
  */
 static int irda_sendmsg_dgram(struct kiocb *iocb, struct socket *sock,
 			      struct msghdr *msg, size_t len)
 {
 	struct sock *sk = sock->sk;
 	struct irda_sock *self;
 	struct sk_buff *skb;
 	int err;
 	IRDA_DEBUG(4, "%s(), len=%zd\n", __func__, len);
 	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
 		return -EINVAL;
 	lock_sock(sk);
 	if (sk->sk_shutdown & SEND_SHUTDOWN) {
 		send_sig(SIGPIPE, current, 0);
 		err = -EPIPE;
 		goto out;
 	}
 	err = -ENOTCONN;
 	if (sk->sk_state != TCP_ESTABLISHED)
 		goto out;
 	self = irda_sk(sk);
 	/*
 	 * Check that we don't send out too big frames. This is an unreliable
 	 * service, so we have no fragmentation and no coalescence
 	 */
 	if (len > self->max_data_size) {
 		IRDA_DEBUG(0, "%s(), Warning to much data! "
 			   "Chopping frame from %zd to %d bytes!\n",
 			   __func__, len, self->max_data_size);
 		len = self->max_data_size;
 	}
 	skb = sock_alloc_send_skb(sk, len + self->max_header_size,
 				  msg->msg_flags & MSG_DONTWAIT, &err);
 	err = -ENOBUFS;
 	if (!skb)
 		goto out;
 	skb_reserve(skb, self->max_header_size);
 	skb_reset_transport_header(skb);
 	IRDA_DEBUG(4, "%s(), appending user data\n", __func__);
 	skb_put(skb, len);
 	err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len);
 	if (err) {
 		kfree_skb(skb);
 		goto out;
 	}
 	/*
 	 * Just send the message to TinyTP, and let it deal with possible
 	 * errors. No need to duplicate all that here
 	 */
 	err = irttp_udata_request(self->tsap, skb);
 	if (err) {
 		IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err);
 		goto out;
 	}
 	release_sock(sk);
 	return len;
 out:
 	release_sock(sk);
 	return err;
 }
 /*
  * Function irda_sendmsg_ultra (iocb, sock, msg, len)
  *
  *    Send message down to IrLMP for the unreliable Ultra
  *    packet service...
  */
 #ifdef CONFIG_IRDA_ULTRA
 static int irda_sendmsg_ultra(struct kiocb *iocb, struct socket *sock,
 			      struct msghdr *msg, size_t len)
 {
 	struct sock *sk = sock->sk;
 	struct irda_sock *self;
 	__u8 pid = 0;
 	int bound = 0;
 	struct sk_buff *skb;
 	int err;
 	IRDA_DEBUG(4, "%s(), len=%zd\n", __func__, len);
 	err = -EINVAL;
 	if (msg->msg_flags & ~(MSG_DONTWAIT|MSG_CMSG_COMPAT))
 		return -EINVAL;
 	lock_sock(sk);
 	err = -EPIPE;
 	if (sk->sk_shutdown & SEND_SHUTDOWN) {
 		send_sig(SIGPIPE, current, 0);
 		goto out;
 	}
 	self = irda_sk(sk);
 	/* Check if an address was specified with sendto. Jean II */
 	if (msg->msg_name) {
 		struct sockaddr_irda *addr = (struct sockaddr_irda *) msg->msg_name;
 		err = -EINVAL;
 		/* Check address, extract pid. Jean II */
 		if (msg->msg_namelen < sizeof(*addr))
 			goto out;
 		if (addr->sir_family != AF_IRDA)
 			goto out;
 		pid = addr->sir_lsap_sel;
 		if (pid & 0x80) {
 			IRDA_DEBUG(0, "%s(), extension in PID not supp!\n", __func__);
 			err = -EOPNOTSUPP;
 			goto out;
 		}
 	} else {
 		/* Check that the socket is properly bound to an Ultra
 		 * port. Jean II */
 		if ((self->lsap == NULL) ||
 		    (sk->sk_state != TCP_ESTABLISHED)) {
 			IRDA_DEBUG(0, "%s(), socket not bound to Ultra PID.\n",
 				   __func__);
 			err = -ENOTCONN;
 			goto out;
 		}
 		/* Use PID from socket */
 		bound = 1;
 	}
 	/*
 	 * Check that we don't send out too big frames. This is an unreliable
 	 * service, so we have no fragmentation and no coalescence
 	 */
 	if (len > self->max_data_size) {
 		IRDA_DEBUG(0, "%s(), Warning to much data! "
 			   "Chopping frame from %zd to %d bytes!\n",
 			   __func__, len, self->max_data_size);
 		len = self->max_data_size;
 	}
 	skb = sock_alloc_send_skb(sk, len + self->max_header_size,
 				  msg->msg_flags & MSG_DONTWAIT, &err);
 	err = -ENOBUFS;
 	if (!skb)
 		goto out;
 	skb_reserve(skb, self->max_header_size);
 	skb_reset_transport_header(skb);
 	IRDA_DEBUG(4, "%s(), appending user data\n", __func__);
 	skb_put(skb, len);
 	err = memcpy_fromiovec(skb_transport_header(skb), msg->msg_iov, len);
 	if (err) {
 		kfree_skb(skb);
 		goto out;
 	}
 	err = irlmp_connless_data_request((bound ? self->lsap : NULL),
 					  skb, pid);
 	if (err)
 		IRDA_DEBUG(0, "%s(), err=%d\n", __func__, err);
 out:
 	release_sock(sk);
 	return err ? : len;
 }
 #endif /* CONFIG_IRDA_ULTRA */
 /*
  * Function irda_shutdown (sk, how)
  */
 static int irda_shutdown(struct socket *sock, int how)
 {
 	struct sock *sk = sock->sk;
 	struct irda_sock *self = irda_sk(sk);
 	IRDA_DEBUG(1, "%s(%p)\n", __func__, self);
 	lock_sock(sk);
 	sk->sk_state       = TCP_CLOSE;
 	sk->sk_shutdown   |= SEND_SHUTDOWN;
 	sk->sk_state_change(sk);
 	if (self->iriap) {
 		iriap_close(self->iriap);
 		self->iriap = NULL;
 	}
 	if (self->tsap) {
 		irttp_disconnect_request(self->tsap, NULL, P_NORMAL);
 		irttp_close_tsap(self->tsap);
 		self->tsap = NULL;
 	}
 	/* A few cleanup so the socket look as good as new... */
 	self->rx_flow = self->tx_flow = FLOW_START;	/* needed ??? */
 	self->daddr = DEV_ADDR_ANY;	/* Until we get re-connected */
 	self->saddr = 0x0;		/* so IrLMP assign us any link */
 	release_sock(sk);
 	return 0;
 }
 /*
  * Function irda_poll (file, sock, wait)
  */
 static unsigned int irda_poll(struct file * file, struct socket *sock,
 			      poll_table *wait)
 {
 	struct sock *sk = sock->sk;
 	struct irda_sock *self = irda_sk(sk);
 	unsigned int mask;
 	IRDA_DEBUG(4, "%s()\n", __func__);
 	poll_wait(file, sk_sleep(sk), wait);
 	mask = 0;
 	/* Exceptional events? */
 	if (sk->sk_err)
 		mask |= POLLERR;
 	if (sk->sk_shutdown & RCV_SHUTDOWN) {
 		IRDA_DEBUG(0, "%s(), POLLHUP\n", __func__);
 		mask |= POLLHUP;
 	}
 	/* Readable? */
 	if (!skb_queue_empty(&sk->sk_receive_queue)) {
 		IRDA_DEBUG(4, "Socket is readable\n");
 		mask |= POLLIN | POLLRDNORM;
 	}
 	/* Connection-based need to check for termination and startup */
 	switch (sk->sk_type) {
 	case SOCK_STREAM:
 		if (sk->sk_state == TCP_CLOSE) {
 			IRDA_DEBUG(0, "%s(), POLLHUP\n", __func__);
 			mask |= POLLHUP;
 		}
 		if (sk->sk_state == TCP_ESTABLISHED) {
 			if ((self->tx_flow == FLOW_START) &&
 			    sock_writeable(sk))
 			{
 				mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 			}
 		}
 		break;
 	case SOCK_SEQPACKET:
 		if ((self->tx_flow == FLOW_START) &&
 		    sock_writeable(sk))
 		{
 			mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 		}
 		break;
 	case SOCK_DGRAM:
 		if (sock_writeable(sk))
 			mask |= POLLOUT | POLLWRNORM | POLLWRBAND;
 		break;
 	default:
 		break;
 	}
 	return mask;
 }
 /*
  * Function irda_ioctl (sock, cmd, arg)
  */
 static int irda_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 {
 	struct sock *sk = sock->sk;
 	int err;
 	IRDA_DEBUG(4, "%s(), cmd=%#x\n", __func__, cmd);
 	err = -EINVAL;
 	switch (cmd) {
 	case TIOCOUTQ: {
 		long amount;
 		amount = sk->sk_sndbuf - sk_wmem_alloc_get(sk);
 		if (amount < 0)
 			amount = 0;
 		err = put_user(amount, (unsigned int __user *)arg);
 		break;
 	}
 	case TIOCINQ: {
 		struct sk_buff *skb;
 		long amount = 0L;
 		/* These two are safe on a single CPU system as only user tasks fiddle here */
 		if ((skb = skb_peek(&sk->sk_receive_queue)) != NULL)
 			amount = skb->len;
 		err = put_user(amount, (unsigned int __user *)arg);
 		break;
 	}
 	case SIOCGSTAMP:
 		if (sk != NULL)
 			err = sock_get_timestamp(sk, (struct timeval __user *)arg);
 		break;
 	case SIOCGIFADDR:
 	case SIOCSIFADDR:
 	case SIOCGIFDSTADDR:
 	case SIOCSIFDSTADDR:
 	case SIOCGIFBRDADDR:
 	case SIOCSIFBRDADDR:
 	case SIOCGIFNETMASK:
 	case SIOCSIFNETMASK:
 	case SIOCGIFMETRIC:
 	case SIOCSIFMETRIC:
 		break;
 	default:
 		IRDA_DEBUG(1, "%s(), doing device ioctl!\n", __func__);
 		err = -ENOIOCTLCMD;
 	}
 	return err;
 }
 #ifdef CONFIG_COMPAT
 /*
  * Function irda_ioctl (sock, cmd, arg)
  */
 static int irda_compat_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
 {
 	/*
 	 * All IRDA's ioctl are standard ones.
 	 */
 	return -ENOIOCTLCMD;
 }
 #endif
 /*
  * Function irda_setsockopt (sock, level, optname, optval, optlen)
  *
  *    Set some options for the socket
  *
  */
 static int irda_setsockopt(struct socket *sock, int level, int optname,
 			   char __user *optval, unsigned int optlen)
 {
 	struct sock *sk = sock->sk;
 	struct irda_sock *self = irda_sk(sk);
 	struct irda_ias_set    *ias_opt;
 	struct ias_object      *ias_obj;
 	struct ias_attrib *	ias_attr;	/* Attribute in IAS object */
 	int opt, free_ias = 0, err = 0;
 	IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 	if (level != SOL_IRLMP)
 		return -ENOPROTOOPT;
 	lock_sock(sk);
 	switch (optname) {
 	case IRLMP_IAS_SET:
 		/* The user want to add an attribute to an existing IAS object
 		 * (in the IAS database) or to create a new object with this
 		 * attribute.
 		 * We first query IAS to know if the object exist, and then
 		 * create the right attribute...
 		 */
 		if (optlen != sizeof(struct irda_ias_set)) {
 			err = -EINVAL;
 			goto out;
 		}
 		ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
 		if (ias_opt == NULL) {
 			err = -ENOMEM;
 			goto out;
 		}
 		/* Copy query to the driver. */
 		if (copy_from_user(ias_opt, optval, optlen)) {
 			kfree(ias_opt);
 			err = -EFAULT;
 			goto out;
 		}
 		/* Find the object we target.
 		 * If the user gives us an empty string, we use the object
 		 * associated with this socket. This will workaround
 		 * duplicated class name - Jean II */
 		if(ias_opt->irda_class_name[0] == '\0') {
 			if(self->ias_obj == NULL) {
 				kfree(ias_opt);
 				err = -EINVAL;
 				goto out;
 			}
 			ias_obj = self->ias_obj;
 		} else
 			ias_obj = irias_find_object(ias_opt->irda_class_name);
 		/* Only ROOT can mess with the global IAS database.
 		 * Users can only add attributes to the object associated
 		 * with the socket they own - Jean II */
 		if((!capable(CAP_NET_ADMIN)) &&
 		   ((ias_obj == NULL) || (ias_obj != self->ias_obj))) {
 			kfree(ias_opt);
 			err = -EPERM;
 			goto out;
 		}
 		/* If the object doesn't exist, create it */
 		if(ias_obj == (struct ias_object *) NULL) {
 			/* Create a new object */
 			ias_obj = irias_new_object(ias_opt->irda_class_name,
 						   jiffies);
 			if (ias_obj == NULL) {
 				kfree(ias_opt);
 				err = -ENOMEM;
 				goto out;
 			}
 			free_ias = 1;
 		}
 		/* Do we have the attribute already ? */
 		if(irias_find_attrib(ias_obj, ias_opt->irda_attrib_name)) {
 			kfree(ias_opt);
 			if (free_ias) {
 				kfree(ias_obj->name);
 				kfree(ias_obj);
 			}
 			err = -EINVAL;
 			goto out;
 		}
 		/* Look at the type */
 		switch(ias_opt->irda_attrib_type) {
 		case IAS_INTEGER:
 			/* Add an integer attribute */
 			irias_add_integer_attrib(
 				ias_obj,
 				ias_opt->irda_attrib_name,
 				ias_opt->attribute.irda_attrib_int,
 				IAS_USER_ATTR);
 			break;
 		case IAS_OCT_SEQ:
 			/* Check length */
 			if(ias_opt->attribute.irda_attrib_octet_seq.len >
 			   IAS_MAX_OCTET_STRING) {
 				kfree(ias_opt);
 				if (free_ias) {
 					kfree(ias_obj->name);
 					kfree(ias_obj);
 				}
 				err = -EINVAL;
 				goto out;
 			}
 			/* Add an octet sequence attribute */
 			irias_add_octseq_attrib(
 			      ias_obj,
 			      ias_opt->irda_attrib_name,
 			      ias_opt->attribute.irda_attrib_octet_seq.octet_seq,
 			      ias_opt->attribute.irda_attrib_octet_seq.len,
 			      IAS_USER_ATTR);
 			break;
 		case IAS_STRING:
 			/* Should check charset & co */
 			/* Check length */
 			/* The length is encoded in a __u8, and
 			 * IAS_MAX_STRING == 256, so there is no way
 			 * userspace can pass us a string too large.
 			 * Jean II */
 			/* NULL terminate the string (avoid troubles) */
 			ias_opt->attribute.irda_attrib_string.string[ias_opt->attribute.irda_attrib_string.len] = '\0';
 			/* Add a string attribute */
 			irias_add_string_attrib(
 				ias_obj,
 				ias_opt->irda_attrib_name,
 				ias_opt->attribute.irda_attrib_string.string,
 				IAS_USER_ATTR);
 			break;
 		default :
 			kfree(ias_opt);
 			if (free_ias) {
 				kfree(ias_obj->name);
 				kfree(ias_obj);
 			}
 			err = -EINVAL;
 			goto out;
 		}
 		irias_insert_object(ias_obj);
 		kfree(ias_opt);
 		break;
 	case IRLMP_IAS_DEL:
 		/* The user want to delete an object from our local IAS
 		 * database. We just need to query the IAS, check is the
 		 * object is not owned by the kernel and delete it.
 		 */
 		if (optlen != sizeof(struct irda_ias_set)) {
 			err = -EINVAL;
 			goto out;
 		}
 		ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
 		if (ias_opt == NULL) {
 			err = -ENOMEM;
 			goto out;
 		}
 		/* Copy query to the driver. */
 		if (copy_from_user(ias_opt, optval, optlen)) {
 			kfree(ias_opt);
 			err = -EFAULT;
 			goto out;
 		}
 		/* Find the object we target.
 		 * If the user gives us an empty string, we use the object
 		 * associated with this socket. This will workaround
 		 * duplicated class name - Jean II */
 		if(ias_opt->irda_class_name[0] == '\0')
 			ias_obj = self->ias_obj;
 		else
 			ias_obj = irias_find_object(ias_opt->irda_class_name);
 		if(ias_obj == (struct ias_object *) NULL) {
 			kfree(ias_opt);
 			err = -EINVAL;
 			goto out;
 		}
 		/* Only ROOT can mess with the global IAS database.
 		 * Users can only del attributes from the object associated
 		 * with the socket they own - Jean II */
 		if((!capable(CAP_NET_ADMIN)) &&
 		   ((ias_obj == NULL) || (ias_obj != self->ias_obj))) {
 			kfree(ias_opt);
 			err = -EPERM;
 			goto out;
 		}
 		/* Find the attribute (in the object) we target */
 		ias_attr = irias_find_attrib(ias_obj,
 					     ias_opt->irda_attrib_name);
 		if(ias_attr == (struct ias_attrib *) NULL) {
 			kfree(ias_opt);
 			err = -EINVAL;
 			goto out;
 		}
 		/* Check is the user space own the object */
 		if(ias_attr->value->owner != IAS_USER_ATTR) {
 			IRDA_DEBUG(1, "%s(), attempting to delete a kernel attribute\n", __func__);
 			kfree(ias_opt);
 			err = -EPERM;
 			goto out;
 		}
 		/* Remove the attribute (and maybe the object) */
 		irias_delete_attrib(ias_obj, ias_attr, 1);
 		kfree(ias_opt);
 		break;
 	case IRLMP_MAX_SDU_SIZE:
 		if (optlen < sizeof(int)) {
 			err = -EINVAL;
 			goto out;
 		}
 		if (get_user(opt, (int __user *)optval)) {
 			err = -EFAULT;
 			goto out;
 		}
 		/* Only possible for a seqpacket service (TTP with SAR) */
 		if (sk->sk_type != SOCK_SEQPACKET) {
 			IRDA_DEBUG(2, "%s(), setting max_sdu_size = %d\n",
 				   __func__, opt);
 			self->max_sdu_size_rx = opt;
 		} else {
 			IRDA_WARNING("%s: not allowed to set MAXSDUSIZE for this socket type!\n",
 				     __func__);
 			err = -ENOPROTOOPT;
 			goto out;
 		}
 		break;
 	case IRLMP_HINTS_SET:
 		if (optlen < sizeof(int)) {
 			err = -EINVAL;
 			goto out;
 		}
 		/* The input is really a (__u8 hints[2]), easier as an int */
 		if (get_user(opt, (int __user *)optval)) {
 			err = -EFAULT;
 			goto out;
 		}
 		/* Unregister any old registration */
 		if (self->skey)
 			irlmp_unregister_service(self->skey);
 		self->skey = irlmp_register_service((__u16) opt);
 		break;
 	case IRLMP_HINT_MASK_SET:
 		/* As opposed to the previous case which set the hint bits
 		 * that we advertise, this one set the filter we use when
 		 * making a discovery (nodes which don't match any hint
 		 * bit in the mask are not reported).
 		 */
 		if (optlen < sizeof(int)) {
 			err = -EINVAL;
 			goto out;
 		}
 		/* The input is really a (__u8 hints[2]), easier as an int */
 		if (get_user(opt, (int __user *)optval)) {
 			err = -EFAULT;
 			goto out;
 		}
 		/* Set the new hint mask */
 		self->mask.word = (__u16) opt;
 		/* Mask out extension bits */
 		self->mask.word &= 0x7f7f;
 		/* Check if no bits */
 		if(!self->mask.word)
 			self->mask.word = 0xFFFF;
 		break;
 	default:
 		err = -ENOPROTOOPT;
 		break;
 	}
 out:
 	release_sock(sk);
 	return err;
 }
 /*
  * Function irda_extract_ias_value(ias_opt, ias_value)
  *
  *    Translate internal IAS value structure to the user space representation
  *
  * The external representation of IAS values, as we exchange them with
  * user space program is quite different from the internal representation,
  * as stored in the IAS database (because we need a flat structure for
  * crossing kernel boundary).
  * This function transform the former in the latter. We also check
  * that the value type is valid.
  */
 static int irda_extract_ias_value(struct irda_ias_set *ias_opt,
 				  struct ias_value *ias_value)
 {
 	/* Look at the type */
 	switch (ias_value->type) {
 	case IAS_INTEGER:
 		/* Copy the integer */
 		ias_opt->attribute.irda_attrib_int = ias_value->t.integer;
 		break;
 	case IAS_OCT_SEQ:
 		/* Set length */
 		ias_opt->attribute.irda_attrib_octet_seq.len = ias_value->len;
 		/* Copy over */
 		memcpy(ias_opt->attribute.irda_attrib_octet_seq.octet_seq,
 		       ias_value->t.oct_seq, ias_value->len);
 		break;
 	case IAS_STRING:
 		/* Set length */
 		ias_opt->attribute.irda_attrib_string.len = ias_value->len;
 		ias_opt->attribute.irda_attrib_string.charset = ias_value->charset;
 		/* Copy over */
 		memcpy(ias_opt->attribute.irda_attrib_string.string,
 		       ias_value->t.string, ias_value->len);
 		/* NULL terminate the string (avoid troubles) */
 		ias_opt->attribute.irda_attrib_string.string[ias_value->len] = '\0';
 		break;
 	case IAS_MISSING:
 	default :
 		return -EINVAL;
 	}
 	/* Copy type over */
 	ias_opt->irda_attrib_type = ias_value->type;
 	return 0;
 }
 /*
  * Function irda_getsockopt (sock, level, optname, optval, optlen)
  */
 static int irda_getsockopt(struct socket *sock, int level, int optname,
 			   char __user *optval, int __user *optlen)
 {
 	struct sock *sk = sock->sk;
 	struct irda_sock *self = irda_sk(sk);
 	struct irda_device_list list;
 	struct irda_device_info *discoveries;
 	struct irda_ias_set *	ias_opt;	/* IAS get/query params */
 	struct ias_object *	ias_obj;	/* Object in IAS */
 	struct ias_attrib *	ias_attr;	/* Attribute in IAS object */
 	int daddr = DEV_ADDR_ANY;	/* Dest address for IAS queries */
 	int val = 0;
 	int len = 0;
 	int err = 0;
 	int offset, total;
 	IRDA_DEBUG(2, "%s(%p)\n", __func__, self);
 	if (level != SOL_IRLMP)
 		return -ENOPROTOOPT;
 	if (get_user(len, optlen))
 		return -EFAULT;
 	if(len < 0)
 		return -EINVAL;
 	lock_sock(sk);
 	switch (optname) {
 	case IRLMP_ENUMDEVICES:
 		/* Offset to first device entry */
 		offset = sizeof(struct irda_device_list) -
 			sizeof(struct irda_device_info);
 		if (len < offset) {
 			err = -EINVAL;
 			goto out;
 		}
 		/* Ask lmp for the current discovery log */
 		discoveries = irlmp_get_discoveries(&list.len, self->mask.word,
 						    self->nslots);
 		/* Check if the we got some results */
 		if (discoveries == NULL) {
 			err = -EAGAIN;
 			goto out;		/* Didn't find any devices */
 		}
 		/* Write total list length back to client */
 		if (copy_to_user(optval, &list, offset))
 			err = -EFAULT;
 		/* Copy the list itself - watch for overflow */
 		if (list.len > 2048) {
 			err = -EINVAL;
 			goto bed;
 		}
 		total = offset + (list.len * sizeof(struct irda_device_info));
 		if (total > len)
 			total = len;
 		if (copy_to_user(optval+offset, discoveries, total - offset))
 			err = -EFAULT;
 		/* Write total number of bytes used back to client */
 		if (put_user(total, optlen))
 			err = -EFAULT;
 bed:
 		/* Free up our buffer */
 		kfree(discoveries);
 		break;
 	case IRLMP_MAX_SDU_SIZE:
 		val = self->max_data_size;
 		len = sizeof(int);
 		if (put_user(len, optlen)) {
 			err = -EFAULT;
 			goto out;
 		}
 		if (copy_to_user(optval, &val, len)) {
 			err = -EFAULT;
 			goto out;
 		}
 		break;
 	case IRLMP_IAS_GET:
 		/* The user want an object from our local IAS database.
 		 * We just need to query the IAS and return the value
 		 * that we found */
 		/* Check that the user has allocated the right space for us */
 		if (len != sizeof(struct irda_ias_set)) {
 			err = -EINVAL;
 			goto out;
 		}
 		ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
 		if (ias_opt == NULL) {
 			err = -ENOMEM;
 			goto out;
 		}
 		/* Copy query to the driver. */
 		if (copy_from_user(ias_opt, optval, len)) {
 			kfree(ias_opt);
 			err = -EFAULT;
 			goto out;
 		}
 		/* Find the object we target.
 		 * If the user gives us an empty string, we use the object
 		 * associated with this socket. This will workaround
 		 * duplicated class name - Jean II */
 		if(ias_opt->irda_class_name[0] == '\0')
 			ias_obj = self->ias_obj;
 		else
 			ias_obj = irias_find_object(ias_opt->irda_class_name);
 		if(ias_obj == (struct ias_object *) NULL) {
 			kfree(ias_opt);
 			err = -EINVAL;
 			goto out;
 		}
 		/* Find the attribute (in the object) we target */
 		ias_attr = irias_find_attrib(ias_obj,
 					     ias_opt->irda_attrib_name);
 		if(ias_attr == (struct ias_attrib *) NULL) {
 			kfree(ias_opt);
 			err = -EINVAL;
 			goto out;
 		}
 		/* Translate from internal to user structure */
 		err = irda_extract_ias_value(ias_opt, ias_attr->value);
 		if(err) {
 			kfree(ias_opt);
 			goto out;
 		}
 		/* Copy reply to the user */
 		if (copy_to_user(optval, ias_opt,
 				 sizeof(struct irda_ias_set))) {
 			kfree(ias_opt);
 			err = -EFAULT;
 			goto out;
 		}
 		/* Note : don't need to put optlen, we checked it */
 		kfree(ias_opt);
 		break;
 	case IRLMP_IAS_QUERY:
 		/* The user want an object from a remote IAS database.
 		 * We need to use IAP to query the remote database and
 		 * then wait for the answer to come back. */
 		/* Check that the user has allocated the right space for us */
 		if (len != sizeof(struct irda_ias_set)) {
 			err = -EINVAL;
 			goto out;
 		}
 		ias_opt = kmalloc(sizeof(struct irda_ias_set), GFP_ATOMIC);
 		if (ias_opt == NULL) {
 			err = -ENOMEM;
 			goto out;
 		}
 		/* Copy query to the driver. */
 		if (copy_from_user(ias_opt, optval, len)) {
 			kfree(ias_opt);
 			err = -EFAULT;
 			goto out;
 		}
 		/* At this point, there are two cases...
 		 * 1) the socket is connected - that's the easy case, we
 		 *	just query the device we are connected to...
 		 * 2) the socket is not connected - the user doesn't want
 		 *	to connect and/or may not have a valid service name
 		 *	(so can't create a fake connection). In this case,
 		 *	we assume that the user pass us a valid destination
 		 *	address in the requesting structure...
 		 */
 		if(self->daddr != DEV_ADDR_ANY) {
 			/* We are connected - reuse known daddr */
 			daddr = self->daddr;
 		} else {
 			/* We are not connected, we must specify a valid
 			 * destination address */
 			daddr = ias_opt->daddr;
 			if((!daddr) || (daddr == DEV_ADDR_ANY)) {
 				kfree(ias_opt);
 				err = -EINVAL;
 				goto out;
 			}
 		}
 		/* Check that we can proceed with IAP */
 		if (self->iriap) {
 			IRDA_WARNING("%s: busy with a previous query\n",
 				     __func__);
 			kfree(ias_opt);
 			err = -EBUSY;
 			goto out;
 		}
 		self->iriap = iriap_open(LSAP_ANY, IAS_CLIENT, self,
 					 irda_getvalue_confirm);
 		if (self->iriap == NULL) {
 			kfree(ias_opt);
 			err = -ENOMEM;
 			goto out;
 		}
 		/* Treat unexpected wakeup as disconnect */
 		self->errno = -EHOSTUNREACH;
 		/* Query remote LM-IAS */
 		iriap_getvaluebyclass_request(self->iriap,
 					      self->saddr, daddr,
 					      ias_opt->irda_class_name,
 					      ias_opt->irda_attrib_name);
 		/* Wait for answer, if not yet finished (or failed) */
 		if (wait_event_interruptible(self->query_wait,
 					     (self->iriap == NULL))) {
 			/* pending request uses copy of ias_opt-content
 			 * we can free it regardless! */
 			kfree(ias_opt);
 			/* Treat signals as disconnect */
 			err = -EHOSTUNREACH;
 			goto out;
 		}
 		/* Check what happened */
 		if (self->errno)
 		{
 			kfree(ias_opt);
 			/* Requested object/attribute doesn't exist */
 			if((self->errno == IAS_CLASS_UNKNOWN) ||
 			   (self->errno == IAS_ATTRIB_UNKNOWN))
 				err = -EADDRNOTAVAIL;
 			else
 				err = -EHOSTUNREACH;
 			goto out;
 		}
 		/* Translate from internal to user structure */
 		err = irda_extract_ias_value(ias_opt, self->ias_result);
 		if (self->ias_result)
 			irias_delete_value(self->ias_result);
 		if (err) {
 			kfree(ias_opt);
 			goto out;
 		}
 		/* Copy reply to the user */
 		if (copy_to_user(optval, ias_opt,
 				 sizeof(struct irda_ias_set))) {
 			kfree(ias_opt);
 			err = -EFAULT;
 			goto out;
 		}
 		/* Note : don't need to put optlen, we checked it */
 		kfree(ias_opt);
 		break;
 	case IRLMP_WAITDEVICE:
 		/* This function is just another way of seeing life ;-)
 		 * IRLMP_ENUMDEVICES assumes that you have a static network,
 		 * and that you just want to pick one of the devices present.
 		 * On the other hand, in here we assume that no device is
 		 * present and that at some point in the future a device will
 		 * come into range. When this device arrive, we just wake
 		 * up the caller, so that he has time to connect to it before
 		 * the device goes away...
 		 * Note : once the node has been discovered for more than a
 		 * few second, it won't trigger this function, unless it
 		 * goes away and come back changes its hint bits (so we
 		 * might call it IRLMP_WAITNEWDEVICE).
 		 */
 		/* Check that the user is passing us an int */
 		if (len != sizeof(int)) {
 			err = -EINVAL;
 			goto out;
 		}
 		/* Get timeout in ms (max time we block the caller) */
 		if (get_user(val, (int __user *)optval)) {
 			err = -EFAULT;
 			goto out;
 		}
 		/* Tell IrLMP we want to be notified */
 		irlmp_update_client(self->ckey, self->mask.word,
 				    irda_selective_discovery_indication,
 				    NULL, (void *) self);
 		/* Do some discovery (and also return cached results) */
 		irlmp_discovery_request(self->nslots);
 		/* Wait until a node is discovered */
 		if (!self->cachedaddr) {
 			IRDA_DEBUG(1, "%s(), nothing discovered yet, going to sleep...\n", __func__);
 			/* Set watchdog timer to expire in <val> ms. */
 			self->errno = 0;
 			setup_timer(&self->watchdog, irda_discovery_timeout,
 					(unsigned long)self);
 			mod_timer(&self->watchdog,
 				  jiffies + msecs_to_jiffies(val));
 			/* Wait for IR-LMP to call us back */
-			__wait_event_interruptible(self->query_wait,
+			err = __wait_event_interruptible(self->query_wait,
-			      (self->cachedaddr != 0 || self->errno == -ETIME),
+			      (self->cachedaddr != 0 || self->errno == -ETIME));
-						   err);
 			/* If watchdog is still activated, kill it! */
 			del_timer(&(self->watchdog));
 			IRDA_DEBUG(1, "%s(), ...waking up !\n", __func__);
 			if (err != 0)
 				goto out;
 		}
 		else
 			IRDA_DEBUG(1, "%s(), found immediately !\n",
 				   __func__);
 		/* Tell IrLMP that we have been notified */
 		irlmp_update_client(self->ckey, self->mask.word,
 				    NULL, NULL, NULL);
 		/* Check if the we got some results */
 		if (!self->cachedaddr) {
 			err = -EAGAIN;		/* Didn't find any devices */
 			goto out;
 		}
 		daddr = self->cachedaddr;
 		/* Cleanup */
 		self->cachedaddr = 0;
 		/* We return the daddr of the device that trigger the
 		 * wakeup. As irlmp pass us only the new devices, we
 		 * are sure that it's not an old device.
 		 * If the user want more details, he should query
 		 * the whole discovery log and pick one device...
 		 */
 		if (put_user(daddr, (int __user *)optval)) {
 			err = -EFAULT;
 			goto out;
 		}
 		break;
 	default:
 		err = -ENOPROTOOPT;
 	}
 out:
 	release_sock(sk);
 	return err;
 }
 static const struct net_proto_family irda_family_ops = {
 	.family = PF_IRDA,
 	.create = irda_create,
 	.owner	= THIS_MODULE,
 };
 static const struct proto_ops irda_stream_ops = {
 	.family =	PF_IRDA,
 	.owner =	THIS_MODULE,
 	.release =	irda_release,
 	.bind =		irda_bind,
 	.connect =	irda_connect,
 	.socketpair =	sock_no_socketpair,
 	.accept =	irda_accept,
 	.getname =	irda_getname,
 	.poll =		irda_poll,
 	.ioctl =	irda_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl =	irda_compat_ioctl,
 #endif
 	.listen =	irda_listen,
 	.shutdown =	irda_shutdown,
 	.setsockopt =	irda_setsockopt,
 	.getsockopt =	irda_getsockopt,
 	.sendmsg =	irda_sendmsg,
 	.recvmsg =	irda_recvmsg_stream,
 	.mmap =		sock_no_mmap,
 	.sendpage =	sock_no_sendpage,
 };
 static const struct proto_ops irda_seqpacket_ops = {
 	.family =	PF_IRDA,
 	.owner =	THIS_MODULE,
 	.release =	irda_release,
 	.bind =		irda_bind,
 	.connect =	irda_connect,
 	.socketpair =	sock_no_socketpair,
 	.accept =	irda_accept,
 	.getname =	irda_getname,
 	.poll =		datagram_poll,
 	.ioctl =	irda_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl =	irda_compat_ioctl,
 #endif
 	.listen =	irda_listen,
 	.shutdown =	irda_shutdown,
 	.setsockopt =	irda_setsockopt,
 	.getsockopt =	irda_getsockopt,
 	.sendmsg =	irda_sendmsg,
 	.recvmsg =	irda_recvmsg_dgram,
 	.mmap =		sock_no_mmap,
 	.sendpage =	sock_no_sendpage,
 };
 static const struct proto_ops irda_dgram_ops = {
 	.family =	PF_IRDA,
 	.owner =	THIS_MODULE,
 	.release =	irda_release,
 	.bind =		irda_bind,
 	.connect =	irda_connect,
 	.socketpair =	sock_no_socketpair,
 	.accept =	irda_accept,
 	.getname =	irda_getname,
 	.poll =		datagram_poll,
 	.ioctl =	irda_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl =	irda_compat_ioctl,
 #endif
 	.listen =	irda_listen,
 	.shutdown =	irda_shutdown,
 	.setsockopt =	irda_setsockopt,
 	.getsockopt =	irda_getsockopt,
 	.sendmsg =	irda_sendmsg_dgram,
 	.recvmsg =	irda_recvmsg_dgram,
 	.mmap =		sock_no_mmap,
 	.sendpage =	sock_no_sendpage,
 };
 #ifdef CONFIG_IRDA_ULTRA
 static const struct proto_ops irda_ultra_ops = {
 	.family =	PF_IRDA,
 	.owner =	THIS_MODULE,
 	.release =	irda_release,
 	.bind =		irda_bind,
 	.connect =	sock_no_connect,
 	.socketpair =	sock_no_socketpair,
 	.accept =	sock_no_accept,
 	.getname =	irda_getname,
 	.poll =		datagram_poll,
 	.ioctl =	irda_ioctl,
 #ifdef CONFIG_COMPAT
 	.compat_ioctl =	irda_compat_ioctl,
 #endif
 	.listen =	sock_no_listen,
 	.shutdown =	irda_shutdown,
 	.setsockopt =	irda_setsockopt,
 	.getsockopt =	irda_getsockopt,
 	.sendmsg =	irda_sendmsg_ultra,
 	.recvmsg =	irda_recvmsg_dgram,
 	.mmap =		sock_no_mmap,
 	.sendpage =	sock_no_sendpage,
 };
 #endif /* CONFIG_IRDA_ULTRA */
 /*
  * Function irsock_init (pro)
  *
  *    Initialize IrDA protocol
  *
  */
 int __init irsock_init(void)
 {
 	int rc = proto_register(&irda_proto, 0);
 	if (rc == 0)
 		rc = sock_register(&irda_family_ops);
 	return rc;
 }
 /*
  * Function irsock_cleanup (void)
  *
  *    Remove IrDA protocol
  *
  */
 void irsock_cleanup(void)
 {
 	sock_unregister(PF_IRDA);
 	proto_unregister(&irda_proto);
 }

net/netfilter/ipvs/ip_vs_sync.c

Diff comments View file @ 35a2af9

 /*
  * IPVS         An implementation of the IP virtual server support for the
  *              LINUX operating system.  IPVS is now implemented as a module
  *              over the NetFilter framework. IPVS can be used to build a
  *              high-performance and highly available server based on a
  *              cluster of servers.
  *
  * Version 1,   is capable of handling both version 0 and 1 messages.
  *              Version 0 is the plain old format.
  *              Note Version 0 receivers will just drop Ver 1 messages.
  *              Version 1 is capable of handle IPv6, Persistence data,
  *              time-outs, and firewall marks.
  *              In ver.1 "ip_vs_sync_conn_options" will be sent in netw. order.
  *              Ver. 0 can be turned on by sysctl -w net.ipv4.vs.sync_version=0
  *
  * Definitions  Message: is a complete datagram
  *              Sync_conn: is a part of a Message
  *              Param Data is an option to a Sync_conn.
  *
  * Authors:     Wensong Zhang <wensong@linuxvirtualserver.org>
  *
  * ip_vs_sync:  sync connection info from master load balancer to backups
  *              through multicast
  *
  * Changes:
  *	Alexandre Cassen	:	Added master & backup support at a time.
  *	Alexandre Cassen	:	Added SyncID support for incoming sync
  *					messages filtering.
  *	Justin Ossevoort	:	Fix endian problem on sync message size.
  *	Hans Schillstrom	:	Added Version 1: i.e. IPv6,
  *					Persistence support, fwmark and time-out.
  */
 #define KMSG_COMPONENT "IPVS"
 #define pr_fmt(fmt) KMSG_COMPONENT ": " fmt
 #include <linux/module.h>
 #include <linux/slab.h>
 #include <linux/inetdevice.h>
 #include <linux/net.h>
 #include <linux/completion.h>
 #include <linux/delay.h>
 #include <linux/skbuff.h>
 #include <linux/in.h>
 #include <linux/igmp.h>                 /* for ip_mc_join_group */
 #include <linux/udp.h>
 #include <linux/err.h>
 #include <linux/kthread.h>
 #include <linux/wait.h>
 #include <linux/kernel.h>
 #include <asm/unaligned.h>		/* Used for ntoh_seq and hton_seq */
 #include <net/ip.h>
 #include <net/sock.h>
 #include <net/ip_vs.h>
 #define IP_VS_SYNC_GROUP 0xe0000051    /* multicast addr - 224.0.0.81 */
 #define IP_VS_SYNC_PORT  8848          /* multicast port */
 #define SYNC_PROTO_VER  1		/* Protocol version in header */
 static struct lock_class_key __ipvs_sync_key;
 /*
  *	IPVS sync connection entry
  *	Version 0, i.e. original version.
  */
 struct ip_vs_sync_conn_v0 {
 	__u8			reserved;
 	/* Protocol, addresses and port numbers */
 	__u8			protocol;       /* Which protocol (TCP/UDP) */
 	__be16			cport;
 	__be16                  vport;
 	__be16                  dport;
 	__be32                  caddr;          /* client address */
 	__be32                  vaddr;          /* virtual address */
 	__be32                  daddr;          /* destination address */
 	/* Flags and state transition */
 	__be16                  flags;          /* status flags */
 	__be16                  state;          /* state info */
 	/* The sequence options start here */
 };
 struct ip_vs_sync_conn_options {
 	struct ip_vs_seq        in_seq;         /* incoming seq. struct */
 	struct ip_vs_seq        out_seq;        /* outgoing seq. struct */
 };
 /*
      Sync Connection format (sync_conn)
        0                   1                   2                   3
        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |    Type       |    Protocol   | Ver.  |        Size           |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |                             Flags                             |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |            State              |         cport                 |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |            vport              |         dport                 |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |                             fwmark                            |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |                             timeout  (in sec.)                |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |                              ...                              |
       |                        IP-Addresses  (v4 or v6)               |
       |                              ...                              |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
   Optional Parameters.
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       | Param. Type    | Param. Length |   Param. data                |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                               |
       |                              ...                              |
       |                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |                               | Param Type    | Param. Length |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |                           Param  data                         |
       |         Last Param data should be padded for 32 bit alignment |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
 */
 /*
  *  Type 0, IPv4 sync connection format
  */
 struct ip_vs_sync_v4 {
 	__u8			type;
 	__u8			protocol;	/* Which protocol (TCP/UDP) */
 	__be16			ver_size;	/* Version msb 4 bits */
 	/* Flags and state transition */
 	__be32			flags;		/* status flags */
 	__be16			state;		/* state info 	*/
 	/* Protocol, addresses and port numbers */
 	__be16			cport;
 	__be16			vport;
 	__be16			dport;
 	__be32			fwmark;		/* Firewall mark from skb */
 	__be32			timeout;	/* cp timeout */
 	__be32			caddr;		/* client address */
 	__be32			vaddr;		/* virtual address */
 	__be32			daddr;		/* destination address */
 	/* The sequence options start here */
 	/* PE data padded to 32bit alignment after seq. options */
 };
 /*
  * Type 2 messages IPv6
  */
 struct ip_vs_sync_v6 {
 	__u8			type;
 	__u8			protocol;	/* Which protocol (TCP/UDP) */
 	__be16			ver_size;	/* Version msb 4 bits */
 	/* Flags and state transition */
 	__be32			flags;		/* status flags */
 	__be16			state;		/* state info 	*/
 	/* Protocol, addresses and port numbers */
 	__be16			cport;
 	__be16			vport;
 	__be16			dport;
 	__be32			fwmark;		/* Firewall mark from skb */
 	__be32			timeout;	/* cp timeout */
 	struct in6_addr		caddr;		/* client address */
 	struct in6_addr		vaddr;		/* virtual address */
 	struct in6_addr		daddr;		/* destination address */
 	/* The sequence options start here */
 	/* PE data padded to 32bit alignment after seq. options */
 };
 union ip_vs_sync_conn {
 	struct ip_vs_sync_v4	v4;
 	struct ip_vs_sync_v6	v6;
 };
 /* Bits in Type field in above */
 #define STYPE_INET6		0
 #define STYPE_F_INET6		(1 << STYPE_INET6)
 #define SVER_SHIFT		12		/* Shift to get version */
 #define SVER_MASK		0x0fff		/* Mask to strip version */
 #define IPVS_OPT_SEQ_DATA	1
 #define IPVS_OPT_PE_DATA	2
 #define IPVS_OPT_PE_NAME	3
 #define IPVS_OPT_PARAM		7
 #define IPVS_OPT_F_SEQ_DATA	(1 << (IPVS_OPT_SEQ_DATA-1))
 #define IPVS_OPT_F_PE_DATA	(1 << (IPVS_OPT_PE_DATA-1))
 #define IPVS_OPT_F_PE_NAME	(1 << (IPVS_OPT_PE_NAME-1))
 #define IPVS_OPT_F_PARAM	(1 << (IPVS_OPT_PARAM-1))
 struct ip_vs_sync_thread_data {
 	struct net *net;
 	struct socket *sock;
 	char *buf;
 	int id;
 };
 /* Version 0 definition of packet sizes */
 #define SIMPLE_CONN_SIZE  (sizeof(struct ip_vs_sync_conn_v0))
 #define FULL_CONN_SIZE  \
 (sizeof(struct ip_vs_sync_conn_v0) + sizeof(struct ip_vs_sync_conn_options))
 /*
   The master mulitcasts messages (Datagrams) to the backup load balancers
   in the following format.
  Version 1:
   Note, first byte should be Zero, so ver 0 receivers will drop the packet.
        0                   1                   2                   3
        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |      0        |    SyncID     |            Size               |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |  Count Conns  |    Version    |    Reserved, set to Zero      |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |                                                               |
       |                    IPVS Sync Connection (1)                   |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |                            .                                  |
       ~                            .                                  ~
       |                            .                                  |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |                                                               |
       |                    IPVS Sync Connection (n)                   |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
  Version 0 Header
        0                   1                   2                   3
        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |  Count Conns  |    SyncID     |            Size               |
       +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
       |                    IPVS Sync Connection (1)                   |
 */
 #define SYNC_MESG_HEADER_LEN	4
 #define MAX_CONNS_PER_SYNCBUFF	255 /* nr_conns in ip_vs_sync_mesg is 8 bit */
 /* Version 0 header */
 struct ip_vs_sync_mesg_v0 {
 	__u8                    nr_conns;
 	__u8                    syncid;
 	__be16                  size;
 	/* ip_vs_sync_conn entries start here */
 };
 /* Version 1 header */
 struct ip_vs_sync_mesg {
 	__u8			reserved;	/* must be zero */
 	__u8			syncid;
 	__be16			size;
 	__u8			nr_conns;
 	__s8			version;	/* SYNC_PROTO_VER  */
 	__u16			spare;
 	/* ip_vs_sync_conn entries start here */
 };
 struct ip_vs_sync_buff {
 	struct list_head        list;
 	unsigned long           firstuse;
 	/* pointers for the message data */
 	struct ip_vs_sync_mesg  *mesg;
 	unsigned char           *head;
 	unsigned char           *end;
 };
 /*
  * Copy of struct ip_vs_seq
  * From unaligned network order to aligned host order
  */
 static void ntoh_seq(struct ip_vs_seq *no, struct ip_vs_seq *ho)
 {
 	ho->init_seq       = get_unaligned_be32(&no->init_seq);
 	ho->delta          = get_unaligned_be32(&no->delta);
 	ho->previous_delta = get_unaligned_be32(&no->previous_delta);
 }
 /*
  * Copy of struct ip_vs_seq
  * From Aligned host order to unaligned network order
  */
 static void hton_seq(struct ip_vs_seq *ho, struct ip_vs_seq *no)
 {
 	put_unaligned_be32(ho->init_seq, &no->init_seq);
 	put_unaligned_be32(ho->delta, &no->delta);
 	put_unaligned_be32(ho->previous_delta, &no->previous_delta);
 }
 static inline struct ip_vs_sync_buff *
 sb_dequeue(struct netns_ipvs *ipvs, struct ipvs_master_sync_state *ms)
 {
 	struct ip_vs_sync_buff *sb;
 	spin_lock_bh(&ipvs->sync_lock);
 	if (list_empty(&ms->sync_queue)) {
 		sb = NULL;
 		__set_current_state(TASK_INTERRUPTIBLE);
 	} else {
 		sb = list_entry(ms->sync_queue.next, struct ip_vs_sync_buff,
 				list);
 		list_del(&sb->list);
 		ms->sync_queue_len--;
 		if (!ms->sync_queue_len)
 			ms->sync_queue_delay = 0;
 	}
 	spin_unlock_bh(&ipvs->sync_lock);
 	return sb;
 }
 /*
  * Create a new sync buffer for Version 1 proto.
  */
 static inline struct ip_vs_sync_buff *
 ip_vs_sync_buff_create(struct netns_ipvs *ipvs)
 {
 	struct ip_vs_sync_buff *sb;
 	if (!(sb=kmalloc(sizeof(struct ip_vs_sync_buff), GFP_ATOMIC)))
 		return NULL;
 	sb->mesg = kmalloc(ipvs->send_mesg_maxlen, GFP_ATOMIC);
 	if (!sb->mesg) {
 		kfree(sb);
 		return NULL;
 	}
 	sb->mesg->reserved = 0;  /* old nr_conns i.e. must be zero now */
 	sb->mesg->version = SYNC_PROTO_VER;
 	sb->mesg->syncid = ipvs->master_syncid;
 	sb->mesg->size = htons(sizeof(struct ip_vs_sync_mesg));
 	sb->mesg->nr_conns = 0;
 	sb->mesg->spare = 0;
 	sb->head = (unsigned char *)sb->mesg + sizeof(struct ip_vs_sync_mesg);
 	sb->end = (unsigned char *)sb->mesg + ipvs->send_mesg_maxlen;
 	sb->firstuse = jiffies;
 	return sb;
 }
 static inline void ip_vs_sync_buff_release(struct ip_vs_sync_buff *sb)
 {
 	kfree(sb->mesg);
 	kfree(sb);
 }
 static inline void sb_queue_tail(struct netns_ipvs *ipvs,
 				 struct ipvs_master_sync_state *ms)
 {
 	struct ip_vs_sync_buff *sb = ms->sync_buff;
 	spin_lock(&ipvs->sync_lock);
 	if (ipvs->sync_state & IP_VS_STATE_MASTER &&
 	    ms->sync_queue_len < sysctl_sync_qlen_max(ipvs)) {
 		if (!ms->sync_queue_len)
 			schedule_delayed_work(&ms->master_wakeup_work,
 					      max(IPVS_SYNC_SEND_DELAY, 1));
 		ms->sync_queue_len++;
 		list_add_tail(&sb->list, &ms->sync_queue);
 		if ((++ms->sync_queue_delay) == IPVS_SYNC_WAKEUP_RATE)
 			wake_up_process(ms->master_thread);
 	} else
 		ip_vs_sync_buff_release(sb);
 	spin_unlock(&ipvs->sync_lock);
 }
 /*
  *	Get the current sync buffer if it has been created for more
  *	than the specified time or the specified time is zero.
  */
 static inline struct ip_vs_sync_buff *
 get_curr_sync_buff(struct netns_ipvs *ipvs, struct ipvs_master_sync_state *ms,
 		   unsigned long time)
 {
 	struct ip_vs_sync_buff *sb;
 	spin_lock_bh(&ipvs->sync_buff_lock);
 	sb = ms->sync_buff;
 	if (sb && time_after_eq(jiffies - sb->firstuse, time)) {
 		ms->sync_buff = NULL;
 		__set_current_state(TASK_RUNNING);
 	} else
 		sb = NULL;
 	spin_unlock_bh(&ipvs->sync_buff_lock);
 	return sb;
 }
 static inline int
 select_master_thread_id(struct netns_ipvs *ipvs, struct ip_vs_conn *cp)
 {
 	return ((long) cp >> (1 + ilog2(sizeof(*cp)))) & ipvs->threads_mask;
 }
 /*
  * Create a new sync buffer for Version 0 proto.
  */
 static inline struct ip_vs_sync_buff *
 ip_vs_sync_buff_create_v0(struct netns_ipvs *ipvs)
 {
 	struct ip_vs_sync_buff *sb;
 	struct ip_vs_sync_mesg_v0 *mesg;
 	if (!(sb=kmalloc(sizeof(struct ip_vs_sync_buff), GFP_ATOMIC)))
 		return NULL;
 	sb->mesg = kmalloc(ipvs->send_mesg_maxlen, GFP_ATOMIC);
 	if (!sb->mesg) {
 		kfree(sb);
 		return NULL;
 	}
 	mesg = (struct ip_vs_sync_mesg_v0 *)sb->mesg;
 	mesg->nr_conns = 0;
 	mesg->syncid = ipvs->master_syncid;
 	mesg->size = htons(sizeof(struct ip_vs_sync_mesg_v0));
 	sb->head = (unsigned char *)mesg + sizeof(struct ip_vs_sync_mesg_v0);
 	sb->end = (unsigned char *)mesg + ipvs->send_mesg_maxlen;
 	sb->firstuse = jiffies;
 	return sb;
 }
 /* Check if connection is controlled by persistence */
 static inline bool in_persistence(struct ip_vs_conn *cp)
 {
 	for (cp = cp->control; cp; cp = cp->control) {
 		if (cp->flags & IP_VS_CONN_F_TEMPLATE)
 			return true;
 	}
 	return false;
 }
 /* Check if conn should be synced.
  * pkts: conn packets, use sysctl_sync_threshold to avoid packet check
  * - (1) sync_refresh_period: reduce sync rate. Additionally, retry
  *	sync_retries times with period of sync_refresh_period/8
  * - (2) if both sync_refresh_period and sync_period are 0 send sync only
  *	for state changes or only once when pkts matches sync_threshold
  * - (3) templates: rate can be reduced only with sync_refresh_period or
  *	with (2)
  */
 static int ip_vs_sync_conn_needed(struct netns_ipvs *ipvs,
 				  struct ip_vs_conn *cp, int pkts)
 {
 	unsigned long orig = ACCESS_ONCE(cp->sync_endtime);
 	unsigned long now = jiffies;
 	unsigned long n = (now + cp->timeout) & ~3UL;
 	unsigned int sync_refresh_period;
 	int sync_period;
 	int force;
 	/* Check if we sync in current state */
 	if (unlikely(cp->flags & IP_VS_CONN_F_TEMPLATE))
 		force = 0;
 	else if (unlikely(sysctl_sync_persist_mode(ipvs) && in_persistence(cp)))
 		return 0;
 	else if (likely(cp->protocol == IPPROTO_TCP)) {
 		if (!((1 << cp->state) &
 		      ((1 << IP_VS_TCP_S_ESTABLISHED) |
 		       (1 << IP_VS_TCP_S_FIN_WAIT) |
 		       (1 << IP_VS_TCP_S_CLOSE) |
 		       (1 << IP_VS_TCP_S_CLOSE_WAIT) |
 		       (1 << IP_VS_TCP_S_TIME_WAIT))))
 			return 0;
 		force = cp->state != cp->old_state;
 		if (force && cp->state != IP_VS_TCP_S_ESTABLISHED)
 			goto set;
 	} else if (unlikely(cp->protocol == IPPROTO_SCTP)) {
 		if (!((1 << cp->state) &
 		      ((1 << IP_VS_SCTP_S_ESTABLISHED) |
 		       (1 << IP_VS_SCTP_S_SHUTDOWN_SENT) |
 		       (1 << IP_VS_SCTP_S_SHUTDOWN_RECEIVED) |
 		       (1 << IP_VS_SCTP_S_SHUTDOWN_ACK_SENT) |
 		       (1 << IP_VS_SCTP_S_CLOSED))))
 			return 0;
 		force = cp->state != cp->old_state;
 		if (force && cp->state != IP_VS_SCTP_S_ESTABLISHED)
 			goto set;
 	} else {
 		/* UDP or another protocol with single state */
 		force = 0;
 	}
 	sync_refresh_period = sysctl_sync_refresh_period(ipvs);
 	if (sync_refresh_period > 0) {
 		long diff = n - orig;
 		long min_diff = max(cp->timeout >> 1, 10UL * HZ);
 		/* Avoid sync if difference is below sync_refresh_period
 		 * and below the half timeout.
 		 */
 		if (abs(diff) < min_t(long, sync_refresh_period, min_diff)) {
 			int retries = orig & 3;
 			if (retries >= sysctl_sync_retries(ipvs))
 				return 0;
 			if (time_before(now, orig - cp->timeout +
 					(sync_refresh_period >> 3)))
 				return 0;
 			n |= retries + 1;
 		}
 	}
 	sync_period = sysctl_sync_period(ipvs);
 	if (sync_period > 0) {
 		if (!(cp->flags & IP_VS_CONN_F_TEMPLATE) &&
 		    pkts % sync_period != sysctl_sync_threshold(ipvs))
 			return 0;
 	} else if (sync_refresh_period <= 0 &&
 		   pkts != sysctl_sync_threshold(ipvs))
 		return 0;
 set:
 	cp->old_state = cp->state;
 	n = cmpxchg(&cp->sync_endtime, orig, n);
 	return n == orig || force;
 }
 /*
  *      Version 0 , could be switched in by sys_ctl.
  *      Add an ip_vs_conn information into the current sync_buff.
  */
 static void ip_vs_sync_conn_v0(struct net *net, struct ip_vs_conn *cp,
 			       int pkts)
 {
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	struct ip_vs_sync_mesg_v0 *m;
 	struct ip_vs_sync_conn_v0 *s;
 	struct ip_vs_sync_buff *buff;
 	struct ipvs_master_sync_state *ms;
 	int id;
 	int len;
 	if (unlikely(cp->af != AF_INET))
 		return;
 	/* Do not sync ONE PACKET */
 	if (cp->flags & IP_VS_CONN_F_ONE_PACKET)
 		return;
 	if (!ip_vs_sync_conn_needed(ipvs, cp, pkts))
 		return;
 	spin_lock_bh(&ipvs->sync_buff_lock);
 	if (!(ipvs->sync_state & IP_VS_STATE_MASTER)) {
 		spin_unlock_bh(&ipvs->sync_buff_lock);
 		return;
 	}
 	id = select_master_thread_id(ipvs, cp);
 	ms = &ipvs->ms[id];
 	buff = ms->sync_buff;
 	if (buff) {
 		m = (struct ip_vs_sync_mesg_v0 *) buff->mesg;
 		/* Send buffer if it is for v1 */
 		if (!m->nr_conns) {
 			sb_queue_tail(ipvs, ms);
 			ms->sync_buff = NULL;
 			buff = NULL;
 		}
 	}
 	if (!buff) {
 		buff = ip_vs_sync_buff_create_v0(ipvs);
 		if (!buff) {
 			spin_unlock_bh(&ipvs->sync_buff_lock);
 			pr_err("ip_vs_sync_buff_create failed.\n");
 			return;
 		}
 		ms->sync_buff = buff;
 	}
 	len = (cp->flags & IP_VS_CONN_F_SEQ_MASK) ? FULL_CONN_SIZE :
 		SIMPLE_CONN_SIZE;
 	m = (struct ip_vs_sync_mesg_v0 *) buff->mesg;
 	s = (struct ip_vs_sync_conn_v0 *) buff->head;
 	/* copy members */
 	s->reserved = 0;
 	s->protocol = cp->protocol;
 	s->cport = cp->cport;
 	s->vport = cp->vport;
 	s->dport = cp->dport;
 	s->caddr = cp->caddr.ip;
 	s->vaddr = cp->vaddr.ip;
 	s->daddr = cp->daddr.ip;
 	s->flags = htons(cp->flags & ~IP_VS_CONN_F_HASHED);
 	s->state = htons(cp->state);
 	if (cp->flags & IP_VS_CONN_F_SEQ_MASK) {
 		struct ip_vs_sync_conn_options *opt =
 			(struct ip_vs_sync_conn_options *)&s[1];
 		memcpy(opt, &cp->in_seq, sizeof(*opt));
 	}
 	m->nr_conns++;
 	m->size = htons(ntohs(m->size) + len);
 	buff->head += len;
 	/* check if there is a space for next one */
 	if (buff->head + FULL_CONN_SIZE > buff->end) {
 		sb_queue_tail(ipvs, ms);
 		ms->sync_buff = NULL;
 	}
 	spin_unlock_bh(&ipvs->sync_buff_lock);
 	/* synchronize its controller if it has */
 	cp = cp->control;
 	if (cp) {
 		if (cp->flags & IP_VS_CONN_F_TEMPLATE)
 			pkts = atomic_add_return(1, &cp->in_pkts);
 		else
 			pkts = sysctl_sync_threshold(ipvs);
 		ip_vs_sync_conn(net, cp->control, pkts);
 	}
 }
 /*
  *      Add an ip_vs_conn information into the current sync_buff.
  *      Called by ip_vs_in.
  *      Sending Version 1 messages
  */
 void ip_vs_sync_conn(struct net *net, struct ip_vs_conn *cp, int pkts)
 {
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	struct ip_vs_sync_mesg *m;
 	union ip_vs_sync_conn *s;
 	struct ip_vs_sync_buff *buff;
 	struct ipvs_master_sync_state *ms;
 	int id;
 	__u8 *p;
 	unsigned int len, pe_name_len, pad;
 	/* Handle old version of the protocol */
 	if (sysctl_sync_ver(ipvs) == 0) {
 		ip_vs_sync_conn_v0(net, cp, pkts);
 		return;
 	}
 	/* Do not sync ONE PACKET */
 	if (cp->flags & IP_VS_CONN_F_ONE_PACKET)
 		goto control;
 sloop:
 	if (!ip_vs_sync_conn_needed(ipvs, cp, pkts))
 		goto control;
 	/* Sanity checks */
 	pe_name_len = 0;
 	if (cp->pe_data_len) {
 		if (!cp->pe_data || !cp->dest) {
 			IP_VS_ERR_RL("SYNC, connection pe_data invalid\n");
 			return;
 		}
 		pe_name_len = strnlen(cp->pe->name, IP_VS_PENAME_MAXLEN);
 	}
 	spin_lock_bh(&ipvs->sync_buff_lock);
 	if (!(ipvs->sync_state & IP_VS_STATE_MASTER)) {
 		spin_unlock_bh(&ipvs->sync_buff_lock);
 		return;
 	}
 	id = select_master_thread_id(ipvs, cp);
 	ms = &ipvs->ms[id];
 #ifdef CONFIG_IP_VS_IPV6
 	if (cp->af == AF_INET6)
 		len = sizeof(struct ip_vs_sync_v6);
 	else
 #endif
 		len = sizeof(struct ip_vs_sync_v4);
 	if (cp->flags & IP_VS_CONN_F_SEQ_MASK)
 		len += sizeof(struct ip_vs_sync_conn_options) + 2;
 	if (cp->pe_data_len)
 		len += cp->pe_data_len + 2;	/* + Param hdr field */
 	if (pe_name_len)
 		len += pe_name_len + 2;
 	/* check if there is a space for this one  */
 	pad = 0;
 	buff = ms->sync_buff;
 	if (buff) {
 		m = buff->mesg;
 		pad = (4 - (size_t) buff->head) & 3;
 		/* Send buffer if it is for v0 */
 		if (buff->head + len + pad > buff->end || m->reserved) {
 			sb_queue_tail(ipvs, ms);
 			ms->sync_buff = NULL;
 			buff = NULL;
 			pad = 0;
 		}
 	}
 	if (!buff) {
 		buff = ip_vs_sync_buff_create(ipvs);
 		if (!buff) {
 			spin_unlock_bh(&ipvs->sync_buff_lock);
 			pr_err("ip_vs_sync_buff_create failed.\n");
 			return;
 		}
 		ms->sync_buff = buff;
 		m = buff->mesg;
 	}
 	p = buff->head;
 	buff->head += pad + len;
 	m->size = htons(ntohs(m->size) + pad + len);
 	/* Add ev. padding from prev. sync_conn */
 	while (pad--)
 		*(p++) = 0;
 	s = (union ip_vs_sync_conn *)p;
 	/* Set message type  & copy members */
 	s->v4.type = (cp->af == AF_INET6 ? STYPE_F_INET6 : 0);
 	s->v4.ver_size = htons(len & SVER_MASK);	/* Version 0 */
 	s->v4.flags = htonl(cp->flags & ~IP_VS_CONN_F_HASHED);
 	s->v4.state = htons(cp->state);
 	s->v4.protocol = cp->protocol;
 	s->v4.cport = cp->cport;
 	s->v4.vport = cp->vport;
 	s->v4.dport = cp->dport;
 	s->v4.fwmark = htonl(cp->fwmark);
 	s->v4.timeout = htonl(cp->timeout / HZ);
 	m->nr_conns++;
 #ifdef CONFIG_IP_VS_IPV6
 	if (cp->af == AF_INET6) {
 		p += sizeof(struct ip_vs_sync_v6);
 		s->v6.caddr = cp->caddr.in6;
 		s->v6.vaddr = cp->vaddr.in6;
 		s->v6.daddr = cp->daddr.in6;
 	} else
 #endif
 	{
 		p += sizeof(struct ip_vs_sync_v4);	/* options ptr */
 		s->v4.caddr = cp->caddr.ip;
 		s->v4.vaddr = cp->vaddr.ip;
 		s->v4.daddr = cp->daddr.ip;
 	}
 	if (cp->flags & IP_VS_CONN_F_SEQ_MASK) {
 		*(p++) = IPVS_OPT_SEQ_DATA;
 		*(p++) = sizeof(struct ip_vs_sync_conn_options);
 		hton_seq((struct ip_vs_seq *)p, &cp->in_seq);
 		p += sizeof(struct ip_vs_seq);
 		hton_seq((struct ip_vs_seq *)p, &cp->out_seq);
 		p += sizeof(struct ip_vs_seq);
 	}
 	/* Handle pe data */
 	if (cp->pe_data_len && cp->pe_data) {
 		*(p++) = IPVS_OPT_PE_DATA;
 		*(p++) = cp->pe_data_len;
 		memcpy(p, cp->pe_data, cp->pe_data_len);
 		p += cp->pe_data_len;
 		if (pe_name_len) {
 			/* Add PE_NAME */
 			*(p++) = IPVS_OPT_PE_NAME;
 			*(p++) = pe_name_len;
 			memcpy(p, cp->pe->name, pe_name_len);
 			p += pe_name_len;
 		}
 	}
 	spin_unlock_bh(&ipvs->sync_buff_lock);
 control:
 	/* synchronize its controller if it has */
 	cp = cp->control;
 	if (!cp)
 		return;
 	if (cp->flags & IP_VS_CONN_F_TEMPLATE)
 		pkts = atomic_add_return(1, &cp->in_pkts);
 	else
 		pkts = sysctl_sync_threshold(ipvs);
 	goto sloop;
 }
 /*
  *  fill_param used by version 1
  */
 static inline int
 ip_vs_conn_fill_param_sync(struct net *net, int af, union ip_vs_sync_conn *sc,
 			   struct ip_vs_conn_param *p,
 			   __u8 *pe_data, unsigned int pe_data_len,
 			   __u8 *pe_name, unsigned int pe_name_len)
 {
 #ifdef CONFIG_IP_VS_IPV6
 	if (af == AF_INET6)
 		ip_vs_conn_fill_param(net, af, sc->v6.protocol,
 				      (const union nf_inet_addr *)&sc->v6.caddr,
 				      sc->v6.cport,
 				      (const union nf_inet_addr *)&sc->v6.vaddr,
 				      sc->v6.vport, p);
 	else
 #endif
 		ip_vs_conn_fill_param(net, af, sc->v4.protocol,
 				      (const union nf_inet_addr *)&sc->v4.caddr,
 				      sc->v4.cport,
 				      (const union nf_inet_addr *)&sc->v4.vaddr,
 				      sc->v4.vport, p);
 	/* Handle pe data */
 	if (pe_data_len) {
 		if (pe_name_len) {
 			char buff[IP_VS_PENAME_MAXLEN+1];
 			memcpy(buff, pe_name, pe_name_len);
 			buff[pe_name_len]=0;
 			p->pe = __ip_vs_pe_getbyname(buff);
 			if (!p->pe) {
 				IP_VS_DBG(3, "BACKUP, no %s engine found/loaded\n",
 					     buff);
 				return 1;
 			}
 		} else {
 			IP_VS_ERR_RL("BACKUP, Invalid PE parameters\n");
 			return 1;
 		}
 		p->pe_data = kmemdup(pe_data, pe_data_len, GFP_ATOMIC);
 		if (!p->pe_data) {
 			if (p->pe->module)
 				module_put(p->pe->module);
 			return -ENOMEM;
 		}
 		p->pe_data_len = pe_data_len;
 	}
 	return 0;
 }
 /*
  *  Connection Add / Update.
  *  Common for version 0 and 1 reception of backup sync_conns.
  *  Param: ...
  *         timeout is in sec.
  */
 static void ip_vs_proc_conn(struct net *net, struct ip_vs_conn_param *param,
 			    unsigned int flags, unsigned int state,
 			    unsigned int protocol, unsigned int type,
 			    const union nf_inet_addr *daddr, __be16 dport,
 			    unsigned long timeout, __u32 fwmark,
 			    struct ip_vs_sync_conn_options *opt)
 {
 	struct ip_vs_dest *dest;
 	struct ip_vs_conn *cp;
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	if (!(flags & IP_VS_CONN_F_TEMPLATE))
 		cp = ip_vs_conn_in_get(param);
 	else
 		cp = ip_vs_ct_in_get(param);
 	if (cp) {
 		/* Free pe_data */
 		kfree(param->pe_data);
 		dest = cp->dest;
 		spin_lock_bh(&cp->lock);
 		if ((cp->flags ^ flags) & IP_VS_CONN_F_INACTIVE &&
 		    !(flags & IP_VS_CONN_F_TEMPLATE) && dest) {
 			if (flags & IP_VS_CONN_F_INACTIVE) {
 				atomic_dec(&dest->activeconns);
 				atomic_inc(&dest->inactconns);
 			} else {
 				atomic_inc(&dest->activeconns);
 				atomic_dec(&dest->inactconns);
 			}
 		}
 		flags &= IP_VS_CONN_F_BACKUP_UPD_MASK;
 		flags |= cp->flags & ~IP_VS_CONN_F_BACKUP_UPD_MASK;
 		cp->flags = flags;
 		spin_unlock_bh(&cp->lock);
 		if (!dest)
 			ip_vs_try_bind_dest(cp);
 	} else {
 		/*
 		 * Find the appropriate destination for the connection.
 		 * If it is not found the connection will remain unbound
 		 * but still handled.
 		 */
 		rcu_read_lock();
 		dest = ip_vs_find_dest(net, type, daddr, dport, param->vaddr,
 				       param->vport, protocol, fwmark, flags);
 		cp = ip_vs_conn_new(param, daddr, dport, flags, dest, fwmark);
 		rcu_read_unlock();
 		if (!cp) {
 			if (param->pe_data)
 				kfree(param->pe_data);
 			IP_VS_DBG(2, "BACKUP, add new conn. failed\n");
 			return;
 		}
 	}
 	if (opt)
 		memcpy(&cp->in_seq, opt, sizeof(*opt));
 	atomic_set(&cp->in_pkts, sysctl_sync_threshold(ipvs));
 	cp->state = state;
 	cp->old_state = cp->state;
 	/*
 	 * For Ver 0 messages style
 	 *  - Not possible to recover the right timeout for templates
 	 *  - can not find the right fwmark
 	 *    virtual service. If needed, we can do it for
 	 *    non-fwmark persistent services.
 	 * Ver 1 messages style.
 	 *  - No problem.
 	 */
 	if (timeout) {
 		if (timeout > MAX_SCHEDULE_TIMEOUT / HZ)
 			timeout = MAX_SCHEDULE_TIMEOUT / HZ;
 		cp->timeout = timeout*HZ;
 	} else {
 		struct ip_vs_proto_data *pd;
 		pd = ip_vs_proto_data_get(net, protocol);
 		if (!(flags & IP_VS_CONN_F_TEMPLATE) && pd && pd->timeout_table)
 			cp->timeout = pd->timeout_table[state];
 		else
 			cp->timeout = (3*60*HZ);
 	}
 	ip_vs_conn_put(cp);
 }
 /*
  *  Process received multicast message for Version 0
  */
 static void ip_vs_process_message_v0(struct net *net, const char *buffer,
 				     const size_t buflen)
 {
 	struct ip_vs_sync_mesg_v0 *m = (struct ip_vs_sync_mesg_v0 *)buffer;
 	struct ip_vs_sync_conn_v0 *s;
 	struct ip_vs_sync_conn_options *opt;
 	struct ip_vs_protocol *pp;
 	struct ip_vs_conn_param param;
 	char *p;
 	int i;
 	p = (char *)buffer + sizeof(struct ip_vs_sync_mesg_v0);
 	for (i=0; i<m->nr_conns; i++) {
 		unsigned int flags, state;
 		if (p + SIMPLE_CONN_SIZE > buffer+buflen) {
 			IP_VS_ERR_RL("BACKUP v0, bogus conn\n");
 			return;
 		}
 		s = (struct ip_vs_sync_conn_v0 *) p;
 		flags = ntohs(s->flags) | IP_VS_CONN_F_SYNC;
 		flags &= ~IP_VS_CONN_F_HASHED;
 		if (flags & IP_VS_CONN_F_SEQ_MASK) {
 			opt = (struct ip_vs_sync_conn_options *)&s[1];
 			p += FULL_CONN_SIZE;
 			if (p > buffer+buflen) {
 				IP_VS_ERR_RL("BACKUP v0, Dropping buffer bogus conn options\n");
 				return;
 			}
 		} else {
 			opt = NULL;
 			p += SIMPLE_CONN_SIZE;
 		}
 		state = ntohs(s->state);
 		if (!(flags & IP_VS_CONN_F_TEMPLATE)) {
 			pp = ip_vs_proto_get(s->protocol);
 			if (!pp) {
 				IP_VS_DBG(2, "BACKUP v0, Unsupported protocol %u\n",
 					s->protocol);
 				continue;
 			}
 			if (state >= pp->num_states) {
 				IP_VS_DBG(2, "BACKUP v0, Invalid %s state %u\n",
 					pp->name, state);
 				continue;
 			}
 		} else {
 			/* protocol in templates is not used for state/timeout */
 			if (state > 0) {
 				IP_VS_DBG(2, "BACKUP v0, Invalid template state %u\n",
 					state);
 				state = 0;
 			}
 		}
 		ip_vs_conn_fill_param(net, AF_INET, s->protocol,
 				      (const union nf_inet_addr *)&s->caddr,
 				      s->cport,
 				      (const union nf_inet_addr *)&s->vaddr,
 				      s->vport, &param);
 		/* Send timeout as Zero */
 		ip_vs_proc_conn(net, &param, flags, state, s->protocol, AF_INET,
 				(union nf_inet_addr *)&s->daddr, s->dport,
 				0, 0, opt);
 	}
 }
 /*
  * Handle options
  */
 static inline int ip_vs_proc_seqopt(__u8 *p, unsigned int plen,
 				    __u32 *opt_flags,
 				    struct ip_vs_sync_conn_options *opt)
 {
 	struct ip_vs_sync_conn_options *topt;
 	topt = (struct ip_vs_sync_conn_options *)p;
 	if (plen != sizeof(struct ip_vs_sync_conn_options)) {
 		IP_VS_DBG(2, "BACKUP, bogus conn options length\n");
 		return -EINVAL;
 	}
 	if (*opt_flags & IPVS_OPT_F_SEQ_DATA) {
 		IP_VS_DBG(2, "BACKUP, conn options found twice\n");
 		return -EINVAL;
 	}
 	ntoh_seq(&topt->in_seq, &opt->in_seq);
 	ntoh_seq(&topt->out_seq, &opt->out_seq);
 	*opt_flags |= IPVS_OPT_F_SEQ_DATA;
 	return 0;
 }
 static int ip_vs_proc_str(__u8 *p, unsigned int plen, unsigned int *data_len,
 			  __u8 **data, unsigned int maxlen,
 			  __u32 *opt_flags, __u32 flag)
 {
 	if (plen > maxlen) {
 		IP_VS_DBG(2, "BACKUP, bogus par.data len > %d\n", maxlen);
 		return -EINVAL;
 	}
 	if (*opt_flags & flag) {
 		IP_VS_DBG(2, "BACKUP, Par.data found twice 0x%x\n", flag);
 		return -EINVAL;
 	}
 	*data_len = plen;
 	*data = p;
 	*opt_flags |= flag;
 	return 0;
 }
 /*
  *   Process a Version 1 sync. connection
  */
 static inline int ip_vs_proc_sync_conn(struct net *net, __u8 *p, __u8 *msg_end)
 {
 	struct ip_vs_sync_conn_options opt;
 	union  ip_vs_sync_conn *s;
 	struct ip_vs_protocol *pp;
 	struct ip_vs_conn_param param;
 	__u32 flags;
 	unsigned int af, state, pe_data_len=0, pe_name_len=0;
 	__u8 *pe_data=NULL, *pe_name=NULL;
 	__u32 opt_flags=0;
 	int retc=0;
 	s = (union ip_vs_sync_conn *) p;
 	if (s->v6.type & STYPE_F_INET6) {
 #ifdef CONFIG_IP_VS_IPV6
 		af = AF_INET6;
 		p += sizeof(struct ip_vs_sync_v6);
 #else
 		IP_VS_DBG(3,"BACKUP, IPv6 msg received, and IPVS is not compiled for IPv6\n");
 		retc = 10;
 		goto out;
 #endif
 	} else if (!s->v4.type) {
 		af = AF_INET;
 		p += sizeof(struct ip_vs_sync_v4);
 	} else {
 		return -10;
 	}
 	if (p > msg_end)
 		return -20;
 	/* Process optional params check Type & Len. */
 	while (p < msg_end) {
 		int ptype;
 		int plen;
 		if (p+2 > msg_end)
 			return -30;
 		ptype = *(p++);
 		plen  = *(p++);
 		if (!plen || ((p + plen) > msg_end))
 			return -40;
 		/* Handle seq option  p = param data */
 		switch (ptype & ~IPVS_OPT_F_PARAM) {
 		case IPVS_OPT_SEQ_DATA:
 			if (ip_vs_proc_seqopt(p, plen, &opt_flags, &opt))
 				return -50;
 			break;
 		case IPVS_OPT_PE_DATA:
 			if (ip_vs_proc_str(p, plen, &pe_data_len, &pe_data,
 					   IP_VS_PEDATA_MAXLEN, &opt_flags,
 					   IPVS_OPT_F_PE_DATA))
 				return -60;
 			break;
 		case IPVS_OPT_PE_NAME:
 			if (ip_vs_proc_str(p, plen,&pe_name_len, &pe_name,
 					   IP_VS_PENAME_MAXLEN, &opt_flags,
 					   IPVS_OPT_F_PE_NAME))
 				return -70;
 			break;
 		default:
 			/* Param data mandatory ? */
 			if (!(ptype & IPVS_OPT_F_PARAM)) {
 				IP_VS_DBG(3, "BACKUP, Unknown mandatory param %d found\n",
 					  ptype & ~IPVS_OPT_F_PARAM);
 				retc = 20;
 				goto out;
 			}
 		}
 		p += plen;  /* Next option */
 	}
 	/* Get flags and Mask off unsupported */
 	flags  = ntohl(s->v4.flags) & IP_VS_CONN_F_BACKUP_MASK;
 	flags |= IP_VS_CONN_F_SYNC;
 	state = ntohs(s->v4.state);
 	if (!(flags & IP_VS_CONN_F_TEMPLATE)) {
 		pp = ip_vs_proto_get(s->v4.protocol);
 		if (!pp) {
 			IP_VS_DBG(3,"BACKUP, Unsupported protocol %u\n",
 				s->v4.protocol);
 			retc = 30;
 			goto out;
 		}
 		if (state >= pp->num_states) {
 			IP_VS_DBG(3, "BACKUP, Invalid %s state %u\n",
 				pp->name, state);
 			retc = 40;
 			goto out;
 		}
 	} else {
 		/* protocol in templates is not used for state/timeout */
 		if (state > 0) {
 			IP_VS_DBG(3, "BACKUP, Invalid template state %u\n",
 				state);
 			state = 0;
 		}
 	}
 	if (ip_vs_conn_fill_param_sync(net, af, s, &param, pe_data,
 				       pe_data_len, pe_name, pe_name_len)) {
 		retc = 50;
 		goto out;
 	}
 	/* If only IPv4, just silent skip IPv6 */
 	if (af == AF_INET)
 		ip_vs_proc_conn(net, &param, flags, state, s->v4.protocol, af,
 				(union nf_inet_addr *)&s->v4.daddr, s->v4.dport,
 				ntohl(s->v4.timeout), ntohl(s->v4.fwmark),
 				(opt_flags & IPVS_OPT_F_SEQ_DATA ? &opt : NULL)
 				);
 #ifdef CONFIG_IP_VS_IPV6
 	else
 		ip_vs_proc_conn(net, &param, flags, state, s->v6.protocol, af,
 				(union nf_inet_addr *)&s->v6.daddr, s->v6.dport,
 				ntohl(s->v6.timeout), ntohl(s->v6.fwmark),
 				(opt_flags & IPVS_OPT_F_SEQ_DATA ? &opt : NULL)
 				);
 #endif
 	return 0;
 	/* Error exit */
 out:
 	IP_VS_DBG(2, "BACKUP, Single msg dropped err:%d\n", retc);
 	return retc;
 }
 /*
  *      Process received multicast message and create the corresponding
  *      ip_vs_conn entries.
  *      Handles Version 0 & 1
  */
 static void ip_vs_process_message(struct net *net, __u8 *buffer,
 				  const size_t buflen)
 {
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	struct ip_vs_sync_mesg *m2 = (struct ip_vs_sync_mesg *)buffer;
 	__u8 *p, *msg_end;
 	int i, nr_conns;
 	if (buflen < sizeof(struct ip_vs_sync_mesg_v0)) {
 		IP_VS_DBG(2, "BACKUP, message header too short\n");
 		return;
 	}
 	if (buflen != ntohs(m2->size)) {
 		IP_VS_DBG(2, "BACKUP, bogus message size\n");
 		return;
 	}
 	/* SyncID sanity check */
 	if (ipvs->backup_syncid != 0 && m2->syncid != ipvs->backup_syncid) {
 		IP_VS_DBG(7, "BACKUP, Ignoring syncid = %d\n", m2->syncid);
 		return;
 	}
 	/* Handle version 1  message */
 	if ((m2->version == SYNC_PROTO_VER) && (m2->reserved == 0)
 	    && (m2->spare == 0)) {
 		msg_end = buffer + sizeof(struct ip_vs_sync_mesg);
 		nr_conns = m2->nr_conns;
 		for (i=0; i<nr_conns; i++) {
 			union ip_vs_sync_conn *s;
 			unsigned int size;
 			int retc;
 			p = msg_end;
 			if (p + sizeof(s->v4) > buffer+buflen) {
 				IP_VS_ERR_RL("BACKUP, Dropping buffer, to small\n");
 				return;
 			}
 			s = (union ip_vs_sync_conn *)p;
 			size = ntohs(s->v4.ver_size) & SVER_MASK;
 			msg_end = p + size;
 			/* Basic sanity checks */
 			if (msg_end  > buffer+buflen) {
 				IP_VS_ERR_RL("BACKUP, Dropping buffer, msg > buffer\n");
 				return;
 			}
 			if (ntohs(s->v4.ver_size) >> SVER_SHIFT) {
 				IP_VS_ERR_RL("BACKUP, Dropping buffer, Unknown version %d\n",
 					      ntohs(s->v4.ver_size) >> SVER_SHIFT);
 				return;
 			}
 			/* Process a single sync_conn */
 			retc = ip_vs_proc_sync_conn(net, p, msg_end);
 			if (retc < 0) {
 				IP_VS_ERR_RL("BACKUP, Dropping buffer, Err: %d in decoding\n",
 					     retc);
 				return;
 			}
 			/* Make sure we have 32 bit alignment */
 			msg_end = p + ((size + 3) & ~3);
 		}
 	} else {
 		/* Old type of message */
 		ip_vs_process_message_v0(net, buffer, buflen);
 		return;
 	}
 }
 /*
  *      Setup sndbuf (mode=1) or rcvbuf (mode=0)
  */
 static void set_sock_size(struct sock *sk, int mode, int val)
 {
 	/* setsockopt(sock, SOL_SOCKET, SO_SNDBUF, &val, sizeof(val)); */
 	/* setsockopt(sock, SOL_SOCKET, SO_RCVBUF, &val, sizeof(val)); */
 	lock_sock(sk);
 	if (mode) {
 		val = clamp_t(int, val, (SOCK_MIN_SNDBUF + 1) / 2,
 			      sysctl_wmem_max);
 		sk->sk_sndbuf = val * 2;
 		sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
 	} else {
 		val = clamp_t(int, val, (SOCK_MIN_RCVBUF + 1) / 2,
 			      sysctl_rmem_max);
 		sk->sk_rcvbuf = val * 2;
 		sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
 	}
 	release_sock(sk);
 }
 /*
  *      Setup loopback of outgoing multicasts on a sending socket
  */
 static void set_mcast_loop(struct sock *sk, u_char loop)
 {
 	struct inet_sock *inet = inet_sk(sk);
 	/* setsockopt(sock, SOL_IP, IP_MULTICAST_LOOP, &loop, sizeof(loop)); */
 	lock_sock(sk);
 	inet->mc_loop = loop ? 1 : 0;
 	release_sock(sk);
 }
 /*
  *      Specify TTL for outgoing multicasts on a sending socket
  */
 static void set_mcast_ttl(struct sock *sk, u_char ttl)
 {
 	struct inet_sock *inet = inet_sk(sk);
 	/* setsockopt(sock, SOL_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)); */
 	lock_sock(sk);
 	inet->mc_ttl = ttl;
 	release_sock(sk);
 }
 /*
  *      Specifiy default interface for outgoing multicasts
  */
 static int set_mcast_if(struct sock *sk, char *ifname)
 {
 	struct net_device *dev;
 	struct inet_sock *inet = inet_sk(sk);
 	struct net *net = sock_net(sk);
 	dev = __dev_get_by_name(net, ifname);
 	if (!dev)
 		return -ENODEV;
 	if (sk->sk_bound_dev_if && dev->ifindex != sk->sk_bound_dev_if)
 		return -EINVAL;
 	lock_sock(sk);
 	inet->mc_index = dev->ifindex;
 	/*  inet->mc_addr  = 0; */
 	release_sock(sk);
 	return 0;
 }
 /*
  *	Set the maximum length of sync message according to the
  *	specified interface's MTU.
  */
 static int set_sync_mesg_maxlen(struct net *net, int sync_state)
 {
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	struct net_device *dev;
 	int num;
 	if (sync_state == IP_VS_STATE_MASTER) {
 		dev = __dev_get_by_name(net, ipvs->master_mcast_ifn);
 		if (!dev)
 			return -ENODEV;
 		num = (dev->mtu - sizeof(struct iphdr) -
 		       sizeof(struct udphdr) -
 		       SYNC_MESG_HEADER_LEN - 20) / SIMPLE_CONN_SIZE;
 		ipvs->send_mesg_maxlen = SYNC_MESG_HEADER_LEN +
 			SIMPLE_CONN_SIZE * min(num, MAX_CONNS_PER_SYNCBUFF);
 		IP_VS_DBG(7, "setting the maximum length of sync sending "
 			  "message %d.\n", ipvs->send_mesg_maxlen);
 	} else if (sync_state == IP_VS_STATE_BACKUP) {
 		dev = __dev_get_by_name(net, ipvs->backup_mcast_ifn);
 		if (!dev)
 			return -ENODEV;
 		ipvs->recv_mesg_maxlen = dev->mtu -
 			sizeof(struct iphdr) - sizeof(struct udphdr);
 		IP_VS_DBG(7, "setting the maximum length of sync receiving "
 			  "message %d.\n", ipvs->recv_mesg_maxlen);
 	}
 	return 0;
 }
 /*
  *      Join a multicast group.
  *      the group is specified by a class D multicast address 224.0.0.0/8
  *      in the in_addr structure passed in as a parameter.
  */
 static int
 join_mcast_group(struct sock *sk, struct in_addr *addr, char *ifname)
 {
 	struct net *net = sock_net(sk);
 	struct ip_mreqn mreq;
 	struct net_device *dev;
 	int ret;
 	memset(&mreq, 0, sizeof(mreq));
 	memcpy(&mreq.imr_multiaddr, addr, sizeof(struct in_addr));
 	dev = __dev_get_by_name(net, ifname);
 	if (!dev)
 		return -ENODEV;
 	if (sk->sk_bound_dev_if && dev->ifindex != sk->sk_bound_dev_if)
 		return -EINVAL;
 	mreq.imr_ifindex = dev->ifindex;
 	lock_sock(sk);
 	ret = ip_mc_join_group(sk, &mreq);
 	release_sock(sk);
 	return ret;
 }
 static int bind_mcastif_addr(struct socket *sock, char *ifname)
 {
 	struct net *net = sock_net(sock->sk);
 	struct net_device *dev;
 	__be32 addr;
 	struct sockaddr_in sin;
 	dev = __dev_get_by_name(net, ifname);
 	if (!dev)
 		return -ENODEV;
 	addr = inet_select_addr(dev, 0, RT_SCOPE_UNIVERSE);
 	if (!addr)
 		pr_err("You probably need to specify IP address on "
 		       "multicast interface.\n");
 	IP_VS_DBG(7, "binding socket with (%s) %pI4\n",
 		  ifname, &addr);
 	/* Now bind the socket with the address of multicast interface */
 	sin.sin_family	     = AF_INET;
 	sin.sin_addr.s_addr  = addr;
 	sin.sin_port         = 0;
 	return sock->ops->bind(sock, (struct sockaddr*)&sin, sizeof(sin));
 }
 /*
  *      Set up sending multicast socket over UDP
  */
 static struct socket *make_send_sock(struct net *net, int id)
 {
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	/* multicast addr */
 	struct sockaddr_in mcast_addr = {
 		.sin_family		= AF_INET,
 		.sin_port		= cpu_to_be16(IP_VS_SYNC_PORT + id),
 		.sin_addr.s_addr	= cpu_to_be32(IP_VS_SYNC_GROUP),
 	};
 	struct socket *sock;
 	int result;
 	/* First create a socket move it to right name space later */
 	result = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
 	if (result < 0) {
 		pr_err("Error during creation of socket; terminating\n");
 		return ERR_PTR(result);
 	}
 	/*
 	 * Kernel sockets that are a part of a namespace, should not
 	 * hold a reference to a namespace in order to allow to stop it.
 	 * After sk_change_net should be released using sk_release_kernel.
 	 */
 	sk_change_net(sock->sk, net);
 	result = set_mcast_if(sock->sk, ipvs->master_mcast_ifn);
 	if (result < 0) {
 		pr_err("Error setting outbound mcast interface\n");
 		goto error;
 	}
 	set_mcast_loop(sock->sk, 0);
 	set_mcast_ttl(sock->sk, 1);
 	result = sysctl_sync_sock_size(ipvs);
 	if (result > 0)
 		set_sock_size(sock->sk, 1, result);
 	result = bind_mcastif_addr(sock, ipvs->master_mcast_ifn);
 	if (result < 0) {
 		pr_err("Error binding address of the mcast interface\n");
 		goto error;
 	}
 	result = sock->ops->connect(sock, (struct sockaddr *) &mcast_addr,
 			sizeof(struct sockaddr), 0);
 	if (result < 0) {
 		pr_err("Error connecting to the multicast addr\n");
 		goto error;
 	}
 	return sock;
 error:
 	sk_release_kernel(sock->sk);
 	return ERR_PTR(result);
 }
 /*
  *      Set up receiving multicast socket over UDP
  */
 static struct socket *make_receive_sock(struct net *net, int id)
 {
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	/* multicast addr */
 	struct sockaddr_in mcast_addr = {
 		.sin_family		= AF_INET,
 		.sin_port		= cpu_to_be16(IP_VS_SYNC_PORT + id),
 		.sin_addr.s_addr	= cpu_to_be32(IP_VS_SYNC_GROUP),
 	};
 	struct socket *sock;
 	int result;
 	/* First create a socket */
 	result = sock_create_kern(PF_INET, SOCK_DGRAM, IPPROTO_UDP, &sock);
 	if (result < 0) {
 		pr_err("Error during creation of socket; terminating\n");
 		return ERR_PTR(result);
 	}
 	/*
 	 * Kernel sockets that are a part of a namespace, should not
 	 * hold a reference to a namespace in order to allow to stop it.
 	 * After sk_change_net should be released using sk_release_kernel.
 	 */
 	sk_change_net(sock->sk, net);
 	/* it is equivalent to the REUSEADDR option in user-space */
 	sock->sk->sk_reuse = SK_CAN_REUSE;
 	result = sysctl_sync_sock_size(ipvs);
 	if (result > 0)
 		set_sock_size(sock->sk, 0, result);
 	result = sock->ops->bind(sock, (struct sockaddr *) &mcast_addr,
 			sizeof(struct sockaddr));
 	if (result < 0) {
 		pr_err("Error binding to the multicast addr\n");
 		goto error;
 	}
 	/* join the multicast group */
 	result = join_mcast_group(sock->sk,
 			(struct in_addr *) &mcast_addr.sin_addr,
 			ipvs->backup_mcast_ifn);
 	if (result < 0) {
 		pr_err("Error joining to the multicast group\n");
 		goto error;
 	}
 	return sock;
 error:
 	sk_release_kernel(sock->sk);
 	return ERR_PTR(result);
 }
 static int
 ip_vs_send_async(struct socket *sock, const char *buffer, const size_t length)
 {
 	struct msghdr	msg = {.msg_flags = MSG_DONTWAIT|MSG_NOSIGNAL};
 	struct kvec	iov;
 	int		len;
 	EnterFunction(7);
 	iov.iov_base     = (void *)buffer;
 	iov.iov_len      = length;
 	len = kernel_sendmsg(sock, &msg, &iov, 1, (size_t)(length));
 	LeaveFunction(7);
 	return len;
 }
 static int
 ip_vs_send_sync_msg(struct socket *sock, struct ip_vs_sync_mesg *msg)
 {
 	int msize;
 	int ret;
 	msize = ntohs(msg->size);
 	ret = ip_vs_send_async(sock, (char *)msg, msize);
 	if (ret >= 0 || ret == -EAGAIN)
 		return ret;
 	pr_err("ip_vs_send_async error %d\n", ret);
 	return 0;
 }
 static int
 ip_vs_receive(struct socket *sock, char *buffer, const size_t buflen)
 {
 	struct msghdr		msg = {NULL,};
 	struct kvec		iov;
 	int			len;
 	EnterFunction(7);
 	/* Receive a packet */
 	iov.iov_base     = buffer;
 	iov.iov_len      = (size_t)buflen;
 	len = kernel_recvmsg(sock, &msg, &iov, 1, buflen, MSG_DONTWAIT);
 	if (len < 0)
 		return len;
 	LeaveFunction(7);
 	return len;
 }
 /* Wakeup the master thread for sending */
 static void master_wakeup_work_handler(struct work_struct *work)
 {
 	struct ipvs_master_sync_state *ms =
 		container_of(work, struct ipvs_master_sync_state,
 			     master_wakeup_work.work);
 	struct netns_ipvs *ipvs = ms->ipvs;
 	spin_lock_bh(&ipvs->sync_lock);
 	if (ms->sync_queue_len &&
 	    ms->sync_queue_delay < IPVS_SYNC_WAKEUP_RATE) {
 		ms->sync_queue_delay = IPVS_SYNC_WAKEUP_RATE;
 		wake_up_process(ms->master_thread);
 	}
 	spin_unlock_bh(&ipvs->sync_lock);
 }
 /* Get next buffer to send */
 static inline struct ip_vs_sync_buff *
 next_sync_buff(struct netns_ipvs *ipvs, struct ipvs_master_sync_state *ms)
 {
 	struct ip_vs_sync_buff *sb;
 	sb = sb_dequeue(ipvs, ms);
 	if (sb)
 		return sb;
 	/* Do not delay entries in buffer for more than 2 seconds */
 	return get_curr_sync_buff(ipvs, ms, IPVS_SYNC_FLUSH_TIME);
 }
 static int sync_thread_master(void *data)
 {
 	struct ip_vs_sync_thread_data *tinfo = data;
 	struct netns_ipvs *ipvs = net_ipvs(tinfo->net);
 	struct ipvs_master_sync_state *ms = &ipvs->ms[tinfo->id];
 	struct sock *sk = tinfo->sock->sk;
 	struct ip_vs_sync_buff *sb;
 	pr_info("sync thread started: state = MASTER, mcast_ifn = %s, "
 		"syncid = %d, id = %d\n",
 		ipvs->master_mcast_ifn, ipvs->master_syncid, tinfo->id);
 	for (;;) {
 		sb = next_sync_buff(ipvs, ms);
 		if (unlikely(kthread_should_stop()))
 			break;
 		if (!sb) {
 			schedule_timeout(IPVS_SYNC_CHECK_PERIOD);
 			continue;
 		}
 		while (ip_vs_send_sync_msg(tinfo->sock, sb->mesg) < 0) {
-			int ret = 0;
+			int ret = __wait_event_interruptible(*sk_sleep(sk),
-			__wait_event_interruptible(*sk_sleep(sk),
 						   sock_writeable(sk) ||
-						   kthread_should_stop(),
+						   kthread_should_stop());
-						   ret);
 			if (unlikely(kthread_should_stop()))
 				goto done;
 		}
 		ip_vs_sync_buff_release(sb);
 	}
 done:
 	__set_current_state(TASK_RUNNING);
 	if (sb)
 		ip_vs_sync_buff_release(sb);
 	/* clean up the sync_buff queue */
 	while ((sb = sb_dequeue(ipvs, ms)))
 		ip_vs_sync_buff_release(sb);
 	__set_current_state(TASK_RUNNING);
 	/* clean up the current sync_buff */
 	sb = get_curr_sync_buff(ipvs, ms, 0);
 	if (sb)
 		ip_vs_sync_buff_release(sb);
 	/* release the sending multicast socket */
 	sk_release_kernel(tinfo->sock->sk);
 	kfree(tinfo);
 	return 0;
 }
 static int sync_thread_backup(void *data)
 {
 	struct ip_vs_sync_thread_data *tinfo = data;
 	struct netns_ipvs *ipvs = net_ipvs(tinfo->net);
 	int len;
 	pr_info("sync thread started: state = BACKUP, mcast_ifn = %s, "
 		"syncid = %d, id = %d\n",
 		ipvs->backup_mcast_ifn, ipvs->backup_syncid, tinfo->id);
 	while (!kthread_should_stop()) {
 		wait_event_interruptible(*sk_sleep(tinfo->sock->sk),
 			 !skb_queue_empty(&tinfo->sock->sk->sk_receive_queue)
 			 || kthread_should_stop());
 		/* do we have data now? */
 		while (!skb_queue_empty(&(tinfo->sock->sk->sk_receive_queue))) {
 			len = ip_vs_receive(tinfo->sock, tinfo->buf,
 					ipvs->recv_mesg_maxlen);
 			if (len <= 0) {
 				if (len != -EAGAIN)
 					pr_err("receiving message error\n");
 				break;
 			}
 			ip_vs_process_message(tinfo->net, tinfo->buf, len);
 		}
 	}
 	/* release the sending multicast socket */
 	sk_release_kernel(tinfo->sock->sk);
 	kfree(tinfo->buf);
 	kfree(tinfo);
 	return 0;
 }
 int start_sync_thread(struct net *net, int state, char *mcast_ifn, __u8 syncid)
 {
 	struct ip_vs_sync_thread_data *tinfo;
 	struct task_struct **array = NULL, *task;
 	struct socket *sock;
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	char *name;
 	int (*threadfn)(void *data);
 	int id, count;
 	int result = -ENOMEM;
 	IP_VS_DBG(7, "%s(): pid %d\n", __func__, task_pid_nr(current));
 	IP_VS_DBG(7, "Each ip_vs_sync_conn entry needs %Zd bytes\n",
 		  sizeof(struct ip_vs_sync_conn_v0));
 	if (!ipvs->sync_state) {
 		count = clamp(sysctl_sync_ports(ipvs), 1, IPVS_SYNC_PORTS_MAX);
 		ipvs->threads_mask = count - 1;
 	} else
 		count = ipvs->threads_mask + 1;
 	if (state == IP_VS_STATE_MASTER) {
 		if (ipvs->ms)
 			return -EEXIST;
 		strlcpy(ipvs->master_mcast_ifn, mcast_ifn,
 			sizeof(ipvs->master_mcast_ifn));
 		ipvs->master_syncid = syncid;
 		name = "ipvs-m:%d:%d";
 		threadfn = sync_thread_master;
 	} else if (state == IP_VS_STATE_BACKUP) {
 		if (ipvs->backup_threads)
 			return -EEXIST;
 		strlcpy(ipvs->backup_mcast_ifn, mcast_ifn,
 			sizeof(ipvs->backup_mcast_ifn));
 		ipvs->backup_syncid = syncid;
 		name = "ipvs-b:%d:%d";
 		threadfn = sync_thread_backup;
 	} else {
 		return -EINVAL;
 	}
 	if (state == IP_VS_STATE_MASTER) {
 		struct ipvs_master_sync_state *ms;
 		ipvs->ms = kzalloc(count * sizeof(ipvs->ms[0]), GFP_KERNEL);
 		if (!ipvs->ms)
 			goto out;
 		ms = ipvs->ms;
 		for (id = 0; id < count; id++, ms++) {
 			INIT_LIST_HEAD(&ms->sync_queue);
 			ms->sync_queue_len = 0;
 			ms->sync_queue_delay = 0;
 			INIT_DELAYED_WORK(&ms->master_wakeup_work,
 					  master_wakeup_work_handler);
 			ms->ipvs = ipvs;
 		}
 	} else {
 		array = kzalloc(count * sizeof(struct task_struct *),
 				GFP_KERNEL);
 		if (!array)
 			goto out;
 	}
 	set_sync_mesg_maxlen(net, state);
 	tinfo = NULL;
 	for (id = 0; id < count; id++) {
 		if (state == IP_VS_STATE_MASTER)
 			sock = make_send_sock(net, id);
 		else
 			sock = make_receive_sock(net, id);
 		if (IS_ERR(sock)) {
 			result = PTR_ERR(sock);
 			goto outtinfo;
 		}
 		tinfo = kmalloc(sizeof(*tinfo), GFP_KERNEL);
 		if (!tinfo)
 			goto outsocket;
 		tinfo->net = net;
 		tinfo->sock = sock;
 		if (state == IP_VS_STATE_BACKUP) {
 			tinfo->buf = kmalloc(ipvs->recv_mesg_maxlen,
 					     GFP_KERNEL);
 			if (!tinfo->buf)
 				goto outtinfo;
 		} else {
 			tinfo->buf = NULL;
 		}
 		tinfo->id = id;
 		task = kthread_run(threadfn, tinfo, name, ipvs->gen, id);
 		if (IS_ERR(task)) {
 			result = PTR_ERR(task);
 			goto outtinfo;
 		}
 		tinfo = NULL;
 		if (state == IP_VS_STATE_MASTER)
 			ipvs->ms[id].master_thread = task;
 		else
 			array[id] = task;
 	}
 	/* mark as active */
 	if (state == IP_VS_STATE_BACKUP)
 		ipvs->backup_threads = array;
 	spin_lock_bh(&ipvs->sync_buff_lock);
 	ipvs->sync_state |= state;
 	spin_unlock_bh(&ipvs->sync_buff_lock);
 	/* increase the module use count */
 	ip_vs_use_count_inc();
 	return 0;
 outsocket:
 	sk_release_kernel(sock->sk);
 outtinfo:
 	if (tinfo) {
 		sk_release_kernel(tinfo->sock->sk);
 		kfree(tinfo->buf);
 		kfree(tinfo);
 	}
 	count = id;
 	while (count-- > 0) {
 		if (state == IP_VS_STATE_MASTER)
 			kthread_stop(ipvs->ms[count].master_thread);
 		else
 			kthread_stop(array[count]);
 	}
 	kfree(array);
 out:
 	if (!(ipvs->sync_state & IP_VS_STATE_MASTER)) {
 		kfree(ipvs->ms);
 		ipvs->ms = NULL;
 	}
 	return result;
 }
 int stop_sync_thread(struct net *net, int state)
 {
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	struct task_struct **array;
 	int id;
 	int retc = -EINVAL;
 	IP_VS_DBG(7, "%s(): pid %d\n", __func__, task_pid_nr(current));
 	if (state == IP_VS_STATE_MASTER) {
 		if (!ipvs->ms)
 			return -ESRCH;
 		/*
 		 * The lock synchronizes with sb_queue_tail(), so that we don't
 		 * add sync buffers to the queue, when we are already in
 		 * progress of stopping the master sync daemon.
 		 */
 		spin_lock_bh(&ipvs->sync_buff_lock);
 		spin_lock(&ipvs->sync_lock);
 		ipvs->sync_state &= ~IP_VS_STATE_MASTER;
 		spin_unlock(&ipvs->sync_lock);
 		spin_unlock_bh(&ipvs->sync_buff_lock);
 		retc = 0;
 		for (id = ipvs->threads_mask; id >= 0; id--) {
 			struct ipvs_master_sync_state *ms = &ipvs->ms[id];
 			int ret;
 			pr_info("stopping master sync thread %d ...\n",
 				task_pid_nr(ms->master_thread));
 			cancel_delayed_work_sync(&ms->master_wakeup_work);
 			ret = kthread_stop(ms->master_thread);
 			if (retc >= 0)
 				retc = ret;
 		}
 		kfree(ipvs->ms);
 		ipvs->ms = NULL;
 	} else if (state == IP_VS_STATE_BACKUP) {
 		if (!ipvs->backup_threads)
 			return -ESRCH;
 		ipvs->sync_state &= ~IP_VS_STATE_BACKUP;
 		array = ipvs->backup_threads;
 		retc = 0;
 		for (id = ipvs->threads_mask; id >= 0; id--) {
 			int ret;
 			pr_info("stopping backup sync thread %d ...\n",
 				task_pid_nr(array[id]));
 			ret = kthread_stop(array[id]);
 			if (retc >= 0)
 				retc = ret;
 		}
 		kfree(array);
 		ipvs->backup_threads = NULL;
 	}
 	/* decrease the module use count */
 	ip_vs_use_count_dec();
 	return retc;
 }
 /*
  * Initialize data struct for each netns
  */
 int __net_init ip_vs_sync_net_init(struct net *net)
 {
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	__mutex_init(&ipvs->sync_mutex, "ipvs->sync_mutex", &__ipvs_sync_key);
 	spin_lock_init(&ipvs->sync_lock);
 	spin_lock_init(&ipvs->sync_buff_lock);
 	return 0;
 }
 void ip_vs_sync_net_cleanup(struct net *net)
 {
 	int retc;
 	struct netns_ipvs *ipvs = net_ipvs(net);
 	mutex_lock(&ipvs->sync_mutex);
 	retc = stop_sync_thread(net, IP_VS_STATE_MASTER);
 	if (retc && retc != -ESRCH)
 		pr_err("Failed to stop Master Daemon\n");
 	retc = stop_sync_thread(net, IP_VS_STATE_BACKUP);
 	if (retc && retc != -ESRCH)
 		pr_err("Failed to stop Backup Daemon\n");
 	mutex_unlock(&ipvs->sync_mutex);
 }