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

Commit 41e5a6ac80c600e1f8bda0a4871f0b797e097d78

Authored by Latchesar Ionkov 2006-05-16 00:44:21 +0800

Committed by Linus Torvalds 2006-05-16 02:20:56 +0800

Exists in master and in 7 other branches

[PATCH] v9fs: signal handling fixes

Multiple races can happen when v9fs is interrupted by a signal and Tflush
message is sent to the server.  After v9fs sends Tflush it doesn't wait
until it receives Rflush, and possibly the response of the original
message.  This behavior may confuse v9fs what fids are allocated by the
file server.

This patch fixes the races and the fid allocation.

Signed-off-by: Latchesar Ionkov <lucho@ionkov.net>
Cc: Eric Van Hensbergen <ericvh@hera.kernel.org>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

Showing 4 changed files with 158 additions and 100 deletions Inline Diff

fs/9p/mux.c
fs/9p/mux.h
fs/9p/vfs_file.c
fs/9p/vfs_inode.c

fs/9p/mux.c

Diff comments View file @ 41e5a6a

1	/*	1	/*
2	* linux/fs/9p/mux.c	2	* linux/fs/9p/mux.c
3	*	3	*
4	* Protocol Multiplexer	4	* Protocol Multiplexer
5	*	5	*
6	* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>	6	* Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
7	* Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>	7	* Copyright (C) 2004-2005 by Latchesar Ionkov <lucho@ionkov.net>
8	*	8	*
9	* This program is free software; you can redistribute it and/or modify	9	* This program is free software; you can redistribute it and/or modify
10	* it under the terms of the GNU General Public License version 2	10	* it under the terms of the GNU General Public License version 2
11	* as published by the Free Software Foundation.	11	* as published by the Free Software Foundation.
12	*	12	*
13	* This program is distributed in the hope that it will be useful,	13	* This program is distributed in the hope that it will be useful,
14	* but WITHOUT ANY WARRANTY; without even the implied warranty of	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16	* GNU General Public License for more details.	16	* GNU General Public License for more details.
17	*	17	*
18	* You should have received a copy of the GNU General Public License	18	* You should have received a copy of the GNU General Public License
19	* along with this program; if not, write to:	19	* along with this program; if not, write to:
20	* Free Software Foundation	20	* Free Software Foundation
21	* 51 Franklin Street, Fifth Floor	21	* 51 Franklin Street, Fifth Floor
22	* Boston, MA 02111-1301 USA	22	* Boston, MA 02111-1301 USA
23	*	23	*
24	*/	24	*/
25		25
26	#include <linux/config.h>	26	#include <linux/config.h>
27	#include <linux/module.h>	27	#include <linux/module.h>
28	#include <linux/errno.h>	28	#include <linux/errno.h>
29	#include <linux/fs.h>	29	#include <linux/fs.h>
30	#include <linux/poll.h>	30	#include <linux/poll.h>
31	#include <linux/kthread.h>	31	#include <linux/kthread.h>
32	#include <linux/idr.h>	32	#include <linux/idr.h>
33	#include <linux/mutex.h>	33	#include <linux/mutex.h>
34		34
35	#include "debug.h"	35	#include "debug.h"
36	#include "v9fs.h"	36	#include "v9fs.h"
37	#include "9p.h"	37	#include "9p.h"
38	#include "conv.h"	38	#include "conv.h"
39	#include "transport.h"	39	#include "transport.h"
40	#include "mux.h"	40	#include "mux.h"
41		41
42	#define ERREQFLUSH 1	42	#define ERREQFLUSH 1
43	#define SCHED_TIMEOUT 10	43	#define SCHED_TIMEOUT 10
44	#define MAXPOLLWADDR 2	44	#define MAXPOLLWADDR 2
45		45
46	enum {	46	enum {
47	Rworksched = 1, /* read work scheduled or running */	47	Rworksched = 1, /* read work scheduled or running */
48	Rpending = 2, /* can read */	48	Rpending = 2, /* can read */
49	Wworksched = 4, /* write work scheduled or running */	49	Wworksched = 4, /* write work scheduled or running */
50	Wpending = 8, /* can write */	50	Wpending = 8, /* can write */
51	};	51	};
52		52
		53	enum {
		54	None,
		55	Flushing,
		56	Flushed,
		57	};
		58
53	struct v9fs_mux_poll_task;	59	struct v9fs_mux_poll_task;
54		60
55	struct v9fs_req {	61	struct v9fs_req {
		62	spinlock_t lock;
56	int tag;	63	int tag;
57	struct v9fs_fcall *tcall;	64	struct v9fs_fcall *tcall;
58	struct v9fs_fcall *rcall;	65	struct v9fs_fcall *rcall;
59	int err;	66	int err;
60	v9fs_mux_req_callback cb;	67	v9fs_mux_req_callback cb;
61	void *cba;	68	void *cba;
		69	int flush;
62	struct list_head req_list;	70	struct list_head req_list;
63	};	71	};
64		72
65	struct v9fs_mux_data {	73	struct v9fs_mux_data {
66	spinlock_t lock;	74	spinlock_t lock;
67	struct list_head mux_list;	75	struct list_head mux_list;
68	struct v9fs_mux_poll_task *poll_task;	76	struct v9fs_mux_poll_task *poll_task;
69	int msize;	77	int msize;
70	unsigned char *extended;	78	unsigned char *extended;
71	struct v9fs_transport *trans;	79	struct v9fs_transport *trans;
72	struct v9fs_idpool tagpool;	80	struct v9fs_idpool tagpool;
73	int err;	81	int err;
74	wait_queue_head_t equeue;	82	wait_queue_head_t equeue;
75	struct list_head req_list;	83	struct list_head req_list;
76	struct list_head unsent_req_list;	84	struct list_head unsent_req_list;
77	struct v9fs_fcall *rcall;	85	struct v9fs_fcall *rcall;
78	int rpos;	86	int rpos;
79	char *rbuf;	87	char *rbuf;
80	int wpos;	88	int wpos;
81	int wsize;	89	int wsize;
82	char *wbuf;	90	char *wbuf;
83	wait_queue_t poll_wait[MAXPOLLWADDR];	91	wait_queue_t poll_wait[MAXPOLLWADDR];
84	wait_queue_head_t *poll_waddr[MAXPOLLWADDR];	92	wait_queue_head_t *poll_waddr[MAXPOLLWADDR];
85	poll_table pt;	93	poll_table pt;
86	struct work_struct rq;	94	struct work_struct rq;
87	struct work_struct wq;	95	struct work_struct wq;
88	unsigned long wsched;	96	unsigned long wsched;
89	};	97	};
90		98
91	struct v9fs_mux_poll_task {	99	struct v9fs_mux_poll_task {
92	struct task_struct *task;	100	struct task_struct *task;
93	struct list_head mux_list;	101	struct list_head mux_list;
94	int muxnum;	102	int muxnum;
95	};	103	};
96		104
97	struct v9fs_mux_rpc {	105	struct v9fs_mux_rpc {
98	struct v9fs_mux_data *m;	106	struct v9fs_mux_data *m;
99	struct v9fs_req *req;
100	int err;	107	int err;
		108	struct v9fs_fcall *tcall;
101	struct v9fs_fcall *rcall;	109	struct v9fs_fcall *rcall;
102	wait_queue_head_t wqueue;	110	wait_queue_head_t wqueue;
103	};	111	};
104		112
105	static int v9fs_poll_proc(void *);	113	static int v9fs_poll_proc(void *);
106	static void v9fs_read_work(void *);	114	static void v9fs_read_work(void *);
107	static void v9fs_write_work(void *);	115	static void v9fs_write_work(void *);
108	static void v9fs_pollwait(struct file filp, wait_queue_head_t wait_address,	116	static void v9fs_pollwait(struct file filp, wait_queue_head_t wait_address,
109	poll_table * p);	117	poll_table * p);
110	static u16 v9fs_mux_get_tag(struct v9fs_mux_data *);	118	static u16 v9fs_mux_get_tag(struct v9fs_mux_data *);
111	static void v9fs_mux_put_tag(struct v9fs_mux_data *, u16);	119	static void v9fs_mux_put_tag(struct v9fs_mux_data *, u16);
112		120
113	static DEFINE_MUTEX(v9fs_mux_task_lock);	121	static DEFINE_MUTEX(v9fs_mux_task_lock);
114	static struct workqueue_struct *v9fs_mux_wq;	122	static struct workqueue_struct *v9fs_mux_wq;
115		123
116	static int v9fs_mux_num;	124	static int v9fs_mux_num;
117	static int v9fs_mux_poll_task_num;	125	static int v9fs_mux_poll_task_num;
118	static struct v9fs_mux_poll_task v9fs_mux_poll_tasks[100];	126	static struct v9fs_mux_poll_task v9fs_mux_poll_tasks[100];
119		127
120	int v9fs_mux_global_init(void)	128	int v9fs_mux_global_init(void)
121	{	129	{
122	int i;	130	int i;
123		131
124	for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++)	132	for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++)
125	v9fs_mux_poll_tasks[i].task = NULL;	133	v9fs_mux_poll_tasks[i].task = NULL;
126		134
127	v9fs_mux_wq = create_workqueue("v9fs");	135	v9fs_mux_wq = create_workqueue("v9fs");
128	if (!v9fs_mux_wq)	136	if (!v9fs_mux_wq)
129	return -ENOMEM;	137	return -ENOMEM;
130		138
131	return 0;	139	return 0;
132	}	140	}
133		141
134	void v9fs_mux_global_exit(void)	142	void v9fs_mux_global_exit(void)
135	{	143	{
136	destroy_workqueue(v9fs_mux_wq);	144	destroy_workqueue(v9fs_mux_wq);
137	}	145	}
138		146
139	/**	147	/**
140	* v9fs_mux_calc_poll_procs - calculates the number of polling procs	148	* v9fs_mux_calc_poll_procs - calculates the number of polling procs
141	* based on the number of mounted v9fs filesystems.	149	* based on the number of mounted v9fs filesystems.
142	*	150	*
143	* The current implementation returns sqrt of the number of mounts.	151	* The current implementation returns sqrt of the number of mounts.
144	*/	152	*/
145	static int v9fs_mux_calc_poll_procs(int muxnum)	153	static int v9fs_mux_calc_poll_procs(int muxnum)
146	{	154	{
147	int n;	155	int n;
148		156
149	if (v9fs_mux_poll_task_num)	157	if (v9fs_mux_poll_task_num)
150	n = muxnum / v9fs_mux_poll_task_num +	158	n = muxnum / v9fs_mux_poll_task_num +
151	(muxnum % v9fs_mux_poll_task_num ? 1 : 0);	159	(muxnum % v9fs_mux_poll_task_num ? 1 : 0);
152	else	160	else
153	n = 1;	161	n = 1;
154		162
155	if (n > ARRAY_SIZE(v9fs_mux_poll_tasks))	163	if (n > ARRAY_SIZE(v9fs_mux_poll_tasks))
156	n = ARRAY_SIZE(v9fs_mux_poll_tasks);	164	n = ARRAY_SIZE(v9fs_mux_poll_tasks);
157		165
158	return n;	166	return n;
159	}	167	}
160		168
161	static int v9fs_mux_poll_start(struct v9fs_mux_data *m)	169	static int v9fs_mux_poll_start(struct v9fs_mux_data *m)
162	{	170	{
163	int i, n;	171	int i, n;
164	struct v9fs_mux_poll_task vpt, vptlast;	172	struct v9fs_mux_poll_task vpt, vptlast;
165	struct task_struct *pproc;	173	struct task_struct *pproc;
166		174
167	dprintk(DEBUG_MUX, "mux %p muxnum %d procnum %d\n", m, v9fs_mux_num,	175	dprintk(DEBUG_MUX, "mux %p muxnum %d procnum %d\n", m, v9fs_mux_num,
168	v9fs_mux_poll_task_num);	176	v9fs_mux_poll_task_num);
169	mutex_lock(&v9fs_mux_task_lock);	177	mutex_lock(&v9fs_mux_task_lock);
170		178
171	n = v9fs_mux_calc_poll_procs(v9fs_mux_num + 1);	179	n = v9fs_mux_calc_poll_procs(v9fs_mux_num + 1);
172	if (n > v9fs_mux_poll_task_num) {	180	if (n > v9fs_mux_poll_task_num) {
173	for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++) {	181	for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++) {
174	if (v9fs_mux_poll_tasks[i].task == NULL) {	182	if (v9fs_mux_poll_tasks[i].task == NULL) {
175	vpt = &v9fs_mux_poll_tasks[i];	183	vpt = &v9fs_mux_poll_tasks[i];
176	dprintk(DEBUG_MUX, "create proc %p\n", vpt);	184	dprintk(DEBUG_MUX, "create proc %p\n", vpt);
177	pproc = kthread_create(v9fs_poll_proc, vpt,	185	pproc = kthread_create(v9fs_poll_proc, vpt,
178	"v9fs-poll");	186	"v9fs-poll");
179		187
180	if (!IS_ERR(pproc)) {	188	if (!IS_ERR(pproc)) {
181	vpt->task = pproc;	189	vpt->task = pproc;
182	INIT_LIST_HEAD(&vpt->mux_list);	190	INIT_LIST_HEAD(&vpt->mux_list);
183	vpt->muxnum = 0;	191	vpt->muxnum = 0;
184	v9fs_mux_poll_task_num++;	192	v9fs_mux_poll_task_num++;
185	wake_up_process(vpt->task);	193	wake_up_process(vpt->task);
186	}	194	}
187	break;	195	break;
188	}	196	}
189	}	197	}
190		198
191	if (i >= ARRAY_SIZE(v9fs_mux_poll_tasks))	199	if (i >= ARRAY_SIZE(v9fs_mux_poll_tasks))
192	dprintk(DEBUG_ERROR, "warning: no free poll slots\n");	200	dprintk(DEBUG_ERROR, "warning: no free poll slots\n");
193	}	201	}
194		202
195	n = (v9fs_mux_num + 1) / v9fs_mux_poll_task_num +	203	n = (v9fs_mux_num + 1) / v9fs_mux_poll_task_num +
196	((v9fs_mux_num + 1) % v9fs_mux_poll_task_num ? 1 : 0);	204	((v9fs_mux_num + 1) % v9fs_mux_poll_task_num ? 1 : 0);
197		205
198	vptlast = NULL;	206	vptlast = NULL;
199	for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++) {	207	for (i = 0; i < ARRAY_SIZE(v9fs_mux_poll_tasks); i++) {
200	vpt = &v9fs_mux_poll_tasks[i];	208	vpt = &v9fs_mux_poll_tasks[i];
201	if (vpt->task != NULL) {	209	if (vpt->task != NULL) {
202	vptlast = vpt;	210	vptlast = vpt;
203	if (vpt->muxnum < n) {	211	if (vpt->muxnum < n) {
204	dprintk(DEBUG_MUX, "put in proc %d\n", i);	212	dprintk(DEBUG_MUX, "put in proc %d\n", i);
205	list_add(&m->mux_list, &vpt->mux_list);	213	list_add(&m->mux_list, &vpt->mux_list);
206	vpt->muxnum++;	214	vpt->muxnum++;
207	m->poll_task = vpt;	215	m->poll_task = vpt;
208	memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));	216	memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
209	init_poll_funcptr(&m->pt, v9fs_pollwait);	217	init_poll_funcptr(&m->pt, v9fs_pollwait);
210	break;	218	break;
211	}	219	}
212	}	220	}
213	}	221	}
214		222
215	if (i >= ARRAY_SIZE(v9fs_mux_poll_tasks)) {	223	if (i >= ARRAY_SIZE(v9fs_mux_poll_tasks)) {
216	if (vptlast == NULL)	224	if (vptlast == NULL)
217	return -ENOMEM;	225	return -ENOMEM;
218		226
219	dprintk(DEBUG_MUX, "put in proc %d\n", i);	227	dprintk(DEBUG_MUX, "put in proc %d\n", i);
220	list_add(&m->mux_list, &vptlast->mux_list);	228	list_add(&m->mux_list, &vptlast->mux_list);
221	vptlast->muxnum++;	229	vptlast->muxnum++;
222	m->poll_task = vptlast;	230	m->poll_task = vptlast;
223	memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));	231	memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
224	init_poll_funcptr(&m->pt, v9fs_pollwait);	232	init_poll_funcptr(&m->pt, v9fs_pollwait);
225	}	233	}
226		234
227	v9fs_mux_num++;	235	v9fs_mux_num++;
228	mutex_unlock(&v9fs_mux_task_lock);	236	mutex_unlock(&v9fs_mux_task_lock);
229		237
230	return 0;	238	return 0;
231	}	239	}
232		240
233	static void v9fs_mux_poll_stop(struct v9fs_mux_data *m)	241	static void v9fs_mux_poll_stop(struct v9fs_mux_data *m)
234	{	242	{
235	int i;	243	int i;
236	struct v9fs_mux_poll_task *vpt;	244	struct v9fs_mux_poll_task *vpt;
237		245
238	mutex_lock(&v9fs_mux_task_lock);	246	mutex_lock(&v9fs_mux_task_lock);
239	vpt = m->poll_task;	247	vpt = m->poll_task;
240	list_del(&m->mux_list);	248	list_del(&m->mux_list);
241	for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {	249	for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
242	if (m->poll_waddr[i] != NULL) {	250	if (m->poll_waddr[i] != NULL) {
243	remove_wait_queue(m->poll_waddr[i], &m->poll_wait[i]);	251	remove_wait_queue(m->poll_waddr[i], &m->poll_wait[i]);
244	m->poll_waddr[i] = NULL;	252	m->poll_waddr[i] = NULL;
245	}	253	}
246	}	254	}
247	vpt->muxnum--;	255	vpt->muxnum--;
248	if (!vpt->muxnum) {	256	if (!vpt->muxnum) {
249	dprintk(DEBUG_MUX, "destroy proc %p\n", vpt);	257	dprintk(DEBUG_MUX, "destroy proc %p\n", vpt);
250	send_sig(SIGKILL, vpt->task, 1);	258	send_sig(SIGKILL, vpt->task, 1);
251	vpt->task = NULL;	259	vpt->task = NULL;
252	v9fs_mux_poll_task_num--;	260	v9fs_mux_poll_task_num--;
253	}	261	}
254	v9fs_mux_num--;	262	v9fs_mux_num--;
255	mutex_unlock(&v9fs_mux_task_lock);	263	mutex_unlock(&v9fs_mux_task_lock);
256	}	264	}
257		265
258	/**	266	/**
259	* v9fs_mux_init - allocate and initialize the per-session mux data	267	* v9fs_mux_init - allocate and initialize the per-session mux data
260	* Creates the polling task if this is the first session.	268	* Creates the polling task if this is the first session.
261	*	269	*
262	* @trans - transport structure	270	* @trans - transport structure
263	* @msize - maximum message size	271	* @msize - maximum message size
264	* @extended - pointer to the extended flag	272	* @extended - pointer to the extended flag
265	*/	273	*/
266	struct v9fs_mux_data v9fs_mux_init(struct v9fs_transport trans, int msize,	274	struct v9fs_mux_data v9fs_mux_init(struct v9fs_transport trans, int msize,
267	unsigned char *extended)	275	unsigned char *extended)
268	{	276	{
269	int i, n;	277	int i, n;
270	struct v9fs_mux_data m, mtmp;	278	struct v9fs_mux_data m, mtmp;
271		279
272	dprintk(DEBUG_MUX, "transport %p msize %d\n", trans, msize);	280	dprintk(DEBUG_MUX, "transport %p msize %d\n", trans, msize);
273	m = kmalloc(sizeof(struct v9fs_mux_data), GFP_KERNEL);	281	m = kmalloc(sizeof(struct v9fs_mux_data), GFP_KERNEL);
274	if (!m)	282	if (!m)
275	return ERR_PTR(-ENOMEM);	283	return ERR_PTR(-ENOMEM);
276		284
277	spin_lock_init(&m->lock);	285	spin_lock_init(&m->lock);
278	INIT_LIST_HEAD(&m->mux_list);	286	INIT_LIST_HEAD(&m->mux_list);
279	m->msize = msize;	287	m->msize = msize;
280	m->extended = extended;	288	m->extended = extended;
281	m->trans = trans;	289	m->trans = trans;
282	idr_init(&m->tagpool.pool);	290	idr_init(&m->tagpool.pool);
283	init_MUTEX(&m->tagpool.lock);	291	init_MUTEX(&m->tagpool.lock);
284	m->err = 0;	292	m->err = 0;
285	init_waitqueue_head(&m->equeue);	293	init_waitqueue_head(&m->equeue);
286	INIT_LIST_HEAD(&m->req_list);	294	INIT_LIST_HEAD(&m->req_list);
287	INIT_LIST_HEAD(&m->unsent_req_list);	295	INIT_LIST_HEAD(&m->unsent_req_list);
288	m->rcall = NULL;	296	m->rcall = NULL;
289	m->rpos = 0;	297	m->rpos = 0;
290	m->rbuf = NULL;	298	m->rbuf = NULL;
291	m->wpos = m->wsize = 0;	299	m->wpos = m->wsize = 0;
292	m->wbuf = NULL;	300	m->wbuf = NULL;
293	INIT_WORK(&m->rq, v9fs_read_work, m);	301	INIT_WORK(&m->rq, v9fs_read_work, m);
294	INIT_WORK(&m->wq, v9fs_write_work, m);	302	INIT_WORK(&m->wq, v9fs_write_work, m);
295	m->wsched = 0;	303	m->wsched = 0;
296	memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));	304	memset(&m->poll_waddr, 0, sizeof(m->poll_waddr));
297	m->poll_task = NULL;	305	m->poll_task = NULL;
298	n = v9fs_mux_poll_start(m);	306	n = v9fs_mux_poll_start(m);
299	if (n)	307	if (n)
300	return ERR_PTR(n);	308	return ERR_PTR(n);
301		309
302	n = trans->poll(trans, &m->pt);	310	n = trans->poll(trans, &m->pt);
303	if (n & POLLIN) {	311	if (n & POLLIN) {
304	dprintk(DEBUG_MUX, "mux %p can read\n", m);	312	dprintk(DEBUG_MUX, "mux %p can read\n", m);
305	set_bit(Rpending, &m->wsched);	313	set_bit(Rpending, &m->wsched);
306	}	314	}
307		315
308	if (n & POLLOUT) {	316	if (n & POLLOUT) {
309	dprintk(DEBUG_MUX, "mux %p can write\n", m);	317	dprintk(DEBUG_MUX, "mux %p can write\n", m);
310	set_bit(Wpending, &m->wsched);	318	set_bit(Wpending, &m->wsched);
311	}	319	}
312		320
313	for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {	321	for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++) {
314	if (IS_ERR(m->poll_waddr[i])) {	322	if (IS_ERR(m->poll_waddr[i])) {
315	v9fs_mux_poll_stop(m);	323	v9fs_mux_poll_stop(m);
316	mtmp = (void )m->poll_waddr; / the error code */	324	mtmp = (void )m->poll_waddr; / the error code */
317	kfree(m);	325	kfree(m);
318	m = mtmp;	326	m = mtmp;
319	break;	327	break;
320	}	328	}
321	}	329	}
322		330
323	return m;	331	return m;
324	}	332	}
325		333
326	/**	334	/**
327	* v9fs_mux_destroy - cancels all pending requests and frees mux resources	335	* v9fs_mux_destroy - cancels all pending requests and frees mux resources
328	*/	336	*/
329	void v9fs_mux_destroy(struct v9fs_mux_data *m)	337	void v9fs_mux_destroy(struct v9fs_mux_data *m)
330	{	338	{
331	dprintk(DEBUG_MUX, "mux %p prev %p next %p\n", m,	339	dprintk(DEBUG_MUX, "mux %p prev %p next %p\n", m,
332	m->mux_list.prev, m->mux_list.next);	340	m->mux_list.prev, m->mux_list.next);
333	v9fs_mux_cancel(m, -ECONNRESET);	341	v9fs_mux_cancel(m, -ECONNRESET);
334		342
335	if (!list_empty(&m->req_list)) {	343	if (!list_empty(&m->req_list)) {
336	/* wait until all processes waiting on this session exit */	344	/* wait until all processes waiting on this session exit */
337	dprintk(DEBUG_MUX, "mux %p waiting for empty request queue\n",	345	dprintk(DEBUG_MUX, "mux %p waiting for empty request queue\n",
338	m);	346	m);
339	wait_event_timeout(m->equeue, (list_empty(&m->req_list)), 5000);	347	wait_event_timeout(m->equeue, (list_empty(&m->req_list)), 5000);
340	dprintk(DEBUG_MUX, "mux %p request queue empty: %d\n", m,	348	dprintk(DEBUG_MUX, "mux %p request queue empty: %d\n", m,
341	list_empty(&m->req_list));	349	list_empty(&m->req_list));
342	}	350	}
343		351
344	v9fs_mux_poll_stop(m);	352	v9fs_mux_poll_stop(m);
345	m->trans = NULL;	353	m->trans = NULL;
346		354
347	kfree(m);	355	kfree(m);
348	}	356	}
349		357
350	/**	358	/**
351	* v9fs_pollwait - called by files poll operation to add v9fs-poll task	359	* v9fs_pollwait - called by files poll operation to add v9fs-poll task
352	* to files wait queue	360	* to files wait queue
353	*/	361	*/
354	static void	362	static void
355	v9fs_pollwait(struct file filp, wait_queue_head_t wait_address,	363	v9fs_pollwait(struct file filp, wait_queue_head_t wait_address,
356	poll_table * p)	364	poll_table * p)
357	{	365	{
358	int i;	366	int i;
359	struct v9fs_mux_data *m;	367	struct v9fs_mux_data *m;
360		368
361	m = container_of(p, struct v9fs_mux_data, pt);	369	m = container_of(p, struct v9fs_mux_data, pt);
362	for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++)	370	for(i = 0; i < ARRAY_SIZE(m->poll_waddr); i++)
363	if (m->poll_waddr[i] == NULL)	371	if (m->poll_waddr[i] == NULL)
364	break;	372	break;
365		373
366	if (i >= ARRAY_SIZE(m->poll_waddr)) {	374	if (i >= ARRAY_SIZE(m->poll_waddr)) {
367	dprintk(DEBUG_ERROR, "not enough wait_address slots\n");	375	dprintk(DEBUG_ERROR, "not enough wait_address slots\n");
368	return;	376	return;
369	}	377	}
370		378
371	m->poll_waddr[i] = wait_address;	379	m->poll_waddr[i] = wait_address;
372		380
373	if (!wait_address) {	381	if (!wait_address) {
374	dprintk(DEBUG_ERROR, "no wait_address\n");	382	dprintk(DEBUG_ERROR, "no wait_address\n");
375	m->poll_waddr[i] = ERR_PTR(-EIO);	383	m->poll_waddr[i] = ERR_PTR(-EIO);
376	return;	384	return;
377	}	385	}
378		386
379	init_waitqueue_entry(&m->poll_wait[i], m->poll_task->task);	387	init_waitqueue_entry(&m->poll_wait[i], m->poll_task->task);
380	add_wait_queue(wait_address, &m->poll_wait[i]);	388	add_wait_queue(wait_address, &m->poll_wait[i]);
381	}	389	}
382		390
383	/**	391	/**
384	* v9fs_poll_mux - polls a mux and schedules read or write works if necessary	392	* v9fs_poll_mux - polls a mux and schedules read or write works if necessary
385	*/	393	*/
386	static void v9fs_poll_mux(struct v9fs_mux_data *m)	394	static void v9fs_poll_mux(struct v9fs_mux_data *m)
387	{	395	{
388	int n;	396	int n;
389		397
390	if (m->err < 0)	398	if (m->err < 0)
391	return;	399	return;
392		400
393	n = m->trans->poll(m->trans, NULL);	401	n = m->trans->poll(m->trans, NULL);
394	if (n < 0 \|\| n & (POLLERR \| POLLHUP \| POLLNVAL)) {	402	if (n < 0 \|\| n & (POLLERR \| POLLHUP \| POLLNVAL)) {
395	dprintk(DEBUG_MUX, "error mux %p err %d\n", m, n);	403	dprintk(DEBUG_MUX, "error mux %p err %d\n", m, n);
396	if (n >= 0)	404	if (n >= 0)
397	n = -ECONNRESET;	405	n = -ECONNRESET;
398	v9fs_mux_cancel(m, n);	406	v9fs_mux_cancel(m, n);
399	}	407	}
400		408
401	if (n & POLLIN) {	409	if (n & POLLIN) {
402	set_bit(Rpending, &m->wsched);	410	set_bit(Rpending, &m->wsched);
403	dprintk(DEBUG_MUX, "mux %p can read\n", m);	411	dprintk(DEBUG_MUX, "mux %p can read\n", m);
404	if (!test_and_set_bit(Rworksched, &m->wsched)) {	412	if (!test_and_set_bit(Rworksched, &m->wsched)) {
405	dprintk(DEBUG_MUX, "schedule read work mux %p\n", m);	413	dprintk(DEBUG_MUX, "schedule read work mux %p\n", m);
406	queue_work(v9fs_mux_wq, &m->rq);	414	queue_work(v9fs_mux_wq, &m->rq);
407	}	415	}
408	}	416	}
409		417
410	if (n & POLLOUT) {	418	if (n & POLLOUT) {
411	set_bit(Wpending, &m->wsched);	419	set_bit(Wpending, &m->wsched);
412	dprintk(DEBUG_MUX, "mux %p can write\n", m);	420	dprintk(DEBUG_MUX, "mux %p can write\n", m);
413	if ((m->wsize \|\| !list_empty(&m->unsent_req_list))	421	if ((m->wsize \|\| !list_empty(&m->unsent_req_list))
414	&& !test_and_set_bit(Wworksched, &m->wsched)) {	422	&& !test_and_set_bit(Wworksched, &m->wsched)) {
415	dprintk(DEBUG_MUX, "schedule write work mux %p\n", m);	423	dprintk(DEBUG_MUX, "schedule write work mux %p\n", m);
416	queue_work(v9fs_mux_wq, &m->wq);	424	queue_work(v9fs_mux_wq, &m->wq);
417	}	425	}
418	}	426	}
419	}	427	}
420		428
421	/**	429	/**
422	* v9fs_poll_proc - polls all v9fs transports for new events and queues	430	* v9fs_poll_proc - polls all v9fs transports for new events and queues
423	* the appropriate work to the work queue	431	* the appropriate work to the work queue
424	*/	432	*/
425	static int v9fs_poll_proc(void *a)	433	static int v9fs_poll_proc(void *a)
426	{	434	{
427	struct v9fs_mux_data m, mtmp;	435	struct v9fs_mux_data m, mtmp;
428	struct v9fs_mux_poll_task *vpt;	436	struct v9fs_mux_poll_task *vpt;
429		437
430	vpt = a;	438	vpt = a;
431	dprintk(DEBUG_MUX, "start %p %p\n", current, vpt);	439	dprintk(DEBUG_MUX, "start %p %p\n", current, vpt);
432	allow_signal(SIGKILL);	440	allow_signal(SIGKILL);
433	while (!kthread_should_stop()) {	441	while (!kthread_should_stop()) {
434	set_current_state(TASK_INTERRUPTIBLE);	442	set_current_state(TASK_INTERRUPTIBLE);
435	if (signal_pending(current))	443	if (signal_pending(current))
436	break;	444	break;
437		445
438	list_for_each_entry_safe(m, mtmp, &vpt->mux_list, mux_list) {	446	list_for_each_entry_safe(m, mtmp, &vpt->mux_list, mux_list) {
439	v9fs_poll_mux(m);	447	v9fs_poll_mux(m);
440	}	448	}
441		449
442	dprintk(DEBUG_MUX, "sleeping...\n");	450	dprintk(DEBUG_MUX, "sleeping...\n");
443	schedule_timeout(SCHED_TIMEOUT * HZ);	451	schedule_timeout(SCHED_TIMEOUT * HZ);
444	}	452	}
445		453
446	__set_current_state(TASK_RUNNING);	454	__set_current_state(TASK_RUNNING);
447	dprintk(DEBUG_MUX, "finish\n");	455	dprintk(DEBUG_MUX, "finish\n");
448	return 0;	456	return 0;
449	}	457	}
450		458
451	/**	459	/**
452	* v9fs_write_work - called when a transport can send some data	460	* v9fs_write_work - called when a transport can send some data
453	*/	461	*/
454	static void v9fs_write_work(void *a)	462	static void v9fs_write_work(void *a)
455	{	463	{
456	int n, err;	464	int n, err;
457	struct v9fs_mux_data *m;	465	struct v9fs_mux_data *m;
458	struct v9fs_req *req;	466	struct v9fs_req *req;
459		467
460	m = a;	468	m = a;
461		469
462	if (m->err < 0) {	470	if (m->err < 0) {
463	clear_bit(Wworksched, &m->wsched);	471	clear_bit(Wworksched, &m->wsched);
464	return;	472	return;
465	}	473	}
466		474
467	if (!m->wsize) {	475	if (!m->wsize) {
468	if (list_empty(&m->unsent_req_list)) {	476	if (list_empty(&m->unsent_req_list)) {
469	clear_bit(Wworksched, &m->wsched);	477	clear_bit(Wworksched, &m->wsched);
470	return;	478	return;
471	}	479	}
472		480
473	spin_lock(&m->lock);	481	spin_lock(&m->lock);
474	again:	482	again:
475	req = list_entry(m->unsent_req_list.next, struct v9fs_req,	483	req = list_entry(m->unsent_req_list.next, struct v9fs_req,
476	req_list);	484	req_list);
477	list_move_tail(&req->req_list, &m->req_list);	485	list_move_tail(&req->req_list, &m->req_list);
478	if (req->err == ERREQFLUSH)	486	if (req->err == ERREQFLUSH)
479	goto again;	487	goto again;
480		488
481	m->wbuf = req->tcall->sdata;	489	m->wbuf = req->tcall->sdata;
482	m->wsize = req->tcall->size;	490	m->wsize = req->tcall->size;
483	m->wpos = 0;	491	m->wpos = 0;
484	dump_data(m->wbuf, m->wsize);	492	dump_data(m->wbuf, m->wsize);
485	spin_unlock(&m->lock);	493	spin_unlock(&m->lock);
486	}	494	}
487		495
488	dprintk(DEBUG_MUX, "mux %p pos %d size %d\n", m, m->wpos, m->wsize);	496	dprintk(DEBUG_MUX, "mux %p pos %d size %d\n", m, m->wpos, m->wsize);
489	clear_bit(Wpending, &m->wsched);	497	clear_bit(Wpending, &m->wsched);
490	err = m->trans->write(m->trans, m->wbuf + m->wpos, m->wsize - m->wpos);	498	err = m->trans->write(m->trans, m->wbuf + m->wpos, m->wsize - m->wpos);
491	dprintk(DEBUG_MUX, "mux %p sent %d bytes\n", m, err);	499	dprintk(DEBUG_MUX, "mux %p sent %d bytes\n", m, err);
492	if (err == -EAGAIN) {	500	if (err == -EAGAIN) {
493	clear_bit(Wworksched, &m->wsched);	501	clear_bit(Wworksched, &m->wsched);
494	return;	502	return;
495	}	503	}
496		504
497	if (err <= 0)	505	if (err <= 0)
498	goto error;	506	goto error;
499		507
500	m->wpos += err;	508	m->wpos += err;
501	if (m->wpos == m->wsize)	509	if (m->wpos == m->wsize)
502	m->wpos = m->wsize = 0;	510	m->wpos = m->wsize = 0;
503		511
504	if (m->wsize == 0 && !list_empty(&m->unsent_req_list)) {	512	if (m->wsize == 0 && !list_empty(&m->unsent_req_list)) {
505	if (test_and_clear_bit(Wpending, &m->wsched))	513	if (test_and_clear_bit(Wpending, &m->wsched))
506	n = POLLOUT;	514	n = POLLOUT;
507	else	515	else
508	n = m->trans->poll(m->trans, NULL);	516	n = m->trans->poll(m->trans, NULL);
509		517
510	if (n & POLLOUT) {	518	if (n & POLLOUT) {
511	dprintk(DEBUG_MUX, "schedule write work mux %p\n", m);	519	dprintk(DEBUG_MUX, "schedule write work mux %p\n", m);
512	queue_work(v9fs_mux_wq, &m->wq);	520	queue_work(v9fs_mux_wq, &m->wq);
513	} else	521	} else
514	clear_bit(Wworksched, &m->wsched);	522	clear_bit(Wworksched, &m->wsched);
515	} else	523	} else
516	clear_bit(Wworksched, &m->wsched);	524	clear_bit(Wworksched, &m->wsched);
517		525
518	return;	526	return;
519		527
520	error:	528	error:
521	v9fs_mux_cancel(m, err);	529	v9fs_mux_cancel(m, err);
522	clear_bit(Wworksched, &m->wsched);	530	clear_bit(Wworksched, &m->wsched);
523	}	531	}
524		532
525	static void process_request(struct v9fs_mux_data m, struct v9fs_req req)	533	static void process_request(struct v9fs_mux_data m, struct v9fs_req req)
526	{	534	{
527	int ecode, tag;	535	int ecode;
528	struct v9fs_str *ename;	536	struct v9fs_str *ename;
529		537
530	tag = req->tag;
531	if (!req->err && req->rcall->id == RERROR) {	538	if (!req->err && req->rcall->id == RERROR) {
532	ecode = req->rcall->params.rerror.errno;	539	ecode = req->rcall->params.rerror.errno;
533	ename = &req->rcall->params.rerror.error;	540	ename = &req->rcall->params.rerror.error;
534		541
535	dprintk(DEBUG_MUX, "Rerror %.*s\n", ename->len, ename->str);	542	dprintk(DEBUG_MUX, "Rerror %.*s\n", ename->len, ename->str);
536		543
537	if (*m->extended)	544	if (*m->extended)
538	req->err = -ecode;	545	req->err = -ecode;
539		546
540	if (!req->err) {	547	if (!req->err) {
541	req->err = v9fs_errstr2errno(ename->str, ename->len);	548	req->err = v9fs_errstr2errno(ename->str, ename->len);
542		549
543	if (!req->err) { /* string match failed */	550	if (!req->err) { /* string match failed */
544	PRINT_FCALL_ERROR("unknown error", req->rcall);	551	PRINT_FCALL_ERROR("unknown error", req->rcall);
545	}	552	}
546		553
547	if (!req->err)	554	if (!req->err)
548	req->err = -ESERVERFAULT;	555	req->err = -ESERVERFAULT;
549	}	556	}
550	} else if (req->tcall && req->rcall->id != req->tcall->id + 1) {	557	} else if (req->tcall && req->rcall->id != req->tcall->id + 1) {
551	dprintk(DEBUG_ERROR, "fcall mismatch: expected %d, got %d\n",	558	dprintk(DEBUG_ERROR, "fcall mismatch: expected %d, got %d\n",
552	req->tcall->id + 1, req->rcall->id);	559	req->tcall->id + 1, req->rcall->id);
553	if (!req->err)	560	if (!req->err)
554	req->err = -EIO;	561	req->err = -EIO;
555	}	562	}
556
557	if (req->err == ERREQFLUSH)
558	return;
559
560	if (req->cb) {
561	dprintk(DEBUG_MUX, "calling callback tcall %p rcall %p\n",
562	req->tcall, req->rcall);
563
564	(*req->cb) (req->cba, req->tcall, req->rcall, req->err);
565	req->cb = NULL;
566	} else
567	kfree(req->rcall);
568
569	v9fs_mux_put_tag(m, tag);
570
571	wake_up(&m->equeue);
572	kfree(req);
573	}	563	}
574		564
575	/**	565	/**
576	* v9fs_read_work - called when there is some data to be read from a transport	566	* v9fs_read_work - called when there is some data to be read from a transport
577	*/	567	*/
578	static void v9fs_read_work(void *a)	568	static void v9fs_read_work(void *a)
579	{	569	{
580	int n, err;	570	int n, err;
581	struct v9fs_mux_data *m;	571	struct v9fs_mux_data *m;
582	struct v9fs_req req, rptr, *rreq;	572	struct v9fs_req req, rptr, *rreq;
583	struct v9fs_fcall *rcall;	573	struct v9fs_fcall *rcall;
584	char *rbuf;	574	char *rbuf;
585		575
586	m = a;	576	m = a;
587		577
588	if (m->err < 0)	578	if (m->err < 0)
589	return;	579	return;
590		580
591	rcall = NULL;	581	rcall = NULL;
592	dprintk(DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos);	582	dprintk(DEBUG_MUX, "start mux %p pos %d\n", m, m->rpos);
593		583
594	if (!m->rcall) {	584	if (!m->rcall) {
595	m->rcall =	585	m->rcall =
596	kmalloc(sizeof(struct v9fs_fcall) + m->msize, GFP_KERNEL);	586	kmalloc(sizeof(struct v9fs_fcall) + m->msize, GFP_KERNEL);
597	if (!m->rcall) {	587	if (!m->rcall) {
598	err = -ENOMEM;	588	err = -ENOMEM;
599	goto error;	589	goto error;
600	}	590	}
601		591
602	m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall);	592	m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall);
603	m->rpos = 0;	593	m->rpos = 0;
604	}	594	}
605		595
606	clear_bit(Rpending, &m->wsched);	596	clear_bit(Rpending, &m->wsched);
607	err = m->trans->read(m->trans, m->rbuf + m->rpos, m->msize - m->rpos);	597	err = m->trans->read(m->trans, m->rbuf + m->rpos, m->msize - m->rpos);
608	dprintk(DEBUG_MUX, "mux %p got %d bytes\n", m, err);	598	dprintk(DEBUG_MUX, "mux %p got %d bytes\n", m, err);
609	if (err == -EAGAIN) {	599	if (err == -EAGAIN) {
610	clear_bit(Rworksched, &m->wsched);	600	clear_bit(Rworksched, &m->wsched);
611	return;	601	return;
612	}	602	}
613		603
614	if (err <= 0)	604	if (err <= 0)
615	goto error;	605	goto error;
616		606
617	m->rpos += err;	607	m->rpos += err;
618	while (m->rpos > 4) {	608	while (m->rpos > 4) {
619	n = le32_to_cpu((__le32 ) m->rbuf);	609	n = le32_to_cpu((__le32 ) m->rbuf);
620	if (n >= m->msize) {	610	if (n >= m->msize) {
621	dprintk(DEBUG_ERROR,	611	dprintk(DEBUG_ERROR,
622	"requested packet size too big: %d\n", n);	612	"requested packet size too big: %d\n", n);
623	err = -EIO;	613	err = -EIO;
624	goto error;	614	goto error;
625	}	615	}
626		616
627	if (m->rpos < n)	617	if (m->rpos < n)
628	break;	618	break;
629		619
630	dump_data(m->rbuf, n);	620	dump_data(m->rbuf, n);
631	err =	621	err =
632	v9fs_deserialize_fcall(m->rbuf, n, m->rcall, *m->extended);	622	v9fs_deserialize_fcall(m->rbuf, n, m->rcall, *m->extended);
633	if (err < 0) {	623	if (err < 0) {
634	goto error;	624	goto error;
635	}	625	}
636		626
637	if ((v9fs_debug_level&DEBUG_FCALL) == DEBUG_FCALL) {	627	if ((v9fs_debug_level&DEBUG_FCALL) == DEBUG_FCALL) {
638	char buf[150];	628	char buf[150];
639		629
640	v9fs_printfcall(buf, sizeof(buf), m->rcall,	630	v9fs_printfcall(buf, sizeof(buf), m->rcall,
641	*m->extended);	631	*m->extended);
642	printk(KERN_NOTICE ">>> %p %s\n", m, buf);	632	printk(KERN_NOTICE ">>> %p %s\n", m, buf);
643	}	633	}
644		634
645	rcall = m->rcall;	635	rcall = m->rcall;
646	rbuf = m->rbuf;	636	rbuf = m->rbuf;
647	if (m->rpos > n) {	637	if (m->rpos > n) {
648	m->rcall = kmalloc(sizeof(struct v9fs_fcall) + m->msize,	638	m->rcall = kmalloc(sizeof(struct v9fs_fcall) + m->msize,
649	GFP_KERNEL);	639	GFP_KERNEL);
650	if (!m->rcall) {	640	if (!m->rcall) {
651	err = -ENOMEM;	641	err = -ENOMEM;
652	goto error;	642	goto error;
653	}	643	}
654		644
655	m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall);	645	m->rbuf = (char *)m->rcall + sizeof(struct v9fs_fcall);
656	memmove(m->rbuf, rbuf + n, m->rpos - n);	646	memmove(m->rbuf, rbuf + n, m->rpos - n);
657	m->rpos -= n;	647	m->rpos -= n;
658	} else {	648	} else {
659	m->rcall = NULL;	649	m->rcall = NULL;
660	m->rbuf = NULL;	650	m->rbuf = NULL;
661	m->rpos = 0;	651	m->rpos = 0;
662	}	652	}
663		653
664	dprintk(DEBUG_MUX, "mux %p fcall id %d tag %d\n", m, rcall->id,	654	dprintk(DEBUG_MUX, "mux %p fcall id %d tag %d\n", m, rcall->id,
665	rcall->tag);	655	rcall->tag);
666		656
667	req = NULL;	657	req = NULL;
668	spin_lock(&m->lock);	658	spin_lock(&m->lock);
669	list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {	659	list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
670	if (rreq->tag == rcall->tag) {	660	if (rreq->tag == rcall->tag) {
671	req = rreq;	661	req = rreq;
672	req->rcall = rcall;	662	if (req->flush != Flushing)
673	list_del(&req->req_list);	663	list_del(&req->req_list);
674	spin_unlock(&m->lock);
675	process_request(m, req);
676	break;	664	break;
677	}	665	}
678
679	}	666	}
		667	spin_unlock(&m->lock);
680		668
681	if (!req) {	669	if (req) {
682	spin_unlock(&m->lock);	670	req->rcall = rcall;
		671	process_request(m, req);
		672
		673	if (req->flush != Flushing) {
		674	if (req->cb)
		675	(*req->cb) (req, req->cba);
		676	else
		677	kfree(req->rcall);
		678
		679	wake_up(&m->equeue);
		680	}
		681	} else {
683	if (err >= 0 && rcall->id != RFLUSH)	682	if (err >= 0 && rcall->id != RFLUSH)
684	dprintk(DEBUG_ERROR,	683	dprintk(DEBUG_ERROR,
685	"unexpected response mux %p id %d tag %d\n",	684	"unexpected response mux %p id %d tag %d\n",
686	m, rcall->id, rcall->tag);	685	m, rcall->id, rcall->tag);
687	kfree(rcall);	686	kfree(rcall);
688	}	687	}
689	}	688	}
690		689
691	if (!list_empty(&m->req_list)) {	690	if (!list_empty(&m->req_list)) {
692	if (test_and_clear_bit(Rpending, &m->wsched))	691	if (test_and_clear_bit(Rpending, &m->wsched))
693	n = POLLIN;	692	n = POLLIN;
694	else	693	else
695	n = m->trans->poll(m->trans, NULL);	694	n = m->trans->poll(m->trans, NULL);
696		695
697	if (n & POLLIN) {	696	if (n & POLLIN) {
698	dprintk(DEBUG_MUX, "schedule read work mux %p\n", m);	697	dprintk(DEBUG_MUX, "schedule read work mux %p\n", m);
699	queue_work(v9fs_mux_wq, &m->rq);	698	queue_work(v9fs_mux_wq, &m->rq);
700	} else	699	} else
701	clear_bit(Rworksched, &m->wsched);	700	clear_bit(Rworksched, &m->wsched);
702	} else	701	} else
703	clear_bit(Rworksched, &m->wsched);	702	clear_bit(Rworksched, &m->wsched);
704		703
705	return;	704	return;
706		705
707	error:	706	error:
708	v9fs_mux_cancel(m, err);	707	v9fs_mux_cancel(m, err);
709	clear_bit(Rworksched, &m->wsched);	708	clear_bit(Rworksched, &m->wsched);
710	}	709	}
711		710
712	/**	711	/**
713	* v9fs_send_request - send 9P request	712	* v9fs_send_request - send 9P request
714	* The function can sleep until the request is scheduled for sending.	713	* The function can sleep until the request is scheduled for sending.
715	* The function can be interrupted. Return from the function is not	714	* The function can be interrupted. Return from the function is not
716	* a guarantee that the request is sent succesfully. Can return errors	715	* a guarantee that the request is sent succesfully. Can return errors
717	* that can be retrieved by PTR_ERR macros.	716	* that can be retrieved by PTR_ERR macros.
718	*	717	*
719	* @m: mux data	718	* @m: mux data
720	* @tc: request to be sent	719	* @tc: request to be sent
721	* @cb: callback function to call when response is received	720	* @cb: callback function to call when response is received
722	* @cba: parameter to pass to the callback function	721	* @cba: parameter to pass to the callback function
723	*/	722	*/
724	static struct v9fs_req v9fs_send_request(struct v9fs_mux_data m,	723	static struct v9fs_req v9fs_send_request(struct v9fs_mux_data m,
725	struct v9fs_fcall *tc,	724	struct v9fs_fcall *tc,
726	v9fs_mux_req_callback cb, void *cba)	725	v9fs_mux_req_callback cb, void *cba)
727	{	726	{
728	int n;	727	int n;
729	struct v9fs_req *req;	728	struct v9fs_req *req;
730		729
731	dprintk(DEBUG_MUX, "mux %p task %p tcall %p id %d\n", m, current,	730	dprintk(DEBUG_MUX, "mux %p task %p tcall %p id %d\n", m, current,
732	tc, tc->id);	731	tc, tc->id);
733	if (m->err < 0)	732	if (m->err < 0)
734	return ERR_PTR(m->err);	733	return ERR_PTR(m->err);
735		734
736	req = kmalloc(sizeof(struct v9fs_req), GFP_KERNEL);	735	req = kmalloc(sizeof(struct v9fs_req), GFP_KERNEL);
737	if (!req)	736	if (!req)
738	return ERR_PTR(-ENOMEM);	737	return ERR_PTR(-ENOMEM);
739		738
740	if (tc->id == TVERSION)	739	if (tc->id == TVERSION)
741	n = V9FS_NOTAG;	740	n = V9FS_NOTAG;
742	else	741	else
743	n = v9fs_mux_get_tag(m);	742	n = v9fs_mux_get_tag(m);
744		743
745	if (n < 0)	744	if (n < 0)
746	return ERR_PTR(-ENOMEM);	745	return ERR_PTR(-ENOMEM);
747		746
748	v9fs_set_tag(tc, n);	747	v9fs_set_tag(tc, n);
749
750	if ((v9fs_debug_level&DEBUG_FCALL) == DEBUG_FCALL) {	748	if ((v9fs_debug_level&DEBUG_FCALL) == DEBUG_FCALL) {
751	char buf[150];	749	char buf[150];
752		750
753	v9fs_printfcall(buf, sizeof(buf), tc, *m->extended);	751	v9fs_printfcall(buf, sizeof(buf), tc, *m->extended);
754	printk(KERN_NOTICE "<<< %p %s\n", m, buf);	752	printk(KERN_NOTICE "<<< %p %s\n", m, buf);
755	}	753	}
756		754
		755	spin_lock_init(&req->lock);
757	req->tag = n;	756	req->tag = n;
758	req->tcall = tc;	757	req->tcall = tc;
759	req->rcall = NULL;	758	req->rcall = NULL;
760	req->err = 0;	759	req->err = 0;
761	req->cb = cb;	760	req->cb = cb;
762	req->cba = cba;	761	req->cba = cba;
		762	req->flush = None;
763		763
764	spin_lock(&m->lock);	764	spin_lock(&m->lock);
765	list_add_tail(&req->req_list, &m->unsent_req_list);	765	list_add_tail(&req->req_list, &m->unsent_req_list);
766	spin_unlock(&m->lock);	766	spin_unlock(&m->lock);
767		767
768	if (test_and_clear_bit(Wpending, &m->wsched))	768	if (test_and_clear_bit(Wpending, &m->wsched))
769	n = POLLOUT;	769	n = POLLOUT;
770	else	770	else
771	n = m->trans->poll(m->trans, NULL);	771	n = m->trans->poll(m->trans, NULL);
772		772
773	if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))	773	if (n & POLLOUT && !test_and_set_bit(Wworksched, &m->wsched))
774	queue_work(v9fs_mux_wq, &m->wq);	774	queue_work(v9fs_mux_wq, &m->wq);
775		775
776	return req;	776	return req;
777	}	777	}
778		778
779	static void v9fs_mux_flush_cb(void a, struct v9fs_fcall tc,	779	static void v9fs_mux_free_request(struct v9fs_mux_data m, struct v9fs_req req)
780	struct v9fs_fcall *rc, int err)
781	{	780	{
		781	v9fs_mux_put_tag(m, req->tag);
		782	kfree(req);
		783	}
		784
		785	static void v9fs_mux_flush_cb(struct v9fs_req freq, void a)
		786	{
782	v9fs_mux_req_callback cb;	787	v9fs_mux_req_callback cb;
783	int tag;	788	int tag;
784	struct v9fs_mux_data *m;	789	struct v9fs_mux_data *m;
785	struct v9fs_req req, rptr;	790	struct v9fs_req req, rreq, *rptr;
786		791
787	m = a;	792	m = a;
788	dprintk(DEBUG_MUX, "mux %p tc %p rc %p err %d oldtag %d\n", m, tc,	793	dprintk(DEBUG_MUX, "mux %p tc %p rc %p err %d oldtag %d\n", m,
789	rc, err, tc->params.tflush.oldtag);	794	freq->tcall, freq->rcall, freq->err,
		795	freq->tcall->params.tflush.oldtag);
790		796
791	spin_lock(&m->lock);	797	spin_lock(&m->lock);
792	cb = NULL;	798	cb = NULL;
793	tag = tc->params.tflush.oldtag;	799	tag = freq->tcall->params.tflush.oldtag;
794	list_for_each_entry_safe(req, rptr, &m->req_list, req_list) {	800	req = NULL;
795	if (req->tag == tag) {	801	list_for_each_entry_safe(rreq, rptr, &m->req_list, req_list) {
		802	if (rreq->tag == tag) {
		803	req = rreq;
796	list_del(&req->req_list);	804	list_del(&req->req_list);
797	if (req->cb) {
798	cb = req->cb;
799	req->cb = NULL;
800	spin_unlock(&m->lock);
801	(*cb) (req->cba, req->tcall, req->rcall,
802	req->err);
803	}
804	kfree(req);
805	wake_up(&m->equeue);
806	break;	805	break;
807	}	806	}
808	}	807	}
		808	spin_unlock(&m->lock);
809		809
810	if (!cb)	810	if (req) {
811	spin_unlock(&m->lock);	811	spin_lock(&req->lock);
		812	req->flush = Flushed;
		813	spin_unlock(&req->lock);
812		814
813	v9fs_mux_put_tag(m, tag);	815	if (req->cb)
814	kfree(tc);	816	(*req->cb) (req, req->cba);
815	kfree(rc);	817	else
		818	kfree(req->rcall);
		819
		820	wake_up(&m->equeue);
		821	}
		822
		823	kfree(freq->tcall);
		824	kfree(freq->rcall);
		825	v9fs_mux_free_request(m, freq);
816	}	826	}
817		827
818	static void	828	static int
819	v9fs_mux_flush_request(struct v9fs_mux_data m, struct v9fs_req req)	829	v9fs_mux_flush_request(struct v9fs_mux_data m, struct v9fs_req req)
820	{	830	{
821	struct v9fs_fcall *fc;	831	struct v9fs_fcall *fc;
		832	struct v9fs_req rreq, rptr;
822		833
823	dprintk(DEBUG_MUX, "mux %p req %p tag %d\n", m, req, req->tag);	834	dprintk(DEBUG_MUX, "mux %p req %p tag %d\n", m, req, req->tag);
824		835
		836	/* if a response was received for a request, do nothing */
		837	spin_lock(&req->lock);
		838	if (req->rcall \|\| req->err) {
		839	spin_unlock(&req->lock);
		840	dprintk(DEBUG_MUX, "mux %p req %p response already received\n", m, req);
		841	return 0;
		842	}
		843
		844	req->flush = Flushing;
		845	spin_unlock(&req->lock);
		846
		847	spin_lock(&m->lock);
		848	/* if the request is not sent yet, just remove it from the list */
		849	list_for_each_entry_safe(rreq, rptr, &m->unsent_req_list, req_list) {
		850	if (rreq->tag == req->tag) {
		851	dprintk(DEBUG_MUX, "mux %p req %p request is not sent yet\n", m, req);
		852	list_del(&rreq->req_list);
		853	req->flush = Flushed;
		854	spin_unlock(&m->lock);
		855	if (req->cb)
		856	(*req->cb) (req, req->cba);
		857	return 0;
		858	}
		859	}
		860	spin_unlock(&m->lock);
		861
		862	clear_thread_flag(TIF_SIGPENDING);
825	fc = v9fs_create_tflush(req->tag);	863	fc = v9fs_create_tflush(req->tag);
826	v9fs_send_request(m, fc, v9fs_mux_flush_cb, m);	864	v9fs_send_request(m, fc, v9fs_mux_flush_cb, m);
		865	return 1;
827	}	866	}
828		867
829	static void	868	static void
830	v9fs_mux_rpc_cb(void a, struct v9fs_fcall tc, struct v9fs_fcall *rc, int err)	869	v9fs_mux_rpc_cb(struct v9fs_req req, void a)
831	{	870	{
832	struct v9fs_mux_rpc *r;	871	struct v9fs_mux_rpc *r;
833		872
834	if (err == ERREQFLUSH) {	873	dprintk(DEBUG_MUX, "req %p r %p\n", req, a);
835	kfree(rc);
836	dprintk(DEBUG_MUX, "err req flush\n");
837	return;
838	}
839
840	r = a;	874	r = a;
841	dprintk(DEBUG_MUX, "mux %p req %p tc %p rc %p err %d\n", r->m, r->req,	875	r->rcall = req->rcall;
842	tc, rc, err);	876	r->err = req->err;
843	r->rcall = rc;	877
844	r->err = err;	878	if (req->flush!=None && !req->err)
		879	r->err = -ERESTARTSYS;
		880
845	wake_up(&r->wqueue);	881	wake_up(&r->wqueue);
846	}	882	}
847		883
848	/**	884	/**
849	* v9fs_mux_rpc - sends 9P request and waits until a response is available.	885	* v9fs_mux_rpc - sends 9P request and waits until a response is available.
850	* The function can be interrupted.	886	* The function can be interrupted.
851	* @m: mux data	887	* @m: mux data
852	* @tc: request to be sent	888	* @tc: request to be sent
853	* @rc: pointer where a pointer to the response is stored	889	* @rc: pointer where a pointer to the response is stored
854	*/	890	*/
855	int	891	int
856	v9fs_mux_rpc(struct v9fs_mux_data m, struct v9fs_fcall tc,	892	v9fs_mux_rpc(struct v9fs_mux_data m, struct v9fs_fcall tc,
857	struct v9fs_fcall **rc)	893	struct v9fs_fcall **rc)
858	{	894	{
859	int err;	895	int err, sigpending;
860	unsigned long flags;	896	unsigned long flags;
861	struct v9fs_req *req;	897	struct v9fs_req *req;
862	struct v9fs_mux_rpc r;	898	struct v9fs_mux_rpc r;
863		899
864	r.err = 0;	900	r.err = 0;
		901	r.tcall = tc;
865	r.rcall = NULL;	902	r.rcall = NULL;
866	r.m = m;	903	r.m = m;
867	init_waitqueue_head(&r.wqueue);	904	init_waitqueue_head(&r.wqueue);
868		905
869	if (rc)	906	if (rc)
870	*rc = NULL;	907	*rc = NULL;
871		908
		909	sigpending = 0;
		910	if (signal_pending(current)) {
		911	sigpending = 1;
		912	clear_thread_flag(TIF_SIGPENDING);
		913	}
		914
872	req = v9fs_send_request(m, tc, v9fs_mux_rpc_cb, &r);	915	req = v9fs_send_request(m, tc, v9fs_mux_rpc_cb, &r);
873	if (IS_ERR(req)) {	916	if (IS_ERR(req)) {
874	err = PTR_ERR(req);	917	err = PTR_ERR(req);
875	dprintk(DEBUG_MUX, "error %d\n", err);	918	dprintk(DEBUG_MUX, "error %d\n", err);
876	return PTR_ERR(req);	919	return err;
877	}	920	}
878		921
879	r.req = req;
880	dprintk(DEBUG_MUX, "mux %p tc %p tag %d rpc %p req %p\n", m, tc,
881	req->tag, &r, req);
882	err = wait_event_interruptible(r.wqueue, r.rcall != NULL \|\| r.err < 0);	922	err = wait_event_interruptible(r.wqueue, r.rcall != NULL \|\| r.err < 0);
883	if (r.err < 0)	923	if (r.err < 0)
884	err = r.err;	924	err = r.err;
885		925
886	if (err == -ERESTARTSYS && m->trans->status == Connected && m->err == 0) {	926	if (err == -ERESTARTSYS && m->trans->status == Connected && m->err == 0) {
887	spin_lock(&m->lock);	927	if (v9fs_mux_flush_request(m, req)) {
888	req->tcall = NULL;	928	/* wait until we get response of the flush message */
889	req->err = ERREQFLUSH;	929	do {
890	spin_unlock(&m->lock);	930	clear_thread_flag(TIF_SIGPENDING);
		931	err = wait_event_interruptible(r.wqueue,
		932	r.rcall \|\| r.err);
		933	} while (!r.rcall && !r.err && err==-ERESTARTSYS &&
		934	m->trans->status==Connected && !m->err);
		935	}
		936	sigpending = 1;
		937	}
891		938
892	clear_thread_flag(TIF_SIGPENDING);	939	if (sigpending) {
893	v9fs_mux_flush_request(m, req);
894	spin_lock_irqsave(&current->sighand->siglock, flags);	940	spin_lock_irqsave(&current->sighand->siglock, flags);
895	recalc_sigpending();	941	recalc_sigpending();
896	spin_unlock_irqrestore(&current->sighand->siglock, flags);	942	spin_unlock_irqrestore(&current->sighand->siglock, flags);
897	}	943	}
898		944
899	if (!err) {	945	if (rc)
900	if (r.rcall)	946	*rc = r.rcall;
901	dprintk(DEBUG_MUX, "got response id %d tag %d\n",	947	else
902	r.rcall->id, r.rcall->tag);
903
904	if (rc)
905	*rc = r.rcall;
906	else
907	kfree(r.rcall);
908	} else {
909	kfree(r.rcall);	948	kfree(r.rcall);
910	dprintk(DEBUG_MUX, "got error %d\n", err);
911	if (err > 0)
912	err = -EIO;
913	}
914		949
		950	v9fs_mux_free_request(m, req);
		951	if (err > 0)
		952	err = -EIO;
		953
915	return err;	954	return err;
916	}	955	}
917		956
918	#if 0	957	#if 0
919	/**	958	/**
920	* v9fs_mux_rpcnb - sends 9P request without waiting for response.	959	* v9fs_mux_rpcnb - sends 9P request without waiting for response.
921	* @m: mux data	960	* @m: mux data
922	* @tc: request to be sent	961	* @tc: request to be sent
923	* @cb: callback function to be called when response arrives	962	* @cb: callback function to be called when response arrives
924	* @cba: value to pass to the callback function	963	* @cba: value to pass to the callback function
925	*/	964	*/
926	int v9fs_mux_rpcnb(struct v9fs_mux_data m, struct v9fs_fcall tc,	965	int v9fs_mux_rpcnb(struct v9fs_mux_data m, struct v9fs_fcall tc,
927	v9fs_mux_req_callback cb, void *a)	966	v9fs_mux_req_callback cb, void *a)
928	{	967	{
929	int err;	968	int err;
930	struct v9fs_req *req;	969	struct v9fs_req *req;
931		970
932	req = v9fs_send_request(m, tc, cb, a);	971	req = v9fs_send_request(m, tc, cb, a);
933	if (IS_ERR(req)) {	972	if (IS_ERR(req)) {
934	err = PTR_ERR(req);	973	err = PTR_ERR(req);
935	dprintk(DEBUG_MUX, "error %d\n", err);	974	dprintk(DEBUG_MUX, "error %d\n", err);
936	return PTR_ERR(req);	975	return PTR_ERR(req);
937	}	976	}
938		977
939	dprintk(DEBUG_MUX, "mux %p tc %p tag %d\n", m, tc, req->tag);	978	dprintk(DEBUG_MUX, "mux %p tc %p tag %d\n", m, tc, req->tag);
940	return 0;	979	return 0;
941	}	980	}
942	#endif /* 0 */	981	#endif /* 0 */

fs/9p/mux.h

Diff comments View file @ 41e5a6a

 /*
  * linux/fs/9p/mux.h
  *
  * Multiplexer Definitions
  *
  *  Copyright (C) 2005 by Latchesar Ionkov <lucho@ionkov.net>
  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2
  *  as published by the Free Software Foundation.
  *
  *  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:
  *  Free Software Foundation
  *  51 Franklin Street, Fifth Floor
  *  Boston, MA  02111-1301  USA
  *
  */
 struct v9fs_mux_data;
+struct v9fs_req;
 /**
  * v9fs_mux_req_callback - callback function that is called when the
  * response of a request is received. The callback is called from
  * a workqueue and shouldn't block.
  *
  * @a - the pointer that was specified when the request was send to be
  *      passed to the callback
  * @tc - request call
  * @rc - response call
  * @err - error code (non-zero if error occured)
  */
-typedef void (*v9fs_mux_req_callback)(void *a, struct v9fs_fcall *tc,
+typedef void (*v9fs_mux_req_callback)(struct v9fs_req *req, void *a);
-	struct v9fs_fcall *rc, int err);
 int v9fs_mux_global_init(void);
 void v9fs_mux_global_exit(void);
 struct v9fs_mux_data *v9fs_mux_init(struct v9fs_transport *trans, int msize,
 	unsigned char *extended);
 void v9fs_mux_destroy(struct v9fs_mux_data *);
 int v9fs_mux_send(struct v9fs_mux_data *m, struct v9fs_fcall *tc);
 struct v9fs_fcall *v9fs_mux_recv(struct v9fs_mux_data *m);
 int v9fs_mux_rpc(struct v9fs_mux_data *m, struct v9fs_fcall *tc, struct v9fs_fcall **rc);
 void v9fs_mux_flush(struct v9fs_mux_data *m, int sendflush);
 void v9fs_mux_cancel(struct v9fs_mux_data *m, int err);
 int v9fs_errstr2errno(char *errstr, int len);

fs/9p/vfs_file.c

Diff comments View file @ 41e5a6a

 /*
  *  linux/fs/9p/vfs_file.c
  *
  * This file contians vfs file ops for 9P2000.
  *
  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2
  *  as published by the Free Software Foundation.
  *
  *  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:
  *  Free Software Foundation
  *  51 Franklin Street, Fifth Floor
  *  Boston, MA  02111-1301  USA
  *
  */
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
 #include <linux/file.h>
 #include <linux/stat.h>
 #include <linux/string.h>
 #include <linux/smp_lock.h>
 #include <linux/inet.h>
 #include <linux/version.h>
 #include <linux/list.h>
 #include <asm/uaccess.h>
 #include <linux/idr.h>
 #include "debug.h"
 #include "v9fs.h"
 #include "9p.h"
 #include "v9fs_vfs.h"
 #include "fid.h"
 /**
  * v9fs_file_open - open a file (or directory)
  * @inode: inode to be opened
  * @file: file being opened
  *
  */
 int v9fs_file_open(struct inode *inode, struct file *file)
 {
 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
 	struct v9fs_fid *vfid;
 	struct v9fs_fcall *fcall = NULL;
 	int omode;
 	int fid = V9FS_NOFID;
 	int err;
 	dprintk(DEBUG_VFS, "inode: %p file: %p \n", inode, file);
 	vfid = v9fs_fid_lookup(file->f_dentry);
 	if (!vfid) {
 		dprintk(DEBUG_ERROR, "Couldn't resolve fid from dentry\n");
 		return -EBADF;
 	}
 	fid = v9fs_get_idpool(&v9ses->fidpool);
 	if (fid < 0) {
 		eprintk(KERN_WARNING, "newfid fails!\n");
 		return -ENOSPC;
 	}
-	err = v9fs_t_walk(v9ses, vfid->fid, fid, NULL, NULL);
+	err = v9fs_t_walk(v9ses, vfid->fid, fid, NULL, &fcall);
 	if (err < 0) {
 		dprintk(DEBUG_ERROR, "rewalk didn't work\n");
-		goto put_fid;
+		if (fcall && fcall->id == RWALK)
+			goto clunk_fid;
+		else {
+			v9fs_put_idpool(fid, &v9ses->fidpool);
+			goto free_fcall;
+		}
 	}
+	kfree(fcall);
 	/* TODO: do special things for O_EXCL, O_NOFOLLOW, O_SYNC */
 	/* translate open mode appropriately */
 	omode = v9fs_uflags2omode(file->f_flags);
 	err = v9fs_t_open(v9ses, fid, omode, &fcall);
 	if (err < 0) {
 		PRINT_FCALL_ERROR("open failed", fcall);
 		goto clunk_fid;
 	}
 	vfid = kmalloc(sizeof(struct v9fs_fid), GFP_KERNEL);
 	if (vfid == NULL) {
 		dprintk(DEBUG_ERROR, "out of memory\n");
 		err = -ENOMEM;
 		goto clunk_fid;
 	}
 	file->private_data = vfid;
 	vfid->fid = fid;
 	vfid->fidopen = 1;
 	vfid->fidclunked = 0;
 	vfid->iounit = fcall->params.ropen.iounit;
 	vfid->rdir_pos = 0;
 	vfid->rdir_fcall = NULL;
 	vfid->filp = file;
 	kfree(fcall);
 	return 0;
 clunk_fid:
 	v9fs_t_clunk(v9ses, fid);
-put_fid:
+free_fcall:
-	v9fs_put_idpool(fid, &v9ses->fidpool);
 	kfree(fcall);
 	return err;
 }
 /**
  * v9fs_file_lock - lock a file (or directory)
  * @inode: inode to be opened
  * @file: file being opened
  *
  * XXX - this looks like a local only lock, we should extend into 9P
  *       by using open exclusive
  */
 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
 {
 	int res = 0;
 	struct inode *inode = filp->f_dentry->d_inode;
 	dprintk(DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
 	/* No mandatory locks */
 	if ((inode->i_mode & (S_ISGID | S_IXGRP)) == S_ISGID)
 		return -ENOLCK;
 	if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
 		filemap_write_and_wait(inode->i_mapping);
 		invalidate_inode_pages(&inode->i_data);
 	}
 	return res;
 }
 /**
  * v9fs_file_read - read from a file
  * @filep: file pointer to read
  * @data: data buffer to read data into
  * @count: size of buffer
  * @offset: offset at which to read data
  *
  */
 static ssize_t
 v9fs_file_read(struct file *filp, char __user * data, size_t count,
 	       loff_t * offset)
 {
 	struct inode *inode = filp->f_dentry->d_inode;
 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
 	struct v9fs_fid *v9f = filp->private_data;
 	struct v9fs_fcall *fcall = NULL;
 	int fid = v9f->fid;
 	int rsize = 0;
 	int result = 0;
 	int total = 0;
 	int n;
 	dprintk(DEBUG_VFS, "\n");
 	rsize = v9ses->maxdata - V9FS_IOHDRSZ;
 	if (v9f->iounit != 0 && rsize > v9f->iounit)
 		rsize = v9f->iounit;
 	do {
 		if (count < rsize)
 			rsize = count;
 		result = v9fs_t_read(v9ses, fid, *offset, rsize, &fcall);
 		if (result < 0) {
 			printk(KERN_ERR "9P2000: v9fs_t_read returned %d\n",
 			       result);
 			kfree(fcall);
 			return total;
 		} else
 			*offset += result;
 		n = copy_to_user(data, fcall->params.rread.data, result);
 		if (n) {
 			dprintk(DEBUG_ERROR, "Problem copying to user %d\n", n);
 			kfree(fcall);
 			return -EFAULT;
 		}
 		count -= result;
 		data += result;
 		total += result;
 		kfree(fcall);
 		if (result < rsize)
 			break;
 	} while (count);
 	return total;
 }
 /**
  * v9fs_file_write - write to a file
  * @filep: file pointer to write
  * @data: data buffer to write data from
  * @count: size of buffer
  * @offset: offset at which to write data
  *
  */
 static ssize_t
 v9fs_file_write(struct file *filp, const char __user * data,
 		size_t count, loff_t * offset)
 {
 	struct inode *inode = filp->f_dentry->d_inode;
 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(inode);
 	struct v9fs_fid *v9fid = filp->private_data;
 	struct v9fs_fcall *fcall;
 	int fid = v9fid->fid;
 	int result = -EIO;
 	int rsize = 0;
 	int total = 0;
 	dprintk(DEBUG_VFS, "data %p count %d offset %x\n", data, (int)count,
 		(int)*offset);
 	rsize = v9ses->maxdata - V9FS_IOHDRSZ;
 	if (v9fid->iounit != 0 && rsize > v9fid->iounit)
 		rsize = v9fid->iounit;
 	do {
 		if (count < rsize)
 			rsize = count;
 		result = v9fs_t_write(v9ses, fid, *offset, rsize, data, &fcall);
 		if (result < 0) {
 			PRINT_FCALL_ERROR("error while writing", fcall);
 			kfree(fcall);
 			return result;
 		} else
 			*offset += result;
 		kfree(fcall);
 		fcall = NULL;
 		if (result != rsize) {
 			eprintk(KERN_ERR,
 				"short write: v9fs_t_write returned %d\n",
 				result);
 			break;
 		}
 		count -= result;
 		data += result;
 		total += result;
 	} while (count);
 		invalidate_inode_pages2(inode->i_mapping);
 	return total;
 }
 const struct file_operations v9fs_file_operations = {
 	.llseek = generic_file_llseek,
 	.read = v9fs_file_read,
 	.write = v9fs_file_write,
 	.open = v9fs_file_open,
 	.release = v9fs_dir_release,
 	.lock = v9fs_file_lock,
 	.mmap = generic_file_mmap,
 };

fs/9p/vfs_inode.c

Diff comments View file @ 41e5a6a

 /*
  *  linux/fs/9p/vfs_inode.c
  *
  * This file contains vfs inode ops for the 9P2000 protocol.
  *
  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
  *
  *  This program is free software; you can redistribute it and/or modify
  *  it under the terms of the GNU General Public License version 2
  *  as published by the Free Software Foundation.
  *
  *  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:
  *  Free Software Foundation
  *  51 Franklin Street, Fifth Floor
  *  Boston, MA  02111-1301  USA
  *
  */
 #include <linux/module.h>
 #include <linux/errno.h>
 #include <linux/fs.h>
 #include <linux/file.h>
 #include <linux/pagemap.h>
 #include <linux/stat.h>
 #include <linux/string.h>
 #include <linux/smp_lock.h>
 #include <linux/inet.h>
 #include <linux/namei.h>
 #include <linux/idr.h>
 #include "debug.h"
 #include "v9fs.h"
 #include "9p.h"
 #include "v9fs_vfs.h"
 #include "fid.h"
 static struct inode_operations v9fs_dir_inode_operations;
 static struct inode_operations v9fs_dir_inode_operations_ext;
 static struct inode_operations v9fs_file_inode_operations;
 static struct inode_operations v9fs_symlink_inode_operations;
 /**
  * unixmode2p9mode - convert unix mode bits to plan 9
  * @v9ses: v9fs session information
  * @mode: mode to convert
  *
  */
 static int unixmode2p9mode(struct v9fs_session_info *v9ses, int mode)
 {
 	int res;
 	res = mode & 0777;
 	if (S_ISDIR(mode))
 		res |= V9FS_DMDIR;
 	if (v9ses->extended) {
 		if (S_ISLNK(mode))
 			res |= V9FS_DMSYMLINK;
 		if (v9ses->nodev == 0) {
 			if (S_ISSOCK(mode))
 				res |= V9FS_DMSOCKET;
 			if (S_ISFIFO(mode))
 				res |= V9FS_DMNAMEDPIPE;
 			if (S_ISBLK(mode))
 				res |= V9FS_DMDEVICE;
 			if (S_ISCHR(mode))
 				res |= V9FS_DMDEVICE;
 		}
 		if ((mode & S_ISUID) == S_ISUID)
 			res |= V9FS_DMSETUID;
 		if ((mode & S_ISGID) == S_ISGID)
 			res |= V9FS_DMSETGID;
 		if ((mode & V9FS_DMLINK))
 			res |= V9FS_DMLINK;
 	}
 	return res;
 }
 /**
  * p9mode2unixmode- convert plan9 mode bits to unix mode bits
  * @v9ses: v9fs session information
  * @mode: mode to convert
  *
  */
 static int p9mode2unixmode(struct v9fs_session_info *v9ses, int mode)
 {
 	int res;
 	res = mode & 0777;
 	if ((mode & V9FS_DMDIR) == V9FS_DMDIR)
 		res |= S_IFDIR;
 	else if ((mode & V9FS_DMSYMLINK) && (v9ses->extended))
 		res |= S_IFLNK;
 	else if ((mode & V9FS_DMSOCKET) && (v9ses->extended)
 		 && (v9ses->nodev == 0))
 		res |= S_IFSOCK;
 	else if ((mode & V9FS_DMNAMEDPIPE) && (v9ses->extended)
 		 && (v9ses->nodev == 0))
 		res |= S_IFIFO;
 	else if ((mode & V9FS_DMDEVICE) && (v9ses->extended)
 		 && (v9ses->nodev == 0))
 		res |= S_IFBLK;
 	else
 		res |= S_IFREG;
 	if (v9ses->extended) {
 		if ((mode & V9FS_DMSETUID) == V9FS_DMSETUID)
 			res |= S_ISUID;
 		if ((mode & V9FS_DMSETGID) == V9FS_DMSETGID)
 			res |= S_ISGID;
 	}
 	return res;
 }
 int v9fs_uflags2omode(int uflags)
 {
 	int ret;
 	ret = 0;
 	switch (uflags&3) {
 	default:
 	case O_RDONLY:
 		ret = V9FS_OREAD;
 		break;
 	case O_WRONLY:
 		ret = V9FS_OWRITE;
 		break;
 	case O_RDWR:
 		ret = V9FS_ORDWR;
 		break;
 	}
 	if (uflags & O_EXCL)
 		ret |= V9FS_OEXCL;
 	if (uflags & O_TRUNC)
 		ret |= V9FS_OTRUNC;
 	if (uflags & O_APPEND)
 		ret |= V9FS_OAPPEND;
 	return ret;
 }
 /**
  * v9fs_blank_wstat - helper function to setup a 9P stat structure
  * @v9ses: 9P session info (for determining extended mode)
  * @wstat: structure to initialize
  *
  */
 static void
 v9fs_blank_wstat(struct v9fs_wstat *wstat)
 {
 	wstat->type = ~0;
 	wstat->dev = ~0;
 	wstat->qid.type = ~0;
 	wstat->qid.version = ~0;
 	*((long long *)&wstat->qid.path) = ~0;
 	wstat->mode = ~0;
 	wstat->atime = ~0;
 	wstat->mtime = ~0;
 	wstat->length = ~0;
 	wstat->name = NULL;
 	wstat->uid = NULL;
 	wstat->gid = NULL;
 	wstat->muid = NULL;
 	wstat->n_uid = ~0;
 	wstat->n_gid = ~0;
 	wstat->n_muid = ~0;
 	wstat->extension = NULL;
 }
 /**
  * v9fs_get_inode - helper function to setup an inode
  * @sb: superblock
  * @mode: mode to setup inode with
  *
  */
 struct inode *v9fs_get_inode(struct super_block *sb, int mode)
 {
 	struct inode *inode;
 	struct v9fs_session_info *v9ses = sb->s_fs_info;
 	dprintk(DEBUG_VFS, "super block: %p mode: %o\n", sb, mode);
 	inode = new_inode(sb);
 	if (inode) {
 		inode->i_mode = mode;
 		inode->i_uid = current->fsuid;
 		inode->i_gid = current->fsgid;
 		inode->i_blksize = sb->s_blocksize;
 		inode->i_blocks = 0;
 		inode->i_rdev = 0;
 		inode->i_atime = inode->i_mtime = inode->i_ctime = CURRENT_TIME;
 		inode->i_mapping->a_ops = &v9fs_addr_operations;
 		switch (mode & S_IFMT) {
 		case S_IFIFO:
 		case S_IFBLK:
 		case S_IFCHR:
 		case S_IFSOCK:
 			if(!v9ses->extended) {
 				dprintk(DEBUG_ERROR, "special files without extended mode\n");
 				return ERR_PTR(-EINVAL);
 			}
 			init_special_inode(inode, inode->i_mode,
 					   inode->i_rdev);
 			break;
 		case S_IFREG:
 			inode->i_op = &v9fs_file_inode_operations;
 			inode->i_fop = &v9fs_file_operations;
 			break;
 		case S_IFLNK:
 			if(!v9ses->extended) {
 				dprintk(DEBUG_ERROR, "extended modes used w/o 9P2000.u\n");
 				return ERR_PTR(-EINVAL);
 			}
 			inode->i_op = &v9fs_symlink_inode_operations;
 			break;
 		case S_IFDIR:
 			inode->i_nlink++;
 			if(v9ses->extended)
 				inode->i_op = &v9fs_dir_inode_operations_ext;
 			else
 				inode->i_op = &v9fs_dir_inode_operations;
 			inode->i_fop = &v9fs_dir_operations;
 			break;
 		default:
 			dprintk(DEBUG_ERROR, "BAD mode 0x%x S_IFMT 0x%x\n",
 				mode, mode & S_IFMT);
 			return ERR_PTR(-EINVAL);
 		}
 	} else {
 		eprintk(KERN_WARNING, "Problem allocating inode\n");
 		return ERR_PTR(-ENOMEM);
 	}
 	return inode;
 }
 static int
 v9fs_create(struct v9fs_session_info *v9ses, u32 pfid, char *name, u32 perm,
 	u8 mode, char *extension, u32 *fidp, struct v9fs_qid *qid, u32 *iounit)
 {
 	u32 fid;
 	int err;
 	struct v9fs_fcall *fcall;
 	fid = v9fs_get_idpool(&v9ses->fidpool);
 	if (fid < 0) {
 		eprintk(KERN_WARNING, "no free fids available\n");
 		return -ENOSPC;
 	}
 	err = v9fs_t_walk(v9ses, pfid, fid, NULL, &fcall);
 	if (err < 0) {
 		PRINT_FCALL_ERROR("clone error", fcall);
-		goto put_fid;
+		if (fcall && fcall->id == RWALK)
+			goto clunk_fid;
+		else
+			goto put_fid;
 	}
 	kfree(fcall);
 	err = v9fs_t_create(v9ses, fid, name, perm, mode, extension, &fcall);
 	if (err < 0) {
 		PRINT_FCALL_ERROR("create fails", fcall);
 		goto clunk_fid;
 	}
 	if (iounit)
 		*iounit = fcall->params.rcreate.iounit;
 	if (qid)
 		*qid = fcall->params.rcreate.qid;
 	if (fidp)
 		*fidp = fid;
 	kfree(fcall);
 	return 0;
 clunk_fid:
 	v9fs_t_clunk(v9ses, fid);
 	fid = V9FS_NOFID;
 put_fid:
 	if (fid >= 0)
 		v9fs_put_idpool(fid, &v9ses->fidpool);
 	kfree(fcall);
 	return err;
 }
 static struct v9fs_fid*
 v9fs_clone_walk(struct v9fs_session_info *v9ses, u32 fid, struct dentry *dentry)
 {
 	int err;
 	u32 nfid;
 	struct v9fs_fid *ret;
 	struct v9fs_fcall *fcall;
 	nfid = v9fs_get_idpool(&v9ses->fidpool);
 	if (nfid < 0) {
 		eprintk(KERN_WARNING, "no free fids available\n");
 		return ERR_PTR(-ENOSPC);
 	}
 	err = v9fs_t_walk(v9ses, fid, nfid, (char *) dentry->d_name.name,
 		&fcall);
 	if (err < 0) {
+		if (fcall && fcall->id == RWALK)
+			goto clunk_fid;
 		PRINT_FCALL_ERROR("walk error", fcall);
 		v9fs_put_idpool(nfid, &v9ses->fidpool);
 		goto error;
 	}
 	kfree(fcall);
 	fcall = NULL;
 	ret = v9fs_fid_create(v9ses, nfid);
 	if (!ret) {
 		err = -ENOMEM;
 		goto clunk_fid;
 	}
 	err = v9fs_fid_insert(ret, dentry);
 	if (err < 0) {
 		v9fs_fid_destroy(ret);
 		goto clunk_fid;
 	}
 	return ret;
 clunk_fid:
 	v9fs_t_clunk(v9ses, nfid);
 error:
 	kfree(fcall);
 	return ERR_PTR(err);
 }
 static struct inode *
 v9fs_inode_from_fid(struct v9fs_session_info *v9ses, u32 fid,
 	struct super_block *sb)
 {
 	int err, umode;
 	struct inode *ret;
 	struct v9fs_fcall *fcall;
 	ret = NULL;
 	err = v9fs_t_stat(v9ses, fid, &fcall);
 	if (err) {
 		PRINT_FCALL_ERROR("stat error", fcall);
 		goto error;
 	}
 	umode = p9mode2unixmode(v9ses, fcall->params.rstat.stat.mode);
 	ret = v9fs_get_inode(sb, umode);
 	if (IS_ERR(ret)) {
 		err = PTR_ERR(ret);
 		ret = NULL;
 		goto error;
 	}
 	v9fs_stat2inode(&fcall->params.rstat.stat, ret, sb);
 	kfree(fcall);
 	return ret;
 error:
 	kfree(fcall);
 	if (ret)
 		iput(ret);
 	return ERR_PTR(err);
 }
 /**
  * v9fs_remove - helper function to remove files and directories
  * @dir: directory inode that is being deleted
  * @file:  dentry that is being deleted
  * @rmdir: removing a directory
  *
  */
 static int v9fs_remove(struct inode *dir, struct dentry *file, int rmdir)
 {
 	struct v9fs_fcall *fcall = NULL;
 	struct super_block *sb = NULL;
 	struct v9fs_session_info *v9ses = NULL;
 	struct v9fs_fid *v9fid = NULL;
 	struct inode *file_inode = NULL;
 	int fid = -1;
 	int result = 0;
 	dprintk(DEBUG_VFS, "inode: %p dentry: %p rmdir: %d\n", dir, file,
 		rmdir);
 	file_inode = file->d_inode;
 	sb = file_inode->i_sb;
 	v9ses = v9fs_inode2v9ses(file_inode);
 	v9fid = v9fs_fid_lookup(file);
 	if (!v9fid) {
 		dprintk(DEBUG_ERROR,
 			"no v9fs_fid\n");
 		return -EBADF;
 	}
 	fid = v9fid->fid;
 	if (fid < 0) {
 		dprintk(DEBUG_ERROR, "inode #%lu, no fid!\n",
 			file_inode->i_ino);
 		return -EBADF;
 	}
 	result = v9fs_t_remove(v9ses, fid, &fcall);
 	if (result < 0) {
 		PRINT_FCALL_ERROR("remove fails", fcall);
 	} else {
 		v9fs_put_idpool(fid, &v9ses->fidpool);
 		v9fs_fid_destroy(v9fid);
 	}
 	kfree(fcall);
 	return result;
 }
 static int
 v9fs_open_created(struct inode *inode, struct file *file)
 {
 	return 0;
 }
 /**
  * v9fs_vfs_create - VFS hook to create files
  * @inode: directory inode that is being deleted
  * @dentry:  dentry that is being deleted
  * @mode: create permissions
  * @nd: path information
  *
  */
 static int
 v9fs_vfs_create(struct inode *dir, struct dentry *dentry, int mode,
 		struct nameidata *nd)
 {
 	int err;
 	u32 fid, perm, iounit;
 	int flags;
 	struct v9fs_session_info *v9ses;
 	struct v9fs_fid *dfid, *vfid, *ffid;
 	struct inode *inode;
 	struct v9fs_qid qid;
 	struct file *filp;
 	inode = NULL;
 	vfid = NULL;
 	v9ses = v9fs_inode2v9ses(dir);
 	dfid = v9fs_fid_lookup(dentry->d_parent);
 	perm = unixmode2p9mode(v9ses, mode);
 	if (nd && nd->flags & LOOKUP_OPEN)
 		flags = nd->intent.open.flags - 1;
 	else
 		flags = O_RDWR;
 	err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
 		perm, v9fs_uflags2omode(flags), NULL, &fid, &qid, &iounit);
 	if (err)
 		goto error;
 	vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
 	if (IS_ERR(vfid)) {
 		err = PTR_ERR(vfid);
 		vfid = NULL;
 		goto error;
 	}
 	inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
 	if (IS_ERR(inode)) {
 		err = PTR_ERR(inode);
 		inode = NULL;
 		goto error;
 	}
 	dentry->d_op = &v9fs_dentry_operations;
 	d_instantiate(dentry, inode);
 	if (nd && nd->flags & LOOKUP_OPEN) {
 		ffid = v9fs_fid_create(v9ses, fid);
 		if (!ffid)
 			return -ENOMEM;
 		filp = lookup_instantiate_filp(nd, dentry, v9fs_open_created);
 		if (IS_ERR(filp)) {
 			v9fs_fid_destroy(ffid);
 			return PTR_ERR(filp);
 		}
 		ffid->rdir_pos = 0;
 		ffid->rdir_fcall = NULL;
 		ffid->fidopen = 1;
 		ffid->iounit = iounit;
 		ffid->filp = filp;
 		filp->private_data = ffid;
 	}
 	return 0;
 error:
 	if (vfid)
 		v9fs_fid_destroy(vfid);
 	if (inode)
 		iput(inode);
 	return err;
 }
 /**
  * v9fs_vfs_mkdir - VFS mkdir hook to create a directory
  * @inode:  inode that is being unlinked
  * @dentry: dentry that is being unlinked
  * @mode: mode for new directory
  *
  */
 static int v9fs_vfs_mkdir(struct inode *dir, struct dentry *dentry, int mode)
 {
 	int err;
 	u32 fid, perm;
 	struct v9fs_session_info *v9ses;
 	struct v9fs_fid *dfid, *vfid;
 	struct inode *inode;
 	inode = NULL;
 	vfid = NULL;
 	v9ses = v9fs_inode2v9ses(dir);
 	dfid = v9fs_fid_lookup(dentry->d_parent);
 	perm = unixmode2p9mode(v9ses, mode | S_IFDIR);
 	err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
 		perm, V9FS_OREAD, NULL, &fid, NULL, NULL);
 	if (err) {
 		dprintk(DEBUG_ERROR, "create error %d\n", err);
 		goto error;
 	}
 	err = v9fs_t_clunk(v9ses, fid);
 	if (err) {
 		dprintk(DEBUG_ERROR, "clunk error %d\n", err);
 		goto error;
 	}
 	vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
 	if (IS_ERR(vfid)) {
 		err = PTR_ERR(vfid);
 		vfid = NULL;
 		goto error;
 	}
 	inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
 	if (IS_ERR(inode)) {
 		err = PTR_ERR(inode);
 		inode = NULL;
 		goto error;
 	}
 	dentry->d_op = &v9fs_dentry_operations;
 	d_instantiate(dentry, inode);
 	return 0;
 error:
 	if (vfid)
 		v9fs_fid_destroy(vfid);
 	return err;
 }
 /**
  * v9fs_vfs_lookup - VFS lookup hook to "walk" to a new inode
  * @dir:  inode that is being walked from
  * @dentry: dentry that is being walked to?
  * @nameidata: path data
  *
  */
 static struct dentry *v9fs_vfs_lookup(struct inode *dir, struct dentry *dentry,
 				      struct nameidata *nameidata)
 {
 	struct super_block *sb;
 	struct v9fs_session_info *v9ses;
 	struct v9fs_fid *dirfid;
 	struct v9fs_fid *fid;
 	struct inode *inode;
 	struct v9fs_fcall *fcall = NULL;
 	int dirfidnum = -1;
 	int newfid = -1;
 	int result = 0;
 	dprintk(DEBUG_VFS, "dir: %p dentry: (%s) %p nameidata: %p\n",
 		dir, dentry->d_name.name, dentry, nameidata);
 	sb = dir->i_sb;
 	v9ses = v9fs_inode2v9ses(dir);
 	dentry->d_op = &v9fs_dentry_operations;
 	dirfid = v9fs_fid_lookup(dentry->d_parent);
 	if (!dirfid) {
 		dprintk(DEBUG_ERROR, "no dirfid\n");
 		return ERR_PTR(-EINVAL);
 	}
 	dirfidnum = dirfid->fid;
 	if (dirfidnum < 0) {
 		dprintk(DEBUG_ERROR, "no dirfid for inode %p, #%lu\n",
 			dir, dir->i_ino);
 		return ERR_PTR(-EBADF);
 	}
 	newfid = v9fs_get_idpool(&v9ses->fidpool);
 	if (newfid < 0) {
 		eprintk(KERN_WARNING, "newfid fails!\n");
 		return ERR_PTR(-ENOSPC);
 	}
 	result = v9fs_t_walk(v9ses, dirfidnum, newfid,
-		(char *)dentry->d_name.name, NULL);
+		(char *)dentry->d_name.name, &fcall);
 	if (result < 0) {
-		v9fs_put_idpool(newfid, &v9ses->fidpool);
+		if (fcall && fcall->id == RWALK)
+			v9fs_t_clunk(v9ses, newfid);
+		else
+			v9fs_put_idpool(newfid, &v9ses->fidpool);
 		if (result == -ENOENT) {
 			d_add(dentry, NULL);
 			dprintk(DEBUG_VFS,
 				"Return negative dentry %p count %d\n",
 				dentry, atomic_read(&dentry->d_count));
+			kfree(fcall);
 			return NULL;
 		}
 		dprintk(DEBUG_ERROR, "walk error:%d\n", result);
 		goto FreeFcall;
 	}
+	kfree(fcall);
 	result = v9fs_t_stat(v9ses, newfid, &fcall);
 	if (result < 0) {
 		dprintk(DEBUG_ERROR, "stat error\n");
 		goto FreeFcall;
 	}
 	inode = v9fs_get_inode(sb, p9mode2unixmode(v9ses,
 		fcall->params.rstat.stat.mode));
 	if (IS_ERR(inode) && (PTR_ERR(inode) == -ENOSPC)) {
 		eprintk(KERN_WARNING, "inode alloc failes, returns %ld\n",
 			PTR_ERR(inode));
 		result = -ENOSPC;
 		goto FreeFcall;
 	}
 	inode->i_ino = v9fs_qid2ino(&fcall->params.rstat.stat.qid);
 	fid = v9fs_fid_create(v9ses, newfid);
 	if (fid == NULL) {
 		dprintk(DEBUG_ERROR, "couldn't insert\n");
 		result = -ENOMEM;
 		goto FreeFcall;
 	}
 	result = v9fs_fid_insert(fid, dentry);
 	if (result < 0)
 		goto FreeFcall;
 	fid->qid = fcall->params.rstat.stat.qid;
 	v9fs_stat2inode(&fcall->params.rstat.stat, inode, inode->i_sb);
 	d_add(dentry, inode);
 	kfree(fcall);
 	return NULL;
       FreeFcall:
 	kfree(fcall);
 	return ERR_PTR(result);
 }
 /**
  * v9fs_vfs_unlink - VFS unlink hook to delete an inode
  * @i:  inode that is being unlinked
  * @d: dentry that is being unlinked
  *
  */
 static int v9fs_vfs_unlink(struct inode *i, struct dentry *d)
 {
 	return v9fs_remove(i, d, 0);
 }
 /**
  * v9fs_vfs_rmdir - VFS unlink hook to delete a directory
  * @i:  inode that is being unlinked
  * @d: dentry that is being unlinked
  *
  */
 static int v9fs_vfs_rmdir(struct inode *i, struct dentry *d)
 {
 	return v9fs_remove(i, d, 1);
 }
 /**
  * v9fs_vfs_rename - VFS hook to rename an inode
  * @old_dir:  old dir inode
  * @old_dentry: old dentry
  * @new_dir: new dir inode
  * @new_dentry: new dentry
  *
  */
 static int
 v9fs_vfs_rename(struct inode *old_dir, struct dentry *old_dentry,
 		struct inode *new_dir, struct dentry *new_dentry)
 {
 	struct inode *old_inode = old_dentry->d_inode;
 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(old_inode);
 	struct v9fs_fid *oldfid = v9fs_fid_lookup(old_dentry);
 	struct v9fs_fid *olddirfid =
 	    v9fs_fid_lookup(old_dentry->d_parent);
 	struct v9fs_fid *newdirfid =
 	    v9fs_fid_lookup(new_dentry->d_parent);
 	struct v9fs_wstat wstat;
 	struct v9fs_fcall *fcall = NULL;
 	int fid = -1;
 	int olddirfidnum = -1;
 	int newdirfidnum = -1;
 	int retval = 0;
 	dprintk(DEBUG_VFS, "\n");
 	if ((!oldfid) || (!olddirfid) || (!newdirfid)) {
 		dprintk(DEBUG_ERROR, "problem with arguments\n");
 		return -EBADF;
 	}
 	/* 9P can only handle file rename in the same directory */
 	if (memcmp(&olddirfid->qid, &newdirfid->qid, sizeof(newdirfid->qid))) {
 		dprintk(DEBUG_ERROR, "old dir and new dir are different\n");
 		retval = -EPERM;
 		goto FreeFcallnBail;
 	}
 	fid = oldfid->fid;
 	olddirfidnum = olddirfid->fid;
 	newdirfidnum = newdirfid->fid;
 	if (fid < 0) {
 		dprintk(DEBUG_ERROR, "no fid for old file #%lu\n",
 			old_inode->i_ino);
 		retval = -EBADF;
 		goto FreeFcallnBail;
 	}
 	v9fs_blank_wstat(&wstat);
 	wstat.muid = v9ses->name;
 	wstat.name = (char *) new_dentry->d_name.name;
 	retval = v9fs_t_wstat(v9ses, fid, &wstat, &fcall);
       FreeFcallnBail:
 	if (retval < 0)
 		PRINT_FCALL_ERROR("wstat error", fcall);
 	kfree(fcall);
 	return retval;
 }
 /**
  * v9fs_vfs_getattr - retrieve file metadata
  * @mnt - mount information
  * @dentry - file to get attributes on
  * @stat - metadata structure to populate
  *
  */
 static int
 v9fs_vfs_getattr(struct vfsmount *mnt, struct dentry *dentry,
 		 struct kstat *stat)
 {
 	struct v9fs_fcall *fcall = NULL;
 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
 	struct v9fs_fid *fid = v9fs_fid_lookup(dentry);
 	int err = -EPERM;
 	dprintk(DEBUG_VFS, "dentry: %p\n", dentry);
 	if (!fid) {
 		dprintk(DEBUG_ERROR,
 			"couldn't find fid associated with dentry\n");
 		return -EBADF;
 	}
 	err = v9fs_t_stat(v9ses, fid->fid, &fcall);
 	if (err < 0)
 		dprintk(DEBUG_ERROR, "stat error\n");
 	else {
 		v9fs_stat2inode(&fcall->params.rstat.stat, dentry->d_inode,
 				  dentry->d_inode->i_sb);
 		generic_fillattr(dentry->d_inode, stat);
 	}
 	kfree(fcall);
 	return err;
 }
 /**
  * v9fs_vfs_setattr - set file metadata
  * @dentry: file whose metadata to set
  * @iattr: metadata assignment structure
  *
  */
 static int v9fs_vfs_setattr(struct dentry *dentry, struct iattr *iattr)
 {
 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
 	struct v9fs_fid *fid = v9fs_fid_lookup(dentry);
 	struct v9fs_fcall *fcall = NULL;
 	struct v9fs_wstat wstat;
 	int res = -EPERM;
 	dprintk(DEBUG_VFS, "\n");
 	if (!fid) {
 		dprintk(DEBUG_ERROR,
 			"Couldn't find fid associated with dentry\n");
 		return -EBADF;
 	}
 	v9fs_blank_wstat(&wstat);
 	if (iattr->ia_valid & ATTR_MODE)
 		wstat.mode = unixmode2p9mode(v9ses, iattr->ia_mode);
 	if (iattr->ia_valid & ATTR_MTIME)
 		wstat.mtime = iattr->ia_mtime.tv_sec;
 	if (iattr->ia_valid & ATTR_ATIME)
 		wstat.atime = iattr->ia_atime.tv_sec;
 	if (iattr->ia_valid & ATTR_SIZE)
 		wstat.length = iattr->ia_size;
 	if (v9ses->extended) {
 		if (iattr->ia_valid & ATTR_UID)
 			wstat.n_uid = iattr->ia_uid;
 		if (iattr->ia_valid & ATTR_GID)
 			wstat.n_gid = iattr->ia_gid;
 	}
 	res = v9fs_t_wstat(v9ses, fid->fid, &wstat, &fcall);
 	if (res < 0)
 		PRINT_FCALL_ERROR("wstat error", fcall);
 	kfree(fcall);
 	if (res >= 0)
 		res = inode_setattr(dentry->d_inode, iattr);
 	return res;
 }
 /**
  * v9fs_stat2inode - populate an inode structure with mistat info
  * @stat: Plan 9 metadata (mistat) structure
  * @inode: inode to populate
  * @sb: superblock of filesystem
  *
  */
 void
 v9fs_stat2inode(struct v9fs_stat *stat, struct inode *inode,
 	struct super_block *sb)
 {
 	int n;
 	char ext[32];
 	struct v9fs_session_info *v9ses = sb->s_fs_info;
 	inode->i_nlink = 1;
 	inode->i_atime.tv_sec = stat->atime;
 	inode->i_mtime.tv_sec = stat->mtime;
 	inode->i_ctime.tv_sec = stat->mtime;
 	inode->i_uid = v9ses->uid;
 	inode->i_gid = v9ses->gid;
 	if (v9ses->extended) {
 		inode->i_uid = stat->n_uid;
 		inode->i_gid = stat->n_gid;
 	}
 	inode->i_mode = p9mode2unixmode(v9ses, stat->mode);
 	if ((S_ISBLK(inode->i_mode)) || (S_ISCHR(inode->i_mode))) {
 		char type = 0;
 		int major = -1;
 		int minor = -1;
 		n = stat->extension.len;
 		if (n > sizeof(ext)-1)
 			n = sizeof(ext)-1;
 		memmove(ext, stat->extension.str, n);
 		ext[n] = 0;
 		sscanf(ext, "%c %u %u", &type, &major, &minor);
 		switch (type) {
 		case 'c':
 			inode->i_mode &= ~S_IFBLK;
 			inode->i_mode |= S_IFCHR;
 			break;
 		case 'b':
 			break;
 		default:
 			dprintk(DEBUG_ERROR, "Unknown special type %c (%.*s)\n",
 				type, stat->extension.len, stat->extension.str);
 		};
 		inode->i_rdev = MKDEV(major, minor);
 	} else
 		inode->i_rdev = 0;
 	inode->i_size = stat->length;
 	inode->i_blksize = sb->s_blocksize;
 	inode->i_blocks =
 	    (inode->i_size + inode->i_blksize - 1) >> sb->s_blocksize_bits;
 }
 /**
  * v9fs_qid2ino - convert qid into inode number
  * @qid: qid to hash
  *
  * BUG: potential for inode number collisions?
  */
 ino_t v9fs_qid2ino(struct v9fs_qid *qid)
 {
 	u64 path = qid->path + 2;
 	ino_t i = 0;
 	if (sizeof(ino_t) == sizeof(path))
 		memcpy(&i, &path, sizeof(ino_t));
 	else
 		i = (ino_t) (path ^ (path >> 32));
 	return i;
 }
 /**
  * v9fs_readlink - read a symlink's location (internal version)
  * @dentry: dentry for symlink
  * @buffer: buffer to load symlink location into
  * @buflen: length of buffer
  *
  */
 static int v9fs_readlink(struct dentry *dentry, char *buffer, int buflen)
 {
 	int retval = -EPERM;
 	struct v9fs_fcall *fcall = NULL;
 	struct v9fs_session_info *v9ses = v9fs_inode2v9ses(dentry->d_inode);
 	struct v9fs_fid *fid = v9fs_fid_lookup(dentry);
 	if (!fid) {
 		dprintk(DEBUG_ERROR, "could not resolve fid from dentry\n");
 		retval = -EBADF;
 		goto FreeFcall;
 	}
 	if (!v9ses->extended) {
 		retval = -EBADF;
 		dprintk(DEBUG_ERROR, "not extended\n");
 		goto FreeFcall;
 	}
 	dprintk(DEBUG_VFS, " %s\n", dentry->d_name.name);
 	retval = v9fs_t_stat(v9ses, fid->fid, &fcall);
 	if (retval < 0) {
 		dprintk(DEBUG_ERROR, "stat error\n");
 		goto FreeFcall;
 	}
 	if (!fcall)
 		return -EIO;
 	if (!(fcall->params.rstat.stat.mode & V9FS_DMSYMLINK)) {
 		retval = -EINVAL;
 		goto FreeFcall;
 	}
 	/* copy extension buffer into buffer */
 	if (fcall->params.rstat.stat.extension.len < buflen)
 		buflen = fcall->params.rstat.stat.extension.len + 1;
 	memmove(buffer, fcall->params.rstat.stat.extension.str, buflen - 1);
 	buffer[buflen-1] = 0;
 	dprintk(DEBUG_ERROR, "%s -> %.*s (%s)\n", dentry->d_name.name, fcall->params.rstat.stat.extension.len,
 		fcall->params.rstat.stat.extension.str, buffer);
 	retval = buflen;
       FreeFcall:
 	kfree(fcall);
 	return retval;
 }
 /**
  * v9fs_vfs_readlink - read a symlink's location
  * @dentry: dentry for symlink
  * @buf: buffer to load symlink location into
  * @buflen: length of buffer
  *
  */
 static int v9fs_vfs_readlink(struct dentry *dentry, char __user * buffer,
 			     int buflen)
 {
 	int retval;
 	int ret;
 	char *link = __getname();
 	if (buflen > PATH_MAX)
 		buflen = PATH_MAX;
 	dprintk(DEBUG_VFS, " dentry: %s (%p)\n", dentry->d_iname, dentry);
 	retval = v9fs_readlink(dentry, link, buflen);
 	if (retval > 0) {
 		if ((ret = copy_to_user(buffer, link, retval)) != 0) {
 			dprintk(DEBUG_ERROR, "problem copying to user: %d\n",
 				ret);
 			retval = ret;
 		}
 	}
 	__putname(link);
 	return retval;
 }
 /**
  * v9fs_vfs_follow_link - follow a symlink path
  * @dentry: dentry for symlink
  * @nd: nameidata
  *
  */
 static void *v9fs_vfs_follow_link(struct dentry *dentry, struct nameidata *nd)
 {
 	int len = 0;
 	char *link = __getname();
 	dprintk(DEBUG_VFS, "%s n", dentry->d_name.name);
 	if (!link)
 		link = ERR_PTR(-ENOMEM);
 	else {
 		len = v9fs_readlink(dentry, link, PATH_MAX);
 		if (len < 0) {
 			__putname(link);
 			link = ERR_PTR(len);
 		} else
 			link[len] = 0;
 	}
 	nd_set_link(nd, link);
 	return NULL;
 }
 /**
  * v9fs_vfs_put_link - release a symlink path
  * @dentry: dentry for symlink
  * @nd: nameidata
  *
  */
 static void v9fs_vfs_put_link(struct dentry *dentry, struct nameidata *nd, void *p)
 {
 	char *s = nd_get_link(nd);
 	dprintk(DEBUG_VFS, " %s %s\n", dentry->d_name.name, s);
 	if (!IS_ERR(s))
 		__putname(s);
 }
 static int v9fs_vfs_mkspecial(struct inode *dir, struct dentry *dentry,
 	int mode, const char *extension)
 {
 	int err;
 	u32 fid, perm;
 	struct v9fs_session_info *v9ses;
 	struct v9fs_fid *dfid, *vfid;
 	struct inode *inode;
 	inode = NULL;
 	vfid = NULL;
 	v9ses = v9fs_inode2v9ses(dir);
 	dfid = v9fs_fid_lookup(dentry->d_parent);
 	perm = unixmode2p9mode(v9ses, mode);
 	if (!v9ses->extended) {
 		dprintk(DEBUG_ERROR, "not extended\n");
 		return -EPERM;
 	}
 	err = v9fs_create(v9ses, dfid->fid, (char *) dentry->d_name.name,
 		perm, V9FS_OREAD, (char *) extension, &fid, NULL, NULL);
 	if (err)
 		goto error;
 	err = v9fs_t_clunk(v9ses, fid);
 	if (err)
 		goto error;
 	vfid = v9fs_clone_walk(v9ses, dfid->fid, dentry);
 	if (IS_ERR(vfid)) {
 		err = PTR_ERR(vfid);
 		vfid = NULL;
 		goto error;
 	}
 	inode = v9fs_inode_from_fid(v9ses, vfid->fid, dir->i_sb);
 	if (IS_ERR(inode)) {
 		err = PTR_ERR(inode);
 		inode = NULL;
 		goto error;
 	}
 	dentry->d_op = &v9fs_dentry_operations;
 	d_instantiate(dentry, inode);
 	return 0;
 error:
 	if (vfid)
 		v9fs_fid_destroy(vfid);
 	if (inode)
 		iput(inode);
 	return err;
 }
 /**
  * v9fs_vfs_symlink - helper function to create symlinks
  * @dir: directory inode containing symlink
  * @dentry: dentry for symlink
  * @symname: symlink data
  *
  * See 9P2000.u RFC for more information
  *
  */
 static int
 v9fs_vfs_symlink(struct inode *dir, struct dentry *dentry, const char *symname)
 {
 	dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
 		symname);
 	return v9fs_vfs_mkspecial(dir, dentry, S_IFLNK, symname);
 }
 /**
  * v9fs_vfs_link - create a hardlink
  * @old_dentry: dentry for file to link to
  * @dir: inode destination for new link
  * @dentry: dentry for link
  *
  */
 /* XXX - lots of code dup'd from symlink and creates,
  * figure out a better reuse strategy
  */
 static int
 v9fs_vfs_link(struct dentry *old_dentry, struct inode *dir,
 	      struct dentry *dentry)
 {
 	int retval;
 	struct v9fs_fid *oldfid;
 	char *name;
 	dprintk(DEBUG_VFS, " %lu,%s,%s\n", dir->i_ino, dentry->d_name.name,
 		old_dentry->d_name.name);
 	oldfid = v9fs_fid_lookup(old_dentry);
 	if (!oldfid) {
 		dprintk(DEBUG_ERROR, "can't find oldfid\n");
 		return -EPERM;
 	}
 	name = __getname();
 	sprintf(name, "%d\n", oldfid->fid);
 	retval = v9fs_vfs_mkspecial(dir, dentry, V9FS_DMLINK, name);
 	__putname(name);
 	return retval;
 }
 /**
  * v9fs_vfs_mknod - create a special file
  * @dir: inode destination for new link
  * @dentry: dentry for file
  * @mode: mode for creation
  * @dev_t: device associated with special file
  *
  */
 static int
 v9fs_vfs_mknod(struct inode *dir, struct dentry *dentry, int mode, dev_t rdev)
 {
 	int retval;
 	char *name;
 	dprintk(DEBUG_VFS, " %lu,%s mode: %x MAJOR: %u MINOR: %u\n", dir->i_ino,
 		dentry->d_name.name, mode, MAJOR(rdev), MINOR(rdev));
 	if (!new_valid_dev(rdev))
 		return -EINVAL;
 	name = __getname();
 	if (!name)
 		return -ENOMEM;
 	/* build extension */
 	if (S_ISBLK(mode))
 		sprintf(name, "b %u %u", MAJOR(rdev), MINOR(rdev));
 	else if (S_ISCHR(mode))
 		sprintf(name, "c %u %u", MAJOR(rdev), MINOR(rdev));
 	else if (S_ISFIFO(mode))
 		*name = 0;
 	else {
 		__putname(name);
 		return -EINVAL;
 	}
 	retval = v9fs_vfs_mkspecial(dir, dentry, mode, name);
 	__putname(name);
 	return retval;
 }
 static struct inode_operations v9fs_dir_inode_operations_ext = {
 	.create = v9fs_vfs_create,
 	.lookup = v9fs_vfs_lookup,
 	.symlink = v9fs_vfs_symlink,
 	.link = v9fs_vfs_link,
 	.unlink = v9fs_vfs_unlink,
 	.mkdir = v9fs_vfs_mkdir,
 	.rmdir = v9fs_vfs_rmdir,
 	.mknod = v9fs_vfs_mknod,
 	.rename = v9fs_vfs_rename,
 	.readlink = v9fs_vfs_readlink,
 	.getattr = v9fs_vfs_getattr,
 	.setattr = v9fs_vfs_setattr,
 };
 static struct inode_operations v9fs_dir_inode_operations = {
 	.create = v9fs_vfs_create,
 	.lookup = v9fs_vfs_lookup,
 	.unlink = v9fs_vfs_unlink,
 	.mkdir = v9fs_vfs_mkdir,
 	.rmdir = v9fs_vfs_rmdir,
 	.mknod = v9fs_vfs_mknod,
 	.rename = v9fs_vfs_rename,
 	.getattr = v9fs_vfs_getattr,
 	.setattr = v9fs_vfs_setattr,
 };
 static struct inode_operations v9fs_file_inode_operations = {
 	.getattr = v9fs_vfs_getattr,
 	.setattr = v9fs_vfs_setattr,
 };
 static struct inode_operations v9fs_symlink_inode_operations = {
 	.readlink = v9fs_vfs_readlink,
 	.follow_link = v9fs_vfs_follow_link,
 	.put_link = v9fs_vfs_put_link,
 	.getattr = v9fs_vfs_getattr,
 	.setattr = v9fs_vfs_setattr,
 };