fs/9p/vfs_file.c

   1 /*
   2  *  linux/fs/9p/vfs_file.c
   3  *
   4  * This file contians vfs file ops for 9P2000.
   5  *
   6  *  Copyright (C) 2004 by Eric Van Hensbergen <ericvh@gmail.com>
   7  *  Copyright (C) 2002 by Ron Minnich <rminnich@lanl.gov>
   8  *
   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
  11  *  as published by the Free Software Foundation.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, write to:
  20  *  Free Software Foundation
  21  *  51 Franklin Street, Fifth Floor
  22  *  Boston, MA  02111-1301  USA
  23  *
  24  */
  25
  26 #include <linux/module.h>
  27 #include <linux/errno.h>
  28 #include <linux/fs.h>
  29 #include <linux/sched.h>
  30 #include <linux/file.h>
  31 #include <linux/stat.h>
  32 #include <linux/string.h>
  33 #include <linux/inet.h>
  34 #include <linux/list.h>
  35 #include <linux/pagemap.h>
  36 #include <linux/utsname.h>
  37 #include <asm/uaccess.h>
  38 #include <linux/idr.h>
  39 #include <net/9p/9p.h>
  40 #include <net/9p/client.h>
  41
  42 #include "v9fs.h"
  43 #include "v9fs_vfs.h"
  44 #include "fid.h"
  45 #include "cache.h"
  46
  47 /**
  48  * v9fs_file_open - open a file (or directory)
  49  * @inode: inode to be opened
  50  * @file: file being opened
  51  *
  52  */
  53
  54 int v9fs_file_open(struct inode *inode, struct file *file)
  55 {
  56         int err;
  57         struct v9fs_session_info *v9ses;
  58         struct p9_fid *fid;
  59         int omode;
  60
  61         P9_DPRINTK(P9_DEBUG_VFS, "inode: %p file: %p\n", inode, file);
  62         v9ses = v9fs_inode2v9ses(inode);
  63         if (v9fs_proto_dotl(v9ses))
  64                 omode = file->f_flags;
  65         else
  66                 omode = v9fs_uflags2omode(file->f_flags,
  67                                         v9fs_proto_dotu(v9ses));
  68         fid = file->private_data;
  69         if (!fid) {
  70                 fid = v9fs_fid_clone(file->f_path.dentry);
  71                 if (IS_ERR(fid))
  72                         return PTR_ERR(fid);
  73
  74                 err = p9_client_open(fid, omode);
  75                 if (err < 0) {
  76                         p9_client_clunk(fid);
  77                         return err;
  78                 }
  79                 if (file->f_flags & O_TRUNC) {
  80                         i_size_write(inode, 0);
  81                         inode->i_blocks = 0;
  82                 }
  83                 if ((file->f_flags & O_APPEND) &&
  84                         (!v9fs_proto_dotu(v9ses) && !v9fs_proto_dotl(v9ses)))
  85                         generic_file_llseek(file, 0, SEEK_END);
  86         }
  87
  88         file->private_data = fid;
  89 #ifdef CONFIG_9P_FSCACHE
  90         if (v9ses->cache)
  91                 v9fs_cache_inode_set_cookie(inode, file);
  92 #endif
  93         return 0;
  94 }
  95
  96 /**
  97  * v9fs_file_lock - lock a file (or directory)
  98  * @filp: file to be locked
  99  * @cmd: lock command
 100  * @fl: file lock structure
 101  *
 102  * Bugs: this looks like a local only lock, we should extend into 9P
 103  *       by using open exclusive
 104  */
 105
 106 static int v9fs_file_lock(struct file *filp, int cmd, struct file_lock *fl)
 107 {
 108         int res = 0;
 109         struct inode *inode = filp->f_path.dentry->d_inode;
 110
 111         P9_DPRINTK(P9_DEBUG_VFS, "filp: %p lock: %p\n", filp, fl);
 112
 113         /* No mandatory locks */
 114         if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
 115                 return -ENOLCK;
 116
 117         if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
 118                 filemap_write_and_wait(inode->i_mapping);
 119                 invalidate_mapping_pages(&inode->i_data, 0, -1);
 120         }
 121
 122         return res;
 123 }
 124
 125 static int v9fs_file_do_lock(struct file *filp, int cmd, struct file_lock *fl)
 126 {
 127         struct p9_flock flock;
 128         struct p9_fid *fid;
 129         uint8_t status;
 130         int res = 0;
 131         unsigned char fl_type;
 132
 133         fid = filp->private_data;
 134         BUG_ON(fid == NULL);
 135
 136         if ((fl->fl_flags & FL_POSIX) != FL_POSIX)
 137                 BUG();
 138
 139         res = posix_lock_file_wait(filp, fl);
 140         if (res < 0)
 141                 goto out;
 142
 143         /* convert posix lock to p9 tlock args */
 144         memset(&flock, 0, sizeof(flock));
 145         flock.type = fl->fl_type;
 146         flock.start = fl->fl_start;
 147         if (fl->fl_end == OFFSET_MAX)
 148                 flock.length = 0;
 149         else
 150                 flock.length = fl->fl_end - fl->fl_start + 1;
 151         flock.proc_id = fl->fl_pid;
 152         flock.client_id = utsname()->nodename;
 153         if (IS_SETLKW(cmd))
 154                 flock.flags = P9_LOCK_FLAGS_BLOCK;
 155
 156         /*
 157          * if its a blocked request and we get P9_LOCK_BLOCKED as the status
 158          * for lock request, keep on trying
 159          */
 160         for (;;) {
 161                 res = p9_client_lock_dotl(fid, &flock, &status);
 162                 if (res < 0)
 163                         break;
 164
 165                 if (status != P9_LOCK_BLOCKED)
 166                         break;
 167                 if (status == P9_LOCK_BLOCKED && !IS_SETLKW(cmd))
 168                         break;
 169                 schedule_timeout_interruptible(P9_LOCK_TIMEOUT);
 170         }
 171
 172         /* map 9p status to VFS status */
 173         switch (status) {
 174         case P9_LOCK_SUCCESS:
 175                 res = 0;
 176                 break;
 177         case P9_LOCK_BLOCKED:
 178                 res = -EAGAIN;
 179                 break;
 180         case P9_LOCK_ERROR:
 181         case P9_LOCK_GRACE:
 182                 res = -ENOLCK;
 183                 break;
 184         default:
 185                 BUG();
 186         }
 187
 188         /*
 189          * incase server returned error for lock request, revert
 190          * it locally
 191          */
 192         if (res < 0 && fl->fl_type != F_UNLCK) {
 193                 fl_type = fl->fl_type;
 194                 fl->fl_type = F_UNLCK;
 195                 res = posix_lock_file_wait(filp, fl);
 196                 fl->fl_type = fl_type;
 197         }
 198 out:
 199         return res;
 200 }
 201
 202 static int v9fs_file_getlock(struct file *filp, struct file_lock *fl)
 203 {
 204         struct p9_getlock glock;
 205         struct p9_fid *fid;
 206         int res = 0;
 207
 208         fid = filp->private_data;
 209         BUG_ON(fid == NULL);
 210
 211         posix_test_lock(filp, fl);
 212         /*
 213          * if we have a conflicting lock locally, no need to validate
 214          * with server
 215          */
 216         if (fl->fl_type != F_UNLCK)
 217                 return res;
 218
 219         /* convert posix lock to p9 tgetlock args */
 220         memset(&glock, 0, sizeof(glock));
 221         glock.type = fl->fl_type;
 222         glock.start = fl->fl_start;
 223         if (fl->fl_end == OFFSET_MAX)
 224                 glock.length = 0;
 225         else
 226                 glock.length = fl->fl_end - fl->fl_start + 1;
 227         glock.proc_id = fl->fl_pid;
 228         glock.client_id = utsname()->nodename;
 229
 230         res = p9_client_getlock_dotl(fid, &glock);
 231         if (res < 0)
 232                 return res;
 233         if (glock.type != F_UNLCK) {
 234                 fl->fl_type = glock.type;
 235                 fl->fl_start = glock.start;
 236                 if (glock.length == 0)
 237                         fl->fl_end = OFFSET_MAX;
 238                 else
 239                         fl->fl_end = glock.start + glock.length - 1;
 240                 fl->fl_pid = glock.proc_id;
 241         } else
 242                 fl->fl_type = F_UNLCK;
 243
 244         return res;
 245 }
 246
 247 /**
 248  * v9fs_file_lock_dotl - lock a file (or directory)
 249  * @filp: file to be locked
 250  * @cmd: lock command
 251  * @fl: file lock structure
 252  *
 253  */
 254
 255 static int v9fs_file_lock_dotl(struct file *filp, int cmd, struct file_lock *fl)
 256 {
 257         struct inode *inode = filp->f_path.dentry->d_inode;
 258         int ret = -ENOLCK;
 259
 260         P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp,
 261                                 cmd, fl, filp->f_path.dentry->d_name.name);
 262
 263         /* No mandatory locks */
 264         if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
 265                 goto out_err;
 266
 267         if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
 268                 filemap_write_and_wait(inode->i_mapping);
 269                 invalidate_mapping_pages(&inode->i_data, 0, -1);
 270         }
 271
 272         if (IS_SETLK(cmd) || IS_SETLKW(cmd))
 273                 ret = v9fs_file_do_lock(filp, cmd, fl);
 274         else if (IS_GETLK(cmd))
 275                 ret = v9fs_file_getlock(filp, fl);
 276         else
 277                 ret = -EINVAL;
 278 out_err:
 279         return ret;
 280 }
 281
 282 /**
 283  * v9fs_file_flock_dotl - lock a file
 284  * @filp: file to be locked
 285  * @cmd: lock command
 286  * @fl: file lock structure
 287  *
 288  */
 289
 290 static int v9fs_file_flock_dotl(struct file *filp, int cmd,
 291         struct file_lock *fl)
 292 {
 293         struct inode *inode = filp->f_path.dentry->d_inode;
 294         int ret = -ENOLCK;
 295
 296         P9_DPRINTK(P9_DEBUG_VFS, "filp: %p cmd:%d lock: %p name: %s\n", filp,
 297                                 cmd, fl, filp->f_path.dentry->d_name.name);
 298
 299         /* No mandatory locks */
 300         if (__mandatory_lock(inode) && fl->fl_type != F_UNLCK)
 301                 goto out_err;
 302
 303         if (!(fl->fl_flags & FL_FLOCK))
 304                 goto out_err;
 305
 306         if ((IS_SETLK(cmd) || IS_SETLKW(cmd)) && fl->fl_type != F_UNLCK) {
 307                 filemap_write_and_wait(inode->i_mapping);
 308                 invalidate_mapping_pages(&inode->i_data, 0, -1);
 309         }
 310         /* Convert flock to posix lock */
 311         fl->fl_owner = (fl_owner_t)filp;
 312         fl->fl_start = 0;
 313         fl->fl_end = OFFSET_MAX;
 314         fl->fl_flags |= FL_POSIX;
 315         fl->fl_flags ^= FL_FLOCK;
 316
 317         if (IS_SETLK(cmd) | IS_SETLKW(cmd))
 318                 ret = v9fs_file_do_lock(filp, cmd, fl);
 319         else
 320                 ret = -EINVAL;
 321 out_err:
 322         return ret;
 323 }
 324
 325 /**
 326  * v9fs_fid_readn - read from a fid
 327  * @fid: fid to read
 328  * @data: data buffer to read data into
 329  * @udata: user data buffer to read data into
 330  * @count: size of buffer
 331  * @offset: offset at which to read data
 332  *
 333  */
 334 ssize_t
 335 v9fs_fid_readn(struct p9_fid *fid, char *data, char __user *udata, u32 count,
 336                u64 offset)
 337 {
 338         int n, total, size;
 339
 340         P9_DPRINTK(P9_DEBUG_VFS, "fid %d offset %llu count %d\n", fid->fid,
 341                    (long long unsigned) offset, count);
 342         n = 0;
 343         total = 0;
 344         size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
 345         do {
 346                 n = p9_client_read(fid, data, udata, offset, count);
 347                 if (n <= 0)
 348                         break;
 349
 350                 if (data)
 351                         data += n;
 352                 if (udata)
 353                         udata += n;
 354
 355                 offset += n;
 356                 count -= n;
 357                 total += n;
 358         } while (count > 0 && n == size);
 359
 360         if (n < 0)
 361                 total = n;
 362
 363         return total;
 364 }
 365
 366 /**
 367  * v9fs_file_readn - read from a file
 368  * @filp: file pointer to read
 369  * @data: data buffer to read data into
 370  * @udata: user data buffer to read data into
 371  * @count: size of buffer
 372  * @offset: offset at which to read data
 373  *
 374  */
 375 ssize_t
 376 v9fs_file_readn(struct file *filp, char *data, char __user *udata, u32 count,
 377                u64 offset)
 378 {
 379         return v9fs_fid_readn(filp->private_data, data, udata, count, offset);
 380 }
 381
 382 /**
 383  * v9fs_file_read - read from a file
 384  * @filp: file pointer to read
 385  * @udata: user data buffer to read data into
 386  * @count: size of buffer
 387  * @offset: offset at which to read data
 388  *
 389  */
 390
 391 static ssize_t
 392 v9fs_file_read(struct file *filp, char __user *udata, size_t count,
 393                loff_t * offset)
 394 {
 395         int ret;
 396         struct p9_fid *fid;
 397         size_t size;
 398
 399         P9_DPRINTK(P9_DEBUG_VFS, "count %zu offset %lld\n", count, *offset);
 400         fid = filp->private_data;
 401
 402         size = fid->iounit ? fid->iounit : fid->clnt->msize - P9_IOHDRSZ;
 403         if (count > size)
 404                 ret = v9fs_file_readn(filp, NULL, udata, count, *offset);
 405         else
 406                 ret = p9_client_read(fid, NULL, udata, *offset, count);
 407
 408         if (ret > 0)
 409                 *offset += ret;
 410
 411         return ret;
 412 }
 413
 414 ssize_t
 415 v9fs_file_write_internal(struct inode *inode, struct p9_fid *fid,
 416                          const char __user *data, size_t count,
 417                          loff_t *offset, int invalidate)
 418 {
 419         int n;
 420         size_t total = 0;
 421         struct p9_client *clnt;
 422         loff_t origin = *offset;
 423         unsigned long pg_start, pg_end;
 424
 425         P9_DPRINTK(P9_DEBUG_VFS, "data %p count %d offset %x\n", data,
 426                 (int)count, (int)*offset);
 427
 428         clnt = fid->clnt;
 429         do {
 430                 n = p9_client_write(fid, NULL, data+total, origin+total, count);
 431                 if (n <= 0)
 432                         break;
 433                 count -= n;
 434                 total += n;
 435         } while (count > 0);
 436
 437         if (invalidate && (total > 0)) {
 438                 pg_start = origin >> PAGE_CACHE_SHIFT;
 439                 pg_end = (origin + total - 1) >> PAGE_CACHE_SHIFT;
 440                 if (inode->i_mapping && inode->i_mapping->nrpages)
 441                         invalidate_inode_pages2_range(inode->i_mapping,
 442                                                       pg_start, pg_end);
 443                 *offset += total;
 444                 i_size_write(inode, i_size_read(inode) + total);
 445                 inode->i_blocks = (i_size_read(inode) + 512 - 1) >> 9;
 446         }
 447         if (n < 0)
 448                 return n;
 449
 450         return total;
 451 }
 452
 453 /**
 454  * v9fs_file_write - write to a file
 455  * @filp: file pointer to write
 456  * @data: data buffer to write data from
 457  * @count: size of buffer
 458  * @offset: offset at which to write data
 459  *
 460  */
 461 static ssize_t
 462 v9fs_file_write(struct file *filp, const char __user * data,
 463                 size_t count, loff_t *offset)
 464 {
 465         ssize_t retval = 0;
 466         loff_t origin = *offset;
 467
 468
 469         retval = generic_write_checks(filp, &origin, &count, 0);
 470         if (retval)
 471                 goto out;
 472
 473         retval = -EINVAL;
 474         if ((ssize_t) count < 0)
 475                 goto out;
 476         retval = 0;
 477         if (!count)
 478                 goto out;
 479
 480         return v9fs_file_write_internal(filp->f_path.dentry->d_inode,
 481                                         filp->private_data,
 482                                         data, count, offset, 1);
 483 out:
 484         return retval;
 485 }
 486
 487 static int v9fs_file_fsync(struct file *filp, int datasync)
 488 {
 489         struct p9_fid *fid;
 490         struct p9_wstat wstat;
 491         int retval;
 492
 493         P9_DPRINTK(P9_DEBUG_VFS, "filp %p datasync %x\n", filp, datasync);
 494
 495         fid = filp->private_data;
 496         v9fs_blank_wstat(&wstat);
 497
 498         retval = p9_client_wstat(fid, &wstat);
 499         return retval;
 500 }
 501
 502 int v9fs_file_fsync_dotl(struct file *filp, int datasync)
 503 {
 504         struct p9_fid *fid;
 505         int retval;
 506
 507         P9_DPRINTK(P9_DEBUG_VFS, "v9fs_file_fsync_dotl: filp %p datasync %x\n",
 508                         filp, datasync);
 509
 510         fid = filp->private_data;
 511
 512         retval = p9_client_fsync(fid, datasync);
 513         return retval;
 514 }
 515
 516 const struct file_operations v9fs_cached_file_operations = {
 517         .llseek = generic_file_llseek,
 518         .read = do_sync_read,
 519         .aio_read = generic_file_aio_read,
 520         .write = v9fs_file_write,
 521         .open = v9fs_file_open,
 522         .release = v9fs_dir_release,
 523         .lock = v9fs_file_lock,
 524         .mmap = generic_file_readonly_mmap,
 525         .fsync = v9fs_file_fsync,
 526 };
 527
 528 const struct file_operations v9fs_cached_file_operations_dotl = {
 529         .llseek = generic_file_llseek,
 530         .read = do_sync_read,
 531         .aio_read = generic_file_aio_read,
 532         .write = v9fs_file_write,
 533         .open = v9fs_file_open,
 534         .release = v9fs_dir_release,
 535         .lock = v9fs_file_lock_dotl,
 536         .flock = v9fs_file_flock_dotl,
 537         .mmap = generic_file_readonly_mmap,
 538         .fsync = v9fs_file_fsync_dotl,
 539 };
 540
 541 const struct file_operations v9fs_file_operations = {
 542         .llseek = generic_file_llseek,
 543         .read = v9fs_file_read,
 544         .write = v9fs_file_write,
 545         .open = v9fs_file_open,
 546         .release = v9fs_dir_release,
 547         .lock = v9fs_file_lock,
 548         .mmap = generic_file_readonly_mmap,
 549         .fsync = v9fs_file_fsync,
 550 };
 551
 552 const struct file_operations v9fs_file_operations_dotl = {
 553         .llseek = generic_file_llseek,
 554         .read = v9fs_file_read,
 555         .write = v9fs_file_write,
 556         .open = v9fs_file_open,
 557         .release = v9fs_dir_release,
 558         .lock = v9fs_file_lock_dotl,
 559         .flock = v9fs_file_flock_dotl,
 560         .mmap = generic_file_readonly_mmap,
 561         .fsync = v9fs_file_fsync_dotl,
 562 };