fs/cifs/file.c

   1 /*
   2  *   fs/cifs/file.c
   3  *
   4  *   vfs operations that deal with files
   5  *
   6  *   Copyright (C) International Business Machines  Corp., 2002,2010
   7  *   Author(s): Steve French (sfrench@us.ibm.com)
   8  *              Jeremy Allison (jra@samba.org)
   9  *
  10  *   This library is free software; you can redistribute it and/or modify
  11  *   it under the terms of the GNU Lesser General Public License as published
  12  *   by the Free Software Foundation; either version 2.1 of the License, or
  13  *   (at your option) any later version.
  14  *
  15  *   This library 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
  18  *   the GNU Lesser General Public License for more details.
  19  *
  20  *   You should have received a copy of the GNU Lesser General Public License
  21  *   along with this library; if not, write to the Free Software
  22  *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  23  */
  24 #include <linux/fs.h>
  25 #include <linux/backing-dev.h>
  26 #include <linux/stat.h>
  27 #include <linux/fcntl.h>
  28 #include <linux/pagemap.h>
  29 #include <linux/pagevec.h>
  30 #include <linux/writeback.h>
  31 #include <linux/task_io_accounting_ops.h>
  32 #include <linux/delay.h>
  33 #include <linux/mount.h>
  34 #include <linux/slab.h>
  35 #include <linux/swap.h>
  36 #include <asm/div64.h>
  37 #include "cifsfs.h"
  38 #include "cifspdu.h"
  39 #include "cifsglob.h"
  40 #include "cifsproto.h"
  41 #include "cifs_unicode.h"
  42 #include "cifs_debug.h"
  43 #include "cifs_fs_sb.h"
  44 #include "fscache.h"
  45
  46
  47 static inline int cifs_convert_flags(unsigned int flags)
  48 {
  49         if ((flags & O_ACCMODE) == O_RDONLY)
  50                 return GENERIC_READ;
  51         else if ((flags & O_ACCMODE) == O_WRONLY)
  52                 return GENERIC_WRITE;
  53         else if ((flags & O_ACCMODE) == O_RDWR) {
  54                 /* GENERIC_ALL is too much permission to request
  55                    can cause unnecessary access denied on create */
  56                 /* return GENERIC_ALL; */
  57                 return (GENERIC_READ | GENERIC_WRITE);
  58         }
  59
  60         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
  61                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
  62                 FILE_READ_DATA);
  63 }
  64
  65 static u32 cifs_posix_convert_flags(unsigned int flags)
  66 {
  67         u32 posix_flags = 0;
  68
  69         if ((flags & O_ACCMODE) == O_RDONLY)
  70                 posix_flags = SMB_O_RDONLY;
  71         else if ((flags & O_ACCMODE) == O_WRONLY)
  72                 posix_flags = SMB_O_WRONLY;
  73         else if ((flags & O_ACCMODE) == O_RDWR)
  74                 posix_flags = SMB_O_RDWR;
  75
  76         if (flags & O_CREAT) {
  77                 posix_flags |= SMB_O_CREAT;
  78                 if (flags & O_EXCL)
  79                         posix_flags |= SMB_O_EXCL;
  80         } else if (flags & O_EXCL)
  81                 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
  82                          current->comm, current->tgid);
  83
  84         if (flags & O_TRUNC)
  85                 posix_flags |= SMB_O_TRUNC;
  86         /* be safe and imply O_SYNC for O_DSYNC */
  87         if (flags & O_DSYNC)
  88                 posix_flags |= SMB_O_SYNC;
  89         if (flags & O_DIRECTORY)
  90                 posix_flags |= SMB_O_DIRECTORY;
  91         if (flags & O_NOFOLLOW)
  92                 posix_flags |= SMB_O_NOFOLLOW;
  93         if (flags & O_DIRECT)
  94                 posix_flags |= SMB_O_DIRECT;
  95
  96         return posix_flags;
  97 }
  98
  99 static inline int cifs_get_disposition(unsigned int flags)
 100 {
 101         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 102                 return FILE_CREATE;
 103         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 104                 return FILE_OVERWRITE_IF;
 105         else if ((flags & O_CREAT) == O_CREAT)
 106                 return FILE_OPEN_IF;
 107         else if ((flags & O_TRUNC) == O_TRUNC)
 108                 return FILE_OVERWRITE;
 109         else
 110                 return FILE_OPEN;
 111 }
 112
 113 int cifs_posix_open(char *full_path, struct inode **pinode,
 114                         struct super_block *sb, int mode, unsigned int f_flags,
 115                         __u32 *poplock, __u16 *pnetfid, unsigned int xid)
 116 {
 117         int rc;
 118         FILE_UNIX_BASIC_INFO *presp_data;
 119         __u32 posix_flags = 0;
 120         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 121         struct cifs_fattr fattr;
 122         struct tcon_link *tlink;
 123         struct cifs_tcon *tcon;
 124
 125         cifs_dbg(FYI, "posix open %s\n", full_path);
 126
 127         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 128         if (presp_data == NULL)
 129                 return -ENOMEM;
 130
 131         tlink = cifs_sb_tlink(cifs_sb);
 132         if (IS_ERR(tlink)) {
 133                 rc = PTR_ERR(tlink);
 134                 goto posix_open_ret;
 135         }
 136
 137         tcon = tlink_tcon(tlink);
 138         mode &= ~current_umask();
 139
 140         posix_flags = cifs_posix_convert_flags(f_flags);
 141         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 142                              poplock, full_path, cifs_sb->local_nls,
 143                              cifs_remap(cifs_sb));
 144         cifs_put_tlink(tlink);
 145
 146         if (rc)
 147                 goto posix_open_ret;
 148
 149         if (presp_data->Type == cpu_to_le32(-1))
 150                 goto posix_open_ret; /* open ok, caller does qpathinfo */
 151
 152         if (!pinode)
 153                 goto posix_open_ret; /* caller does not need info */
 154
 155         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 156
 157         /* get new inode and set it up */
 158         if (*pinode == NULL) {
 159                 cifs_fill_uniqueid(sb, &fattr);
 160                 *pinode = cifs_iget(sb, &fattr);
 161                 if (!*pinode) {
 162                         rc = -ENOMEM;
 163                         goto posix_open_ret;
 164                 }
 165         } else {
 166                 cifs_fattr_to_inode(*pinode, &fattr);
 167         }
 168
 169 posix_open_ret:
 170         kfree(presp_data);
 171         return rc;
 172 }
 173
 174 static int
 175 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
 176              struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
 177              struct cifs_fid *fid, unsigned int xid)
 178 {
 179         int rc;
 180         int desired_access;
 181         int disposition;
 182         int create_options = CREATE_NOT_DIR;
 183         FILE_ALL_INFO *buf;
 184         struct TCP_Server_Info *server = tcon->ses->server;
 185         struct cifs_open_parms oparms;
 186
 187         if (!server->ops->open)
 188                 return -ENOSYS;
 189
 190         desired_access = cifs_convert_flags(f_flags);
 191
 192 /*********************************************************************
 193  *  open flag mapping table:
 194  *
 195  *      POSIX Flag            CIFS Disposition
 196  *      ----------            ----------------
 197  *      O_CREAT               FILE_OPEN_IF
 198  *      O_CREAT | O_EXCL      FILE_CREATE
 199  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 200  *      O_TRUNC               FILE_OVERWRITE
 201  *      none of the above     FILE_OPEN
 202  *
 203  *      Note that there is not a direct match between disposition
 204  *      FILE_SUPERSEDE (ie create whether or not file exists although
 205  *      O_CREAT | O_TRUNC is similar but truncates the existing
 206  *      file rather than creating a new file as FILE_SUPERSEDE does
 207  *      (which uses the attributes / metadata passed in on open call)
 208  *?
 209  *?  O_SYNC is a reasonable match to CIFS writethrough flag
 210  *?  and the read write flags match reasonably.  O_LARGEFILE
 211  *?  is irrelevant because largefile support is always used
 212  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 213  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 214  *********************************************************************/
 215
 216         disposition = cifs_get_disposition(f_flags);
 217
 218         /* BB pass O_SYNC flag through on file attributes .. BB */
 219
 220         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 221         if (!buf)
 222                 return -ENOMEM;
 223
 224         if (backup_cred(cifs_sb))
 225                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 226
 227         oparms.tcon = tcon;
 228         oparms.cifs_sb = cifs_sb;
 229         oparms.desired_access = desired_access;
 230         oparms.create_options = create_options;
 231         oparms.disposition = disposition;
 232         oparms.path = full_path;
 233         oparms.fid = fid;
 234         oparms.reconnect = false;
 235
 236         rc = server->ops->open(xid, &oparms, oplock, buf);
 237
 238         if (rc)
 239                 goto out;
 240
 241         if (tcon->unix_ext)
 242                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 243                                               xid);
 244         else
 245                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 246                                          xid, fid);
 247
 248 out:
 249         kfree(buf);
 250         return rc;
 251 }
 252
 253 static bool
 254 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
 255 {
 256         struct cifs_fid_locks *cur;
 257         bool has_locks = false;
 258
 259         down_read(&cinode->lock_sem);
 260         list_for_each_entry(cur, &cinode->llist, llist) {
 261                 if (!list_empty(&cur->locks)) {
 262                         has_locks = true;
 263                         break;
 264                 }
 265         }
 266         up_read(&cinode->lock_sem);
 267         return has_locks;
 268 }
 269
 270 struct cifsFileInfo *
 271 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
 272                   struct tcon_link *tlink, __u32 oplock)
 273 {
 274         struct dentry *dentry = file_dentry(file);
 275         struct inode *inode = d_inode(dentry);
 276         struct cifsInodeInfo *cinode = CIFS_I(inode);
 277         struct cifsFileInfo *cfile;
 278         struct cifs_fid_locks *fdlocks;
 279         struct cifs_tcon *tcon = tlink_tcon(tlink);
 280         struct TCP_Server_Info *server = tcon->ses->server;
 281
 282         cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 283         if (cfile == NULL)
 284                 return cfile;
 285
 286         fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
 287         if (!fdlocks) {
 288                 kfree(cfile);
 289                 return NULL;
 290         }
 291
 292         INIT_LIST_HEAD(&fdlocks->locks);
 293         fdlocks->cfile = cfile;
 294         cfile->llist = fdlocks;
 295         down_write(&cinode->lock_sem);
 296         list_add(&fdlocks->llist, &cinode->llist);
 297         up_write(&cinode->lock_sem);
 298
 299         cfile->count = 1;
 300         cfile->pid = current->tgid;
 301         cfile->uid = current_fsuid();
 302         cfile->dentry = dget(dentry);
 303         cfile->f_flags = file->f_flags;
 304         cfile->invalidHandle = false;
 305         cfile->tlink = cifs_get_tlink(tlink);
 306         INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
 307         mutex_init(&cfile->fh_mutex);
 308         spin_lock_init(&cfile->file_info_lock);
 309
 310         cifs_sb_active(inode->i_sb);
 311
 312         /*
 313          * If the server returned a read oplock and we have mandatory brlocks,
 314          * set oplock level to None.
 315          */
 316         if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
 317                 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
 318                 oplock = 0;
 319         }
 320
 321         spin_lock(&tcon->open_file_lock);
 322         if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
 323                 oplock = fid->pending_open->oplock;
 324         list_del(&fid->pending_open->olist);
 325
 326         fid->purge_cache = false;
 327         server->ops->set_fid(cfile, fid, oplock);
 328
 329         list_add(&cfile->tlist, &tcon->openFileList);
 330
 331         /* if readable file instance put first in list*/
 332         if (file->f_mode & FMODE_READ)
 333                 list_add(&cfile->flist, &cinode->openFileList);
 334         else
 335                 list_add_tail(&cfile->flist, &cinode->openFileList);
 336         spin_unlock(&tcon->open_file_lock);
 337
 338         if (fid->purge_cache)
 339                 cifs_zap_mapping(inode);
 340
 341         file->private_data = cfile;
 342         return cfile;
 343 }
 344
 345 struct cifsFileInfo *
 346 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
 347 {
 348         spin_lock(&cifs_file->file_info_lock);
 349         cifsFileInfo_get_locked(cifs_file);
 350         spin_unlock(&cifs_file->file_info_lock);
 351         return cifs_file;
 352 }
 353
 354 /*
 355  * Release a reference on the file private data. This may involve closing
 356  * the filehandle out on the server. Must be called without holding
 357  * tcon->open_file_lock and cifs_file->file_info_lock.
 358  */
 359 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 360 {
 361         struct inode *inode = d_inode(cifs_file->dentry);
 362         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 363         struct TCP_Server_Info *server = tcon->ses->server;
 364         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 365         struct super_block *sb = inode->i_sb;
 366         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 367         struct cifsLockInfo *li, *tmp;
 368         struct cifs_fid fid;
 369         struct cifs_pending_open open;
 370         bool oplock_break_cancelled;
 371
 372         spin_lock(&tcon->open_file_lock);
 373
 374         spin_lock(&cifs_file->file_info_lock);
 375         if (--cifs_file->count > 0) {
 376                 spin_unlock(&cifs_file->file_info_lock);
 377                 spin_unlock(&tcon->open_file_lock);
 378                 return;
 379         }
 380         spin_unlock(&cifs_file->file_info_lock);
 381
 382         if (server->ops->get_lease_key)
 383                 server->ops->get_lease_key(inode, &fid);
 384
 385         /* store open in pending opens to make sure we don't miss lease break */
 386         cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
 387
 388         /* remove it from the lists */
 389         list_del(&cifs_file->flist);
 390         list_del(&cifs_file->tlist);
 391
 392         if (list_empty(&cifsi->openFileList)) {
 393                 cifs_dbg(FYI, "closing last open instance for inode %p\n",
 394                          d_inode(cifs_file->dentry));
 395                 /*
 396                  * In strict cache mode we need invalidate mapping on the last
 397                  * close  because it may cause a error when we open this file
 398                  * again and get at least level II oplock.
 399                  */
 400                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 401                         set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
 402                 cifs_set_oplock_level(cifsi, 0);
 403         }
 404
 405         spin_unlock(&tcon->open_file_lock);
 406
 407         oplock_break_cancelled = cancel_work_sync(&cifs_file->oplock_break);
 408
 409         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 410                 struct TCP_Server_Info *server = tcon->ses->server;
 411                 unsigned int xid;
 412
 413                 xid = get_xid();
 414                 if (server->ops->close)
 415                         server->ops->close(xid, tcon, &cifs_file->fid);
 416                 _free_xid(xid);
 417         }
 418
 419         if (oplock_break_cancelled)
 420                 cifs_done_oplock_break(cifsi);
 421
 422         cifs_del_pending_open(&open);
 423
 424         /*
 425          * Delete any outstanding lock records. We'll lose them when the file
 426          * is closed anyway.
 427          */
 428         down_write(&cifsi->lock_sem);
 429         list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
 430                 list_del(&li->llist);
 431                 cifs_del_lock_waiters(li);
 432                 kfree(li);
 433         }
 434         list_del(&cifs_file->llist->llist);
 435         kfree(cifs_file->llist);
 436         up_write(&cifsi->lock_sem);
 437
 438         cifs_put_tlink(cifs_file->tlink);
 439         dput(cifs_file->dentry);
 440         cifs_sb_deactive(sb);
 441         kfree(cifs_file);
 442 }
 443
 444 int cifs_open(struct inode *inode, struct file *file)
 445
 446 {
 447         int rc = -EACCES;
 448         unsigned int xid;
 449         __u32 oplock;
 450         struct cifs_sb_info *cifs_sb;
 451         struct TCP_Server_Info *server;
 452         struct cifs_tcon *tcon;
 453         struct tcon_link *tlink;
 454         struct cifsFileInfo *cfile = NULL;
 455         char *full_path = NULL;
 456         bool posix_open_ok = false;
 457         struct cifs_fid fid;
 458         struct cifs_pending_open open;
 459
 460         xid = get_xid();
 461
 462         cifs_sb = CIFS_SB(inode->i_sb);
 463         tlink = cifs_sb_tlink(cifs_sb);
 464         if (IS_ERR(tlink)) {
 465                 free_xid(xid);
 466                 return PTR_ERR(tlink);
 467         }
 468         tcon = tlink_tcon(tlink);
 469         server = tcon->ses->server;
 470
 471         full_path = build_path_from_dentry(file_dentry(file));
 472         if (full_path == NULL) {
 473                 rc = -ENOMEM;
 474                 goto out;
 475         }
 476
 477         cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
 478                  inode, file->f_flags, full_path);
 479
 480         if (file->f_flags & O_DIRECT &&
 481             cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
 482                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 483                         file->f_op = &cifs_file_direct_nobrl_ops;
 484                 else
 485                         file->f_op = &cifs_file_direct_ops;
 486         }
 487
 488         if (server->oplocks)
 489                 oplock = REQ_OPLOCK;
 490         else
 491                 oplock = 0;
 492
 493         if (!tcon->broken_posix_open && tcon->unix_ext &&
 494             cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 495                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 496                 /* can not refresh inode info since size could be stale */
 497                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
 498                                 cifs_sb->mnt_file_mode /* ignored */,
 499                                 file->f_flags, &oplock, &fid.netfid, xid);
 500                 if (rc == 0) {
 501                         cifs_dbg(FYI, "posix open succeeded\n");
 502                         posix_open_ok = true;
 503                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 504                         if (tcon->ses->serverNOS)
 505                                 cifs_dbg(VFS, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
 506                                          tcon->ses->serverName,
 507                                          tcon->ses->serverNOS);
 508                         tcon->broken_posix_open = true;
 509                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
 510                          (rc != -EOPNOTSUPP)) /* path not found or net err */
 511                         goto out;
 512                 /*
 513                  * Else fallthrough to retry open the old way on network i/o
 514                  * or DFS errors.
 515                  */
 516         }
 517
 518         if (server->ops->get_lease_key)
 519                 server->ops->get_lease_key(inode, &fid);
 520
 521         cifs_add_pending_open(&fid, tlink, &open);
 522
 523         if (!posix_open_ok) {
 524                 if (server->ops->get_lease_key)
 525                         server->ops->get_lease_key(inode, &fid);
 526
 527                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
 528                                   file->f_flags, &oplock, &fid, xid);
 529                 if (rc) {
 530                         cifs_del_pending_open(&open);
 531                         goto out;
 532                 }
 533         }
 534
 535         cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
 536         if (cfile == NULL) {
 537                 if (server->ops->close)
 538                         server->ops->close(xid, tcon, &fid);
 539                 cifs_del_pending_open(&open);
 540                 rc = -ENOMEM;
 541                 goto out;
 542         }
 543
 544         cifs_fscache_set_inode_cookie(inode, file);
 545
 546         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
 547                 /*
 548                  * Time to set mode which we can not set earlier due to
 549                  * problems creating new read-only files.
 550                  */
 551                 struct cifs_unix_set_info_args args = {
 552                         .mode   = inode->i_mode,
 553                         .uid    = INVALID_UID, /* no change */
 554                         .gid    = INVALID_GID, /* no change */
 555                         .ctime  = NO_CHANGE_64,
 556                         .atime  = NO_CHANGE_64,
 557                         .mtime  = NO_CHANGE_64,
 558                         .device = 0,
 559                 };
 560                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
 561                                        cfile->pid);
 562         }
 563
 564 out:
 565         kfree(full_path);
 566         free_xid(xid);
 567         cifs_put_tlink(tlink);
 568         return rc;
 569 }
 570
 571 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
 572
 573 /*
 574  * Try to reacquire byte range locks that were released when session
 575  * to server was lost.
 576  */
 577 static int
 578 cifs_relock_file(struct cifsFileInfo *cfile)
 579 {
 580         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
 581         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 582         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 583         int rc = 0;
 584
 585         down_read(&cinode->lock_sem);
 586         if (cinode->can_cache_brlcks) {
 587                 /* can cache locks - no need to relock */
 588                 up_read(&cinode->lock_sem);
 589                 return rc;
 590         }
 591
 592         if (cap_unix(tcon->ses) &&
 593             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
 594             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
 595                 rc = cifs_push_posix_locks(cfile);
 596         else
 597                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
 598
 599         up_read(&cinode->lock_sem);
 600         return rc;
 601 }
 602
 603 static int
 604 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
 605 {
 606         int rc = -EACCES;
 607         unsigned int xid;
 608         __u32 oplock;
 609         struct cifs_sb_info *cifs_sb;
 610         struct cifs_tcon *tcon;
 611         struct TCP_Server_Info *server;
 612         struct cifsInodeInfo *cinode;
 613         struct inode *inode;
 614         char *full_path = NULL;
 615         int desired_access;
 616         int disposition = FILE_OPEN;
 617         int create_options = CREATE_NOT_DIR;
 618         struct cifs_open_parms oparms;
 619
 620         xid = get_xid();
 621         mutex_lock(&cfile->fh_mutex);
 622         if (!cfile->invalidHandle) {
 623                 mutex_unlock(&cfile->fh_mutex);
 624                 rc = 0;
 625                 free_xid(xid);
 626                 return rc;
 627         }
 628
 629         inode = d_inode(cfile->dentry);
 630         cifs_sb = CIFS_SB(inode->i_sb);
 631         tcon = tlink_tcon(cfile->tlink);
 632         server = tcon->ses->server;
 633
 634         /*
 635          * Can not grab rename sem here because various ops, including those
 636          * that already have the rename sem can end up causing writepage to get
 637          * called and if the server was down that means we end up here, and we
 638          * can never tell if the caller already has the rename_sem.
 639          */
 640         full_path = build_path_from_dentry(cfile->dentry);
 641         if (full_path == NULL) {
 642                 rc = -ENOMEM;
 643                 mutex_unlock(&cfile->fh_mutex);
 644                 free_xid(xid);
 645                 return rc;
 646         }
 647
 648         cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
 649                  inode, cfile->f_flags, full_path);
 650
 651         if (tcon->ses->server->oplocks)
 652                 oplock = REQ_OPLOCK;
 653         else
 654                 oplock = 0;
 655
 656         if (tcon->unix_ext && cap_unix(tcon->ses) &&
 657             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 658                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 659                 /*
 660                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
 661                  * original open. Must mask them off for a reopen.
 662                  */
 663                 unsigned int oflags = cfile->f_flags &
 664                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
 665
 666                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
 667                                      cifs_sb->mnt_file_mode /* ignored */,
 668                                      oflags, &oplock, &cfile->fid.netfid, xid);
 669                 if (rc == 0) {
 670                         cifs_dbg(FYI, "posix reopen succeeded\n");
 671                         oparms.reconnect = true;
 672                         goto reopen_success;
 673                 }
 674                 /*
 675                  * fallthrough to retry open the old way on errors, especially
 676                  * in the reconnect path it is important to retry hard
 677                  */
 678         }
 679
 680         desired_access = cifs_convert_flags(cfile->f_flags);
 681
 682         if (backup_cred(cifs_sb))
 683                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 684
 685         if (server->ops->get_lease_key)
 686                 server->ops->get_lease_key(inode, &cfile->fid);
 687
 688         oparms.tcon = tcon;
 689         oparms.cifs_sb = cifs_sb;
 690         oparms.desired_access = desired_access;
 691         oparms.create_options = create_options;
 692         oparms.disposition = disposition;
 693         oparms.path = full_path;
 694         oparms.fid = &cfile->fid;
 695         oparms.reconnect = true;
 696
 697         /*
 698          * Can not refresh inode by passing in file_info buf to be returned by
 699          * ops->open and then calling get_inode_info with returned buf since
 700          * file might have write behind data that needs to be flushed and server
 701          * version of file size can be stale. If we knew for sure that inode was
 702          * not dirty locally we could do this.
 703          */
 704         rc = server->ops->open(xid, &oparms, &oplock, NULL);
 705         if (rc == -ENOENT && oparms.reconnect == false) {
 706                 /* durable handle timeout is expired - open the file again */
 707                 rc = server->ops->open(xid, &oparms, &oplock, NULL);
 708                 /* indicate that we need to relock the file */
 709                 oparms.reconnect = true;
 710         }
 711
 712         if (rc) {
 713                 mutex_unlock(&cfile->fh_mutex);
 714                 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
 715                 cifs_dbg(FYI, "oplock: %d\n", oplock);
 716                 goto reopen_error_exit;
 717         }
 718
 719 reopen_success:
 720         cfile->invalidHandle = false;
 721         mutex_unlock(&cfile->fh_mutex);
 722         cinode = CIFS_I(inode);
 723
 724         if (can_flush) {
 725                 rc = filemap_write_and_wait(inode->i_mapping);
 726                 mapping_set_error(inode->i_mapping, rc);
 727
 728                 if (tcon->unix_ext)
 729                         rc = cifs_get_inode_info_unix(&inode, full_path,
 730                                                       inode->i_sb, xid);
 731                 else
 732                         rc = cifs_get_inode_info(&inode, full_path, NULL,
 733                                                  inode->i_sb, xid, NULL);
 734         }
 735         /*
 736          * Else we are writing out data to server already and could deadlock if
 737          * we tried to flush data, and since we do not know if we have data that
 738          * would invalidate the current end of file on the server we can not go
 739          * to the server to get the new inode info.
 740          */
 741
 742         server->ops->set_fid(cfile, &cfile->fid, oplock);
 743         if (oparms.reconnect)
 744                 cifs_relock_file(cfile);
 745
 746 reopen_error_exit:
 747         kfree(full_path);
 748         free_xid(xid);
 749         return rc;
 750 }
 751
 752 int cifs_close(struct inode *inode, struct file *file)
 753 {
 754         if (file->private_data != NULL) {
 755                 cifsFileInfo_put(file->private_data);
 756                 file->private_data = NULL;
 757         }
 758
 759         /* return code from the ->release op is always ignored */
 760         return 0;
 761 }
 762
 763 void
 764 cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
 765 {
 766         struct cifsFileInfo *open_file = NULL;
 767         struct list_head *tmp;
 768         struct list_head *tmp1;
 769
 770         /* list all files open on tree connection, reopen resilient handles  */
 771         spin_lock(&tcon->open_file_lock);
 772         list_for_each_safe(tmp, tmp1, &tcon->openFileList) {
 773                 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
 774                 spin_unlock(&tcon->open_file_lock);
 775                 cifs_reopen_file(open_file, false /* do not flush */);
 776                 spin_lock(&tcon->open_file_lock);
 777         }
 778         spin_unlock(&tcon->open_file_lock);
 779 }
 780
 781 int cifs_closedir(struct inode *inode, struct file *file)
 782 {
 783         int rc = 0;
 784         unsigned int xid;
 785         struct cifsFileInfo *cfile = file->private_data;
 786         struct cifs_tcon *tcon;
 787         struct TCP_Server_Info *server;
 788         char *buf;
 789
 790         cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
 791
 792         if (cfile == NULL)
 793                 return rc;
 794
 795         xid = get_xid();
 796         tcon = tlink_tcon(cfile->tlink);
 797         server = tcon->ses->server;
 798
 799         cifs_dbg(FYI, "Freeing private data in close dir\n");
 800         spin_lock(&cfile->file_info_lock);
 801         if (server->ops->dir_needs_close(cfile)) {
 802                 cfile->invalidHandle = true;
 803                 spin_unlock(&cfile->file_info_lock);
 804                 if (server->ops->close_dir)
 805                         rc = server->ops->close_dir(xid, tcon, &cfile->fid);
 806                 else
 807                         rc = -ENOSYS;
 808                 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
 809                 /* not much we can do if it fails anyway, ignore rc */
 810                 rc = 0;
 811         } else
 812                 spin_unlock(&cfile->file_info_lock);
 813
 814         buf = cfile->srch_inf.ntwrk_buf_start;
 815         if (buf) {
 816                 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
 817                 cfile->srch_inf.ntwrk_buf_start = NULL;
 818                 if (cfile->srch_inf.smallBuf)
 819                         cifs_small_buf_release(buf);
 820                 else
 821                         cifs_buf_release(buf);
 822         }
 823
 824         cifs_put_tlink(cfile->tlink);
 825         kfree(file->private_data);
 826         file->private_data = NULL;
 827         /* BB can we lock the filestruct while this is going on? */
 828         free_xid(xid);
 829         return rc;
 830 }
 831
 832 static struct cifsLockInfo *
 833 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
 834 {
 835         struct cifsLockInfo *lock =
 836                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 837         if (!lock)
 838                 return lock;
 839         lock->offset = offset;
 840         lock->length = length;
 841         lock->type = type;
 842         lock->pid = current->tgid;
 843         INIT_LIST_HEAD(&lock->blist);
 844         init_waitqueue_head(&lock->block_q);
 845         return lock;
 846 }
 847
 848 void
 849 cifs_del_lock_waiters(struct cifsLockInfo *lock)
 850 {
 851         struct cifsLockInfo *li, *tmp;
 852         list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
 853                 list_del_init(&li->blist);
 854                 wake_up(&li->block_q);
 855         }
 856 }
 857
 858 #define CIFS_LOCK_OP    0
 859 #define CIFS_READ_OP    1
 860 #define CIFS_WRITE_OP   2
 861
 862 /* @rw_check : 0 - no op, 1 - read, 2 - write */
 863 static bool
 864 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
 865                             __u64 length, __u8 type, struct cifsFileInfo *cfile,
 866                             struct cifsLockInfo **conf_lock, int rw_check)
 867 {
 868         struct cifsLockInfo *li;
 869         struct cifsFileInfo *cur_cfile = fdlocks->cfile;
 870         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
 871
 872         list_for_each_entry(li, &fdlocks->locks, llist) {
 873                 if (offset + length <= li->offset ||
 874                     offset >= li->offset + li->length)
 875                         continue;
 876                 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
 877                     server->ops->compare_fids(cfile, cur_cfile)) {
 878                         /* shared lock prevents write op through the same fid */
 879                         if (!(li->type & server->vals->shared_lock_type) ||
 880                             rw_check != CIFS_WRITE_OP)
 881                                 continue;
 882                 }
 883                 if ((type & server->vals->shared_lock_type) &&
 884                     ((server->ops->compare_fids(cfile, cur_cfile) &&
 885                      current->tgid == li->pid) || type == li->type))
 886                         continue;
 887                 if (conf_lock)
 888                         *conf_lock = li;
 889                 return true;
 890         }
 891         return false;
 892 }
 893
 894 bool
 895 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 896                         __u8 type, struct cifsLockInfo **conf_lock,
 897                         int rw_check)
 898 {
 899         bool rc = false;
 900         struct cifs_fid_locks *cur;
 901         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 902
 903         list_for_each_entry(cur, &cinode->llist, llist) {
 904                 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
 905                                                  cfile, conf_lock, rw_check);
 906                 if (rc)
 907                         break;
 908         }
 909
 910         return rc;
 911 }
 912
 913 /*
 914  * Check if there is another lock that prevents us to set the lock (mandatory
 915  * style). If such a lock exists, update the flock structure with its
 916  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 917  * or leave it the same if we can't. Returns 0 if we don't need to request to
 918  * the server or 1 otherwise.
 919  */
 920 static int
 921 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 922                __u8 type, struct file_lock *flock)
 923 {
 924         int rc = 0;
 925         struct cifsLockInfo *conf_lock;
 926         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 927         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
 928         bool exist;
 929
 930         down_read(&cinode->lock_sem);
 931
 932         exist = cifs_find_lock_conflict(cfile, offset, length, type,
 933                                         &conf_lock, CIFS_LOCK_OP);
 934         if (exist) {
 935                 flock->fl_start = conf_lock->offset;
 936                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
 937                 flock->fl_pid = conf_lock->pid;
 938                 if (conf_lock->type & server->vals->shared_lock_type)
 939                         flock->fl_type = F_RDLCK;
 940                 else
 941                         flock->fl_type = F_WRLCK;
 942         } else if (!cinode->can_cache_brlcks)
 943                 rc = 1;
 944         else
 945                 flock->fl_type = F_UNLCK;
 946
 947         up_read(&cinode->lock_sem);
 948         return rc;
 949 }
 950
 951 static void
 952 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
 953 {
 954         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 955         down_write(&cinode->lock_sem);
 956         list_add_tail(&lock->llist, &cfile->llist->locks);
 957         up_write(&cinode->lock_sem);
 958 }
 959
 960 /*
 961  * Set the byte-range lock (mandatory style). Returns:
 962  * 1) 0, if we set the lock and don't need to request to the server;
 963  * 2) 1, if no locks prevent us but we need to request to the server;
 964  * 3) -EACCESS, if there is a lock that prevents us and wait is false.
 965  */
 966 static int
 967 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
 968                  bool wait)
 969 {
 970         struct cifsLockInfo *conf_lock;
 971         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 972         bool exist;
 973         int rc = 0;
 974
 975 try_again:
 976         exist = false;
 977         down_write(&cinode->lock_sem);
 978
 979         exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
 980                                         lock->type, &conf_lock, CIFS_LOCK_OP);
 981         if (!exist && cinode->can_cache_brlcks) {
 982                 list_add_tail(&lock->llist, &cfile->llist->locks);
 983                 up_write(&cinode->lock_sem);
 984                 return rc;
 985         }
 986
 987         if (!exist)
 988                 rc = 1;
 989         else if (!wait)
 990                 rc = -EACCES;
 991         else {
 992                 list_add_tail(&lock->blist, &conf_lock->blist);
 993                 up_write(&cinode->lock_sem);
 994                 rc = wait_event_interruptible(lock->block_q,
 995                                         (lock->blist.prev == &lock->blist) &&
 996                                         (lock->blist.next == &lock->blist));
 997                 if (!rc)
 998                         goto try_again;
 999                 down_write(&cinode->lock_sem);
1000                 list_del_init(&lock->blist);
1001         }
1002
1003         up_write(&cinode->lock_sem);
1004         return rc;
1005 }
1006
1007 /*
1008  * Check if there is another lock that prevents us to set the lock (posix
1009  * style). If such a lock exists, update the flock structure with its
1010  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1011  * or leave it the same if we can't. Returns 0 if we don't need to request to
1012  * the server or 1 otherwise.
1013  */
1014 static int
1015 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1016 {
1017         int rc = 0;
1018         struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1019         unsigned char saved_type = flock->fl_type;
1020
1021         if ((flock->fl_flags & FL_POSIX) == 0)
1022                 return 1;
1023
1024         down_read(&cinode->lock_sem);
1025         posix_test_lock(file, flock);
1026
1027         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1028                 flock->fl_type = saved_type;
1029                 rc = 1;
1030         }
1031
1032         up_read(&cinode->lock_sem);
1033         return rc;
1034 }
1035
1036 /*
1037  * Set the byte-range lock (posix style). Returns:
1038  * 1) 0, if we set the lock and don't need to request to the server;
1039  * 2) 1, if we need to request to the server;
1040  * 3) <0, if the error occurs while setting the lock.
1041  */
1042 static int
1043 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1044 {
1045         struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1046         int rc = 1;
1047
1048         if ((flock->fl_flags & FL_POSIX) == 0)
1049                 return rc;
1050
1051 try_again:
1052         down_write(&cinode->lock_sem);
1053         if (!cinode->can_cache_brlcks) {
1054                 up_write(&cinode->lock_sem);
1055                 return rc;
1056         }
1057
1058         rc = posix_lock_file(file, flock, NULL);
1059         up_write(&cinode->lock_sem);
1060         if (rc == FILE_LOCK_DEFERRED) {
1061                 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
1062                 if (!rc)
1063                         goto try_again;
1064                 posix_unblock_lock(flock);
1065         }
1066         return rc;
1067 }
1068
1069 int
1070 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1071 {
1072         unsigned int xid;
1073         int rc = 0, stored_rc;
1074         struct cifsLockInfo *li, *tmp;
1075         struct cifs_tcon *tcon;
1076         unsigned int num, max_num, max_buf;
1077         LOCKING_ANDX_RANGE *buf, *cur;
1078         int types[] = {LOCKING_ANDX_LARGE_FILES,
1079                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1080         int i;
1081
1082         xid = get_xid();
1083         tcon = tlink_tcon(cfile->tlink);
1084
1085         /*
1086          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1087          * and check it for zero before using.
1088          */
1089         max_buf = tcon->ses->server->maxBuf;
1090         if (!max_buf) {
1091                 free_xid(xid);
1092                 return -EINVAL;
1093         }
1094
1095         max_num = (max_buf - sizeof(struct smb_hdr)) /
1096                                                 sizeof(LOCKING_ANDX_RANGE);
1097         buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1098         if (!buf) {
1099                 free_xid(xid);
1100                 return -ENOMEM;
1101         }
1102
1103         for (i = 0; i < 2; i++) {
1104                 cur = buf;
1105                 num = 0;
1106                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1107                         if (li->type != types[i])
1108                                 continue;
1109                         cur->Pid = cpu_to_le16(li->pid);
1110                         cur->LengthLow = cpu_to_le32((u32)li->length);
1111                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1112                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1113                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1114                         if (++num == max_num) {
1115                                 stored_rc = cifs_lockv(xid, tcon,
1116                                                        cfile->fid.netfid,
1117                                                        (__u8)li->type, 0, num,
1118                                                        buf);
1119                                 if (stored_rc)
1120                                         rc = stored_rc;
1121                                 cur = buf;
1122                                 num = 0;
1123                         } else
1124                                 cur++;
1125                 }
1126
1127                 if (num) {
1128                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1129                                                (__u8)types[i], 0, num, buf);
1130                         if (stored_rc)
1131                                 rc = stored_rc;
1132                 }
1133         }
1134
1135         kfree(buf);
1136         free_xid(xid);
1137         return rc;
1138 }
1139
1140 static __u32
1141 hash_lockowner(fl_owner_t owner)
1142 {
1143         return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1144 }
1145
1146 struct lock_to_push {
1147         struct list_head llist;
1148         __u64 offset;
1149         __u64 length;
1150         __u32 pid;
1151         __u16 netfid;
1152         __u8 type;
1153 };
1154
1155 static int
1156 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1157 {
1158         struct inode *inode = d_inode(cfile->dentry);
1159         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1160         struct file_lock *flock;
1161         struct file_lock_context *flctx = inode->i_flctx;
1162         unsigned int count = 0, i;
1163         int rc = 0, xid, type;
1164         struct list_head locks_to_send, *el;
1165         struct lock_to_push *lck, *tmp;
1166         __u64 length;
1167
1168         xid = get_xid();
1169
1170         if (!flctx)
1171                 goto out;
1172
1173         spin_lock(&flctx->flc_lock);
1174         list_for_each(el, &flctx->flc_posix) {
1175                 count++;
1176         }
1177         spin_unlock(&flctx->flc_lock);
1178
1179         INIT_LIST_HEAD(&locks_to_send);
1180
1181         /*
1182          * Allocating count locks is enough because no FL_POSIX locks can be
1183          * added to the list while we are holding cinode->lock_sem that
1184          * protects locking operations of this inode.
1185          */
1186         for (i = 0; i < count; i++) {
1187                 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1188                 if (!lck) {
1189                         rc = -ENOMEM;
1190                         goto err_out;
1191                 }
1192                 list_add_tail(&lck->llist, &locks_to_send);
1193         }
1194
1195         el = locks_to_send.next;
1196         spin_lock(&flctx->flc_lock);
1197         list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1198                 if (el == &locks_to_send) {
1199                         /*
1200                          * The list ended. We don't have enough allocated
1201                          * structures - something is really wrong.
1202                          */
1203                         cifs_dbg(VFS, "Can't push all brlocks!\n");
1204                         break;
1205                 }
1206                 length = 1 + flock->fl_end - flock->fl_start;
1207                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1208                         type = CIFS_RDLCK;
1209                 else
1210                         type = CIFS_WRLCK;
1211                 lck = list_entry(el, struct lock_to_push, llist);
1212                 lck->pid = hash_lockowner(flock->fl_owner);
1213                 lck->netfid = cfile->fid.netfid;
1214                 lck->length = length;
1215                 lck->type = type;
1216                 lck->offset = flock->fl_start;
1217         }
1218         spin_unlock(&flctx->flc_lock);
1219
1220         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1221                 int stored_rc;
1222
1223                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1224                                              lck->offset, lck->length, NULL,
1225                                              lck->type, 0);
1226                 if (stored_rc)
1227                         rc = stored_rc;
1228                 list_del(&lck->llist);
1229                 kfree(lck);
1230         }
1231
1232 out:
1233         free_xid(xid);
1234         return rc;
1235 err_out:
1236         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1237                 list_del(&lck->llist);
1238                 kfree(lck);
1239         }
1240         goto out;
1241 }
1242
1243 static int
1244 cifs_push_locks(struct cifsFileInfo *cfile)
1245 {
1246         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1247         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1248         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1249         int rc = 0;
1250
1251         /* we are going to update can_cache_brlcks here - need a write access */
1252         down_write(&cinode->lock_sem);
1253         if (!cinode->can_cache_brlcks) {
1254                 up_write(&cinode->lock_sem);
1255                 return rc;
1256         }
1257
1258         if (cap_unix(tcon->ses) &&
1259             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1260             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1261                 rc = cifs_push_posix_locks(cfile);
1262         else
1263                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1264
1265         cinode->can_cache_brlcks = false;
1266         up_write(&cinode->lock_sem);
1267         return rc;
1268 }
1269
1270 static void
1271 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1272                 bool *wait_flag, struct TCP_Server_Info *server)
1273 {
1274         if (flock->fl_flags & FL_POSIX)
1275                 cifs_dbg(FYI, "Posix\n");
1276         if (flock->fl_flags & FL_FLOCK)
1277                 cifs_dbg(FYI, "Flock\n");
1278         if (flock->fl_flags & FL_SLEEP) {
1279                 cifs_dbg(FYI, "Blocking lock\n");
1280                 *wait_flag = true;
1281         }
1282         if (flock->fl_flags & FL_ACCESS)
1283                 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1284         if (flock->fl_flags & FL_LEASE)
1285                 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1286         if (flock->fl_flags &
1287             (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1288                FL_ACCESS | FL_LEASE | FL_CLOSE)))
1289                 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1290
1291         *type = server->vals->large_lock_type;
1292         if (flock->fl_type == F_WRLCK) {
1293                 cifs_dbg(FYI, "F_WRLCK\n");
1294                 *type |= server->vals->exclusive_lock_type;
1295                 *lock = 1;
1296         } else if (flock->fl_type == F_UNLCK) {
1297                 cifs_dbg(FYI, "F_UNLCK\n");
1298                 *type |= server->vals->unlock_lock_type;
1299                 *unlock = 1;
1300                 /* Check if unlock includes more than one lock range */
1301         } else if (flock->fl_type == F_RDLCK) {
1302                 cifs_dbg(FYI, "F_RDLCK\n");
1303                 *type |= server->vals->shared_lock_type;
1304                 *lock = 1;
1305         } else if (flock->fl_type == F_EXLCK) {
1306                 cifs_dbg(FYI, "F_EXLCK\n");
1307                 *type |= server->vals->exclusive_lock_type;
1308                 *lock = 1;
1309         } else if (flock->fl_type == F_SHLCK) {
1310                 cifs_dbg(FYI, "F_SHLCK\n");
1311                 *type |= server->vals->shared_lock_type;
1312                 *lock = 1;
1313         } else
1314                 cifs_dbg(FYI, "Unknown type of lock\n");
1315 }
1316
1317 static int
1318 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1319            bool wait_flag, bool posix_lck, unsigned int xid)
1320 {
1321         int rc = 0;
1322         __u64 length = 1 + flock->fl_end - flock->fl_start;
1323         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1324         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1325         struct TCP_Server_Info *server = tcon->ses->server;
1326         __u16 netfid = cfile->fid.netfid;
1327
1328         if (posix_lck) {
1329                 int posix_lock_type;
1330
1331                 rc = cifs_posix_lock_test(file, flock);
1332                 if (!rc)
1333                         return rc;
1334
1335                 if (type & server->vals->shared_lock_type)
1336                         posix_lock_type = CIFS_RDLCK;
1337                 else
1338                         posix_lock_type = CIFS_WRLCK;
1339                 rc = CIFSSMBPosixLock(xid, tcon, netfid,
1340                                       hash_lockowner(flock->fl_owner),
1341                                       flock->fl_start, length, flock,
1342                                       posix_lock_type, wait_flag);
1343                 return rc;
1344         }
1345
1346         rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1347         if (!rc)
1348                 return rc;
1349
1350         /* BB we could chain these into one lock request BB */
1351         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1352                                     1, 0, false);
1353         if (rc == 0) {
1354                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1355                                             type, 0, 1, false);
1356                 flock->fl_type = F_UNLCK;
1357                 if (rc != 0)
1358                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1359                                  rc);
1360                 return 0;
1361         }
1362
1363         if (type & server->vals->shared_lock_type) {
1364                 flock->fl_type = F_WRLCK;
1365                 return 0;
1366         }
1367
1368         type &= ~server->vals->exclusive_lock_type;
1369
1370         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1371                                     type | server->vals->shared_lock_type,
1372                                     1, 0, false);
1373         if (rc == 0) {
1374                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1375                         type | server->vals->shared_lock_type, 0, 1, false);
1376                 flock->fl_type = F_RDLCK;
1377                 if (rc != 0)
1378                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1379                                  rc);
1380         } else
1381                 flock->fl_type = F_WRLCK;
1382
1383         return 0;
1384 }
1385
1386 void
1387 cifs_move_llist(struct list_head *source, struct list_head *dest)
1388 {
1389         struct list_head *li, *tmp;
1390         list_for_each_safe(li, tmp, source)
1391                 list_move(li, dest);
1392 }
1393
1394 void
1395 cifs_free_llist(struct list_head *llist)
1396 {
1397         struct cifsLockInfo *li, *tmp;
1398         list_for_each_entry_safe(li, tmp, llist, llist) {
1399                 cifs_del_lock_waiters(li);
1400                 list_del(&li->llist);
1401                 kfree(li);
1402         }
1403 }
1404
1405 int
1406 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1407                   unsigned int xid)
1408 {
1409         int rc = 0, stored_rc;
1410         int types[] = {LOCKING_ANDX_LARGE_FILES,
1411                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1412         unsigned int i;
1413         unsigned int max_num, num, max_buf;
1414         LOCKING_ANDX_RANGE *buf, *cur;
1415         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1416         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1417         struct cifsLockInfo *li, *tmp;
1418         __u64 length = 1 + flock->fl_end - flock->fl_start;
1419         struct list_head tmp_llist;
1420
1421         INIT_LIST_HEAD(&tmp_llist);
1422
1423         /*
1424          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1425          * and check it for zero before using.
1426          */
1427         max_buf = tcon->ses->server->maxBuf;
1428         if (!max_buf)
1429                 return -EINVAL;
1430
1431         max_num = (max_buf - sizeof(struct smb_hdr)) /
1432                                                 sizeof(LOCKING_ANDX_RANGE);
1433         buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1434         if (!buf)
1435                 return -ENOMEM;
1436
1437         down_write(&cinode->lock_sem);
1438         for (i = 0; i < 2; i++) {
1439                 cur = buf;
1440                 num = 0;
1441                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1442                         if (flock->fl_start > li->offset ||
1443                             (flock->fl_start + length) <
1444                             (li->offset + li->length))
1445                                 continue;
1446                         if (current->tgid != li->pid)
1447                                 continue;
1448                         if (types[i] != li->type)
1449                                 continue;
1450                         if (cinode->can_cache_brlcks) {
1451                                 /*
1452                                  * We can cache brlock requests - simply remove
1453                                  * a lock from the file's list.
1454                                  */
1455                                 list_del(&li->llist);
1456                                 cifs_del_lock_waiters(li);
1457                                 kfree(li);
1458                                 continue;
1459                         }
1460                         cur->Pid = cpu_to_le16(li->pid);
1461                         cur->LengthLow = cpu_to_le32((u32)li->length);
1462                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1463                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1464                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1465                         /*
1466                          * We need to save a lock here to let us add it again to
1467                          * the file's list if the unlock range request fails on
1468                          * the server.
1469                          */
1470                         list_move(&li->llist, &tmp_llist);
1471                         if (++num == max_num) {
1472                                 stored_rc = cifs_lockv(xid, tcon,
1473                                                        cfile->fid.netfid,
1474                                                        li->type, num, 0, buf);
1475                                 if (stored_rc) {
1476                                         /*
1477                                          * We failed on the unlock range
1478                                          * request - add all locks from the tmp
1479                                          * list to the head of the file's list.
1480                                          */
1481                                         cifs_move_llist(&tmp_llist,
1482                                                         &cfile->llist->locks);
1483                                         rc = stored_rc;
1484                                 } else
1485                                         /*
1486                                          * The unlock range request succeed -
1487                                          * free the tmp list.
1488                                          */
1489                                         cifs_free_llist(&tmp_llist);
1490                                 cur = buf;
1491                                 num = 0;
1492                         } else
1493                                 cur++;
1494                 }
1495                 if (num) {
1496                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1497                                                types[i], num, 0, buf);
1498                         if (stored_rc) {
1499                                 cifs_move_llist(&tmp_llist,
1500                                                 &cfile->llist->locks);
1501                                 rc = stored_rc;
1502                         } else
1503                                 cifs_free_llist(&tmp_llist);
1504                 }
1505         }
1506
1507         up_write(&cinode->lock_sem);
1508         kfree(buf);
1509         return rc;
1510 }
1511
1512 static int
1513 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1514            bool wait_flag, bool posix_lck, int lock, int unlock,
1515            unsigned int xid)
1516 {
1517         int rc = 0;
1518         __u64 length = 1 + flock->fl_end - flock->fl_start;
1519         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1520         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1521         struct TCP_Server_Info *server = tcon->ses->server;
1522         struct inode *inode = d_inode(cfile->dentry);
1523
1524         if (posix_lck) {
1525                 int posix_lock_type;
1526
1527                 rc = cifs_posix_lock_set(file, flock);
1528                 if (!rc || rc < 0)
1529                         return rc;
1530
1531                 if (type & server->vals->shared_lock_type)
1532                         posix_lock_type = CIFS_RDLCK;
1533                 else
1534                         posix_lock_type = CIFS_WRLCK;
1535
1536                 if (unlock == 1)
1537                         posix_lock_type = CIFS_UNLCK;
1538
1539                 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1540                                       hash_lockowner(flock->fl_owner),
1541                                       flock->fl_start, length,
1542                                       NULL, posix_lock_type, wait_flag);
1543                 goto out;
1544         }
1545
1546         if (lock) {
1547                 struct cifsLockInfo *lock;
1548
1549                 lock = cifs_lock_init(flock->fl_start, length, type);
1550                 if (!lock)
1551                         return -ENOMEM;
1552
1553                 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1554                 if (rc < 0) {
1555                         kfree(lock);
1556                         return rc;
1557                 }
1558                 if (!rc)
1559                         goto out;
1560
1561                 /*
1562                  * Windows 7 server can delay breaking lease from read to None
1563                  * if we set a byte-range lock on a file - break it explicitly
1564                  * before sending the lock to the server to be sure the next
1565                  * read won't conflict with non-overlapted locks due to
1566                  * pagereading.
1567                  */
1568                 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1569                                         CIFS_CACHE_READ(CIFS_I(inode))) {
1570                         cifs_zap_mapping(inode);
1571                         cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1572                                  inode);
1573                         CIFS_I(inode)->oplock = 0;
1574                 }
1575
1576                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1577                                             type, 1, 0, wait_flag);
1578                 if (rc) {
1579                         kfree(lock);
1580                         return rc;
1581                 }
1582
1583                 cifs_lock_add(cfile, lock);
1584         } else if (unlock)
1585                 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1586
1587 out:
1588         if (flock->fl_flags & FL_POSIX && !rc)
1589                 rc = locks_lock_file_wait(file, flock);
1590         return rc;
1591 }
1592
1593 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1594 {
1595         int rc, xid;
1596         int lock = 0, unlock = 0;
1597         bool wait_flag = false;
1598         bool posix_lck = false;
1599         struct cifs_sb_info *cifs_sb;
1600         struct cifs_tcon *tcon;
1601         struct cifsInodeInfo *cinode;
1602         struct cifsFileInfo *cfile;
1603         __u16 netfid;
1604         __u32 type;
1605
1606         rc = -EACCES;
1607         xid = get_xid();
1608
1609         cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1610                  cmd, flock->fl_flags, flock->fl_type,
1611                  flock->fl_start, flock->fl_end);
1612
1613         cfile = (struct cifsFileInfo *)file->private_data;
1614         tcon = tlink_tcon(cfile->tlink);
1615
1616         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1617                         tcon->ses->server);
1618
1619         cifs_sb = CIFS_FILE_SB(file);
1620         netfid = cfile->fid.netfid;
1621         cinode = CIFS_I(file_inode(file));
1622
1623         if (cap_unix(tcon->ses) &&
1624             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1625             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1626                 posix_lck = true;
1627         /*
1628          * BB add code here to normalize offset and length to account for
1629          * negative length which we can not accept over the wire.
1630          */
1631         if (IS_GETLK(cmd)) {
1632                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1633                 free_xid(xid);
1634                 return rc;
1635         }
1636
1637         if (!lock && !unlock) {
1638                 /*
1639                  * if no lock or unlock then nothing to do since we do not
1640                  * know what it is
1641                  */
1642                 free_xid(xid);
1643                 return -EOPNOTSUPP;
1644         }
1645
1646         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1647                         xid);
1648         free_xid(xid);
1649         return rc;
1650 }
1651
1652 /*
1653  * update the file size (if needed) after a write. Should be called with
1654  * the inode->i_lock held
1655  */
1656 void
1657 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1658                       unsigned int bytes_written)
1659 {
1660         loff_t end_of_write = offset + bytes_written;
1661
1662         if (end_of_write > cifsi->server_eof)
1663                 cifsi->server_eof = end_of_write;
1664 }
1665
1666 static ssize_t
1667 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1668            size_t write_size, loff_t *offset)
1669 {
1670         int rc = 0;
1671         unsigned int bytes_written = 0;
1672         unsigned int total_written;
1673         struct cifs_sb_info *cifs_sb;
1674         struct cifs_tcon *tcon;
1675         struct TCP_Server_Info *server;
1676         unsigned int xid;
1677         struct dentry *dentry = open_file->dentry;
1678         struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1679         struct cifs_io_parms io_parms;
1680
1681         cifs_sb = CIFS_SB(dentry->d_sb);
1682
1683         cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1684                  write_size, *offset, dentry);
1685
1686         tcon = tlink_tcon(open_file->tlink);
1687         server = tcon->ses->server;
1688
1689         if (!server->ops->sync_write)
1690                 return -ENOSYS;
1691
1692         xid = get_xid();
1693
1694         for (total_written = 0; write_size > total_written;
1695              total_written += bytes_written) {
1696                 rc = -EAGAIN;
1697                 while (rc == -EAGAIN) {
1698                         struct kvec iov[2];
1699                         unsigned int len;
1700
1701                         if (open_file->invalidHandle) {
1702                                 /* we could deadlock if we called
1703                                    filemap_fdatawait from here so tell
1704                                    reopen_file not to flush data to
1705                                    server now */
1706                                 rc = cifs_reopen_file(open_file, false);
1707                                 if (rc != 0)
1708                                         break;
1709                         }
1710
1711                         len = min(server->ops->wp_retry_size(d_inode(dentry)),
1712                                   (unsigned int)write_size - total_written);
1713                         /* iov[0] is reserved for smb header */
1714                         iov[1].iov_base = (char *)write_data + total_written;
1715                         iov[1].iov_len = len;
1716                         io_parms.pid = pid;
1717                         io_parms.tcon = tcon;
1718                         io_parms.offset = *offset;
1719                         io_parms.length = len;
1720                         rc = server->ops->sync_write(xid, &open_file->fid,
1721                                         &io_parms, &bytes_written, iov, 1);
1722                 }
1723                 if (rc || (bytes_written == 0)) {
1724                         if (total_written)
1725                                 break;
1726                         else {
1727                                 free_xid(xid);
1728                                 return rc;
1729                         }
1730                 } else {
1731                         spin_lock(&d_inode(dentry)->i_lock);
1732                         cifs_update_eof(cifsi, *offset, bytes_written);
1733                         spin_unlock(&d_inode(dentry)->i_lock);
1734                         *offset += bytes_written;
1735                 }
1736         }
1737
1738         cifs_stats_bytes_written(tcon, total_written);
1739
1740         if (total_written > 0) {
1741                 spin_lock(&d_inode(dentry)->i_lock);
1742                 if (*offset > d_inode(dentry)->i_size)
1743                         i_size_write(d_inode(dentry), *offset);
1744                 spin_unlock(&d_inode(dentry)->i_lock);
1745         }
1746         mark_inode_dirty_sync(d_inode(dentry));
1747         free_xid(xid);
1748         return total_written;
1749 }
1750
1751 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1752                                         bool fsuid_only)
1753 {
1754         struct cifsFileInfo *open_file = NULL;
1755         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1756         struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1757
1758         /* only filter by fsuid on multiuser mounts */
1759         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1760                 fsuid_only = false;
1761
1762         spin_lock(&tcon->open_file_lock);
1763         /* we could simply get the first_list_entry since write-only entries
1764            are always at the end of the list but since the first entry might
1765            have a close pending, we go through the whole list */
1766         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1767                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1768                         continue;
1769                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1770                         if (!open_file->invalidHandle) {
1771                                 /* found a good file */
1772                                 /* lock it so it will not be closed on us */
1773                                 cifsFileInfo_get(open_file);
1774                                 spin_unlock(&tcon->open_file_lock);
1775                                 return open_file;
1776                         } /* else might as well continue, and look for
1777                              another, or simply have the caller reopen it
1778                              again rather than trying to fix this handle */
1779                 } else /* write only file */
1780                         break; /* write only files are last so must be done */
1781         }
1782         spin_unlock(&tcon->open_file_lock);
1783         return NULL;
1784 }
1785
1786 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1787                                         bool fsuid_only)
1788 {
1789         struct cifsFileInfo *open_file, *inv_file = NULL;
1790         struct cifs_sb_info *cifs_sb;
1791         struct cifs_tcon *tcon;
1792         bool any_available = false;
1793         int rc;
1794         unsigned int refind = 0;
1795
1796         /* Having a null inode here (because mapping->host was set to zero by
1797         the VFS or MM) should not happen but we had reports of on oops (due to
1798         it being zero) during stress testcases so we need to check for it */
1799
1800         if (cifs_inode == NULL) {
1801                 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1802                 dump_stack();
1803                 return NULL;
1804         }
1805
1806         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1807         tcon = cifs_sb_master_tcon(cifs_sb);
1808
1809         /* only filter by fsuid on multiuser mounts */
1810         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1811                 fsuid_only = false;
1812
1813         spin_lock(&tcon->open_file_lock);
1814 refind_writable:
1815         if (refind > MAX_REOPEN_ATT) {
1816                 spin_unlock(&tcon->open_file_lock);
1817                 return NULL;
1818         }
1819         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1820                 if (!any_available && open_file->pid != current->tgid)
1821                         continue;
1822                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1823                         continue;
1824                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1825                         if (!open_file->invalidHandle) {
1826                                 /* found a good writable file */
1827                                 cifsFileInfo_get(open_file);
1828                                 spin_unlock(&tcon->open_file_lock);
1829                                 return open_file;
1830                         } else {
1831                                 if (!inv_file)
1832                                         inv_file = open_file;
1833                         }
1834                 }
1835         }
1836         /* couldn't find useable FH with same pid, try any available */
1837         if (!any_available) {
1838                 any_available = true;
1839                 goto refind_writable;
1840         }
1841
1842         if (inv_file) {
1843                 any_available = false;
1844                 cifsFileInfo_get(inv_file);
1845         }
1846
1847         spin_unlock(&tcon->open_file_lock);
1848
1849         if (inv_file) {
1850                 rc = cifs_reopen_file(inv_file, false);
1851                 if (!rc)
1852                         return inv_file;
1853                 else {
1854                         spin_lock(&tcon->open_file_lock);
1855                         list_move_tail(&inv_file->flist,
1856                                         &cifs_inode->openFileList);
1857                         spin_unlock(&tcon->open_file_lock);
1858                         cifsFileInfo_put(inv_file);
1859                         ++refind;
1860                         inv_file = NULL;
1861                         spin_lock(&tcon->open_file_lock);
1862                         goto refind_writable;
1863                 }
1864         }
1865
1866         return NULL;
1867 }
1868
1869 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1870 {
1871         struct address_space *mapping = page->mapping;
1872         loff_t offset = (loff_t)page->index << PAGE_SHIFT;
1873         char *write_data;
1874         int rc = -EFAULT;
1875         int bytes_written = 0;
1876         struct inode *inode;
1877         struct cifsFileInfo *open_file;
1878
1879         if (!mapping || !mapping->host)
1880                 return -EFAULT;
1881
1882         inode = page->mapping->host;
1883
1884         offset += (loff_t)from;
1885         write_data = kmap(page);
1886         write_data += from;
1887
1888         if ((to > PAGE_SIZE) || (from > to)) {
1889                 kunmap(page);
1890                 return -EIO;
1891         }
1892
1893         /* racing with truncate? */
1894         if (offset > mapping->host->i_size) {
1895                 kunmap(page);
1896                 return 0; /* don't care */
1897         }
1898
1899         /* check to make sure that we are not extending the file */
1900         if (mapping->host->i_size - offset < (loff_t)to)
1901                 to = (unsigned)(mapping->host->i_size - offset);
1902
1903         open_file = find_writable_file(CIFS_I(mapping->host), false);
1904         if (open_file) {
1905                 bytes_written = cifs_write(open_file, open_file->pid,
1906                                            write_data, to - from, &offset);
1907                 cifsFileInfo_put(open_file);
1908                 /* Does mm or vfs already set times? */
1909                 inode->i_atime = inode->i_mtime = current_time(inode);
1910                 if ((bytes_written > 0) && (offset))
1911                         rc = 0;
1912                 else if (bytes_written < 0)
1913                         rc = bytes_written;
1914         } else {
1915                 cifs_dbg(FYI, "No writeable filehandles for inode\n");
1916                 rc = -EIO;
1917         }
1918
1919         kunmap(page);
1920         return rc;
1921 }
1922
1923 static struct cifs_writedata *
1924 wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
1925                           pgoff_t end, pgoff_t *index,
1926                           unsigned int *found_pages)
1927 {
1928         unsigned int nr_pages;
1929         struct page **pages;
1930         struct cifs_writedata *wdata;
1931
1932         wdata = cifs_writedata_alloc((unsigned int)tofind,
1933                                      cifs_writev_complete);
1934         if (!wdata)
1935                 return NULL;
1936
1937         /*
1938          * find_get_pages_tag seems to return a max of 256 on each
1939          * iteration, so we must call it several times in order to
1940          * fill the array or the wsize is effectively limited to
1941          * 256 * PAGE_SIZE.
1942          */
1943         *found_pages = 0;
1944         pages = wdata->pages;
1945         do {
1946                 nr_pages = find_get_pages_tag(mapping, index,
1947                                               PAGECACHE_TAG_DIRTY, tofind,
1948                                               pages);
1949                 *found_pages += nr_pages;
1950                 tofind -= nr_pages;
1951                 pages += nr_pages;
1952         } while (nr_pages && tofind && *index <= end);
1953
1954         return wdata;
1955 }
1956
1957 static unsigned int
1958 wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
1959                     struct address_space *mapping,
1960                     struct writeback_control *wbc,
1961                     pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
1962 {
1963         unsigned int nr_pages = 0, i;
1964         struct page *page;
1965
1966         for (i = 0; i < found_pages; i++) {
1967                 page = wdata->pages[i];
1968                 /*
1969                  * At this point we hold neither mapping->tree_lock nor
1970                  * lock on the page itself: the page may be truncated or
1971                  * invalidated (changing page->mapping to NULL), or even
1972                  * swizzled back from swapper_space to tmpfs file
1973                  * mapping
1974                  */
1975
1976                 if (nr_pages == 0)
1977                         lock_page(page);
1978                 else if (!trylock_page(page))
1979                         break;
1980
1981                 if (unlikely(page->mapping != mapping)) {
1982                         unlock_page(page);
1983                         break;
1984                 }
1985
1986                 if (!wbc->range_cyclic && page->index > end) {
1987                         *done = true;
1988                         unlock_page(page);
1989                         break;
1990                 }
1991
1992                 if (*next && (page->index != *next)) {
1993                         /* Not next consecutive page */
1994                         unlock_page(page);
1995                         break;
1996                 }
1997
1998                 if (wbc->sync_mode != WB_SYNC_NONE)
1999                         wait_on_page_writeback(page);
2000
2001                 if (PageWriteback(page) ||
2002                                 !clear_page_dirty_for_io(page)) {
2003                         unlock_page(page);
2004                         break;
2005                 }
2006
2007                 /*
2008                  * This actually clears the dirty bit in the radix tree.
2009                  * See cifs_writepage() for more commentary.
2010                  */
2011                 set_page_writeback(page);
2012                 if (page_offset(page) >= i_size_read(mapping->host)) {
2013                         *done = true;
2014                         unlock_page(page);
2015                         end_page_writeback(page);
2016                         break;
2017                 }
2018
2019                 wdata->pages[i] = page;
2020                 *next = page->index + 1;
2021                 ++nr_pages;
2022         }
2023
2024         /* reset index to refind any pages skipped */
2025         if (nr_pages == 0)
2026                 *index = wdata->pages[0]->index + 1;
2027
2028         /* put any pages we aren't going to use */
2029         for (i = nr_pages; i < found_pages; i++) {
2030                 put_page(wdata->pages[i]);
2031                 wdata->pages[i] = NULL;
2032         }
2033
2034         return nr_pages;
2035 }
2036
2037 static int
2038 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2039                  struct address_space *mapping, struct writeback_control *wbc)
2040 {
2041         int rc = 0;
2042         struct TCP_Server_Info *server;
2043         unsigned int i;
2044
2045         wdata->sync_mode = wbc->sync_mode;
2046         wdata->nr_pages = nr_pages;
2047         wdata->offset = page_offset(wdata->pages[0]);
2048         wdata->pagesz = PAGE_SIZE;
2049         wdata->tailsz = min(i_size_read(mapping->host) -
2050                         page_offset(wdata->pages[nr_pages - 1]),
2051                         (loff_t)PAGE_SIZE);
2052         wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2053
2054         if (wdata->cfile != NULL)
2055                 cifsFileInfo_put(wdata->cfile);
2056         wdata->cfile = find_writable_file(CIFS_I(mapping->host), false);
2057         if (!wdata->cfile) {
2058                 cifs_dbg(VFS, "No writable handles for inode\n");
2059                 rc = -EBADF;
2060         } else {
2061                 wdata->pid = wdata->cfile->pid;
2062                 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2063                 rc = server->ops->async_writev(wdata, cifs_writedata_release);
2064         }
2065
2066         for (i = 0; i < nr_pages; ++i)
2067                 unlock_page(wdata->pages[i]);
2068
2069         return rc;
2070 }
2071
2072 static int cifs_writepages(struct address_space *mapping,
2073                            struct writeback_control *wbc)
2074 {
2075         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
2076         struct TCP_Server_Info *server;
2077         bool done = false, scanned = false, range_whole = false;
2078         pgoff_t end, index;
2079         struct cifs_writedata *wdata;
2080         int rc = 0;
2081
2082         /*
2083          * If wsize is smaller than the page cache size, default to writing
2084          * one page at a time via cifs_writepage
2085          */
2086         if (cifs_sb->wsize < PAGE_SIZE)
2087                 return generic_writepages(mapping, wbc);
2088
2089         if (wbc->range_cyclic) {
2090                 index = mapping->writeback_index; /* Start from prev offset */
2091                 end = -1;
2092         } else {
2093                 index = wbc->range_start >> PAGE_SHIFT;
2094                 end = wbc->range_end >> PAGE_SHIFT;
2095                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2096                         range_whole = true;
2097                 scanned = true;
2098         }
2099         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2100 retry:
2101         while (!done && index <= end) {
2102                 unsigned int i, nr_pages, found_pages, wsize, credits;
2103                 pgoff_t next = 0, tofind, saved_index = index;
2104
2105                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2106                                                    &wsize, &credits);
2107                 if (rc)
2108                         break;
2109
2110                 tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2111
2112                 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2113                                                   &found_pages);
2114                 if (!wdata) {
2115                         rc = -ENOMEM;
2116                         add_credits_and_wake_if(server, credits, 0);
2117                         break;
2118                 }
2119
2120                 if (found_pages == 0) {
2121                         kref_put(&wdata->refcount, cifs_writedata_release);
2122                         add_credits_and_wake_if(server, credits, 0);
2123                         break;
2124                 }
2125
2126                 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2127                                                end, &index, &next, &done);
2128
2129                 /* nothing to write? */
2130                 if (nr_pages == 0) {
2131                         kref_put(&wdata->refcount, cifs_writedata_release);
2132                         add_credits_and_wake_if(server, credits, 0);
2133                         continue;
2134                 }
2135
2136                 wdata->credits = credits;
2137
2138                 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2139
2140                 /* send failure -- clean up the mess */
2141                 if (rc != 0) {
2142                         add_credits_and_wake_if(server, wdata->credits, 0);
2143                         for (i = 0; i < nr_pages; ++i) {
2144                                 if (rc == -EAGAIN)
2145                                         redirty_page_for_writepage(wbc,
2146                                                            wdata->pages[i]);
2147                                 else
2148                                         SetPageError(wdata->pages[i]);
2149                                 end_page_writeback(wdata->pages[i]);
2150                                 put_page(wdata->pages[i]);
2151                         }
2152                         if (rc != -EAGAIN)
2153                                 mapping_set_error(mapping, rc);
2154                 }
2155                 kref_put(&wdata->refcount, cifs_writedata_release);
2156
2157                 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2158                         index = saved_index;
2159                         continue;
2160                 }
2161
2162                 wbc->nr_to_write -= nr_pages;
2163                 if (wbc->nr_to_write <= 0)
2164                         done = true;
2165
2166                 index = next;
2167         }
2168
2169         if (!scanned && !done) {
2170                 /*
2171                  * We hit the last page and there is more work to be done: wrap
2172                  * back to the start of the file
2173                  */
2174                 scanned = true;
2175                 index = 0;
2176                 goto retry;
2177         }
2178
2179         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2180                 mapping->writeback_index = index;
2181
2182         return rc;
2183 }
2184
2185 static int
2186 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2187 {
2188         int rc;
2189         unsigned int xid;
2190
2191         xid = get_xid();
2192 /* BB add check for wbc flags */
2193         get_page(page);
2194         if (!PageUptodate(page))
2195                 cifs_dbg(FYI, "ppw - page not up to date\n");
2196
2197         /*
2198          * Set the "writeback" flag, and clear "dirty" in the radix tree.
2199          *
2200          * A writepage() implementation always needs to do either this,
2201          * or re-dirty the page with "redirty_page_for_writepage()" in
2202          * the case of a failure.
2203          *
2204          * Just unlocking the page will cause the radix tree tag-bits
2205          * to fail to update with the state of the page correctly.
2206          */
2207         set_page_writeback(page);
2208 retry_write:
2209         rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2210         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2211                 goto retry_write;
2212         else if (rc == -EAGAIN)
2213                 redirty_page_for_writepage(wbc, page);
2214         else if (rc != 0)
2215                 SetPageError(page);
2216         else
2217                 SetPageUptodate(page);
2218         end_page_writeback(page);
2219         put_page(page);
2220         free_xid(xid);
2221         return rc;
2222 }
2223
2224 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2225 {
2226         int rc = cifs_writepage_locked(page, wbc);
2227         unlock_page(page);
2228         return rc;
2229 }
2230
2231 static int cifs_write_end(struct file *file, struct address_space *mapping,
2232                         loff_t pos, unsigned len, unsigned copied,
2233                         struct page *page, void *fsdata)
2234 {
2235         int rc;
2236         struct inode *inode = mapping->host;
2237         struct cifsFileInfo *cfile = file->private_data;
2238         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2239         __u32 pid;
2240
2241         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2242                 pid = cfile->pid;
2243         else
2244                 pid = current->tgid;
2245
2246         cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2247                  page, pos, copied);
2248
2249         if (PageChecked(page)) {
2250                 if (copied == len)
2251                         SetPageUptodate(page);
2252                 ClearPageChecked(page);
2253         } else if (!PageUptodate(page) && copied == PAGE_SIZE)
2254                 SetPageUptodate(page);
2255
2256         if (!PageUptodate(page)) {
2257                 char *page_data;
2258                 unsigned offset = pos & (PAGE_SIZE - 1);
2259                 unsigned int xid;
2260
2261                 xid = get_xid();
2262                 /* this is probably better than directly calling
2263                    partialpage_write since in this function the file handle is
2264                    known which we might as well leverage */
2265                 /* BB check if anything else missing out of ppw
2266                    such as updating last write time */
2267                 page_data = kmap(page);
2268                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2269                 /* if (rc < 0) should we set writebehind rc? */
2270                 kunmap(page);
2271
2272                 free_xid(xid);
2273         } else {
2274                 rc = copied;
2275                 pos += copied;
2276                 set_page_dirty(page);
2277         }
2278
2279         if (rc > 0) {
2280                 spin_lock(&inode->i_lock);
2281                 if (pos > inode->i_size)
2282                         i_size_write(inode, pos);
2283                 spin_unlock(&inode->i_lock);
2284         }
2285
2286         unlock_page(page);
2287         put_page(page);
2288
2289         return rc;
2290 }
2291
2292 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2293                       int datasync)
2294 {
2295         unsigned int xid;
2296         int rc = 0;
2297         struct cifs_tcon *tcon;
2298         struct TCP_Server_Info *server;
2299         struct cifsFileInfo *smbfile = file->private_data;
2300         struct inode *inode = file_inode(file);
2301         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2302
2303         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2304         if (rc)
2305                 return rc;
2306         inode_lock(inode);
2307
2308         xid = get_xid();
2309
2310         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2311                  file, datasync);
2312
2313         if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2314                 rc = cifs_zap_mapping(inode);
2315                 if (rc) {
2316                         cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2317                         rc = 0; /* don't care about it in fsync */
2318                 }
2319         }
2320
2321         tcon = tlink_tcon(smbfile->tlink);
2322         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2323                 server = tcon->ses->server;
2324                 if (server->ops->flush)
2325                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2326                 else
2327                         rc = -ENOSYS;
2328         }
2329
2330         free_xid(xid);
2331         inode_unlock(inode);
2332         return rc;
2333 }
2334
2335 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2336 {
2337         unsigned int xid;
2338         int rc = 0;
2339         struct cifs_tcon *tcon;
2340         struct TCP_Server_Info *server;
2341         struct cifsFileInfo *smbfile = file->private_data;
2342         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2343         struct inode *inode = file->f_mapping->host;
2344
2345         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2346         if (rc)
2347                 return rc;
2348         inode_lock(inode);
2349
2350         xid = get_xid();
2351
2352         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2353                  file, datasync);
2354
2355         tcon = tlink_tcon(smbfile->tlink);
2356         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2357                 server = tcon->ses->server;
2358                 if (server->ops->flush)
2359                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2360                 else
2361                         rc = -ENOSYS;
2362         }
2363
2364         free_xid(xid);
2365         inode_unlock(inode);
2366         return rc;
2367 }
2368
2369 /*
2370  * As file closes, flush all cached write data for this inode checking
2371  * for write behind errors.
2372  */
2373 int cifs_flush(struct file *file, fl_owner_t id)
2374 {
2375         struct inode *inode = file_inode(file);
2376         int rc = 0;
2377
2378         if (file->f_mode & FMODE_WRITE)
2379                 rc = filemap_write_and_wait(inode->i_mapping);
2380
2381         cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2382
2383         return rc;
2384 }
2385
2386 static int
2387 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2388 {
2389         int rc = 0;
2390         unsigned long i;
2391
2392         for (i = 0; i < num_pages; i++) {
2393                 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2394                 if (!pages[i]) {
2395                         /*
2396                          * save number of pages we have already allocated and
2397                          * return with ENOMEM error
2398                          */
2399                         num_pages = i;
2400                         rc = -ENOMEM;
2401                         break;
2402                 }
2403         }
2404
2405         if (rc) {
2406                 for (i = 0; i < num_pages; i++)
2407                         put_page(pages[i]);
2408         }
2409         return rc;
2410 }
2411
2412 static inline
2413 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2414 {
2415         size_t num_pages;
2416         size_t clen;
2417
2418         clen = min_t(const size_t, len, wsize);
2419         num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2420
2421         if (cur_len)
2422                 *cur_len = clen;
2423
2424         return num_pages;
2425 }
2426
2427 static void
2428 cifs_uncached_writedata_release(struct kref *refcount)
2429 {
2430         int i;
2431         struct cifs_writedata *wdata = container_of(refcount,
2432                                         struct cifs_writedata, refcount);
2433
2434         for (i = 0; i < wdata->nr_pages; i++)
2435                 put_page(wdata->pages[i]);
2436         cifs_writedata_release(refcount);
2437 }
2438
2439 static void
2440 cifs_uncached_writev_complete(struct work_struct *work)
2441 {
2442         struct cifs_writedata *wdata = container_of(work,
2443                                         struct cifs_writedata, work);
2444         struct inode *inode = d_inode(wdata->cfile->dentry);
2445         struct cifsInodeInfo *cifsi = CIFS_I(inode);
2446
2447         spin_lock(&inode->i_lock);
2448         cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2449         if (cifsi->server_eof > inode->i_size)
2450                 i_size_write(inode, cifsi->server_eof);
2451         spin_unlock(&inode->i_lock);
2452
2453         complete(&wdata->done);
2454
2455         kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2456 }
2457
2458 static int
2459 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2460                       size_t *len, unsigned long *num_pages)
2461 {
2462         size_t save_len, copied, bytes, cur_len = *len;
2463         unsigned long i, nr_pages = *num_pages;
2464
2465         save_len = cur_len;
2466         for (i = 0; i < nr_pages; i++) {
2467                 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2468                 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2469                 cur_len -= copied;
2470                 /*
2471                  * If we didn't copy as much as we expected, then that
2472                  * may mean we trod into an unmapped area. Stop copying
2473                  * at that point. On the next pass through the big
2474                  * loop, we'll likely end up getting a zero-length
2475                  * write and bailing out of it.
2476                  */
2477                 if (copied < bytes)
2478                         break;
2479         }
2480         cur_len = save_len - cur_len;
2481         *len = cur_len;
2482
2483         /*
2484          * If we have no data to send, then that probably means that
2485          * the copy above failed altogether. That's most likely because
2486          * the address in the iovec was bogus. Return -EFAULT and let
2487          * the caller free anything we allocated and bail out.
2488          */
2489         if (!cur_len)
2490                 return -EFAULT;
2491
2492         /*
2493          * i + 1 now represents the number of pages we actually used in
2494          * the copy phase above.
2495          */
2496         *num_pages = i + 1;
2497         return 0;
2498 }
2499
2500 static int
2501 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2502                      struct cifsFileInfo *open_file,
2503                      struct cifs_sb_info *cifs_sb, struct list_head *wdata_list)
2504 {
2505         int rc = 0;
2506         size_t cur_len;
2507         unsigned long nr_pages, num_pages, i;
2508         struct cifs_writedata *wdata;
2509         struct iov_iter saved_from = *from;
2510         loff_t saved_offset = offset;
2511         pid_t pid;
2512         struct TCP_Server_Info *server;
2513
2514         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2515                 pid = open_file->pid;
2516         else
2517                 pid = current->tgid;
2518
2519         server = tlink_tcon(open_file->tlink)->ses->server;
2520
2521         do {
2522                 unsigned int wsize, credits;
2523
2524                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2525                                                    &wsize, &credits);
2526                 if (rc)
2527                         break;
2528
2529                 nr_pages = get_numpages(wsize, len, &cur_len);
2530                 wdata = cifs_writedata_alloc(nr_pages,
2531                                              cifs_uncached_writev_complete);
2532                 if (!wdata) {
2533                         rc = -ENOMEM;
2534                         add_credits_and_wake_if(server, credits, 0);
2535                         break;
2536                 }
2537
2538                 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2539                 if (rc) {
2540                         kfree(wdata);
2541                         add_credits_and_wake_if(server, credits, 0);
2542                         break;
2543                 }
2544
2545                 num_pages = nr_pages;
2546                 rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
2547                 if (rc) {
2548                         for (i = 0; i < nr_pages; i++)
2549                                 put_page(wdata->pages[i]);
2550                         kfree(wdata);
2551                         add_credits_and_wake_if(server, credits, 0);
2552                         break;
2553                 }
2554
2555                 /*
2556                  * Bring nr_pages down to the number of pages we actually used,
2557                  * and free any pages that we didn't use.
2558                  */
2559                 for ( ; nr_pages > num_pages; nr_pages--)
2560                         put_page(wdata->pages[nr_pages - 1]);
2561
2562                 wdata->sync_mode = WB_SYNC_ALL;
2563                 wdata->nr_pages = nr_pages;
2564                 wdata->offset = (__u64)offset;
2565                 wdata->cfile = cifsFileInfo_get(open_file);
2566                 wdata->pid = pid;
2567                 wdata->bytes = cur_len;
2568                 wdata->pagesz = PAGE_SIZE;
2569                 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2570                 wdata->credits = credits;
2571
2572                 if (!wdata->cfile->invalidHandle ||
2573                     !cifs_reopen_file(wdata->cfile, false))
2574                         rc = server->ops->async_writev(wdata,
2575                                         cifs_uncached_writedata_release);
2576                 if (rc) {
2577                         add_credits_and_wake_if(server, wdata->credits, 0);
2578                         kref_put(&wdata->refcount,
2579                                  cifs_uncached_writedata_release);
2580                         if (rc == -EAGAIN) {
2581                                 *from = saved_from;
2582                                 iov_iter_advance(from, offset - saved_offset);
2583                                 continue;
2584                         }
2585                         break;
2586                 }
2587
2588                 list_add_tail(&wdata->list, wdata_list);
2589                 offset += cur_len;
2590                 len -= cur_len;
2591         } while (len > 0);
2592
2593         return rc;
2594 }
2595
2596 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
2597 {
2598         struct file *file = iocb->ki_filp;
2599         ssize_t total_written = 0;
2600         struct cifsFileInfo *open_file;
2601         struct cifs_tcon *tcon;
2602         struct cifs_sb_info *cifs_sb;
2603         struct cifs_writedata *wdata, *tmp;
2604         struct list_head wdata_list;
2605         struct iov_iter saved_from = *from;
2606         int rc;
2607
2608         /*
2609          * BB - optimize the way when signing is disabled. We can drop this
2610          * extra memory-to-memory copying and use iovec buffers for constructing
2611          * write request.
2612          */
2613
2614         rc = generic_write_checks(iocb, from);
2615         if (rc <= 0)
2616                 return rc;
2617
2618         INIT_LIST_HEAD(&wdata_list);
2619         cifs_sb = CIFS_FILE_SB(file);
2620         open_file = file->private_data;
2621         tcon = tlink_tcon(open_file->tlink);
2622
2623         if (!tcon->ses->server->ops->async_writev)
2624                 return -ENOSYS;
2625
2626         rc = cifs_write_from_iter(iocb->ki_pos, iov_iter_count(from), from,
2627                                   open_file, cifs_sb, &wdata_list);
2628
2629         /*
2630          * If at least one write was successfully sent, then discard any rc
2631          * value from the later writes. If the other write succeeds, then
2632          * we'll end up returning whatever was written. If it fails, then
2633          * we'll get a new rc value from that.
2634          */
2635         if (!list_empty(&wdata_list))
2636                 rc = 0;
2637
2638         /*
2639          * Wait for and collect replies for any successful sends in order of
2640          * increasing offset. Once an error is hit or we get a fatal signal
2641          * while waiting, then return without waiting for any more replies.
2642          */
2643 restart_loop:
2644         list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2645                 if (!rc) {
2646                         /* FIXME: freezable too? */
2647                         rc = wait_for_completion_killable(&wdata->done);
2648                         if (rc)
2649                                 rc = -EINTR;
2650                         else if (wdata->result)
2651                                 rc = wdata->result;
2652                         else
2653                                 total_written += wdata->bytes;
2654
2655                         /* resend call if it's a retryable error */
2656                         if (rc == -EAGAIN) {
2657                                 struct list_head tmp_list;
2658                                 struct iov_iter tmp_from = saved_from;
2659
2660                                 INIT_LIST_HEAD(&tmp_list);
2661                                 list_del_init(&wdata->list);
2662
2663                                 iov_iter_advance(&tmp_from,
2664                                                  wdata->offset - iocb->ki_pos);
2665
2666                                 rc = cifs_write_from_iter(wdata->offset,
2667                                                 wdata->bytes, &tmp_from,
2668                                                 open_file, cifs_sb, &tmp_list);
2669
2670                                 list_splice(&tmp_list, &wdata_list);
2671
2672                                 kref_put(&wdata->refcount,
2673                                          cifs_uncached_writedata_release);
2674                                 goto restart_loop;
2675                         }
2676                 }
2677                 list_del_init(&wdata->list);
2678                 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2679         }
2680
2681         if (unlikely(!total_written))
2682                 return rc;
2683
2684         iocb->ki_pos += total_written;
2685         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(file_inode(file))->flags);
2686         cifs_stats_bytes_written(tcon, total_written);
2687         return total_written;
2688 }
2689
2690 static ssize_t
2691 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2692 {
2693         struct file *file = iocb->ki_filp;
2694         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2695         struct inode *inode = file->f_mapping->host;
2696         struct cifsInodeInfo *cinode = CIFS_I(inode);
2697         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2698         ssize_t rc;
2699
2700         /*
2701          * We need to hold the sem to be sure nobody modifies lock list
2702          * with a brlock that prevents writing.
2703          */
2704         down_read(&cinode->lock_sem);
2705         inode_lock(inode);
2706
2707         rc = generic_write_checks(iocb, from);
2708         if (rc <= 0)
2709                 goto out;
2710
2711         if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
2712                                      server->vals->exclusive_lock_type, NULL,
2713                                      CIFS_WRITE_OP))
2714                 rc = __generic_file_write_iter(iocb, from);
2715         else
2716                 rc = -EACCES;
2717 out:
2718         inode_unlock(inode);
2719
2720         if (rc > 0)
2721                 rc = generic_write_sync(iocb, rc);
2722         up_read(&cinode->lock_sem);
2723         return rc;
2724 }
2725
2726 ssize_t
2727 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2728 {
2729         struct inode *inode = file_inode(iocb->ki_filp);
2730         struct cifsInodeInfo *cinode = CIFS_I(inode);
2731         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2732         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2733                                                 iocb->ki_filp->private_data;
2734         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2735         ssize_t written;
2736
2737         written = cifs_get_writer(cinode);
2738         if (written)
2739                 return written;
2740
2741         if (CIFS_CACHE_WRITE(cinode)) {
2742                 if (cap_unix(tcon->ses) &&
2743                 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2744                   && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
2745                         written = generic_file_write_iter(iocb, from);
2746                         goto out;
2747                 }
2748                 written = cifs_writev(iocb, from);
2749                 goto out;
2750         }
2751         /*
2752          * For non-oplocked files in strict cache mode we need to write the data
2753          * to the server exactly from the pos to pos+len-1 rather than flush all
2754          * affected pages because it may cause a error with mandatory locks on
2755          * these pages but not on the region from pos to ppos+len-1.
2756          */
2757         written = cifs_user_writev(iocb, from);
2758         if (written > 0 && CIFS_CACHE_READ(cinode)) {
2759                 /*
2760                  * Windows 7 server can delay breaking level2 oplock if a write
2761                  * request comes - break it on the client to prevent reading
2762                  * an old data.
2763                  */
2764                 cifs_zap_mapping(inode);
2765                 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2766                          inode);
2767                 cinode->oplock = 0;
2768         }
2769 out:
2770         cifs_put_writer(cinode);
2771         return written;
2772 }
2773
2774 static struct cifs_readdata *
2775 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2776 {
2777         struct cifs_readdata *rdata;
2778
2779         rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2780                         GFP_KERNEL);
2781         if (rdata != NULL) {
2782                 kref_init(&rdata->refcount);
2783                 INIT_LIST_HEAD(&rdata->list);
2784                 init_completion(&rdata->done);
2785                 INIT_WORK(&rdata->work, complete);
2786         }
2787
2788         return rdata;
2789 }
2790
2791 void
2792 cifs_readdata_release(struct kref *refcount)
2793 {
2794         struct cifs_readdata *rdata = container_of(refcount,
2795                                         struct cifs_readdata, refcount);
2796
2797         if (rdata->cfile)
2798                 cifsFileInfo_put(rdata->cfile);
2799
2800         kfree(rdata);
2801 }
2802
2803 static int
2804 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2805 {
2806         int rc = 0;
2807         struct page *page;
2808         unsigned int i;
2809
2810         for (i = 0; i < nr_pages; i++) {
2811                 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2812                 if (!page) {
2813                         rc = -ENOMEM;
2814                         break;
2815                 }
2816                 rdata->pages[i] = page;
2817         }
2818
2819         if (rc) {
2820                 for (i = 0; i < nr_pages; i++) {
2821                         put_page(rdata->pages[i]);
2822                         rdata->pages[i] = NULL;
2823                 }
2824         }
2825         return rc;
2826 }
2827
2828 static void
2829 cifs_uncached_readdata_release(struct kref *refcount)
2830 {
2831         struct cifs_readdata *rdata = container_of(refcount,
2832                                         struct cifs_readdata, refcount);
2833         unsigned int i;
2834
2835         for (i = 0; i < rdata->nr_pages; i++) {
2836                 put_page(rdata->pages[i]);
2837                 rdata->pages[i] = NULL;
2838         }
2839         cifs_readdata_release(refcount);
2840 }
2841
2842 /**
2843  * cifs_readdata_to_iov - copy data from pages in response to an iovec
2844  * @rdata:      the readdata response with list of pages holding data
2845  * @iter:       destination for our data
2846  *
2847  * This function copies data from a list of pages in a readdata response into
2848  * an array of iovecs. It will first calculate where the data should go
2849  * based on the info in the readdata and then copy the data into that spot.
2850  */
2851 static int
2852 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
2853 {
2854         size_t remaining = rdata->got_bytes;
2855         unsigned int i;
2856
2857         for (i = 0; i < rdata->nr_pages; i++) {
2858                 struct page *page = rdata->pages[i];
2859                 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
2860                 size_t written = copy_page_to_iter(page, 0, copy, iter);
2861                 remaining -= written;
2862                 if (written < copy && iov_iter_count(iter) > 0)
2863                         break;
2864         }
2865         return remaining ? -EFAULT : 0;
2866 }
2867
2868 static void
2869 cifs_uncached_readv_complete(struct work_struct *work)
2870 {
2871         struct cifs_readdata *rdata = container_of(work,
2872                                                 struct cifs_readdata, work);
2873
2874         complete(&rdata->done);
2875         kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2876 }
2877
2878 static int
2879 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2880                         struct cifs_readdata *rdata, unsigned int len)
2881 {
2882         int result = 0;
2883         unsigned int i;
2884         unsigned int nr_pages = rdata->nr_pages;
2885
2886         rdata->got_bytes = 0;
2887         rdata->tailsz = PAGE_SIZE;
2888         for (i = 0; i < nr_pages; i++) {
2889                 struct page *page = rdata->pages[i];
2890                 size_t n;
2891
2892                 if (len <= 0) {
2893                         /* no need to hold page hostage */
2894                         rdata->pages[i] = NULL;
2895                         rdata->nr_pages--;
2896                         put_page(page);
2897                         continue;
2898                 }
2899                 n = len;
2900                 if (len >= PAGE_SIZE) {
2901                         /* enough data to fill the page */
2902                         n = PAGE_SIZE;
2903                         len -= n;
2904                 } else {
2905                         zero_user(page, len, PAGE_SIZE - len);
2906                         rdata->tailsz = len;
2907                         len = 0;
2908                 }
2909                 result = cifs_read_page_from_socket(server, page, n);
2910                 if (result < 0)
2911                         break;
2912
2913                 rdata->got_bytes += result;
2914         }
2915
2916         return rdata->got_bytes > 0 && result != -ECONNABORTED ?
2917                                                 rdata->got_bytes : result;
2918 }
2919
2920 static int
2921 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
2922                      struct cifs_sb_info *cifs_sb, struct list_head *rdata_list)
2923 {
2924         struct cifs_readdata *rdata;
2925         unsigned int npages, rsize, credits;
2926         size_t cur_len;
2927         int rc;
2928         pid_t pid;
2929         struct TCP_Server_Info *server;
2930
2931         server = tlink_tcon(open_file->tlink)->ses->server;
2932
2933         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2934                 pid = open_file->pid;
2935         else
2936                 pid = current->tgid;
2937
2938         do {
2939                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
2940                                                    &rsize, &credits);
2941                 if (rc)
2942                         break;
2943
2944                 cur_len = min_t(const size_t, len, rsize);
2945                 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2946
2947                 /* allocate a readdata struct */
2948                 rdata = cifs_readdata_alloc(npages,
2949                                             cifs_uncached_readv_complete);
2950                 if (!rdata) {
2951                         add_credits_and_wake_if(server, credits, 0);
2952                         rc = -ENOMEM;
2953                         break;
2954                 }
2955
2956                 rc = cifs_read_allocate_pages(rdata, npages);
2957                 if (rc)
2958                         goto error;
2959
2960                 rdata->cfile = cifsFileInfo_get(open_file);
2961                 rdata->nr_pages = npages;
2962                 rdata->offset = offset;
2963                 rdata->bytes = cur_len;
2964                 rdata->pid = pid;
2965                 rdata->pagesz = PAGE_SIZE;
2966                 rdata->read_into_pages = cifs_uncached_read_into_pages;
2967                 rdata->credits = credits;
2968
2969                 if (!rdata->cfile->invalidHandle ||
2970                     !cifs_reopen_file(rdata->cfile, true))
2971                         rc = server->ops->async_readv(rdata);
2972 error:
2973                 if (rc) {
2974                         add_credits_and_wake_if(server, rdata->credits, 0);
2975                         kref_put(&rdata->refcount,
2976                                  cifs_uncached_readdata_release);
2977                         if (rc == -EAGAIN)
2978                                 continue;
2979                         break;
2980                 }
2981
2982                 list_add_tail(&rdata->list, rdata_list);
2983                 offset += cur_len;
2984                 len -= cur_len;
2985         } while (len > 0);
2986
2987         return rc;
2988 }
2989
2990 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
2991 {
2992         struct file *file = iocb->ki_filp;
2993         ssize_t rc;
2994         size_t len;
2995         ssize_t total_read = 0;
2996         loff_t offset = iocb->ki_pos;
2997         struct cifs_sb_info *cifs_sb;
2998         struct cifs_tcon *tcon;
2999         struct cifsFileInfo *open_file;
3000         struct cifs_readdata *rdata, *tmp;
3001         struct list_head rdata_list;
3002
3003         len = iov_iter_count(to);
3004         if (!len)
3005                 return 0;
3006
3007         INIT_LIST_HEAD(&rdata_list);
3008         cifs_sb = CIFS_FILE_SB(file);
3009         open_file = file->private_data;
3010         tcon = tlink_tcon(open_file->tlink);
3011
3012         if (!tcon->ses->server->ops->async_readv)
3013                 return -ENOSYS;
3014
3015         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3016                 cifs_dbg(FYI, "attempting read on write only file instance\n");
3017
3018         rc = cifs_send_async_read(offset, len, open_file, cifs_sb, &rdata_list);
3019
3020         /* if at least one read request send succeeded, then reset rc */
3021         if (!list_empty(&rdata_list))
3022                 rc = 0;
3023
3024         len = iov_iter_count(to);
3025         /* the loop below should proceed in the order of increasing offsets */
3026 again:
3027         list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
3028                 if (!rc) {
3029                         /* FIXME: freezable sleep too? */
3030                         rc = wait_for_completion_killable(&rdata->done);
3031                         if (rc)
3032                                 rc = -EINTR;
3033                         else if (rdata->result == -EAGAIN) {
3034                                 /* resend call if it's a retryable error */
3035                                 struct list_head tmp_list;
3036                                 unsigned int got_bytes = rdata->got_bytes;
3037
3038                                 list_del_init(&rdata->list);
3039                                 INIT_LIST_HEAD(&tmp_list);
3040
3041                                 /*
3042                                  * Got a part of data and then reconnect has
3043                                  * happened -- fill the buffer and continue
3044                                  * reading.
3045                                  */
3046                                 if (got_bytes && got_bytes < rdata->bytes) {
3047                                         rc = cifs_readdata_to_iov(rdata, to);
3048                                         if (rc) {
3049                                                 kref_put(&rdata->refcount,
3050                                                 cifs_uncached_readdata_release);
3051                                                 continue;
3052                                         }
3053                                 }
3054
3055                                 rc = cifs_send_async_read(
3056                                                 rdata->offset + got_bytes,
3057                                                 rdata->bytes - got_bytes,
3058                                                 rdata->cfile, cifs_sb,
3059                                                 &tmp_list);
3060
3061                                 list_splice(&tmp_list, &rdata_list);
3062
3063                                 kref_put(&rdata->refcount,
3064                                          cifs_uncached_readdata_release);
3065                                 goto again;
3066                         } else if (rdata->result)
3067                                 rc = rdata->result;
3068                         else
3069                                 rc = cifs_readdata_to_iov(rdata, to);
3070
3071                         /* if there was a short read -- discard anything left */
3072                         if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3073                                 rc = -ENODATA;
3074                 }
3075                 list_del_init(&rdata->list);
3076                 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3077         }
3078
3079         total_read = len - iov_iter_count(to);
3080
3081         cifs_stats_bytes_read(tcon, total_read);
3082
3083         /* mask nodata case */
3084         if (rc == -ENODATA)
3085                 rc = 0;
3086
3087         if (total_read) {
3088                 iocb->ki_pos += total_read;
3089                 return total_read;
3090         }
3091         return rc;
3092 }
3093
3094 ssize_t
3095 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3096 {
3097         struct inode *inode = file_inode(iocb->ki_filp);
3098         struct cifsInodeInfo *cinode = CIFS_I(inode);
3099         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3100         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3101                                                 iocb->ki_filp->private_data;
3102         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3103         int rc = -EACCES;
3104
3105         /*
3106          * In strict cache mode we need to read from the server all the time
3107          * if we don't have level II oplock because the server can delay mtime
3108          * change - so we can't make a decision about inode invalidating.
3109          * And we can also fail with pagereading if there are mandatory locks
3110          * on pages affected by this read but not on the region from pos to
3111          * pos+len-1.
3112          */
3113         if (!CIFS_CACHE_READ(cinode))
3114                 return cifs_user_readv(iocb, to);
3115
3116         if (cap_unix(tcon->ses) &&
3117             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3118             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3119                 return generic_file_read_iter(iocb, to);
3120
3121         /*
3122          * We need to hold the sem to be sure nobody modifies lock list
3123          * with a brlock that prevents reading.
3124          */
3125         down_read(&cinode->lock_sem);
3126         if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3127                                      tcon->ses->server->vals->shared_lock_type,
3128                                      NULL, CIFS_READ_OP))
3129                 rc = generic_file_read_iter(iocb, to);
3130         up_read(&cinode->lock_sem);
3131         return rc;
3132 }
3133
3134 static ssize_t
3135 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3136 {
3137         int rc = -EACCES;
3138         unsigned int bytes_read = 0;
3139         unsigned int total_read;
3140         unsigned int current_read_size;
3141         unsigned int rsize;
3142         struct cifs_sb_info *cifs_sb;
3143         struct cifs_tcon *tcon;
3144         struct TCP_Server_Info *server;
3145         unsigned int xid;
3146         char *cur_offset;
3147         struct cifsFileInfo *open_file;
3148         struct cifs_io_parms io_parms;
3149         int buf_type = CIFS_NO_BUFFER;
3150         __u32 pid;
3151
3152         xid = get_xid();
3153         cifs_sb = CIFS_FILE_SB(file);
3154
3155         /* FIXME: set up handlers for larger reads and/or convert to async */
3156         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3157
3158         if (file->private_data == NULL) {
3159                 rc = -EBADF;
3160                 free_xid(xid);
3161                 return rc;
3162         }
3163         open_file = file->private_data;
3164         tcon = tlink_tcon(open_file->tlink);
3165         server = tcon->ses->server;
3166
3167         if (!server->ops->sync_read) {
3168                 free_xid(xid);
3169                 return -ENOSYS;
3170         }
3171
3172         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3173                 pid = open_file->pid;
3174         else
3175                 pid = current->tgid;
3176
3177         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3178                 cifs_dbg(FYI, "attempting read on write only file instance\n");
3179
3180         for (total_read = 0, cur_offset = read_data; read_size > total_read;
3181              total_read += bytes_read, cur_offset += bytes_read) {
3182                 do {
3183                         current_read_size = min_t(uint, read_size - total_read,
3184                                                   rsize);
3185                         /*
3186                          * For windows me and 9x we do not want to request more
3187                          * than it negotiated since it will refuse the read
3188                          * then.
3189                          */
3190                         if ((tcon->ses) && !(tcon->ses->capabilities &
3191                                 tcon->ses->server->vals->cap_large_files)) {
3192                                 current_read_size = min_t(uint,
3193                                         current_read_size, CIFSMaxBufSize);
3194                         }
3195                         if (open_file->invalidHandle) {
3196                                 rc = cifs_reopen_file(open_file, true);
3197                                 if (rc != 0)
3198                                         break;
3199                         }
3200                         io_parms.pid = pid;
3201                         io_parms.tcon = tcon;
3202                         io_parms.offset = *offset;
3203                         io_parms.length = current_read_size;
3204                         rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3205                                                     &bytes_read, &cur_offset,
3206                                                     &buf_type);
3207                 } while (rc == -EAGAIN);
3208
3209                 if (rc || (bytes_read == 0)) {
3210                         if (total_read) {
3211                                 break;
3212                         } else {
3213                                 free_xid(xid);
3214                                 return rc;
3215                         }
3216                 } else {
3217                         cifs_stats_bytes_read(tcon, total_read);
3218                         *offset += bytes_read;
3219                 }
3220         }
3221         free_xid(xid);
3222         return total_read;
3223 }
3224
3225 /*
3226  * If the page is mmap'ed into a process' page tables, then we need to make
3227  * sure that it doesn't change while being written back.
3228  */
3229 static int
3230 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3231 {
3232         struct page *page = vmf->page;
3233
3234         lock_page(page);
3235         return VM_FAULT_LOCKED;
3236 }
3237
3238 static const struct vm_operations_struct cifs_file_vm_ops = {
3239         .fault = filemap_fault,
3240         .map_pages = filemap_map_pages,
3241         .page_mkwrite = cifs_page_mkwrite,
3242 };
3243
3244 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3245 {
3246         int rc, xid;
3247         struct inode *inode = file_inode(file);
3248
3249         xid = get_xid();
3250
3251         if (!CIFS_CACHE_READ(CIFS_I(inode))) {
3252                 rc = cifs_zap_mapping(inode);
3253                 if (rc)
3254                         return rc;
3255         }
3256
3257         rc = generic_file_mmap(file, vma);
3258         if (rc == 0)
3259                 vma->vm_ops = &cifs_file_vm_ops;
3260         free_xid(xid);
3261         return rc;
3262 }
3263
3264 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3265 {
3266         int rc, xid;
3267
3268         xid = get_xid();
3269         rc = cifs_revalidate_file(file);
3270         if (rc) {
3271                 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3272                          rc);
3273                 free_xid(xid);
3274                 return rc;
3275         }
3276         rc = generic_file_mmap(file, vma);
3277         if (rc == 0)
3278                 vma->vm_ops = &cifs_file_vm_ops;
3279         free_xid(xid);
3280         return rc;
3281 }
3282
3283 static void
3284 cifs_readv_complete(struct work_struct *work)
3285 {
3286         unsigned int i, got_bytes;
3287         struct cifs_readdata *rdata = container_of(work,
3288                                                 struct cifs_readdata, work);
3289
3290         got_bytes = rdata->got_bytes;
3291         for (i = 0; i < rdata->nr_pages; i++) {
3292                 struct page *page = rdata->pages[i];
3293
3294                 lru_cache_add_file(page);
3295
3296                 if (rdata->result == 0 ||
3297                     (rdata->result == -EAGAIN && got_bytes)) {
3298                         flush_dcache_page(page);
3299                         SetPageUptodate(page);
3300                 }
3301
3302                 unlock_page(page);
3303
3304                 if (rdata->result == 0 ||
3305                     (rdata->result == -EAGAIN && got_bytes))
3306                         cifs_readpage_to_fscache(rdata->mapping->host, page);
3307
3308                 got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
3309
3310                 put_page(page);
3311                 rdata->pages[i] = NULL;
3312         }
3313         kref_put(&rdata->refcount, cifs_readdata_release);
3314 }
3315
3316 static int
3317 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3318                         struct cifs_readdata *rdata, unsigned int len)
3319 {
3320         int result = 0;
3321         unsigned int i;
3322         u64 eof;
3323         pgoff_t eof_index;
3324         unsigned int nr_pages = rdata->nr_pages;
3325
3326         /* determine the eof that the server (probably) has */
3327         eof = CIFS_I(rdata->mapping->host)->server_eof;
3328         eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
3329         cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
3330
3331         rdata->got_bytes = 0;
3332         rdata->tailsz = PAGE_SIZE;
3333         for (i = 0; i < nr_pages; i++) {
3334                 struct page *page = rdata->pages[i];
3335                 size_t n = PAGE_SIZE;
3336
3337                 if (len >= PAGE_SIZE) {
3338                         len -= PAGE_SIZE;
3339                 } else if (len > 0) {
3340                         /* enough for partial page, fill and zero the rest */
3341                         zero_user(page, len, PAGE_SIZE - len);
3342                         n = rdata->tailsz = len;
3343                         len = 0;
3344                 } else if (page->index > eof_index) {
3345                         /*
3346                          * The VFS will not try to do readahead past the
3347                          * i_size, but it's possible that we have outstanding
3348                          * writes with gaps in the middle and the i_size hasn't
3349                          * caught up yet. Populate those with zeroed out pages
3350                          * to prevent the VFS from repeatedly attempting to
3351                          * fill them until the writes are flushed.
3352                          */
3353                         zero_user(page, 0, PAGE_SIZE);
3354                         lru_cache_add_file(page);
3355                         flush_dcache_page(page);
3356                         SetPageUptodate(page);
3357                         unlock_page(page);
3358                         put_page(page);
3359                         rdata->pages[i] = NULL;
3360                         rdata->nr_pages--;
3361                         continue;
3362                 } else {
3363                         /* no need to hold page hostage */
3364                         lru_cache_add_file(page);
3365                         unlock_page(page);
3366                         put_page(page);
3367                         rdata->pages[i] = NULL;
3368                         rdata->nr_pages--;
3369                         continue;
3370                 }
3371
3372                 result = cifs_read_page_from_socket(server, page, n);
3373                 if (result < 0)
3374                         break;
3375
3376                 rdata->got_bytes += result;
3377         }
3378
3379         return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3380                                                 rdata->got_bytes : result;
3381 }
3382
3383 static int
3384 readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
3385                     unsigned int rsize, struct list_head *tmplist,
3386                     unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
3387 {
3388         struct page *page, *tpage;
3389         unsigned int expected_index;
3390         int rc;
3391         gfp_t gfp = readahead_gfp_mask(mapping);
3392
3393         INIT_LIST_HEAD(tmplist);
3394
3395         page = list_entry(page_list->prev, struct page, lru);
3396
3397         /*
3398          * Lock the page and put it in the cache. Since no one else
3399          * should have access to this page, we're safe to simply set
3400          * PG_locked without checking it first.
3401          */
3402         __SetPageLocked(page);
3403         rc = add_to_page_cache_locked(page, mapping,
3404                                       page->index, gfp);
3405
3406         /* give up if we can't stick it in the cache */
3407         if (rc) {
3408                 __ClearPageLocked(page);
3409                 return rc;
3410         }
3411
3412         /* move first page to the tmplist */
3413         *offset = (loff_t)page->index << PAGE_SHIFT;
3414         *bytes = PAGE_SIZE;
3415         *nr_pages = 1;
3416         list_move_tail(&page->lru, tmplist);
3417
3418         /* now try and add more pages onto the request */
3419         expected_index = page->index + 1;
3420         list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3421                 /* discontinuity ? */
3422                 if (page->index != expected_index)
3423                         break;
3424
3425                 /* would this page push the read over the rsize? */
3426                 if (*bytes + PAGE_SIZE > rsize)
3427                         break;
3428
3429                 __SetPageLocked(page);
3430                 if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
3431                         __ClearPageLocked(page);
3432                         break;
3433                 }
3434                 list_move_tail(&page->lru, tmplist);
3435                 (*bytes) += PAGE_SIZE;
3436                 expected_index++;
3437                 (*nr_pages)++;
3438         }
3439         return rc;
3440 }
3441
3442 static int cifs_readpages(struct file *file, struct address_space *mapping,
3443         struct list_head *page_list, unsigned num_pages)
3444 {
3445         int rc;
3446         struct list_head tmplist;
3447         struct cifsFileInfo *open_file = file->private_data;
3448         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
3449         struct TCP_Server_Info *server;
3450         pid_t pid;
3451
3452         /*
3453          * Reads as many pages as possible from fscache. Returns -ENOBUFS
3454          * immediately if the cookie is negative
3455          *
3456          * After this point, every page in the list might have PG_fscache set,
3457          * so we will need to clean that up off of every page we don't use.
3458          */
3459         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3460                                          &num_pages);
3461         if (rc == 0)
3462                 return rc;
3463
3464         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3465                 pid = open_file->pid;
3466         else
3467                 pid = current->tgid;
3468
3469         rc = 0;
3470         server = tlink_tcon(open_file->tlink)->ses->server;
3471
3472         cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3473                  __func__, file, mapping, num_pages);
3474
3475         /*
3476          * Start with the page at end of list and move it to private
3477          * list. Do the same with any following pages until we hit
3478          * the rsize limit, hit an index discontinuity, or run out of
3479          * pages. Issue the async read and then start the loop again
3480          * until the list is empty.
3481          *
3482          * Note that list order is important. The page_list is in
3483          * the order of declining indexes. When we put the pages in
3484          * the rdata->pages, then we want them in increasing order.
3485          */
3486         while (!list_empty(page_list)) {
3487                 unsigned int i, nr_pages, bytes, rsize;
3488                 loff_t offset;
3489                 struct page *page, *tpage;
3490                 struct cifs_readdata *rdata;
3491                 unsigned credits;
3492
3493                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3494                                                    &rsize, &credits);
3495                 if (rc)
3496                         break;
3497
3498                 /*
3499                  * Give up immediately if rsize is too small to read an entire
3500                  * page. The VFS will fall back to readpage. We should never
3501                  * reach this point however since we set ra_pages to 0 when the
3502                  * rsize is smaller than a cache page.
3503                  */
3504                 if (unlikely(rsize < PAGE_SIZE)) {
3505                         add_credits_and_wake_if(server, credits, 0);
3506                         return 0;
3507                 }
3508
3509                 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
3510                                          &nr_pages, &offset, &bytes);
3511                 if (rc) {
3512                         add_credits_and_wake_if(server, credits, 0);
3513                         break;
3514                 }
3515
3516                 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3517                 if (!rdata) {
3518                         /* best to give up if we're out of mem */
3519                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3520                                 list_del(&page->lru);
3521                                 lru_cache_add_file(page);
3522                                 unlock_page(page);
3523                                 put_page(page);
3524                         }
3525                         rc = -ENOMEM;
3526                         add_credits_and_wake_if(server, credits, 0);
3527                         break;
3528                 }
3529
3530                 rdata->cfile = cifsFileInfo_get(open_file);
3531                 rdata->mapping = mapping;
3532                 rdata->offset = offset;
3533                 rdata->bytes = bytes;
3534                 rdata->pid = pid;
3535                 rdata->pagesz = PAGE_SIZE;
3536                 rdata->read_into_pages = cifs_readpages_read_into_pages;
3537                 rdata->credits = credits;
3538
3539                 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3540                         list_del(&page->lru);
3541                         rdata->pages[rdata->nr_pages++] = page;
3542                 }
3543
3544                 if (!rdata->cfile->invalidHandle ||
3545                     !cifs_reopen_file(rdata->cfile, true))
3546                         rc = server->ops->async_readv(rdata);
3547                 if (rc) {
3548                         add_credits_and_wake_if(server, rdata->credits, 0);
3549                         for (i = 0; i < rdata->nr_pages; i++) {
3550                                 page = rdata->pages[i];
3551                                 lru_cache_add_file(page);
3552                                 unlock_page(page);
3553                                 put_page(page);
3554                         }
3555                         /* Fallback to the readpage in error/reconnect cases */
3556                         kref_put(&rdata->refcount, cifs_readdata_release);
3557                         break;
3558                 }
3559
3560                 kref_put(&rdata->refcount, cifs_readdata_release);
3561         }
3562
3563         /* Any pages that have been shown to fscache but didn't get added to
3564          * the pagecache must be uncached before they get returned to the
3565          * allocator.
3566          */
3567         cifs_fscache_readpages_cancel(mapping->host, page_list);
3568         return rc;
3569 }
3570
3571 /*
3572  * cifs_readpage_worker must be called with the page pinned
3573  */
3574 static int cifs_readpage_worker(struct file *file, struct page *page,
3575         loff_t *poffset)
3576 {
3577         char *read_data;
3578         int rc;
3579
3580         /* Is the page cached? */
3581         rc = cifs_readpage_from_fscache(file_inode(file), page);
3582         if (rc == 0)
3583                 goto read_complete;
3584
3585         read_data = kmap(page);
3586         /* for reads over a certain size could initiate async read ahead */
3587
3588         rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
3589
3590         if (rc < 0)
3591                 goto io_error;
3592         else
3593                 cifs_dbg(FYI, "Bytes read %d\n", rc);
3594
3595         file_inode(file)->i_atime =
3596                 current_time(file_inode(file));
3597
3598         if (PAGE_SIZE > rc)
3599                 memset(read_data + rc, 0, PAGE_SIZE - rc);
3600
3601         flush_dcache_page(page);
3602         SetPageUptodate(page);
3603
3604         /* send this page to the cache */
3605         cifs_readpage_to_fscache(file_inode(file), page);
3606
3607         rc = 0;
3608
3609 io_error:
3610         kunmap(page);
3611         unlock_page(page);
3612
3613 read_complete:
3614         return rc;
3615 }
3616
3617 static int cifs_readpage(struct file *file, struct page *page)
3618 {
3619         loff_t offset = (loff_t)page->index << PAGE_SHIFT;
3620         int rc = -EACCES;
3621         unsigned int xid;
3622
3623         xid = get_xid();
3624
3625         if (file->private_data == NULL) {
3626                 rc = -EBADF;
3627                 free_xid(xid);
3628                 return rc;
3629         }
3630
3631         cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3632                  page, (int)offset, (int)offset);
3633
3634         rc = cifs_readpage_worker(file, page, &offset);
3635
3636         free_xid(xid);
3637         return rc;
3638 }
3639
3640 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3641 {
3642         struct cifsFileInfo *open_file;
3643         struct cifs_tcon *tcon =
3644                 cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
3645
3646         spin_lock(&tcon->open_file_lock);
3647         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3648                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3649                         spin_unlock(&tcon->open_file_lock);
3650                         return 1;
3651                 }
3652         }
3653         spin_unlock(&tcon->open_file_lock);
3654         return 0;
3655 }
3656
3657 /* We do not want to update the file size from server for inodes
3658    open for write - to avoid races with writepage extending
3659    the file - in the future we could consider allowing
3660    refreshing the inode only on increases in the file size
3661    but this is tricky to do without racing with writebehind
3662    page caching in the current Linux kernel design */
3663 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3664 {
3665         if (!cifsInode)
3666                 return true;
3667
3668         if (is_inode_writable(cifsInode)) {
3669                 /* This inode is open for write at least once */
3670                 struct cifs_sb_info *cifs_sb;
3671
3672                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3673                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3674                         /* since no page cache to corrupt on directio
3675                         we can change size safely */
3676                         return true;
3677                 }
3678
3679                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3680                         return true;
3681
3682                 return false;
3683         } else
3684                 return true;
3685 }
3686
3687 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3688                         loff_t pos, unsigned len, unsigned flags,
3689                         struct page **pagep, void **fsdata)
3690 {
3691         int oncethru = 0;
3692         pgoff_t index = pos >> PAGE_SHIFT;
3693         loff_t offset = pos & (PAGE_SIZE - 1);
3694         loff_t page_start = pos & PAGE_MASK;
3695         loff_t i_size;
3696         struct page *page;
3697         int rc = 0;
3698
3699         cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
3700
3701 start:
3702         page = grab_cache_page_write_begin(mapping, index, flags);
3703         if (!page) {
3704                 rc = -ENOMEM;
3705                 goto out;
3706         }
3707
3708         if (PageUptodate(page))
3709                 goto out;
3710
3711         /*
3712          * If we write a full page it will be up to date, no need to read from
3713          * the server. If the write is short, we'll end up doing a sync write
3714          * instead.
3715          */
3716         if (len == PAGE_SIZE)
3717                 goto out;
3718
3719         /*
3720          * optimize away the read when we have an oplock, and we're not
3721          * expecting to use any of the data we'd be reading in. That
3722          * is, when the page lies beyond the EOF, or straddles the EOF
3723          * and the write will cover all of the existing data.
3724          */
3725         if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
3726                 i_size = i_size_read(mapping->host);
3727                 if (page_start >= i_size ||
3728                     (offset == 0 && (pos + len) >= i_size)) {
3729                         zero_user_segments(page, 0, offset,
3730                                            offset + len,
3731                                            PAGE_SIZE);
3732                         /*
3733                          * PageChecked means that the parts of the page
3734                          * to which we're not writing are considered up
3735                          * to date. Once the data is copied to the
3736                          * page, it can be set uptodate.
3737                          */
3738                         SetPageChecked(page);
3739                         goto out;
3740                 }
3741         }
3742
3743         if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
3744                 /*
3745                  * might as well read a page, it is fast enough. If we get
3746                  * an error, we don't need to return it. cifs_write_end will
3747                  * do a sync write instead since PG_uptodate isn't set.
3748                  */
3749                 cifs_readpage_worker(file, page, &page_start);
3750                 put_page(page);
3751                 oncethru = 1;
3752                 goto start;
3753         } else {
3754                 /* we could try using another file handle if there is one -
3755                    but how would we lock it to prevent close of that handle
3756                    racing with this read? In any case
3757                    this will be written out by write_end so is fine */
3758         }
3759 out:
3760         *pagep = page;
3761         return rc;
3762 }
3763
3764 static int cifs_release_page(struct page *page, gfp_t gfp)
3765 {
3766         if (PagePrivate(page))
3767                 return 0;
3768
3769         return cifs_fscache_release_page(page, gfp);
3770 }
3771
3772 static void cifs_invalidate_page(struct page *page, unsigned int offset,
3773                                  unsigned int length)
3774 {
3775         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3776
3777         if (offset == 0 && length == PAGE_SIZE)
3778                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3779 }
3780
3781 static int cifs_launder_page(struct page *page)
3782 {
3783         int rc = 0;
3784         loff_t range_start = page_offset(page);
3785         loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
3786         struct writeback_control wbc = {
3787                 .sync_mode = WB_SYNC_ALL,
3788                 .nr_to_write = 0,
3789                 .range_start = range_start,
3790                 .range_end = range_end,
3791         };
3792
3793         cifs_dbg(FYI, "Launder page: %p\n", page);
3794
3795         if (clear_page_dirty_for_io(page))
3796                 rc = cifs_writepage_locked(page, &wbc);
3797
3798         cifs_fscache_invalidate_page(page, page->mapping->host);
3799         return rc;
3800 }
3801
3802 void cifs_oplock_break(struct work_struct *work)
3803 {
3804         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3805                                                   oplock_break);
3806         struct inode *inode = d_inode(cfile->dentry);
3807         struct cifsInodeInfo *cinode = CIFS_I(inode);
3808         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3809         struct TCP_Server_Info *server = tcon->ses->server;
3810         int rc = 0;
3811
3812         wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
3813                         TASK_UNINTERRUPTIBLE);
3814
3815         server->ops->downgrade_oplock(server, cinode,
3816                 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
3817
3818         if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
3819                                                 cifs_has_mand_locks(cinode)) {
3820                 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3821                          inode);
3822                 cinode->oplock = 0;
3823         }
3824
3825         if (inode && S_ISREG(inode->i_mode)) {
3826                 if (CIFS_CACHE_READ(cinode))
3827                         break_lease(inode, O_RDONLY);
3828                 else
3829                         break_lease(inode, O_WRONLY);
3830                 rc = filemap_fdatawrite(inode->i_mapping);
3831                 if (!CIFS_CACHE_READ(cinode)) {
3832                         rc = filemap_fdatawait(inode->i_mapping);
3833                         mapping_set_error(inode->i_mapping, rc);
3834                         cifs_zap_mapping(inode);
3835                 }
3836                 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
3837         }
3838
3839         rc = cifs_push_locks(cfile);
3840         if (rc)
3841                 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
3842
3843         /*
3844          * releasing stale oplock after recent reconnect of smb session using
3845          * a now incorrect file handle is not a data integrity issue but do
3846          * not bother sending an oplock release if session to server still is
3847          * disconnected since oplock already released by the server
3848          */
3849         if (!cfile->oplock_break_cancelled) {
3850                 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3851                                                              cinode);
3852                 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
3853         }
3854         cifs_done_oplock_break(cinode);
3855 }
3856
3857 /*
3858  * The presence of cifs_direct_io() in the address space ops vector
3859  * allowes open() O_DIRECT flags which would have failed otherwise.
3860  *
3861  * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
3862  * so this method should never be called.
3863  *
3864  * Direct IO is not yet supported in the cached mode.
3865  */
3866 static ssize_t
3867 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
3868 {
3869         /*
3870          * FIXME
3871          * Eventually need to support direct IO for non forcedirectio mounts
3872          */
3873         return -EINVAL;
3874 }
3875
3876
3877 const struct address_space_operations cifs_addr_ops = {
3878         .readpage = cifs_readpage,
3879         .readpages = cifs_readpages,
3880         .writepage = cifs_writepage,
3881         .writepages = cifs_writepages,
3882         .write_begin = cifs_write_begin,
3883         .write_end = cifs_write_end,
3884         .set_page_dirty = __set_page_dirty_nobuffers,
3885         .releasepage = cifs_release_page,
3886         .direct_IO = cifs_direct_io,
3887         .invalidatepage = cifs_invalidate_page,
3888         .launder_page = cifs_launder_page,
3889 };
3890
3891 /*
3892  * cifs_readpages requires the server to support a buffer large enough to
3893  * contain the header plus one complete page of data.  Otherwise, we need
3894  * to leave cifs_readpages out of the address space operations.
3895  */
3896 const struct address_space_operations cifs_addr_ops_smallbuf = {
3897         .readpage = cifs_readpage,
3898         .writepage = cifs_writepage,
3899         .writepages = cifs_writepages,
3900         .write_begin = cifs_write_begin,
3901         .write_end = cifs_write_end,
3902         .set_page_dirty = __set_page_dirty_nobuffers,
3903         .releasepage = cifs_release_page,
3904         .invalidatepage = cifs_invalidate_page,
3905         .launder_page = cifs_launder_page,
3906 };