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         struct backing_dev_info *bdi = mapping->backing_dev_info;
1306         unsigned int bytes_to_write;
1307         unsigned int bytes_written;
1308         struct cifs_sb_info *cifs_sb;
1309         int done = 0;
1310         pgoff_t end;
1311         pgoff_t index;
1312         int range_whole = 0;
1313         struct kvec *iov;
1314         int len;
1315         int n_iov = 0;
1316         pgoff_t next;
1317         int nr_pages;
1318         __u64 offset = 0;
1319         struct cifsFileInfo *open_file;
1320         struct cifsTconInfo *tcon;
1321         struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1322         struct page *page;
1323         struct pagevec pvec;
1324         int rc = 0;
1325         int scanned = 0;
1326         int xid, long_op;
1327
1328         /*
1329          * BB: Is this meaningful for a non-block-device file system?
1330          * If it is, we should test it again after we do I/O
1331          */
1332         if (wbc->nonblocking && bdi_write_congested(bdi)) {
1333                 wbc->encountered_congestion = 1;
1334                 return 0;
1335         }
1336
1337         cifs_sb = CIFS_SB(mapping->host->i_sb);
1338
1339         /*
1340          * If wsize is smaller that the page cache size, default to writing
1341          * one page at a time via cifs_writepage
1342          */
1343         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1344                 return generic_writepages(mapping, wbc);
1345
1346         iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1347         if (iov == NULL)
1348                 return generic_writepages(mapping, wbc);
1349
1350         /*
1351          * if there's no open file, then this is likely to fail too,
1352          * but it'll at least handle the return. Maybe it should be
1353          * a BUG() instead?
1354          */
1355         open_file = find_writable_file(CIFS_I(mapping->host), false);
1356         if (!open_file) {
1357                 kfree(iov);
1358                 return generic_writepages(mapping, wbc);
1359         }
1360
1361         tcon = tlink_tcon(open_file->tlink);
1362         if (!experimEnabled && tcon->ses->server->secMode &
1363                         (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1364                 cifsFileInfo_put(open_file);
1365                 return generic_writepages(mapping, wbc);
1366         }
1367         cifsFileInfo_put(open_file);
1368
1369         xid = GetXid();
1370
1371         pagevec_init(&pvec, 0);
1372         if (wbc->range_cyclic) {
1373                 index = mapping->writeback_index; /* Start from prev offset */
1374                 end = -1;
1375         } else {
1376                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1377                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1378                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1379                         range_whole = 1;
1380                 scanned = 1;
1381         }
1382 retry:
1383         while (!done && (index <= end) &&
1384                (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1385                         PAGECACHE_TAG_DIRTY,
1386                         min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1387                 int first;
1388                 unsigned int i;
1389
1390                 first = -1;
1391                 next = 0;
1392                 n_iov = 0;
1393                 bytes_to_write = 0;
1394
1395                 for (i = 0; i < nr_pages; i++) {
1396                         page = pvec.pages[i];
1397                         /*
1398                          * At this point we hold neither mapping->tree_lock nor
1399                          * lock on the page itself: the page may be truncated or
1400                          * invalidated (changing page->mapping to NULL), or even
1401                          * swizzled back from swapper_space to tmpfs file
1402                          * mapping
1403                          */
1404
1405                         if (first < 0)
1406                                 lock_page(page);
1407                         else if (!trylock_page(page))
1408                                 break;
1409
1410                         if (unlikely(page->mapping != mapping)) {
1411                                 unlock_page(page);
1412                                 break;
1413                         }
1414
1415                         if (!wbc->range_cyclic && page->index > end) {
1416                                 done = 1;
1417                                 unlock_page(page);
1418                                 break;
1419                         }
1420
1421                         if (next && (page->index != next)) {
1422                                 /* Not next consecutive page */
1423                                 unlock_page(page);
1424                                 break;
1425                         }
1426
1427                         if (wbc->sync_mode != WB_SYNC_NONE)
1428                                 wait_on_page_writeback(page);
1429
1430                         if (PageWriteback(page) ||
1431                                         !clear_page_dirty_for_io(page)) {
1432                                 unlock_page(page);
1433                                 break;
1434                         }
1435
1436                         /*
1437                          * This actually clears the dirty bit in the radix tree.
1438                          * See cifs_writepage() for more commentary.
1439                          */
1440                         set_page_writeback(page);
1441
1442                         if (page_offset(page) >= mapping->host->i_size) {
1443                                 done = 1;
1444                                 unlock_page(page);
1445                                 end_page_writeback(page);
1446                                 break;
1447                         }
1448
1449                         /*
1450                          * BB can we get rid of this?  pages are held by pvec
1451                          */
1452                         page_cache_get(page);
1453
1454                         len = min(mapping->host->i_size - page_offset(page),
1455                                   (loff_t)PAGE_CACHE_SIZE);
1456
1457                         /* reserve iov[0] for the smb header */
1458                         n_iov++;
1459                         iov[n_iov].iov_base = kmap(page);
1460                         iov[n_iov].iov_len = len;
1461                         bytes_to_write += len;
1462
1463                         if (first < 0) {
1464                                 first = i;
1465                                 offset = page_offset(page);
1466                         }
1467                         next = page->index + 1;
1468                         if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1469                                 break;
1470                 }
1471                 if (n_iov) {
1472                         open_file = find_writable_file(CIFS_I(mapping->host),
1473                                                         false);
1474                         if (!open_file) {
1475                                 cERROR(1, "No writable handles for inode");
1476                                 rc = -EBADF;
1477                         } else {
1478                                 long_op = cifs_write_timeout(cifsi, offset);
1479                                 rc = CIFSSMBWrite2(xid, tcon, open_file->netfid,
1480                                                    bytes_to_write, offset,
1481                                                    &bytes_written, iov, n_iov,
1482                                                    long_op);
1483                                 cifsFileInfo_put(open_file);
1484                                 cifs_update_eof(cifsi, offset, bytes_written);
1485                         }
1486
1487                         if (rc || bytes_written < bytes_to_write) {
1488                                 cERROR(1, "Write2 ret %d, wrote %d",
1489                                           rc, bytes_written);
1490                                 mapping_set_error(mapping, rc);
1491                         } else {
1492                                 cifs_stats_bytes_written(tcon, bytes_written);
1493                         }
1494
1495                         for (i = 0; i < n_iov; i++) {
1496                                 page = pvec.pages[first + i];
1497                                 /* Should we also set page error on
1498                                 success rc but too little data written? */
1499                                 /* BB investigate retry logic on temporary
1500                                 server crash cases and how recovery works
1501                                 when page marked as error */
1502                                 if (rc)
1503                                         SetPageError(page);
1504                                 kunmap(page);
1505                                 unlock_page(page);
1506                                 end_page_writeback(page);
1507                                 page_cache_release(page);
1508                         }
1509                         if ((wbc->nr_to_write -= n_iov) <= 0)
1510                                 done = 1;
1511                         index = next;
1512                 } else
1513                         /* Need to re-find the pages we skipped */
1514                         index = pvec.pages[0]->index + 1;
1515
1516                 pagevec_release(&pvec);
1517         }
1518         if (!scanned && !done) {
1519                 /*
1520                  * We hit the last page and there is more work to be done: wrap
1521                  * back to the start of the file
1522                  */
1523                 scanned = 1;
1524                 index = 0;
1525                 goto retry;
1526         }
1527         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1528                 mapping->writeback_index = index;
1529
1530         FreeXid(xid);
1531         kfree(iov);
1532         return rc;
1533 }
1534
1535 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1536 {
1537         int rc = -EFAULT;
1538         int xid;
1539
1540         xid = GetXid();
1541 /* BB add check for wbc flags */
1542         page_cache_get(page);
1543         if (!PageUptodate(page))
1544                 cFYI(1, "ppw - page not up to date");
1545
1546         /*
1547          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1548          *
1549          * A writepage() implementation always needs to do either this,
1550          * or re-dirty the page with "redirty_page_for_writepage()" in
1551          * the case of a failure.
1552          *
1553          * Just unlocking the page will cause the radix tree tag-bits
1554          * to fail to update with the state of the page correctly.
1555          */
1556         set_page_writeback(page);
1557         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1558         SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1559         unlock_page(page);
1560         end_page_writeback(page);
1561         page_cache_release(page);
1562         FreeXid(xid);
1563         return rc;
1564 }
1565
1566 static int cifs_write_end(struct file *file, struct address_space *mapping,
1567                         loff_t pos, unsigned len, unsigned copied,
1568                         struct page *page, void *fsdata)
1569 {
1570         int rc;
1571         struct inode *inode = mapping->host;
1572
1573         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1574                  page, pos, copied);
1575
1576         if (PageChecked(page)) {
1577                 if (copied == len)
1578                         SetPageUptodate(page);
1579                 ClearPageChecked(page);
1580         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1581                 SetPageUptodate(page);
1582
1583         if (!PageUptodate(page)) {
1584                 char *page_data;
1585                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1586                 int xid;
1587
1588                 xid = GetXid();
1589                 /* this is probably better than directly calling
1590                    partialpage_write since in this function the file handle is
1591                    known which we might as well leverage */
1592                 /* BB check if anything else missing out of ppw
1593                    such as updating last write time */
1594                 page_data = kmap(page);
1595                 rc = cifs_write(file->private_data, page_data + offset,
1596                                 copied, &pos);
1597                 /* if (rc < 0) should we set writebehind rc? */
1598                 kunmap(page);
1599
1600                 FreeXid(xid);
1601         } else {
1602                 rc = copied;
1603                 pos += copied;
1604                 set_page_dirty(page);
1605         }
1606
1607         if (rc > 0) {
1608                 spin_lock(&inode->i_lock);
1609                 if (pos > inode->i_size)
1610                         i_size_write(inode, pos);
1611                 spin_unlock(&inode->i_lock);
1612         }
1613
1614         unlock_page(page);
1615         page_cache_release(page);
1616
1617         return rc;
1618 }
1619
1620 int cifs_fsync(struct file *file, int datasync)
1621 {
1622         int xid;
1623         int rc = 0;
1624         struct cifsTconInfo *tcon;
1625         struct cifsFileInfo *smbfile = file->private_data;
1626         struct inode *inode = file->f_path.dentry->d_inode;
1627
1628         xid = GetXid();
1629
1630         cFYI(1, "Sync file - name: %s datasync: 0x%x",
1631                 file->f_path.dentry->d_name.name, datasync);
1632
1633         rc = filemap_write_and_wait(inode->i_mapping);
1634         if (rc == 0) {
1635                 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1636
1637                 tcon = tlink_tcon(smbfile->tlink);
1638                 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1639                         rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1640         }
1641
1642         FreeXid(xid);
1643         return rc;
1644 }
1645
1646 /* static void cifs_sync_page(struct page *page)
1647 {
1648         struct address_space *mapping;
1649         struct inode *inode;
1650         unsigned long index = page->index;
1651         unsigned int rpages = 0;
1652         int rc = 0;
1653
1654         cFYI(1, "sync page %p", page);
1655         mapping = page->mapping;
1656         if (!mapping)
1657                 return 0;
1658         inode = mapping->host;
1659         if (!inode)
1660                 return; */
1661
1662 /*      fill in rpages then
1663         result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1664
1665 /*      cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1666
1667 #if 0
1668         if (rc < 0)
1669                 return rc;
1670         return 0;
1671 #endif
1672 } */
1673
1674 /*
1675  * As file closes, flush all cached write data for this inode checking
1676  * for write behind errors.
1677  */
1678 int cifs_flush(struct file *file, fl_owner_t id)
1679 {
1680         struct inode *inode = file->f_path.dentry->d_inode;
1681         int rc = 0;
1682
1683         if (file->f_mode & FMODE_WRITE)
1684                 rc = filemap_write_and_wait(inode->i_mapping);
1685
1686         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1687
1688         return rc;
1689 }
1690
1691 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1692         size_t read_size, loff_t *poffset)
1693 {
1694         int rc = -EACCES;
1695         unsigned int bytes_read = 0;
1696         unsigned int total_read = 0;
1697         unsigned int current_read_size;
1698         struct cifs_sb_info *cifs_sb;
1699         struct cifsTconInfo *pTcon;
1700         int xid;
1701         struct cifsFileInfo *open_file;
1702         char *smb_read_data;
1703         char __user *current_offset;
1704         struct smb_com_read_rsp *pSMBr;
1705
1706         xid = GetXid();
1707         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1708
1709         if (file->private_data == NULL) {
1710                 rc = -EBADF;
1711                 FreeXid(xid);
1712                 return rc;
1713         }
1714         open_file = file->private_data;
1715         pTcon = tlink_tcon(open_file->tlink);
1716
1717         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1718                 cFYI(1, "attempting read on write only file instance");
1719
1720         for (total_read = 0, current_offset = read_data;
1721              read_size > total_read;
1722              total_read += bytes_read, current_offset += bytes_read) {
1723                 current_read_size = min_t(const int, read_size - total_read,
1724                                           cifs_sb->rsize);
1725                 rc = -EAGAIN;
1726                 smb_read_data = NULL;
1727                 while (rc == -EAGAIN) {
1728                         int buf_type = CIFS_NO_BUFFER;
1729                         if (open_file->invalidHandle) {
1730                                 rc = cifs_reopen_file(open_file, true);
1731                                 if (rc != 0)
1732                                         break;
1733                         }
1734                         rc = CIFSSMBRead(xid, pTcon,
1735                                          open_file->netfid,
1736                                          current_read_size, *poffset,
1737                                          &bytes_read, &smb_read_data,
1738                                          &buf_type);
1739                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1740                         if (smb_read_data) {
1741                                 if (copy_to_user(current_offset,
1742                                                 smb_read_data +
1743                                                 4 /* RFC1001 length field */ +
1744                                                 le16_to_cpu(pSMBr->DataOffset),
1745                                                 bytes_read))
1746                                         rc = -EFAULT;
1747
1748                                 if (buf_type == CIFS_SMALL_BUFFER)
1749                                         cifs_small_buf_release(smb_read_data);
1750                                 else if (buf_type == CIFS_LARGE_BUFFER)
1751                                         cifs_buf_release(smb_read_data);
1752                                 smb_read_data = NULL;
1753                         }
1754                 }
1755                 if (rc || (bytes_read == 0)) {
1756                         if (total_read) {
1757                                 break;
1758                         } else {
1759                                 FreeXid(xid);
1760                                 return rc;
1761                         }
1762                 } else {
1763                         cifs_stats_bytes_read(pTcon, bytes_read);
1764                         *poffset += bytes_read;
1765                 }
1766         }
1767         FreeXid(xid);
1768         return total_read;
1769 }
1770
1771
1772 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1773         loff_t *poffset)
1774 {
1775         int rc = -EACCES;
1776         unsigned int bytes_read = 0;
1777         unsigned int total_read;
1778         unsigned int current_read_size;
1779         struct cifs_sb_info *cifs_sb;
1780         struct cifsTconInfo *pTcon;
1781         int xid;
1782         char *current_offset;
1783         struct cifsFileInfo *open_file;
1784         int buf_type = CIFS_NO_BUFFER;
1785
1786         xid = GetXid();
1787         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1788
1789         if (file->private_data == NULL) {
1790                 rc = -EBADF;
1791                 FreeXid(xid);
1792                 return rc;
1793         }
1794         open_file = file->private_data;
1795         pTcon = tlink_tcon(open_file->tlink);
1796
1797         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1798                 cFYI(1, "attempting read on write only file instance");
1799
1800         for (total_read = 0, current_offset = read_data;
1801              read_size > total_read;
1802              total_read += bytes_read, current_offset += bytes_read) {
1803                 current_read_size = min_t(const int, read_size - total_read,
1804                                           cifs_sb->rsize);
1805                 /* For windows me and 9x we do not want to request more
1806                 than it negotiated since it will refuse the read then */
1807                 if ((pTcon->ses) &&
1808                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1809                         current_read_size = min_t(const int, current_read_size,
1810                                         pTcon->ses->server->maxBuf - 128);
1811                 }
1812                 rc = -EAGAIN;
1813                 while (rc == -EAGAIN) {
1814                         if (open_file->invalidHandle) {
1815                                 rc = cifs_reopen_file(open_file, true);
1816                                 if (rc != 0)
1817                                         break;
1818                         }
1819                         rc = CIFSSMBRead(xid, pTcon,
1820                                          open_file->netfid,
1821                                          current_read_size, *poffset,
1822                                          &bytes_read, &current_offset,
1823                                          &buf_type);
1824                 }
1825                 if (rc || (bytes_read == 0)) {
1826                         if (total_read) {
1827                                 break;
1828                         } else {
1829                                 FreeXid(xid);
1830                                 return rc;
1831                         }
1832                 } else {
1833                         cifs_stats_bytes_read(pTcon, total_read);
1834                         *poffset += bytes_read;
1835                 }
1836         }
1837         FreeXid(xid);
1838         return total_read;
1839 }
1840
1841 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1842 {
1843         int rc, xid;
1844
1845         xid = GetXid();
1846         rc = cifs_revalidate_file(file);
1847         if (rc) {
1848                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1849                 FreeXid(xid);
1850                 return rc;
1851         }
1852         rc = generic_file_mmap(file, vma);
1853         FreeXid(xid);
1854         return rc;
1855 }
1856
1857
1858 static void cifs_copy_cache_pages(struct address_space *mapping,
1859         struct list_head *pages, int bytes_read, char *data)
1860 {
1861         struct page *page;
1862         char *target;
1863
1864         while (bytes_read > 0) {
1865                 if (list_empty(pages))
1866                         break;
1867
1868                 page = list_entry(pages->prev, struct page, lru);
1869                 list_del(&page->lru);
1870
1871                 if (add_to_page_cache_lru(page, mapping, page->index,
1872                                       GFP_KERNEL)) {
1873                         page_cache_release(page);
1874                         cFYI(1, "Add page cache failed");
1875                         data += PAGE_CACHE_SIZE;
1876                         bytes_read -= PAGE_CACHE_SIZE;
1877                         continue;
1878                 }
1879                 page_cache_release(page);
1880
1881                 target = kmap_atomic(page, KM_USER0);
1882
1883                 if (PAGE_CACHE_SIZE > bytes_read) {
1884                         memcpy(target, data, bytes_read);
1885                         /* zero the tail end of this partial page */
1886                         memset(target + bytes_read, 0,
1887                                PAGE_CACHE_SIZE - bytes_read);
1888                         bytes_read = 0;
1889                 } else {
1890                         memcpy(target, data, PAGE_CACHE_SIZE);
1891                         bytes_read -= PAGE_CACHE_SIZE;
1892                 }
1893                 kunmap_atomic(target, KM_USER0);
1894
1895                 flush_dcache_page(page);
1896                 SetPageUptodate(page);
1897                 unlock_page(page);
1898                 data += PAGE_CACHE_SIZE;
1899
1900                 /* add page to FS-Cache */
1901                 cifs_readpage_to_fscache(mapping->host, page);
1902         }
1903         return;
1904 }
1905
1906 static int cifs_readpages(struct file *file, struct address_space *mapping,
1907         struct list_head *page_list, unsigned num_pages)
1908 {
1909         int rc = -EACCES;
1910         int xid;
1911         loff_t offset;
1912         struct page *page;
1913         struct cifs_sb_info *cifs_sb;
1914         struct cifsTconInfo *pTcon;
1915         unsigned int bytes_read = 0;
1916         unsigned int read_size, i;
1917         char *smb_read_data = NULL;
1918         struct smb_com_read_rsp *pSMBr;
1919         struct cifsFileInfo *open_file;
1920         int buf_type = CIFS_NO_BUFFER;
1921
1922         xid = GetXid();
1923         if (file->private_data == NULL) {
1924                 rc = -EBADF;
1925                 FreeXid(xid);
1926                 return rc;
1927         }
1928         open_file = file->private_data;
1929         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1930         pTcon = tlink_tcon(open_file->tlink);
1931
1932         /*
1933          * Reads as many pages as possible from fscache. Returns -ENOBUFS
1934          * immediately if the cookie is negative
1935          */
1936         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
1937                                          &num_pages);
1938         if (rc == 0)
1939                 goto read_complete;
1940
1941         cFYI(DBG2, "rpages: num pages %d", num_pages);
1942         for (i = 0; i < num_pages; ) {
1943                 unsigned contig_pages;
1944                 struct page *tmp_page;
1945                 unsigned long expected_index;
1946
1947                 if (list_empty(page_list))
1948                         break;
1949
1950                 page = list_entry(page_list->prev, struct page, lru);
1951                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1952
1953                 /* count adjacent pages that we will read into */
1954                 contig_pages = 0;
1955                 expected_index =
1956                         list_entry(page_list->prev, struct page, lru)->index;
1957                 list_for_each_entry_reverse(tmp_page, page_list, lru) {
1958                         if (tmp_page->index == expected_index) {
1959                                 contig_pages++;
1960                                 expected_index++;
1961                         } else
1962                                 break;
1963                 }
1964                 if (contig_pages + i >  num_pages)
1965                         contig_pages = num_pages - i;
1966
1967                 /* for reads over a certain size could initiate async
1968                    read ahead */
1969
1970                 read_size = contig_pages * PAGE_CACHE_SIZE;
1971                 /* Read size needs to be in multiples of one page */
1972                 read_size = min_t(const unsigned int, read_size,
1973                                   cifs_sb->rsize & PAGE_CACHE_MASK);
1974                 cFYI(DBG2, "rpages: read size 0x%x  contiguous pages %d",
1975                                 read_size, contig_pages);
1976                 rc = -EAGAIN;
1977                 while (rc == -EAGAIN) {
1978                         if (open_file->invalidHandle) {
1979                                 rc = cifs_reopen_file(open_file, true);
1980                                 if (rc != 0)
1981                                         break;
1982                         }
1983
1984                         rc = CIFSSMBRead(xid, pTcon,
1985                                          open_file->netfid,
1986                                          read_size, offset,
1987                                          &bytes_read, &smb_read_data,
1988                                          &buf_type);
1989                         /* BB more RC checks ? */
1990                         if (rc == -EAGAIN) {
1991                                 if (smb_read_data) {
1992                                         if (buf_type == CIFS_SMALL_BUFFER)
1993                                                 cifs_small_buf_release(smb_read_data);
1994                                         else if (buf_type == CIFS_LARGE_BUFFER)
1995                                                 cifs_buf_release(smb_read_data);
1996                                         smb_read_data = NULL;
1997                                 }
1998                         }
1999                 }
2000                 if ((rc < 0) || (smb_read_data == NULL)) {
2001                         cFYI(1, "Read error in readpages: %d", rc);
2002                         break;
2003                 } else if (bytes_read > 0) {
2004                         task_io_account_read(bytes_read);
2005                         pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2006                         cifs_copy_cache_pages(mapping, page_list, bytes_read,
2007                                 smb_read_data + 4 /* RFC1001 hdr */ +
2008                                 le16_to_cpu(pSMBr->DataOffset));
2009
2010                         i +=  bytes_read >> PAGE_CACHE_SHIFT;
2011                         cifs_stats_bytes_read(pTcon, bytes_read);
2012                         if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2013                                 i++; /* account for partial page */
2014
2015                                 /* server copy of file can have smaller size
2016                                    than client */
2017                                 /* BB do we need to verify this common case ?
2018                                    this case is ok - if we are at server EOF
2019                                    we will hit it on next read */
2020
2021                                 /* break; */
2022                         }
2023                 } else {
2024                         cFYI(1, "No bytes read (%d) at offset %lld . "
2025                                 "Cleaning remaining pages from readahead list",
2026                                 bytes_read, offset);
2027                         /* BB turn off caching and do new lookup on
2028                            file size at server? */
2029                         break;
2030                 }
2031                 if (smb_read_data) {
2032                         if (buf_type == CIFS_SMALL_BUFFER)
2033                                 cifs_small_buf_release(smb_read_data);
2034                         else if (buf_type == CIFS_LARGE_BUFFER)
2035                                 cifs_buf_release(smb_read_data);
2036                         smb_read_data = NULL;
2037                 }
2038                 bytes_read = 0;
2039         }
2040
2041 /* need to free smb_read_data buf before exit */
2042         if (smb_read_data) {
2043                 if (buf_type == CIFS_SMALL_BUFFER)
2044                         cifs_small_buf_release(smb_read_data);
2045                 else if (buf_type == CIFS_LARGE_BUFFER)
2046                         cifs_buf_release(smb_read_data);
2047                 smb_read_data = NULL;
2048         }
2049
2050 read_complete:
2051         FreeXid(xid);
2052         return rc;
2053 }
2054
2055 static int cifs_readpage_worker(struct file *file, struct page *page,
2056         loff_t *poffset)
2057 {
2058         char *read_data;
2059         int rc;
2060
2061         /* Is the page cached? */
2062         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2063         if (rc == 0)
2064                 goto read_complete;
2065
2066         page_cache_get(page);
2067         read_data = kmap(page);
2068         /* for reads over a certain size could initiate async read ahead */
2069
2070         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2071
2072         if (rc < 0)
2073                 goto io_error;
2074         else
2075                 cFYI(1, "Bytes read %d", rc);
2076
2077         file->f_path.dentry->d_inode->i_atime =
2078                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2079
2080         if (PAGE_CACHE_SIZE > rc)
2081                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2082
2083         flush_dcache_page(page);
2084         SetPageUptodate(page);
2085
2086         /* send this page to the cache */
2087         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2088
2089         rc = 0;
2090
2091 io_error:
2092         kunmap(page);
2093         page_cache_release(page);
2094
2095 read_complete:
2096         return rc;
2097 }
2098
2099 static int cifs_readpage(struct file *file, struct page *page)
2100 {
2101         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2102         int rc = -EACCES;
2103         int xid;
2104
2105         xid = GetXid();
2106
2107         if (file->private_data == NULL) {
2108                 rc = -EBADF;
2109                 FreeXid(xid);
2110                 return rc;
2111         }
2112
2113         cFYI(1, "readpage %p at offset %d 0x%x\n",
2114                  page, (int)offset, (int)offset);
2115
2116         rc = cifs_readpage_worker(file, page, &offset);
2117
2118         unlock_page(page);
2119
2120         FreeXid(xid);
2121         return rc;
2122 }
2123
2124 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2125 {
2126         struct cifsFileInfo *open_file;
2127
2128         spin_lock(&cifs_file_list_lock);
2129         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2130                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2131                         spin_unlock(&cifs_file_list_lock);
2132                         return 1;
2133                 }
2134         }
2135         spin_unlock(&cifs_file_list_lock);
2136         return 0;
2137 }
2138
2139 /* We do not want to update the file size from server for inodes
2140    open for write - to avoid races with writepage extending
2141    the file - in the future we could consider allowing
2142    refreshing the inode only on increases in the file size
2143    but this is tricky to do without racing with writebehind
2144    page caching in the current Linux kernel design */
2145 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2146 {
2147         if (!cifsInode)
2148                 return true;
2149
2150         if (is_inode_writable(cifsInode)) {
2151                 /* This inode is open for write at least once */
2152                 struct cifs_sb_info *cifs_sb;
2153
2154                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2155                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2156                         /* since no page cache to corrupt on directio
2157                         we can change size safely */
2158                         return true;
2159                 }
2160
2161                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2162                         return true;
2163
2164                 return false;
2165         } else
2166                 return true;
2167 }
2168
2169 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2170                         loff_t pos, unsigned len, unsigned flags,
2171                         struct page **pagep, void **fsdata)
2172 {
2173         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2174         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2175         loff_t page_start = pos & PAGE_MASK;
2176         loff_t i_size;
2177         struct page *page;
2178         int rc = 0;
2179
2180         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2181
2182         page = grab_cache_page_write_begin(mapping, index, flags);
2183         if (!page) {
2184                 rc = -ENOMEM;
2185                 goto out;
2186         }
2187
2188         if (PageUptodate(page))
2189                 goto out;
2190
2191         /*
2192          * If we write a full page it will be up to date, no need to read from
2193          * the server. If the write is short, we'll end up doing a sync write
2194          * instead.
2195          */
2196         if (len == PAGE_CACHE_SIZE)
2197                 goto out;
2198
2199         /*
2200          * optimize away the read when we have an oplock, and we're not
2201          * expecting to use any of the data we'd be reading in. That
2202          * is, when the page lies beyond the EOF, or straddles the EOF
2203          * and the write will cover all of the existing data.
2204          */
2205         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2206                 i_size = i_size_read(mapping->host);
2207                 if (page_start >= i_size ||
2208                     (offset == 0 && (pos + len) >= i_size)) {
2209                         zero_user_segments(page, 0, offset,
2210                                            offset + len,
2211                                            PAGE_CACHE_SIZE);
2212                         /*
2213                          * PageChecked means that the parts of the page
2214                          * to which we're not writing are considered up
2215                          * to date. Once the data is copied to the
2216                          * page, it can be set uptodate.
2217                          */
2218                         SetPageChecked(page);
2219                         goto out;
2220                 }
2221         }
2222
2223         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2224                 /*
2225                  * might as well read a page, it is fast enough. If we get
2226                  * an error, we don't need to return it. cifs_write_end will
2227                  * do a sync write instead since PG_uptodate isn't set.
2228                  */
2229                 cifs_readpage_worker(file, page, &page_start);
2230         } else {
2231                 /* we could try using another file handle if there is one -
2232                    but how would we lock it to prevent close of that handle
2233                    racing with this read? In any case
2234                    this will be written out by write_end so is fine */
2235         }
2236 out:
2237         *pagep = page;
2238         return rc;
2239 }
2240
2241 static int cifs_release_page(struct page *page, gfp_t gfp)
2242 {
2243         if (PagePrivate(page))
2244                 return 0;
2245
2246         return cifs_fscache_release_page(page, gfp);
2247 }
2248
2249 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2250 {
2251         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2252
2253         if (offset == 0)
2254                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2255 }
2256
2257 void cifs_oplock_break(struct work_struct *work)
2258 {
2259         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2260                                                   oplock_break);
2261         struct inode *inode = cfile->dentry->d_inode;
2262         struct cifsInodeInfo *cinode = CIFS_I(inode);
2263         int rc = 0;
2264
2265         if (inode && S_ISREG(inode->i_mode)) {
2266                 if (cinode->clientCanCacheRead)
2267                         break_lease(inode, O_RDONLY);
2268                 else
2269                         break_lease(inode, O_WRONLY);
2270                 rc = filemap_fdatawrite(inode->i_mapping);
2271                 if (cinode->clientCanCacheRead == 0) {
2272                         rc = filemap_fdatawait(inode->i_mapping);
2273                         mapping_set_error(inode->i_mapping, rc);
2274                         invalidate_remote_inode(inode);
2275                 }
2276                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2277         }
2278
2279         /*
2280          * releasing stale oplock after recent reconnect of smb session using
2281          * a now incorrect file handle is not a data integrity issue but do
2282          * not bother sending an oplock release if session to server still is
2283          * disconnected since oplock already released by the server
2284          */
2285         if (!cfile->oplock_break_cancelled) {
2286                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2287                                  0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false);
2288                 cFYI(1, "Oplock release rc = %d", rc);
2289         }
2290
2291         /*
2292          * We might have kicked in before is_valid_oplock_break()
2293          * finished grabbing reference for us.  Make sure it's done by
2294          * waiting for GlobalSMSSeslock.
2295          */
2296         spin_lock(&cifs_file_list_lock);
2297         spin_unlock(&cifs_file_list_lock);
2298
2299         cifs_oplock_break_put(cfile);
2300 }
2301
2302 /* must be called while holding cifs_file_list_lock */
2303 void cifs_oplock_break_get(struct cifsFileInfo *cfile)
2304 {
2305         cifs_sb_active(cfile->dentry->d_sb);
2306         cifsFileInfo_get(cfile);
2307 }
2308
2309 void cifs_oplock_break_put(struct cifsFileInfo *cfile)
2310 {
2311         cifsFileInfo_put(cfile);
2312         cifs_sb_deactive(cfile->dentry->d_sb);
2313 }
2314
2315 const struct address_space_operations cifs_addr_ops = {
2316         .readpage = cifs_readpage,
2317         .readpages = cifs_readpages,
2318         .writepage = cifs_writepage,
2319         .writepages = cifs_writepages,
2320         .write_begin = cifs_write_begin,
2321         .write_end = cifs_write_end,
2322         .set_page_dirty = __set_page_dirty_nobuffers,
2323         .releasepage = cifs_release_page,
2324         .invalidatepage = cifs_invalidate_page,
2325         /* .sync_page = cifs_sync_page, */
2326         /* .direct_IO = */
2327 };
2328
2329 /*
2330  * cifs_readpages requires the server to support a buffer large enough to
2331  * contain the header plus one complete page of data.  Otherwise, we need
2332  * to leave cifs_readpages out of the address space operations.
2333  */
2334 const struct address_space_operations cifs_addr_ops_smallbuf = {
2335         .readpage = cifs_readpage,
2336         .writepage = cifs_writepage,
2337         .writepages = cifs_writepages,
2338         .write_begin = cifs_write_begin,
2339         .write_end = cifs_write_end,
2340         .set_page_dirty = __set_page_dirty_nobuffers,
2341         .releasepage = cifs_release_page,
2342         .invalidatepage = cifs_invalidate_page,
2343         /* .sync_page = cifs_sync_page, */
2344         /* .direct_IO = */
2345 };