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                 locks_delete_block(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 cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1096         struct file_lock *flock, **before;
1097         unsigned int count = 0, i = 0;
1098         int rc = 0, xid, type;
1099         struct list_head locks_to_send, *el;
1100         struct lock_to_push *lck, *tmp;
1101         __u64 length;
1102
1103         xid = get_xid();
1104
1105         lock_flocks();
1106         cifs_for_each_lock(cfile->dentry->d_inode, before) {
1107                 if ((*before)->fl_flags & FL_POSIX)
1108                         count++;
1109         }
1110         unlock_flocks();
1111
1112         INIT_LIST_HEAD(&locks_to_send);
1113
1114         /*
1115          * Allocating count locks is enough because no FL_POSIX locks can be
1116          * added to the list while we are holding cinode->lock_sem that
1117          * protects locking operations of this inode.
1118          */
1119         for (; i < count; i++) {
1120                 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1121                 if (!lck) {
1122                         rc = -ENOMEM;
1123                         goto err_out;
1124                 }
1125                 list_add_tail(&lck->llist, &locks_to_send);
1126         }
1127
1128         el = locks_to_send.next;
1129         lock_flocks();
1130         cifs_for_each_lock(cfile->dentry->d_inode, before) {
1131                 flock = *before;
1132                 if ((flock->fl_flags & FL_POSIX) == 0)
1133                         continue;
1134                 if (el == &locks_to_send) {
1135                         /*
1136                          * The list ended. We don't have enough allocated
1137                          * structures - something is really wrong.
1138                          */
1139                         cifs_dbg(VFS, "Can't push all brlocks!\n");
1140                         break;
1141                 }
1142                 length = 1 + flock->fl_end - flock->fl_start;
1143                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1144                         type = CIFS_RDLCK;
1145                 else
1146                         type = CIFS_WRLCK;
1147                 lck = list_entry(el, struct lock_to_push, llist);
1148                 lck->pid = flock->fl_pid;
1149                 lck->netfid = cfile->fid.netfid;
1150                 lck->length = length;
1151                 lck->type = type;
1152                 lck->offset = flock->fl_start;
1153                 el = el->next;
1154         }
1155         unlock_flocks();
1156
1157         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1158                 int stored_rc;
1159
1160                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1161                                              lck->offset, lck->length, NULL,
1162                                              lck->type, 0);
1163                 if (stored_rc)
1164                         rc = stored_rc;
1165                 list_del(&lck->llist);
1166                 kfree(lck);
1167         }
1168
1169 out:
1170         free_xid(xid);
1171         return rc;
1172 err_out:
1173         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1174                 list_del(&lck->llist);
1175                 kfree(lck);
1176         }
1177         goto out;
1178 }
1179
1180 static int
1181 cifs_push_locks(struct cifsFileInfo *cfile)
1182 {
1183         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1184         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1185         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1186         int rc = 0;
1187
1188         /* we are going to update can_cache_brlcks here - need a write access */
1189         down_write(&cinode->lock_sem);
1190         if (!cinode->can_cache_brlcks) {
1191                 up_write(&cinode->lock_sem);
1192                 return rc;
1193         }
1194
1195         if (cap_unix(tcon->ses) &&
1196             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1197             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1198                 rc = cifs_push_posix_locks(cfile);
1199         else
1200                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1201
1202         cinode->can_cache_brlcks = false;
1203         up_write(&cinode->lock_sem);
1204         return rc;
1205 }
1206
1207 static void
1208 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1209                 bool *wait_flag, struct TCP_Server_Info *server)
1210 {
1211         if (flock->fl_flags & FL_POSIX)
1212                 cifs_dbg(FYI, "Posix\n");
1213         if (flock->fl_flags & FL_FLOCK)
1214                 cifs_dbg(FYI, "Flock\n");
1215         if (flock->fl_flags & FL_SLEEP) {
1216                 cifs_dbg(FYI, "Blocking lock\n");
1217                 *wait_flag = true;
1218         }
1219         if (flock->fl_flags & FL_ACCESS)
1220                 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1221         if (flock->fl_flags & FL_LEASE)
1222                 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1223         if (flock->fl_flags &
1224             (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1225                FL_ACCESS | FL_LEASE | FL_CLOSE)))
1226                 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1227
1228         *type = server->vals->large_lock_type;
1229         if (flock->fl_type == F_WRLCK) {
1230                 cifs_dbg(FYI, "F_WRLCK\n");
1231                 *type |= server->vals->exclusive_lock_type;
1232                 *lock = 1;
1233         } else if (flock->fl_type == F_UNLCK) {
1234                 cifs_dbg(FYI, "F_UNLCK\n");
1235                 *type |= server->vals->unlock_lock_type;
1236                 *unlock = 1;
1237                 /* Check if unlock includes more than one lock range */
1238         } else if (flock->fl_type == F_RDLCK) {
1239                 cifs_dbg(FYI, "F_RDLCK\n");
1240                 *type |= server->vals->shared_lock_type;
1241                 *lock = 1;
1242         } else if (flock->fl_type == F_EXLCK) {
1243                 cifs_dbg(FYI, "F_EXLCK\n");
1244                 *type |= server->vals->exclusive_lock_type;
1245                 *lock = 1;
1246         } else if (flock->fl_type == F_SHLCK) {
1247                 cifs_dbg(FYI, "F_SHLCK\n");
1248                 *type |= server->vals->shared_lock_type;
1249                 *lock = 1;
1250         } else
1251                 cifs_dbg(FYI, "Unknown type of lock\n");
1252 }
1253
1254 static int
1255 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1256            bool wait_flag, bool posix_lck, unsigned int xid)
1257 {
1258         int rc = 0;
1259         __u64 length = 1 + flock->fl_end - flock->fl_start;
1260         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1261         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1262         struct TCP_Server_Info *server = tcon->ses->server;
1263         __u16 netfid = cfile->fid.netfid;
1264
1265         if (posix_lck) {
1266                 int posix_lock_type;
1267
1268                 rc = cifs_posix_lock_test(file, flock);
1269                 if (!rc)
1270                         return rc;
1271
1272                 if (type & server->vals->shared_lock_type)
1273                         posix_lock_type = CIFS_RDLCK;
1274                 else
1275                         posix_lock_type = CIFS_WRLCK;
1276                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1277                                       flock->fl_start, length, flock,
1278                                       posix_lock_type, wait_flag);
1279                 return rc;
1280         }
1281
1282         rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1283         if (!rc)
1284                 return rc;
1285
1286         /* BB we could chain these into one lock request BB */
1287         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1288                                     1, 0, false);
1289         if (rc == 0) {
1290                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1291                                             type, 0, 1, false);
1292                 flock->fl_type = F_UNLCK;
1293                 if (rc != 0)
1294                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1295                                  rc);
1296                 return 0;
1297         }
1298
1299         if (type & server->vals->shared_lock_type) {
1300                 flock->fl_type = F_WRLCK;
1301                 return 0;
1302         }
1303
1304         type &= ~server->vals->exclusive_lock_type;
1305
1306         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1307                                     type | server->vals->shared_lock_type,
1308                                     1, 0, false);
1309         if (rc == 0) {
1310                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1311                         type | server->vals->shared_lock_type, 0, 1, false);
1312                 flock->fl_type = F_RDLCK;
1313                 if (rc != 0)
1314                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1315                                  rc);
1316         } else
1317                 flock->fl_type = F_WRLCK;
1318
1319         return 0;
1320 }
1321
1322 void
1323 cifs_move_llist(struct list_head *source, struct list_head *dest)
1324 {
1325         struct list_head *li, *tmp;
1326         list_for_each_safe(li, tmp, source)
1327                 list_move(li, dest);
1328 }
1329
1330 void
1331 cifs_free_llist(struct list_head *llist)
1332 {
1333         struct cifsLockInfo *li, *tmp;
1334         list_for_each_entry_safe(li, tmp, llist, llist) {
1335                 cifs_del_lock_waiters(li);
1336                 list_del(&li->llist);
1337                 kfree(li);
1338         }
1339 }
1340
1341 int
1342 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1343                   unsigned int xid)
1344 {
1345         int rc = 0, stored_rc;
1346         int types[] = {LOCKING_ANDX_LARGE_FILES,
1347                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1348         unsigned int i;
1349         unsigned int max_num, num, max_buf;
1350         LOCKING_ANDX_RANGE *buf, *cur;
1351         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1352         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1353         struct cifsLockInfo *li, *tmp;
1354         __u64 length = 1 + flock->fl_end - flock->fl_start;
1355         struct list_head tmp_llist;
1356
1357         INIT_LIST_HEAD(&tmp_llist);
1358
1359         /*
1360          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1361          * and check it for zero before using.
1362          */
1363         max_buf = tcon->ses->server->maxBuf;
1364         if (!max_buf)
1365                 return -EINVAL;
1366
1367         max_num = (max_buf - sizeof(struct smb_hdr)) /
1368                                                 sizeof(LOCKING_ANDX_RANGE);
1369         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1370         if (!buf)
1371                 return -ENOMEM;
1372
1373         down_write(&cinode->lock_sem);
1374         for (i = 0; i < 2; i++) {
1375                 cur = buf;
1376                 num = 0;
1377                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1378                         if (flock->fl_start > li->offset ||
1379                             (flock->fl_start + length) <
1380                             (li->offset + li->length))
1381                                 continue;
1382                         if (current->tgid != li->pid)
1383                                 continue;
1384                         if (types[i] != li->type)
1385                                 continue;
1386                         if (cinode->can_cache_brlcks) {
1387                                 /*
1388                                  * We can cache brlock requests - simply remove
1389                                  * a lock from the file's list.
1390                                  */
1391                                 list_del(&li->llist);
1392                                 cifs_del_lock_waiters(li);
1393                                 kfree(li);
1394                                 continue;
1395                         }
1396                         cur->Pid = cpu_to_le16(li->pid);
1397                         cur->LengthLow = cpu_to_le32((u32)li->length);
1398                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1399                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1400                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1401                         /*
1402                          * We need to save a lock here to let us add it again to
1403                          * the file's list if the unlock range request fails on
1404                          * the server.
1405                          */
1406                         list_move(&li->llist, &tmp_llist);
1407                         if (++num == max_num) {
1408                                 stored_rc = cifs_lockv(xid, tcon,
1409                                                        cfile->fid.netfid,
1410                                                        li->type, num, 0, buf);
1411                                 if (stored_rc) {
1412                                         /*
1413                                          * We failed on the unlock range
1414                                          * request - add all locks from the tmp
1415                                          * list to the head of the file's list.
1416                                          */
1417                                         cifs_move_llist(&tmp_llist,
1418                                                         &cfile->llist->locks);
1419                                         rc = stored_rc;
1420                                 } else
1421                                         /*
1422                                          * The unlock range request succeed -
1423                                          * free the tmp list.
1424                                          */
1425                                         cifs_free_llist(&tmp_llist);
1426                                 cur = buf;
1427                                 num = 0;
1428                         } else
1429                                 cur++;
1430                 }
1431                 if (num) {
1432                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1433                                                types[i], num, 0, buf);
1434                         if (stored_rc) {
1435                                 cifs_move_llist(&tmp_llist,
1436                                                 &cfile->llist->locks);
1437                                 rc = stored_rc;
1438                         } else
1439                                 cifs_free_llist(&tmp_llist);
1440                 }
1441         }
1442
1443         up_write(&cinode->lock_sem);
1444         kfree(buf);
1445         return rc;
1446 }
1447
1448 static int
1449 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1450            bool wait_flag, bool posix_lck, int lock, int unlock,
1451            unsigned int xid)
1452 {
1453         int rc = 0;
1454         __u64 length = 1 + flock->fl_end - flock->fl_start;
1455         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1456         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1457         struct TCP_Server_Info *server = tcon->ses->server;
1458         struct inode *inode = cfile->dentry->d_inode;
1459
1460         if (posix_lck) {
1461                 int posix_lock_type;
1462
1463                 rc = cifs_posix_lock_set(file, flock);
1464                 if (!rc || rc < 0)
1465                         return rc;
1466
1467                 if (type & server->vals->shared_lock_type)
1468                         posix_lock_type = CIFS_RDLCK;
1469                 else
1470                         posix_lock_type = CIFS_WRLCK;
1471
1472                 if (unlock == 1)
1473                         posix_lock_type = CIFS_UNLCK;
1474
1475                 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1476                                       current->tgid, flock->fl_start, length,
1477                                       NULL, posix_lock_type, wait_flag);
1478                 goto out;
1479         }
1480
1481         if (lock) {
1482                 struct cifsLockInfo *lock;
1483
1484                 lock = cifs_lock_init(flock->fl_start, length, type);
1485                 if (!lock)
1486                         return -ENOMEM;
1487
1488                 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1489                 if (rc < 0) {
1490                         kfree(lock);
1491                         return rc;
1492                 }
1493                 if (!rc)
1494                         goto out;
1495
1496                 /*
1497                  * Windows 7 server can delay breaking lease from read to None
1498                  * if we set a byte-range lock on a file - break it explicitly
1499                  * before sending the lock to the server to be sure the next
1500                  * read won't conflict with non-overlapted locks due to
1501                  * pagereading.
1502                  */
1503                 if (!CIFS_I(inode)->clientCanCacheAll &&
1504                                         CIFS_I(inode)->clientCanCacheRead) {
1505                         cifs_invalidate_mapping(inode);
1506                         cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1507                                  inode);
1508                         CIFS_I(inode)->clientCanCacheRead = false;
1509                 }
1510
1511                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1512                                             type, 1, 0, wait_flag);
1513                 if (rc) {
1514                         kfree(lock);
1515                         return rc;
1516                 }
1517
1518                 cifs_lock_add(cfile, lock);
1519         } else if (unlock)
1520                 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1521
1522 out:
1523         if (flock->fl_flags & FL_POSIX)
1524                 posix_lock_file_wait(file, flock);
1525         return rc;
1526 }
1527
1528 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1529 {
1530         int rc, xid;
1531         int lock = 0, unlock = 0;
1532         bool wait_flag = false;
1533         bool posix_lck = false;
1534         struct cifs_sb_info *cifs_sb;
1535         struct cifs_tcon *tcon;
1536         struct cifsInodeInfo *cinode;
1537         struct cifsFileInfo *cfile;
1538         __u16 netfid;
1539         __u32 type;
1540
1541         rc = -EACCES;
1542         xid = get_xid();
1543
1544         cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1545                  cmd, flock->fl_flags, flock->fl_type,
1546                  flock->fl_start, flock->fl_end);
1547
1548         cfile = (struct cifsFileInfo *)file->private_data;
1549         tcon = tlink_tcon(cfile->tlink);
1550
1551         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1552                         tcon->ses->server);
1553
1554         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1555         netfid = cfile->fid.netfid;
1556         cinode = CIFS_I(file_inode(file));
1557
1558         if (cap_unix(tcon->ses) &&
1559             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1560             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1561                 posix_lck = true;
1562         /*
1563          * BB add code here to normalize offset and length to account for
1564          * negative length which we can not accept over the wire.
1565          */
1566         if (IS_GETLK(cmd)) {
1567                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1568                 free_xid(xid);
1569                 return rc;
1570         }
1571
1572         if (!lock && !unlock) {
1573                 /*
1574                  * if no lock or unlock then nothing to do since we do not
1575                  * know what it is
1576                  */
1577                 free_xid(xid);
1578                 return -EOPNOTSUPP;
1579         }
1580
1581         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1582                         xid);
1583         free_xid(xid);
1584         return rc;
1585 }
1586
1587 /*
1588  * update the file size (if needed) after a write. Should be called with
1589  * the inode->i_lock held
1590  */
1591 void
1592 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1593                       unsigned int bytes_written)
1594 {
1595         loff_t end_of_write = offset + bytes_written;
1596
1597         if (end_of_write > cifsi->server_eof)
1598                 cifsi->server_eof = end_of_write;
1599 }
1600
1601 static ssize_t
1602 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1603            size_t write_size, loff_t *offset)
1604 {
1605         int rc = 0;
1606         unsigned int bytes_written = 0;
1607         unsigned int total_written;
1608         struct cifs_sb_info *cifs_sb;
1609         struct cifs_tcon *tcon;
1610         struct TCP_Server_Info *server;
1611         unsigned int xid;
1612         struct dentry *dentry = open_file->dentry;
1613         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1614         struct cifs_io_parms io_parms;
1615
1616         cifs_sb = CIFS_SB(dentry->d_sb);
1617
1618         cifs_dbg(FYI, "write %zd bytes to offset %lld of %s\n",
1619                  write_size, *offset, dentry->d_name.name);
1620
1621         tcon = tlink_tcon(open_file->tlink);
1622         server = tcon->ses->server;
1623
1624         if (!server->ops->sync_write)
1625                 return -ENOSYS;
1626
1627         xid = get_xid();
1628
1629         for (total_written = 0; write_size > total_written;
1630              total_written += bytes_written) {
1631                 rc = -EAGAIN;
1632                 while (rc == -EAGAIN) {
1633                         struct kvec iov[2];
1634                         unsigned int len;
1635
1636                         if (open_file->invalidHandle) {
1637                                 /* we could deadlock if we called
1638                                    filemap_fdatawait from here so tell
1639                                    reopen_file not to flush data to
1640                                    server now */
1641                                 rc = cifs_reopen_file(open_file, false);
1642                                 if (rc != 0)
1643                                         break;
1644                         }
1645
1646                         len = min((size_t)cifs_sb->wsize,
1647                                   write_size - total_written);
1648                         /* iov[0] is reserved for smb header */
1649                         iov[1].iov_base = (char *)write_data + total_written;
1650                         iov[1].iov_len = len;
1651                         io_parms.pid = pid;
1652                         io_parms.tcon = tcon;
1653                         io_parms.offset = *offset;
1654                         io_parms.length = len;
1655                         rc = server->ops->sync_write(xid, open_file, &io_parms,
1656                                                      &bytes_written, iov, 1);
1657                 }
1658                 if (rc || (bytes_written == 0)) {
1659                         if (total_written)
1660                                 break;
1661                         else {
1662                                 free_xid(xid);
1663                                 return rc;
1664                         }
1665                 } else {
1666                         spin_lock(&dentry->d_inode->i_lock);
1667                         cifs_update_eof(cifsi, *offset, bytes_written);
1668                         spin_unlock(&dentry->d_inode->i_lock);
1669                         *offset += bytes_written;
1670                 }
1671         }
1672
1673         cifs_stats_bytes_written(tcon, total_written);
1674
1675         if (total_written > 0) {
1676                 spin_lock(&dentry->d_inode->i_lock);
1677                 if (*offset > dentry->d_inode->i_size)
1678                         i_size_write(dentry->d_inode, *offset);
1679                 spin_unlock(&dentry->d_inode->i_lock);
1680         }
1681         mark_inode_dirty_sync(dentry->d_inode);
1682         free_xid(xid);
1683         return total_written;
1684 }
1685
1686 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1687                                         bool fsuid_only)
1688 {
1689         struct cifsFileInfo *open_file = NULL;
1690         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1691
1692         /* only filter by fsuid on multiuser mounts */
1693         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1694                 fsuid_only = false;
1695
1696         spin_lock(&cifs_file_list_lock);
1697         /* we could simply get the first_list_entry since write-only entries
1698            are always at the end of the list but since the first entry might
1699            have a close pending, we go through the whole list */
1700         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1701                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1702                         continue;
1703                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1704                         if (!open_file->invalidHandle) {
1705                                 /* found a good file */
1706                                 /* lock it so it will not be closed on us */
1707                                 cifsFileInfo_get_locked(open_file);
1708                                 spin_unlock(&cifs_file_list_lock);
1709                                 return open_file;
1710                         } /* else might as well continue, and look for
1711                              another, or simply have the caller reopen it
1712                              again rather than trying to fix this handle */
1713                 } else /* write only file */
1714                         break; /* write only files are last so must be done */
1715         }
1716         spin_unlock(&cifs_file_list_lock);
1717         return NULL;
1718 }
1719
1720 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1721                                         bool fsuid_only)
1722 {
1723         struct cifsFileInfo *open_file, *inv_file = NULL;
1724         struct cifs_sb_info *cifs_sb;
1725         bool any_available = false;
1726         int rc;
1727         unsigned int refind = 0;
1728
1729         /* Having a null inode here (because mapping->host was set to zero by
1730         the VFS or MM) should not happen but we had reports of on oops (due to
1731         it being zero) during stress testcases so we need to check for it */
1732
1733         if (cifs_inode == NULL) {
1734                 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1735                 dump_stack();
1736                 return NULL;
1737         }
1738
1739         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1740
1741         /* only filter by fsuid on multiuser mounts */
1742         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1743                 fsuid_only = false;
1744
1745         spin_lock(&cifs_file_list_lock);
1746 refind_writable:
1747         if (refind > MAX_REOPEN_ATT) {
1748                 spin_unlock(&cifs_file_list_lock);
1749                 return NULL;
1750         }
1751         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1752                 if (!any_available && open_file->pid != current->tgid)
1753                         continue;
1754                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1755                         continue;
1756                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1757                         if (!open_file->invalidHandle) {
1758                                 /* found a good writable file */
1759                                 cifsFileInfo_get_locked(open_file);
1760                                 spin_unlock(&cifs_file_list_lock);
1761                                 return open_file;
1762                         } else {
1763                                 if (!inv_file)
1764                                         inv_file = open_file;
1765                         }
1766                 }
1767         }
1768         /* couldn't find useable FH with same pid, try any available */
1769         if (!any_available) {
1770                 any_available = true;
1771                 goto refind_writable;
1772         }
1773
1774         if (inv_file) {
1775                 any_available = false;
1776                 cifsFileInfo_get_locked(inv_file);
1777         }
1778
1779         spin_unlock(&cifs_file_list_lock);
1780
1781         if (inv_file) {
1782                 rc = cifs_reopen_file(inv_file, false);
1783                 if (!rc)
1784                         return inv_file;
1785                 else {
1786                         spin_lock(&cifs_file_list_lock);
1787                         list_move_tail(&inv_file->flist,
1788                                         &cifs_inode->openFileList);
1789                         spin_unlock(&cifs_file_list_lock);
1790                         cifsFileInfo_put(inv_file);
1791                         spin_lock(&cifs_file_list_lock);
1792                         ++refind;
1793                         goto refind_writable;
1794                 }
1795         }
1796
1797         return NULL;
1798 }
1799
1800 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1801 {
1802         struct address_space *mapping = page->mapping;
1803         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1804         char *write_data;
1805         int rc = -EFAULT;
1806         int bytes_written = 0;
1807         struct inode *inode;
1808         struct cifsFileInfo *open_file;
1809
1810         if (!mapping || !mapping->host)
1811                 return -EFAULT;
1812
1813         inode = page->mapping->host;
1814
1815         offset += (loff_t)from;
1816         write_data = kmap(page);
1817         write_data += from;
1818
1819         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1820                 kunmap(page);
1821                 return -EIO;
1822         }
1823
1824         /* racing with truncate? */
1825         if (offset > mapping->host->i_size) {
1826                 kunmap(page);
1827                 return 0; /* don't care */
1828         }
1829
1830         /* check to make sure that we are not extending the file */
1831         if (mapping->host->i_size - offset < (loff_t)to)
1832                 to = (unsigned)(mapping->host->i_size - offset);
1833
1834         open_file = find_writable_file(CIFS_I(mapping->host), false);
1835         if (open_file) {
1836                 bytes_written = cifs_write(open_file, open_file->pid,
1837                                            write_data, to - from, &offset);
1838                 cifsFileInfo_put(open_file);
1839                 /* Does mm or vfs already set times? */
1840                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1841                 if ((bytes_written > 0) && (offset))
1842                         rc = 0;
1843                 else if (bytes_written < 0)
1844                         rc = bytes_written;
1845         } else {
1846                 cifs_dbg(FYI, "No writeable filehandles for inode\n");
1847                 rc = -EIO;
1848         }
1849
1850         kunmap(page);
1851         return rc;
1852 }
1853
1854 static int cifs_writepages(struct address_space *mapping,
1855                            struct writeback_control *wbc)
1856 {
1857         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1858         bool done = false, scanned = false, range_whole = false;
1859         pgoff_t end, index;
1860         struct cifs_writedata *wdata;
1861         struct TCP_Server_Info *server;
1862         struct page *page;
1863         int rc = 0;
1864
1865         /*
1866          * If wsize is smaller than the page cache size, default to writing
1867          * one page at a time via cifs_writepage
1868          */
1869         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1870                 return generic_writepages(mapping, wbc);
1871
1872         if (wbc->range_cyclic) {
1873                 index = mapping->writeback_index; /* Start from prev offset */
1874                 end = -1;
1875         } else {
1876                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1877                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1878                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1879                         range_whole = true;
1880                 scanned = true;
1881         }
1882 retry:
1883         while (!done && index <= end) {
1884                 unsigned int i, nr_pages, found_pages;
1885                 pgoff_t next = 0, tofind;
1886                 struct page **pages;
1887
1888                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1889                                 end - index) + 1;
1890
1891                 wdata = cifs_writedata_alloc((unsigned int)tofind,
1892                                              cifs_writev_complete);
1893                 if (!wdata) {
1894                         rc = -ENOMEM;
1895                         break;
1896                 }
1897
1898                 /*
1899                  * find_get_pages_tag seems to return a max of 256 on each
1900                  * iteration, so we must call it several times in order to
1901                  * fill the array or the wsize is effectively limited to
1902                  * 256 * PAGE_CACHE_SIZE.
1903                  */
1904                 found_pages = 0;
1905                 pages = wdata->pages;
1906                 do {
1907                         nr_pages = find_get_pages_tag(mapping, &index,
1908                                                         PAGECACHE_TAG_DIRTY,
1909                                                         tofind, pages);
1910                         found_pages += nr_pages;
1911                         tofind -= nr_pages;
1912                         pages += nr_pages;
1913                 } while (nr_pages && tofind && index <= end);
1914
1915                 if (found_pages == 0) {
1916                         kref_put(&wdata->refcount, cifs_writedata_release);
1917                         break;
1918                 }
1919
1920                 nr_pages = 0;
1921                 for (i = 0; i < found_pages; i++) {
1922                         page = wdata->pages[i];
1923                         /*
1924                          * At this point we hold neither mapping->tree_lock nor
1925                          * lock on the page itself: the page may be truncated or
1926                          * invalidated (changing page->mapping to NULL), or even
1927                          * swizzled back from swapper_space to tmpfs file
1928                          * mapping
1929                          */
1930
1931                         if (nr_pages == 0)
1932                                 lock_page(page);
1933                         else if (!trylock_page(page))
1934                                 break;
1935
1936                         if (unlikely(page->mapping != mapping)) {
1937                                 unlock_page(page);
1938                                 break;
1939                         }
1940
1941                         if (!wbc->range_cyclic && page->index > end) {
1942                                 done = true;
1943                                 unlock_page(page);
1944                                 break;
1945                         }
1946
1947                         if (next && (page->index != next)) {
1948                                 /* Not next consecutive page */
1949                                 unlock_page(page);
1950                                 break;
1951                         }
1952
1953                         if (wbc->sync_mode != WB_SYNC_NONE)
1954                                 wait_on_page_writeback(page);
1955
1956                         if (PageWriteback(page) ||
1957                                         !clear_page_dirty_for_io(page)) {
1958                                 unlock_page(page);
1959                                 break;
1960                         }
1961
1962                         /*
1963                          * This actually clears the dirty bit in the radix tree.
1964                          * See cifs_writepage() for more commentary.
1965                          */
1966                         set_page_writeback(page);
1967
1968                         if (page_offset(page) >= i_size_read(mapping->host)) {
1969                                 done = true;
1970                                 unlock_page(page);
1971                                 end_page_writeback(page);
1972                                 break;
1973                         }
1974
1975                         wdata->pages[i] = page;
1976                         next = page->index + 1;
1977                         ++nr_pages;
1978                 }
1979
1980                 /* reset index to refind any pages skipped */
1981                 if (nr_pages == 0)
1982                         index = wdata->pages[0]->index + 1;
1983
1984                 /* put any pages we aren't going to use */
1985                 for (i = nr_pages; i < found_pages; i++) {
1986                         page_cache_release(wdata->pages[i]);
1987                         wdata->pages[i] = NULL;
1988                 }
1989
1990                 /* nothing to write? */
1991                 if (nr_pages == 0) {
1992                         kref_put(&wdata->refcount, cifs_writedata_release);
1993                         continue;
1994                 }
1995
1996                 wdata->sync_mode = wbc->sync_mode;
1997                 wdata->nr_pages = nr_pages;
1998                 wdata->offset = page_offset(wdata->pages[0]);
1999                 wdata->pagesz = PAGE_CACHE_SIZE;
2000                 wdata->tailsz =
2001                         min(i_size_read(mapping->host) -
2002                             page_offset(wdata->pages[nr_pages - 1]),
2003                             (loff_t)PAGE_CACHE_SIZE);
2004                 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) +
2005                                         wdata->tailsz;
2006
2007                 do {
2008                         if (wdata->cfile != NULL)
2009                                 cifsFileInfo_put(wdata->cfile);
2010                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
2011                                                           false);
2012                         if (!wdata->cfile) {
2013                                 cifs_dbg(VFS, "No writable handles for inode\n");
2014                                 rc = -EBADF;
2015                                 break;
2016                         }
2017                         wdata->pid = wdata->cfile->pid;
2018                         server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2019                         rc = server->ops->async_writev(wdata);
2020                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
2021
2022                 for (i = 0; i < nr_pages; ++i)
2023                         unlock_page(wdata->pages[i]);
2024
2025                 /* send failure -- clean up the mess */
2026                 if (rc != 0) {
2027                         for (i = 0; i < nr_pages; ++i) {
2028                                 if (rc == -EAGAIN)
2029                                         redirty_page_for_writepage(wbc,
2030                                                            wdata->pages[i]);
2031                                 else
2032                                         SetPageError(wdata->pages[i]);
2033                                 end_page_writeback(wdata->pages[i]);
2034                                 page_cache_release(wdata->pages[i]);
2035                         }
2036                         if (rc != -EAGAIN)
2037                                 mapping_set_error(mapping, rc);
2038                 }
2039                 kref_put(&wdata->refcount, cifs_writedata_release);
2040
2041                 wbc->nr_to_write -= nr_pages;
2042                 if (wbc->nr_to_write <= 0)
2043                         done = true;
2044
2045                 index = next;
2046         }
2047
2048         if (!scanned && !done) {
2049                 /*
2050                  * We hit the last page and there is more work to be done: wrap
2051                  * back to the start of the file
2052                  */
2053                 scanned = true;
2054                 index = 0;
2055                 goto retry;
2056         }
2057
2058         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2059                 mapping->writeback_index = index;
2060
2061         return rc;
2062 }
2063
2064 static int
2065 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2066 {
2067         int rc;
2068         unsigned int xid;
2069
2070         xid = get_xid();
2071 /* BB add check for wbc flags */
2072         page_cache_get(page);
2073         if (!PageUptodate(page))
2074                 cifs_dbg(FYI, "ppw - page not up to date\n");
2075
2076         /*
2077          * Set the "writeback" flag, and clear "dirty" in the radix tree.
2078          *
2079          * A writepage() implementation always needs to do either this,
2080          * or re-dirty the page with "redirty_page_for_writepage()" in
2081          * the case of a failure.
2082          *
2083          * Just unlocking the page will cause the radix tree tag-bits
2084          * to fail to update with the state of the page correctly.
2085          */
2086         set_page_writeback(page);
2087 retry_write:
2088         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
2089         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2090                 goto retry_write;
2091         else if (rc == -EAGAIN)
2092                 redirty_page_for_writepage(wbc, page);
2093         else if (rc != 0)
2094                 SetPageError(page);
2095         else
2096                 SetPageUptodate(page);
2097         end_page_writeback(page);
2098         page_cache_release(page);
2099         free_xid(xid);
2100         return rc;
2101 }
2102
2103 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2104 {
2105         int rc = cifs_writepage_locked(page, wbc);
2106         unlock_page(page);
2107         return rc;
2108 }
2109
2110 static int cifs_write_end(struct file *file, struct address_space *mapping,
2111                         loff_t pos, unsigned len, unsigned copied,
2112                         struct page *page, void *fsdata)
2113 {
2114         int rc;
2115         struct inode *inode = mapping->host;
2116         struct cifsFileInfo *cfile = file->private_data;
2117         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2118         __u32 pid;
2119
2120         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2121                 pid = cfile->pid;
2122         else
2123                 pid = current->tgid;
2124
2125         cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2126                  page, pos, copied);
2127
2128         if (PageChecked(page)) {
2129                 if (copied == len)
2130                         SetPageUptodate(page);
2131                 ClearPageChecked(page);
2132         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
2133                 SetPageUptodate(page);
2134
2135         if (!PageUptodate(page)) {
2136                 char *page_data;
2137                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
2138                 unsigned int xid;
2139
2140                 xid = get_xid();
2141                 /* this is probably better than directly calling
2142                    partialpage_write since in this function the file handle is
2143                    known which we might as well leverage */
2144                 /* BB check if anything else missing out of ppw
2145                    such as updating last write time */
2146                 page_data = kmap(page);
2147                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2148                 /* if (rc < 0) should we set writebehind rc? */
2149                 kunmap(page);
2150
2151                 free_xid(xid);
2152         } else {
2153                 rc = copied;
2154                 pos += copied;
2155                 set_page_dirty(page);
2156         }
2157
2158         if (rc > 0) {
2159                 spin_lock(&inode->i_lock);
2160                 if (pos > inode->i_size)
2161                         i_size_write(inode, pos);
2162                 spin_unlock(&inode->i_lock);
2163         }
2164
2165         unlock_page(page);
2166         page_cache_release(page);
2167
2168         return rc;
2169 }
2170
2171 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2172                       int datasync)
2173 {
2174         unsigned int xid;
2175         int rc = 0;
2176         struct cifs_tcon *tcon;
2177         struct TCP_Server_Info *server;
2178         struct cifsFileInfo *smbfile = file->private_data;
2179         struct inode *inode = file_inode(file);
2180         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2181
2182         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2183         if (rc)
2184                 return rc;
2185         mutex_lock(&inode->i_mutex);
2186
2187         xid = get_xid();
2188
2189         cifs_dbg(FYI, "Sync file - name: %s datasync: 0x%x\n",
2190                  file->f_path.dentry->d_name.name, datasync);
2191
2192         if (!CIFS_I(inode)->clientCanCacheRead) {
2193                 rc = cifs_invalidate_mapping(inode);
2194                 if (rc) {
2195                         cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2196                         rc = 0; /* don't care about it in fsync */
2197                 }
2198         }
2199
2200         tcon = tlink_tcon(smbfile->tlink);
2201         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2202                 server = tcon->ses->server;
2203                 if (server->ops->flush)
2204                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2205                 else
2206                         rc = -ENOSYS;
2207         }
2208
2209         free_xid(xid);
2210         mutex_unlock(&inode->i_mutex);
2211         return rc;
2212 }
2213
2214 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2215 {
2216         unsigned int xid;
2217         int rc = 0;
2218         struct cifs_tcon *tcon;
2219         struct TCP_Server_Info *server;
2220         struct cifsFileInfo *smbfile = file->private_data;
2221         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2222         struct inode *inode = file->f_mapping->host;
2223
2224         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2225         if (rc)
2226                 return rc;
2227         mutex_lock(&inode->i_mutex);
2228
2229         xid = get_xid();
2230
2231         cifs_dbg(FYI, "Sync file - name: %s datasync: 0x%x\n",
2232                  file->f_path.dentry->d_name.name, datasync);
2233
2234         tcon = tlink_tcon(smbfile->tlink);
2235         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2236                 server = tcon->ses->server;
2237                 if (server->ops->flush)
2238                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2239                 else
2240                         rc = -ENOSYS;
2241         }
2242
2243         free_xid(xid);
2244         mutex_unlock(&inode->i_mutex);
2245         return rc;
2246 }
2247
2248 /*
2249  * As file closes, flush all cached write data for this inode checking
2250  * for write behind errors.
2251  */
2252 int cifs_flush(struct file *file, fl_owner_t id)
2253 {
2254         struct inode *inode = file_inode(file);
2255         int rc = 0;
2256
2257         if (file->f_mode & FMODE_WRITE)
2258                 rc = filemap_write_and_wait(inode->i_mapping);
2259
2260         cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2261
2262         return rc;
2263 }
2264
2265 static int
2266 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2267 {
2268         int rc = 0;
2269         unsigned long i;
2270
2271         for (i = 0; i < num_pages; i++) {
2272                 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2273                 if (!pages[i]) {
2274                         /*
2275                          * save number of pages we have already allocated and
2276                          * return with ENOMEM error
2277                          */
2278                         num_pages = i;
2279                         rc = -ENOMEM;
2280                         break;
2281                 }
2282         }
2283
2284         if (rc) {
2285                 for (i = 0; i < num_pages; i++)
2286                         put_page(pages[i]);
2287         }
2288         return rc;
2289 }
2290
2291 static inline
2292 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2293 {
2294         size_t num_pages;
2295         size_t clen;
2296
2297         clen = min_t(const size_t, len, wsize);
2298         num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2299
2300         if (cur_len)
2301                 *cur_len = clen;
2302
2303         return num_pages;
2304 }
2305
2306 static void
2307 cifs_uncached_writev_complete(struct work_struct *work)
2308 {
2309         int i;
2310         struct cifs_writedata *wdata = container_of(work,
2311                                         struct cifs_writedata, work);
2312         struct inode *inode = wdata->cfile->dentry->d_inode;
2313         struct cifsInodeInfo *cifsi = CIFS_I(inode);
2314
2315         spin_lock(&inode->i_lock);
2316         cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2317         if (cifsi->server_eof > inode->i_size)
2318                 i_size_write(inode, cifsi->server_eof);
2319         spin_unlock(&inode->i_lock);
2320
2321         complete(&wdata->done);
2322
2323         if (wdata->result != -EAGAIN) {
2324                 for (i = 0; i < wdata->nr_pages; i++)
2325                         put_page(wdata->pages[i]);
2326         }
2327
2328         kref_put(&wdata->refcount, cifs_writedata_release);
2329 }
2330
2331 /* attempt to send write to server, retry on any -EAGAIN errors */
2332 static int
2333 cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2334 {
2335         int rc;
2336         struct TCP_Server_Info *server;
2337
2338         server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2339
2340         do {
2341                 if (wdata->cfile->invalidHandle) {
2342                         rc = cifs_reopen_file(wdata->cfile, false);
2343                         if (rc != 0)
2344                                 continue;
2345                 }
2346                 rc = server->ops->async_writev(wdata);
2347         } while (rc == -EAGAIN);
2348
2349         return rc;
2350 }
2351
2352 static ssize_t
2353 cifs_iovec_write(struct file *file, const struct iovec *iov,
2354                  unsigned long nr_segs, loff_t *poffset)
2355 {
2356         unsigned long nr_pages, i;
2357         size_t copied, len, cur_len;
2358         ssize_t total_written = 0;
2359         loff_t offset;
2360         struct iov_iter it;
2361         struct cifsFileInfo *open_file;
2362         struct cifs_tcon *tcon;
2363         struct cifs_sb_info *cifs_sb;
2364         struct cifs_writedata *wdata, *tmp;
2365         struct list_head wdata_list;
2366         int rc;
2367         pid_t pid;
2368
2369         len = iov_length(iov, nr_segs);
2370         if (!len)
2371                 return 0;
2372
2373         rc = generic_write_checks(file, poffset, &len, 0);
2374         if (rc)
2375                 return rc;
2376
2377         INIT_LIST_HEAD(&wdata_list);
2378         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2379         open_file = file->private_data;
2380         tcon = tlink_tcon(open_file->tlink);
2381
2382         if (!tcon->ses->server->ops->async_writev)
2383                 return -ENOSYS;
2384
2385         offset = *poffset;
2386
2387         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2388                 pid = open_file->pid;
2389         else
2390                 pid = current->tgid;
2391
2392         iov_iter_init(&it, iov, nr_segs, len, 0);
2393         do {
2394                 size_t save_len;
2395
2396                 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2397                 wdata = cifs_writedata_alloc(nr_pages,
2398                                              cifs_uncached_writev_complete);
2399                 if (!wdata) {
2400                         rc = -ENOMEM;
2401                         break;
2402                 }
2403
2404                 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2405                 if (rc) {
2406                         kfree(wdata);
2407                         break;
2408                 }
2409
2410                 save_len = cur_len;
2411                 for (i = 0; i < nr_pages; i++) {
2412                         copied = min_t(const size_t, cur_len, PAGE_SIZE);
2413                         copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2414                                                          0, copied);
2415                         cur_len -= copied;
2416                         iov_iter_advance(&it, copied);
2417                 }
2418                 cur_len = save_len - cur_len;
2419
2420                 wdata->sync_mode = WB_SYNC_ALL;
2421                 wdata->nr_pages = nr_pages;
2422                 wdata->offset = (__u64)offset;
2423                 wdata->cfile = cifsFileInfo_get(open_file);
2424                 wdata->pid = pid;
2425                 wdata->bytes = cur_len;
2426                 wdata->pagesz = PAGE_SIZE;
2427                 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2428                 rc = cifs_uncached_retry_writev(wdata);
2429                 if (rc) {
2430                         kref_put(&wdata->refcount, cifs_writedata_release);
2431                         break;
2432                 }
2433
2434                 list_add_tail(&wdata->list, &wdata_list);
2435                 offset += cur_len;
2436                 len -= cur_len;
2437         } while (len > 0);
2438
2439         /*
2440          * If at least one write was successfully sent, then discard any rc
2441          * value from the later writes. If the other write succeeds, then
2442          * we'll end up returning whatever was written. If it fails, then
2443          * we'll get a new rc value from that.
2444          */
2445         if (!list_empty(&wdata_list))
2446                 rc = 0;
2447
2448         /*
2449          * Wait for and collect replies for any successful sends in order of
2450          * increasing offset. Once an error is hit or we get a fatal signal
2451          * while waiting, then return without waiting for any more replies.
2452          */
2453 restart_loop:
2454         list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2455                 if (!rc) {
2456                         /* FIXME: freezable too? */
2457                         rc = wait_for_completion_killable(&wdata->done);
2458                         if (rc)
2459                                 rc = -EINTR;
2460                         else if (wdata->result)
2461                                 rc = wdata->result;
2462                         else
2463                                 total_written += wdata->bytes;
2464
2465                         /* resend call if it's a retryable error */
2466                         if (rc == -EAGAIN) {
2467                                 rc = cifs_uncached_retry_writev(wdata);
2468                                 goto restart_loop;
2469                         }
2470                 }
2471                 list_del_init(&wdata->list);
2472                 kref_put(&wdata->refcount, cifs_writedata_release);
2473         }
2474
2475         if (total_written > 0)
2476                 *poffset += total_written;
2477
2478         cifs_stats_bytes_written(tcon, total_written);
2479         return total_written ? total_written : (ssize_t)rc;
2480 }
2481
2482 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2483                                 unsigned long nr_segs, loff_t pos)
2484 {
2485         ssize_t written;
2486         struct inode *inode;
2487
2488         inode = file_inode(iocb->ki_filp);
2489
2490         /*
2491          * BB - optimize the way when signing is disabled. We can drop this
2492          * extra memory-to-memory copying and use iovec buffers for constructing
2493          * write request.
2494          */
2495
2496         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2497         if (written > 0) {
2498                 CIFS_I(inode)->invalid_mapping = true;
2499                 iocb->ki_pos = pos;
2500         }
2501
2502         return written;
2503 }
2504
2505 static ssize_t
2506 cifs_writev(struct kiocb *iocb, const struct iovec *iov,
2507             unsigned long nr_segs, loff_t pos)
2508 {
2509         struct file *file = iocb->ki_filp;
2510         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2511         struct inode *inode = file->f_mapping->host;
2512         struct cifsInodeInfo *cinode = CIFS_I(inode);
2513         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2514         ssize_t rc = -EACCES;
2515
2516         BUG_ON(iocb->ki_pos != pos);
2517
2518         /*
2519          * We need to hold the sem to be sure nobody modifies lock list
2520          * with a brlock that prevents writing.
2521          */
2522         down_read(&cinode->lock_sem);
2523         if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2524                                      server->vals->exclusive_lock_type, NULL,
2525                                      CIFS_WRITE_OP)) {
2526                 mutex_lock(&inode->i_mutex);
2527                 rc = __generic_file_aio_write(iocb, iov, nr_segs,
2528                                                &iocb->ki_pos);
2529                 mutex_unlock(&inode->i_mutex);
2530         }
2531
2532         if (rc > 0 || rc == -EIOCBQUEUED) {
2533                 ssize_t err;
2534
2535                 err = generic_write_sync(file, pos, rc);
2536                 if (err < 0 && rc > 0)
2537                         rc = err;
2538         }
2539
2540         up_read(&cinode->lock_sem);
2541         return rc;
2542 }
2543
2544 ssize_t
2545 cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2546                    unsigned long nr_segs, loff_t pos)
2547 {
2548         struct inode *inode = file_inode(iocb->ki_filp);
2549         struct cifsInodeInfo *cinode = CIFS_I(inode);
2550         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2551         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2552                                                 iocb->ki_filp->private_data;
2553         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2554         ssize_t written;
2555
2556         if (cinode->clientCanCacheAll) {
2557                 if (cap_unix(tcon->ses) &&
2558                 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2559                     && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2560                         return generic_file_aio_write(iocb, iov, nr_segs, pos);
2561                 return cifs_writev(iocb, iov, nr_segs, pos);
2562         }
2563         /*
2564          * For non-oplocked files in strict cache mode we need to write the data
2565          * to the server exactly from the pos to pos+len-1 rather than flush all
2566          * affected pages because it may cause a error with mandatory locks on
2567          * these pages but not on the region from pos to ppos+len-1.
2568          */
2569         written = cifs_user_writev(iocb, iov, nr_segs, pos);
2570         if (written > 0 && cinode->clientCanCacheRead) {
2571                 /*
2572                  * Windows 7 server can delay breaking level2 oplock if a write
2573                  * request comes - break it on the client to prevent reading
2574                  * an old data.
2575                  */
2576                 cifs_invalidate_mapping(inode);
2577                 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2578                          inode);
2579                 cinode->clientCanCacheRead = false;
2580         }
2581         return written;
2582 }
2583
2584 static struct cifs_readdata *
2585 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2586 {
2587         struct cifs_readdata *rdata;
2588
2589         rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2590                         GFP_KERNEL);
2591         if (rdata != NULL) {
2592                 kref_init(&rdata->refcount);
2593                 INIT_LIST_HEAD(&rdata->list);
2594                 init_completion(&rdata->done);
2595                 INIT_WORK(&rdata->work, complete);
2596         }
2597
2598         return rdata;
2599 }
2600
2601 void
2602 cifs_readdata_release(struct kref *refcount)
2603 {
2604         struct cifs_readdata *rdata = container_of(refcount,
2605                                         struct cifs_readdata, refcount);
2606
2607         if (rdata->cfile)
2608                 cifsFileInfo_put(rdata->cfile);
2609
2610         kfree(rdata);
2611 }
2612
2613 static int
2614 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2615 {
2616         int rc = 0;
2617         struct page *page;
2618         unsigned int i;
2619
2620         for (i = 0; i < nr_pages; i++) {
2621                 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2622                 if (!page) {
2623                         rc = -ENOMEM;
2624                         break;
2625                 }
2626                 rdata->pages[i] = page;
2627         }
2628
2629         if (rc) {
2630                 for (i = 0; i < nr_pages; i++) {
2631                         put_page(rdata->pages[i]);
2632                         rdata->pages[i] = NULL;
2633                 }
2634         }
2635         return rc;
2636 }
2637
2638 static void
2639 cifs_uncached_readdata_release(struct kref *refcount)
2640 {
2641         struct cifs_readdata *rdata = container_of(refcount,
2642                                         struct cifs_readdata, refcount);
2643         unsigned int i;
2644
2645         for (i = 0; i < rdata->nr_pages; i++) {
2646                 put_page(rdata->pages[i]);
2647                 rdata->pages[i] = NULL;
2648         }
2649         cifs_readdata_release(refcount);
2650 }
2651
2652 static int
2653 cifs_retry_async_readv(struct cifs_readdata *rdata)
2654 {
2655         int rc;
2656         struct TCP_Server_Info *server;
2657
2658         server = tlink_tcon(rdata->cfile->tlink)->ses->server;
2659
2660         do {
2661                 if (rdata->cfile->invalidHandle) {
2662                         rc = cifs_reopen_file(rdata->cfile, true);
2663                         if (rc != 0)
2664                                 continue;
2665                 }
2666                 rc = server->ops->async_readv(rdata);
2667         } while (rc == -EAGAIN);
2668
2669         return rc;
2670 }
2671
2672 /**
2673  * cifs_readdata_to_iov - copy data from pages in response to an iovec
2674  * @rdata:      the readdata response with list of pages holding data
2675  * @iov:        vector in which we should copy the data
2676  * @nr_segs:    number of segments in vector
2677  * @offset:     offset into file of the first iovec
2678  * @copied:     used to return the amount of data copied to the iov
2679  *
2680  * This function copies data from a list of pages in a readdata response into
2681  * an array of iovecs. It will first calculate where the data should go
2682  * based on the info in the readdata and then copy the data into that spot.
2683  */
2684 static ssize_t
2685 cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2686                         unsigned long nr_segs, loff_t offset, ssize_t *copied)
2687 {
2688         int rc = 0;
2689         struct iov_iter ii;
2690         size_t pos = rdata->offset - offset;
2691         ssize_t remaining = rdata->bytes;
2692         unsigned char *pdata;
2693         unsigned int i;
2694
2695         /* set up iov_iter and advance to the correct offset */
2696         iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2697         iov_iter_advance(&ii, pos);
2698
2699         *copied = 0;
2700         for (i = 0; i < rdata->nr_pages; i++) {
2701                 ssize_t copy;
2702                 struct page *page = rdata->pages[i];
2703
2704                 /* copy a whole page or whatever's left */
2705                 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2706
2707                 /* ...but limit it to whatever space is left in the iov */
2708                 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2709
2710                 /* go while there's data to be copied and no errors */
2711                 if (copy && !rc) {
2712                         pdata = kmap(page);
2713                         rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2714                                                 (int)copy);
2715                         kunmap(page);
2716                         if (!rc) {
2717                                 *copied += copy;
2718                                 remaining -= copy;
2719                                 iov_iter_advance(&ii, copy);
2720                         }
2721                 }
2722         }
2723
2724         return rc;
2725 }
2726
2727 static void
2728 cifs_uncached_readv_complete(struct work_struct *work)
2729 {
2730         struct cifs_readdata *rdata = container_of(work,
2731                                                 struct cifs_readdata, work);
2732
2733         complete(&rdata->done);
2734         kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2735 }
2736
2737 static int
2738 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2739                         struct cifs_readdata *rdata, unsigned int len)
2740 {
2741         int total_read = 0, result = 0;
2742         unsigned int i;
2743         unsigned int nr_pages = rdata->nr_pages;
2744         struct kvec iov;
2745
2746         rdata->tailsz = PAGE_SIZE;
2747         for (i = 0; i < nr_pages; i++) {
2748                 struct page *page = rdata->pages[i];
2749
2750                 if (len >= PAGE_SIZE) {
2751                         /* enough data to fill the page */
2752                         iov.iov_base = kmap(page);
2753                         iov.iov_len = PAGE_SIZE;
2754                         cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2755                                  i, iov.iov_base, iov.iov_len);
2756                         len -= PAGE_SIZE;
2757                 } else if (len > 0) {
2758                         /* enough for partial page, fill and zero the rest */
2759                         iov.iov_base = kmap(page);
2760                         iov.iov_len = len;
2761                         cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2762                                  i, iov.iov_base, iov.iov_len);
2763                         memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2764                         rdata->tailsz = len;
2765                         len = 0;
2766                 } else {
2767                         /* no need to hold page hostage */
2768                         rdata->pages[i] = NULL;
2769                         rdata->nr_pages--;
2770                         put_page(page);
2771                         continue;
2772                 }
2773
2774                 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2775                 kunmap(page);
2776                 if (result < 0)
2777                         break;
2778
2779                 total_read += result;
2780         }
2781
2782         return total_read > 0 ? total_read : result;
2783 }
2784
2785 static ssize_t
2786 cifs_iovec_read(struct file *file, const struct iovec *iov,
2787                  unsigned long nr_segs, loff_t *poffset)
2788 {
2789         ssize_t rc;
2790         size_t len, cur_len;
2791         ssize_t total_read = 0;
2792         loff_t offset = *poffset;
2793         unsigned int npages;
2794         struct cifs_sb_info *cifs_sb;
2795         struct cifs_tcon *tcon;
2796         struct cifsFileInfo *open_file;
2797         struct cifs_readdata *rdata, *tmp;
2798         struct list_head rdata_list;
2799         pid_t pid;
2800
2801         if (!nr_segs)
2802                 return 0;
2803
2804         len = iov_length(iov, nr_segs);
2805         if (!len)
2806                 return 0;
2807
2808         INIT_LIST_HEAD(&rdata_list);
2809         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2810         open_file = file->private_data;
2811         tcon = tlink_tcon(open_file->tlink);
2812
2813         if (!tcon->ses->server->ops->async_readv)
2814                 return -ENOSYS;
2815
2816         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2817                 pid = open_file->pid;
2818         else
2819                 pid = current->tgid;
2820
2821         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2822                 cifs_dbg(FYI, "attempting read on write only file instance\n");
2823
2824         do {
2825                 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2826                 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2827
2828                 /* allocate a readdata struct */
2829                 rdata = cifs_readdata_alloc(npages,
2830                                             cifs_uncached_readv_complete);
2831                 if (!rdata) {
2832                         rc = -ENOMEM;
2833                         goto error;
2834                 }
2835
2836                 rc = cifs_read_allocate_pages(rdata, npages);
2837                 if (rc)
2838                         goto error;
2839
2840                 rdata->cfile = cifsFileInfo_get(open_file);
2841                 rdata->nr_pages = npages;
2842                 rdata->offset = offset;
2843                 rdata->bytes = cur_len;
2844                 rdata->pid = pid;
2845                 rdata->pagesz = PAGE_SIZE;
2846                 rdata->read_into_pages = cifs_uncached_read_into_pages;
2847
2848                 rc = cifs_retry_async_readv(rdata);
2849 error:
2850                 if (rc) {
2851                         kref_put(&rdata->refcount,
2852                                  cifs_uncached_readdata_release);
2853                         break;
2854                 }
2855
2856                 list_add_tail(&rdata->list, &rdata_list);
2857                 offset += cur_len;
2858                 len -= cur_len;
2859         } while (len > 0);
2860
2861         /* if at least one read request send succeeded, then reset rc */
2862         if (!list_empty(&rdata_list))
2863                 rc = 0;
2864
2865         /* the loop below should proceed in the order of increasing offsets */
2866 restart_loop:
2867         list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2868                 if (!rc) {
2869                         ssize_t copied;
2870
2871                         /* FIXME: freezable sleep too? */
2872                         rc = wait_for_completion_killable(&rdata->done);
2873                         if (rc)
2874                                 rc = -EINTR;
2875                         else if (rdata->result)
2876                                 rc = rdata->result;
2877                         else {
2878                                 rc = cifs_readdata_to_iov(rdata, iov,
2879                                                         nr_segs, *poffset,
2880                                                         &copied);
2881                                 total_read += copied;
2882                         }
2883
2884                         /* resend call if it's a retryable error */
2885                         if (rc == -EAGAIN) {
2886                                 rc = cifs_retry_async_readv(rdata);
2887                                 goto restart_loop;
2888                         }
2889                 }
2890                 list_del_init(&rdata->list);
2891                 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2892         }
2893
2894         cifs_stats_bytes_read(tcon, total_read);
2895         *poffset += total_read;
2896
2897         /* mask nodata case */
2898         if (rc == -ENODATA)
2899                 rc = 0;
2900
2901         return total_read ? total_read : rc;
2902 }
2903
2904 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2905                                unsigned long nr_segs, loff_t pos)
2906 {
2907         ssize_t read;
2908
2909         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2910         if (read > 0)
2911                 iocb->ki_pos = pos;
2912
2913         return read;
2914 }
2915
2916 ssize_t
2917 cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2918                   unsigned long nr_segs, loff_t pos)
2919 {
2920         struct inode *inode = file_inode(iocb->ki_filp);
2921         struct cifsInodeInfo *cinode = CIFS_I(inode);
2922         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2923         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2924                                                 iocb->ki_filp->private_data;
2925         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2926         int rc = -EACCES;
2927
2928         /*
2929          * In strict cache mode we need to read from the server all the time
2930          * if we don't have level II oplock because the server can delay mtime
2931          * change - so we can't make a decision about inode invalidating.
2932          * And we can also fail with pagereading if there are mandatory locks
2933          * on pages affected by this read but not on the region from pos to
2934          * pos+len-1.
2935          */
2936         if (!cinode->clientCanCacheRead)
2937                 return cifs_user_readv(iocb, iov, nr_segs, pos);
2938
2939         if (cap_unix(tcon->ses) &&
2940             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2941             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2942                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2943
2944         /*
2945          * We need to hold the sem to be sure nobody modifies lock list
2946          * with a brlock that prevents reading.
2947          */
2948         down_read(&cinode->lock_sem);
2949         if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2950                                      tcon->ses->server->vals->shared_lock_type,
2951                                      NULL, CIFS_READ_OP))
2952                 rc = generic_file_aio_read(iocb, iov, nr_segs, pos);
2953         up_read(&cinode->lock_sem);
2954         return rc;
2955 }
2956
2957 static ssize_t
2958 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
2959 {
2960         int rc = -EACCES;
2961         unsigned int bytes_read = 0;
2962         unsigned int total_read;
2963         unsigned int current_read_size;
2964         unsigned int rsize;
2965         struct cifs_sb_info *cifs_sb;
2966         struct cifs_tcon *tcon;
2967         struct TCP_Server_Info *server;
2968         unsigned int xid;
2969         char *cur_offset;
2970         struct cifsFileInfo *open_file;
2971         struct cifs_io_parms io_parms;
2972         int buf_type = CIFS_NO_BUFFER;
2973         __u32 pid;
2974
2975         xid = get_xid();
2976         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2977
2978         /* FIXME: set up handlers for larger reads and/or convert to async */
2979         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2980
2981         if (file->private_data == NULL) {
2982                 rc = -EBADF;
2983                 free_xid(xid);
2984                 return rc;
2985         }
2986         open_file = file->private_data;
2987         tcon = tlink_tcon(open_file->tlink);
2988         server = tcon->ses->server;
2989
2990         if (!server->ops->sync_read) {
2991                 free_xid(xid);
2992                 return -ENOSYS;
2993         }
2994
2995         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2996                 pid = open_file->pid;
2997         else
2998                 pid = current->tgid;
2999
3000         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3001                 cifs_dbg(FYI, "attempting read on write only file instance\n");
3002
3003         for (total_read = 0, cur_offset = read_data; read_size > total_read;
3004              total_read += bytes_read, cur_offset += bytes_read) {
3005                 current_read_size = min_t(uint, read_size - total_read, rsize);
3006                 /*
3007                  * For windows me and 9x we do not want to request more than it
3008                  * negotiated since it will refuse the read then.
3009                  */
3010                 if ((tcon->ses) && !(tcon->ses->capabilities &
3011                                 tcon->ses->server->vals->cap_large_files)) {
3012                         current_read_size = min_t(uint, current_read_size,
3013                                         CIFSMaxBufSize);
3014                 }
3015                 rc = -EAGAIN;
3016                 while (rc == -EAGAIN) {
3017                         if (open_file->invalidHandle) {
3018                                 rc = cifs_reopen_file(open_file, true);
3019                                 if (rc != 0)
3020                                         break;
3021                         }
3022                         io_parms.pid = pid;
3023                         io_parms.tcon = tcon;
3024                         io_parms.offset = *offset;
3025                         io_parms.length = current_read_size;
3026                         rc = server->ops->sync_read(xid, open_file, &io_parms,
3027                                                     &bytes_read, &cur_offset,
3028                                                     &buf_type);
3029                 }
3030                 if (rc || (bytes_read == 0)) {
3031                         if (total_read) {
3032                                 break;
3033                         } else {
3034                                 free_xid(xid);
3035                                 return rc;
3036                         }
3037                 } else {
3038                         cifs_stats_bytes_read(tcon, total_read);
3039                         *offset += bytes_read;
3040                 }
3041         }
3042         free_xid(xid);
3043         return total_read;
3044 }
3045
3046 /*
3047  * If the page is mmap'ed into a process' page tables, then we need to make
3048  * sure that it doesn't change while being written back.
3049  */
3050 static int
3051 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3052 {
3053         struct page *page = vmf->page;
3054
3055         lock_page(page);
3056         return VM_FAULT_LOCKED;
3057 }
3058
3059 static struct vm_operations_struct cifs_file_vm_ops = {
3060         .fault = filemap_fault,
3061         .page_mkwrite = cifs_page_mkwrite,
3062         .remap_pages = generic_file_remap_pages,
3063 };
3064
3065 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3066 {
3067         int rc, xid;
3068         struct inode *inode = file_inode(file);
3069
3070         xid = get_xid();
3071
3072         if (!CIFS_I(inode)->clientCanCacheRead) {
3073                 rc = cifs_invalidate_mapping(inode);
3074                 if (rc)
3075                         return rc;
3076         }
3077
3078         rc = generic_file_mmap(file, vma);
3079         if (rc == 0)
3080                 vma->vm_ops = &cifs_file_vm_ops;
3081         free_xid(xid);
3082         return rc;
3083 }
3084
3085 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3086 {
3087         int rc, xid;
3088
3089         xid = get_xid();
3090         rc = cifs_revalidate_file(file);
3091         if (rc) {
3092                 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3093                          rc);
3094                 free_xid(xid);
3095                 return rc;
3096         }
3097         rc = generic_file_mmap(file, vma);
3098         if (rc == 0)
3099                 vma->vm_ops = &cifs_file_vm_ops;
3100         free_xid(xid);
3101         return rc;
3102 }
3103
3104 static void
3105 cifs_readv_complete(struct work_struct *work)
3106 {
3107         unsigned int i;
3108         struct cifs_readdata *rdata = container_of(work,
3109                                                 struct cifs_readdata, work);
3110
3111         for (i = 0; i < rdata->nr_pages; i++) {
3112                 struct page *page = rdata->pages[i];
3113
3114                 lru_cache_add_file(page);
3115
3116                 if (rdata->result == 0) {
3117                         flush_dcache_page(page);
3118                         SetPageUptodate(page);
3119                 }
3120
3121                 unlock_page(page);
3122
3123                 if (rdata->result == 0)
3124                         cifs_readpage_to_fscache(rdata->mapping->host, page);
3125
3126                 page_cache_release(page);
3127                 rdata->pages[i] = NULL;
3128         }
3129         kref_put(&rdata->refcount, cifs_readdata_release);
3130 }
3131
3132 static int
3133 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3134                         struct cifs_readdata *rdata, unsigned int len)
3135 {
3136         int total_read = 0, result = 0;
3137         unsigned int i;
3138         u64 eof;
3139         pgoff_t eof_index;
3140         unsigned int nr_pages = rdata->nr_pages;
3141         struct kvec iov;
3142
3143         /* determine the eof that the server (probably) has */
3144         eof = CIFS_I(rdata->mapping->host)->server_eof;
3145         eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
3146         cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
3147
3148         rdata->tailsz = PAGE_CACHE_SIZE;
3149         for (i = 0; i < nr_pages; i++) {
3150                 struct page *page = rdata->pages[i];
3151
3152                 if (len >= PAGE_CACHE_SIZE) {
3153                         /* enough data to fill the page */
3154                         iov.iov_base = kmap(page);
3155                         iov.iov_len = PAGE_CACHE_SIZE;
3156                         cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3157                                  i, page->index, iov.iov_base, iov.iov_len);
3158                         len -= PAGE_CACHE_SIZE;
3159                 } else if (len > 0) {
3160                         /* enough for partial page, fill and zero the rest */
3161                         iov.iov_base = kmap(page);
3162                         iov.iov_len = len;
3163                         cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3164                                  i, page->index, iov.iov_base, iov.iov_len);
3165                         memset(iov.iov_base + len,
3166                                 '\0', PAGE_CACHE_SIZE - len);
3167                         rdata->tailsz = len;
3168                         len = 0;
3169                 } else if (page->index > eof_index) {
3170                         /*
3171                          * The VFS will not try to do readahead past the
3172                          * i_size, but it's possible that we have outstanding
3173                          * writes with gaps in the middle and the i_size hasn't
3174                          * caught up yet. Populate those with zeroed out pages
3175                          * to prevent the VFS from repeatedly attempting to
3176                          * fill them until the writes are flushed.
3177                          */
3178                         zero_user(page, 0, PAGE_CACHE_SIZE);
3179                         lru_cache_add_file(page);
3180                         flush_dcache_page(page);
3181                         SetPageUptodate(page);
3182                         unlock_page(page);
3183                         page_cache_release(page);
3184                         rdata->pages[i] = NULL;
3185                         rdata->nr_pages--;
3186                         continue;
3187                 } else {
3188                         /* no need to hold page hostage */
3189                         lru_cache_add_file(page);
3190                         unlock_page(page);
3191                         page_cache_release(page);
3192                         rdata->pages[i] = NULL;
3193                         rdata->nr_pages--;
3194                         continue;
3195                 }
3196
3197                 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3198                 kunmap(page);
3199                 if (result < 0)
3200                         break;
3201
3202                 total_read += result;
3203         }
3204
3205         return total_read > 0 ? total_read : result;
3206 }
3207
3208 static int cifs_readpages(struct file *file, struct address_space *mapping,
3209         struct list_head *page_list, unsigned num_pages)
3210 {
3211         int rc;
3212         struct list_head tmplist;
3213         struct cifsFileInfo *open_file = file->private_data;
3214         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3215         unsigned int rsize = cifs_sb->rsize;
3216         pid_t pid;
3217
3218         /*
3219          * Give up immediately if rsize is too small to read an entire page.
3220          * The VFS will fall back to readpage. We should never reach this
3221          * point however since we set ra_pages to 0 when the rsize is smaller
3222          * than a cache page.
3223          */
3224         if (unlikely(rsize < PAGE_CACHE_SIZE))
3225                 return 0;
3226
3227         /*
3228          * Reads as many pages as possible from fscache. Returns -ENOBUFS
3229          * immediately if the cookie is negative
3230          */
3231         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3232                                          &num_pages);
3233         if (rc == 0)
3234                 return rc;
3235
3236         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3237                 pid = open_file->pid;
3238         else
3239                 pid = current->tgid;
3240
3241         rc = 0;
3242         INIT_LIST_HEAD(&tmplist);
3243
3244         cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3245                  __func__, file, mapping, num_pages);
3246
3247         /*
3248          * Start with the page at end of list and move it to private
3249          * list. Do the same with any following pages until we hit
3250          * the rsize limit, hit an index discontinuity, or run out of
3251          * pages. Issue the async read and then start the loop again
3252          * until the list is empty.
3253          *
3254          * Note that list order is important. The page_list is in
3255          * the order of declining indexes. When we put the pages in
3256          * the rdata->pages, then we want them in increasing order.
3257          */
3258         while (!list_empty(page_list)) {
3259                 unsigned int i;
3260                 unsigned int bytes = PAGE_CACHE_SIZE;
3261                 unsigned int expected_index;
3262                 unsigned int nr_pages = 1;
3263                 loff_t offset;
3264                 struct page *page, *tpage;
3265                 struct cifs_readdata *rdata;
3266
3267                 page = list_entry(page_list->prev, struct page, lru);
3268
3269                 /*
3270                  * Lock the page and put it in the cache. Since no one else
3271                  * should have access to this page, we're safe to simply set
3272                  * PG_locked without checking it first.
3273                  */
3274                 __set_page_locked(page);
3275                 rc = add_to_page_cache_locked(page, mapping,
3276                                               page->index, GFP_KERNEL);
3277
3278                 /* give up if we can't stick it in the cache */
3279                 if (rc) {
3280                         __clear_page_locked(page);
3281                         break;
3282                 }
3283
3284                 /* move first page to the tmplist */
3285                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3286                 list_move_tail(&page->lru, &tmplist);
3287
3288                 /* now try and add more pages onto the request */
3289                 expected_index = page->index + 1;
3290                 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3291                         /* discontinuity ? */
3292                         if (page->index != expected_index)
3293                                 break;
3294
3295                         /* would this page push the read over the rsize? */
3296                         if (bytes + PAGE_CACHE_SIZE > rsize)
3297                                 break;
3298
3299                         __set_page_locked(page);
3300                         if (add_to_page_cache_locked(page, mapping,
3301                                                 page->index, GFP_KERNEL)) {
3302                                 __clear_page_locked(page);
3303                                 break;
3304                         }
3305                         list_move_tail(&page->lru, &tmplist);
3306                         bytes += PAGE_CACHE_SIZE;
3307                         expected_index++;
3308                         nr_pages++;
3309                 }
3310
3311                 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3312                 if (!rdata) {
3313                         /* best to give up if we're out of mem */
3314                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3315                                 list_del(&page->lru);
3316                                 lru_cache_add_file(page);
3317                                 unlock_page(page);
3318                                 page_cache_release(page);
3319                         }
3320                         rc = -ENOMEM;
3321                         break;
3322                 }
3323
3324                 rdata->cfile = cifsFileInfo_get(open_file);
3325                 rdata->mapping = mapping;
3326                 rdata->offset = offset;
3327                 rdata->bytes = bytes;
3328                 rdata->pid = pid;
3329                 rdata->pagesz = PAGE_CACHE_SIZE;
3330                 rdata->read_into_pages = cifs_readpages_read_into_pages;
3331
3332                 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3333                         list_del(&page->lru);
3334                         rdata->pages[rdata->nr_pages++] = page;
3335                 }
3336
3337                 rc = cifs_retry_async_readv(rdata);
3338                 if (rc != 0) {
3339                         for (i = 0; i < rdata->nr_pages; i++) {
3340                                 page = rdata->pages[i];
3341                                 lru_cache_add_file(page);
3342                                 unlock_page(page);
3343                                 page_cache_release(page);
3344                         }
3345                         kref_put(&rdata->refcount, cifs_readdata_release);
3346                         break;
3347                 }
3348
3349                 kref_put(&rdata->refcount, cifs_readdata_release);
3350         }
3351
3352         return rc;
3353 }
3354
3355 static int cifs_readpage_worker(struct file *file, struct page *page,
3356         loff_t *poffset)
3357 {
3358         char *read_data;
3359         int rc;
3360
3361         /* Is the page cached? */
3362         rc = cifs_readpage_from_fscache(file_inode(file), page);
3363         if (rc == 0)
3364                 goto read_complete;
3365
3366         page_cache_get(page);
3367         read_data = kmap(page);
3368         /* for reads over a certain size could initiate async read ahead */
3369
3370         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
3371
3372         if (rc < 0)
3373                 goto io_error;
3374         else
3375                 cifs_dbg(FYI, "Bytes read %d\n", rc);
3376
3377         file_inode(file)->i_atime =
3378                 current_fs_time(file_inode(file)->i_sb);
3379
3380         if (PAGE_CACHE_SIZE > rc)
3381                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3382
3383         flush_dcache_page(page);
3384         SetPageUptodate(page);
3385
3386         /* send this page to the cache */
3387         cifs_readpage_to_fscache(file_inode(file), page);
3388
3389         rc = 0;
3390
3391 io_error:
3392         kunmap(page);
3393         page_cache_release(page);
3394
3395 read_complete:
3396         return rc;
3397 }
3398
3399 static int cifs_readpage(struct file *file, struct page *page)
3400 {
3401         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3402         int rc = -EACCES;
3403         unsigned int xid;
3404
3405         xid = get_xid();
3406
3407         if (file->private_data == NULL) {
3408                 rc = -EBADF;
3409                 free_xid(xid);
3410                 return rc;
3411         }
3412
3413         cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3414                  page, (int)offset, (int)offset);
3415
3416         rc = cifs_readpage_worker(file, page, &offset);
3417
3418         unlock_page(page);
3419
3420         free_xid(xid);
3421         return rc;
3422 }
3423
3424 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3425 {
3426         struct cifsFileInfo *open_file;
3427
3428         spin_lock(&cifs_file_list_lock);
3429         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3430                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3431                         spin_unlock(&cifs_file_list_lock);
3432                         return 1;
3433                 }
3434         }
3435         spin_unlock(&cifs_file_list_lock);
3436         return 0;
3437 }
3438
3439 /* We do not want to update the file size from server for inodes
3440    open for write - to avoid races with writepage extending
3441    the file - in the future we could consider allowing
3442    refreshing the inode only on increases in the file size
3443    but this is tricky to do without racing with writebehind
3444    page caching in the current Linux kernel design */
3445 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3446 {
3447         if (!cifsInode)
3448                 return true;
3449
3450         if (is_inode_writable(cifsInode)) {
3451                 /* This inode is open for write at least once */
3452                 struct cifs_sb_info *cifs_sb;
3453
3454                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3455                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3456                         /* since no page cache to corrupt on directio
3457                         we can change size safely */
3458                         return true;
3459                 }
3460
3461                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3462                         return true;
3463
3464                 return false;
3465         } else
3466                 return true;
3467 }
3468
3469 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3470                         loff_t pos, unsigned len, unsigned flags,
3471                         struct page **pagep, void **fsdata)
3472 {
3473         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3474         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
3475         loff_t page_start = pos & PAGE_MASK;
3476         loff_t i_size;
3477         struct page *page;
3478         int rc = 0;
3479
3480         cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
3481
3482         page = grab_cache_page_write_begin(mapping, index, flags);
3483         if (!page) {
3484                 rc = -ENOMEM;
3485                 goto out;
3486         }
3487
3488         if (PageUptodate(page))
3489                 goto out;
3490
3491         /*
3492          * If we write a full page it will be up to date, no need to read from
3493          * the server. If the write is short, we'll end up doing a sync write
3494          * instead.
3495          */
3496         if (len == PAGE_CACHE_SIZE)
3497                 goto out;
3498
3499         /*
3500          * optimize away the read when we have an oplock, and we're not
3501          * expecting to use any of the data we'd be reading in. That
3502          * is, when the page lies beyond the EOF, or straddles the EOF
3503          * and the write will cover all of the existing data.
3504          */
3505         if (CIFS_I(mapping->host)->clientCanCacheRead) {
3506                 i_size = i_size_read(mapping->host);
3507                 if (page_start >= i_size ||
3508                     (offset == 0 && (pos + len) >= i_size)) {
3509                         zero_user_segments(page, 0, offset,
3510                                            offset + len,
3511                                            PAGE_CACHE_SIZE);
3512                         /*
3513                          * PageChecked means that the parts of the page
3514                          * to which we're not writing are considered up
3515                          * to date. Once the data is copied to the
3516                          * page, it can be set uptodate.
3517                          */
3518                         SetPageChecked(page);
3519                         goto out;
3520                 }
3521         }
3522
3523         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
3524                 /*
3525                  * might as well read a page, it is fast enough. If we get
3526                  * an error, we don't need to return it. cifs_write_end will
3527                  * do a sync write instead since PG_uptodate isn't set.
3528                  */
3529                 cifs_readpage_worker(file, page, &page_start);
3530         } else {
3531                 /* we could try using another file handle if there is one -
3532                    but how would we lock it to prevent close of that handle
3533                    racing with this read? In any case
3534                    this will be written out by write_end so is fine */
3535         }
3536 out:
3537         *pagep = page;
3538         return rc;
3539 }
3540
3541 static int cifs_release_page(struct page *page, gfp_t gfp)
3542 {
3543         if (PagePrivate(page))
3544                 return 0;
3545
3546         return cifs_fscache_release_page(page, gfp);
3547 }
3548
3549 static void cifs_invalidate_page(struct page *page, unsigned long offset)
3550 {
3551         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3552
3553         if (offset == 0)
3554                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3555 }
3556
3557 static int cifs_launder_page(struct page *page)
3558 {
3559         int rc = 0;
3560         loff_t range_start = page_offset(page);
3561         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3562         struct writeback_control wbc = {
3563                 .sync_mode = WB_SYNC_ALL,
3564                 .nr_to_write = 0,
3565                 .range_start = range_start,
3566                 .range_end = range_end,
3567         };
3568
3569         cifs_dbg(FYI, "Launder page: %p\n", page);
3570
3571         if (clear_page_dirty_for_io(page))
3572                 rc = cifs_writepage_locked(page, &wbc);
3573
3574         cifs_fscache_invalidate_page(page, page->mapping->host);
3575         return rc;
3576 }
3577
3578 void cifs_oplock_break(struct work_struct *work)
3579 {
3580         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3581                                                   oplock_break);
3582         struct inode *inode = cfile->dentry->d_inode;
3583         struct cifsInodeInfo *cinode = CIFS_I(inode);
3584         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3585         int rc = 0;
3586
3587         if (!cinode->clientCanCacheAll && cinode->clientCanCacheRead &&
3588                                                 cifs_has_mand_locks(cinode)) {
3589                 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3590                          inode);
3591                 cinode->clientCanCacheRead = false;
3592         }
3593
3594         if (inode && S_ISREG(inode->i_mode)) {
3595                 if (cinode->clientCanCacheRead)
3596                         break_lease(inode, O_RDONLY);
3597                 else
3598                         break_lease(inode, O_WRONLY);
3599                 rc = filemap_fdatawrite(inode->i_mapping);
3600                 if (cinode->clientCanCacheRead == 0) {
3601                         rc = filemap_fdatawait(inode->i_mapping);
3602                         mapping_set_error(inode->i_mapping, rc);
3603                         cifs_invalidate_mapping(inode);
3604                 }
3605                 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
3606         }
3607
3608         rc = cifs_push_locks(cfile);
3609         if (rc)
3610                 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
3611
3612         /*
3613          * releasing stale oplock after recent reconnect of smb session using
3614          * a now incorrect file handle is not a data integrity issue but do
3615          * not bother sending an oplock release if session to server still is
3616          * disconnected since oplock already released by the server
3617          */
3618         if (!cfile->oplock_break_cancelled) {
3619                 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3620                                                              cinode);
3621                 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
3622         }
3623 }
3624
3625 const struct address_space_operations cifs_addr_ops = {
3626         .readpage = cifs_readpage,
3627         .readpages = cifs_readpages,
3628         .writepage = cifs_writepage,
3629         .writepages = cifs_writepages,
3630         .write_begin = cifs_write_begin,
3631         .write_end = cifs_write_end,
3632         .set_page_dirty = __set_page_dirty_nobuffers,
3633         .releasepage = cifs_release_page,
3634         .invalidatepage = cifs_invalidate_page,
3635         .launder_page = cifs_launder_page,
3636 };
3637
3638 /*
3639  * cifs_readpages requires the server to support a buffer large enough to
3640  * contain the header plus one complete page of data.  Otherwise, we need
3641  * to leave cifs_readpages out of the address space operations.
3642  */
3643 const struct address_space_operations cifs_addr_ops_smallbuf = {
3644         .readpage = cifs_readpage,
3645         .writepage = cifs_writepage,
3646         .writepages = cifs_writepages,
3647         .write_begin = cifs_write_begin,
3648         .write_end = cifs_write_end,
3649         .set_page_dirty = __set_page_dirty_nobuffers,
3650         .releasepage = cifs_release_page,
3651         .invalidatepage = cifs_invalidate_page,
3652         .launder_page = cifs_launder_page,
3653 };