fs/9p/9p.c

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