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 <linux/swap.h>
  36 #include <asm/div64.h>
  37 #include "cifsfs.h"
  38 #include "cifspdu.h"
  39 #include "cifsglob.h"
  40 #include "cifsproto.h"
  41 #include "cifs_unicode.h"
  42 #include "cifs_debug.h"
  43 #include "cifs_fs_sb.h"
  44 #include "fscache.h"
  45
  46 static inline int cifs_convert_flags(unsigned int flags)
  47 {
  48         if ((flags & O_ACCMODE) == O_RDONLY)
  49                 return GENERIC_READ;
  50         else if ((flags & O_ACCMODE) == O_WRONLY)
  51                 return GENERIC_WRITE;
  52         else if ((flags & O_ACCMODE) == O_RDWR) {
  53                 /* GENERIC_ALL is too much permission to request
  54                    can cause unnecessary access denied on create */
  55                 /* return GENERIC_ALL; */
  56                 return (GENERIC_READ | GENERIC_WRITE);
  57         }
  58
  59         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
  60                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
  61                 FILE_READ_DATA);
  62 }
  63
  64 static u32 cifs_posix_convert_flags(unsigned int flags)
  65 {
  66         u32 posix_flags = 0;
  67
  68         if ((flags & O_ACCMODE) == O_RDONLY)
  69                 posix_flags = SMB_O_RDONLY;
  70         else if ((flags & O_ACCMODE) == O_WRONLY)
  71                 posix_flags = SMB_O_WRONLY;
  72         else if ((flags & O_ACCMODE) == O_RDWR)
  73                 posix_flags = SMB_O_RDWR;
  74
  75         if (flags & O_CREAT)
  76                 posix_flags |= SMB_O_CREAT;
  77         if (flags & O_EXCL)
  78                 posix_flags |= SMB_O_EXCL;
  79         if (flags & O_TRUNC)
  80                 posix_flags |= SMB_O_TRUNC;
  81         /* be safe and imply O_SYNC for O_DSYNC */
  82         if (flags & O_DSYNC)
  83                 posix_flags |= SMB_O_SYNC;
  84         if (flags & O_DIRECTORY)
  85                 posix_flags |= SMB_O_DIRECTORY;
  86         if (flags & O_NOFOLLOW)
  87                 posix_flags |= SMB_O_NOFOLLOW;
  88         if (flags & O_DIRECT)
  89                 posix_flags |= SMB_O_DIRECT;
  90
  91         return posix_flags;
  92 }
  93
  94 static inline int cifs_get_disposition(unsigned int flags)
  95 {
  96         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
  97                 return FILE_CREATE;
  98         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
  99                 return FILE_OVERWRITE_IF;
 100         else if ((flags & O_CREAT) == O_CREAT)
 101                 return FILE_OPEN_IF;
 102         else if ((flags & O_TRUNC) == O_TRUNC)
 103                 return FILE_OVERWRITE;
 104         else
 105                 return FILE_OPEN;
 106 }
 107
 108 int cifs_posix_open(char *full_path, struct inode **pinode,
 109                         struct super_block *sb, int mode, unsigned int f_flags,
 110                         __u32 *poplock, __u16 *pnetfid, int xid)
 111 {
 112         int rc;
 113         FILE_UNIX_BASIC_INFO *presp_data;
 114         __u32 posix_flags = 0;
 115         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 116         struct cifs_fattr fattr;
 117         struct tcon_link *tlink;
 118         struct cifs_tcon *tcon;
 119
 120         cFYI(1, "posix open %s", full_path);
 121
 122         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 123         if (presp_data == NULL)
 124                 return -ENOMEM;
 125
 126         tlink = cifs_sb_tlink(cifs_sb);
 127         if (IS_ERR(tlink)) {
 128                 rc = PTR_ERR(tlink);
 129                 goto posix_open_ret;
 130         }
 131
 132         tcon = tlink_tcon(tlink);
 133         mode &= ~current_umask();
 134
 135         posix_flags = cifs_posix_convert_flags(f_flags);
 136         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 137                              poplock, full_path, cifs_sb->local_nls,
 138                              cifs_sb->mnt_cifs_flags &
 139                                         CIFS_MOUNT_MAP_SPECIAL_CHR);
 140         cifs_put_tlink(tlink);
 141
 142         if (rc)
 143                 goto posix_open_ret;
 144
 145         if (presp_data->Type == cpu_to_le32(-1))
 146                 goto posix_open_ret; /* open ok, caller does qpathinfo */
 147
 148         if (!pinode)
 149                 goto posix_open_ret; /* caller does not need info */
 150
 151         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 152
 153         /* get new inode and set it up */
 154         if (*pinode == NULL) {
 155                 cifs_fill_uniqueid(sb, &fattr);
 156                 *pinode = cifs_iget(sb, &fattr);
 157                 if (!*pinode) {
 158                         rc = -ENOMEM;
 159                         goto posix_open_ret;
 160                 }
 161         } else {
 162                 cifs_fattr_to_inode(*pinode, &fattr);
 163         }
 164
 165 posix_open_ret:
 166         kfree(presp_data);
 167         return rc;
 168 }
 169
 170 static int
 171 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
 172              struct cifs_tcon *tcon, unsigned int f_flags, __u32 *poplock,
 173              __u16 *pnetfid, int xid)
 174 {
 175         int rc;
 176         int desiredAccess;
 177         int disposition;
 178         int create_options = CREATE_NOT_DIR;
 179         FILE_ALL_INFO *buf;
 180
 181         desiredAccess = cifs_convert_flags(f_flags);
 182
 183 /*********************************************************************
 184  *  open flag mapping table:
 185  *
 186  *      POSIX Flag            CIFS Disposition
 187  *      ----------            ----------------
 188  *      O_CREAT               FILE_OPEN_IF
 189  *      O_CREAT | O_EXCL      FILE_CREATE
 190  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 191  *      O_TRUNC               FILE_OVERWRITE
 192  *      none of the above     FILE_OPEN
 193  *
 194  *      Note that there is not a direct match between disposition
 195  *      FILE_SUPERSEDE (ie create whether or not file exists although
 196  *      O_CREAT | O_TRUNC is similar but truncates the existing
 197  *      file rather than creating a new file as FILE_SUPERSEDE does
 198  *      (which uses the attributes / metadata passed in on open call)
 199  *?
 200  *?  O_SYNC is a reasonable match to CIFS writethrough flag
 201  *?  and the read write flags match reasonably.  O_LARGEFILE
 202  *?  is irrelevant because largefile support is always used
 203  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 204  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 205  *********************************************************************/
 206
 207         disposition = cifs_get_disposition(f_flags);
 208
 209         /* BB pass O_SYNC flag through on file attributes .. BB */
 210
 211         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 212         if (!buf)
 213                 return -ENOMEM;
 214
 215         if (backup_cred(cifs_sb))
 216                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 217
 218         if (tcon->ses->capabilities & CAP_NT_SMBS)
 219                 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
 220                          desiredAccess, create_options, pnetfid, poplock, buf,
 221                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 222                                  & CIFS_MOUNT_MAP_SPECIAL_CHR);
 223         else
 224                 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
 225                         desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
 226                         cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
 227                                 & CIFS_MOUNT_MAP_SPECIAL_CHR);
 228
 229         if (rc)
 230                 goto out;
 231
 232         if (tcon->unix_ext)
 233                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 234                                               xid);
 235         else
 236                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 237                                          xid, pnetfid);
 238
 239 out:
 240         kfree(buf);
 241         return rc;
 242 }
 243
 244 struct cifsFileInfo *
 245 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
 246                   struct tcon_link *tlink, __u32 oplock)
 247 {
 248         struct dentry *dentry = file->f_path.dentry;
 249         struct inode *inode = dentry->d_inode;
 250         struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
 251         struct cifsFileInfo *pCifsFile;
 252
 253         pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 254         if (pCifsFile == NULL)
 255                 return pCifsFile;
 256
 257         pCifsFile->count = 1;
 258         pCifsFile->netfid = fileHandle;
 259         pCifsFile->pid = current->tgid;
 260         pCifsFile->uid = current_fsuid();
 261         pCifsFile->dentry = dget(dentry);
 262         pCifsFile->f_flags = file->f_flags;
 263         pCifsFile->invalidHandle = false;
 264         pCifsFile->tlink = cifs_get_tlink(tlink);
 265         mutex_init(&pCifsFile->fh_mutex);
 266         INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
 267
 268         spin_lock(&cifs_file_list_lock);
 269         list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
 270         /* if readable file instance put first in list*/
 271         if (file->f_mode & FMODE_READ)
 272                 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
 273         else
 274                 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
 275         spin_unlock(&cifs_file_list_lock);
 276
 277         cifs_set_oplock_level(pCifsInode, oplock);
 278         pCifsInode->can_cache_brlcks = pCifsInode->clientCanCacheAll;
 279
 280         file->private_data = pCifsFile;
 281         return pCifsFile;
 282 }
 283
 284 static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
 285
 286 /*
 287  * Release a reference on the file private data. This may involve closing
 288  * the filehandle out on the server. Must be called without holding
 289  * cifs_file_list_lock.
 290  */
 291 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 292 {
 293         struct inode *inode = cifs_file->dentry->d_inode;
 294         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 295         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 296         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
 297         struct cifsLockInfo *li, *tmp;
 298
 299         spin_lock(&cifs_file_list_lock);
 300         if (--cifs_file->count > 0) {
 301                 spin_unlock(&cifs_file_list_lock);
 302                 return;
 303         }
 304
 305         /* remove it from the lists */
 306         list_del(&cifs_file->flist);
 307         list_del(&cifs_file->tlist);
 308
 309         if (list_empty(&cifsi->openFileList)) {
 310                 cFYI(1, "closing last open instance for inode %p",
 311                         cifs_file->dentry->d_inode);
 312
 313                 /* in strict cache mode we need invalidate mapping on the last
 314                    close  because it may cause a error when we open this file
 315                    again and get at least level II oplock */
 316                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 317                         CIFS_I(inode)->invalid_mapping = true;
 318
 319                 cifs_set_oplock_level(cifsi, 0);
 320         }
 321         spin_unlock(&cifs_file_list_lock);
 322
 323         cancel_work_sync(&cifs_file->oplock_break);
 324
 325         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 326                 int xid, rc;
 327
 328                 xid = GetXid();
 329                 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
 330                 FreeXid(xid);
 331         }
 332
 333         /* Delete any outstanding lock records. We'll lose them when the file
 334          * is closed anyway.
 335          */
 336         mutex_lock(&cifsi->lock_mutex);
 337         list_for_each_entry_safe(li, tmp, &cifsi->llist, llist) {
 338                 if (li->netfid != cifs_file->netfid)
 339                         continue;
 340                 list_del(&li->llist);
 341                 cifs_del_lock_waiters(li);
 342                 kfree(li);
 343         }
 344         mutex_unlock(&cifsi->lock_mutex);
 345
 346         cifs_put_tlink(cifs_file->tlink);
 347         dput(cifs_file->dentry);
 348         kfree(cifs_file);
 349 }
 350
 351 int cifs_open(struct inode *inode, struct file *file)
 352 {
 353         int rc = -EACCES;
 354         int xid;
 355         __u32 oplock;
 356         struct cifs_sb_info *cifs_sb;
 357         struct cifs_tcon *tcon;
 358         struct tcon_link *tlink;
 359         struct cifsFileInfo *pCifsFile = NULL;
 360         char *full_path = NULL;
 361         bool posix_open_ok = false;
 362         __u16 netfid;
 363
 364         xid = GetXid();
 365
 366         cifs_sb = CIFS_SB(inode->i_sb);
 367         tlink = cifs_sb_tlink(cifs_sb);
 368         if (IS_ERR(tlink)) {
 369                 FreeXid(xid);
 370                 return PTR_ERR(tlink);
 371         }
 372         tcon = tlink_tcon(tlink);
 373
 374         full_path = build_path_from_dentry(file->f_path.dentry);
 375         if (full_path == NULL) {
 376                 rc = -ENOMEM;
 377                 goto out;
 378         }
 379
 380         cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
 381                  inode, file->f_flags, full_path);
 382
 383         if (tcon->ses->server->oplocks)
 384                 oplock = REQ_OPLOCK;
 385         else
 386                 oplock = 0;
 387
 388         if (!tcon->broken_posix_open && tcon->unix_ext &&
 389             (tcon->ses->capabilities & CAP_UNIX) &&
 390             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 391                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 392                 /* can not refresh inode info since size could be stale */
 393                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
 394                                 cifs_sb->mnt_file_mode /* ignored */,
 395                                 file->f_flags, &oplock, &netfid, xid);
 396                 if (rc == 0) {
 397                         cFYI(1, "posix open succeeded");
 398                         posix_open_ok = true;
 399                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 400                         if (tcon->ses->serverNOS)
 401                                 cERROR(1, "server %s of type %s returned"
 402                                            " unexpected error on SMB posix open"
 403                                            ", disabling posix open support."
 404                                            " Check if server update available.",
 405                                            tcon->ses->serverName,
 406                                            tcon->ses->serverNOS);
 407                         tcon->broken_posix_open = true;
 408                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
 409                          (rc != -EOPNOTSUPP)) /* path not found or net err */
 410                         goto out;
 411                 /* else fallthrough to retry open the old way on network i/o
 412                    or DFS errors */
 413         }
 414
 415         if (!posix_open_ok) {
 416                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
 417                                   file->f_flags, &oplock, &netfid, xid);
 418                 if (rc)
 419                         goto out;
 420         }
 421
 422         pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
 423         if (pCifsFile == NULL) {
 424                 CIFSSMBClose(xid, tcon, netfid);
 425                 rc = -ENOMEM;
 426                 goto out;
 427         }
 428
 429         cifs_fscache_set_inode_cookie(inode, file);
 430
 431         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
 432                 /* time to set mode which we can not set earlier due to
 433                    problems creating new read-only files */
 434                 struct cifs_unix_set_info_args args = {
 435                         .mode   = inode->i_mode,
 436                         .uid    = NO_CHANGE_64,
 437                         .gid    = NO_CHANGE_64,
 438                         .ctime  = NO_CHANGE_64,
 439                         .atime  = NO_CHANGE_64,
 440                         .mtime  = NO_CHANGE_64,
 441                         .device = 0,
 442                 };
 443                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
 444                                         pCifsFile->pid);
 445         }
 446
 447 out:
 448         kfree(full_path);
 449         FreeXid(xid);
 450         cifs_put_tlink(tlink);
 451         return rc;
 452 }
 453
 454 /* Try to reacquire byte range locks that were released when session */
 455 /* to server was lost */
 456 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
 457 {
 458         int rc = 0;
 459
 460 /* BB list all locks open on this file and relock */
 461
 462         return rc;
 463 }
 464
 465 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
 466 {
 467         int rc = -EACCES;
 468         int xid;
 469         __u32 oplock;
 470         struct cifs_sb_info *cifs_sb;
 471         struct cifs_tcon *tcon;
 472         struct cifsInodeInfo *pCifsInode;
 473         struct inode *inode;
 474         char *full_path = NULL;
 475         int desiredAccess;
 476         int disposition = FILE_OPEN;
 477         int create_options = CREATE_NOT_DIR;
 478         __u16 netfid;
 479
 480         xid = GetXid();
 481         mutex_lock(&pCifsFile->fh_mutex);
 482         if (!pCifsFile->invalidHandle) {
 483                 mutex_unlock(&pCifsFile->fh_mutex);
 484                 rc = 0;
 485                 FreeXid(xid);
 486                 return rc;
 487         }
 488
 489         inode = pCifsFile->dentry->d_inode;
 490         cifs_sb = CIFS_SB(inode->i_sb);
 491         tcon = tlink_tcon(pCifsFile->tlink);
 492
 493 /* can not grab rename sem here because various ops, including
 494    those that already have the rename sem can end up causing writepage
 495    to get called and if the server was down that means we end up here,
 496    and we can never tell if the caller already has the rename_sem */
 497         full_path = build_path_from_dentry(pCifsFile->dentry);
 498         if (full_path == NULL) {
 499                 rc = -ENOMEM;
 500                 mutex_unlock(&pCifsFile->fh_mutex);
 501                 FreeXid(xid);
 502                 return rc;
 503         }
 504
 505         cFYI(1, "inode = 0x%p file flags 0x%x for %s",
 506                  inode, pCifsFile->f_flags, full_path);
 507
 508         if (tcon->ses->server->oplocks)
 509                 oplock = REQ_OPLOCK;
 510         else
 511                 oplock = 0;
 512
 513         if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
 514             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 515                         le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 516
 517                 /*
 518                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
 519                  * original open. Must mask them off for a reopen.
 520                  */
 521                 unsigned int oflags = pCifsFile->f_flags &
 522                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
 523
 524                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
 525                                 cifs_sb->mnt_file_mode /* ignored */,
 526                                 oflags, &oplock, &netfid, xid);
 527                 if (rc == 0) {
 528                         cFYI(1, "posix reopen succeeded");
 529                         goto reopen_success;
 530                 }
 531                 /* fallthrough to retry open the old way on errors, especially
 532                    in the reconnect path it is important to retry hard */
 533         }
 534
 535         desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
 536
 537         if (backup_cred(cifs_sb))
 538                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 539
 540         /* Can not refresh inode by passing in file_info buf to be returned
 541            by SMBOpen and then calling get_inode_info with returned buf
 542            since file might have write behind data that needs to be flushed
 543            and server version of file size can be stale. If we knew for sure
 544            that inode was not dirty locally we could do this */
 545
 546         rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
 547                          create_options, &netfid, &oplock, NULL,
 548                          cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
 549                                 CIFS_MOUNT_MAP_SPECIAL_CHR);
 550         if (rc) {
 551                 mutex_unlock(&pCifsFile->fh_mutex);
 552                 cFYI(1, "cifs_open returned 0x%x", rc);
 553                 cFYI(1, "oplock: %d", oplock);
 554                 goto reopen_error_exit;
 555         }
 556
 557 reopen_success:
 558         pCifsFile->netfid = netfid;
 559         pCifsFile->invalidHandle = false;
 560         mutex_unlock(&pCifsFile->fh_mutex);
 561         pCifsInode = CIFS_I(inode);
 562
 563         if (can_flush) {
 564                 rc = filemap_write_and_wait(inode->i_mapping);
 565                 mapping_set_error(inode->i_mapping, rc);
 566
 567                 if (tcon->unix_ext)
 568                         rc = cifs_get_inode_info_unix(&inode,
 569                                 full_path, inode->i_sb, xid);
 570                 else
 571                         rc = cifs_get_inode_info(&inode,
 572                                 full_path, NULL, inode->i_sb,
 573                                 xid, NULL);
 574         } /* else we are writing out data to server already
 575              and could deadlock if we tried to flush data, and
 576              since we do not know if we have data that would
 577              invalidate the current end of file on the server
 578              we can not go to the server to get the new inod
 579              info */
 580
 581         cifs_set_oplock_level(pCifsInode, oplock);
 582
 583         cifs_relock_file(pCifsFile);
 584
 585 reopen_error_exit:
 586         kfree(full_path);
 587         FreeXid(xid);
 588         return rc;
 589 }
 590
 591 int cifs_close(struct inode *inode, struct file *file)
 592 {
 593         if (file->private_data != NULL) {
 594                 cifsFileInfo_put(file->private_data);
 595                 file->private_data = NULL;
 596         }
 597
 598         /* return code from the ->release op is always ignored */
 599         return 0;
 600 }
 601
 602 int cifs_closedir(struct inode *inode, struct file *file)
 603 {
 604         int rc = 0;
 605         int xid;
 606         struct cifsFileInfo *pCFileStruct = file->private_data;
 607         char *ptmp;
 608
 609         cFYI(1, "Closedir inode = 0x%p", inode);
 610
 611         xid = GetXid();
 612
 613         if (pCFileStruct) {
 614                 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
 615
 616                 cFYI(1, "Freeing private data in close dir");
 617                 spin_lock(&cifs_file_list_lock);
 618                 if (!pCFileStruct->srch_inf.endOfSearch &&
 619                     !pCFileStruct->invalidHandle) {
 620                         pCFileStruct->invalidHandle = true;
 621                         spin_unlock(&cifs_file_list_lock);
 622                         rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
 623                         cFYI(1, "Closing uncompleted readdir with rc %d",
 624                                  rc);
 625                         /* not much we can do if it fails anyway, ignore rc */
 626                         rc = 0;
 627                 } else
 628                         spin_unlock(&cifs_file_list_lock);
 629                 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
 630                 if (ptmp) {
 631                         cFYI(1, "closedir free smb buf in srch struct");
 632                         pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
 633                         if (pCFileStruct->srch_inf.smallBuf)
 634                                 cifs_small_buf_release(ptmp);
 635                         else
 636                                 cifs_buf_release(ptmp);
 637                 }
 638                 cifs_put_tlink(pCFileStruct->tlink);
 639                 kfree(file->private_data);
 640                 file->private_data = NULL;
 641         }
 642         /* BB can we lock the filestruct while this is going on? */
 643         FreeXid(xid);
 644         return rc;
 645 }
 646
 647 static struct cifsLockInfo *
 648 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 netfid)
 649 {
 650         struct cifsLockInfo *lock =
 651                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 652         if (!lock)
 653                 return lock;
 654         lock->offset = offset;
 655         lock->length = length;
 656         lock->type = type;
 657         lock->netfid = netfid;
 658         lock->pid = current->tgid;
 659         INIT_LIST_HEAD(&lock->blist);
 660         init_waitqueue_head(&lock->block_q);
 661         return lock;
 662 }
 663
 664 static void
 665 cifs_del_lock_waiters(struct cifsLockInfo *lock)
 666 {
 667         struct cifsLockInfo *li, *tmp;
 668         list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
 669                 list_del_init(&li->blist);
 670                 wake_up(&li->block_q);
 671         }
 672 }
 673
 674 static bool
 675 __cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
 676                         __u64 length, __u8 type, __u16 netfid,
 677                         struct cifsLockInfo **conf_lock)
 678 {
 679         struct cifsLockInfo *li, *tmp;
 680
 681         list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
 682                 if (offset + length <= li->offset ||
 683                     offset >= li->offset + li->length)
 684                         continue;
 685                 else if ((type & LOCKING_ANDX_SHARED_LOCK) &&
 686                          ((netfid == li->netfid && current->tgid == li->pid) ||
 687                           type == li->type))
 688                         continue;
 689                 else {
 690                         *conf_lock = li;
 691                         return true;
 692                 }
 693         }
 694         return false;
 695 }
 696
 697 static bool
 698 cifs_find_lock_conflict(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
 699                         struct cifsLockInfo **conf_lock)
 700 {
 701         return __cifs_find_lock_conflict(cinode, lock->offset, lock->length,
 702                                          lock->type, lock->netfid, conf_lock);
 703 }
 704
 705 /*
 706  * Check if there is another lock that prevents us to set the lock (mandatory
 707  * style). If such a lock exists, update the flock structure with its
 708  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 709  * or leave it the same if we can't. Returns 0 if we don't need to request to
 710  * the server or 1 otherwise.
 711  */
 712 static int
 713 cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
 714                __u8 type, __u16 netfid, struct file_lock *flock)
 715 {
 716         int rc = 0;
 717         struct cifsLockInfo *conf_lock;
 718         bool exist;
 719
 720         mutex_lock(&cinode->lock_mutex);
 721
 722         exist = __cifs_find_lock_conflict(cinode, offset, length, type, netfid,
 723                                           &conf_lock);
 724         if (exist) {
 725                 flock->fl_start = conf_lock->offset;
 726                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
 727                 flock->fl_pid = conf_lock->pid;
 728                 if (conf_lock->type & LOCKING_ANDX_SHARED_LOCK)
 729                         flock->fl_type = F_RDLCK;
 730                 else
 731                         flock->fl_type = F_WRLCK;
 732         } else if (!cinode->can_cache_brlcks)
 733                 rc = 1;
 734         else
 735                 flock->fl_type = F_UNLCK;
 736
 737         mutex_unlock(&cinode->lock_mutex);
 738         return rc;
 739 }
 740
 741 static void
 742 cifs_lock_add(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock)
 743 {
 744         mutex_lock(&cinode->lock_mutex);
 745         list_add_tail(&lock->llist, &cinode->llist);
 746         mutex_unlock(&cinode->lock_mutex);
 747 }
 748
 749 /*
 750  * Set the byte-range lock (mandatory style). Returns:
 751  * 1) 0, if we set the lock and don't need to request to the server;
 752  * 2) 1, if no locks prevent us but we need to request to the server;
 753  * 3) -EACCESS, if there is a lock that prevents us and wait is false.
 754  */
 755 static int
 756 cifs_lock_add_if(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
 757                  bool wait)
 758 {
 759         struct cifsLockInfo *conf_lock;
 760         bool exist;
 761         int rc = 0;
 762
 763 try_again:
 764         exist = false;
 765         mutex_lock(&cinode->lock_mutex);
 766
 767         exist = cifs_find_lock_conflict(cinode, lock, &conf_lock);
 768         if (!exist && cinode->can_cache_brlcks) {
 769                 list_add_tail(&lock->llist, &cinode->llist);
 770                 mutex_unlock(&cinode->lock_mutex);
 771                 return rc;
 772         }
 773
 774         if (!exist)
 775                 rc = 1;
 776         else if (!wait)
 777                 rc = -EACCES;
 778         else {
 779                 list_add_tail(&lock->blist, &conf_lock->blist);
 780                 mutex_unlock(&cinode->lock_mutex);
 781                 rc = wait_event_interruptible(lock->block_q,
 782                                         (lock->blist.prev == &lock->blist) &&
 783                                         (lock->blist.next == &lock->blist));
 784                 if (!rc)
 785                         goto try_again;
 786                 mutex_lock(&cinode->lock_mutex);
 787                 list_del_init(&lock->blist);
 788         }
 789
 790         mutex_unlock(&cinode->lock_mutex);
 791         return rc;
 792 }
 793
 794 /*
 795  * Check if there is another lock that prevents us to set the lock (posix
 796  * style). If such a lock exists, update the flock structure with its
 797  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 798  * or leave it the same if we can't. Returns 0 if we don't need to request to
 799  * the server or 1 otherwise.
 800  */
 801 static int
 802 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
 803 {
 804         int rc = 0;
 805         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
 806         unsigned char saved_type = flock->fl_type;
 807
 808         if ((flock->fl_flags & FL_POSIX) == 0)
 809                 return 1;
 810
 811         mutex_lock(&cinode->lock_mutex);
 812         posix_test_lock(file, flock);
 813
 814         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
 815                 flock->fl_type = saved_type;
 816                 rc = 1;
 817         }
 818
 819         mutex_unlock(&cinode->lock_mutex);
 820         return rc;
 821 }
 822
 823 /*
 824  * Set the byte-range lock (posix style). Returns:
 825  * 1) 0, if we set the lock and don't need to request to the server;
 826  * 2) 1, if we need to request to the server;
 827  * 3) <0, if the error occurs while setting the lock.
 828  */
 829 static int
 830 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
 831 {
 832         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
 833         int rc = 1;
 834
 835         if ((flock->fl_flags & FL_POSIX) == 0)
 836                 return rc;
 837
 838         mutex_lock(&cinode->lock_mutex);
 839         if (!cinode->can_cache_brlcks) {
 840                 mutex_unlock(&cinode->lock_mutex);
 841                 return rc;
 842         }
 843         rc = posix_lock_file_wait(file, flock);
 844         mutex_unlock(&cinode->lock_mutex);
 845         return rc;
 846 }
 847
 848 static int
 849 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
 850 {
 851         int xid, rc = 0, stored_rc;
 852         struct cifsLockInfo *li, *tmp;
 853         struct cifs_tcon *tcon;
 854         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 855         unsigned int num, max_num;
 856         LOCKING_ANDX_RANGE *buf, *cur;
 857         int types[] = {LOCKING_ANDX_LARGE_FILES,
 858                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
 859         int i;
 860
 861         xid = GetXid();
 862         tcon = tlink_tcon(cfile->tlink);
 863
 864         mutex_lock(&cinode->lock_mutex);
 865         if (!cinode->can_cache_brlcks) {
 866                 mutex_unlock(&cinode->lock_mutex);
 867                 FreeXid(xid);
 868                 return rc;
 869         }
 870
 871         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
 872                   sizeof(LOCKING_ANDX_RANGE);
 873         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
 874         if (!buf) {
 875                 mutex_unlock(&cinode->lock_mutex);
 876                 FreeXid(xid);
 877                 return rc;
 878         }
 879
 880         for (i = 0; i < 2; i++) {
 881                 cur = buf;
 882                 num = 0;
 883                 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
 884                         if (li->type != types[i])
 885                                 continue;
 886                         cur->Pid = cpu_to_le16(li->pid);
 887                         cur->LengthLow = cpu_to_le32((u32)li->length);
 888                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
 889                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
 890                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
 891                         if (++num == max_num) {
 892                                 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
 893                                                        li->type, 0, num, buf);
 894                                 if (stored_rc)
 895                                         rc = stored_rc;
 896                                 cur = buf;
 897                                 num = 0;
 898                         } else
 899                                 cur++;
 900                 }
 901
 902                 if (num) {
 903                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
 904                                                types[i], 0, num, buf);
 905                         if (stored_rc)
 906                                 rc = stored_rc;
 907                 }
 908         }
 909
 910         cinode->can_cache_brlcks = false;
 911         mutex_unlock(&cinode->lock_mutex);
 912
 913         kfree(buf);
 914         FreeXid(xid);
 915         return rc;
 916 }
 917
 918 /* copied from fs/locks.c with a name change */
 919 #define cifs_for_each_lock(inode, lockp) \
 920         for (lockp = &inode->i_flock; *lockp != NULL; \
 921              lockp = &(*lockp)->fl_next)
 922
 923 struct lock_to_push {
 924         struct list_head llist;
 925         __u64 offset;
 926         __u64 length;
 927         __u32 pid;
 928         __u16 netfid;
 929         __u8 type;
 930 };
 931
 932 static int
 933 cifs_push_posix_locks(struct cifsFileInfo *cfile)
 934 {
 935         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
 936         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 937         struct file_lock *flock, **before;
 938         unsigned int count = 0, i = 0;
 939         int rc = 0, xid, type;
 940         struct list_head locks_to_send, *el;
 941         struct lock_to_push *lck, *tmp;
 942         __u64 length;
 943
 944         xid = GetXid();
 945
 946         mutex_lock(&cinode->lock_mutex);
 947         if (!cinode->can_cache_brlcks) {
 948                 mutex_unlock(&cinode->lock_mutex);
 949                 FreeXid(xid);
 950                 return rc;
 951         }
 952
 953         lock_flocks();
 954         cifs_for_each_lock(cfile->dentry->d_inode, before) {
 955                 if ((*before)->fl_flags & FL_POSIX)
 956                         count++;
 957         }
 958         unlock_flocks();
 959
 960         INIT_LIST_HEAD(&locks_to_send);
 961
 962         /*
 963          * Allocating count locks is enough because no FL_POSIX locks can be
 964          * added to the list while we are holding cinode->lock_mutex that
 965          * protects locking operations of this inode.
 966          */
 967         for (; i < count; i++) {
 968                 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
 969                 if (!lck) {
 970                         rc = -ENOMEM;
 971                         goto err_out;
 972                 }
 973                 list_add_tail(&lck->llist, &locks_to_send);
 974         }
 975
 976         el = locks_to_send.next;
 977         lock_flocks();
 978         cifs_for_each_lock(cfile->dentry->d_inode, before) {
 979                 flock = *before;
 980                 if ((flock->fl_flags & FL_POSIX) == 0)
 981                         continue;
 982                 if (el == &locks_to_send) {
 983                         /*
 984                          * The list ended. We don't have enough allocated
 985                          * structures - something is really wrong.
 986                          */
 987                         cERROR(1, "Can't push all brlocks!");
 988                         break;
 989                 }
 990                 length = 1 + flock->fl_end - flock->fl_start;
 991                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
 992                         type = CIFS_RDLCK;
 993                 else
 994                         type = CIFS_WRLCK;
 995                 lck = list_entry(el, struct lock_to_push, llist);
 996                 lck->pid = flock->fl_pid;
 997                 lck->netfid = cfile->netfid;
 998                 lck->length = length;
 999                 lck->type = type;
1000                 lck->offset = flock->fl_start;
1001                 el = el->next;
1002         }
1003         unlock_flocks();
1004
1005         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1006                 struct file_lock tmp_lock;
1007                 int stored_rc;
1008
1009                 tmp_lock.fl_start = lck->offset;
1010                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1011                                              0, lck->length, &tmp_lock,
1012                                              lck->type, 0);
1013                 if (stored_rc)
1014                         rc = stored_rc;
1015                 list_del(&lck->llist);
1016                 kfree(lck);
1017         }
1018
1019 out:
1020         cinode->can_cache_brlcks = false;
1021         mutex_unlock(&cinode->lock_mutex);
1022
1023         FreeXid(xid);
1024         return rc;
1025 err_out:
1026         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1027                 list_del(&lck->llist);
1028                 kfree(lck);
1029         }
1030         goto out;
1031 }
1032
1033 static int
1034 cifs_push_locks(struct cifsFileInfo *cfile)
1035 {
1036         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1037         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1038
1039         if ((tcon->ses->capabilities & CAP_UNIX) &&
1040             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1041             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1042                 return cifs_push_posix_locks(cfile);
1043
1044         return cifs_push_mandatory_locks(cfile);
1045 }
1046
1047 static void
1048 cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
1049                 bool *wait_flag)
1050 {
1051         if (flock->fl_flags & FL_POSIX)
1052                 cFYI(1, "Posix");
1053         if (flock->fl_flags & FL_FLOCK)
1054                 cFYI(1, "Flock");
1055         if (flock->fl_flags & FL_SLEEP) {
1056                 cFYI(1, "Blocking lock");
1057                 *wait_flag = true;
1058         }
1059         if (flock->fl_flags & FL_ACCESS)
1060                 cFYI(1, "Process suspended by mandatory locking - "
1061                         "not implemented yet");
1062         if (flock->fl_flags & FL_LEASE)
1063                 cFYI(1, "Lease on file - not implemented yet");
1064         if (flock->fl_flags &
1065             (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
1066                 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1067
1068         *type = LOCKING_ANDX_LARGE_FILES;
1069         if (flock->fl_type == F_WRLCK) {
1070                 cFYI(1, "F_WRLCK ");
1071                 *lock = 1;
1072         } else if (flock->fl_type == F_UNLCK) {
1073                 cFYI(1, "F_UNLCK");
1074                 *unlock = 1;
1075                 /* Check if unlock includes more than one lock range */
1076         } else if (flock->fl_type == F_RDLCK) {
1077                 cFYI(1, "F_RDLCK");
1078                 *type |= LOCKING_ANDX_SHARED_LOCK;
1079                 *lock = 1;
1080         } else if (flock->fl_type == F_EXLCK) {
1081                 cFYI(1, "F_EXLCK");
1082                 *lock = 1;
1083         } else if (flock->fl_type == F_SHLCK) {
1084                 cFYI(1, "F_SHLCK");
1085                 *type |= LOCKING_ANDX_SHARED_LOCK;
1086                 *lock = 1;
1087         } else
1088                 cFYI(1, "Unknown type of lock");
1089 }
1090
1091 static int
1092 cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
1093            bool wait_flag, bool posix_lck, int xid)
1094 {
1095         int rc = 0;
1096         __u64 length = 1 + flock->fl_end - flock->fl_start;
1097         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1098         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1099         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1100         __u16 netfid = cfile->netfid;
1101
1102         if (posix_lck) {
1103                 int posix_lock_type;
1104
1105                 rc = cifs_posix_lock_test(file, flock);
1106                 if (!rc)
1107                         return rc;
1108
1109                 if (type & LOCKING_ANDX_SHARED_LOCK)
1110                         posix_lock_type = CIFS_RDLCK;
1111                 else
1112                         posix_lock_type = CIFS_WRLCK;
1113                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1114                                       1 /* get */, length, flock,
1115                                       posix_lock_type, wait_flag);
1116                 return rc;
1117         }
1118
1119         rc = cifs_lock_test(cinode, flock->fl_start, length, type, netfid,
1120                             flock);
1121         if (!rc)
1122                 return rc;
1123
1124         /* BB we could chain these into one lock request BB */
1125         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1126                          flock->fl_start, 0, 1, type, 0, 0);
1127         if (rc == 0) {
1128                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1129                                  length, flock->fl_start, 1, 0,
1130                                  type, 0, 0);
1131                 flock->fl_type = F_UNLCK;
1132                 if (rc != 0)
1133                         cERROR(1, "Error unlocking previously locked "
1134                                    "range %d during test of lock", rc);
1135                 return 0;
1136         }
1137
1138         if (type & LOCKING_ANDX_SHARED_LOCK) {
1139                 flock->fl_type = F_WRLCK;
1140                 return 0;
1141         }
1142
1143         rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1144                          flock->fl_start, 0, 1,
1145                          type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1146         if (rc == 0) {
1147                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1148                                  length, flock->fl_start, 1, 0,
1149                                  type | LOCKING_ANDX_SHARED_LOCK,
1150                                  0, 0);
1151                 flock->fl_type = F_RDLCK;
1152                 if (rc != 0)
1153                         cERROR(1, "Error unlocking previously locked "
1154                                   "range %d during test of lock", rc);
1155         } else
1156                 flock->fl_type = F_WRLCK;
1157
1158         return 0;
1159 }
1160
1161 static void
1162 cifs_move_llist(struct list_head *source, struct list_head *dest)
1163 {
1164         struct list_head *li, *tmp;
1165         list_for_each_safe(li, tmp, source)
1166                 list_move(li, dest);
1167 }
1168
1169 static void
1170 cifs_free_llist(struct list_head *llist)
1171 {
1172         struct cifsLockInfo *li, *tmp;
1173         list_for_each_entry_safe(li, tmp, llist, llist) {
1174                 cifs_del_lock_waiters(li);
1175                 list_del(&li->llist);
1176                 kfree(li);
1177         }
1178 }
1179
1180 static int
1181 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1182 {
1183         int rc = 0, stored_rc;
1184         int types[] = {LOCKING_ANDX_LARGE_FILES,
1185                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1186         unsigned int i;
1187         unsigned int max_num, num;
1188         LOCKING_ANDX_RANGE *buf, *cur;
1189         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1190         struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1191         struct cifsLockInfo *li, *tmp;
1192         __u64 length = 1 + flock->fl_end - flock->fl_start;
1193         struct list_head tmp_llist;
1194
1195         INIT_LIST_HEAD(&tmp_llist);
1196
1197         max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1198                   sizeof(LOCKING_ANDX_RANGE);
1199         buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1200         if (!buf)
1201                 return -ENOMEM;
1202
1203         mutex_lock(&cinode->lock_mutex);
1204         for (i = 0; i < 2; i++) {
1205                 cur = buf;
1206                 num = 0;
1207                 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
1208                         if (flock->fl_start > li->offset ||
1209                             (flock->fl_start + length) <
1210                             (li->offset + li->length))
1211                                 continue;
1212                         if (current->tgid != li->pid)
1213                                 continue;
1214                         if (cfile->netfid != li->netfid)
1215                                 continue;
1216                         if (types[i] != li->type)
1217                                 continue;
1218                         if (!cinode->can_cache_brlcks) {
1219                                 cur->Pid = cpu_to_le16(li->pid);
1220                                 cur->LengthLow = cpu_to_le32((u32)li->length);
1221                                 cur->LengthHigh =
1222                                         cpu_to_le32((u32)(li->length>>32));
1223                                 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1224                                 cur->OffsetHigh =
1225                                         cpu_to_le32((u32)(li->offset>>32));
1226                                 /*
1227                                  * We need to save a lock here to let us add
1228                                  * it again to the inode list if the unlock
1229                                  * range request fails on the server.
1230                                  */
1231                                 list_move(&li->llist, &tmp_llist);
1232                                 if (++num == max_num) {
1233                                         stored_rc = cifs_lockv(xid, tcon,
1234                                                                cfile->netfid,
1235                                                                li->type, num,
1236                                                                0, buf);
1237                                         if (stored_rc) {
1238                                                 /*
1239                                                  * We failed on the unlock range
1240                                                  * request - add all locks from
1241                                                  * the tmp list to the head of
1242                                                  * the inode list.
1243                                                  */
1244                                                 cifs_move_llist(&tmp_llist,
1245                                                                 &cinode->llist);
1246                                                 rc = stored_rc;
1247                                         } else
1248                                                 /*
1249                                                  * The unlock range request
1250                                                  * succeed - free the tmp list.
1251                                                  */
1252                                                 cifs_free_llist(&tmp_llist);
1253                                         cur = buf;
1254                                         num = 0;
1255                                 } else
1256                                         cur++;
1257                         } else {
1258                                 /*
1259                                  * We can cache brlock requests - simply remove
1260                                  * a lock from the inode list.
1261                                  */
1262                                 list_del(&li->llist);
1263                                 cifs_del_lock_waiters(li);
1264                                 kfree(li);
1265                         }
1266                 }
1267                 if (num) {
1268                         stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1269                                                types[i], num, 0, buf);
1270                         if (stored_rc) {
1271                                 cifs_move_llist(&tmp_llist, &cinode->llist);
1272                                 rc = stored_rc;
1273                         } else
1274                                 cifs_free_llist(&tmp_llist);
1275                 }
1276         }
1277
1278         mutex_unlock(&cinode->lock_mutex);
1279         kfree(buf);
1280         return rc;
1281 }
1282
1283 static int
1284 cifs_setlk(struct file *file,  struct file_lock *flock, __u8 type,
1285            bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1286 {
1287         int rc = 0;
1288         __u64 length = 1 + flock->fl_end - flock->fl_start;
1289         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1290         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1291         struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
1292         __u16 netfid = cfile->netfid;
1293
1294         if (posix_lck) {
1295                 int posix_lock_type;
1296
1297                 rc = cifs_posix_lock_set(file, flock);
1298                 if (!rc || rc < 0)
1299                         return rc;
1300
1301                 if (type & LOCKING_ANDX_SHARED_LOCK)
1302                         posix_lock_type = CIFS_RDLCK;
1303                 else
1304                         posix_lock_type = CIFS_WRLCK;
1305
1306                 if (unlock == 1)
1307                         posix_lock_type = CIFS_UNLCK;
1308
1309                 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1310                                       0 /* set */, length, flock,
1311                                       posix_lock_type, wait_flag);
1312                 goto out;
1313         }
1314
1315         if (lock) {
1316                 struct cifsLockInfo *lock;
1317
1318                 lock = cifs_lock_init(flock->fl_start, length, type, netfid);
1319                 if (!lock)
1320                         return -ENOMEM;
1321
1322                 rc = cifs_lock_add_if(cinode, lock, wait_flag);
1323                 if (rc < 0)
1324                         kfree(lock);
1325                 if (rc <= 0)
1326                         goto out;
1327
1328                 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1329                                  flock->fl_start, 0, 1, type, wait_flag, 0);
1330                 if (rc) {
1331                         kfree(lock);
1332                         goto out;
1333                 }
1334
1335                 cifs_lock_add(cinode, lock);
1336         } else if (unlock)
1337                 rc = cifs_unlock_range(cfile, flock, xid);
1338
1339 out:
1340         if (flock->fl_flags & FL_POSIX)
1341                 posix_lock_file_wait(file, flock);
1342         return rc;
1343 }
1344
1345 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1346 {
1347         int rc, xid;
1348         int lock = 0, unlock = 0;
1349         bool wait_flag = false;
1350         bool posix_lck = false;
1351         struct cifs_sb_info *cifs_sb;
1352         struct cifs_tcon *tcon;
1353         struct cifsInodeInfo *cinode;
1354         struct cifsFileInfo *cfile;
1355         __u16 netfid;
1356         __u8 type;
1357
1358         rc = -EACCES;
1359         xid = GetXid();
1360
1361         cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1362                 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1363                 flock->fl_start, flock->fl_end);
1364
1365         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1366
1367         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1368         cfile = (struct cifsFileInfo *)file->private_data;
1369         tcon = tlink_tcon(cfile->tlink);
1370         netfid = cfile->netfid;
1371         cinode = CIFS_I(file->f_path.dentry->d_inode);
1372
1373         if ((tcon->ses->capabilities & CAP_UNIX) &&
1374             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1375             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1376                 posix_lck = true;
1377         /*
1378          * BB add code here to normalize offset and length to account for
1379          * negative length which we can not accept over the wire.
1380          */
1381         if (IS_GETLK(cmd)) {
1382                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1383                 FreeXid(xid);
1384                 return rc;
1385         }
1386
1387         if (!lock && !unlock) {
1388                 /*
1389                  * if no lock or unlock then nothing to do since we do not
1390                  * know what it is
1391                  */
1392                 FreeXid(xid);
1393                 return -EOPNOTSUPP;
1394         }
1395
1396         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1397                         xid);
1398         FreeXid(xid);
1399         return rc;
1400 }
1401
1402 /*
1403  * update the file size (if needed) after a write. Should be called with
1404  * the inode->i_lock held
1405  */
1406 void
1407 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1408                       unsigned int bytes_written)
1409 {
1410         loff_t end_of_write = offset + bytes_written;
1411
1412         if (end_of_write > cifsi->server_eof)
1413                 cifsi->server_eof = end_of_write;
1414 }
1415
1416 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1417                           const char *write_data, size_t write_size,
1418                           loff_t *poffset)
1419 {
1420         int rc = 0;
1421         unsigned int bytes_written = 0;
1422         unsigned int total_written;
1423         struct cifs_sb_info *cifs_sb;
1424         struct cifs_tcon *pTcon;
1425         int xid;
1426         struct dentry *dentry = open_file->dentry;
1427         struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1428         struct cifs_io_parms io_parms;
1429
1430         cifs_sb = CIFS_SB(dentry->d_sb);
1431
1432         cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1433            *poffset, dentry->d_name.name);
1434
1435         pTcon = tlink_tcon(open_file->tlink);
1436
1437         xid = GetXid();
1438
1439         for (total_written = 0; write_size > total_written;
1440              total_written += bytes_written) {
1441                 rc = -EAGAIN;
1442                 while (rc == -EAGAIN) {
1443                         struct kvec iov[2];
1444                         unsigned int len;
1445
1446                         if (open_file->invalidHandle) {
1447                                 /* we could deadlock if we called
1448                                    filemap_fdatawait from here so tell
1449                                    reopen_file not to flush data to
1450                                    server now */
1451                                 rc = cifs_reopen_file(open_file, false);
1452                                 if (rc != 0)
1453                                         break;
1454                         }
1455
1456                         len = min((size_t)cifs_sb->wsize,
1457                                   write_size - total_written);
1458                         /* iov[0] is reserved for smb header */
1459                         iov[1].iov_base = (char *)write_data + total_written;
1460                         iov[1].iov_len = len;
1461                         io_parms.netfid = open_file->netfid;
1462                         io_parms.pid = pid;
1463                         io_parms.tcon = pTcon;
1464                         io_parms.offset = *poffset;
1465                         io_parms.length = len;
1466                         rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1467                                            1, 0);
1468                 }
1469                 if (rc || (bytes_written == 0)) {
1470                         if (total_written)
1471                                 break;
1472                         else {
1473                                 FreeXid(xid);
1474                                 return rc;
1475                         }
1476                 } else {
1477                         spin_lock(&dentry->d_inode->i_lock);
1478                         cifs_update_eof(cifsi, *poffset, bytes_written);
1479                         spin_unlock(&dentry->d_inode->i_lock);
1480                         *poffset += bytes_written;
1481                 }
1482         }
1483
1484         cifs_stats_bytes_written(pTcon, total_written);
1485
1486         if (total_written > 0) {
1487                 spin_lock(&dentry->d_inode->i_lock);
1488                 if (*poffset > dentry->d_inode->i_size)
1489                         i_size_write(dentry->d_inode, *poffset);
1490                 spin_unlock(&dentry->d_inode->i_lock);
1491         }
1492         mark_inode_dirty_sync(dentry->d_inode);
1493         FreeXid(xid);
1494         return total_written;
1495 }
1496
1497 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1498                                         bool fsuid_only)
1499 {
1500         struct cifsFileInfo *open_file = NULL;
1501         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1502
1503         /* only filter by fsuid on multiuser mounts */
1504         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1505                 fsuid_only = false;
1506
1507         spin_lock(&cifs_file_list_lock);
1508         /* we could simply get the first_list_entry since write-only entries
1509            are always at the end of the list but since the first entry might
1510            have a close pending, we go through the whole list */
1511         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1512                 if (fsuid_only && open_file->uid != current_fsuid())
1513                         continue;
1514                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1515                         if (!open_file->invalidHandle) {
1516                                 /* found a good file */
1517                                 /* lock it so it will not be closed on us */
1518                                 cifsFileInfo_get(open_file);
1519                                 spin_unlock(&cifs_file_list_lock);
1520                                 return open_file;
1521                         } /* else might as well continue, and look for
1522                              another, or simply have the caller reopen it
1523                              again rather than trying to fix this handle */
1524                 } else /* write only file */
1525                         break; /* write only files are last so must be done */
1526         }
1527         spin_unlock(&cifs_file_list_lock);
1528         return NULL;
1529 }
1530
1531 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1532                                         bool fsuid_only)
1533 {
1534         struct cifsFileInfo *open_file;
1535         struct cifs_sb_info *cifs_sb;
1536         bool any_available = false;
1537         int rc;
1538
1539         /* Having a null inode here (because mapping->host was set to zero by
1540         the VFS or MM) should not happen but we had reports of on oops (due to
1541         it being zero) during stress testcases so we need to check for it */
1542
1543         if (cifs_inode == NULL) {
1544                 cERROR(1, "Null inode passed to cifs_writeable_file");
1545                 dump_stack();
1546                 return NULL;
1547         }
1548
1549         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1550
1551         /* only filter by fsuid on multiuser mounts */
1552         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1553                 fsuid_only = false;
1554
1555         spin_lock(&cifs_file_list_lock);
1556 refind_writable:
1557         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1558                 if (!any_available && open_file->pid != current->tgid)
1559                         continue;
1560                 if (fsuid_only && open_file->uid != current_fsuid())
1561                         continue;
1562                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1563                         cifsFileInfo_get(open_file);
1564
1565                         if (!open_file->invalidHandle) {
1566                                 /* found a good writable file */
1567                                 spin_unlock(&cifs_file_list_lock);
1568                                 return open_file;
1569                         }
1570
1571                         spin_unlock(&cifs_file_list_lock);
1572
1573                         /* Had to unlock since following call can block */
1574                         rc = cifs_reopen_file(open_file, false);
1575                         if (!rc)
1576                                 return open_file;
1577
1578                         /* if it fails, try another handle if possible */
1579                         cFYI(1, "wp failed on reopen file");
1580                         cifsFileInfo_put(open_file);
1581
1582                         spin_lock(&cifs_file_list_lock);
1583
1584                         /* else we simply continue to the next entry. Thus
1585                            we do not loop on reopen errors.  If we
1586                            can not reopen the file, for example if we
1587                            reconnected to a server with another client
1588                            racing to delete or lock the file we would not
1589                            make progress if we restarted before the beginning
1590                            of the loop here. */
1591                 }
1592         }
1593         /* couldn't find useable FH with same pid, try any available */
1594         if (!any_available) {
1595                 any_available = true;
1596                 goto refind_writable;
1597         }
1598         spin_unlock(&cifs_file_list_lock);
1599         return NULL;
1600 }
1601
1602 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1603 {
1604         struct address_space *mapping = page->mapping;
1605         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1606         char *write_data;
1607         int rc = -EFAULT;
1608         int bytes_written = 0;
1609         struct inode *inode;
1610         struct cifsFileInfo *open_file;
1611
1612         if (!mapping || !mapping->host)
1613                 return -EFAULT;
1614
1615         inode = page->mapping->host;
1616
1617         offset += (loff_t)from;
1618         write_data = kmap(page);
1619         write_data += from;
1620
1621         if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1622                 kunmap(page);
1623                 return -EIO;
1624         }
1625
1626         /* racing with truncate? */
1627         if (offset > mapping->host->i_size) {
1628                 kunmap(page);
1629                 return 0; /* don't care */
1630         }
1631
1632         /* check to make sure that we are not extending the file */
1633         if (mapping->host->i_size - offset < (loff_t)to)
1634                 to = (unsigned)(mapping->host->i_size - offset);
1635
1636         open_file = find_writable_file(CIFS_I(mapping->host), false);
1637         if (open_file) {
1638                 bytes_written = cifs_write(open_file, open_file->pid,
1639                                            write_data, to - from, &offset);
1640                 cifsFileInfo_put(open_file);
1641                 /* Does mm or vfs already set times? */
1642                 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1643                 if ((bytes_written > 0) && (offset))
1644                         rc = 0;
1645                 else if (bytes_written < 0)
1646                         rc = bytes_written;
1647         } else {
1648                 cFYI(1, "No writeable filehandles for inode");
1649                 rc = -EIO;
1650         }
1651
1652         kunmap(page);
1653         return rc;
1654 }
1655
1656 /*
1657  * Marshal up the iov array, reserving the first one for the header. Also,
1658  * set wdata->bytes.
1659  */
1660 static void
1661 cifs_writepages_marshal_iov(struct kvec *iov, struct cifs_writedata *wdata)
1662 {
1663         int i;
1664         struct inode *inode = wdata->cfile->dentry->d_inode;
1665         loff_t size = i_size_read(inode);
1666
1667         /* marshal up the pages into iov array */
1668         wdata->bytes = 0;
1669         for (i = 0; i < wdata->nr_pages; i++) {
1670                 iov[i + 1].iov_len = min(size - page_offset(wdata->pages[i]),
1671                                         (loff_t)PAGE_CACHE_SIZE);
1672                 iov[i + 1].iov_base = kmap(wdata->pages[i]);
1673                 wdata->bytes += iov[i + 1].iov_len;
1674         }
1675 }
1676
1677 static int cifs_writepages(struct address_space *mapping,
1678                            struct writeback_control *wbc)
1679 {
1680         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1681         bool done = false, scanned = false, range_whole = false;
1682         pgoff_t end, index;
1683         struct cifs_writedata *wdata;
1684         struct page *page;
1685         int rc = 0;
1686
1687         /*
1688          * If wsize is smaller than the page cache size, default to writing
1689          * one page at a time via cifs_writepage
1690          */
1691         if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1692                 return generic_writepages(mapping, wbc);
1693
1694         if (wbc->range_cyclic) {
1695                 index = mapping->writeback_index; /* Start from prev offset */
1696                 end = -1;
1697         } else {
1698                 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1699                 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1700                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1701                         range_whole = true;
1702                 scanned = true;
1703         }
1704 retry:
1705         while (!done && index <= end) {
1706                 unsigned int i, nr_pages, found_pages;
1707                 pgoff_t next = 0, tofind;
1708                 struct page **pages;
1709
1710                 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1711                                 end - index) + 1;
1712
1713                 wdata = cifs_writedata_alloc((unsigned int)tofind,
1714                                              cifs_writev_complete);
1715                 if (!wdata) {
1716                         rc = -ENOMEM;
1717                         break;
1718                 }
1719
1720                 /*
1721                  * find_get_pages_tag seems to return a max of 256 on each
1722                  * iteration, so we must call it several times in order to
1723                  * fill the array or the wsize is effectively limited to
1724                  * 256 * PAGE_CACHE_SIZE.
1725                  */
1726                 found_pages = 0;
1727                 pages = wdata->pages;
1728                 do {
1729                         nr_pages = find_get_pages_tag(mapping, &index,
1730                                                         PAGECACHE_TAG_DIRTY,
1731                                                         tofind, pages);
1732                         found_pages += nr_pages;
1733                         tofind -= nr_pages;
1734                         pages += nr_pages;
1735                 } while (nr_pages && tofind && index <= end);
1736
1737                 if (found_pages == 0) {
1738                         kref_put(&wdata->refcount, cifs_writedata_release);
1739                         break;
1740                 }
1741
1742                 nr_pages = 0;
1743                 for (i = 0; i < found_pages; i++) {
1744                         page = wdata->pages[i];
1745                         /*
1746                          * At this point we hold neither mapping->tree_lock nor
1747                          * lock on the page itself: the page may be truncated or
1748                          * invalidated (changing page->mapping to NULL), or even
1749                          * swizzled back from swapper_space to tmpfs file
1750                          * mapping
1751                          */
1752
1753                         if (nr_pages == 0)
1754                                 lock_page(page);
1755                         else if (!trylock_page(page))
1756                                 break;
1757
1758                         if (unlikely(page->mapping != mapping)) {
1759                                 unlock_page(page);
1760                                 break;
1761                         }
1762
1763                         if (!wbc->range_cyclic && page->index > end) {
1764                                 done = true;
1765                                 unlock_page(page);
1766                                 break;
1767                         }
1768
1769                         if (next && (page->index != next)) {
1770                                 /* Not next consecutive page */
1771                                 unlock_page(page);
1772                                 break;
1773                         }
1774
1775                         if (wbc->sync_mode != WB_SYNC_NONE)
1776                                 wait_on_page_writeback(page);
1777
1778                         if (PageWriteback(page) ||
1779                                         !clear_page_dirty_for_io(page)) {
1780                                 unlock_page(page);
1781                                 break;
1782                         }
1783
1784                         /*
1785                          * This actually clears the dirty bit in the radix tree.
1786                          * See cifs_writepage() for more commentary.
1787                          */
1788                         set_page_writeback(page);
1789
1790                         if (page_offset(page) >= mapping->host->i_size) {
1791                                 done = true;
1792                                 unlock_page(page);
1793                                 end_page_writeback(page);
1794                                 break;
1795                         }
1796
1797                         wdata->pages[i] = page;
1798                         next = page->index + 1;
1799                         ++nr_pages;
1800                 }
1801
1802                 /* reset index to refind any pages skipped */
1803                 if (nr_pages == 0)
1804                         index = wdata->pages[0]->index + 1;
1805
1806                 /* put any pages we aren't going to use */
1807                 for (i = nr_pages; i < found_pages; i++) {
1808                         page_cache_release(wdata->pages[i]);
1809                         wdata->pages[i] = NULL;
1810                 }
1811
1812                 /* nothing to write? */
1813                 if (nr_pages == 0) {
1814                         kref_put(&wdata->refcount, cifs_writedata_release);
1815                         continue;
1816                 }
1817
1818                 wdata->sync_mode = wbc->sync_mode;
1819                 wdata->nr_pages = nr_pages;
1820                 wdata->offset = page_offset(wdata->pages[0]);
1821                 wdata->marshal_iov = cifs_writepages_marshal_iov;
1822
1823                 do {
1824                         if (wdata->cfile != NULL)
1825                                 cifsFileInfo_put(wdata->cfile);
1826                         wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1827                                                           false);
1828                         if (!wdata->cfile) {
1829                                 cERROR(1, "No writable handles for inode");
1830                                 rc = -EBADF;
1831                                 break;
1832                         }
1833                         wdata->pid = wdata->cfile->pid;
1834                         rc = cifs_async_writev(wdata);
1835                 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1836
1837                 for (i = 0; i < nr_pages; ++i)
1838                         unlock_page(wdata->pages[i]);
1839
1840                 /* send failure -- clean up the mess */
1841                 if (rc != 0) {
1842                         for (i = 0; i < nr_pages; ++i) {
1843                                 if (rc == -EAGAIN)
1844                                         redirty_page_for_writepage(wbc,
1845                                                            wdata->pages[i]);
1846                                 else
1847                                         SetPageError(wdata->pages[i]);
1848                                 end_page_writeback(wdata->pages[i]);
1849                                 page_cache_release(wdata->pages[i]);
1850                         }
1851                         if (rc != -EAGAIN)
1852                                 mapping_set_error(mapping, rc);
1853                 }
1854                 kref_put(&wdata->refcount, cifs_writedata_release);
1855
1856                 wbc->nr_to_write -= nr_pages;
1857                 if (wbc->nr_to_write <= 0)
1858                         done = true;
1859
1860                 index = next;
1861         }
1862
1863         if (!scanned && !done) {
1864                 /*
1865                  * We hit the last page and there is more work to be done: wrap
1866                  * back to the start of the file
1867                  */
1868                 scanned = true;
1869                 index = 0;
1870                 goto retry;
1871         }
1872
1873         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1874                 mapping->writeback_index = index;
1875
1876         return rc;
1877 }
1878
1879 static int
1880 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1881 {
1882         int rc;
1883         int xid;
1884
1885         xid = GetXid();
1886 /* BB add check for wbc flags */
1887         page_cache_get(page);
1888         if (!PageUptodate(page))
1889                 cFYI(1, "ppw - page not up to date");
1890
1891         /*
1892          * Set the "writeback" flag, and clear "dirty" in the radix tree.
1893          *
1894          * A writepage() implementation always needs to do either this,
1895          * or re-dirty the page with "redirty_page_for_writepage()" in
1896          * the case of a failure.
1897          *
1898          * Just unlocking the page will cause the radix tree tag-bits
1899          * to fail to update with the state of the page correctly.
1900          */
1901         set_page_writeback(page);
1902 retry_write:
1903         rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1904         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1905                 goto retry_write;
1906         else if (rc == -EAGAIN)
1907                 redirty_page_for_writepage(wbc, page);
1908         else if (rc != 0)
1909                 SetPageError(page);
1910         else
1911                 SetPageUptodate(page);
1912         end_page_writeback(page);
1913         page_cache_release(page);
1914         FreeXid(xid);
1915         return rc;
1916 }
1917
1918 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1919 {
1920         int rc = cifs_writepage_locked(page, wbc);
1921         unlock_page(page);
1922         return rc;
1923 }
1924
1925 static int cifs_write_end(struct file *file, struct address_space *mapping,
1926                         loff_t pos, unsigned len, unsigned copied,
1927                         struct page *page, void *fsdata)
1928 {
1929         int rc;
1930         struct inode *inode = mapping->host;
1931         struct cifsFileInfo *cfile = file->private_data;
1932         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1933         __u32 pid;
1934
1935         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1936                 pid = cfile->pid;
1937         else
1938                 pid = current->tgid;
1939
1940         cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1941                  page, pos, copied);
1942
1943         if (PageChecked(page)) {
1944                 if (copied == len)
1945                         SetPageUptodate(page);
1946                 ClearPageChecked(page);
1947         } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1948                 SetPageUptodate(page);
1949
1950         if (!PageUptodate(page)) {
1951                 char *page_data;
1952                 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1953                 int xid;
1954
1955                 xid = GetXid();
1956                 /* this is probably better than directly calling
1957                    partialpage_write since in this function the file handle is
1958                    known which we might as well leverage */
1959                 /* BB check if anything else missing out of ppw
1960                    such as updating last write time */
1961                 page_data = kmap(page);
1962                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1963                 /* if (rc < 0) should we set writebehind rc? */
1964                 kunmap(page);
1965
1966                 FreeXid(xid);
1967         } else {
1968                 rc = copied;
1969                 pos += copied;
1970                 set_page_dirty(page);
1971         }
1972
1973         if (rc > 0) {
1974                 spin_lock(&inode->i_lock);
1975                 if (pos > inode->i_size)
1976                         i_size_write(inode, pos);
1977                 spin_unlock(&inode->i_lock);
1978         }
1979
1980         unlock_page(page);
1981         page_cache_release(page);
1982
1983         return rc;
1984 }
1985
1986 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1987                       int datasync)
1988 {
1989         int xid;
1990         int rc = 0;
1991         struct cifs_tcon *tcon;
1992         struct cifsFileInfo *smbfile = file->private_data;
1993         struct inode *inode = file->f_path.dentry->d_inode;
1994         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1995
1996         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1997         if (rc)
1998                 return rc;
1999         mutex_lock(&inode->i_mutex);
2000
2001         xid = GetXid();
2002
2003         cFYI(1, "Sync file - name: %s datasync: 0x%x",
2004                 file->f_path.dentry->d_name.name, datasync);
2005
2006         if (!CIFS_I(inode)->clientCanCacheRead) {
2007                 rc = cifs_invalidate_mapping(inode);
2008                 if (rc) {
2009                         cFYI(1, "rc: %d during invalidate phase", rc);
2010                         rc = 0; /* don't care about it in fsync */
2011                 }
2012         }
2013
2014         tcon = tlink_tcon(smbfile->tlink);
2015         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2016                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2017
2018         FreeXid(xid);
2019         mutex_unlock(&inode->i_mutex);
2020         return rc;
2021 }
2022
2023 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2024 {
2025         int xid;
2026         int rc = 0;
2027         struct cifs_tcon *tcon;
2028         struct cifsFileInfo *smbfile = file->private_data;
2029         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2030         struct inode *inode = file->f_mapping->host;
2031
2032         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2033         if (rc)
2034                 return rc;
2035         mutex_lock(&inode->i_mutex);
2036
2037         xid = GetXid();
2038
2039         cFYI(1, "Sync file - name: %s datasync: 0x%x",
2040                 file->f_path.dentry->d_name.name, datasync);
2041
2042         tcon = tlink_tcon(smbfile->tlink);
2043         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2044                 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2045
2046         FreeXid(xid);
2047         mutex_unlock(&inode->i_mutex);
2048         return rc;
2049 }
2050
2051 /*
2052  * As file closes, flush all cached write data for this inode checking
2053  * for write behind errors.
2054  */
2055 int cifs_flush(struct file *file, fl_owner_t id)
2056 {
2057         struct inode *inode = file->f_path.dentry->d_inode;
2058         int rc = 0;
2059
2060         if (file->f_mode & FMODE_WRITE)
2061                 rc = filemap_write_and_wait(inode->i_mapping);
2062
2063         cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2064
2065         return rc;
2066 }
2067
2068 static int
2069 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2070 {
2071         int rc = 0;
2072         unsigned long i;
2073
2074         for (i = 0; i < num_pages; i++) {
2075                 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2076                 if (!pages[i]) {
2077                         /*
2078                          * save number of pages we have already allocated and
2079                          * return with ENOMEM error
2080                          */
2081                         num_pages = i;
2082                         rc = -ENOMEM;
2083                         break;
2084                 }
2085         }
2086
2087         if (rc) {
2088                 for (i = 0; i < num_pages; i++)
2089                         put_page(pages[i]);
2090         }
2091         return rc;
2092 }
2093
2094 static inline
2095 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2096 {
2097         size_t num_pages;
2098         size_t clen;
2099
2100         clen = min_t(const size_t, len, wsize);
2101         num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2102
2103         if (cur_len)
2104                 *cur_len = clen;
2105
2106         return num_pages;
2107 }
2108
2109 static void
2110 cifs_uncached_marshal_iov(struct kvec *iov, struct cifs_writedata *wdata)
2111 {
2112         int i;
2113         size_t bytes = wdata->bytes;
2114
2115         /* marshal up the pages into iov array */
2116         for (i = 0; i < wdata->nr_pages; i++) {
2117                 iov[i + 1].iov_len = min_t(size_t, bytes, PAGE_SIZE);
2118                 iov[i + 1].iov_base = kmap(wdata->pages[i]);
2119                 bytes -= iov[i + 1].iov_len;
2120         }
2121 }
2122
2123 static void
2124 cifs_uncached_writev_complete(struct work_struct *work)
2125 {
2126         int i;
2127         struct cifs_writedata *wdata = container_of(work,
2128                                         struct cifs_writedata, work);
2129         struct inode *inode = wdata->cfile->dentry->d_inode;
2130         struct cifsInodeInfo *cifsi = CIFS_I(inode);
2131
2132         spin_lock(&inode->i_lock);
2133         cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2134         if (cifsi->server_eof > inode->i_size)
2135                 i_size_write(inode, cifsi->server_eof);
2136         spin_unlock(&inode->i_lock);
2137
2138         complete(&wdata->done);
2139
2140         if (wdata->result != -EAGAIN) {
2141                 for (i = 0; i < wdata->nr_pages; i++)
2142                         put_page(wdata->pages[i]);
2143         }
2144
2145         kref_put(&wdata->refcount, cifs_writedata_release);
2146 }
2147
2148 /* attempt to send write to server, retry on any -EAGAIN errors */
2149 static int
2150 cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2151 {
2152         int rc;
2153
2154         do {
2155                 if (wdata->cfile->invalidHandle) {
2156                         rc = cifs_reopen_file(wdata->cfile, false);
2157                         if (rc != 0)
2158                                 continue;
2159                 }
2160                 rc = cifs_async_writev(wdata);
2161         } while (rc == -EAGAIN);
2162
2163         return rc;
2164 }
2165
2166 static ssize_t
2167 cifs_iovec_write(struct file *file, const struct iovec *iov,
2168                  unsigned long nr_segs, loff_t *poffset)
2169 {
2170         unsigned long nr_pages, i;
2171         size_t copied, len, cur_len;
2172         ssize_t total_written = 0;
2173         loff_t offset = *poffset;
2174         struct iov_iter it;
2175         struct cifsFileInfo *open_file;
2176         struct cifs_tcon *tcon;
2177         struct cifs_sb_info *cifs_sb;
2178         struct cifs_writedata *wdata, *tmp;
2179         struct list_head wdata_list;
2180         int rc;
2181         pid_t pid;
2182
2183         len = iov_length(iov, nr_segs);
2184         if (!len)
2185                 return 0;
2186
2187         rc = generic_write_checks(file, poffset, &len, 0);
2188         if (rc)
2189                 return rc;
2190
2191         INIT_LIST_HEAD(&wdata_list);
2192         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2193         open_file = file->private_data;
2194         tcon = tlink_tcon(open_file->tlink);
2195
2196         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2197                 pid = open_file->pid;
2198         else
2199                 pid = current->tgid;
2200
2201         iov_iter_init(&it, iov, nr_segs, len, 0);
2202         do {
2203                 size_t save_len;
2204
2205                 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2206                 wdata = cifs_writedata_alloc(nr_pages,
2207                                              cifs_uncached_writev_complete);
2208                 if (!wdata) {
2209                         rc = -ENOMEM;
2210                         break;
2211                 }
2212
2213                 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2214                 if (rc) {
2215                         kfree(wdata);
2216                         break;
2217                 }
2218
2219                 save_len = cur_len;
2220                 for (i = 0; i < nr_pages; i++) {
2221                         copied = min_t(const size_t, cur_len, PAGE_SIZE);
2222                         copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2223                                                          0, copied);
2224                         cur_len -= copied;
2225                         iov_iter_advance(&it, copied);
2226                 }
2227                 cur_len = save_len - cur_len;
2228
2229                 wdata->sync_mode = WB_SYNC_ALL;
2230                 wdata->nr_pages = nr_pages;
2231                 wdata->offset = (__u64)offset;
2232                 wdata->cfile = cifsFileInfo_get(open_file);
2233                 wdata->pid = pid;
2234                 wdata->bytes = cur_len;
2235                 wdata->marshal_iov = cifs_uncached_marshal_iov;
2236                 rc = cifs_uncached_retry_writev(wdata);
2237                 if (rc) {
2238                         kref_put(&wdata->refcount, cifs_writedata_release);
2239                         break;
2240                 }
2241
2242                 list_add_tail(&wdata->list, &wdata_list);
2243                 offset += cur_len;
2244                 len -= cur_len;
2245         } while (len > 0);
2246
2247         /*
2248          * If at least one write was successfully sent, then discard any rc
2249          * value from the later writes. If the other write succeeds, then
2250          * we'll end up returning whatever was written. If it fails, then
2251          * we'll get a new rc value from that.
2252          */
2253         if (!list_empty(&wdata_list))
2254                 rc = 0;
2255
2256         /*
2257          * Wait for and collect replies for any successful sends in order of
2258          * increasing offset. Once an error is hit or we get a fatal signal
2259          * while waiting, then return without waiting for any more replies.
2260          */
2261 restart_loop:
2262         list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2263                 if (!rc) {
2264                         /* FIXME: freezable too? */
2265                         rc = wait_for_completion_killable(&wdata->done);
2266                         if (rc)
2267                                 rc = -EINTR;
2268                         else if (wdata->result)
2269                                 rc = wdata->result;
2270                         else
2271                                 total_written += wdata->bytes;
2272
2273                         /* resend call if it's a retryable error */
2274                         if (rc == -EAGAIN) {
2275                                 rc = cifs_uncached_retry_writev(wdata);
2276                                 goto restart_loop;
2277                         }
2278                 }
2279                 list_del_init(&wdata->list);
2280                 kref_put(&wdata->refcount, cifs_writedata_release);
2281         }
2282
2283         if (total_written > 0)
2284                 *poffset += total_written;
2285
2286         cifs_stats_bytes_written(tcon, total_written);
2287         return total_written ? total_written : (ssize_t)rc;
2288 }
2289
2290 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2291                                 unsigned long nr_segs, loff_t pos)
2292 {
2293         ssize_t written;
2294         struct inode *inode;
2295
2296         inode = iocb->ki_filp->f_path.dentry->d_inode;
2297
2298         /*
2299          * BB - optimize the way when signing is disabled. We can drop this
2300          * extra memory-to-memory copying and use iovec buffers for constructing
2301          * write request.
2302          */
2303
2304         written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2305         if (written > 0) {
2306                 CIFS_I(inode)->invalid_mapping = true;
2307                 iocb->ki_pos = pos;
2308         }
2309
2310         return written;
2311 }
2312
2313 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2314                            unsigned long nr_segs, loff_t pos)
2315 {
2316         struct inode *inode;
2317
2318         inode = iocb->ki_filp->f_path.dentry->d_inode;
2319
2320         if (CIFS_I(inode)->clientCanCacheAll)
2321                 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2322
2323         /*
2324          * In strict cache mode we need to write the data to the server exactly
2325          * from the pos to pos+len-1 rather than flush all affected pages
2326          * because it may cause a error with mandatory locks on these pages but
2327          * not on the region from pos to ppos+len-1.
2328          */
2329
2330         return cifs_user_writev(iocb, iov, nr_segs, pos);
2331 }
2332
2333 static ssize_t
2334 cifs_iovec_read(struct file *file, const struct iovec *iov,
2335                  unsigned long nr_segs, loff_t *poffset)
2336 {
2337         int rc;
2338         int xid;
2339         ssize_t total_read;
2340         unsigned int bytes_read = 0;
2341         size_t len, cur_len;
2342         int iov_offset = 0;
2343         struct cifs_sb_info *cifs_sb;
2344         struct cifs_tcon *pTcon;
2345         struct cifsFileInfo *open_file;
2346         struct smb_com_read_rsp *pSMBr;
2347         struct cifs_io_parms io_parms;
2348         char *read_data;
2349         unsigned int rsize;
2350         __u32 pid;
2351
2352         if (!nr_segs)
2353                 return 0;
2354
2355         len = iov_length(iov, nr_segs);
2356         if (!len)
2357                 return 0;
2358
2359         xid = GetXid();
2360         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2361
2362         /* FIXME: set up handlers for larger reads and/or convert to async */
2363         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2364
2365         open_file = file->private_data;
2366         pTcon = tlink_tcon(open_file->tlink);
2367
2368         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2369                 pid = open_file->pid;
2370         else
2371                 pid = current->tgid;
2372
2373         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2374                 cFYI(1, "attempting read on write only file instance");
2375
2376         for (total_read = 0; total_read < len; total_read += bytes_read) {
2377                 cur_len = min_t(const size_t, len - total_read, rsize);
2378                 rc = -EAGAIN;
2379                 read_data = NULL;
2380
2381                 while (rc == -EAGAIN) {
2382                         int buf_type = CIFS_NO_BUFFER;
2383                         if (open_file->invalidHandle) {
2384                                 rc = cifs_reopen_file(open_file, true);
2385                                 if (rc != 0)
2386                                         break;
2387                         }
2388                         io_parms.netfid = open_file->netfid;
2389                         io_parms.pid = pid;
2390                         io_parms.tcon = pTcon;
2391                         io_parms.offset = *poffset;
2392                         io_parms.length = cur_len;
2393                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2394                                          &read_data, &buf_type);
2395                         pSMBr = (struct smb_com_read_rsp *)read_data;
2396                         if (read_data) {
2397                                 char *data_offset = read_data + 4 +
2398                                                 le16_to_cpu(pSMBr->DataOffset);
2399                                 if (memcpy_toiovecend(iov, data_offset,
2400                                                       iov_offset, bytes_read))
2401                                         rc = -EFAULT;
2402                                 if (buf_type == CIFS_SMALL_BUFFER)
2403                                         cifs_small_buf_release(read_data);
2404                                 else if (buf_type == CIFS_LARGE_BUFFER)
2405                                         cifs_buf_release(read_data);
2406                                 read_data = NULL;
2407                                 iov_offset += bytes_read;
2408                         }
2409                 }
2410
2411                 if (rc || (bytes_read == 0)) {
2412                         if (total_read) {
2413                                 break;
2414                         } else {
2415                                 FreeXid(xid);
2416                                 return rc;
2417                         }
2418                 } else {
2419                         cifs_stats_bytes_read(pTcon, bytes_read);
2420                         *poffset += bytes_read;
2421                 }
2422         }
2423
2424         FreeXid(xid);
2425         return total_read;
2426 }
2427
2428 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2429                                unsigned long nr_segs, loff_t pos)
2430 {
2431         ssize_t read;
2432
2433         read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2434         if (read > 0)
2435                 iocb->ki_pos = pos;
2436
2437         return read;
2438 }
2439
2440 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2441                           unsigned long nr_segs, loff_t pos)
2442 {
2443         struct inode *inode;
2444
2445         inode = iocb->ki_filp->f_path.dentry->d_inode;
2446
2447         if (CIFS_I(inode)->clientCanCacheRead)
2448                 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2449
2450         /*
2451          * In strict cache mode we need to read from the server all the time
2452          * if we don't have level II oplock because the server can delay mtime
2453          * change - so we can't make a decision about inode invalidating.
2454          * And we can also fail with pagereading if there are mandatory locks
2455          * on pages affected by this read but not on the region from pos to
2456          * pos+len-1.
2457          */
2458
2459         return cifs_user_readv(iocb, iov, nr_segs, pos);
2460 }
2461
2462 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2463                          loff_t *poffset)
2464 {
2465         int rc = -EACCES;
2466         unsigned int bytes_read = 0;
2467         unsigned int total_read;
2468         unsigned int current_read_size;
2469         unsigned int rsize;
2470         struct cifs_sb_info *cifs_sb;
2471         struct cifs_tcon *pTcon;
2472         int xid;
2473         char *current_offset;
2474         struct cifsFileInfo *open_file;
2475         struct cifs_io_parms io_parms;
2476         int buf_type = CIFS_NO_BUFFER;
2477         __u32 pid;
2478
2479         xid = GetXid();
2480         cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2481
2482         /* FIXME: set up handlers for larger reads and/or convert to async */
2483         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2484
2485         if (file->private_data == NULL) {
2486                 rc = -EBADF;
2487                 FreeXid(xid);
2488                 return rc;
2489         }
2490         open_file = file->private_data;
2491         pTcon = tlink_tcon(open_file->tlink);
2492
2493         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2494                 pid = open_file->pid;
2495         else
2496                 pid = current->tgid;
2497
2498         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2499                 cFYI(1, "attempting read on write only file instance");
2500
2501         for (total_read = 0, current_offset = read_data;
2502              read_size > total_read;
2503              total_read += bytes_read, current_offset += bytes_read) {
2504                 current_read_size = min_t(uint, read_size - total_read, rsize);
2505
2506                 /* For windows me and 9x we do not want to request more
2507                 than it negotiated since it will refuse the read then */
2508                 if ((pTcon->ses) &&
2509                         !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2510                         current_read_size = min_t(uint, current_read_size,
2511                                         CIFSMaxBufSize);
2512                 }
2513                 rc = -EAGAIN;
2514                 while (rc == -EAGAIN) {
2515                         if (open_file->invalidHandle) {
2516                                 rc = cifs_reopen_file(open_file, true);
2517                                 if (rc != 0)
2518                                         break;
2519                         }
2520                         io_parms.netfid = open_file->netfid;
2521                         io_parms.pid = pid;
2522                         io_parms.tcon = pTcon;
2523                         io_parms.offset = *poffset;
2524                         io_parms.length = current_read_size;
2525                         rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2526                                          &current_offset, &buf_type);
2527                 }
2528                 if (rc || (bytes_read == 0)) {
2529                         if (total_read) {
2530                                 break;
2531                         } else {
2532                                 FreeXid(xid);
2533                                 return rc;
2534                         }
2535                 } else {
2536                         cifs_stats_bytes_read(pTcon, total_read);
2537                         *poffset += bytes_read;
2538                 }
2539         }
2540         FreeXid(xid);
2541         return total_read;
2542 }
2543
2544 /*
2545  * If the page is mmap'ed into a process' page tables, then we need to make
2546  * sure that it doesn't change while being written back.
2547  */
2548 static int
2549 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2550 {
2551         struct page *page = vmf->page;
2552
2553         lock_page(page);
2554         return VM_FAULT_LOCKED;
2555 }
2556
2557 static struct vm_operations_struct cifs_file_vm_ops = {
2558         .fault = filemap_fault,
2559         .page_mkwrite = cifs_page_mkwrite,
2560 };
2561
2562 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2563 {
2564         int rc, xid;
2565         struct inode *inode = file->f_path.dentry->d_inode;
2566
2567         xid = GetXid();
2568
2569         if (!CIFS_I(inode)->clientCanCacheRead) {
2570                 rc = cifs_invalidate_mapping(inode);
2571                 if (rc)
2572                         return rc;
2573         }
2574
2575         rc = generic_file_mmap(file, vma);
2576         if (rc == 0)
2577                 vma->vm_ops = &cifs_file_vm_ops;
2578         FreeXid(xid);
2579         return rc;
2580 }
2581
2582 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2583 {
2584         int rc, xid;
2585
2586         xid = GetXid();
2587         rc = cifs_revalidate_file(file);
2588         if (rc) {
2589                 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2590                 FreeXid(xid);
2591                 return rc;
2592         }
2593         rc = generic_file_mmap(file, vma);
2594         if (rc == 0)
2595                 vma->vm_ops = &cifs_file_vm_ops;
2596         FreeXid(xid);
2597         return rc;
2598 }
2599
2600 static int cifs_readpages(struct file *file, struct address_space *mapping,
2601         struct list_head *page_list, unsigned num_pages)
2602 {
2603         int rc;
2604         struct list_head tmplist;
2605         struct cifsFileInfo *open_file = file->private_data;
2606         struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2607         unsigned int rsize = cifs_sb->rsize;
2608         pid_t pid;
2609
2610         /*
2611          * Give up immediately if rsize is too small to read an entire page.
2612          * The VFS will fall back to readpage. We should never reach this
2613          * point however since we set ra_pages to 0 when the rsize is smaller
2614          * than a cache page.
2615          */
2616         if (unlikely(rsize < PAGE_CACHE_SIZE))
2617                 return 0;
2618
2619         /*
2620          * Reads as many pages as possible from fscache. Returns -ENOBUFS
2621          * immediately if the cookie is negative
2622          */
2623         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2624                                          &num_pages);
2625         if (rc == 0)
2626                 return rc;
2627
2628         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2629                 pid = open_file->pid;
2630         else
2631                 pid = current->tgid;
2632
2633         rc = 0;
2634         INIT_LIST_HEAD(&tmplist);
2635
2636         cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2637                 mapping, num_pages);
2638
2639         /*
2640          * Start with the page at end of list and move it to private
2641          * list. Do the same with any following pages until we hit
2642          * the rsize limit, hit an index discontinuity, or run out of
2643          * pages. Issue the async read and then start the loop again
2644          * until the list is empty.
2645          *
2646          * Note that list order is important. The page_list is in
2647          * the order of declining indexes. When we put the pages in
2648          * the rdata->pages, then we want them in increasing order.
2649          */
2650         while (!list_empty(page_list)) {
2651                 unsigned int bytes = PAGE_CACHE_SIZE;
2652                 unsigned int expected_index;
2653                 unsigned int nr_pages = 1;
2654                 loff_t offset;
2655                 struct page *page, *tpage;
2656                 struct cifs_readdata *rdata;
2657
2658                 page = list_entry(page_list->prev, struct page, lru);
2659
2660                 /*
2661                  * Lock the page and put it in the cache. Since no one else
2662                  * should have access to this page, we're safe to simply set
2663                  * PG_locked without checking it first.
2664                  */
2665                 __set_page_locked(page);
2666                 rc = add_to_page_cache_locked(page, mapping,
2667                                               page->index, GFP_KERNEL);
2668
2669                 /* give up if we can't stick it in the cache */
2670                 if (rc) {
2671                         __clear_page_locked(page);
2672                         break;
2673                 }
2674
2675                 /* move first page to the tmplist */
2676                 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2677                 list_move_tail(&page->lru, &tmplist);
2678
2679                 /* now try and add more pages onto the request */
2680                 expected_index = page->index + 1;
2681                 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2682                         /* discontinuity ? */
2683                         if (page->index != expected_index)
2684                                 break;
2685
2686                         /* would this page push the read over the rsize? */
2687                         if (bytes + PAGE_CACHE_SIZE > rsize)
2688                                 break;
2689
2690                         __set_page_locked(page);
2691                         if (add_to_page_cache_locked(page, mapping,
2692                                                 page->index, GFP_KERNEL)) {
2693                                 __clear_page_locked(page);
2694                                 break;
2695                         }
2696                         list_move_tail(&page->lru, &tmplist);
2697                         bytes += PAGE_CACHE_SIZE;
2698                         expected_index++;
2699                         nr_pages++;
2700                 }
2701
2702                 rdata = cifs_readdata_alloc(nr_pages);
2703                 if (!rdata) {
2704                         /* best to give up if we're out of mem */
2705                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2706                                 list_del(&page->lru);
2707                                 lru_cache_add_file(page);
2708                                 unlock_page(page);
2709                                 page_cache_release(page);
2710                         }
2711                         rc = -ENOMEM;
2712                         break;
2713                 }
2714
2715                 spin_lock(&cifs_file_list_lock);
2716                 cifsFileInfo_get(open_file);
2717                 spin_unlock(&cifs_file_list_lock);
2718                 rdata->cfile = open_file;
2719                 rdata->mapping = mapping;
2720                 rdata->offset = offset;
2721                 rdata->bytes = bytes;
2722                 rdata->pid = pid;
2723                 list_splice_init(&tmplist, &rdata->pages);
2724
2725                 do {
2726                         if (open_file->invalidHandle) {
2727                                 rc = cifs_reopen_file(open_file, true);
2728                                 if (rc != 0)
2729                                         continue;
2730                         }
2731                         rc = cifs_async_readv(rdata);
2732                 } while (rc == -EAGAIN);
2733
2734                 if (rc != 0) {
2735                         list_for_each_entry_safe(page, tpage, &rdata->pages,
2736                                                  lru) {
2737                                 list_del(&page->lru);
2738                                 lru_cache_add_file(page);
2739                                 unlock_page(page);
2740                                 page_cache_release(page);
2741                         }
2742                         cifs_readdata_free(rdata);
2743                         break;
2744                 }
2745         }
2746
2747         return rc;
2748 }
2749
2750 static int cifs_readpage_worker(struct file *file, struct page *page,
2751         loff_t *poffset)
2752 {
2753         char *read_data;
2754         int rc;
2755
2756         /* Is the page cached? */
2757         rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2758         if (rc == 0)
2759                 goto read_complete;
2760
2761         page_cache_get(page);
2762         read_data = kmap(page);
2763         /* for reads over a certain size could initiate async read ahead */
2764
2765         rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2766
2767         if (rc < 0)
2768                 goto io_error;
2769         else
2770                 cFYI(1, "Bytes read %d", rc);
2771
2772         file->f_path.dentry->d_inode->i_atime =
2773                 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2774
2775         if (PAGE_CACHE_SIZE > rc)
2776                 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2777
2778         flush_dcache_page(page);
2779         SetPageUptodate(page);
2780
2781         /* send this page to the cache */
2782         cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2783
2784         rc = 0;
2785
2786 io_error:
2787         kunmap(page);
2788         page_cache_release(page);
2789
2790 read_complete:
2791         return rc;
2792 }
2793
2794 static int cifs_readpage(struct file *file, struct page *page)
2795 {
2796         loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2797         int rc = -EACCES;
2798         int xid;
2799
2800         xid = GetXid();
2801
2802         if (file->private_data == NULL) {
2803                 rc = -EBADF;
2804                 FreeXid(xid);
2805                 return rc;
2806         }
2807
2808         cFYI(1, "readpage %p at offset %d 0x%x\n",
2809                  page, (int)offset, (int)offset);
2810
2811         rc = cifs_readpage_worker(file, page, &offset);
2812
2813         unlock_page(page);
2814
2815         FreeXid(xid);
2816         return rc;
2817 }
2818
2819 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2820 {
2821         struct cifsFileInfo *open_file;
2822
2823         spin_lock(&cifs_file_list_lock);
2824         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2825                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2826                         spin_unlock(&cifs_file_list_lock);
2827                         return 1;
2828                 }
2829         }
2830         spin_unlock(&cifs_file_list_lock);
2831         return 0;
2832 }
2833
2834 /* We do not want to update the file size from server for inodes
2835    open for write - to avoid races with writepage extending
2836    the file - in the future we could consider allowing
2837    refreshing the inode only on increases in the file size
2838    but this is tricky to do without racing with writebehind
2839    page caching in the current Linux kernel design */
2840 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2841 {
2842         if (!cifsInode)
2843                 return true;
2844
2845         if (is_inode_writable(cifsInode)) {
2846                 /* This inode is open for write at least once */
2847                 struct cifs_sb_info *cifs_sb;
2848
2849                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2850                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2851                         /* since no page cache to corrupt on directio
2852                         we can change size safely */
2853                         return true;
2854                 }
2855
2856                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2857                         return true;
2858
2859                 return false;
2860         } else
2861                 return true;
2862 }
2863
2864 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2865                         loff_t pos, unsigned len, unsigned flags,
2866                         struct page **pagep, void **fsdata)
2867 {
2868         pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2869         loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2870         loff_t page_start = pos & PAGE_MASK;
2871         loff_t i_size;
2872         struct page *page;
2873         int rc = 0;
2874
2875         cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2876
2877         page = grab_cache_page_write_begin(mapping, index, flags);
2878         if (!page) {
2879                 rc = -ENOMEM;
2880                 goto out;
2881         }
2882
2883         if (PageUptodate(page))
2884                 goto out;
2885
2886         /*
2887          * If we write a full page it will be up to date, no need to read from
2888          * the server. If the write is short, we'll end up doing a sync write
2889          * instead.
2890          */
2891         if (len == PAGE_CACHE_SIZE)
2892                 goto out;
2893
2894         /*
2895          * optimize away the read when we have an oplock, and we're not
2896          * expecting to use any of the data we'd be reading in. That
2897          * is, when the page lies beyond the EOF, or straddles the EOF
2898          * and the write will cover all of the existing data.
2899          */
2900         if (CIFS_I(mapping->host)->clientCanCacheRead) {
2901                 i_size = i_size_read(mapping->host);
2902                 if (page_start >= i_size ||
2903                     (offset == 0 && (pos + len) >= i_size)) {
2904                         zero_user_segments(page, 0, offset,
2905                                            offset + len,
2906                                            PAGE_CACHE_SIZE);
2907                         /*
2908                          * PageChecked means that the parts of the page
2909                          * to which we're not writing are considered up
2910                          * to date. Once the data is copied to the
2911                          * page, it can be set uptodate.
2912                          */
2913                         SetPageChecked(page);
2914                         goto out;
2915                 }
2916         }
2917
2918         if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2919                 /*
2920                  * might as well read a page, it is fast enough. If we get
2921                  * an error, we don't need to return it. cifs_write_end will
2922                  * do a sync write instead since PG_uptodate isn't set.
2923                  */
2924                 cifs_readpage_worker(file, page, &page_start);
2925         } else {
2926                 /* we could try using another file handle if there is one -
2927                    but how would we lock it to prevent close of that handle
2928                    racing with this read? In any case
2929                    this will be written out by write_end so is fine */
2930         }
2931 out:
2932         *pagep = page;
2933         return rc;
2934 }
2935
2936 static int cifs_release_page(struct page *page, gfp_t gfp)
2937 {
2938         if (PagePrivate(page))
2939                 return 0;
2940
2941         return cifs_fscache_release_page(page, gfp);
2942 }
2943
2944 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2945 {
2946         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2947
2948         if (offset == 0)
2949                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2950 }
2951
2952 static int cifs_launder_page(struct page *page)
2953 {
2954         int rc = 0;
2955         loff_t range_start = page_offset(page);
2956         loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2957         struct writeback_control wbc = {
2958                 .sync_mode = WB_SYNC_ALL,
2959                 .nr_to_write = 0,
2960                 .range_start = range_start,
2961                 .range_end = range_end,
2962         };
2963
2964         cFYI(1, "Launder page: %p", page);
2965
2966         if (clear_page_dirty_for_io(page))
2967                 rc = cifs_writepage_locked(page, &wbc);
2968
2969         cifs_fscache_invalidate_page(page, page->mapping->host);
2970         return rc;
2971 }
2972
2973 void cifs_oplock_break(struct work_struct *work)
2974 {
2975         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2976                                                   oplock_break);
2977         struct inode *inode = cfile->dentry->d_inode;
2978         struct cifsInodeInfo *cinode = CIFS_I(inode);
2979         int rc = 0;
2980
2981         if (inode && S_ISREG(inode->i_mode)) {
2982                 if (cinode->clientCanCacheRead)
2983                         break_lease(inode, O_RDONLY);
2984                 else
2985                         break_lease(inode, O_WRONLY);
2986                 rc = filemap_fdatawrite(inode->i_mapping);
2987                 if (cinode->clientCanCacheRead == 0) {
2988                         rc = filemap_fdatawait(inode->i_mapping);
2989                         mapping_set_error(inode->i_mapping, rc);
2990                         invalidate_remote_inode(inode);
2991                 }
2992                 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2993         }
2994
2995         rc = cifs_push_locks(cfile);
2996         if (rc)
2997                 cERROR(1, "Push locks rc = %d", rc);
2998
2999         /*
3000          * releasing stale oplock after recent reconnect of smb session using
3001          * a now incorrect file handle is not a data integrity issue but do
3002          * not bother sending an oplock release if session to server still is
3003          * disconnected since oplock already released by the server
3004          */
3005         if (!cfile->oplock_break_cancelled) {
3006                 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
3007                                  current->tgid, 0, 0, 0, 0,
3008                                  LOCKING_ANDX_OPLOCK_RELEASE, false,
3009                                  cinode->clientCanCacheRead ? 1 : 0);
3010                 cFYI(1, "Oplock release rc = %d", rc);
3011         }
3012 }
3013
3014 const struct address_space_operations cifs_addr_ops = {
3015         .readpage = cifs_readpage,
3016         .readpages = cifs_readpages,
3017         .writepage = cifs_writepage,
3018         .writepages = cifs_writepages,
3019         .write_begin = cifs_write_begin,
3020         .write_end = cifs_write_end,
3021         .set_page_dirty = __set_page_dirty_nobuffers,
3022         .releasepage = cifs_release_page,
3023         .invalidatepage = cifs_invalidate_page,
3024         .launder_page = cifs_launder_page,
3025 };
3026
3027 /*
3028  * cifs_readpages requires the server to support a buffer large enough to
3029  * contain the header plus one complete page of data.  Otherwise, we need
3030  * to leave cifs_readpages out of the address space operations.
3031  */
3032 const struct address_space_operations cifs_addr_ops_smallbuf = {
3033         .readpage = cifs_readpage,
3034         .writepage = cifs_writepage,
3035         .writepages = cifs_writepages,
3036         .write_begin = cifs_write_begin,
3037         .write_end = cifs_write_end,
3038         .set_page_dirty = __set_page_dirty_nobuffers,
3039         .releasepage = cifs_release_page,
3040         .invalidatepage = cifs_invalidate_page,
3041         .launder_page = cifs_launder_page,
3042 };