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