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