Merge git://git.infradead.org/~dwmw2/rbtree-2.6
[linux-2.6] / fs / 9p / fcall.c
1 /*
2  *  linux/fs/9p/fcall.c
3  *
4  *  This file contains functions to perform synchronous 9P calls
5  *
6  *  Copyright (C) 2004 by Latchesar Ionkov <lucho@ionkov.net>
7  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
8  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
9  *
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License version 2
12  *  as published by the Free Software Foundation.
13  *
14  *  This program is distributed in the hope that it will be useful,
15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
17  *  GNU General Public License for more details.
18  *
19  *  You should have received a copy of the GNU General Public License
20  *  along with this program; if not, write to:
21  *  Free Software Foundation
22  *  51 Franklin Street, Fifth Floor
23  *  Boston, MA  02111-1301  USA
24  *
25  */
26
27 #include <linux/config.h>
28 #include <linux/module.h>
29 #include <linux/errno.h>
30 #include <linux/fs.h>
31 #include <linux/idr.h>
32
33 #include "debug.h"
34 #include "v9fs.h"
35 #include "9p.h"
36 #include "conv.h"
37 #include "mux.h"
38
39 /**
40  * v9fs_t_version - negotiate protocol parameters with sever
41  * @v9ses: 9P2000 session information
42  * @msize: requested max size packet
43  * @version: requested version.extension string
44  * @fcall: pointer to response fcall pointer
45  *
46  */
47
48 int
49 v9fs_t_version(struct v9fs_session_info *v9ses, u32 msize,
50                char *version, struct v9fs_fcall **rcp)
51 {
52         int ret;
53         struct v9fs_fcall *tc;
54
55         dprintk(DEBUG_9P, "msize: %d version: %s\n", msize, version);
56         tc = v9fs_create_tversion(msize, version);
57
58         if (!IS_ERR(tc)) {
59                 ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
60                 kfree(tc);
61         } else
62                 ret = PTR_ERR(tc);
63
64         return ret;
65 }
66
67 /**
68  * v9fs_t_attach - mount the server
69  * @v9ses: 9P2000 session information
70  * @uname: user name doing the attach
71  * @aname: remote name being attached to
72  * @fid: mount fid to attatch to root node
73  * @afid: authentication fid (in this case result key)
74  * @fcall: pointer to response fcall pointer
75  *
76  */
77
78 int
79 v9fs_t_attach(struct v9fs_session_info *v9ses, char *uname, char *aname,
80               u32 fid, u32 afid, struct v9fs_fcall **rcp)
81 {
82         int ret;
83         struct v9fs_fcall* tc;
84
85         dprintk(DEBUG_9P, "uname '%s' aname '%s' fid %d afid %d\n", uname,
86                 aname, fid, afid);
87
88         tc = v9fs_create_tattach(fid, afid, uname, aname);
89         if (!IS_ERR(tc)) {
90                 ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
91                 kfree(tc);
92         } else
93                 ret = PTR_ERR(tc);
94
95         return ret;
96 }
97
98 static void v9fs_t_clunk_cb(void *a, struct v9fs_fcall *tc,
99         struct v9fs_fcall *rc, int err)
100 {
101         int fid, id;
102         struct v9fs_session_info *v9ses;
103
104         id = 0;
105         fid = tc->params.tclunk.fid;
106         if (rc)
107                 id = rc->id;
108
109         kfree(tc);
110         kfree(rc);
111         if (id == RCLUNK) {
112                 v9ses = a;
113                 v9fs_put_idpool(fid, &v9ses->fidpool);
114         }
115 }
116
117 /**
118  * v9fs_t_clunk - release a fid (finish a transaction)
119  * @v9ses: 9P2000 session information
120  * @fid: fid to release
121  * @fcall: pointer to response fcall pointer
122  *
123  */
124
125 int
126 v9fs_t_clunk(struct v9fs_session_info *v9ses, u32 fid)
127 {
128         int ret;
129         struct v9fs_fcall *tc, *rc;
130
131         dprintk(DEBUG_9P, "fid %d\n", fid);
132
133         rc = NULL;
134         tc = v9fs_create_tclunk(fid);
135         if (!IS_ERR(tc))
136                 ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
137         else
138                 ret = PTR_ERR(tc);
139
140         if (ret)
141                 dprintk(DEBUG_ERROR, "failed fid %d err %d\n", fid, ret);
142
143         v9fs_t_clunk_cb(v9ses, tc, rc, ret);
144         return ret;
145 }
146
147 #if 0
148 /**
149  * v9fs_v9fs_t_flush - flush a pending transaction
150  * @v9ses: 9P2000 session information
151  * @tag: tag to release
152  *
153  */
154 int v9fs_t_flush(struct v9fs_session_info *v9ses, u16 oldtag)
155 {
156         int ret;
157         struct v9fs_fcall *tc;
158
159         dprintk(DEBUG_9P, "oldtag %d\n", oldtag);
160
161         tc = v9fs_create_tflush(oldtag);
162         if (!IS_ERR(tc)) {
163                 ret = v9fs_mux_rpc(v9ses->mux, tc, NULL);
164                 kfree(tc);
165         } else
166                 ret = PTR_ERR(tc);
167
168         return ret;
169 }
170 #endif
171
172 /**
173  * v9fs_t_stat - read a file's meta-data
174  * @v9ses: 9P2000 session information
175  * @fid: fid pointing to file or directory to get info about
176  * @fcall: pointer to response fcall
177  *
178  */
179
180 int
181 v9fs_t_stat(struct v9fs_session_info *v9ses, u32 fid, struct v9fs_fcall **rcp)
182 {
183         int ret;
184         struct v9fs_fcall *tc;
185
186         dprintk(DEBUG_9P, "fid %d\n", fid);
187
188         ret = -ENOMEM;
189         tc = v9fs_create_tstat(fid);
190         if (!IS_ERR(tc)) {
191                 ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
192                 kfree(tc);
193         } else
194                 ret = PTR_ERR(tc);
195
196         return ret;
197 }
198
199 /**
200  * v9fs_t_wstat - write a file's meta-data
201  * @v9ses: 9P2000 session information
202  * @fid: fid pointing to file or directory to write info about
203  * @stat: metadata
204  * @fcall: pointer to response fcall
205  *
206  */
207
208 int
209 v9fs_t_wstat(struct v9fs_session_info *v9ses, u32 fid,
210              struct v9fs_wstat *wstat, struct v9fs_fcall **rcp)
211 {
212         int ret;
213         struct v9fs_fcall *tc;
214
215         dprintk(DEBUG_9P, "fid %d\n", fid);
216
217         tc = v9fs_create_twstat(fid, wstat, v9ses->extended);
218         if (!IS_ERR(tc)) {
219                 ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
220                 kfree(tc);
221         } else
222                 ret = PTR_ERR(tc);
223
224         return ret;
225 }
226
227 /**
228  * v9fs_t_walk - walk a fid to a new file or directory
229  * @v9ses: 9P2000 session information
230  * @fid: fid to walk
231  * @newfid: new fid (for clone operations)
232  * @name: path to walk fid to
233  * @fcall: pointer to response fcall
234  *
235  */
236
237 /* TODO: support multiple walk */
238
239 int
240 v9fs_t_walk(struct v9fs_session_info *v9ses, u32 fid, u32 newfid,
241             char *name, struct v9fs_fcall **rcp)
242 {
243         int ret;
244         struct v9fs_fcall *tc;
245         int nwname;
246
247         dprintk(DEBUG_9P, "fid %d newfid %d wname '%s'\n", fid, newfid, name);
248
249         if (name)
250                 nwname = 1;
251         else
252                 nwname = 0;
253
254         tc = v9fs_create_twalk(fid, newfid, nwname, &name);
255         if (!IS_ERR(tc)) {
256                 ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
257                 kfree(tc);
258         } else
259                 ret = PTR_ERR(tc);
260
261         return ret;
262 }
263
264 /**
265  * v9fs_t_open - open a file
266  *
267  * @v9ses - 9P2000 session information
268  * @fid - fid to open
269  * @mode - mode to open file (R, RW, etc)
270  * @fcall - pointer to response fcall
271  *
272  */
273
274 int
275 v9fs_t_open(struct v9fs_session_info *v9ses, u32 fid, u8 mode,
276             struct v9fs_fcall **rcp)
277 {
278         int ret;
279         struct v9fs_fcall *tc;
280
281         dprintk(DEBUG_9P, "fid %d mode %d\n", fid, mode);
282
283         tc = v9fs_create_topen(fid, mode);
284         if (!IS_ERR(tc)) {
285                 ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
286                 kfree(tc);
287         } else
288                 ret = PTR_ERR(tc);
289
290         return ret;
291 }
292
293 /**
294  * v9fs_t_remove - remove a file or directory
295  * @v9ses: 9P2000 session information
296  * @fid: fid to remove
297  * @fcall: pointer to response fcall
298  *
299  */
300
301 int
302 v9fs_t_remove(struct v9fs_session_info *v9ses, u32 fid,
303               struct v9fs_fcall **rcp)
304 {
305         int ret;
306         struct v9fs_fcall *tc;
307
308         dprintk(DEBUG_9P, "fid %d\n", fid);
309
310         tc = v9fs_create_tremove(fid);
311         if (!IS_ERR(tc)) {
312                 ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
313                 kfree(tc);
314         } else
315                 ret = PTR_ERR(tc);
316
317         return ret;
318 }
319
320 /**
321  * v9fs_t_create - create a file or directory
322  * @v9ses: 9P2000 session information
323  * @fid: fid to create
324  * @name: name of the file or directory to create
325  * @perm: permissions to create with
326  * @mode: mode to open file (R, RW, etc)
327  * @fcall: pointer to response fcall
328  *
329  */
330
331 int
332 v9fs_t_create(struct v9fs_session_info *v9ses, u32 fid, char *name, u32 perm,
333         u8 mode, char *extension, struct v9fs_fcall **rcp)
334 {
335         int ret;
336         struct v9fs_fcall *tc;
337
338         dprintk(DEBUG_9P, "fid %d name '%s' perm %x mode %d\n",
339                 fid, name, perm, mode);
340
341         tc = v9fs_create_tcreate(fid, name, perm, mode, extension,
342                 v9ses->extended);
343
344         if (!IS_ERR(tc)) {
345                 ret = v9fs_mux_rpc(v9ses->mux, tc, rcp);
346                 kfree(tc);
347         } else
348                 ret = PTR_ERR(tc);
349
350         return ret;
351 }
352
353 /**
354  * v9fs_t_read - read data
355  * @v9ses: 9P2000 session information
356  * @fid: fid to read from
357  * @offset: offset to start read at
358  * @count: how many bytes to read
359  * @fcall: pointer to response fcall (with data)
360  *
361  */
362
363 int
364 v9fs_t_read(struct v9fs_session_info *v9ses, u32 fid, u64 offset,
365             u32 count, struct v9fs_fcall **rcp)
366 {
367         int ret;
368         struct v9fs_fcall *tc, *rc;
369
370         dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
371                 (long long unsigned) offset, count);
372
373         tc = v9fs_create_tread(fid, offset, count);
374         if (!IS_ERR(tc)) {
375                 ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
376                 if (!ret)
377                         ret = rc->params.rread.count;
378                 if (rcp)
379                         *rcp = rc;
380                 else
381                         kfree(rc);
382
383                 kfree(tc);
384         } else
385                 ret = PTR_ERR(tc);
386
387         return ret;
388 }
389
390 /**
391  * v9fs_t_write - write data
392  * @v9ses: 9P2000 session information
393  * @fid: fid to write to
394  * @offset: offset to start write at
395  * @count: how many bytes to write
396  * @fcall: pointer to response fcall
397  *
398  */
399
400 int
401 v9fs_t_write(struct v9fs_session_info *v9ses, u32 fid, u64 offset, u32 count,
402         const char __user *data, struct v9fs_fcall **rcp)
403 {
404         int ret;
405         struct v9fs_fcall *tc, *rc;
406
407         dprintk(DEBUG_9P, "fid %d offset 0x%llux count 0x%x\n", fid,
408                 (long long unsigned) offset, count);
409
410         tc = v9fs_create_twrite(fid, offset, count, data);
411         if (!IS_ERR(tc)) {
412                 ret = v9fs_mux_rpc(v9ses->mux, tc, &rc);
413
414                 if (!ret)
415                         ret = rc->params.rwrite.count;
416                 if (rcp)
417                         *rcp = rc;
418                 else
419                         kfree(rc);
420
421                 kfree(tc);
422         } else
423                 ret = PTR_ERR(tc);
424
425         return ret;
426 }
427