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