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