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 <asm/div64.h>
  36 #include "cifsfs.h"
  37 #include "cifspdu.h"
  38 #include "cifsglob.h"
  39 #include "cifsproto.h"
  40 #include "cifs_unicode.h"
  41 #include "cifs_debug.h"
  42 #include "cifs_fs_sb.h"
  43 #include "fscache.h"
  44
  45 static inline int cifs_convert_flags(unsigned int flags)
  46 {
  47         if ((flags & O_ACCMODE) == O_RDONLY)
  48                 return GENERIC_READ;
  49         else if ((flags & O_ACCMODE) == O_WRONLY)
  50                 return GENERIC_WRITE;
  51         else if ((flags & O_ACCMODE) == O_RDWR) {
  52                 /* GENERIC_ALL is too much permission to request
  53                    can cause unnecessary access denied on create */
  54                 /* return GENERIC_ALL; */
  55                 return (GENERIC_READ | GENERIC_WRITE);
  56         }
  57
  58         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
  59                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
  60                 FILE_READ_DATA);
  61 }
  62
  63 static u32 cifs_posix_convert_flags(unsigned int flags)
  64 {
  65         u32 posix_flags = 0;
  66
  67         if ((flags & O_ACCMODE) == O_RDONLY)
  68                 posix_flags = SMB_O_RDONLY;
  69         else if ((flags & O_ACCMODE) == O_WRONLY)
  70                 posix_flags = SMB_O_WRONLY;
  71         else if ((flags & O_ACCMODE) == O_RDWR)
  72                 posix_flags = SMB_O_RDWR;
  73
  74         if (flags & O_CREAT)
  75                 posix_flags |= SMB_O_CREAT;
  76         if (flags & O_EXCL)
  77                 posix_flags |= SMB_O_EXCL;
  78         if (flags & O_TRUNC)
  79                 posix_flags |= SMB_O_TRUNC;
  80         /* be safe and imply O_SYNC for O_DSYNC */
  81         if (flags & O_DSYNC)
  82                 posix_flags |= SMB_O_SYNC;
  83         if (flags & O_DIRECTORY)
  84                 posix_flags |= SMB_O_DIRECTORY;
  85         if (flags & O_NOFOLLOW)
  86                 posix_flags |= SMB_O_NOFOLLOW;
  87         if (flags & O_DIRECT)
  88                 posix_flags |= SMB_O_DIRECT;
  89
  90         return posix_flags;
  91 }
  92
  93 static inline int cifs_get_disposition(unsigned int flags)
  94 {
  95         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
  96                 return FILE_CREATE;
  97         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
  98                 return FILE_OVERWRITE_IF;
  99         else if ((flags & O_CREAT) == O_CREAT)
 100                 return FILE_OPEN_IF;
 101         else if ((flags & O_TRUNC) == O_TRUNC)
 102                 return FILE_OVERWRITE;
 103         else
 104                 return FILE_OPEN;
 105 }
 106
 107 int cifs_posix_open(char *full_path, struct inode **pinode,
 108                         struct super_block *sb, int mode, unsigned int f_flags,
 109                         __u32 *poplock, __u16 *pnetfid, int xid)
 110 {
 111         int rc;
 112         FILE_UNIX_BASIC_INFO *presp_data;
 113         __u32 posix_flags = 0;
 114         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 115         struct cifs_fattr fattr;
 116         struct tcon_link *tlink;
 117         struct cifs_tcon *tcon;
 118
 119         cFYI(1, "posix open %s", full_path);
 120
 121         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 122         if (presp_data == NULL)
 123                 return -ENOMEM;
 124
 125         tlink = cifs_sb_tlink(cifs_sb);
 126         if (IS_ERR(tlink)) {
 127                 rc = PTR_ERR(tlink);
 128                 goto posix_open_ret;
 129         }
 130
 131         tcon = tlink_tcon(tlink);
 132         mode &= ~current_umask();
 133
 134         posix_flags = cifs_posix_convert_flags(f_flags);
 135         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 136                              poplock, full_path, cifs_sb->local_nls,
 137                              cifs_sb->mnt_cifs_flags &
 138                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 139         cifs_put_tlink(tlink);
 140
 141         if (rc)
 142                 goto posix_open_ret;
 143
 144         if (presp_data->Type == cpu_to_le32(-1))
 145                 goto posix_open_ret; /* open ok, caller does qpathinfo */
 146
 147         if (!pinode)
 148                 goto posix_open_ret; /* caller does not need info */
 149
 150         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 151
 152         /* get new inode and set it up */
 153         if (*pinode == NULL) {
 154                 cifs_fill_uniqueid(sb, &fattr);
 155                 *pinode = cifs_iget(sb, &fattr);
 156                 if (!*pinode) {
 157                         rc = -ENOMEM;
 158                         goto posix_open_ret;
 159                 }
 160         } else {
 161                 cifs_fattr_to_inode(*pinode, &fattr);
 162         }
 163
 164 posix_open_ret:
 165         kfree(presp_data);
 166         return rc;
 167 }
 168
 169 static int
 170 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
 171              struct cifs_tcon *tcon, unsigned int f_flags, __u32 *poplock,
 172              __u16 *pnetfid, int xid)
 173 {
 174         int rc;
 175         int desiredAccess;
 176         int disposition;
 177         int create_options = CREATE_NOT_DIR;
 178         FILE_ALL_INFO *buf;
 179
 180         desiredAccess = cifs_convert_flags(f_flags);
 181
 182 /*********************************************************************
 183  *  open flag mapping table:
 184  *
 185  *      POSIX Flag            CIFS Disposition
 186  *      ----------            ----------------
 187  *      O_CREAT               FILE_OPEN_IF
 188  *      O_CREAT | O_EXCL      FILE_CREATE
 189  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 190  *      O_TRUNC               FILE_OVERWRITE
 191  *      none of the above     FILE_OPEN
 192  *
 193  *      Note that there is not a direct match between disposition
 194  *      FILE_SUPERSEDE (ie create whether or not file exists although
 195  *      O_CREAT | O_TRUNC is similar but truncates the existing
 196  *      file rather than creating a new file as FILE_SUPERSEDE does
 197  *      (which uses the attributes / metadata passed in on open call)
 198  *?
 199  *?  O_SYNC is a reasonable match to CIFS writethrough flag
 200  *?  and the read write flags match reasonably.  O_LARGEFILE
 201  *?  is irrelevant because largefile support is always used
 202  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 203  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 204  *********************************************************************/
 205
 206         disposition = cifs_get_disposition(f_flags);
 207
 208         /* BB pass O_SYNC flag through on file attributes .. BB */
 209
 210         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 211         if (!buf)
 212                 return -ENOMEM;
 213
 214         if (backup_cred(cifs_sb))
 215                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 216
 217         if (tcon->ses->capabilities & CAP_NT_SMBS)
 218                 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
 219                          desiredAccess, create_options, pnetfid, poplock, buf,
 220                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 221                                  & CIFS_MOUNT_MAP_SPECIAL_CHR);
 222         else
 223                 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
 224                         desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
 225                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 226                                 & CIFS_MOUNT_MAP_SPECIAL_CHR);
 227
 228         if (rc)
 229                 goto out;
 230
 231         if (tcon->unix_ext)
 232                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 233                                               xid);
 234         else
 235                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 236                                          xid, pnetfid);
 237
 238 out:
 239         kfree(buf);
 240         return rc;
 241 }
 242
 243 struct cifsFileInfo *
 244 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
 245                   struct tcon_link *tlink, __u32 oplock)
 246 {
 247         struct dentry *dentry = file->f_path.dentry;
 248         struct inode *inode = dentry->d_inode;
 249         struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
 250         struct cifsFileInfo *pCifsFile;
 251
 252         pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 253         if (pCifsFile == NULL)
 254                 return pCifsFile;
 255
 256         pCifsFile->count = 1;
 257         pCifsFile->netfid = fileHandle;
 258         pCifsFile->pid = current->tgid;
 259         pCifsFile->uid = current_fsuid();
 260         pCifsFile->dentry = dget(dentry);
 261         pCifsFile->f_flags = file->f_flags;
 262         pCifsFile->invalidHandle = false;
 263         pCifsFile->tlink = cifs_get_tlink(tlink);
 264         mutex_init(&pCifsFile->fh_mutex);
 265         mutex_init(&pCifsFile->lock_mutex);
 266         INIT_LIST_HEAD(&pCifsFile->llist);
 267         INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
 268
 269         spin_lock(&cifs_file_list_lock);
 270         list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
 271         /* if readable file instance put first in list*/
 272         if (file->f_mode & FMODE_READ)
 273                 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
 274         else
 275                 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
 276         spin_unlock(&cifs_file_list_lock);
 277
 278         cifs_set_oplock_level(pCifsInode, oplock);
 279
 280         file->private_data = pCifsFile;
 281         return pCifsFile;
 282 }
 283
 284 /*
 285  * Release a reference on the file private data. This may involve closing
 286  * the filehandle out on the server. Must be called without holding
 287  * cifs_file_list_lock.
 288  */
 289 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 290 {
 291         struct inode *inode = cifs_file->dentry->d_inode;
 292         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 293         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 294         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 295         struct cifsLockInfo *li, *tmp;
 296
 297         spin_lock(&cifs_file_list_lock);
 298         if (--cifs_file->count > 0) {
 299                 spin_unlock(&cifs_file_list_lock);
 300                 return;
 301         }
 302
 303         /* remove it from the lists */
 304         list_del(&cifs_file->flist);
 305         list_del(&cifs_file->tlist);
 306
 307         if (list_empty(&cifsi->openFileList)) {
 308                 cFYI(1, "closing last open instance for inode %p",
 309                         cifs_file->dentry->d_inode);
 310
 311                 /* in strict cache mode we need invalidate mapping on the last
 312                    close  because it may cause a error when we open this file
 313                    again and get at least level II oplock */
 314                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 315                         CIFS_I(inode)->invalid_mapping = true;
 316
 317                 cifs_set_oplock_level(cifsi, 0);
 318         }
 319         spin_unlock(&cifs_file_list_lock);
 320
 321         cancel_work_sync(&cifs_file->oplock_break);
 322
 323         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 324                 int xid, rc;
 325
 326                 xid = GetXid();
 327                 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
 328                 FreeXid(xid);
 329         }
 330
 331         /* Delete any outstanding lock records. We'll lose them when the file
 332          * is closed anyway.
 333          */
 334         mutex_lock(&cifs_file->lock_mutex);
 335         list_for_each_entry_safe(li, tmp, &cifs_file->llist, llist) {
 336                 list_del(&li->llist);
 337                 kfree(li);
 338         }
 339         mutex_unlock(&cifs_file->lock_mutex);
 340
 341         cifs_put_tlink(cifs_file->tlink);
 342         dput(cifs_file->dentry);
 343         kfree(cifs_file);
 344 }
 345
 346 int cifs_open(struct inode *inode, struct file *file)
 347 {
 348         int rc = -EACCES;
 349         int xid;
 350         __u32 oplock;
 351         struct cifs_sb_info *cifs_sb;
 352         struct cifs_tcon *tcon;
 353         struct tcon_link *tlink;
 354         struct cifsFileInfo *pCifsFile = NULL;
 355         char *full_path = NULL;
 356         bool posix_open_ok = false;
 357         __u16 netfid;
 358
 359         xid = GetXid();
 360
 361         cifs_sb = CIFS_SB(inode->i_sb);
 362         tlink = cifs_sb_tlink(cifs_sb);
 363         if (IS_ERR(tlink)) {
 364                 FreeXid(xid);
 365                 return PTR_ERR(tlink);
 366         }
 367         tcon = tlink_tcon(tlink);
 368
 369         full_path = build_path_from_dentry(file->f_path.dentry);
 370         if (full_path == NULL) {
 371                 rc = -ENOMEM;
 372                 goto out;
 373         }
 374
 375         cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
 376                  inode, file->f_flags, full_path);
 377
 378         if (enable_oplocks)
 379                 oplock = REQ_OPLOCK;
 380         else
 381                 oplock = 0;
 382
 383         if (!tcon->broken_posix_open && tcon->unix_ext &&
 384             (tcon->ses->capabilities & CAP_UNIX) &&
 385             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 386                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 387                 /* can not refresh inode info since size could be stale */
 388                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
 389                                 cifs_sb->mnt_file_mode /* ignored */,
 390                                 file->f_flags, &oplock, &netfid, xid);
 391                 if (rc == 0) {
 392                         cFYI(1, "posix open succeeded");
 393                         posix_open_ok = true;
 394                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 395                         if (tcon->ses->serverNOS)
 396                                 cERROR(1, "server %s of type %s returned"
 397                                            " unexpected error on SMB posix open"
 398                                            ", disabling posix open support."
 399                                            " Check if server update available.",
 400                                            tcon->ses->serverName,
 401                                            tcon->ses->serverNOS);
 402                         tcon->broken_posix_open = true;
 403                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
 404                          (rc != -EOPNOTSUPP)) /* path not found or net err */
 405                         goto out;
 406                 /* else fallthrough to retry open the old way on network i/o
 407                    or DFS errors */
 408         }
 409
 410         if (!posix_open_ok) {
 411                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
 412                                   file->f_flags, &oplock, &netfid, xid);
 413                 if (rc)
 414                         goto out;
 415         }
 416
 417         pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
 418         if (pCifsFile == NULL) {
 419                 CIFSSMBClose(xid, tcon, netfid);
 420                 rc = -ENOMEM;
 421                 goto out;
 422         }
 423
 424         cifs_fscache_set_inode_cookie(inode, file);
 425
 426         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
 427                 /* time to set mode which we can not set earlier due to
 428                    problems creating new read-only files */
 429                 struct cifs_unix_set_info_args args = {
 430                         .mode   = inode->i_mode,
 431                         .uid    = NO_CHANGE_64,
 432                         .gid    = NO_CHANGE_64,
 433                         .ctime  = NO_CHANGE_64,
 434                         .atime  = NO_CHANGE_64,
 435                         .mtime  = NO_CHANGE_64,
 436                         .device = 0,
 437                 };
 438                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
 439                                         pCifsFile->pid);
 440         }
 441
 442 out:
 443         kfree(full_path);
 444         FreeXid(xid);
 445         cifs_put_tlink(tlink);
 446         return rc;
 447 }
 448
 449 /* Try to reacquire byte range locks that were released when session */
 450 /* to server was lost */
 451 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
 452 {
 453         int rc = 0;
 454
 455 /* BB list all locks open on this file and relock */
 456
 457         return rc;
 458 }
 459
 460 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
 461 {
 462         int rc = -EACCES;
 463         int xid;
 464         __u32 oplock;
 465         struct cifs_sb_info *cifs_sb;
 466         struct cifs_tcon *tcon;
 467         struct cifsInodeInfo *pCifsInode;
 468         struct inode *inode;
 469         char *full_path = NULL;
 470         int desiredAccess;
 471         int disposition = FILE_OPEN;
 472         int create_options = CREATE_NOT_DIR;
 473         __u16 netfid;
 474
 475         xid = GetXid();
 476         mutex_lock(&pCifsFile->fh_mutex);
 477         if (!pCifsFile->invalidHandle) {
 478                 mutex_unlock(&pCifsFile->fh_mutex);
 479                 rc = 0;
 480                 FreeXid(xid);
 481                 return rc;
 482         }
 483
 484         inode = pCifsFile->dentry->d_inode;
 485         cifs_sb = CIFS_SB(inode->i_sb);
 486         tcon = tlink_tcon(pCifsFile->tlink);
 487
 488 /* can not grab rename sem here because various ops, including
 489    those that already have the rename sem can end up causing writepage
 490    to get called and if the server was down that means we end up here,
 491    and we can never tell if the caller already has the rename_sem */
 492         full_path = build_path_from_dentry(pCifsFile->dentry);
 493         if (full_path == NULL) {
 494                 rc = -ENOMEM;
 495                 mutex_unlock(&pCifsFile->fh_mutex);
 496                 FreeXid(xid);
 497                 return rc;
 498         }
 499
 500         cFYI(1, "inode = 0x%p file flags 0x%x for %s",
 501                  inode, pCifsFile->f_flags, full_path);
 502
 503         if (enable_oplocks)
 504                 oplock = REQ_OPLOCK;
 505         else
 506                 oplock = 0;
 507
 508         if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
 509             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 510                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 511
 512                 /*
 513                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
 514                  * original open. Must mask them off for a reopen.
 515                  */
 516                 unsigned int oflags = pCifsFile->f_flags &
 517                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
 518
 519                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
 520                                 cifs_sb->mnt_file_mode /* ignored */,
 521                                 oflags, &oplock, &netfid, xid);
 522                 if (rc == 0) {
 523                         cFYI(1, "posix reopen succeeded");
 524                         goto reopen_success;
 525                 }
 526                 /* fallthrough to retry open the old way on errors, especially
 527                    in the reconnect path it is important to retry hard */
 528         }
 529
 530         desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
 531
 532         if (backup_cred(cifs_sb))
 533                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 534
 535         /* Can not refresh inode by passing in file_info buf to be returned
 536            by SMBOpen and then calling get_inode_info with returned buf
 537            since file might have write behind data that needs to be flushed
 538            and server version of file size can be stale. If we knew for sure
 539            that inode was not dirty locally we could do this */
 540
 541         rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
 542                          create_options, &netfid, &oplock, NULL,
 543                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 544                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 545         if (rc) {
 546                 mutex_unlock(&pCifsFile->fh_mutex);
 547                 cFYI(1, "cifs_open returned 0x%x", rc);
 548                 cFYI(1, "oplock: %d", oplock);
 549                 goto reopen_error_exit;
 550         }
 551
 552 reopen_success:
 553         pCifsFile->netfid = netfid;
 554         pCifsFile->invalidHandle = false;
 555         mutex_unlock(&pCifsFile->fh_mutex);
 556         pCifsInode = CIFS_I(inode);
 557
 558         if (can_flush) {
 559                 rc = filemap_write_and_wait(inode->i_mapping);
 560                 mapping_set_error(inode->i_mapping, rc);
 561
 562                 if (tcon->unix_ext)
 563                         rc = cifs_get_inode_info_unix(&inode,
 564                                 full_path, inode->i_sb, xid);
 565                 else
 566                         rc = cifs_get_inode_info(&inode,
 567                                 full_path, NULL, inode->i_sb,
 568                                 xid, NULL);
 569         } /* else we are writing out data to server already
 570              and could deadlock if we tried to flush data, and
 571              since we do not know if we have data that would
 572              invalidate the current end of file on the server
 573              we can not go to the server to get the new inod
 574              info */
 575
 576         cifs_set_oplock_level(pCifsInode, oplock);
 577
 578         cifs_relock_file(pCifsFile);
 579
 580 reopen_error_exit:
 581         kfree(full_path);
 582         FreeXid(xid);
 583         return rc;
 584 }
 585
 586 int cifs_close(struct inode *inode, struct file *file)
 587 {
 588         if (file->private_data != NULL) {
 589                 cifsFileInfo_put(file->private_data);
 590                 file->private_data = NULL;
 591         }
 592
 593         /* return code from the ->release op is always ignored */
 594         return 0;
 595 }
 596
 597 int cifs_closedir(struct inode *inode, struct file *file)
 598 {
 599         int rc = 0;
 600         int xid;
 601         struct cifsFileInfo *pCFileStruct = file->private_data;
 602         char *ptmp;
 603
 604         cFYI(1, "Closedir inode = 0x%p", inode);
 605
 606         xid = GetXid();
 607
 608         if (pCFileStruct) {
 609                 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
 610
 611                 cFYI(1, "Freeing private data in close dir");
 612                 spin_lock(&cifs_file_list_lock);
 613                 if (!pCFileStruct->srch_inf.endOfSearch &&
 614                     !pCFileStruct->invalidHandle) {
 615                         pCFileStruct->invalidHandle = true;
 616                         spin_unlock(&cifs_file_list_lock);
 617                         rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
 618                         cFYI(1, "Closing uncompleted readdir with rc %d",
 619                                  rc);
 620                         /* not much we can do if it fails anyway, ignore rc */
 621                         rc = 0;
 622                 } else
 623                         spin_unlock(&cifs_file_list_lock);
 624                 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
 625                 if (ptmp) {
 626                         cFYI(1, "closedir free smb buf in srch struct");
 627                         pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
 628                         if (pCFileStruct->srch_inf.smallBuf)
 629                                 cifs_small_buf_release(ptmp);
 630                         else
 631                                 cifs_buf_release(ptmp);
 632                 }
 633                 cifs_put_tlink(pCFileStruct->tlink);
 634                 kfree(file->private_data);
 635                 file->private_data = NULL;
 636         }
 637         /* BB can we lock the filestruct while this is going on? */
 638         FreeXid(xid);
 639         return rc;
 640 }
 641
 642 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
 643                                 __u64 offset, __u8 lockType)
 644 {
 645         struct cifsLockInfo *li =
 646                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 647         if (li == NULL)
 648                 return -ENOMEM;
 649         li->offset = offset;
 650         li->length = len;
 651         li->type = lockType;
 652         mutex_lock(&fid->lock_mutex);
 653         list_add(&li->llist, &fid->llist);
 654         mutex_unlock(&fid->lock_mutex);
 655         return 0;
 656 }
 657
 658 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
 659 {
 660         int rc, xid;
 661         __u32 numLock = 0;
 662         __u32 numUnlock = 0;
 663         __u64 length;
 664         bool wait_flag = false;
 665         struct cifs_sb_info *cifs_sb;
 666         struct cifs_tcon *tcon;
 667         __u16 netfid;
 668         __u8 lockType = LOCKING_ANDX_LARGE_FILES;
 669         bool posix_locking = 0;
 670
 671         length = 1 + pfLock->fl_end - pfLock->fl_start;
 672         rc = -EACCES;
 673         xid = GetXid();
 674
 675         cFYI(1, "Lock parm: 0x%x flockflags: "
 676                  "0x%x flocktype: 0x%x start: %lld end: %lld",
 677                 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
 678                 pfLock->fl_end);
 679
 680         if (pfLock->fl_flags & FL_POSIX)
 681                 cFYI(1, "Posix");
 682         if (pfLock->fl_flags & FL_FLOCK)
 683                 cFYI(1, "Flock");
 684         if (pfLock->fl_flags & FL_SLEEP) {
 685                 cFYI(1, "Blocking lock");
 686                 wait_flag = true;
 687         }
 688         if (pfLock->fl_flags & FL_ACCESS)
 689                 cFYI(1, "Process suspended by mandatory locking - "
 690                          "not implemented yet");
 691         if (pfLock->fl_flags & FL_LEASE)
 692                 cFYI(1, "Lease on file - not implemented yet");
 693         if (pfLock->fl_flags &
 694             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
 695                 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
 696
 697         if (pfLock->fl_type == F_WRLCK) {
 698                 cFYI(1, "F_WRLCK ");
 699                 numLock = 1;
 700         } else if (pfLock->fl_type == F_UNLCK) {
 701                 cFYI(1, "F_UNLCK");
 702                 numUnlock = 1;
 703                 /* Check if unlock includes more than
 704                 one lock range */
 705         } else if (pfLock->fl_type == F_RDLCK) {
 706                 cFYI(1, "F_RDLCK");
 707                 lockType |= LOCKING_ANDX_SHARED_LOCK;
 708                 numLock = 1;
 709         } else if (pfLock->fl_type == F_EXLCK) {
 710                 cFYI(1, "F_EXLCK");
 711                 numLock = 1;
 712         } else if (pfLock->fl_type == F_SHLCK) {
 713                 cFYI(1, "F_SHLCK");
 714                 lockType |= LOCKING_ANDX_SHARED_LOCK;
 715                 numLock = 1;
 716         } else
 717                 cFYI(1, "Unknown type of lock");
 718
 719         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
 720         tcon = tlink_tcon(((struct cifsFileInfo *)file->private_data)->tlink);
 721         netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
 722
 723         if ((tcon->ses->capabilities & CAP_UNIX) &&
 724             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
 725             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
 726                 posix_locking = 1;
 727         /* BB add code here to normalize offset and length to
 728         account for negative length which we can not accept over the
 729         wire */
 730         if (IS_GETLK(cmd)) {
 731                 if (posix_locking) {
 732                         int posix_lock_type;
 733                         if (lockType & LOCKING_ANDX_SHARED_LOCK)
 734                                 posix_lock_type = CIFS_RDLCK;
 735                         else
 736                                 posix_lock_type = CIFS_WRLCK;
 737                         rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
 738                                         length, pfLock, posix_lock_type,
 739                                         wait_flag);
 740                         FreeXid(xid);
 741                         return rc;
 742                 }
 743
 744                 /* BB we could chain these into one lock request BB */
 745                 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
 746                                  0, 1, lockType, 0 /* wait flag */, 0);
 747                 if (rc == 0) {
 748                         rc = CIFSSMBLock(xid, tcon, netfid, length,
 749                                          pfLock->fl_start, 1 /* numUnlock */ ,
 750                                          0 /* numLock */ , lockType,
 751                                          0 /* wait flag */, 0);
 752                         pfLock->fl_type = F_UNLCK;
 753                         if (rc != 0)
 754                                 cERROR(1, "Error unlocking previously locked "
 755                                            "range %d during test of lock", rc);
 756                         rc = 0;
 757
 758                 } else {
 759                         /* if rc == ERR_SHARING_VIOLATION ? */
 760                         rc = 0;
 761
 762                         if (lockType & LOCKING_ANDX_SHARED_LOCK) {
 763                                 pfLock->fl_type = F_WRLCK;
 764                         } else {
 765                                 rc = CIFSSMBLock(xid, tcon, netfid, length,
 766                                         pfLock->fl_start, 0, 1,
 767                                         lockType | LOCKING_ANDX_SHARED_LOCK,
 768                                         0 /* wait flag */, 0);
 769                                 if (rc == 0) {
 770                                         rc = CIFSSMBLock(xid, tcon, netfid,
 771                                                 length, pfLock->fl_start, 1, 0,
 772                                                 lockType |
 773                                                 LOCKING_ANDX_SHARED_LOCK,
 774                                                 0 /* wait flag */, 0);
 775                                         pfLock->fl_type = F_RDLCK;
 776                                         if (rc != 0)
 777                                                 cERROR(1, "Error unlocking "
 778                                                 "previously locked range %d "
 779                                                 "during test of lock", rc);
 780                                         rc = 0;
 781                                 } else {
 782                                         pfLock->fl_type = F_WRLCK;
 783                                         rc = 0;
 784                                 }
 785                         }
 786                 }
 787
 788                 FreeXid(xid);
 789                 return rc;
 790         }
 791
 792         if (!numLock && !numUnlock) {
 793                 /* if no lock or unlock then nothing
 794                 to do since we do not know what it is */
 795                 FreeXid(xid);
 796                 return -EOPNOTSUPP;
 797         }
 798
 799         if (posix_locking) {
 800                 int posix_lock_type;
 801                 if (lockType & LOCKING_ANDX_SHARED_LOCK)
 802                         posix_lock_type = CIFS_RDLCK;
 803                 else
 804                         posix_lock_type = CIFS_WRLCK;
 805
 806                 if (numUnlock == 1)
 807                         posix_lock_type = CIFS_UNLCK;
 808
 809                 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
 810                                       length, pfLock, posix_lock_type,
 811                                       wait_flag);
 812         } else {
 813                 struct cifsFileInfo *fid = file->private_data;
 814
 815                 if (numLock) {
 816                         rc = CIFSSMBLock(xid, tcon, netfid, length,
 817                                          pfLock->fl_start, 0, numLock, lockType,
 818                                          wait_flag, 0);
 819
 820                         if (rc == 0) {
 821                                 /* For Windows locks we must store them. */
 822                                 rc = store_file_lock(fid, length,
 823                                                 pfLock->fl_start, lockType);
 824                         }
 825                 } else if (numUnlock) {
 826                         /* For each stored lock that this unlock overlaps
 827                            completely, unlock it. */
 828                         int stored_rc = 0;
 829                         struct cifsLockInfo *li, *tmp;
 830
 831                         rc = 0;
 832                         mutex_lock(&fid->lock_mutex);
 833                         list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
 834                                 if (pfLock->fl_start <= li->offset &&
 835                                                 (pfLock->fl_start + length) >=
 836                                                 (li->offset + li->length)) {
 837                                         stored_rc = CIFSSMBLock(xid, tcon,
 838                                                         netfid, li->length,
 839                                                         li->offset, 1, 0,
 840                                                         li->type, false, 0);
 841                                         if (stored_rc)
 842                                                 rc = stored_rc;
 843                                         else {
 844                                                 list_del(&li->llist);
 845                                                 kfree(li);
 846                                         }
 847                                 }
 848                         }
 849                         mutex_unlock(&fid->lock_mutex);
 850                 }
 851         }
 852
 853         if (pfLock->fl_flags & FL_POSIX)
 854                 posix_lock_file_wait(file, pfLock);
 855         FreeXid(xid);
 856         return rc;
 857 }
 858
 859 /* update the file size (if needed) after a write */
 860 void
 861 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
 862                       unsigned int bytes_written)
 863 {
 864         loff_t end_of_write = offset + bytes_written;
 865
 866         if (end_of_write > cifsi->server_eof)
 867                 cifsi->server_eof = end_of_write;
 868 }
 869
 870 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
 871                           const char *write_data, size_t write_size,
 872                           loff_t *poffset)
 873 {
 874         int rc = 0;
 875         unsigned int bytes_written = 0;
 876         unsigned int total_written;
 877         struct cifs_sb_info *cifs_sb;
 878         struct cifs_tcon *pTcon;
 879         int xid;
 880         struct dentry *dentry = open_file->dentry;
 881         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
 882         struct cifs_io_parms io_parms;
 883
 884         cifs_sb = CIFS_SB(dentry->d_sb);
 885
 886         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
 887            *poffset, dentry->d_name.name);
 888
 889         pTcon = tlink_tcon(open_file->tlink);
 890
 891         xid = GetXid();
 892
 893         for (total_written = 0; write_size > total_written;
 894              total_written += bytes_written) {
 895                 rc = -EAGAIN;
 896                 while (rc == -EAGAIN) {
 897                         struct kvec iov[2];
 898                         unsigned int len;
 899
 900                         if (open_file->invalidHandle) {
 901                                 /* we could deadlock if we called
 902                                    filemap_fdatawait from here so tell
 903                                    reopen_file not to flush data to
 904                                    server now */
 905                                 rc = cifs_reopen_file(open_file, false);
 906                                 if (rc != 0)
 907                                         break;
 908                         }
 909
 910                         len = min((size_t)cifs_sb->wsize,
 911                                   write_size - total_written);
 912                         /* iov[0] is reserved for smb header */
 913                         iov[1].iov_base = (char *)write_data + total_written;
 914                         iov[1].iov_len = len;
 915                         io_parms.netfid = open_file->netfid;
 916                         io_parms.pid = pid;
 917                         io_parms.tcon = pTcon;
 918                         io_parms.offset = *poffset;
 919                         io_parms.length = len;
 920                         rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
 921                                            1, 0);
 922                 }
 923                 if (rc || (bytes_written == 0)) {
 924                         if (total_written)
 925                                 break;
 926                         else {
 927                                 FreeXid(xid);
 928                                 return rc;
 929                         }
 930                 } else {
 931                         cifs_update_eof(cifsi, *poffset, bytes_written);
 932                         *poffset += bytes_written;
 933                 }
 934         }
 935
 936         cifs_stats_bytes_written(pTcon, total_written);
 937
 938         if (total_written > 0) {
 939                 spin_lock(&dentry->d_inode->i_lock);
 940                 if (*poffset > dentry->d_inode->i_size)
 941                         i_size_write(dentry->d_inode, *poffset);
 942                 spin_unlock(&dentry->d_inode->i_lock);
 943         }
 944         mark_inode_dirty_sync(dentry->d_inode);
 945         FreeXid(xid);
 946         return total_written;
 947 }
 948
 949 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
 950                                         bool fsuid_only)
 951 {
 952         struct cifsFileInfo *open_file = NULL;
 953         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
 954
 955         /* only filter by fsuid on multiuser mounts */
 956         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
 957                 fsuid_only = false;
 958
 959         spin_lock(&cifs_file_list_lock);
 960         /* we could simply get the first_list_entry since write-only entries
 961            are always at the end of the list but since the first entry might
 962            have a close pending, we go through the whole list */
 963         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
 964                 if (fsuid_only && open_file->uid != current_fsuid())
 965                         continue;
 966                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
 967                         if (!open_file->invalidHandle) {
 968                                 /* found a good file */
 969                                 /* lock it so it will not be closed on us */
 970                                 cifsFileInfo_get(open_file);
 971                                 spin_unlock(&cifs_file_list_lock);
 972                                 return open_file;
 973                         } /* else might as well continue, and look for
 974                              another, or simply have the caller reopen it
 975                              again rather than trying to fix this handle */
 976                 } else /* write only file */
 977                         break; /* write only files are last so must be done */
 978         }
 979         spin_unlock(&cifs_file_list_lock);
 980         return NULL;
 981 }
 982
 983 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
 984                                         bool fsuid_only)
 985 {
 986         struct cifsFileInfo *open_file;
 987         struct cifs_sb_info *cifs_sb;
 988         bool any_available = false;
 989         int rc;
 990
 991         /* Having a null inode here (because mapping->host was set to zero by
 992         the VFS or MM) should not happen but we had reports of on oops (due to
 993         it being zero) during stress testcases so we need to check for it */
 994
 995         if (cifs_inode == NULL) {
 996                 cERROR(1, "Null inode passed to cifs_writeable_file");
 997                 dump_stack();
 998                 return NULL;
 999         }
1000
1001         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1002
1003         /* only filter by fsuid on multiuser mounts */
1004         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1005                 fsuid_only = false;
1006
1007         spin_lock(&cifs_file_list_lock);
1008 refind_writable:
1009         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1010                 if (!any_available && open_file->pid != current->tgid)
1011                         continue;
1012                 if (fsuid_only && open_file->uid != current_fsuid())
1013                         continue;
1014                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1015                         cifsFileInfo_get(open_file);
1016
1017                         if (!open_file->invalidHandle) {
1018                                 /* found a good writable file */
1019                                 spin_unlock(&cifs_file_list_lock);
1020                                 return open_file;
1021                         }
1022
1023                         spin_unlock(&cifs_file_list_lock);
1024
1025                         /* Had to unlock since following call can block */
1026                         rc = cifs_reopen_file(open_file, false);
1027                         if (!rc)
1028                                 return open_file;
1029
1030                         /* if it fails, try another handle if possible */
1031                         cFYI(1, "wp failed on reopen file");
1032                         cifsFileInfo_put(open_file);
1033
1034                         spin_lock(&cifs_file_list_lock);
1035
1036                         /* else we simply continue to the next entry. Thus
1037                            we do not loop on reopen errors.  If we
1038                            can not reopen the file, for example if we
1039                            reconnected to a server with another client
1040                            racing to delete or lock the file we would not
1041                            make progress if we restarted before the beginning
1042                            of the loop here. */
1043                 }
1044         }
1045         /* couldn't find useable FH with same pid, try any available */
1046         if (!any_available) {
1047                 any_available = true;
1048                 goto refind_writable;
1049         }
1050         spin_unlock(&cifs_file_list_lock);
1051         return NULL;
1052 }
1053
1054 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1055 {
1056         struct address_space *mapping = page->mapping;
1057         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1058         char *write_data;
1059         int rc = -EFAULT;
1060         int bytes_written = 0;
1061         struct inode *inode;
1062         struct cifsFileInfo *open_file;
1063
1064         if (!mapping || !mapping->host)
1065                 return -EFAULT;
1066
1067         inode = page->mapping->host;
1068
1069         offset += (loff_t)from;
1070         write_data = kmap(page);
1071         write_data += from;
1072
1073         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1074                 kunmap(page);
1075                 return -EIO;
1076         }
1077
1078         /* racing with truncate? */
1079         if (offset > mapping->host->i_size) {
1080                 kunmap(page);
1081                 return 0; /* don't care */
1082         }
1083
1084         /* check to make sure that we are not extending the file */
1085         if (mapping->host->i_size - offset < (loff_t)to)
1086                 to = (unsigned)(mapping->host->i_size - offset);
1087
1088         open_file = find_writable_file(CIFS_I(mapping->host), false);
1089         if (open_file) {
1090                 bytes_written = cifs_write(open_file, open_file->pid,
1091                                            write_data, to - from, &offset);
1092                 cifsFileInfo_put(open_file);
1093                 /* Does mm or vfs already set times? */
1094                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1095                 if ((bytes_written > 0) && (offset))
1096                         rc = 0;
1097                 else if (bytes_written < 0)
1098                         rc = bytes_written;
1099         } else {
1100                 cFYI(1, "No writeable filehandles for inode");
1101                 rc = -EIO;
1102         }
1103
1104         kunmap(page);
1105         return rc;
1106 }
1107
1108 static int cifs_writepages(struct address_space *mapping,
1109                            struct writeback_control *wbc)
1110 {
1111         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1112         bool done = false, scanned = false, range_whole = false;
1113         pgoff_t end, index;
1114         struct cifs_writedata *wdata;
1115         struct page *page;
1116         int rc = 0;
1117
1118         /*
1119          * If wsize is smaller than the page cache size, default to writing
1120          * one page at a time via cifs_writepage
1121          */
1122         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1123                 return generic_writepages(mapping, wbc);
1124
1125         if (wbc->range_cyclic) {
1126                 index = mapping->writeback_index; /* Start from prev offset */
1127                 end = -1;
1128         } else {
1129                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1130                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1131                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1132                         range_whole = true;
1133                 scanned = true;
1134         }
1135 retry:
1136         while (!done && index <= end) {
1137                 unsigned int i, nr_pages, found_pages;
1138                 pgoff_t next = 0, tofind;
1139                 struct page **pages;
1140
1141                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1142                                 end - index) + 1;
1143
1144                 wdata = cifs_writedata_alloc((unsigned int)tofind);
1145                 if (!wdata) {
1146                         rc = -ENOMEM;
1147                         break;
1148                 }
1149
1150                 /*
1151                  * find_get_pages_tag seems to return a max of 256 on each
1152                  * iteration, so we must call it several times in order to
1153                  * fill the array or the wsize is effectively limited to
1154                  * 256 * PAGE_CACHE_SIZE.
1155                  */
1156                 found_pages = 0;
1157                 pages = wdata->pages;
1158                 do {
1159                         nr_pages = find_get_pages_tag(mapping, &index,
1160                                                         PAGECACHE_TAG_DIRTY,
1161                                                         tofind, pages);
1162                         found_pages += nr_pages;
1163                         tofind -= nr_pages;
1164                         pages += nr_pages;
1165                 } while (nr_pages && tofind && index <= end);
1166
1167                 if (found_pages == 0) {
1168                         kref_put(&wdata->refcount, cifs_writedata_release);
1169                         break;
1170                 }
1171
1172                 nr_pages = 0;
1173                 for (i = 0; i < found_pages; i++) {
1174                         page = wdata->pages[i];
1175                         /*
1176                          * At this point we hold neither mapping->tree_lock nor
1177                          * lock on the page itself: the page may be truncated or
1178                          * invalidated (changing page->mapping to NULL), or even
1179                          * swizzled back from swapper_space to tmpfs file
1180                          * mapping
1181                          */
1182
1183                         if (nr_pages == 0)
1184                                 lock_page(page);
1185                         else if (!trylock_page(page))
1186                                 break;
1187
1188                         if (unlikely(page->mapping != mapping)) {
1189                                 unlock_page(page);
1190                                 break;
1191                         }
1192
1193                         if (!wbc->range_cyclic && page->index > end) {
1194                                 done = true;
1195                                 unlock_page(page);
1196                                 break;
1197                         }
1198
1199                         if (next && (page->index != next)) {
1200                                 /* Not next consecutive page */
1201                                 unlock_page(page);
1202                                 break;
1203                         }
1204
1205                         if (wbc->sync_mode != WB_SYNC_NONE)
1206                                 wait_on_page_writeback(page);
1207
1208                         if (PageWriteback(page) ||
1209                                         !clear_page_dirty_for_io(page)) {
1210                                 unlock_page(page);
1211                                 break;
1212                         }
1213
1214                         /*
1215                          * This actually clears the dirty bit in the radix tree.
1216                          * See cifs_writepage() for more commentary.
1217                          */
1218                         set_page_writeback(page);
1219
1220                         if (page_offset(page) >= mapping->host->i_size) {
1221                                 done = true;
1222                                 unlock_page(page);
1223                                 end_page_writeback(page);
1224                                 break;
1225                         }
1226
1227                         wdata->pages[i] = page;
1228                         next = page->index + 1;
1229                         ++nr_pages;
1230                 }
1231
1232                 /* reset index to refind any pages skipped */
1233                 if (nr_pages == 0)
1234                         index = wdata->pages[0]->index + 1;
1235
1236                 /* put any pages we aren't going to use */
1237                 for (i = nr_pages; i < found_pages; i++) {
1238                         page_cache_release(wdata->pages[i]);
1239                         wdata->pages[i] = NULL;
1240                 }
1241
1242                 /* nothing to write? */
1243                 if (nr_pages == 0) {
1244                         kref_put(&wdata->refcount, cifs_writedata_release);
1245                         continue;
1246                 }
1247
1248                 wdata->sync_mode = wbc->sync_mode;
1249                 wdata->nr_pages = nr_pages;
1250                 wdata->offset = page_offset(wdata->pages[0]);
1251
1252                 do {
1253                         if (wdata->cfile != NULL)
1254                                 cifsFileInfo_put(wdata->cfile);
1255                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1256                                                           false);
1257                         if (!wdata->cfile) {
1258                                 cERROR(1, "No writable handles for inode");
1259                                 rc = -EBADF;
1260                                 break;
1261                         }
1262                         rc = cifs_async_writev(wdata);
1263                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1264
1265                 for (i = 0; i < nr_pages; ++i)
1266                         unlock_page(wdata->pages[i]);
1267
1268                 /* send failure -- clean up the mess */
1269                 if (rc != 0) {
1270                         for (i = 0; i < nr_pages; ++i) {
1271                                 if (rc == -EAGAIN)
1272                                         redirty_page_for_writepage(wbc,
1273                                                            wdata->pages[i]);
1274                                 else
1275                                         SetPageError(wdata->pages[i]);
1276                                 end_page_writeback(wdata->pages[i]);
1277                                 page_cache_release(wdata->pages[i]);
1278                         }
1279                         if (rc != -EAGAIN)
1280                                 mapping_set_error(mapping, rc);
1281                 }
1282                 kref_put(&wdata->refcount, cifs_writedata_release);
1283
1284                 wbc->nr_to_write -= nr_pages;
1285                 if (wbc->nr_to_write <= 0)
1286                         done = true;
1287
1288                 index = next;
1289         }
1290
1291         if (!scanned && !done) {
1292                 /*
1293                  * We hit the last page and there is more work to be done: wrap
1294                  * back to the start of the file
1295                  */
1296                 scanned = true;
1297                 index = 0;
1298                 goto retry;
1299         }
1300
1301         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1302                 mapping->writeback_index = index;
1303
1304         return rc;
1305 }
1306
1307 static int
1308 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1309 {
1310         int rc;
1311         int xid;
1312
1313         xid = GetXid();
1314 /* BB add check for wbc flags */
1315         page_cache_get(page);
1316         if (!PageUptodate(page))
1317                 cFYI(1, "ppw - page not up to date");
1318
1319         /*
1320          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1321          *
1322          * A writepage() implementation always needs to do either this,
1323          * or re-dirty the page with "redirty_page_for_writepage()" in
1324          * the case of a failure.
1325          *
1326          * Just unlocking the page will cause the radix tree tag-bits
1327          * to fail to update with the state of the page correctly.
1328          */
1329         set_page_writeback(page);
1330 retry_write:
1331         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1332         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1333                 goto retry_write;
1334         else if (rc == -EAGAIN)
1335                 redirty_page_for_writepage(wbc, page);
1336         else if (rc != 0)
1337                 SetPageError(page);
1338         else
1339                 SetPageUptodate(page);
1340         end_page_writeback(page);
1341         page_cache_release(page);
1342         FreeXid(xid);
1343         return rc;
1344 }
1345
1346 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1347 {
1348         int rc = cifs_writepage_locked(page, wbc);
1349         unlock_page(page);
1350         return rc;
1351 }
1352
1353 static int cifs_write_end(struct file *file, struct address_space *mapping,
1354                         loff_t pos, unsigned len, unsigned copied,
1355                         struct page *page, void *fsdata)
1356 {
1357         int rc;
1358         struct inode *inode = mapping->host;
1359         struct cifsFileInfo *cfile = file->private_data;
1360         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1361         __u32 pid;
1362
1363         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1364                 pid = cfile->pid;
1365         else
1366                 pid = current->tgid;
1367
1368         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1369                  page, pos, copied);
1370
1371         if (PageChecked(page)) {
1372                 if (copied == len)
1373                         SetPageUptodate(page);
1374                 ClearPageChecked(page);
1375         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1376                 SetPageUptodate(page);
1377
1378         if (!PageUptodate(page)) {
1379                 char *page_data;
1380                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1381                 int xid;
1382
1383                 xid = GetXid();
1384                 /* this is probably better than directly calling
1385                    partialpage_write since in this function the file handle is
1386                    known which we might as well leverage */
1387                 /* BB check if anything else missing out of ppw
1388                    such as updating last write time */
1389                 page_data = kmap(page);
1390                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1391                 /* if (rc < 0) should we set writebehind rc? */
1392                 kunmap(page);
1393
1394                 FreeXid(xid);
1395         } else {
1396                 rc = copied;
1397                 pos += copied;
1398                 set_page_dirty(page);
1399         }
1400
1401         if (rc > 0) {
1402                 spin_lock(&inode->i_lock);
1403                 if (pos > inode->i_size)
1404                         i_size_write(inode, pos);
1405                 spin_unlock(&inode->i_lock);
1406         }
1407
1408         unlock_page(page);
1409         page_cache_release(page);
1410
1411         return rc;
1412 }
1413
1414 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1415                       int datasync)
1416 {
1417         int xid;
1418         int rc = 0;
1419         struct cifs_tcon *tcon;
1420         struct cifsFileInfo *smbfile = file->private_data;
1421         struct inode *inode = file->f_path.dentry->d_inode;
1422         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1423
1424         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1425         if (rc)
1426                 return rc;
1427         mutex_lock(&inode->i_mutex);
1428
1429         xid = GetXid();
1430
1431         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1432                 file->f_path.dentry->d_name.name, datasync);
1433
1434         if (!CIFS_I(inode)->clientCanCacheRead) {
1435                 rc = cifs_invalidate_mapping(inode);
1436                 if (rc) {
1437                         cFYI(1, "rc: %d during invalidate phase", rc);
1438                         rc = 0; /* don't care about it in fsync */
1439                 }
1440         }
1441
1442         tcon = tlink_tcon(smbfile->tlink);
1443         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1444                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1445
1446         FreeXid(xid);
1447         mutex_unlock(&inode->i_mutex);
1448         return rc;
1449 }
1450
1451 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1452 {
1453         int xid;
1454         int rc = 0;
1455         struct cifs_tcon *tcon;
1456         struct cifsFileInfo *smbfile = file->private_data;
1457         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1458         struct inode *inode = file->f_mapping->host;
1459
1460         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1461         if (rc)
1462                 return rc;
1463         mutex_lock(&inode->i_mutex);
1464
1465         xid = GetXid();
1466
1467         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1468                 file->f_path.dentry->d_name.name, datasync);
1469
1470         tcon = tlink_tcon(smbfile->tlink);
1471         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1472                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1473
1474         FreeXid(xid);
1475         mutex_unlock(&inode->i_mutex);
1476         return rc;
1477 }
1478
1479 /*
1480  * As file closes, flush all cached write data for this inode checking
1481  * for write behind errors.
1482  */
1483 int cifs_flush(struct file *file, fl_owner_t id)
1484 {
1485         struct inode *inode = file->f_path.dentry->d_inode;
1486         int rc = 0;
1487
1488         if (file->f_mode & FMODE_WRITE)
1489                 rc = filemap_write_and_wait(inode->i_mapping);
1490
1491         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1492
1493         return rc;
1494 }
1495
1496 static int
1497 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
1498 {
1499         int rc = 0;
1500         unsigned long i;
1501
1502         for (i = 0; i < num_pages; i++) {
1503                 pages[i] = alloc_page(__GFP_HIGHMEM);
1504                 if (!pages[i]) {
1505                         /*
1506                          * save number of pages we have already allocated and
1507                          * return with ENOMEM error
1508                          */
1509                         num_pages = i;
1510                         rc = -ENOMEM;
1511                         goto error;
1512                 }
1513         }
1514
1515         return rc;
1516
1517 error:
1518         for (i = 0; i < num_pages; i++)
1519                 put_page(pages[i]);
1520         return rc;
1521 }
1522
1523 static inline
1524 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
1525 {
1526         size_t num_pages;
1527         size_t clen;
1528
1529         clen = min_t(const size_t, len, wsize);
1530         num_pages = clen / PAGE_CACHE_SIZE;
1531         if (clen % PAGE_CACHE_SIZE)
1532                 num_pages++;
1533
1534         if (cur_len)
1535                 *cur_len = clen;
1536
1537         return num_pages;
1538 }
1539
1540 static ssize_t
1541 cifs_iovec_write(struct file *file, const struct iovec *iov,
1542                  unsigned long nr_segs, loff_t *poffset)
1543 {
1544         unsigned int written;
1545         unsigned long num_pages, npages, i;
1546         size_t copied, len, cur_len;
1547         ssize_t total_written = 0;
1548         struct kvec *to_send;
1549         struct page **pages;
1550         struct iov_iter it;
1551         struct inode *inode;
1552         struct cifsFileInfo *open_file;
1553         struct cifs_tcon *pTcon;
1554         struct cifs_sb_info *cifs_sb;
1555         struct cifs_io_parms io_parms;
1556         int xid, rc;
1557         __u32 pid;
1558
1559         len = iov_length(iov, nr_segs);
1560         if (!len)
1561                 return 0;
1562
1563         rc = generic_write_checks(file, poffset, &len, 0);
1564         if (rc)
1565                 return rc;
1566
1567         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1568         num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
1569
1570         pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
1571         if (!pages)
1572                 return -ENOMEM;
1573
1574         to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
1575         if (!to_send) {
1576                 kfree(pages);
1577                 return -ENOMEM;
1578         }
1579
1580         rc = cifs_write_allocate_pages(pages, num_pages);
1581         if (rc) {
1582                 kfree(pages);
1583                 kfree(to_send);
1584                 return rc;
1585         }
1586
1587         xid = GetXid();
1588         open_file = file->private_data;
1589
1590         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1591                 pid = open_file->pid;
1592         else
1593                 pid = current->tgid;
1594
1595         pTcon = tlink_tcon(open_file->tlink);
1596         inode = file->f_path.dentry->d_inode;
1597
1598         iov_iter_init(&it, iov, nr_segs, len, 0);
1599         npages = num_pages;
1600
1601         do {
1602                 size_t save_len = cur_len;
1603                 for (i = 0; i < npages; i++) {
1604                         copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
1605                         copied = iov_iter_copy_from_user(pages[i], &it, 0,
1606                                                          copied);
1607                         cur_len -= copied;
1608                         iov_iter_advance(&it, copied);
1609                         to_send[i+1].iov_base = kmap(pages[i]);
1610                         to_send[i+1].iov_len = copied;
1611                 }
1612
1613                 cur_len = save_len - cur_len;
1614
1615                 do {
1616                         if (open_file->invalidHandle) {
1617                                 rc = cifs_reopen_file(open_file, false);
1618                                 if (rc != 0)
1619                                         break;
1620                         }
1621                         io_parms.netfid = open_file->netfid;
1622                         io_parms.pid = pid;
1623                         io_parms.tcon = pTcon;
1624                         io_parms.offset = *poffset;
1625                         io_parms.length = cur_len;
1626                         rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
1627                                            npages, 0);
1628                 } while (rc == -EAGAIN);
1629
1630                 for (i = 0; i < npages; i++)
1631                         kunmap(pages[i]);
1632
1633                 if (written) {
1634                         len -= written;
1635                         total_written += written;
1636                         cifs_update_eof(CIFS_I(inode), *poffset, written);
1637                         *poffset += written;
1638                 } else if (rc < 0) {
1639                         if (!total_written)
1640                                 total_written = rc;
1641                         break;
1642                 }
1643
1644                 /* get length and number of kvecs of the next write */
1645                 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
1646         } while (len > 0);
1647
1648         if (total_written > 0) {
1649                 spin_lock(&inode->i_lock);
1650                 if (*poffset > inode->i_size)
1651                         i_size_write(inode, *poffset);
1652                 spin_unlock(&inode->i_lock);
1653         }
1654
1655         cifs_stats_bytes_written(pTcon, total_written);
1656         mark_inode_dirty_sync(inode);
1657
1658         for (i = 0; i < num_pages; i++)
1659                 put_page(pages[i]);
1660         kfree(to_send);
1661         kfree(pages);
1662         FreeXid(xid);
1663         return total_written;
1664 }
1665
1666 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
1667                                 unsigned long nr_segs, loff_t pos)
1668 {
1669         ssize_t written;
1670         struct inode *inode;
1671
1672         inode = iocb->ki_filp->f_path.dentry->d_inode;
1673
1674         /*
1675          * BB - optimize the way when signing is disabled. We can drop this
1676          * extra memory-to-memory copying and use iovec buffers for constructing
1677          * write request.
1678          */
1679
1680         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
1681         if (written > 0) {
1682                 CIFS_I(inode)->invalid_mapping = true;
1683                 iocb->ki_pos = pos;
1684         }
1685
1686         return written;
1687 }
1688
1689 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
1690                            unsigned long nr_segs, loff_t pos)
1691 {
1692         struct inode *inode;
1693
1694         inode = iocb->ki_filp->f_path.dentry->d_inode;
1695
1696         if (CIFS_I(inode)->clientCanCacheAll)
1697                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
1698
1699         /*
1700          * In strict cache mode we need to write the data to the server exactly
1701          * from the pos to pos+len-1 rather than flush all affected pages
1702          * because it may cause a error with mandatory locks on these pages but
1703          * not on the region from pos to ppos+len-1.
1704          */
1705
1706         return cifs_user_writev(iocb, iov, nr_segs, pos);
1707 }
1708
1709 static ssize_t
1710 cifs_iovec_read(struct file *file, const struct iovec *iov,
1711                  unsigned long nr_segs, loff_t *poffset)
1712 {
1713         int rc;
1714         int xid;
1715         ssize_t total_read;
1716         unsigned int bytes_read = 0;
1717         size_t len, cur_len;
1718         int iov_offset = 0;
1719         struct cifs_sb_info *cifs_sb;
1720         struct cifs_tcon *pTcon;
1721         struct cifsFileInfo *open_file;
1722         struct smb_com_read_rsp *pSMBr;
1723         struct cifs_io_parms io_parms;
1724         char *read_data;
1725         __u32 pid;
1726
1727         if (!nr_segs)
1728                 return 0;
1729
1730         len = iov_length(iov, nr_segs);
1731         if (!len)
1732                 return 0;
1733
1734         xid = GetXid();
1735         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1736
1737         open_file = file->private_data;
1738         pTcon = tlink_tcon(open_file->tlink);
1739
1740         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1741                 pid = open_file->pid;
1742         else
1743                 pid = current->tgid;
1744
1745         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1746                 cFYI(1, "attempting read on write only file instance");
1747
1748         for (total_read = 0; total_read < len; total_read += bytes_read) {
1749                 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
1750                 rc = -EAGAIN;
1751                 read_data = NULL;
1752
1753                 while (rc == -EAGAIN) {
1754                         int buf_type = CIFS_NO_BUFFER;
1755                         if (open_file->invalidHandle) {
1756                                 rc = cifs_reopen_file(open_file, true);
1757                                 if (rc != 0)
1758                                         break;
1759                         }
1760                         io_parms.netfid = open_file->netfid;
1761                         io_parms.pid = pid;
1762                         io_parms.tcon = pTcon;
1763                         io_parms.offset = *poffset;
1764                         io_parms.length = cur_len;
1765                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
1766                                          &read_data, &buf_type);
1767                         pSMBr = (struct smb_com_read_rsp *)read_data;
1768                         if (read_data) {
1769                                 char *data_offset = read_data + 4 +
1770                                                 le16_to_cpu(pSMBr->DataOffset);
1771                                 if (memcpy_toiovecend(iov, data_offset,
1772                                                       iov_offset, bytes_read))
1773                                         rc = -EFAULT;
1774                                 if (buf_type == CIFS_SMALL_BUFFER)
1775                                         cifs_small_buf_release(read_data);
1776                                 else if (buf_type == CIFS_LARGE_BUFFER)
1777                                         cifs_buf_release(read_data);
1778                                 read_data = NULL;
1779                                 iov_offset += bytes_read;
1780                         }
1781                 }
1782
1783                 if (rc || (bytes_read == 0)) {
1784                         if (total_read) {
1785                                 break;
1786                         } else {
1787                                 FreeXid(xid);
1788                                 return rc;
1789                         }
1790                 } else {
1791                         cifs_stats_bytes_read(pTcon, bytes_read);
1792                         *poffset += bytes_read;
1793                 }
1794         }
1795
1796         FreeXid(xid);
1797         return total_read;
1798 }
1799
1800 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
1801                                unsigned long nr_segs, loff_t pos)
1802 {
1803         ssize_t read;
1804
1805         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
1806         if (read > 0)
1807                 iocb->ki_pos = pos;
1808
1809         return read;
1810 }
1811
1812 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
1813                           unsigned long nr_segs, loff_t pos)
1814 {
1815         struct inode *inode;
1816
1817         inode = iocb->ki_filp->f_path.dentry->d_inode;
1818
1819         if (CIFS_I(inode)->clientCanCacheRead)
1820                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
1821
1822         /*
1823          * In strict cache mode we need to read from the server all the time
1824          * if we don't have level II oplock because the server can delay mtime
1825          * change - so we can't make a decision about inode invalidating.
1826          * And we can also fail with pagereading if there are mandatory locks
1827          * on pages affected by this read but not on the region from pos to
1828          * pos+len-1.
1829          */
1830
1831         return cifs_user_readv(iocb, iov, nr_segs, pos);
1832 }
1833
1834 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1835                          loff_t *poffset)
1836 {
1837         int rc = -EACCES;
1838         unsigned int bytes_read = 0;
1839         unsigned int total_read;
1840         unsigned int current_read_size;
1841         struct cifs_sb_info *cifs_sb;
1842         struct cifs_tcon *pTcon;
1843         int xid;
1844         char *current_offset;
1845         struct cifsFileInfo *open_file;
1846         struct cifs_io_parms io_parms;
1847         int buf_type = CIFS_NO_BUFFER;
1848         __u32 pid;
1849
1850         xid = GetXid();
1851         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1852
1853         if (file->private_data == NULL) {
1854                 rc = -EBADF;
1855                 FreeXid(xid);
1856                 return rc;
1857         }
1858         open_file = file->private_data;
1859         pTcon = tlink_tcon(open_file->tlink);
1860
1861         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1862                 pid = open_file->pid;
1863         else
1864                 pid = current->tgid;
1865
1866         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1867                 cFYI(1, "attempting read on write only file instance");
1868
1869         for (total_read = 0, current_offset = read_data;
1870              read_size > total_read;
1871              total_read += bytes_read, current_offset += bytes_read) {
1872                 current_read_size = min_t(const int, read_size - total_read,
1873                                           cifs_sb->rsize);
1874                 /* For windows me and 9x we do not want to request more
1875                 than it negotiated since it will refuse the read then */
1876                 if ((pTcon->ses) &&
1877                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1878                         current_read_size = min_t(const int, current_read_size,
1879                                         CIFSMaxBufSize);
1880                 }
1881                 rc = -EAGAIN;
1882                 while (rc == -EAGAIN) {
1883                         if (open_file->invalidHandle) {
1884                                 rc = cifs_reopen_file(open_file, true);
1885                                 if (rc != 0)
1886                                         break;
1887                         }
1888                         io_parms.netfid = open_file->netfid;
1889                         io_parms.pid = pid;
1890                         io_parms.tcon = pTcon;
1891                         io_parms.offset = *poffset;
1892                         io_parms.length = current_read_size;
1893                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
1894                                          &current_offset, &buf_type);
1895                 }
1896                 if (rc || (bytes_read == 0)) {
1897                         if (total_read) {
1898                                 break;
1899                         } else {
1900                                 FreeXid(xid);
1901                                 return rc;
1902                         }
1903                 } else {
1904                         cifs_stats_bytes_read(pTcon, total_read);
1905                         *poffset += bytes_read;
1906                 }
1907         }
1908         FreeXid(xid);
1909         return total_read;
1910 }
1911
1912 /*
1913  * If the page is mmap'ed into a process' page tables, then we need to make
1914  * sure that it doesn't change while being written back.
1915  */
1916 static int
1917 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
1918 {
1919         struct page *page = vmf->page;
1920
1921         lock_page(page);
1922         return VM_FAULT_LOCKED;
1923 }
1924
1925 static struct vm_operations_struct cifs_file_vm_ops = {
1926         .fault = filemap_fault,
1927         .page_mkwrite = cifs_page_mkwrite,
1928 };
1929
1930 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
1931 {
1932         int rc, xid;
1933         struct inode *inode = file->f_path.dentry->d_inode;
1934
1935         xid = GetXid();
1936
1937         if (!CIFS_I(inode)->clientCanCacheRead) {
1938                 rc = cifs_invalidate_mapping(inode);
1939                 if (rc)
1940                         return rc;
1941         }
1942
1943         rc = generic_file_mmap(file, vma);
1944         if (rc == 0)
1945                 vma->vm_ops = &cifs_file_vm_ops;
1946         FreeXid(xid);
1947         return rc;
1948 }
1949
1950 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1951 {
1952         int rc, xid;
1953
1954         xid = GetXid();
1955         rc = cifs_revalidate_file(file);
1956         if (rc) {
1957                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1958                 FreeXid(xid);
1959                 return rc;
1960         }
1961         rc = generic_file_mmap(file, vma);
1962         if (rc == 0)
1963                 vma->vm_ops = &cifs_file_vm_ops;
1964         FreeXid(xid);
1965         return rc;
1966 }
1967
1968
1969 static void cifs_copy_cache_pages(struct address_space *mapping,
1970         struct list_head *pages, int bytes_read, char *data)
1971 {
1972         struct page *page;
1973         char *target;
1974
1975         while (bytes_read > 0) {
1976                 if (list_empty(pages))
1977                         break;
1978
1979                 page = list_entry(pages->prev, struct page, lru);
1980                 list_del(&page->lru);
1981
1982                 if (add_to_page_cache_lru(page, mapping, page->index,
1983                                       GFP_KERNEL)) {
1984                         page_cache_release(page);
1985                         cFYI(1, "Add page cache failed");
1986                         data += PAGE_CACHE_SIZE;
1987                         bytes_read -= PAGE_CACHE_SIZE;
1988                         continue;
1989                 }
1990                 page_cache_release(page);
1991
1992                 target = kmap_atomic(page, KM_USER0);
1993
1994                 if (PAGE_CACHE_SIZE > bytes_read) {
1995                         memcpy(target, data, bytes_read);
1996                         /* zero the tail end of this partial page */
1997                         memset(target + bytes_read, 0,
1998                                PAGE_CACHE_SIZE - bytes_read);
1999                         bytes_read = 0;
2000                 } else {
2001                         memcpy(target, data, PAGE_CACHE_SIZE);
2002                         bytes_read -= PAGE_CACHE_SIZE;
2003                 }
2004                 kunmap_atomic(target, KM_USER0);
2005
2006                 flush_dcache_page(page);
2007                 SetPageUptodate(page);
2008                 unlock_page(page);
2009                 data += PAGE_CACHE_SIZE;
2010
2011                 /* add page to FS-Cache */
2012                 cifs_readpage_to_fscache(mapping->host, page);
2013         }
2014         return;
2015 }
2016
2017 static int cifs_readpages(struct file *file, struct address_space *mapping,
2018         struct list_head *page_list, unsigned num_pages)
2019 {
2020         int rc = -EACCES;
2021         int xid;
2022         loff_t offset;
2023         struct page *page;
2024         struct cifs_sb_info *cifs_sb;
2025         struct cifs_tcon *pTcon;
2026         unsigned int bytes_read = 0;
2027         unsigned int read_size, i;
2028         char *smb_read_data = NULL;
2029         struct smb_com_read_rsp *pSMBr;
2030         struct cifsFileInfo *open_file;
2031         struct cifs_io_parms io_parms;
2032         int buf_type = CIFS_NO_BUFFER;
2033         __u32 pid;
2034
2035         xid = GetXid();
2036         if (file->private_data == NULL) {
2037                 rc = -EBADF;
2038                 FreeXid(xid);
2039                 return rc;
2040         }
2041         open_file = file->private_data;
2042         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2043         pTcon = tlink_tcon(open_file->tlink);
2044
2045         /*
2046          * Reads as many pages as possible from fscache. Returns -ENOBUFS
2047          * immediately if the cookie is negative
2048          */
2049         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2050                                          &num_pages);
2051         if (rc == 0)
2052                 goto read_complete;
2053
2054         cFYI(DBG2, "rpages: num pages %d", num_pages);
2055         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2056                 pid = open_file->pid;
2057         else
2058                 pid = current->tgid;
2059
2060         for (i = 0; i < num_pages; ) {
2061                 unsigned contig_pages;
2062                 struct page *tmp_page;
2063                 unsigned long expected_index;
2064
2065                 if (list_empty(page_list))
2066                         break;
2067
2068                 page = list_entry(page_list->prev, struct page, lru);
2069                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2070
2071                 /* count adjacent pages that we will read into */
2072                 contig_pages = 0;
2073                 expected_index =
2074                         list_entry(page_list->prev, struct page, lru)->index;
2075                 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2076                         if (tmp_page->index == expected_index) {
2077                                 contig_pages++;
2078                                 expected_index++;
2079                         } else
2080                                 break;
2081                 }
2082                 if (contig_pages + i >  num_pages)
2083                         contig_pages = num_pages - i;
2084
2085                 /* for reads over a certain size could initiate async
2086                    read ahead */
2087
2088                 read_size = contig_pages * PAGE_CACHE_SIZE;
2089                 /* Read size needs to be in multiples of one page */
2090                 read_size = min_t(const unsigned int, read_size,
2091                                   cifs_sb->rsize & PAGE_CACHE_MASK);
2092                 cFYI(DBG2, "rpages: read size 0x%x  contiguous pages %d",
2093                                 read_size, contig_pages);
2094                 rc = -EAGAIN;
2095                 while (rc == -EAGAIN) {
2096                         if (open_file->invalidHandle) {
2097                                 rc = cifs_reopen_file(open_file, true);
2098                                 if (rc != 0)
2099                                         break;
2100                         }
2101                         io_parms.netfid = open_file->netfid;
2102                         io_parms.pid = pid;
2103                         io_parms.tcon = pTcon;
2104                         io_parms.offset = offset;
2105                         io_parms.length = read_size;
2106                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2107                                          &smb_read_data, &buf_type);
2108                         /* BB more RC checks ? */
2109                         if (rc == -EAGAIN) {
2110                                 if (smb_read_data) {
2111                                         if (buf_type == CIFS_SMALL_BUFFER)
2112                                                 cifs_small_buf_release(smb_read_data);
2113                                         else if (buf_type == CIFS_LARGE_BUFFER)
2114                                                 cifs_buf_release(smb_read_data);
2115                                         smb_read_data = NULL;
2116                                 }
2117                         }
2118                 }
2119                 if ((rc < 0) || (smb_read_data == NULL)) {
2120                         cFYI(1, "Read error in readpages: %d", rc);
2121                         break;
2122                 } else if (bytes_read > 0) {
2123                         task_io_account_read(bytes_read);
2124                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2125                         cifs_copy_cache_pages(mapping, page_list, bytes_read,
2126                                 smb_read_data + 4 /* RFC1001 hdr */ +
2127                                 le16_to_cpu(pSMBr->DataOffset));
2128
2129                         i +=  bytes_read >> PAGE_CACHE_SHIFT;
2130                         cifs_stats_bytes_read(pTcon, bytes_read);
2131                         if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2132                                 i++; /* account for partial page */
2133
2134                                 /* server copy of file can have smaller size
2135                                    than client */
2136                                 /* BB do we need to verify this common case ?
2137                                    this case is ok - if we are at server EOF
2138                                    we will hit it on next read */
2139
2140                                 /* break; */
2141                         }
2142                 } else {
2143                         cFYI(1, "No bytes read (%d) at offset %lld . "
2144                                 "Cleaning remaining pages from readahead list",
2145                                 bytes_read, offset);
2146                         /* BB turn off caching and do new lookup on
2147                            file size at server? */
2148                         break;
2149                 }
2150                 if (smb_read_data) {
2151                         if (buf_type == CIFS_SMALL_BUFFER)
2152                                 cifs_small_buf_release(smb_read_data);
2153                         else if (buf_type == CIFS_LARGE_BUFFER)
2154                                 cifs_buf_release(smb_read_data);
2155                         smb_read_data = NULL;
2156                 }
2157                 bytes_read = 0;
2158         }
2159
2160 /* need to free smb_read_data buf before exit */
2161         if (smb_read_data) {
2162                 if (buf_type == CIFS_SMALL_BUFFER)
2163                         cifs_small_buf_release(smb_read_data);
2164                 else if (buf_type == CIFS_LARGE_BUFFER)
2165                         cifs_buf_release(smb_read_data);
2166                 smb_read_data = NULL;
2167         }
2168
2169 read_complete:
2170         FreeXid(xid);
2171         return rc;
2172 }
2173
2174 static int cifs_readpage_worker(struct file *file, struct page *page,
2175         loff_t *poffset)
2176 {
2177         char *read_data;
2178         int rc;
2179
2180         /* Is the page cached? */
2181         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2182         if (rc == 0)
2183                 goto read_complete;
2184
2185         page_cache_get(page);
2186         read_data = kmap(page);
2187         /* for reads over a certain size could initiate async read ahead */
2188
2189         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2190
2191         if (rc < 0)
2192                 goto io_error;
2193         else
2194                 cFYI(1, "Bytes read %d", rc);
2195
2196         file->f_path.dentry->d_inode->i_atime =
2197                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2198
2199         if (PAGE_CACHE_SIZE > rc)
2200                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2201
2202         flush_dcache_page(page);
2203         SetPageUptodate(page);
2204
2205         /* send this page to the cache */
2206         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2207
2208         rc = 0;
2209
2210 io_error:
2211         kunmap(page);
2212         page_cache_release(page);
2213
2214 read_complete:
2215         return rc;
2216 }
2217
2218 static int cifs_readpage(struct file *file, struct page *page)
2219 {
2220         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2221         int rc = -EACCES;
2222         int xid;
2223
2224         xid = GetXid();
2225
2226         if (file->private_data == NULL) {
2227                 rc = -EBADF;
2228                 FreeXid(xid);
2229                 return rc;
2230         }
2231
2232         cFYI(1, "readpage %p at offset %d 0x%x\n",
2233                  page, (int)offset, (int)offset);
2234
2235         rc = cifs_readpage_worker(file, page, &offset);
2236
2237         unlock_page(page);
2238
2239         FreeXid(xid);
2240         return rc;
2241 }
2242
2243 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2244 {
2245         struct cifsFileInfo *open_file;
2246
2247         spin_lock(&cifs_file_list_lock);
2248         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2249                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2250                         spin_unlock(&cifs_file_list_lock);
2251                         return 1;
2252                 }
2253         }
2254         spin_unlock(&cifs_file_list_lock);
2255         return 0;
2256 }
2257
2258 /* We do not want to update the file size from server for inodes
2259    open for write - to avoid races with writepage extending
2260    the file - in the future we could consider allowing
2261    refreshing the inode only on increases in the file size
2262    but this is tricky to do without racing with writebehind
2263    page caching in the current Linux kernel design */
2264 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2265 {
2266         if (!cifsInode)
2267                 return true;
2268
2269         if (is_inode_writable(cifsInode)) {
2270                 /* This inode is open for write at least once */
2271                 struct cifs_sb_info *cifs_sb;
2272
2273                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2274                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2275                         /* since no page cache to corrupt on directio
2276                         we can change size safely */
2277                         return true;
2278                 }
2279
2280                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2281                         return true;
2282
2283                 return false;
2284         } else
2285                 return true;
2286 }
2287
2288 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2289                         loff_t pos, unsigned len, unsigned flags,
2290                         struct page **pagep, void **fsdata)
2291 {
2292         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2293         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2294         loff_t page_start = pos & PAGE_MASK;
2295         loff_t i_size;
2296         struct page *page;
2297         int rc = 0;
2298
2299         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2300
2301         page = grab_cache_page_write_begin(mapping, index, flags);
2302         if (!page) {
2303                 rc = -ENOMEM;
2304                 goto out;
2305         }
2306
2307         if (PageUptodate(page))
2308                 goto out;
2309
2310         /*
2311          * If we write a full page it will be up to date, no need to read from
2312          * the server. If the write is short, we'll end up doing a sync write
2313          * instead.
2314          */
2315         if (len == PAGE_CACHE_SIZE)
2316                 goto out;
2317
2318         /*
2319          * optimize away the read when we have an oplock, and we're not
2320          * expecting to use any of the data we'd be reading in. That
2321          * is, when the page lies beyond the EOF, or straddles the EOF
2322          * and the write will cover all of the existing data.
2323          */
2324         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2325                 i_size = i_size_read(mapping->host);
2326                 if (page_start >= i_size ||
2327                     (offset == 0 && (pos + len) >= i_size)) {
2328                         zero_user_segments(page, 0, offset,
2329                                            offset + len,
2330                                            PAGE_CACHE_SIZE);
2331                         /*
2332                          * PageChecked means that the parts of the page
2333                          * to which we're not writing are considered up
2334                          * to date. Once the data is copied to the
2335                          * page, it can be set uptodate.
2336                          */
2337                         SetPageChecked(page);
2338                         goto out;
2339                 }
2340         }
2341
2342         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2343                 /*
2344                  * might as well read a page, it is fast enough. If we get
2345                  * an error, we don't need to return it. cifs_write_end will
2346                  * do a sync write instead since PG_uptodate isn't set.
2347                  */
2348                 cifs_readpage_worker(file, page, &page_start);
2349         } else {
2350                 /* we could try using another file handle if there is one -
2351                    but how would we lock it to prevent close of that handle
2352                    racing with this read? In any case
2353                    this will be written out by write_end so is fine */
2354         }
2355 out:
2356         *pagep = page;
2357         return rc;
2358 }
2359
2360 static int cifs_release_page(struct page *page, gfp_t gfp)
2361 {
2362         if (PagePrivate(page))
2363                 return 0;
2364
2365         return cifs_fscache_release_page(page, gfp);
2366 }
2367
2368 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2369 {
2370         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2371
2372         if (offset == 0)
2373                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2374 }
2375
2376 static int cifs_launder_page(struct page *page)
2377 {
2378         int rc = 0;
2379         loff_t range_start = page_offset(page);
2380         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2381         struct writeback_control wbc = {
2382                 .sync_mode = WB_SYNC_ALL,
2383                 .nr_to_write = 0,
2384                 .range_start = range_start,
2385                 .range_end = range_end,
2386         };
2387
2388         cFYI(1, "Launder page: %p", page);
2389
2390         if (clear_page_dirty_for_io(page))
2391                 rc = cifs_writepage_locked(page, &wbc);
2392
2393         cifs_fscache_invalidate_page(page, page->mapping->host);
2394         return rc;
2395 }
2396
2397 void cifs_oplock_break(struct work_struct *work)
2398 {
2399         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2400                                                   oplock_break);
2401         struct inode *inode = cfile->dentry->d_inode;
2402         struct cifsInodeInfo *cinode = CIFS_I(inode);
2403         int rc = 0;
2404
2405         if (inode && S_ISREG(inode->i_mode)) {
2406                 if (cinode->clientCanCacheRead)
2407                         break_lease(inode, O_RDONLY);
2408                 else
2409                         break_lease(inode, O_WRONLY);
2410                 rc = filemap_fdatawrite(inode->i_mapping);
2411                 if (cinode->clientCanCacheRead == 0) {
2412                         rc = filemap_fdatawait(inode->i_mapping);
2413                         mapping_set_error(inode->i_mapping, rc);
2414                         invalidate_remote_inode(inode);
2415                 }
2416                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2417         }
2418
2419         /*
2420          * releasing stale oplock after recent reconnect of smb session using
2421          * a now incorrect file handle is not a data integrity issue but do
2422          * not bother sending an oplock release if session to server still is
2423          * disconnected since oplock already released by the server
2424          */
2425         if (!cfile->oplock_break_cancelled) {
2426                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2427                                  0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false,
2428                                  cinode->clientCanCacheRead ? 1 : 0);
2429                 cFYI(1, "Oplock release rc = %d", rc);
2430         }
2431 }
2432
2433 const struct address_space_operations cifs_addr_ops = {
2434         .readpage = cifs_readpage,
2435         .readpages = cifs_readpages,
2436         .writepage = cifs_writepage,
2437         .writepages = cifs_writepages,
2438         .write_begin = cifs_write_begin,
2439         .write_end = cifs_write_end,
2440         .set_page_dirty = __set_page_dirty_nobuffers,
2441         .releasepage = cifs_release_page,
2442         .invalidatepage = cifs_invalidate_page,
2443         .launder_page = cifs_launder_page,
2444 };
2445
2446 /*
2447  * cifs_readpages requires the server to support a buffer large enough to
2448  * contain the header plus one complete page of data.  Otherwise, we need
2449  * to leave cifs_readpages out of the address space operations.
2450  */
2451 const struct address_space_operations cifs_addr_ops_smallbuf = {
2452         .readpage = cifs_readpage,
2453         .writepage = cifs_writepage,
2454         .writepages = cifs_writepages,
2455         .write_begin = cifs_write_begin,
2456         .write_end = cifs_write_end,
2457         .set_page_dirty = __set_page_dirty_nobuffers,
2458         .releasepage = cifs_release_page,
2459         .invalidatepage = cifs_invalidate_page,
2460         .launder_page = cifs_launder_page,
2461 };