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