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