fs/cifs/file.c

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