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