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
  47 static inline int cifs_convert_flags(unsigned int flags)
  48 {
  49         if ((flags & O_ACCMODE) == O_RDONLY)
  50                 return GENERIC_READ;
  51         else if ((flags & O_ACCMODE) == O_WRONLY)
  52                 return GENERIC_WRITE;
  53         else if ((flags & O_ACCMODE) == O_RDWR) {
  54                 /* GENERIC_ALL is too much permission to request
  55                    can cause unnecessary access denied on create */
  56                 /* return GENERIC_ALL; */
  57                 return (GENERIC_READ | GENERIC_WRITE);
  58         }
  59
  60         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
  61                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
  62                 FILE_READ_DATA);
  63 }
  64
  65 static u32 cifs_posix_convert_flags(unsigned int flags)
  66 {
  67         u32 posix_flags = 0;
  68
  69         if ((flags & O_ACCMODE) == O_RDONLY)
  70                 posix_flags = SMB_O_RDONLY;
  71         else if ((flags & O_ACCMODE) == O_WRONLY)
  72                 posix_flags = SMB_O_WRONLY;
  73         else if ((flags & O_ACCMODE) == O_RDWR)
  74                 posix_flags = SMB_O_RDWR;
  75
  76         if (flags & O_CREAT) {
  77                 posix_flags |= SMB_O_CREAT;
  78                 if (flags & O_EXCL)
  79                         posix_flags |= SMB_O_EXCL;
  80         } else if (flags & O_EXCL)
  81                 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
  82                          current->comm, current->tgid);
  83
  84         if (flags & O_TRUNC)
  85                 posix_flags |= SMB_O_TRUNC;
  86         /* be safe and imply O_SYNC for O_DSYNC */
  87         if (flags & O_DSYNC)
  88                 posix_flags |= SMB_O_SYNC;
  89         if (flags & O_DIRECTORY)
  90                 posix_flags |= SMB_O_DIRECTORY;
  91         if (flags & O_NOFOLLOW)
  92                 posix_flags |= SMB_O_NOFOLLOW;
  93         if (flags & O_DIRECT)
  94                 posix_flags |= SMB_O_DIRECT;
  95
  96         return posix_flags;
  97 }
  98
  99 static inline int cifs_get_disposition(unsigned int flags)
 100 {
 101         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 102                 return FILE_CREATE;
 103         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 104                 return FILE_OVERWRITE_IF;
 105         else if ((flags & O_CREAT) == O_CREAT)
 106                 return FILE_OPEN_IF;
 107         else if ((flags & O_TRUNC) == O_TRUNC)
 108                 return FILE_OVERWRITE;
 109         else
 110                 return FILE_OPEN;
 111 }
 112
 113 int cifs_posix_open(char *full_path, struct inode **pinode,
 114                         struct super_block *sb, int mode, unsigned int f_flags,
 115                         __u32 *poplock, __u16 *pnetfid, unsigned int xid)
 116 {
 117         int rc;
 118         FILE_UNIX_BASIC_INFO *presp_data;
 119         __u32 posix_flags = 0;
 120         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 121         struct cifs_fattr fattr;
 122         struct tcon_link *tlink;
 123         struct cifs_tcon *tcon;
 124
 125         cifs_dbg(FYI, "posix open %s\n", full_path);
 126
 127         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 128         if (presp_data == NULL)
 129                 return -ENOMEM;
 130
 131         tlink = cifs_sb_tlink(cifs_sb);
 132         if (IS_ERR(tlink)) {
 133                 rc = PTR_ERR(tlink);
 134                 goto posix_open_ret;
 135         }
 136
 137         tcon = tlink_tcon(tlink);
 138         mode &= ~current_umask();
 139
 140         posix_flags = cifs_posix_convert_flags(f_flags);
 141         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 142                              poplock, full_path, cifs_sb->local_nls,
 143                              cifs_remap(cifs_sb));
 144         cifs_put_tlink(tlink);
 145
 146         if (rc)
 147                 goto posix_open_ret;
 148
 149         if (presp_data->Type == cpu_to_le32(-1))
 150                 goto posix_open_ret; /* open ok, caller does qpathinfo */
 151
 152         if (!pinode)
 153                 goto posix_open_ret; /* caller does not need info */
 154
 155         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 156
 157         /* get new inode and set it up */
 158         if (*pinode == NULL) {
 159                 cifs_fill_uniqueid(sb, &fattr);
 160                 *pinode = cifs_iget(sb, &fattr);
 161                 if (!*pinode) {
 162                         rc = -ENOMEM;
 163                         goto posix_open_ret;
 164                 }
 165         } else {
 166                 cifs_fattr_to_inode(*pinode, &fattr);
 167         }
 168
 169 posix_open_ret:
 170         kfree(presp_data);
 171         return rc;
 172 }
 173
 174 static int
 175 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
 176              struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
 177              struct cifs_fid *fid, unsigned int xid)
 178 {
 179         int rc;
 180         int desired_access;
 181         int disposition;
 182         int create_options = CREATE_NOT_DIR;
 183         FILE_ALL_INFO *buf;
 184         struct TCP_Server_Info *server = tcon->ses->server;
 185         struct cifs_open_parms oparms;
 186
 187         if (!server->ops->open)
 188                 return -ENOSYS;
 189
 190         desired_access = cifs_convert_flags(f_flags);
 191
 192 /*********************************************************************
 193  *  open flag mapping table:
 194  *
 195  *      POSIX Flag            CIFS Disposition
 196  *      ----------            ----------------
 197  *      O_CREAT               FILE_OPEN_IF
 198  *      O_CREAT | O_EXCL      FILE_CREATE
 199  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 200  *      O_TRUNC               FILE_OVERWRITE
 201  *      none of the above     FILE_OPEN
 202  *
 203  *      Note that there is not a direct match between disposition
 204  *      FILE_SUPERSEDE (ie create whether or not file exists although
 205  *      O_CREAT | O_TRUNC is similar but truncates the existing
 206  *      file rather than creating a new file as FILE_SUPERSEDE does
 207  *      (which uses the attributes / metadata passed in on open call)
 208  *?
 209  *?  O_SYNC is a reasonable match to CIFS writethrough flag
 210  *?  and the read write flags match reasonably.  O_LARGEFILE
 211  *?  is irrelevant because largefile support is always used
 212  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 213  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 214  *********************************************************************/
 215
 216         disposition = cifs_get_disposition(f_flags);
 217
 218         /* BB pass O_SYNC flag through on file attributes .. BB */
 219
 220         buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
 221         if (!buf)
 222                 return -ENOMEM;
 223
 224         if (backup_cred(cifs_sb))
 225                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 226
 227         oparms.tcon = tcon;
 228         oparms.cifs_sb = cifs_sb;
 229         oparms.desired_access = desired_access;
 230         oparms.create_options = create_options;
 231         oparms.disposition = disposition;
 232         oparms.path = full_path;
 233         oparms.fid = fid;
 234         oparms.reconnect = false;
 235
 236         rc = server->ops->open(xid, &oparms, oplock, buf);
 237
 238         if (rc)
 239                 goto out;
 240
 241         if (tcon->unix_ext)
 242                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 243                                               xid);
 244         else
 245                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 246                                          xid, fid);
 247
 248 out:
 249         kfree(buf);
 250         return rc;
 251 }
 252
 253 static bool
 254 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
 255 {
 256         struct cifs_fid_locks *cur;
 257         bool has_locks = false;
 258
 259         down_read(&cinode->lock_sem);
 260         list_for_each_entry(cur, &cinode->llist, llist) {
 261                 if (!list_empty(&cur->locks)) {
 262                         has_locks = true;
 263                         break;
 264                 }
 265         }
 266         up_read(&cinode->lock_sem);
 267         return has_locks;
 268 }
 269
 270 struct cifsFileInfo *
 271 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
 272                   struct tcon_link *tlink, __u32 oplock)
 273 {
 274         struct dentry *dentry = file_dentry(file);
 275         struct inode *inode = d_inode(dentry);
 276         struct cifsInodeInfo *cinode = CIFS_I(inode);
 277         struct cifsFileInfo *cfile;
 278         struct cifs_fid_locks *fdlocks;
 279         struct cifs_tcon *tcon = tlink_tcon(tlink);
 280         struct TCP_Server_Info *server = tcon->ses->server;
 281
 282         cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 283         if (cfile == NULL)
 284                 return cfile;
 285
 286         fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
 287         if (!fdlocks) {
 288                 kfree(cfile);
 289                 return NULL;
 290         }
 291
 292         INIT_LIST_HEAD(&fdlocks->locks);
 293         fdlocks->cfile = cfile;
 294         cfile->llist = fdlocks;
 295         down_write(&cinode->lock_sem);
 296         list_add(&fdlocks->llist, &cinode->llist);
 297         up_write(&cinode->lock_sem);
 298
 299         cfile->count = 1;
 300         cfile->pid = current->tgid;
 301         cfile->uid = current_fsuid();
 302         cfile->dentry = dget(dentry);
 303         cfile->f_flags = file->f_flags;
 304         cfile->invalidHandle = false;
 305         cfile->tlink = cifs_get_tlink(tlink);
 306         INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
 307         mutex_init(&cfile->fh_mutex);
 308
 309         cifs_sb_active(inode->i_sb);
 310
 311         /*
 312          * If the server returned a read oplock and we have mandatory brlocks,
 313          * set oplock level to None.
 314          */
 315         if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
 316                 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
 317                 oplock = 0;
 318         }
 319
 320         spin_lock(&cifs_file_list_lock);
 321         if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
 322                 oplock = fid->pending_open->oplock;
 323         list_del(&fid->pending_open->olist);
 324
 325         fid->purge_cache = false;
 326         server->ops->set_fid(cfile, fid, oplock);
 327
 328         list_add(&cfile->tlist, &tcon->openFileList);
 329         /* if readable file instance put first in list*/
 330         if (file->f_mode & FMODE_READ)
 331                 list_add(&cfile->flist, &cinode->openFileList);
 332         else
 333                 list_add_tail(&cfile->flist, &cinode->openFileList);
 334         spin_unlock(&cifs_file_list_lock);
 335
 336         if (fid->purge_cache)
 337                 cifs_zap_mapping(inode);
 338
 339         file->private_data = cfile;
 340         return cfile;
 341 }
 342
 343 struct cifsFileInfo *
 344 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
 345 {
 346         spin_lock(&cifs_file_list_lock);
 347         cifsFileInfo_get_locked(cifs_file);
 348         spin_unlock(&cifs_file_list_lock);
 349         return cifs_file;
 350 }
 351
 352 /*
 353  * Release a reference on the file private data. This may involve closing
 354  * the filehandle out on the server. Must be called without holding
 355  * cifs_file_list_lock.
 356  */
 357 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 358 {
 359         struct inode *inode = d_inode(cifs_file->dentry);
 360         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 361         struct TCP_Server_Info *server = tcon->ses->server;
 362         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 363         struct super_block *sb = inode->i_sb;
 364         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 365         struct cifsLockInfo *li, *tmp;
 366         struct cifs_fid fid;
 367         struct cifs_pending_open open;
 368         bool oplock_break_cancelled;
 369
 370         spin_lock(&cifs_file_list_lock);
 371         if (--cifs_file->count > 0) {
 372                 spin_unlock(&cifs_file_list_lock);
 373                 return;
 374         }
 375
 376         if (server->ops->get_lease_key)
 377                 server->ops->get_lease_key(inode, &fid);
 378
 379         /* store open in pending opens to make sure we don't miss lease break */
 380         cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
 381
 382         /* remove it from the lists */
 383         list_del(&cifs_file->flist);
 384         list_del(&cifs_file->tlist);
 385
 386         if (list_empty(&cifsi->openFileList)) {
 387                 cifs_dbg(FYI, "closing last open instance for inode %p\n",
 388                          d_inode(cifs_file->dentry));
 389                 /*
 390                  * In strict cache mode we need invalidate mapping on the last
 391                  * close  because it may cause a error when we open this file
 392                  * again and get at least level II oplock.
 393                  */
 394                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 395                         set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
 396                 cifs_set_oplock_level(cifsi, 0);
 397         }
 398         spin_unlock(&cifs_file_list_lock);
 399
 400         oplock_break_cancelled = cancel_work_sync(&cifs_file->oplock_break);
 401
 402         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 403                 struct TCP_Server_Info *server = tcon->ses->server;
 404                 unsigned int xid;
 405
 406                 xid = get_xid();
 407                 if (server->ops->close)
 408                         server->ops->close(xid, tcon, &cifs_file->fid);
 409                 _free_xid(xid);
 410         }
 411
 412         if (oplock_break_cancelled)
 413                 cifs_done_oplock_break(cifsi);
 414
 415         cifs_del_pending_open(&open);
 416
 417         /*
 418          * Delete any outstanding lock records. We'll lose them when the file
 419          * is closed anyway.
 420          */
 421         down_write(&cifsi->lock_sem);
 422         list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
 423                 list_del(&li->llist);
 424                 cifs_del_lock_waiters(li);
 425                 kfree(li);
 426         }
 427         list_del(&cifs_file->llist->llist);
 428         kfree(cifs_file->llist);
 429         up_write(&cifsi->lock_sem);
 430
 431         cifs_put_tlink(cifs_file->tlink);
 432         dput(cifs_file->dentry);
 433         cifs_sb_deactive(sb);
 434         kfree(cifs_file);
 435 }
 436
 437 int cifs_open(struct inode *inode, struct file *file)
 438
 439 {
 440         int rc = -EACCES;
 441         unsigned int xid;
 442         __u32 oplock;
 443         struct cifs_sb_info *cifs_sb;
 444         struct TCP_Server_Info *server;
 445         struct cifs_tcon *tcon;
 446         struct tcon_link *tlink;
 447         struct cifsFileInfo *cfile = NULL;
 448         char *full_path = NULL;
 449         bool posix_open_ok = false;
 450         struct cifs_fid fid;
 451         struct cifs_pending_open open;
 452
 453         xid = get_xid();
 454
 455         cifs_sb = CIFS_SB(inode->i_sb);
 456         tlink = cifs_sb_tlink(cifs_sb);
 457         if (IS_ERR(tlink)) {
 458                 free_xid(xid);
 459                 return PTR_ERR(tlink);
 460         }
 461         tcon = tlink_tcon(tlink);
 462         server = tcon->ses->server;
 463
 464         full_path = build_path_from_dentry(file_dentry(file));
 465         if (full_path == NULL) {
 466                 rc = -ENOMEM;
 467                 goto out;
 468         }
 469
 470         cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
 471                  inode, file->f_flags, full_path);
 472
 473         if (file->f_flags & O_DIRECT &&
 474             cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
 475                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 476                         file->f_op = &cifs_file_direct_nobrl_ops;
 477                 else
 478                         file->f_op = &cifs_file_direct_ops;
 479         }
 480
 481         if (server->oplocks)
 482                 oplock = REQ_OPLOCK;
 483         else
 484                 oplock = 0;
 485
 486         if (!tcon->broken_posix_open && tcon->unix_ext &&
 487             cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 488                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 489                 /* can not refresh inode info since size could be stale */
 490                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
 491                                 cifs_sb->mnt_file_mode /* ignored */,
 492                                 file->f_flags, &oplock, &fid.netfid, xid);
 493                 if (rc == 0) {
 494                         cifs_dbg(FYI, "posix open succeeded\n");
 495                         posix_open_ok = true;
 496                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
 497                         if (tcon->ses->serverNOS)
 498                                 cifs_dbg(VFS, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
 499                                          tcon->ses->serverName,
 500                                          tcon->ses->serverNOS);
 501                         tcon->broken_posix_open = true;
 502                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
 503                          (rc != -EOPNOTSUPP)) /* path not found or net err */
 504                         goto out;
 505                 /*
 506                  * Else fallthrough to retry open the old way on network i/o
 507                  * or DFS errors.
 508                  */
 509         }
 510
 511         if (server->ops->get_lease_key)
 512                 server->ops->get_lease_key(inode, &fid);
 513
 514         cifs_add_pending_open(&fid, tlink, &open);
 515
 516         if (!posix_open_ok) {
 517                 if (server->ops->get_lease_key)
 518                         server->ops->get_lease_key(inode, &fid);
 519
 520                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
 521                                   file->f_flags, &oplock, &fid, xid);
 522                 if (rc) {
 523                         cifs_del_pending_open(&open);
 524                         goto out;
 525                 }
 526         }
 527
 528         cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
 529         if (cfile == NULL) {
 530                 if (server->ops->close)
 531                         server->ops->close(xid, tcon, &fid);
 532                 cifs_del_pending_open(&open);
 533                 rc = -ENOMEM;
 534                 goto out;
 535         }
 536
 537         cifs_fscache_set_inode_cookie(inode, file);
 538
 539         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
 540                 /*
 541                  * Time to set mode which we can not set earlier due to
 542                  * problems creating new read-only files.
 543                  */
 544                 struct cifs_unix_set_info_args args = {
 545                         .mode   = inode->i_mode,
 546                         .uid    = INVALID_UID, /* no change */
 547                         .gid    = INVALID_GID, /* no change */
 548                         .ctime  = NO_CHANGE_64,
 549                         .atime  = NO_CHANGE_64,
 550                         .mtime  = NO_CHANGE_64,
 551                         .device = 0,
 552                 };
 553                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
 554                                        cfile->pid);
 555         }
 556
 557 out:
 558         kfree(full_path);
 559         free_xid(xid);
 560         cifs_put_tlink(tlink);
 561         return rc;
 562 }
 563
 564 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
 565
 566 /*
 567  * Try to reacquire byte range locks that were released when session
 568  * to server was lost.
 569  */
 570 static int
 571 cifs_relock_file(struct cifsFileInfo *cfile)
 572 {
 573         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
 574         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 575         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
 576         int rc = 0;
 577
 578         down_read(&cinode->lock_sem);
 579         if (cinode->can_cache_brlcks) {
 580                 /* can cache locks - no need to relock */
 581                 up_read(&cinode->lock_sem);
 582                 return rc;
 583         }
 584
 585         if (cap_unix(tcon->ses) &&
 586             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
 587             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
 588                 rc = cifs_push_posix_locks(cfile);
 589         else
 590                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
 591
 592         up_read(&cinode->lock_sem);
 593         return rc;
 594 }
 595
 596 static int
 597 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
 598 {
 599         int rc = -EACCES;
 600         unsigned int xid;
 601         __u32 oplock;
 602         struct cifs_sb_info *cifs_sb;
 603         struct cifs_tcon *tcon;
 604         struct TCP_Server_Info *server;
 605         struct cifsInodeInfo *cinode;
 606         struct inode *inode;
 607         char *full_path = NULL;
 608         int desired_access;
 609         int disposition = FILE_OPEN;
 610         int create_options = CREATE_NOT_DIR;
 611         struct cifs_open_parms oparms;
 612
 613         xid = get_xid();
 614         mutex_lock(&cfile->fh_mutex);
 615         if (!cfile->invalidHandle) {
 616                 mutex_unlock(&cfile->fh_mutex);
 617                 rc = 0;
 618                 free_xid(xid);
 619                 return rc;
 620         }
 621
 622         inode = d_inode(cfile->dentry);
 623         cifs_sb = CIFS_SB(inode->i_sb);
 624         tcon = tlink_tcon(cfile->tlink);
 625         server = tcon->ses->server;
 626
 627         /*
 628          * Can not grab rename sem here because various ops, including those
 629          * that already have the rename sem can end up causing writepage to get
 630          * called and if the server was down that means we end up here, and we
 631          * can never tell if the caller already has the rename_sem.
 632          */
 633         full_path = build_path_from_dentry(cfile->dentry);
 634         if (full_path == NULL) {
 635                 rc = -ENOMEM;
 636                 mutex_unlock(&cfile->fh_mutex);
 637                 free_xid(xid);
 638                 return rc;
 639         }
 640
 641         cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
 642                  inode, cfile->f_flags, full_path);
 643
 644         if (tcon->ses->server->oplocks)
 645                 oplock = REQ_OPLOCK;
 646         else
 647                 oplock = 0;
 648
 649         if (tcon->unix_ext && cap_unix(tcon->ses) &&
 650             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
 651                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
 652                 /*
 653                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
 654                  * original open. Must mask them off for a reopen.
 655                  */
 656                 unsigned int oflags = cfile->f_flags &
 657                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
 658
 659                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
 660                                      cifs_sb->mnt_file_mode /* ignored */,
 661                                      oflags, &oplock, &cfile->fid.netfid, xid);
 662                 if (rc == 0) {
 663                         cifs_dbg(FYI, "posix reopen succeeded\n");
 664                         oparms.reconnect = true;
 665                         goto reopen_success;
 666                 }
 667                 /*
 668                  * fallthrough to retry open the old way on errors, especially
 669                  * in the reconnect path it is important to retry hard
 670                  */
 671         }
 672
 673         desired_access = cifs_convert_flags(cfile->f_flags);
 674
 675         if (backup_cred(cifs_sb))
 676                 create_options |= CREATE_OPEN_BACKUP_INTENT;
 677
 678         if (server->ops->get_lease_key)
 679                 server->ops->get_lease_key(inode, &cfile->fid);
 680
 681         oparms.tcon = tcon;
 682         oparms.cifs_sb = cifs_sb;
 683         oparms.desired_access = desired_access;
 684         oparms.create_options = create_options;
 685         oparms.disposition = disposition;
 686         oparms.path = full_path;
 687         oparms.fid = &cfile->fid;
 688         oparms.reconnect = true;
 689
 690         /*
 691          * Can not refresh inode by passing in file_info buf to be returned by
 692          * ops->open and then calling get_inode_info with returned buf since
 693          * file might have write behind data that needs to be flushed and server
 694          * version of file size can be stale. If we knew for sure that inode was
 695          * not dirty locally we could do this.
 696          */
 697         rc = server->ops->open(xid, &oparms, &oplock, NULL);
 698         if (rc == -ENOENT && oparms.reconnect == false) {
 699                 /* durable handle timeout is expired - open the file again */
 700                 rc = server->ops->open(xid, &oparms, &oplock, NULL);
 701                 /* indicate that we need to relock the file */
 702                 oparms.reconnect = true;
 703         }
 704
 705         if (rc) {
 706                 mutex_unlock(&cfile->fh_mutex);
 707                 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
 708                 cifs_dbg(FYI, "oplock: %d\n", oplock);
 709                 goto reopen_error_exit;
 710         }
 711
 712 reopen_success:
 713         cfile->invalidHandle = false;
 714         mutex_unlock(&cfile->fh_mutex);
 715         cinode = CIFS_I(inode);
 716
 717         if (can_flush) {
 718                 rc = filemap_write_and_wait(inode->i_mapping);
 719                 mapping_set_error(inode->i_mapping, rc);
 720
 721                 if (tcon->unix_ext)
 722                         rc = cifs_get_inode_info_unix(&inode, full_path,
 723                                                       inode->i_sb, xid);
 724                 else
 725                         rc = cifs_get_inode_info(&inode, full_path, NULL,
 726                                                  inode->i_sb, xid, NULL);
 727         }
 728         /*
 729          * Else we are writing out data to server already and could deadlock if
 730          * we tried to flush data, and since we do not know if we have data that
 731          * would invalidate the current end of file on the server we can not go
 732          * to the server to get the new inode info.
 733          */
 734
 735         server->ops->set_fid(cfile, &cfile->fid, oplock);
 736         if (oparms.reconnect)
 737                 cifs_relock_file(cfile);
 738
 739 reopen_error_exit:
 740         kfree(full_path);
 741         free_xid(xid);
 742         return rc;
 743 }
 744
 745 int cifs_close(struct inode *inode, struct file *file)
 746 {
 747         if (file->private_data != NULL) {
 748                 cifsFileInfo_put(file->private_data);
 749                 file->private_data = NULL;
 750         }
 751
 752         /* return code from the ->release op is always ignored */
 753         return 0;
 754 }
 755
 756 int cifs_closedir(struct inode *inode, struct file *file)
 757 {
 758         int rc = 0;
 759         unsigned int xid;
 760         struct cifsFileInfo *cfile = file->private_data;
 761         struct cifs_tcon *tcon;
 762         struct TCP_Server_Info *server;
 763         char *buf;
 764
 765         cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
 766
 767         if (cfile == NULL)
 768                 return rc;
 769
 770         xid = get_xid();
 771         tcon = tlink_tcon(cfile->tlink);
 772         server = tcon->ses->server;
 773
 774         cifs_dbg(FYI, "Freeing private data in close dir\n");
 775         spin_lock(&cifs_file_list_lock);
 776         if (server->ops->dir_needs_close(cfile)) {
 777                 cfile->invalidHandle = true;
 778                 spin_unlock(&cifs_file_list_lock);
 779                 if (server->ops->close_dir)
 780                         rc = server->ops->close_dir(xid, tcon, &cfile->fid);
 781                 else
 782                         rc = -ENOSYS;
 783                 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
 784                 /* not much we can do if it fails anyway, ignore rc */
 785                 rc = 0;
 786         } else
 787                 spin_unlock(&cifs_file_list_lock);
 788
 789         buf = cfile->srch_inf.ntwrk_buf_start;
 790         if (buf) {
 791                 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
 792                 cfile->srch_inf.ntwrk_buf_start = NULL;
 793                 if (cfile->srch_inf.smallBuf)
 794                         cifs_small_buf_release(buf);
 795                 else
 796                         cifs_buf_release(buf);
 797         }
 798
 799         cifs_put_tlink(cfile->tlink);
 800         kfree(file->private_data);
 801         file->private_data = NULL;
 802         /* BB can we lock the filestruct while this is going on? */
 803         free_xid(xid);
 804         return rc;
 805 }
 806
 807 static struct cifsLockInfo *
 808 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
 809 {
 810         struct cifsLockInfo *lock =
 811                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
 812         if (!lock)
 813                 return lock;
 814         lock->offset = offset;
 815         lock->length = length;
 816         lock->type = type;
 817         lock->pid = current->tgid;
 818         INIT_LIST_HEAD(&lock->blist);
 819         init_waitqueue_head(&lock->block_q);
 820         return lock;
 821 }
 822
 823 void
 824 cifs_del_lock_waiters(struct cifsLockInfo *lock)
 825 {
 826         struct cifsLockInfo *li, *tmp;
 827         list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
 828                 list_del_init(&li->blist);
 829                 wake_up(&li->block_q);
 830         }
 831 }
 832
 833 #define CIFS_LOCK_OP    0
 834 #define CIFS_READ_OP    1
 835 #define CIFS_WRITE_OP   2
 836
 837 /* @rw_check : 0 - no op, 1 - read, 2 - write */
 838 static bool
 839 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
 840                             __u64 length, __u8 type, struct cifsFileInfo *cfile,
 841                             struct cifsLockInfo **conf_lock, int rw_check)
 842 {
 843         struct cifsLockInfo *li;
 844         struct cifsFileInfo *cur_cfile = fdlocks->cfile;
 845         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
 846
 847         list_for_each_entry(li, &fdlocks->locks, llist) {
 848                 if (offset + length <= li->offset ||
 849                     offset >= li->offset + li->length)
 850                         continue;
 851                 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
 852                     server->ops->compare_fids(cfile, cur_cfile)) {
 853                         /* shared lock prevents write op through the same fid */
 854                         if (!(li->type & server->vals->shared_lock_type) ||
 855                             rw_check != CIFS_WRITE_OP)
 856                                 continue;
 857                 }
 858                 if ((type & server->vals->shared_lock_type) &&
 859                     ((server->ops->compare_fids(cfile, cur_cfile) &&
 860                      current->tgid == li->pid) || type == li->type))
 861                         continue;
 862                 if (conf_lock)
 863                         *conf_lock = li;
 864                 return true;
 865         }
 866         return false;
 867 }
 868
 869 bool
 870 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 871                         __u8 type, struct cifsLockInfo **conf_lock,
 872                         int rw_check)
 873 {
 874         bool rc = false;
 875         struct cifs_fid_locks *cur;
 876         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 877
 878         list_for_each_entry(cur, &cinode->llist, llist) {
 879                 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
 880                                                  cfile, conf_lock, rw_check);
 881                 if (rc)
 882                         break;
 883         }
 884
 885         return rc;
 886 }
 887
 888 /*
 889  * Check if there is another lock that prevents us to set the lock (mandatory
 890  * style). If such a lock exists, update the flock structure with its
 891  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 892  * or leave it the same if we can't. Returns 0 if we don't need to request to
 893  * the server or 1 otherwise.
 894  */
 895 static int
 896 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
 897                __u8 type, struct file_lock *flock)
 898 {
 899         int rc = 0;
 900         struct cifsLockInfo *conf_lock;
 901         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 902         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
 903         bool exist;
 904
 905         down_read(&cinode->lock_sem);
 906
 907         exist = cifs_find_lock_conflict(cfile, offset, length, type,
 908                                         &conf_lock, CIFS_LOCK_OP);
 909         if (exist) {
 910                 flock->fl_start = conf_lock->offset;
 911                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
 912                 flock->fl_pid = conf_lock->pid;
 913                 if (conf_lock->type & server->vals->shared_lock_type)
 914                         flock->fl_type = F_RDLCK;
 915                 else
 916                         flock->fl_type = F_WRLCK;
 917         } else if (!cinode->can_cache_brlcks)
 918                 rc = 1;
 919         else
 920                 flock->fl_type = F_UNLCK;
 921
 922         up_read(&cinode->lock_sem);
 923         return rc;
 924 }
 925
 926 static void
 927 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
 928 {
 929         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 930         down_write(&cinode->lock_sem);
 931         list_add_tail(&lock->llist, &cfile->llist->locks);
 932         up_write(&cinode->lock_sem);
 933 }
 934
 935 /*
 936  * Set the byte-range lock (mandatory style). Returns:
 937  * 1) 0, if we set the lock and don't need to request to the server;
 938  * 2) 1, if no locks prevent us but we need to request to the server;
 939  * 3) -EACCESS, if there is a lock that prevents us and wait is false.
 940  */
 941 static int
 942 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
 943                  bool wait)
 944 {
 945         struct cifsLockInfo *conf_lock;
 946         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
 947         bool exist;
 948         int rc = 0;
 949
 950 try_again:
 951         exist = false;
 952         down_write(&cinode->lock_sem);
 953
 954         exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
 955                                         lock->type, &conf_lock, CIFS_LOCK_OP);
 956         if (!exist && cinode->can_cache_brlcks) {
 957                 list_add_tail(&lock->llist, &cfile->llist->locks);
 958                 up_write(&cinode->lock_sem);
 959                 return rc;
 960         }
 961
 962         if (!exist)
 963                 rc = 1;
 964         else if (!wait)
 965                 rc = -EACCES;
 966         else {
 967                 list_add_tail(&lock->blist, &conf_lock->blist);
 968                 up_write(&cinode->lock_sem);
 969                 rc = wait_event_interruptible(lock->block_q,
 970                                         (lock->blist.prev == &lock->blist) &&
 971                                         (lock->blist.next == &lock->blist));
 972                 if (!rc)
 973                         goto try_again;
 974                 down_write(&cinode->lock_sem);
 975                 list_del_init(&lock->blist);
 976         }
 977
 978         up_write(&cinode->lock_sem);
 979         return rc;
 980 }
 981
 982 /*
 983  * Check if there is another lock that prevents us to set the lock (posix
 984  * style). If such a lock exists, update the flock structure with its
 985  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
 986  * or leave it the same if we can't. Returns 0 if we don't need to request to
 987  * the server or 1 otherwise.
 988  */
 989 static int
 990 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
 991 {
 992         int rc = 0;
 993         struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
 994         unsigned char saved_type = flock->fl_type;
 995
 996         if ((flock->fl_flags & FL_POSIX) == 0)
 997                 return 1;
 998
 999         down_read(&cinode->lock_sem);
1000         posix_test_lock(file, flock);
1001
1002         if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1003                 flock->fl_type = saved_type;
1004                 rc = 1;
1005         }
1006
1007         up_read(&cinode->lock_sem);
1008         return rc;
1009 }
1010
1011 /*
1012  * Set the byte-range lock (posix style). Returns:
1013  * 1) 0, if we set the lock and don't need to request to the server;
1014  * 2) 1, if we need to request to the server;
1015  * 3) <0, if the error occurs while setting the lock.
1016  */
1017 static int
1018 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1019 {
1020         struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1021         int rc = 1;
1022
1023         if ((flock->fl_flags & FL_POSIX) == 0)
1024                 return rc;
1025
1026 try_again:
1027         down_write(&cinode->lock_sem);
1028         if (!cinode->can_cache_brlcks) {
1029                 up_write(&cinode->lock_sem);
1030                 return rc;
1031         }
1032
1033         rc = posix_lock_file(file, flock, NULL);
1034         up_write(&cinode->lock_sem);
1035         if (rc == FILE_LOCK_DEFERRED) {
1036                 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
1037                 if (!rc)
1038                         goto try_again;
1039                 posix_unblock_lock(flock);
1040         }
1041         return rc;
1042 }
1043
1044 int
1045 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1046 {
1047         unsigned int xid;
1048         int rc = 0, stored_rc;
1049         struct cifsLockInfo *li, *tmp;
1050         struct cifs_tcon *tcon;
1051         unsigned int num, max_num, max_buf;
1052         LOCKING_ANDX_RANGE *buf, *cur;
1053         int types[] = {LOCKING_ANDX_LARGE_FILES,
1054                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1055         int i;
1056
1057         xid = get_xid();
1058         tcon = tlink_tcon(cfile->tlink);
1059
1060         /*
1061          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1062          * and check it for zero before using.
1063          */
1064         max_buf = tcon->ses->server->maxBuf;
1065         if (!max_buf) {
1066                 free_xid(xid);
1067                 return -EINVAL;
1068         }
1069
1070         max_num = (max_buf - sizeof(struct smb_hdr)) /
1071                                                 sizeof(LOCKING_ANDX_RANGE);
1072         buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1073         if (!buf) {
1074                 free_xid(xid);
1075                 return -ENOMEM;
1076         }
1077
1078         for (i = 0; i < 2; i++) {
1079                 cur = buf;
1080                 num = 0;
1081                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1082                         if (li->type != types[i])
1083                                 continue;
1084                         cur->Pid = cpu_to_le16(li->pid);
1085                         cur->LengthLow = cpu_to_le32((u32)li->length);
1086                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1087                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1088                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1089                         if (++num == max_num) {
1090                                 stored_rc = cifs_lockv(xid, tcon,
1091                                                        cfile->fid.netfid,
1092                                                        (__u8)li->type, 0, num,
1093                                                        buf);
1094                                 if (stored_rc)
1095                                         rc = stored_rc;
1096                                 cur = buf;
1097                                 num = 0;
1098                         } else
1099                                 cur++;
1100                 }
1101
1102                 if (num) {
1103                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1104                                                (__u8)types[i], 0, num, buf);
1105                         if (stored_rc)
1106                                 rc = stored_rc;
1107                 }
1108         }
1109
1110         kfree(buf);
1111         free_xid(xid);
1112         return rc;
1113 }
1114
1115 static __u32
1116 hash_lockowner(fl_owner_t owner)
1117 {
1118         return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1119 }
1120
1121 struct lock_to_push {
1122         struct list_head llist;
1123         __u64 offset;
1124         __u64 length;
1125         __u32 pid;
1126         __u16 netfid;
1127         __u8 type;
1128 };
1129
1130 static int
1131 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1132 {
1133         struct inode *inode = d_inode(cfile->dentry);
1134         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1135         struct file_lock *flock;
1136         struct file_lock_context *flctx = inode->i_flctx;
1137         unsigned int count = 0, i;
1138         int rc = 0, xid, type;
1139         struct list_head locks_to_send, *el;
1140         struct lock_to_push *lck, *tmp;
1141         __u64 length;
1142
1143         xid = get_xid();
1144
1145         if (!flctx)
1146                 goto out;
1147
1148         spin_lock(&flctx->flc_lock);
1149         list_for_each(el, &flctx->flc_posix) {
1150                 count++;
1151         }
1152         spin_unlock(&flctx->flc_lock);
1153
1154         INIT_LIST_HEAD(&locks_to_send);
1155
1156         /*
1157          * Allocating count locks is enough because no FL_POSIX locks can be
1158          * added to the list while we are holding cinode->lock_sem that
1159          * protects locking operations of this inode.
1160          */
1161         for (i = 0; i < count; i++) {
1162                 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1163                 if (!lck) {
1164                         rc = -ENOMEM;
1165                         goto err_out;
1166                 }
1167                 list_add_tail(&lck->llist, &locks_to_send);
1168         }
1169
1170         el = locks_to_send.next;
1171         spin_lock(&flctx->flc_lock);
1172         list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1173                 if (el == &locks_to_send) {
1174                         /*
1175                          * The list ended. We don't have enough allocated
1176                          * structures - something is really wrong.
1177                          */
1178                         cifs_dbg(VFS, "Can't push all brlocks!\n");
1179                         break;
1180                 }
1181                 length = 1 + flock->fl_end - flock->fl_start;
1182                 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1183                         type = CIFS_RDLCK;
1184                 else
1185                         type = CIFS_WRLCK;
1186                 lck = list_entry(el, struct lock_to_push, llist);
1187                 lck->pid = hash_lockowner(flock->fl_owner);
1188                 lck->netfid = cfile->fid.netfid;
1189                 lck->length = length;
1190                 lck->type = type;
1191                 lck->offset = flock->fl_start;
1192         }
1193         spin_unlock(&flctx->flc_lock);
1194
1195         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1196                 int stored_rc;
1197
1198                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1199                                              lck->offset, lck->length, NULL,
1200                                              lck->type, 0);
1201                 if (stored_rc)
1202                         rc = stored_rc;
1203                 list_del(&lck->llist);
1204                 kfree(lck);
1205         }
1206
1207 out:
1208         free_xid(xid);
1209         return rc;
1210 err_out:
1211         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1212                 list_del(&lck->llist);
1213                 kfree(lck);
1214         }
1215         goto out;
1216 }
1217
1218 static int
1219 cifs_push_locks(struct cifsFileInfo *cfile)
1220 {
1221         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1222         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1223         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1224         int rc = 0;
1225
1226         /* we are going to update can_cache_brlcks here - need a write access */
1227         down_write(&cinode->lock_sem);
1228         if (!cinode->can_cache_brlcks) {
1229                 up_write(&cinode->lock_sem);
1230                 return rc;
1231         }
1232
1233         if (cap_unix(tcon->ses) &&
1234             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1235             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1236                 rc = cifs_push_posix_locks(cfile);
1237         else
1238                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1239
1240         cinode->can_cache_brlcks = false;
1241         up_write(&cinode->lock_sem);
1242         return rc;
1243 }
1244
1245 static void
1246 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1247                 bool *wait_flag, struct TCP_Server_Info *server)
1248 {
1249         if (flock->fl_flags & FL_POSIX)
1250                 cifs_dbg(FYI, "Posix\n");
1251         if (flock->fl_flags & FL_FLOCK)
1252                 cifs_dbg(FYI, "Flock\n");
1253         if (flock->fl_flags & FL_SLEEP) {
1254                 cifs_dbg(FYI, "Blocking lock\n");
1255                 *wait_flag = true;
1256         }
1257         if (flock->fl_flags & FL_ACCESS)
1258                 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1259         if (flock->fl_flags & FL_LEASE)
1260                 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1261         if (flock->fl_flags &
1262             (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1263                FL_ACCESS | FL_LEASE | FL_CLOSE)))
1264                 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1265
1266         *type = server->vals->large_lock_type;
1267         if (flock->fl_type == F_WRLCK) {
1268                 cifs_dbg(FYI, "F_WRLCK\n");
1269                 *type |= server->vals->exclusive_lock_type;
1270                 *lock = 1;
1271         } else if (flock->fl_type == F_UNLCK) {
1272                 cifs_dbg(FYI, "F_UNLCK\n");
1273                 *type |= server->vals->unlock_lock_type;
1274                 *unlock = 1;
1275                 /* Check if unlock includes more than one lock range */
1276         } else if (flock->fl_type == F_RDLCK) {
1277                 cifs_dbg(FYI, "F_RDLCK\n");
1278                 *type |= server->vals->shared_lock_type;
1279                 *lock = 1;
1280         } else if (flock->fl_type == F_EXLCK) {
1281                 cifs_dbg(FYI, "F_EXLCK\n");
1282                 *type |= server->vals->exclusive_lock_type;
1283                 *lock = 1;
1284         } else if (flock->fl_type == F_SHLCK) {
1285                 cifs_dbg(FYI, "F_SHLCK\n");
1286                 *type |= server->vals->shared_lock_type;
1287                 *lock = 1;
1288         } else
1289                 cifs_dbg(FYI, "Unknown type of lock\n");
1290 }
1291
1292 static int
1293 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1294            bool wait_flag, bool posix_lck, unsigned int xid)
1295 {
1296         int rc = 0;
1297         __u64 length = 1 + flock->fl_end - flock->fl_start;
1298         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1299         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1300         struct TCP_Server_Info *server = tcon->ses->server;
1301         __u16 netfid = cfile->fid.netfid;
1302
1303         if (posix_lck) {
1304                 int posix_lock_type;
1305
1306                 rc = cifs_posix_lock_test(file, flock);
1307                 if (!rc)
1308                         return rc;
1309
1310                 if (type & server->vals->shared_lock_type)
1311                         posix_lock_type = CIFS_RDLCK;
1312                 else
1313                         posix_lock_type = CIFS_WRLCK;
1314                 rc = CIFSSMBPosixLock(xid, tcon, netfid,
1315                                       hash_lockowner(flock->fl_owner),
1316                                       flock->fl_start, length, flock,
1317                                       posix_lock_type, wait_flag);
1318                 return rc;
1319         }
1320
1321         rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1322         if (!rc)
1323                 return rc;
1324
1325         /* BB we could chain these into one lock request BB */
1326         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1327                                     1, 0, false);
1328         if (rc == 0) {
1329                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1330                                             type, 0, 1, false);
1331                 flock->fl_type = F_UNLCK;
1332                 if (rc != 0)
1333                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1334                                  rc);
1335                 return 0;
1336         }
1337
1338         if (type & server->vals->shared_lock_type) {
1339                 flock->fl_type = F_WRLCK;
1340                 return 0;
1341         }
1342
1343         type &= ~server->vals->exclusive_lock_type;
1344
1345         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1346                                     type | server->vals->shared_lock_type,
1347                                     1, 0, false);
1348         if (rc == 0) {
1349                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1350                         type | server->vals->shared_lock_type, 0, 1, false);
1351                 flock->fl_type = F_RDLCK;
1352                 if (rc != 0)
1353                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1354                                  rc);
1355         } else
1356                 flock->fl_type = F_WRLCK;
1357
1358         return 0;
1359 }
1360
1361 void
1362 cifs_move_llist(struct list_head *source, struct list_head *dest)
1363 {
1364         struct list_head *li, *tmp;
1365         list_for_each_safe(li, tmp, source)
1366                 list_move(li, dest);
1367 }
1368
1369 void
1370 cifs_free_llist(struct list_head *llist)
1371 {
1372         struct cifsLockInfo *li, *tmp;
1373         list_for_each_entry_safe(li, tmp, llist, llist) {
1374                 cifs_del_lock_waiters(li);
1375                 list_del(&li->llist);
1376                 kfree(li);
1377         }
1378 }
1379
1380 int
1381 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1382                   unsigned int xid)
1383 {
1384         int rc = 0, stored_rc;
1385         int types[] = {LOCKING_ANDX_LARGE_FILES,
1386                        LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1387         unsigned int i;
1388         unsigned int max_num, num, max_buf;
1389         LOCKING_ANDX_RANGE *buf, *cur;
1390         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1391         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1392         struct cifsLockInfo *li, *tmp;
1393         __u64 length = 1 + flock->fl_end - flock->fl_start;
1394         struct list_head tmp_llist;
1395
1396         INIT_LIST_HEAD(&tmp_llist);
1397
1398         /*
1399          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1400          * and check it for zero before using.
1401          */
1402         max_buf = tcon->ses->server->maxBuf;
1403         if (!max_buf)
1404                 return -EINVAL;
1405
1406         max_num = (max_buf - sizeof(struct smb_hdr)) /
1407                                                 sizeof(LOCKING_ANDX_RANGE);
1408         buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1409         if (!buf)
1410                 return -ENOMEM;
1411
1412         down_write(&cinode->lock_sem);
1413         for (i = 0; i < 2; i++) {
1414                 cur = buf;
1415                 num = 0;
1416                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1417                         if (flock->fl_start > li->offset ||
1418                             (flock->fl_start + length) <
1419                             (li->offset + li->length))
1420                                 continue;
1421                         if (current->tgid != li->pid)
1422                                 continue;
1423                         if (types[i] != li->type)
1424                                 continue;
1425                         if (cinode->can_cache_brlcks) {
1426                                 /*
1427                                  * We can cache brlock requests - simply remove
1428                                  * a lock from the file's list.
1429                                  */
1430                                 list_del(&li->llist);
1431                                 cifs_del_lock_waiters(li);
1432                                 kfree(li);
1433                                 continue;
1434                         }
1435                         cur->Pid = cpu_to_le16(li->pid);
1436                         cur->LengthLow = cpu_to_le32((u32)li->length);
1437                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1438                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1439                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1440                         /*
1441                          * We need to save a lock here to let us add it again to
1442                          * the file's list if the unlock range request fails on
1443                          * the server.
1444                          */
1445                         list_move(&li->llist, &tmp_llist);
1446                         if (++num == max_num) {
1447                                 stored_rc = cifs_lockv(xid, tcon,
1448                                                        cfile->fid.netfid,
1449                                                        li->type, num, 0, buf);
1450                                 if (stored_rc) {
1451                                         /*
1452                                          * We failed on the unlock range
1453                                          * request - add all locks from the tmp
1454                                          * list to the head of the file's list.
1455                                          */
1456                                         cifs_move_llist(&tmp_llist,
1457                                                         &cfile->llist->locks);
1458                                         rc = stored_rc;
1459                                 } else
1460                                         /*
1461                                          * The unlock range request succeed -
1462                                          * free the tmp list.
1463                                          */
1464                                         cifs_free_llist(&tmp_llist);
1465                                 cur = buf;
1466                                 num = 0;
1467                         } else
1468                                 cur++;
1469                 }
1470                 if (num) {
1471                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1472                                                types[i], num, 0, buf);
1473                         if (stored_rc) {
1474                                 cifs_move_llist(&tmp_llist,
1475                                                 &cfile->llist->locks);
1476                                 rc = stored_rc;
1477                         } else
1478                                 cifs_free_llist(&tmp_llist);
1479                 }
1480         }
1481
1482         up_write(&cinode->lock_sem);
1483         kfree(buf);
1484         return rc;
1485 }
1486
1487 static int
1488 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1489            bool wait_flag, bool posix_lck, int lock, int unlock,
1490            unsigned int xid)
1491 {
1492         int rc = 0;
1493         __u64 length = 1 + flock->fl_end - flock->fl_start;
1494         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1495         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1496         struct TCP_Server_Info *server = tcon->ses->server;
1497         struct inode *inode = d_inode(cfile->dentry);
1498
1499         if (posix_lck) {
1500                 int posix_lock_type;
1501
1502                 rc = cifs_posix_lock_set(file, flock);
1503                 if (!rc || rc < 0)
1504                         return rc;
1505
1506                 if (type & server->vals->shared_lock_type)
1507                         posix_lock_type = CIFS_RDLCK;
1508                 else
1509                         posix_lock_type = CIFS_WRLCK;
1510
1511                 if (unlock == 1)
1512                         posix_lock_type = CIFS_UNLCK;
1513
1514                 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1515                                       hash_lockowner(flock->fl_owner),
1516                                       flock->fl_start, length,
1517                                       NULL, posix_lock_type, wait_flag);
1518                 goto out;
1519         }
1520
1521         if (lock) {
1522                 struct cifsLockInfo *lock;
1523
1524                 lock = cifs_lock_init(flock->fl_start, length, type);
1525                 if (!lock)
1526                         return -ENOMEM;
1527
1528                 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1529                 if (rc < 0) {
1530                         kfree(lock);
1531                         return rc;
1532                 }
1533                 if (!rc)
1534                         goto out;
1535
1536                 /*
1537                  * Windows 7 server can delay breaking lease from read to None
1538                  * if we set a byte-range lock on a file - break it explicitly
1539                  * before sending the lock to the server to be sure the next
1540                  * read won't conflict with non-overlapted locks due to
1541                  * pagereading.
1542                  */
1543                 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1544                                         CIFS_CACHE_READ(CIFS_I(inode))) {
1545                         cifs_zap_mapping(inode);
1546                         cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1547                                  inode);
1548                         CIFS_I(inode)->oplock = 0;
1549                 }
1550
1551                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1552                                             type, 1, 0, wait_flag);
1553                 if (rc) {
1554                         kfree(lock);
1555                         return rc;
1556                 }
1557
1558                 cifs_lock_add(cfile, lock);
1559         } else if (unlock)
1560                 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1561
1562 out:
1563         if (flock->fl_flags & FL_POSIX && !rc)
1564                 rc = locks_lock_file_wait(file, flock);
1565         return rc;
1566 }
1567
1568 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1569 {
1570         int rc, xid;
1571         int lock = 0, unlock = 0;
1572         bool wait_flag = false;
1573         bool posix_lck = false;
1574         struct cifs_sb_info *cifs_sb;
1575         struct cifs_tcon *tcon;
1576         struct cifsInodeInfo *cinode;
1577         struct cifsFileInfo *cfile;
1578         __u16 netfid;
1579         __u32 type;
1580
1581         rc = -EACCES;
1582         xid = get_xid();
1583
1584         cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1585                  cmd, flock->fl_flags, flock->fl_type,
1586                  flock->fl_start, flock->fl_end);
1587
1588         cfile = (struct cifsFileInfo *)file->private_data;
1589         tcon = tlink_tcon(cfile->tlink);
1590
1591         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1592                         tcon->ses->server);
1593
1594         cifs_sb = CIFS_FILE_SB(file);
1595         netfid = cfile->fid.netfid;
1596         cinode = CIFS_I(file_inode(file));
1597
1598         if (cap_unix(tcon->ses) &&
1599             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1600             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1601                 posix_lck = true;
1602         /*
1603          * BB add code here to normalize offset and length to account for
1604          * negative length which we can not accept over the wire.
1605          */
1606         if (IS_GETLK(cmd)) {
1607                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1608                 free_xid(xid);
1609                 return rc;
1610         }
1611
1612         if (!lock && !unlock) {
1613                 /*
1614                  * if no lock or unlock then nothing to do since we do not
1615                  * know what it is
1616                  */
1617                 free_xid(xid);
1618                 return -EOPNOTSUPP;
1619         }
1620
1621         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1622                         xid);
1623         free_xid(xid);
1624         return rc;
1625 }
1626
1627 /*
1628  * update the file size (if needed) after a write. Should be called with
1629  * the inode->i_lock held
1630  */
1631 void
1632 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1633                       unsigned int bytes_written)
1634 {
1635         loff_t end_of_write = offset + bytes_written;
1636
1637         if (end_of_write > cifsi->server_eof)
1638                 cifsi->server_eof = end_of_write;
1639 }
1640
1641 static ssize_t
1642 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1643            size_t write_size, loff_t *offset)
1644 {
1645         int rc = 0;
1646         unsigned int bytes_written = 0;
1647         unsigned int total_written;
1648         struct cifs_sb_info *cifs_sb;
1649         struct cifs_tcon *tcon;
1650         struct TCP_Server_Info *server;
1651         unsigned int xid;
1652         struct dentry *dentry = open_file->dentry;
1653         struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1654         struct cifs_io_parms io_parms;
1655
1656         cifs_sb = CIFS_SB(dentry->d_sb);
1657
1658         cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1659                  write_size, *offset, dentry);
1660
1661         tcon = tlink_tcon(open_file->tlink);
1662         server = tcon->ses->server;
1663
1664         if (!server->ops->sync_write)
1665                 return -ENOSYS;
1666
1667         xid = get_xid();
1668
1669         for (total_written = 0; write_size > total_written;
1670              total_written += bytes_written) {
1671                 rc = -EAGAIN;
1672                 while (rc == -EAGAIN) {
1673                         struct kvec iov[2];
1674                         unsigned int len;
1675
1676                         if (open_file->invalidHandle) {
1677                                 /* we could deadlock if we called
1678                                    filemap_fdatawait from here so tell
1679                                    reopen_file not to flush data to
1680                                    server now */
1681                                 rc = cifs_reopen_file(open_file, false);
1682                                 if (rc != 0)
1683                                         break;
1684                         }
1685
1686                         len = min(server->ops->wp_retry_size(d_inode(dentry)),
1687                                   (unsigned int)write_size - total_written);
1688                         /* iov[0] is reserved for smb header */
1689                         iov[1].iov_base = (char *)write_data + total_written;
1690                         iov[1].iov_len = len;
1691                         io_parms.pid = pid;
1692                         io_parms.tcon = tcon;
1693                         io_parms.offset = *offset;
1694                         io_parms.length = len;
1695                         rc = server->ops->sync_write(xid, &open_file->fid,
1696                                         &io_parms, &bytes_written, iov, 1);
1697                 }
1698                 if (rc || (bytes_written == 0)) {
1699                         if (total_written)
1700                                 break;
1701                         else {
1702                                 free_xid(xid);
1703                                 return rc;
1704                         }
1705                 } else {
1706                         spin_lock(&d_inode(dentry)->i_lock);
1707                         cifs_update_eof(cifsi, *offset, bytes_written);
1708                         spin_unlock(&d_inode(dentry)->i_lock);
1709                         *offset += bytes_written;
1710                 }
1711         }
1712
1713         cifs_stats_bytes_written(tcon, total_written);
1714
1715         if (total_written > 0) {
1716                 spin_lock(&d_inode(dentry)->i_lock);
1717                 if (*offset > d_inode(dentry)->i_size)
1718                         i_size_write(d_inode(dentry), *offset);
1719                 spin_unlock(&d_inode(dentry)->i_lock);
1720         }
1721         mark_inode_dirty_sync(d_inode(dentry));
1722         free_xid(xid);
1723         return total_written;
1724 }
1725
1726 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1727                                         bool fsuid_only)
1728 {
1729         struct cifsFileInfo *open_file = NULL;
1730         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1731
1732         /* only filter by fsuid on multiuser mounts */
1733         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1734                 fsuid_only = false;
1735
1736         spin_lock(&cifs_file_list_lock);
1737         /* we could simply get the first_list_entry since write-only entries
1738            are always at the end of the list but since the first entry might
1739            have a close pending, we go through the whole list */
1740         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1741                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1742                         continue;
1743                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1744                         if (!open_file->invalidHandle) {
1745                                 /* found a good file */
1746                                 /* lock it so it will not be closed on us */
1747                                 cifsFileInfo_get_locked(open_file);
1748                                 spin_unlock(&cifs_file_list_lock);
1749                                 return open_file;
1750                         } /* else might as well continue, and look for
1751                              another, or simply have the caller reopen it
1752                              again rather than trying to fix this handle */
1753                 } else /* write only file */
1754                         break; /* write only files are last so must be done */
1755         }
1756         spin_unlock(&cifs_file_list_lock);
1757         return NULL;
1758 }
1759
1760 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1761                                         bool fsuid_only)
1762 {
1763         struct cifsFileInfo *open_file, *inv_file = NULL;
1764         struct cifs_sb_info *cifs_sb;
1765         bool any_available = false;
1766         int rc;
1767         unsigned int refind = 0;
1768
1769         /* Having a null inode here (because mapping->host was set to zero by
1770         the VFS or MM) should not happen but we had reports of on oops (due to
1771         it being zero) during stress testcases so we need to check for it */
1772
1773         if (cifs_inode == NULL) {
1774                 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1775                 dump_stack();
1776                 return NULL;
1777         }
1778
1779         cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1780
1781         /* only filter by fsuid on multiuser mounts */
1782         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1783                 fsuid_only = false;
1784
1785         spin_lock(&cifs_file_list_lock);
1786 refind_writable:
1787         if (refind > MAX_REOPEN_ATT) {
1788                 spin_unlock(&cifs_file_list_lock);
1789                 return NULL;
1790         }
1791         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1792                 if (!any_available && open_file->pid != current->tgid)
1793                         continue;
1794                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1795                         continue;
1796                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1797                         if (!open_file->invalidHandle) {
1798                                 /* found a good writable file */
1799                                 cifsFileInfo_get_locked(open_file);
1800                                 spin_unlock(&cifs_file_list_lock);
1801                                 return open_file;
1802                         } else {
1803                                 if (!inv_file)
1804                                         inv_file = open_file;
1805                         }
1806                 }
1807         }
1808         /* couldn't find useable FH with same pid, try any available */
1809         if (!any_available) {
1810                 any_available = true;
1811                 goto refind_writable;
1812         }
1813
1814         if (inv_file) {
1815                 any_available = false;
1816                 cifsFileInfo_get_locked(inv_file);
1817         }
1818
1819         spin_unlock(&cifs_file_list_lock);
1820
1821         if (inv_file) {
1822                 rc = cifs_reopen_file(inv_file, false);
1823                 if (!rc)
1824                         return inv_file;
1825                 else {
1826                         spin_lock(&cifs_file_list_lock);
1827                         list_move_tail(&inv_file->flist,
1828                                         &cifs_inode->openFileList);
1829                         spin_unlock(&cifs_file_list_lock);
1830                         cifsFileInfo_put(inv_file);
1831                         spin_lock(&cifs_file_list_lock);
1832                         ++refind;
1833                         inv_file = NULL;
1834                         goto refind_writable;
1835                 }
1836         }
1837
1838         return NULL;
1839 }
1840
1841 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1842 {
1843         struct address_space *mapping = page->mapping;
1844         loff_t offset = (loff_t)page->index << PAGE_SHIFT;
1845         char *write_data;
1846         int rc = -EFAULT;
1847         int bytes_written = 0;
1848         struct inode *inode;
1849         struct cifsFileInfo *open_file;
1850
1851         if (!mapping || !mapping->host)
1852                 return -EFAULT;
1853
1854         inode = page->mapping->host;
1855
1856         offset += (loff_t)from;
1857         write_data = kmap(page);
1858         write_data += from;
1859
1860         if ((to > PAGE_SIZE) || (from > to)) {
1861                 kunmap(page);
1862                 return -EIO;
1863         }
1864
1865         /* racing with truncate? */
1866         if (offset > mapping->host->i_size) {
1867                 kunmap(page);
1868                 return 0; /* don't care */
1869         }
1870
1871         /* check to make sure that we are not extending the file */
1872         if (mapping->host->i_size - offset < (loff_t)to)
1873                 to = (unsigned)(mapping->host->i_size - offset);
1874
1875         open_file = find_writable_file(CIFS_I(mapping->host), false);
1876         if (open_file) {
1877                 bytes_written = cifs_write(open_file, open_file->pid,
1878                                            write_data, to - from, &offset);
1879                 cifsFileInfo_put(open_file);
1880                 /* Does mm or vfs already set times? */
1881                 inode->i_atime = inode->i_mtime = current_time(inode);
1882                 if ((bytes_written > 0) && (offset))
1883                         rc = 0;
1884                 else if (bytes_written < 0)
1885                         rc = bytes_written;
1886         } else {
1887                 cifs_dbg(FYI, "No writeable filehandles for inode\n");
1888                 rc = -EIO;
1889         }
1890
1891         kunmap(page);
1892         return rc;
1893 }
1894
1895 static struct cifs_writedata *
1896 wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
1897                           pgoff_t end, pgoff_t *index,
1898                           unsigned int *found_pages)
1899 {
1900         unsigned int nr_pages;
1901         struct page **pages;
1902         struct cifs_writedata *wdata;
1903
1904         wdata = cifs_writedata_alloc((unsigned int)tofind,
1905                                      cifs_writev_complete);
1906         if (!wdata)
1907                 return NULL;
1908
1909         /*
1910          * find_get_pages_tag seems to return a max of 256 on each
1911          * iteration, so we must call it several times in order to
1912          * fill the array or the wsize is effectively limited to
1913          * 256 * PAGE_SIZE.
1914          */
1915         *found_pages = 0;
1916         pages = wdata->pages;
1917         do {
1918                 nr_pages = find_get_pages_tag(mapping, index,
1919                                               PAGECACHE_TAG_DIRTY, tofind,
1920                                               pages);
1921                 *found_pages += nr_pages;
1922                 tofind -= nr_pages;
1923                 pages += nr_pages;
1924         } while (nr_pages && tofind && *index <= end);
1925
1926         return wdata;
1927 }
1928
1929 static unsigned int
1930 wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
1931                     struct address_space *mapping,
1932                     struct writeback_control *wbc,
1933                     pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
1934 {
1935         unsigned int nr_pages = 0, i;
1936         struct page *page;
1937
1938         for (i = 0; i < found_pages; i++) {
1939                 page = wdata->pages[i];
1940                 /*
1941                  * At this point we hold neither mapping->tree_lock nor
1942                  * lock on the page itself: the page may be truncated or
1943                  * invalidated (changing page->mapping to NULL), or even
1944                  * swizzled back from swapper_space to tmpfs file
1945                  * mapping
1946                  */
1947
1948                 if (nr_pages == 0)
1949                         lock_page(page);
1950                 else if (!trylock_page(page))
1951                         break;
1952
1953                 if (unlikely(page->mapping != mapping)) {
1954                         unlock_page(page);
1955                         break;
1956                 }
1957
1958                 if (!wbc->range_cyclic && page->index > end) {
1959                         *done = true;
1960                         unlock_page(page);
1961                         break;
1962                 }
1963
1964                 if (*next && (page->index != *next)) {
1965                         /* Not next consecutive page */
1966                         unlock_page(page);
1967                         break;
1968                 }
1969
1970                 if (wbc->sync_mode != WB_SYNC_NONE)
1971                         wait_on_page_writeback(page);
1972
1973                 if (PageWriteback(page) ||
1974                                 !clear_page_dirty_for_io(page)) {
1975                         unlock_page(page);
1976                         break;
1977                 }
1978
1979                 /*
1980                  * This actually clears the dirty bit in the radix tree.
1981                  * See cifs_writepage() for more commentary.
1982                  */
1983                 set_page_writeback(page);
1984                 if (page_offset(page) >= i_size_read(mapping->host)) {
1985                         *done = true;
1986                         unlock_page(page);
1987                         end_page_writeback(page);
1988                         break;
1989                 }
1990
1991                 wdata->pages[i] = page;
1992                 *next = page->index + 1;
1993                 ++nr_pages;
1994         }
1995
1996         /* reset index to refind any pages skipped */
1997         if (nr_pages == 0)
1998                 *index = wdata->pages[0]->index + 1;
1999
2000         /* put any pages we aren't going to use */
2001         for (i = nr_pages; i < found_pages; i++) {
2002                 put_page(wdata->pages[i]);
2003                 wdata->pages[i] = NULL;
2004         }
2005
2006         return nr_pages;
2007 }
2008
2009 static int
2010 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2011                  struct address_space *mapping, struct writeback_control *wbc)
2012 {
2013         int rc = 0;
2014         struct TCP_Server_Info *server;
2015         unsigned int i;
2016
2017         wdata->sync_mode = wbc->sync_mode;
2018         wdata->nr_pages = nr_pages;
2019         wdata->offset = page_offset(wdata->pages[0]);
2020         wdata->pagesz = PAGE_SIZE;
2021         wdata->tailsz = min(i_size_read(mapping->host) -
2022                         page_offset(wdata->pages[nr_pages - 1]),
2023                         (loff_t)PAGE_SIZE);
2024         wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2025
2026         if (wdata->cfile != NULL)
2027                 cifsFileInfo_put(wdata->cfile);
2028         wdata->cfile = find_writable_file(CIFS_I(mapping->host), false);
2029         if (!wdata->cfile) {
2030                 cifs_dbg(VFS, "No writable handles for inode\n");
2031                 rc = -EBADF;
2032         } else {
2033                 wdata->pid = wdata->cfile->pid;
2034                 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2035                 rc = server->ops->async_writev(wdata, cifs_writedata_release);
2036         }
2037
2038         for (i = 0; i < nr_pages; ++i)
2039                 unlock_page(wdata->pages[i]);
2040
2041         return rc;
2042 }
2043
2044 static int cifs_writepages(struct address_space *mapping,
2045                            struct writeback_control *wbc)
2046 {
2047         struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
2048         struct TCP_Server_Info *server;
2049         bool done = false, scanned = false, range_whole = false;
2050         pgoff_t end, index;
2051         struct cifs_writedata *wdata;
2052         int rc = 0;
2053
2054         /*
2055          * If wsize is smaller than the page cache size, default to writing
2056          * one page at a time via cifs_writepage
2057          */
2058         if (cifs_sb->wsize < PAGE_SIZE)
2059                 return generic_writepages(mapping, wbc);
2060
2061         if (wbc->range_cyclic) {
2062                 index = mapping->writeback_index; /* Start from prev offset */
2063                 end = -1;
2064         } else {
2065                 index = wbc->range_start >> PAGE_SHIFT;
2066                 end = wbc->range_end >> PAGE_SHIFT;
2067                 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2068                         range_whole = true;
2069                 scanned = true;
2070         }
2071         server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2072 retry:
2073         while (!done && index <= end) {
2074                 unsigned int i, nr_pages, found_pages, wsize, credits;
2075                 pgoff_t next = 0, tofind, saved_index = index;
2076
2077                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2078                                                    &wsize, &credits);
2079                 if (rc)
2080                         break;
2081
2082                 tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2083
2084                 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2085                                                   &found_pages);
2086                 if (!wdata) {
2087                         rc = -ENOMEM;
2088                         add_credits_and_wake_if(server, credits, 0);
2089                         break;
2090                 }
2091
2092                 if (found_pages == 0) {
2093                         kref_put(&wdata->refcount, cifs_writedata_release);
2094                         add_credits_and_wake_if(server, credits, 0);
2095                         break;
2096                 }
2097
2098                 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2099                                                end, &index, &next, &done);
2100
2101                 /* nothing to write? */
2102                 if (nr_pages == 0) {
2103                         kref_put(&wdata->refcount, cifs_writedata_release);
2104                         add_credits_and_wake_if(server, credits, 0);
2105                         continue;
2106                 }
2107
2108                 wdata->credits = credits;
2109
2110                 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2111
2112                 /* send failure -- clean up the mess */
2113                 if (rc != 0) {
2114                         add_credits_and_wake_if(server, wdata->credits, 0);
2115                         for (i = 0; i < nr_pages; ++i) {
2116                                 if (rc == -EAGAIN)
2117                                         redirty_page_for_writepage(wbc,
2118                                                            wdata->pages[i]);
2119                                 else
2120                                         SetPageError(wdata->pages[i]);
2121                                 end_page_writeback(wdata->pages[i]);
2122                                 put_page(wdata->pages[i]);
2123                         }
2124                         if (rc != -EAGAIN)
2125                                 mapping_set_error(mapping, rc);
2126                 }
2127                 kref_put(&wdata->refcount, cifs_writedata_release);
2128
2129                 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2130                         index = saved_index;
2131                         continue;
2132                 }
2133
2134                 wbc->nr_to_write -= nr_pages;
2135                 if (wbc->nr_to_write <= 0)
2136                         done = true;
2137
2138                 index = next;
2139         }
2140
2141         if (!scanned && !done) {
2142                 /*
2143                  * We hit the last page and there is more work to be done: wrap
2144                  * back to the start of the file
2145                  */
2146                 scanned = true;
2147                 index = 0;
2148                 goto retry;
2149         }
2150
2151         if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2152                 mapping->writeback_index = index;
2153
2154         return rc;
2155 }
2156
2157 static int
2158 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2159 {
2160         int rc;
2161         unsigned int xid;
2162
2163         xid = get_xid();
2164 /* BB add check for wbc flags */
2165         get_page(page);
2166         if (!PageUptodate(page))
2167                 cifs_dbg(FYI, "ppw - page not up to date\n");
2168
2169         /*
2170          * Set the "writeback" flag, and clear "dirty" in the radix tree.
2171          *
2172          * A writepage() implementation always needs to do either this,
2173          * or re-dirty the page with "redirty_page_for_writepage()" in
2174          * the case of a failure.
2175          *
2176          * Just unlocking the page will cause the radix tree tag-bits
2177          * to fail to update with the state of the page correctly.
2178          */
2179         set_page_writeback(page);
2180 retry_write:
2181         rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2182         if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2183                 goto retry_write;
2184         else if (rc == -EAGAIN)
2185                 redirty_page_for_writepage(wbc, page);
2186         else if (rc != 0)
2187                 SetPageError(page);
2188         else
2189                 SetPageUptodate(page);
2190         end_page_writeback(page);
2191         put_page(page);
2192         free_xid(xid);
2193         return rc;
2194 }
2195
2196 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2197 {
2198         int rc = cifs_writepage_locked(page, wbc);
2199         unlock_page(page);
2200         return rc;
2201 }
2202
2203 static int cifs_write_end(struct file *file, struct address_space *mapping,
2204                         loff_t pos, unsigned len, unsigned copied,
2205                         struct page *page, void *fsdata)
2206 {
2207         int rc;
2208         struct inode *inode = mapping->host;
2209         struct cifsFileInfo *cfile = file->private_data;
2210         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2211         __u32 pid;
2212
2213         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2214                 pid = cfile->pid;
2215         else
2216                 pid = current->tgid;
2217
2218         cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2219                  page, pos, copied);
2220
2221         if (PageChecked(page)) {
2222                 if (copied == len)
2223                         SetPageUptodate(page);
2224                 ClearPageChecked(page);
2225         } else if (!PageUptodate(page) && copied == PAGE_SIZE)
2226                 SetPageUptodate(page);
2227
2228         if (!PageUptodate(page)) {
2229                 char *page_data;
2230                 unsigned offset = pos & (PAGE_SIZE - 1);
2231                 unsigned int xid;
2232
2233                 xid = get_xid();
2234                 /* this is probably better than directly calling
2235                    partialpage_write since in this function the file handle is
2236                    known which we might as well leverage */
2237                 /* BB check if anything else missing out of ppw
2238                    such as updating last write time */
2239                 page_data = kmap(page);
2240                 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2241                 /* if (rc < 0) should we set writebehind rc? */
2242                 kunmap(page);
2243
2244                 free_xid(xid);
2245         } else {
2246                 rc = copied;
2247                 pos += copied;
2248                 set_page_dirty(page);
2249         }
2250
2251         if (rc > 0) {
2252                 spin_lock(&inode->i_lock);
2253                 if (pos > inode->i_size)
2254                         i_size_write(inode, pos);
2255                 spin_unlock(&inode->i_lock);
2256         }
2257
2258         unlock_page(page);
2259         put_page(page);
2260
2261         return rc;
2262 }
2263
2264 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2265                       int datasync)
2266 {
2267         unsigned int xid;
2268         int rc = 0;
2269         struct cifs_tcon *tcon;
2270         struct TCP_Server_Info *server;
2271         struct cifsFileInfo *smbfile = file->private_data;
2272         struct inode *inode = file_inode(file);
2273         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2274
2275         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2276         if (rc)
2277                 return rc;
2278         inode_lock(inode);
2279
2280         xid = get_xid();
2281
2282         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2283                  file, datasync);
2284
2285         if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2286                 rc = cifs_zap_mapping(inode);
2287                 if (rc) {
2288                         cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2289                         rc = 0; /* don't care about it in fsync */
2290                 }
2291         }
2292
2293         tcon = tlink_tcon(smbfile->tlink);
2294         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2295                 server = tcon->ses->server;
2296                 if (server->ops->flush)
2297                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2298                 else
2299                         rc = -ENOSYS;
2300         }
2301
2302         free_xid(xid);
2303         inode_unlock(inode);
2304         return rc;
2305 }
2306
2307 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2308 {
2309         unsigned int xid;
2310         int rc = 0;
2311         struct cifs_tcon *tcon;
2312         struct TCP_Server_Info *server;
2313         struct cifsFileInfo *smbfile = file->private_data;
2314         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2315         struct inode *inode = file->f_mapping->host;
2316
2317         rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2318         if (rc)
2319                 return rc;
2320         inode_lock(inode);
2321
2322         xid = get_xid();
2323
2324         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2325                  file, datasync);
2326
2327         tcon = tlink_tcon(smbfile->tlink);
2328         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2329                 server = tcon->ses->server;
2330                 if (server->ops->flush)
2331                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2332                 else
2333                         rc = -ENOSYS;
2334         }
2335
2336         free_xid(xid);
2337         inode_unlock(inode);
2338         return rc;
2339 }
2340
2341 /*
2342  * As file closes, flush all cached write data for this inode checking
2343  * for write behind errors.
2344  */
2345 int cifs_flush(struct file *file, fl_owner_t id)
2346 {
2347         struct inode *inode = file_inode(file);
2348         int rc = 0;
2349
2350         if (file->f_mode & FMODE_WRITE)
2351                 rc = filemap_write_and_wait(inode->i_mapping);
2352
2353         cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2354
2355         return rc;
2356 }
2357
2358 static int
2359 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2360 {
2361         int rc = 0;
2362         unsigned long i;
2363
2364         for (i = 0; i < num_pages; i++) {
2365                 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2366                 if (!pages[i]) {
2367                         /*
2368                          * save number of pages we have already allocated and
2369                          * return with ENOMEM error
2370                          */
2371                         num_pages = i;
2372                         rc = -ENOMEM;
2373                         break;
2374                 }
2375         }
2376
2377         if (rc) {
2378                 for (i = 0; i < num_pages; i++)
2379                         put_page(pages[i]);
2380         }
2381         return rc;
2382 }
2383
2384 static inline
2385 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2386 {
2387         size_t num_pages;
2388         size_t clen;
2389
2390         clen = min_t(const size_t, len, wsize);
2391         num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2392
2393         if (cur_len)
2394                 *cur_len = clen;
2395
2396         return num_pages;
2397 }
2398
2399 static void
2400 cifs_uncached_writedata_release(struct kref *refcount)
2401 {
2402         int i;
2403         struct cifs_writedata *wdata = container_of(refcount,
2404                                         struct cifs_writedata, refcount);
2405
2406         for (i = 0; i < wdata->nr_pages; i++)
2407                 put_page(wdata->pages[i]);
2408         cifs_writedata_release(refcount);
2409 }
2410
2411 static void
2412 cifs_uncached_writev_complete(struct work_struct *work)
2413 {
2414         struct cifs_writedata *wdata = container_of(work,
2415                                         struct cifs_writedata, work);
2416         struct inode *inode = d_inode(wdata->cfile->dentry);
2417         struct cifsInodeInfo *cifsi = CIFS_I(inode);
2418
2419         spin_lock(&inode->i_lock);
2420         cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2421         if (cifsi->server_eof > inode->i_size)
2422                 i_size_write(inode, cifsi->server_eof);
2423         spin_unlock(&inode->i_lock);
2424
2425         complete(&wdata->done);
2426
2427         kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2428 }
2429
2430 static int
2431 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2432                       size_t *len, unsigned long *num_pages)
2433 {
2434         size_t save_len, copied, bytes, cur_len = *len;
2435         unsigned long i, nr_pages = *num_pages;
2436
2437         save_len = cur_len;
2438         for (i = 0; i < nr_pages; i++) {
2439                 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2440                 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2441                 cur_len -= copied;
2442                 /*
2443                  * If we didn't copy as much as we expected, then that
2444                  * may mean we trod into an unmapped area. Stop copying
2445                  * at that point. On the next pass through the big
2446                  * loop, we'll likely end up getting a zero-length
2447                  * write and bailing out of it.
2448                  */
2449                 if (copied < bytes)
2450                         break;
2451         }
2452         cur_len = save_len - cur_len;
2453         *len = cur_len;
2454
2455         /*
2456          * If we have no data to send, then that probably means that
2457          * the copy above failed altogether. That's most likely because
2458          * the address in the iovec was bogus. Return -EFAULT and let
2459          * the caller free anything we allocated and bail out.
2460          */
2461         if (!cur_len)
2462                 return -EFAULT;
2463
2464         /*
2465          * i + 1 now represents the number of pages we actually used in
2466          * the copy phase above.
2467          */
2468         *num_pages = i + 1;
2469         return 0;
2470 }
2471
2472 static int
2473 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2474                      struct cifsFileInfo *open_file,
2475                      struct cifs_sb_info *cifs_sb, struct list_head *wdata_list)
2476 {
2477         int rc = 0;
2478         size_t cur_len;
2479         unsigned long nr_pages, num_pages, i;
2480         struct cifs_writedata *wdata;
2481         struct iov_iter saved_from = *from;
2482         loff_t saved_offset = offset;
2483         pid_t pid;
2484         struct TCP_Server_Info *server;
2485
2486         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2487                 pid = open_file->pid;
2488         else
2489                 pid = current->tgid;
2490
2491         server = tlink_tcon(open_file->tlink)->ses->server;
2492
2493         do {
2494                 unsigned int wsize, credits;
2495
2496                 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2497                                                    &wsize, &credits);
2498                 if (rc)
2499                         break;
2500
2501                 nr_pages = get_numpages(wsize, len, &cur_len);
2502                 wdata = cifs_writedata_alloc(nr_pages,
2503                                              cifs_uncached_writev_complete);
2504                 if (!wdata) {
2505                         rc = -ENOMEM;
2506                         add_credits_and_wake_if(server, credits, 0);
2507                         break;
2508                 }
2509
2510                 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2511                 if (rc) {
2512                         kfree(wdata);
2513                         add_credits_and_wake_if(server, credits, 0);
2514                         break;
2515                 }
2516
2517                 num_pages = nr_pages;
2518                 rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
2519                 if (rc) {
2520                         for (i = 0; i < nr_pages; i++)
2521                                 put_page(wdata->pages[i]);
2522                         kfree(wdata);
2523                         add_credits_and_wake_if(server, credits, 0);
2524                         break;
2525                 }
2526
2527                 /*
2528                  * Bring nr_pages down to the number of pages we actually used,
2529                  * and free any pages that we didn't use.
2530                  */
2531                 for ( ; nr_pages > num_pages; nr_pages--)
2532                         put_page(wdata->pages[nr_pages - 1]);
2533
2534                 wdata->sync_mode = WB_SYNC_ALL;
2535                 wdata->nr_pages = nr_pages;
2536                 wdata->offset = (__u64)offset;
2537                 wdata->cfile = cifsFileInfo_get(open_file);
2538                 wdata->pid = pid;
2539                 wdata->bytes = cur_len;
2540                 wdata->pagesz = PAGE_SIZE;
2541                 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2542                 wdata->credits = credits;
2543
2544                 if (!wdata->cfile->invalidHandle ||
2545                     !cifs_reopen_file(wdata->cfile, false))
2546                         rc = server->ops->async_writev(wdata,
2547                                         cifs_uncached_writedata_release);
2548                 if (rc) {
2549                         add_credits_and_wake_if(server, wdata->credits, 0);
2550                         kref_put(&wdata->refcount,
2551                                  cifs_uncached_writedata_release);
2552                         if (rc == -EAGAIN) {
2553                                 *from = saved_from;
2554                                 iov_iter_advance(from, offset - saved_offset);
2555                                 continue;
2556                         }
2557                         break;
2558                 }
2559
2560                 list_add_tail(&wdata->list, wdata_list);
2561                 offset += cur_len;
2562                 len -= cur_len;
2563         } while (len > 0);
2564
2565         return rc;
2566 }
2567
2568 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
2569 {
2570         struct file *file = iocb->ki_filp;
2571         ssize_t total_written = 0;
2572         struct cifsFileInfo *open_file;
2573         struct cifs_tcon *tcon;
2574         struct cifs_sb_info *cifs_sb;
2575         struct cifs_writedata *wdata, *tmp;
2576         struct list_head wdata_list;
2577         struct iov_iter saved_from = *from;
2578         int rc;
2579
2580         /*
2581          * BB - optimize the way when signing is disabled. We can drop this
2582          * extra memory-to-memory copying and use iovec buffers for constructing
2583          * write request.
2584          */
2585
2586         rc = generic_write_checks(iocb, from);
2587         if (rc <= 0)
2588                 return rc;
2589
2590         INIT_LIST_HEAD(&wdata_list);
2591         cifs_sb = CIFS_FILE_SB(file);
2592         open_file = file->private_data;
2593         tcon = tlink_tcon(open_file->tlink);
2594
2595         if (!tcon->ses->server->ops->async_writev)
2596                 return -ENOSYS;
2597
2598         rc = cifs_write_from_iter(iocb->ki_pos, iov_iter_count(from), from,
2599                                   open_file, cifs_sb, &wdata_list);
2600
2601         /*
2602          * If at least one write was successfully sent, then discard any rc
2603          * value from the later writes. If the other write succeeds, then
2604          * we'll end up returning whatever was written. If it fails, then
2605          * we'll get a new rc value from that.
2606          */
2607         if (!list_empty(&wdata_list))
2608                 rc = 0;
2609
2610         /*
2611          * Wait for and collect replies for any successful sends in order of
2612          * increasing offset. Once an error is hit or we get a fatal signal
2613          * while waiting, then return without waiting for any more replies.
2614          */
2615 restart_loop:
2616         list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2617                 if (!rc) {
2618                         /* FIXME: freezable too? */
2619                         rc = wait_for_completion_killable(&wdata->done);
2620                         if (rc)
2621                                 rc = -EINTR;
2622                         else if (wdata->result)
2623                                 rc = wdata->result;
2624                         else
2625                                 total_written += wdata->bytes;
2626
2627                         /* resend call if it's a retryable error */
2628                         if (rc == -EAGAIN) {
2629                                 struct list_head tmp_list;
2630                                 struct iov_iter tmp_from = saved_from;
2631
2632                                 INIT_LIST_HEAD(&tmp_list);
2633                                 list_del_init(&wdata->list);
2634
2635                                 iov_iter_advance(&tmp_from,
2636                                                  wdata->offset - iocb->ki_pos);
2637
2638                                 rc = cifs_write_from_iter(wdata->offset,
2639                                                 wdata->bytes, &tmp_from,
2640                                                 open_file, cifs_sb, &tmp_list);
2641
2642                                 list_splice(&tmp_list, &wdata_list);
2643
2644                                 kref_put(&wdata->refcount,
2645                                          cifs_uncached_writedata_release);
2646                                 goto restart_loop;
2647                         }
2648                 }
2649                 list_del_init(&wdata->list);
2650                 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2651         }
2652
2653         if (unlikely(!total_written))
2654                 return rc;
2655
2656         iocb->ki_pos += total_written;
2657         set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(file_inode(file))->flags);
2658         cifs_stats_bytes_written(tcon, total_written);
2659         return total_written;
2660 }
2661
2662 static ssize_t
2663 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2664 {
2665         struct file *file = iocb->ki_filp;
2666         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2667         struct inode *inode = file->f_mapping->host;
2668         struct cifsInodeInfo *cinode = CIFS_I(inode);
2669         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2670         ssize_t rc;
2671
2672         /*
2673          * We need to hold the sem to be sure nobody modifies lock list
2674          * with a brlock that prevents writing.
2675          */
2676         down_read(&cinode->lock_sem);
2677         inode_lock(inode);
2678
2679         rc = generic_write_checks(iocb, from);
2680         if (rc <= 0)
2681                 goto out;
2682
2683         if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
2684                                      server->vals->exclusive_lock_type, NULL,
2685                                      CIFS_WRITE_OP))
2686                 rc = __generic_file_write_iter(iocb, from);
2687         else
2688                 rc = -EACCES;
2689 out:
2690         inode_unlock(inode);
2691
2692         if (rc > 0)
2693                 rc = generic_write_sync(iocb, rc);
2694         up_read(&cinode->lock_sem);
2695         return rc;
2696 }
2697
2698 ssize_t
2699 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2700 {
2701         struct inode *inode = file_inode(iocb->ki_filp);
2702         struct cifsInodeInfo *cinode = CIFS_I(inode);
2703         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2704         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2705                                                 iocb->ki_filp->private_data;
2706         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2707         ssize_t written;
2708
2709         written = cifs_get_writer(cinode);
2710         if (written)
2711                 return written;
2712
2713         if (CIFS_CACHE_WRITE(cinode)) {
2714                 if (cap_unix(tcon->ses) &&
2715                 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2716                   && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
2717                         written = generic_file_write_iter(iocb, from);
2718                         goto out;
2719                 }
2720                 written = cifs_writev(iocb, from);
2721                 goto out;
2722         }
2723         /*
2724          * For non-oplocked files in strict cache mode we need to write the data
2725          * to the server exactly from the pos to pos+len-1 rather than flush all
2726          * affected pages because it may cause a error with mandatory locks on
2727          * these pages but not on the region from pos to ppos+len-1.
2728          */
2729         written = cifs_user_writev(iocb, from);
2730         if (written > 0 && CIFS_CACHE_READ(cinode)) {
2731                 /*
2732                  * Windows 7 server can delay breaking level2 oplock if a write
2733                  * request comes - break it on the client to prevent reading
2734                  * an old data.
2735                  */
2736                 cifs_zap_mapping(inode);
2737                 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2738                          inode);
2739                 cinode->oplock = 0;
2740         }
2741 out:
2742         cifs_put_writer(cinode);
2743         return written;
2744 }
2745
2746 static struct cifs_readdata *
2747 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2748 {
2749         struct cifs_readdata *rdata;
2750
2751         rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2752                         GFP_KERNEL);
2753         if (rdata != NULL) {
2754                 kref_init(&rdata->refcount);
2755                 INIT_LIST_HEAD(&rdata->list);
2756                 init_completion(&rdata->done);
2757                 INIT_WORK(&rdata->work, complete);
2758         }
2759
2760         return rdata;
2761 }
2762
2763 void
2764 cifs_readdata_release(struct kref *refcount)
2765 {
2766         struct cifs_readdata *rdata = container_of(refcount,
2767                                         struct cifs_readdata, refcount);
2768
2769         if (rdata->cfile)
2770                 cifsFileInfo_put(rdata->cfile);
2771
2772         kfree(rdata);
2773 }
2774
2775 static int
2776 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2777 {
2778         int rc = 0;
2779         struct page *page;
2780         unsigned int i;
2781
2782         for (i = 0; i < nr_pages; i++) {
2783                 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2784                 if (!page) {
2785                         rc = -ENOMEM;
2786                         break;
2787                 }
2788                 rdata->pages[i] = page;
2789         }
2790
2791         if (rc) {
2792                 for (i = 0; i < nr_pages; i++) {
2793                         put_page(rdata->pages[i]);
2794                         rdata->pages[i] = NULL;
2795                 }
2796         }
2797         return rc;
2798 }
2799
2800 static void
2801 cifs_uncached_readdata_release(struct kref *refcount)
2802 {
2803         struct cifs_readdata *rdata = container_of(refcount,
2804                                         struct cifs_readdata, refcount);
2805         unsigned int i;
2806
2807         for (i = 0; i < rdata->nr_pages; i++) {
2808                 put_page(rdata->pages[i]);
2809                 rdata->pages[i] = NULL;
2810         }
2811         cifs_readdata_release(refcount);
2812 }
2813
2814 /**
2815  * cifs_readdata_to_iov - copy data from pages in response to an iovec
2816  * @rdata:      the readdata response with list of pages holding data
2817  * @iter:       destination for our data
2818  *
2819  * This function copies data from a list of pages in a readdata response into
2820  * an array of iovecs. It will first calculate where the data should go
2821  * based on the info in the readdata and then copy the data into that spot.
2822  */
2823 static int
2824 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
2825 {
2826         size_t remaining = rdata->got_bytes;
2827         unsigned int i;
2828
2829         for (i = 0; i < rdata->nr_pages; i++) {
2830                 struct page *page = rdata->pages[i];
2831                 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
2832                 size_t written = copy_page_to_iter(page, 0, copy, iter);
2833                 remaining -= written;
2834                 if (written < copy && iov_iter_count(iter) > 0)
2835                         break;
2836         }
2837         return remaining ? -EFAULT : 0;
2838 }
2839
2840 static void
2841 cifs_uncached_readv_complete(struct work_struct *work)
2842 {
2843         struct cifs_readdata *rdata = container_of(work,
2844                                                 struct cifs_readdata, work);
2845
2846         complete(&rdata->done);
2847         kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2848 }
2849
2850 static int
2851 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2852                         struct cifs_readdata *rdata, unsigned int len)
2853 {
2854         int result = 0;
2855         unsigned int i;
2856         unsigned int nr_pages = rdata->nr_pages;
2857
2858         rdata->got_bytes = 0;
2859         rdata->tailsz = PAGE_SIZE;
2860         for (i = 0; i < nr_pages; i++) {
2861                 struct page *page = rdata->pages[i];
2862                 size_t n;
2863
2864                 if (len <= 0) {
2865                         /* no need to hold page hostage */
2866                         rdata->pages[i] = NULL;
2867                         rdata->nr_pages--;
2868                         put_page(page);
2869                         continue;
2870                 }
2871                 n = len;
2872                 if (len >= PAGE_SIZE) {
2873                         /* enough data to fill the page */
2874                         n = PAGE_SIZE;
2875                         len -= n;
2876                 } else {
2877                         zero_user(page, len, PAGE_SIZE - len);
2878                         rdata->tailsz = len;
2879                         len = 0;
2880                 }
2881                 result = cifs_read_page_from_socket(server, page, n);
2882                 if (result < 0)
2883                         break;
2884
2885                 rdata->got_bytes += result;
2886         }
2887
2888         return rdata->got_bytes > 0 && result != -ECONNABORTED ?
2889                                                 rdata->got_bytes : result;
2890 }
2891
2892 static int
2893 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
2894                      struct cifs_sb_info *cifs_sb, struct list_head *rdata_list)
2895 {
2896         struct cifs_readdata *rdata;
2897         unsigned int npages, rsize, credits;
2898         size_t cur_len;
2899         int rc;
2900         pid_t pid;
2901         struct TCP_Server_Info *server;
2902
2903         server = tlink_tcon(open_file->tlink)->ses->server;
2904
2905         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2906                 pid = open_file->pid;
2907         else
2908                 pid = current->tgid;
2909
2910         do {
2911                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
2912                                                    &rsize, &credits);
2913                 if (rc)
2914                         break;
2915
2916                 cur_len = min_t(const size_t, len, rsize);
2917                 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2918
2919                 /* allocate a readdata struct */
2920                 rdata = cifs_readdata_alloc(npages,
2921                                             cifs_uncached_readv_complete);
2922                 if (!rdata) {
2923                         add_credits_and_wake_if(server, credits, 0);
2924                         rc = -ENOMEM;
2925                         break;
2926                 }
2927
2928                 rc = cifs_read_allocate_pages(rdata, npages);
2929                 if (rc)
2930                         goto error;
2931
2932                 rdata->cfile = cifsFileInfo_get(open_file);
2933                 rdata->nr_pages = npages;
2934                 rdata->offset = offset;
2935                 rdata->bytes = cur_len;
2936                 rdata->pid = pid;
2937                 rdata->pagesz = PAGE_SIZE;
2938                 rdata->read_into_pages = cifs_uncached_read_into_pages;
2939                 rdata->credits = credits;
2940
2941                 if (!rdata->cfile->invalidHandle ||
2942                     !cifs_reopen_file(rdata->cfile, true))
2943                         rc = server->ops->async_readv(rdata);
2944 error:
2945                 if (rc) {
2946                         add_credits_and_wake_if(server, rdata->credits, 0);
2947                         kref_put(&rdata->refcount,
2948                                  cifs_uncached_readdata_release);
2949                         if (rc == -EAGAIN)
2950                                 continue;
2951                         break;
2952                 }
2953
2954                 list_add_tail(&rdata->list, rdata_list);
2955                 offset += cur_len;
2956                 len -= cur_len;
2957         } while (len > 0);
2958
2959         return rc;
2960 }
2961
2962 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
2963 {
2964         struct file *file = iocb->ki_filp;
2965         ssize_t rc;
2966         size_t len;
2967         ssize_t total_read = 0;
2968         loff_t offset = iocb->ki_pos;
2969         struct cifs_sb_info *cifs_sb;
2970         struct cifs_tcon *tcon;
2971         struct cifsFileInfo *open_file;
2972         struct cifs_readdata *rdata, *tmp;
2973         struct list_head rdata_list;
2974
2975         len = iov_iter_count(to);
2976         if (!len)
2977                 return 0;
2978
2979         INIT_LIST_HEAD(&rdata_list);
2980         cifs_sb = CIFS_FILE_SB(file);
2981         open_file = file->private_data;
2982         tcon = tlink_tcon(open_file->tlink);
2983
2984         if (!tcon->ses->server->ops->async_readv)
2985                 return -ENOSYS;
2986
2987         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2988                 cifs_dbg(FYI, "attempting read on write only file instance\n");
2989
2990         rc = cifs_send_async_read(offset, len, open_file, cifs_sb, &rdata_list);
2991
2992         /* if at least one read request send succeeded, then reset rc */
2993         if (!list_empty(&rdata_list))
2994                 rc = 0;
2995
2996         len = iov_iter_count(to);
2997         /* the loop below should proceed in the order of increasing offsets */
2998 again:
2999         list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
3000                 if (!rc) {
3001                         /* FIXME: freezable sleep too? */
3002                         rc = wait_for_completion_killable(&rdata->done);
3003                         if (rc)
3004                                 rc = -EINTR;
3005                         else if (rdata->result == -EAGAIN) {
3006                                 /* resend call if it's a retryable error */
3007                                 struct list_head tmp_list;
3008                                 unsigned int got_bytes = rdata->got_bytes;
3009
3010                                 list_del_init(&rdata->list);
3011                                 INIT_LIST_HEAD(&tmp_list);
3012
3013                                 /*
3014                                  * Got a part of data and then reconnect has
3015                                  * happened -- fill the buffer and continue
3016                                  * reading.
3017                                  */
3018                                 if (got_bytes && got_bytes < rdata->bytes) {
3019                                         rc = cifs_readdata_to_iov(rdata, to);
3020                                         if (rc) {
3021                                                 kref_put(&rdata->refcount,
3022                                                 cifs_uncached_readdata_release);
3023                                                 continue;
3024                                         }
3025                                 }
3026
3027                                 rc = cifs_send_async_read(
3028                                                 rdata->offset + got_bytes,
3029                                                 rdata->bytes - got_bytes,
3030                                                 rdata->cfile, cifs_sb,
3031                                                 &tmp_list);
3032
3033                                 list_splice(&tmp_list, &rdata_list);
3034
3035                                 kref_put(&rdata->refcount,
3036                                          cifs_uncached_readdata_release);
3037                                 goto again;
3038                         } else if (rdata->result)
3039                                 rc = rdata->result;
3040                         else
3041                                 rc = cifs_readdata_to_iov(rdata, to);
3042
3043                         /* if there was a short read -- discard anything left */
3044                         if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3045                                 rc = -ENODATA;
3046                 }
3047                 list_del_init(&rdata->list);
3048                 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3049         }
3050
3051         total_read = len - iov_iter_count(to);
3052
3053         cifs_stats_bytes_read(tcon, total_read);
3054
3055         /* mask nodata case */
3056         if (rc == -ENODATA)
3057                 rc = 0;
3058
3059         if (total_read) {
3060                 iocb->ki_pos += total_read;
3061                 return total_read;
3062         }
3063         return rc;
3064 }
3065
3066 ssize_t
3067 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3068 {
3069         struct inode *inode = file_inode(iocb->ki_filp);
3070         struct cifsInodeInfo *cinode = CIFS_I(inode);
3071         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3072         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3073                                                 iocb->ki_filp->private_data;
3074         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3075         int rc = -EACCES;
3076
3077         /*
3078          * In strict cache mode we need to read from the server all the time
3079          * if we don't have level II oplock because the server can delay mtime
3080          * change - so we can't make a decision about inode invalidating.
3081          * And we can also fail with pagereading if there are mandatory locks
3082          * on pages affected by this read but not on the region from pos to
3083          * pos+len-1.
3084          */
3085         if (!CIFS_CACHE_READ(cinode))
3086                 return cifs_user_readv(iocb, to);
3087
3088         if (cap_unix(tcon->ses) &&
3089             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3090             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3091                 return generic_file_read_iter(iocb, to);
3092
3093         /*
3094          * We need to hold the sem to be sure nobody modifies lock list
3095          * with a brlock that prevents reading.
3096          */
3097         down_read(&cinode->lock_sem);
3098         if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3099                                      tcon->ses->server->vals->shared_lock_type,
3100                                      NULL, CIFS_READ_OP))
3101                 rc = generic_file_read_iter(iocb, to);
3102         up_read(&cinode->lock_sem);
3103         return rc;
3104 }
3105
3106 static ssize_t
3107 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3108 {
3109         int rc = -EACCES;
3110         unsigned int bytes_read = 0;
3111         unsigned int total_read;
3112         unsigned int current_read_size;
3113         unsigned int rsize;
3114         struct cifs_sb_info *cifs_sb;
3115         struct cifs_tcon *tcon;
3116         struct TCP_Server_Info *server;
3117         unsigned int xid;
3118         char *cur_offset;
3119         struct cifsFileInfo *open_file;
3120         struct cifs_io_parms io_parms;
3121         int buf_type = CIFS_NO_BUFFER;
3122         __u32 pid;
3123
3124         xid = get_xid();
3125         cifs_sb = CIFS_FILE_SB(file);
3126
3127         /* FIXME: set up handlers for larger reads and/or convert to async */
3128         rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3129
3130         if (file->private_data == NULL) {
3131                 rc = -EBADF;
3132                 free_xid(xid);
3133                 return rc;
3134         }
3135         open_file = file->private_data;
3136         tcon = tlink_tcon(open_file->tlink);
3137         server = tcon->ses->server;
3138
3139         if (!server->ops->sync_read) {
3140                 free_xid(xid);
3141                 return -ENOSYS;
3142         }
3143
3144         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3145                 pid = open_file->pid;
3146         else
3147                 pid = current->tgid;
3148
3149         if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3150                 cifs_dbg(FYI, "attempting read on write only file instance\n");
3151
3152         for (total_read = 0, cur_offset = read_data; read_size > total_read;
3153              total_read += bytes_read, cur_offset += bytes_read) {
3154                 do {
3155                         current_read_size = min_t(uint, read_size - total_read,
3156                                                   rsize);
3157                         /*
3158                          * For windows me and 9x we do not want to request more
3159                          * than it negotiated since it will refuse the read
3160                          * then.
3161                          */
3162                         if ((tcon->ses) && !(tcon->ses->capabilities &
3163                                 tcon->ses->server->vals->cap_large_files)) {
3164                                 current_read_size = min_t(uint,
3165                                         current_read_size, CIFSMaxBufSize);
3166                         }
3167                         if (open_file->invalidHandle) {
3168                                 rc = cifs_reopen_file(open_file, true);
3169                                 if (rc != 0)
3170                                         break;
3171                         }
3172                         io_parms.pid = pid;
3173                         io_parms.tcon = tcon;
3174                         io_parms.offset = *offset;
3175                         io_parms.length = current_read_size;
3176                         rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3177                                                     &bytes_read, &cur_offset,
3178                                                     &buf_type);
3179                 } while (rc == -EAGAIN);
3180
3181                 if (rc || (bytes_read == 0)) {
3182                         if (total_read) {
3183                                 break;
3184                         } else {
3185                                 free_xid(xid);
3186                                 return rc;
3187                         }
3188                 } else {
3189                         cifs_stats_bytes_read(tcon, total_read);
3190                         *offset += bytes_read;
3191                 }
3192         }
3193         free_xid(xid);
3194         return total_read;
3195 }
3196
3197 /*
3198  * If the page is mmap'ed into a process' page tables, then we need to make
3199  * sure that it doesn't change while being written back.
3200  */
3201 static int
3202 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3203 {
3204         struct page *page = vmf->page;
3205
3206         lock_page(page);
3207         return VM_FAULT_LOCKED;
3208 }
3209
3210 static const struct vm_operations_struct cifs_file_vm_ops = {
3211         .fault = filemap_fault,
3212         .map_pages = filemap_map_pages,
3213         .page_mkwrite = cifs_page_mkwrite,
3214 };
3215
3216 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3217 {
3218         int rc, xid;
3219         struct inode *inode = file_inode(file);
3220
3221         xid = get_xid();
3222
3223         if (!CIFS_CACHE_READ(CIFS_I(inode))) {
3224                 rc = cifs_zap_mapping(inode);
3225                 if (rc)
3226                         return rc;
3227         }
3228
3229         rc = generic_file_mmap(file, vma);
3230         if (rc == 0)
3231                 vma->vm_ops = &cifs_file_vm_ops;
3232         free_xid(xid);
3233         return rc;
3234 }
3235
3236 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3237 {
3238         int rc, xid;
3239
3240         xid = get_xid();
3241         rc = cifs_revalidate_file(file);
3242         if (rc) {
3243                 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3244                          rc);
3245                 free_xid(xid);
3246                 return rc;
3247         }
3248         rc = generic_file_mmap(file, vma);
3249         if (rc == 0)
3250                 vma->vm_ops = &cifs_file_vm_ops;
3251         free_xid(xid);
3252         return rc;
3253 }
3254
3255 static void
3256 cifs_readv_complete(struct work_struct *work)
3257 {
3258         unsigned int i, got_bytes;
3259         struct cifs_readdata *rdata = container_of(work,
3260                                                 struct cifs_readdata, work);
3261
3262         got_bytes = rdata->got_bytes;
3263         for (i = 0; i < rdata->nr_pages; i++) {
3264                 struct page *page = rdata->pages[i];
3265
3266                 lru_cache_add_file(page);
3267
3268                 if (rdata->result == 0 ||
3269                     (rdata->result == -EAGAIN && got_bytes)) {
3270                         flush_dcache_page(page);
3271                         SetPageUptodate(page);
3272                 }
3273
3274                 unlock_page(page);
3275
3276                 if (rdata->result == 0 ||
3277                     (rdata->result == -EAGAIN && got_bytes))
3278                         cifs_readpage_to_fscache(rdata->mapping->host, page);
3279
3280                 got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
3281
3282                 put_page(page);
3283                 rdata->pages[i] = NULL;
3284         }
3285         kref_put(&rdata->refcount, cifs_readdata_release);
3286 }
3287
3288 static int
3289 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3290                         struct cifs_readdata *rdata, unsigned int len)
3291 {
3292         int result = 0;
3293         unsigned int i;
3294         u64 eof;
3295         pgoff_t eof_index;
3296         unsigned int nr_pages = rdata->nr_pages;
3297
3298         /* determine the eof that the server (probably) has */
3299         eof = CIFS_I(rdata->mapping->host)->server_eof;
3300         eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
3301         cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
3302
3303         rdata->got_bytes = 0;
3304         rdata->tailsz = PAGE_SIZE;
3305         for (i = 0; i < nr_pages; i++) {
3306                 struct page *page = rdata->pages[i];
3307                 size_t n = PAGE_SIZE;
3308
3309                 if (len >= PAGE_SIZE) {
3310                         len -= PAGE_SIZE;
3311                 } else if (len > 0) {
3312                         /* enough for partial page, fill and zero the rest */
3313                         zero_user(page, len, PAGE_SIZE - len);
3314                         n = rdata->tailsz = len;
3315                         len = 0;
3316                 } else if (page->index > eof_index) {
3317                         /*
3318                          * The VFS will not try to do readahead past the
3319                          * i_size, but it's possible that we have outstanding
3320                          * writes with gaps in the middle and the i_size hasn't
3321                          * caught up yet. Populate those with zeroed out pages
3322                          * to prevent the VFS from repeatedly attempting to
3323                          * fill them until the writes are flushed.
3324                          */
3325                         zero_user(page, 0, PAGE_SIZE);
3326                         lru_cache_add_file(page);
3327                         flush_dcache_page(page);
3328                         SetPageUptodate(page);
3329                         unlock_page(page);
3330                         put_page(page);
3331                         rdata->pages[i] = NULL;
3332                         rdata->nr_pages--;
3333                         continue;
3334                 } else {
3335                         /* no need to hold page hostage */
3336                         lru_cache_add_file(page);
3337                         unlock_page(page);
3338                         put_page(page);
3339                         rdata->pages[i] = NULL;
3340                         rdata->nr_pages--;
3341                         continue;
3342                 }
3343
3344                 result = cifs_read_page_from_socket(server, page, n);
3345                 if (result < 0)
3346                         break;
3347
3348                 rdata->got_bytes += result;
3349         }
3350
3351         return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3352                                                 rdata->got_bytes : result;
3353 }
3354
3355 static int
3356 readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
3357                     unsigned int rsize, struct list_head *tmplist,
3358                     unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
3359 {
3360         struct page *page, *tpage;
3361         unsigned int expected_index;
3362         int rc;
3363         gfp_t gfp = readahead_gfp_mask(mapping);
3364
3365         INIT_LIST_HEAD(tmplist);
3366
3367         page = list_entry(page_list->prev, struct page, lru);
3368
3369         /*
3370          * Lock the page and put it in the cache. Since no one else
3371          * should have access to this page, we're safe to simply set
3372          * PG_locked without checking it first.
3373          */
3374         __SetPageLocked(page);
3375         rc = add_to_page_cache_locked(page, mapping,
3376                                       page->index, gfp);
3377
3378         /* give up if we can't stick it in the cache */
3379         if (rc) {
3380                 __ClearPageLocked(page);
3381                 return rc;
3382         }
3383
3384         /* move first page to the tmplist */
3385         *offset = (loff_t)page->index << PAGE_SHIFT;
3386         *bytes = PAGE_SIZE;
3387         *nr_pages = 1;
3388         list_move_tail(&page->lru, tmplist);
3389
3390         /* now try and add more pages onto the request */
3391         expected_index = page->index + 1;
3392         list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3393                 /* discontinuity ? */
3394                 if (page->index != expected_index)
3395                         break;
3396
3397                 /* would this page push the read over the rsize? */
3398                 if (*bytes + PAGE_SIZE > rsize)
3399                         break;
3400
3401                 __SetPageLocked(page);
3402                 if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
3403                         __ClearPageLocked(page);
3404                         break;
3405                 }
3406                 list_move_tail(&page->lru, tmplist);
3407                 (*bytes) += PAGE_SIZE;
3408                 expected_index++;
3409                 (*nr_pages)++;
3410         }
3411         return rc;
3412 }
3413
3414 static int cifs_readpages(struct file *file, struct address_space *mapping,
3415         struct list_head *page_list, unsigned num_pages)
3416 {
3417         int rc;
3418         struct list_head tmplist;
3419         struct cifsFileInfo *open_file = file->private_data;
3420         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
3421         struct TCP_Server_Info *server;
3422         pid_t pid;
3423
3424         /*
3425          * Reads as many pages as possible from fscache. Returns -ENOBUFS
3426          * immediately if the cookie is negative
3427          *
3428          * After this point, every page in the list might have PG_fscache set,
3429          * so we will need to clean that up off of every page we don't use.
3430          */
3431         rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3432                                          &num_pages);
3433         if (rc == 0)
3434                 return rc;
3435
3436         if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3437                 pid = open_file->pid;
3438         else
3439                 pid = current->tgid;
3440
3441         rc = 0;
3442         server = tlink_tcon(open_file->tlink)->ses->server;
3443
3444         cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3445                  __func__, file, mapping, num_pages);
3446
3447         /*
3448          * Start with the page at end of list and move it to private
3449          * list. Do the same with any following pages until we hit
3450          * the rsize limit, hit an index discontinuity, or run out of
3451          * pages. Issue the async read and then start the loop again
3452          * until the list is empty.
3453          *
3454          * Note that list order is important. The page_list is in
3455          * the order of declining indexes. When we put the pages in
3456          * the rdata->pages, then we want them in increasing order.
3457          */
3458         while (!list_empty(page_list)) {
3459                 unsigned int i, nr_pages, bytes, rsize;
3460                 loff_t offset;
3461                 struct page *page, *tpage;
3462                 struct cifs_readdata *rdata;
3463                 unsigned credits;
3464
3465                 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3466                                                    &rsize, &credits);
3467                 if (rc)
3468                         break;
3469
3470                 /*
3471                  * Give up immediately if rsize is too small to read an entire
3472                  * page. The VFS will fall back to readpage. We should never
3473                  * reach this point however since we set ra_pages to 0 when the
3474                  * rsize is smaller than a cache page.
3475                  */
3476                 if (unlikely(rsize < PAGE_SIZE)) {
3477                         add_credits_and_wake_if(server, credits, 0);
3478                         return 0;
3479                 }
3480
3481                 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
3482                                          &nr_pages, &offset, &bytes);
3483                 if (rc) {
3484                         add_credits_and_wake_if(server, credits, 0);
3485                         break;
3486                 }
3487
3488                 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3489                 if (!rdata) {
3490                         /* best to give up if we're out of mem */
3491                         list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3492                                 list_del(&page->lru);
3493                                 lru_cache_add_file(page);
3494                                 unlock_page(page);
3495                                 put_page(page);
3496                         }
3497                         rc = -ENOMEM;
3498                         add_credits_and_wake_if(server, credits, 0);
3499                         break;
3500                 }
3501
3502                 rdata->cfile = cifsFileInfo_get(open_file);
3503                 rdata->mapping = mapping;
3504                 rdata->offset = offset;
3505                 rdata->bytes = bytes;
3506                 rdata->pid = pid;
3507                 rdata->pagesz = PAGE_SIZE;
3508                 rdata->read_into_pages = cifs_readpages_read_into_pages;
3509                 rdata->credits = credits;
3510
3511                 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3512                         list_del(&page->lru);
3513                         rdata->pages[rdata->nr_pages++] = page;
3514                 }
3515
3516                 if (!rdata->cfile->invalidHandle ||
3517                     !cifs_reopen_file(rdata->cfile, true))
3518                         rc = server->ops->async_readv(rdata);
3519                 if (rc) {
3520                         add_credits_and_wake_if(server, rdata->credits, 0);
3521                         for (i = 0; i < rdata->nr_pages; i++) {
3522                                 page = rdata->pages[i];
3523                                 lru_cache_add_file(page);
3524                                 unlock_page(page);
3525                                 put_page(page);
3526                         }
3527                         /* Fallback to the readpage in error/reconnect cases */
3528                         kref_put(&rdata->refcount, cifs_readdata_release);
3529                         break;
3530                 }
3531
3532                 kref_put(&rdata->refcount, cifs_readdata_release);
3533         }
3534
3535         /* Any pages that have been shown to fscache but didn't get added to
3536          * the pagecache must be uncached before they get returned to the
3537          * allocator.
3538          */
3539         cifs_fscache_readpages_cancel(mapping->host, page_list);
3540         return rc;
3541 }
3542
3543 /*
3544  * cifs_readpage_worker must be called with the page pinned
3545  */
3546 static int cifs_readpage_worker(struct file *file, struct page *page,
3547         loff_t *poffset)
3548 {
3549         char *read_data;
3550         int rc;
3551
3552         /* Is the page cached? */
3553         rc = cifs_readpage_from_fscache(file_inode(file), page);
3554         if (rc == 0)
3555                 goto read_complete;
3556
3557         read_data = kmap(page);
3558         /* for reads over a certain size could initiate async read ahead */
3559
3560         rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
3561
3562         if (rc < 0)
3563                 goto io_error;
3564         else
3565                 cifs_dbg(FYI, "Bytes read %d\n", rc);
3566
3567         file_inode(file)->i_atime =
3568                 current_time(file_inode(file));
3569
3570         if (PAGE_SIZE > rc)
3571                 memset(read_data + rc, 0, PAGE_SIZE - rc);
3572
3573         flush_dcache_page(page);
3574         SetPageUptodate(page);
3575
3576         /* send this page to the cache */
3577         cifs_readpage_to_fscache(file_inode(file), page);
3578
3579         rc = 0;
3580
3581 io_error:
3582         kunmap(page);
3583         unlock_page(page);
3584
3585 read_complete:
3586         return rc;
3587 }
3588
3589 static int cifs_readpage(struct file *file, struct page *page)
3590 {
3591         loff_t offset = (loff_t)page->index << PAGE_SHIFT;
3592         int rc = -EACCES;
3593         unsigned int xid;
3594
3595         xid = get_xid();
3596
3597         if (file->private_data == NULL) {
3598                 rc = -EBADF;
3599                 free_xid(xid);
3600                 return rc;
3601         }
3602
3603         cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3604                  page, (int)offset, (int)offset);
3605
3606         rc = cifs_readpage_worker(file, page, &offset);
3607
3608         free_xid(xid);
3609         return rc;
3610 }
3611
3612 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3613 {
3614         struct cifsFileInfo *open_file;
3615
3616         spin_lock(&cifs_file_list_lock);
3617         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3618                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3619                         spin_unlock(&cifs_file_list_lock);
3620                         return 1;
3621                 }
3622         }
3623         spin_unlock(&cifs_file_list_lock);
3624         return 0;
3625 }
3626
3627 /* We do not want to update the file size from server for inodes
3628    open for write - to avoid races with writepage extending
3629    the file - in the future we could consider allowing
3630    refreshing the inode only on increases in the file size
3631    but this is tricky to do without racing with writebehind
3632    page caching in the current Linux kernel design */
3633 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3634 {
3635         if (!cifsInode)
3636                 return true;
3637
3638         if (is_inode_writable(cifsInode)) {
3639                 /* This inode is open for write at least once */
3640                 struct cifs_sb_info *cifs_sb;
3641
3642                 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3643                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3644                         /* since no page cache to corrupt on directio
3645                         we can change size safely */
3646                         return true;
3647                 }
3648
3649                 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3650                         return true;
3651
3652                 return false;
3653         } else
3654                 return true;
3655 }
3656
3657 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3658                         loff_t pos, unsigned len, unsigned flags,
3659                         struct page **pagep, void **fsdata)
3660 {
3661         int oncethru = 0;
3662         pgoff_t index = pos >> PAGE_SHIFT;
3663         loff_t offset = pos & (PAGE_SIZE - 1);
3664         loff_t page_start = pos & PAGE_MASK;
3665         loff_t i_size;
3666         struct page *page;
3667         int rc = 0;
3668
3669         cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
3670
3671 start:
3672         page = grab_cache_page_write_begin(mapping, index, flags);
3673         if (!page) {
3674                 rc = -ENOMEM;
3675                 goto out;
3676         }
3677
3678         if (PageUptodate(page))
3679                 goto out;
3680
3681         /*
3682          * If we write a full page it will be up to date, no need to read from
3683          * the server. If the write is short, we'll end up doing a sync write
3684          * instead.
3685          */
3686         if (len == PAGE_SIZE)
3687                 goto out;
3688
3689         /*
3690          * optimize away the read when we have an oplock, and we're not
3691          * expecting to use any of the data we'd be reading in. That
3692          * is, when the page lies beyond the EOF, or straddles the EOF
3693          * and the write will cover all of the existing data.
3694          */
3695         if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
3696                 i_size = i_size_read(mapping->host);
3697                 if (page_start >= i_size ||
3698                     (offset == 0 && (pos + len) >= i_size)) {
3699                         zero_user_segments(page, 0, offset,
3700                                            offset + len,
3701                                            PAGE_SIZE);
3702                         /*
3703                          * PageChecked means that the parts of the page
3704                          * to which we're not writing are considered up
3705                          * to date. Once the data is copied to the
3706                          * page, it can be set uptodate.
3707                          */
3708                         SetPageChecked(page);
3709                         goto out;
3710                 }
3711         }
3712
3713         if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
3714                 /*
3715                  * might as well read a page, it is fast enough. If we get
3716                  * an error, we don't need to return it. cifs_write_end will
3717                  * do a sync write instead since PG_uptodate isn't set.
3718                  */
3719                 cifs_readpage_worker(file, page, &page_start);
3720                 put_page(page);
3721                 oncethru = 1;
3722                 goto start;
3723         } else {
3724                 /* we could try using another file handle if there is one -
3725                    but how would we lock it to prevent close of that handle
3726                    racing with this read? In any case
3727                    this will be written out by write_end so is fine */
3728         }
3729 out:
3730         *pagep = page;
3731         return rc;
3732 }
3733
3734 static int cifs_release_page(struct page *page, gfp_t gfp)
3735 {
3736         if (PagePrivate(page))
3737                 return 0;
3738
3739         return cifs_fscache_release_page(page, gfp);
3740 }
3741
3742 static void cifs_invalidate_page(struct page *page, unsigned int offset,
3743                                  unsigned int length)
3744 {
3745         struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3746
3747         if (offset == 0 && length == PAGE_SIZE)
3748                 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3749 }
3750
3751 static int cifs_launder_page(struct page *page)
3752 {
3753         int rc = 0;
3754         loff_t range_start = page_offset(page);
3755         loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
3756         struct writeback_control wbc = {
3757                 .sync_mode = WB_SYNC_ALL,
3758                 .nr_to_write = 0,
3759                 .range_start = range_start,
3760                 .range_end = range_end,
3761         };
3762
3763         cifs_dbg(FYI, "Launder page: %p\n", page);
3764
3765         if (clear_page_dirty_for_io(page))
3766                 rc = cifs_writepage_locked(page, &wbc);
3767
3768         cifs_fscache_invalidate_page(page, page->mapping->host);
3769         return rc;
3770 }
3771
3772 void cifs_oplock_break(struct work_struct *work)
3773 {
3774         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3775                                                   oplock_break);
3776         struct inode *inode = d_inode(cfile->dentry);
3777         struct cifsInodeInfo *cinode = CIFS_I(inode);
3778         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3779         struct TCP_Server_Info *server = tcon->ses->server;
3780         int rc = 0;
3781
3782         wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
3783                         TASK_UNINTERRUPTIBLE);
3784
3785         server->ops->downgrade_oplock(server, cinode,
3786                 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
3787
3788         if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
3789                                                 cifs_has_mand_locks(cinode)) {
3790                 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3791                          inode);
3792                 cinode->oplock = 0;
3793         }
3794
3795         if (inode && S_ISREG(inode->i_mode)) {
3796                 if (CIFS_CACHE_READ(cinode))
3797                         break_lease(inode, O_RDONLY);
3798                 else
3799                         break_lease(inode, O_WRONLY);
3800                 rc = filemap_fdatawrite(inode->i_mapping);
3801                 if (!CIFS_CACHE_READ(cinode)) {
3802                         rc = filemap_fdatawait(inode->i_mapping);
3803                         mapping_set_error(inode->i_mapping, rc);
3804                         cifs_zap_mapping(inode);
3805                 }
3806                 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
3807         }
3808
3809         rc = cifs_push_locks(cfile);
3810         if (rc)
3811                 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
3812
3813         /*
3814          * releasing stale oplock after recent reconnect of smb session using
3815          * a now incorrect file handle is not a data integrity issue but do
3816          * not bother sending an oplock release if session to server still is
3817          * disconnected since oplock already released by the server
3818          */
3819         if (!cfile->oplock_break_cancelled) {
3820                 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3821                                                              cinode);
3822                 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
3823         }
3824         cifs_done_oplock_break(cinode);
3825 }
3826
3827 /*
3828  * The presence of cifs_direct_io() in the address space ops vector
3829  * allowes open() O_DIRECT flags which would have failed otherwise.
3830  *
3831  * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
3832  * so this method should never be called.
3833  *
3834  * Direct IO is not yet supported in the cached mode.
3835  */
3836 static ssize_t
3837 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
3838 {
3839         /*
3840          * FIXME
3841          * Eventually need to support direct IO for non forcedirectio mounts
3842          */
3843         return -EINVAL;
3844 }
3845
3846
3847 const struct address_space_operations cifs_addr_ops = {
3848         .readpage = cifs_readpage,
3849         .readpages = cifs_readpages,
3850         .writepage = cifs_writepage,
3851         .writepages = cifs_writepages,
3852         .write_begin = cifs_write_begin,
3853         .write_end = cifs_write_end,
3854         .set_page_dirty = __set_page_dirty_nobuffers,
3855         .releasepage = cifs_release_page,
3856         .direct_IO = cifs_direct_io,
3857         .invalidatepage = cifs_invalidate_page,
3858         .launder_page = cifs_launder_page,
3859 };
3860
3861 /*
3862  * cifs_readpages requires the server to support a buffer large enough to
3863  * contain the header plus one complete page of data.  Otherwise, we need
3864  * to leave cifs_readpages out of the address space operations.
3865  */
3866 const struct address_space_operations cifs_addr_ops_smallbuf = {
3867         .readpage = cifs_readpage,
3868         .writepage = cifs_writepage,
3869         .writepages = cifs_writepages,
3870         .write_begin = cifs_write_begin,
3871         .write_end = cifs_write_end,
3872         .set_page_dirty = __set_page_dirty_nobuffers,
3873         .releasepage = cifs_release_page,
3874         .invalidatepage = cifs_invalidate_page,
3875         .launder_page = cifs_launder_page,
3876 };