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