fs/smb/client/file.c

   1 // SPDX-License-Identifier: LGPL-2.1
   2 /*
   3  *
   4  *   vfs operations that deal with files
   5  *
   6  *   Copyright (C) International Business Machines  Corp., 2002,2010
   7  *   Author(s): Steve French ([email protected])
   8  *              Jeremy Allison ([email protected])
   9  *
  10  */
  11 #include <linux/fs.h>
  12 #include <linux/filelock.h>
  13 #include <linux/backing-dev.h>
  14 #include <linux/stat.h>
  15 #include <linux/fcntl.h>
  16 #include <linux/pagemap.h>
  17 #include <linux/pagevec.h>
  18 #include <linux/writeback.h>
  19 #include <linux/task_io_accounting_ops.h>
  20 #include <linux/delay.h>
  21 #include <linux/mount.h>
  22 #include <linux/slab.h>
  23 #include <linux/swap.h>
  24 #include <linux/mm.h>
  25 #include <asm/div64.h>
  26 #include "cifsfs.h"
  27 #include "cifspdu.h"
  28 #include "cifsglob.h"
  29 #include "cifsproto.h"
  30 #include "smb2proto.h"
  31 #include "cifs_unicode.h"
  32 #include "cifs_debug.h"
  33 #include "cifs_fs_sb.h"
  34 #include "fscache.h"
  35 #include "smbdirect.h"
  36 #include "fs_context.h"
  37 #include "cifs_ioctl.h"
  38 #include "cached_dir.h"
  39 #include <trace/events/netfs.h>
  40
  41 static int cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush);
  42
  43 /*
  44  * Prepare a subrequest to upload to the server.  We need to allocate credits
  45  * so that we know the maximum amount of data that we can include in it.
  46  */
  47 static void cifs_prepare_write(struct netfs_io_subrequest *subreq)
  48 {
  49         struct cifs_io_subrequest *wdata =
  50                 container_of(subreq, struct cifs_io_subrequest, subreq);
  51         struct cifs_io_request *req = wdata->req;
  52         struct netfs_io_stream *stream = &req->rreq.io_streams[subreq->stream_nr];
  53         struct TCP_Server_Info *server;
  54         struct cifsFileInfo *open_file = req->cfile;
  55         size_t wsize = req->rreq.wsize;
  56         int rc;
  57
  58         if (!wdata->have_xid) {
  59                 wdata->xid = get_xid();
  60                 wdata->have_xid = true;
  61         }
  62
  63         server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
  64         wdata->server = server;
  65
  66 retry:
  67         if (open_file->invalidHandle) {
  68                 rc = cifs_reopen_file(open_file, false);
  69                 if (rc < 0) {
  70                         if (rc == -EAGAIN)
  71                                 goto retry;
  72                         subreq->error = rc;
  73                         return netfs_prepare_write_failed(subreq);
  74                 }
  75         }
  76
  77         rc = server->ops->wait_mtu_credits(server, wsize, &stream->sreq_max_len,
  78                                            &wdata->credits);
  79         if (rc < 0) {
  80                 subreq->error = rc;
  81                 return netfs_prepare_write_failed(subreq);
  82         }
  83
  84         wdata->credits.rreq_debug_id = subreq->rreq->debug_id;
  85         wdata->credits.rreq_debug_index = subreq->debug_index;
  86         wdata->credits.in_flight_check = 1;
  87         trace_smb3_rw_credits(wdata->rreq->debug_id,
  88                               wdata->subreq.debug_index,
  89                               wdata->credits.value,
  90                               server->credits, server->in_flight,
  91                               wdata->credits.value,
  92                               cifs_trace_rw_credits_write_prepare);
  93
  94 #ifdef CONFIG_CIFS_SMB_DIRECT
  95         if (server->smbd_conn)
  96                 stream->sreq_max_segs = server->smbd_conn->max_frmr_depth;
  97 #endif
  98 }
  99
 100 /*
 101  * Issue a subrequest to upload to the server.
 102  */
 103 static void cifs_issue_write(struct netfs_io_subrequest *subreq)
 104 {
 105         struct cifs_io_subrequest *wdata =
 106                 container_of(subreq, struct cifs_io_subrequest, subreq);
 107         struct cifs_sb_info *sbi = CIFS_SB(subreq->rreq->inode->i_sb);
 108         int rc;
 109
 110         if (cifs_forced_shutdown(sbi)) {
 111                 rc = -EIO;
 112                 goto fail;
 113         }
 114
 115         rc = adjust_credits(wdata->server, wdata, cifs_trace_rw_credits_issue_write_adjust);
 116         if (rc)
 117                 goto fail;
 118
 119         rc = -EAGAIN;
 120         if (wdata->req->cfile->invalidHandle)
 121                 goto fail;
 122
 123         wdata->server->ops->async_writev(wdata);
 124 out:
 125         return;
 126
 127 fail:
 128         if (rc == -EAGAIN)
 129                 trace_netfs_sreq(subreq, netfs_sreq_trace_retry);
 130         else
 131                 trace_netfs_sreq(subreq, netfs_sreq_trace_fail);
 132         add_credits_and_wake_if(wdata->server, &wdata->credits, 0);
 133         cifs_write_subrequest_terminated(wdata, rc, false);
 134         goto out;
 135 }
 136
 137 static void cifs_netfs_invalidate_cache(struct netfs_io_request *wreq)
 138 {
 139         cifs_invalidate_cache(wreq->inode, 0);
 140 }
 141
 142 /*
 143  * Negotiate the size of a read operation on behalf of the netfs library.
 144  */
 145 static int cifs_prepare_read(struct netfs_io_subrequest *subreq)
 146 {
 147         struct netfs_io_request *rreq = subreq->rreq;
 148         struct cifs_io_subrequest *rdata = container_of(subreq, struct cifs_io_subrequest, subreq);
 149         struct cifs_io_request *req = container_of(subreq->rreq, struct cifs_io_request, rreq);
 150         struct TCP_Server_Info *server;
 151         struct cifs_sb_info *cifs_sb = CIFS_SB(rreq->inode->i_sb);
 152         size_t size;
 153         int rc = 0;
 154
 155         if (!rdata->have_xid) {
 156                 rdata->xid = get_xid();
 157                 rdata->have_xid = true;
 158         }
 159
 160         server = cifs_pick_channel(tlink_tcon(req->cfile->tlink)->ses);
 161         rdata->server = server;
 162
 163         if (cifs_sb->ctx->rsize == 0)
 164                 cifs_sb->ctx->rsize =
 165                         server->ops->negotiate_rsize(tlink_tcon(req->cfile->tlink),
 166                                                      cifs_sb->ctx);
 167
 168         rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
 169                                            &size, &rdata->credits);
 170         if (rc)
 171                 return rc;
 172
 173         rreq->io_streams[0].sreq_max_len = size;
 174
 175         rdata->credits.in_flight_check = 1;
 176         rdata->credits.rreq_debug_id = rreq->debug_id;
 177         rdata->credits.rreq_debug_index = subreq->debug_index;
 178
 179         trace_smb3_rw_credits(rdata->rreq->debug_id,
 180                               rdata->subreq.debug_index,
 181                               rdata->credits.value,
 182                               server->credits, server->in_flight, 0,
 183                               cifs_trace_rw_credits_read_submit);
 184
 185 #ifdef CONFIG_CIFS_SMB_DIRECT
 186         if (server->smbd_conn)
 187                 rreq->io_streams[0].sreq_max_segs = server->smbd_conn->max_frmr_depth;
 188 #endif
 189         return 0;
 190 }
 191
 192 /*
 193  * Issue a read operation on behalf of the netfs helper functions.  We're asked
 194  * to make a read of a certain size at a point in the file.  We are permitted
 195  * to only read a portion of that, but as long as we read something, the netfs
 196  * helper will call us again so that we can issue another read.
 197  */
 198 static void cifs_issue_read(struct netfs_io_subrequest *subreq)
 199 {
 200         struct netfs_io_request *rreq = subreq->rreq;
 201         struct cifs_io_subrequest *rdata = container_of(subreq, struct cifs_io_subrequest, subreq);
 202         struct cifs_io_request *req = container_of(subreq->rreq, struct cifs_io_request, rreq);
 203         struct TCP_Server_Info *server = rdata->server;
 204         int rc = 0;
 205
 206         cifs_dbg(FYI, "%s: op=%08x[%x] mapping=%p len=%zu/%zu\n",
 207                  __func__, rreq->debug_id, subreq->debug_index, rreq->mapping,
 208                  subreq->transferred, subreq->len);
 209
 210         rc = adjust_credits(server, rdata, cifs_trace_rw_credits_issue_read_adjust);
 211         if (rc)
 212                 goto failed;
 213
 214         if (req->cfile->invalidHandle) {
 215                 do {
 216                         rc = cifs_reopen_file(req->cfile, true);
 217                 } while (rc == -EAGAIN);
 218                 if (rc)
 219                         goto failed;
 220         }
 221
 222         if (subreq->rreq->origin != NETFS_DIO_READ)
 223                 __set_bit(NETFS_SREQ_CLEAR_TAIL, &subreq->flags);
 224
 225         trace_netfs_sreq(subreq, netfs_sreq_trace_submit);
 226         rc = rdata->server->ops->async_readv(rdata);
 227         if (rc)
 228                 goto failed;
 229         return;
 230
 231 failed:
 232         subreq->error = rc;
 233         netfs_read_subreq_terminated(subreq);
 234 }
 235
 236 /*
 237  * Writeback calls this when it finds a folio that needs uploading.  This isn't
 238  * called if writeback only has copy-to-cache to deal with.
 239  */
 240 static void cifs_begin_writeback(struct netfs_io_request *wreq)
 241 {
 242         struct cifs_io_request *req = container_of(wreq, struct cifs_io_request, rreq);
 243         int ret;
 244
 245         ret = cifs_get_writable_file(CIFS_I(wreq->inode), FIND_WR_ANY, &req->cfile);
 246         if (ret) {
 247                 cifs_dbg(VFS, "No writable handle in writepages ret=%d\n", ret);
 248                 return;
 249         }
 250
 251         wreq->io_streams[0].avail = true;
 252 }
 253
 254 /*
 255  * Initialise a request.
 256  */
 257 static int cifs_init_request(struct netfs_io_request *rreq, struct file *file)
 258 {
 259         struct cifs_io_request *req = container_of(rreq, struct cifs_io_request, rreq);
 260         struct cifs_sb_info *cifs_sb = CIFS_SB(rreq->inode->i_sb);
 261         struct cifsFileInfo *open_file = NULL;
 262
 263         rreq->rsize = cifs_sb->ctx->rsize;
 264         rreq->wsize = cifs_sb->ctx->wsize;
 265         req->pid = current->tgid; // Ummm...  This may be a workqueue
 266
 267         if (file) {
 268                 open_file = file->private_data;
 269                 rreq->netfs_priv = file->private_data;
 270                 req->cfile = cifsFileInfo_get(open_file);
 271                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
 272                         req->pid = req->cfile->pid;
 273         } else if (rreq->origin != NETFS_WRITEBACK) {
 274                 WARN_ON_ONCE(1);
 275                 return -EIO;
 276         }
 277
 278         return 0;
 279 }
 280
 281 /*
 282  * Completion of a request operation.
 283  */
 284 static void cifs_rreq_done(struct netfs_io_request *rreq)
 285 {
 286         struct timespec64 atime, mtime;
 287         struct inode *inode = rreq->inode;
 288
 289         /* we do not want atime to be less than mtime, it broke some apps */
 290         atime = inode_set_atime_to_ts(inode, current_time(inode));
 291         mtime = inode_get_mtime(inode);
 292         if (timespec64_compare(&atime, &mtime))
 293                 inode_set_atime_to_ts(inode, inode_get_mtime(inode));
 294 }
 295
 296 static void cifs_free_request(struct netfs_io_request *rreq)
 297 {
 298         struct cifs_io_request *req = container_of(rreq, struct cifs_io_request, rreq);
 299
 300         if (req->cfile)
 301                 cifsFileInfo_put(req->cfile);
 302 }
 303
 304 static void cifs_free_subrequest(struct netfs_io_subrequest *subreq)
 305 {
 306         struct cifs_io_subrequest *rdata =
 307                 container_of(subreq, struct cifs_io_subrequest, subreq);
 308         int rc = subreq->error;
 309
 310         if (rdata->subreq.source == NETFS_DOWNLOAD_FROM_SERVER) {
 311 #ifdef CONFIG_CIFS_SMB_DIRECT
 312                 if (rdata->mr) {
 313                         smbd_deregister_mr(rdata->mr);
 314                         rdata->mr = NULL;
 315                 }
 316 #endif
 317         }
 318
 319         if (rdata->credits.value != 0) {
 320                 trace_smb3_rw_credits(rdata->rreq->debug_id,
 321                                       rdata->subreq.debug_index,
 322                                       rdata->credits.value,
 323                                       rdata->server ? rdata->server->credits : 0,
 324                                       rdata->server ? rdata->server->in_flight : 0,
 325                                       -rdata->credits.value,
 326                                       cifs_trace_rw_credits_free_subreq);
 327                 if (rdata->server)
 328                         add_credits_and_wake_if(rdata->server, &rdata->credits, 0);
 329                 else
 330                         rdata->credits.value = 0;
 331         }
 332
 333         if (rdata->have_xid)
 334                 free_xid(rdata->xid);
 335 }
 336
 337 const struct netfs_request_ops cifs_req_ops = {
 338         .request_pool           = &cifs_io_request_pool,
 339         .subrequest_pool        = &cifs_io_subrequest_pool,
 340         .init_request           = cifs_init_request,
 341         .free_request           = cifs_free_request,
 342         .free_subrequest        = cifs_free_subrequest,
 343         .prepare_read           = cifs_prepare_read,
 344         .issue_read             = cifs_issue_read,
 345         .done                   = cifs_rreq_done,
 346         .begin_writeback        = cifs_begin_writeback,
 347         .prepare_write          = cifs_prepare_write,
 348         .issue_write            = cifs_issue_write,
 349         .invalidate_cache       = cifs_netfs_invalidate_cache,
 350 };
 351
 352 /*
 353  * Mark as invalid, all open files on tree connections since they
 354  * were closed when session to server was lost.
 355  */
 356 void
 357 cifs_mark_open_files_invalid(struct cifs_tcon *tcon)
 358 {
 359         struct cifsFileInfo *open_file = NULL;
 360         struct list_head *tmp;
 361         struct list_head *tmp1;
 362
 363         /* only send once per connect */
 364         spin_lock(&tcon->tc_lock);
 365         if (tcon->need_reconnect)
 366                 tcon->status = TID_NEED_RECON;
 367
 368         if (tcon->status != TID_NEED_RECON) {
 369                 spin_unlock(&tcon->tc_lock);
 370                 return;
 371         }
 372         tcon->status = TID_IN_FILES_INVALIDATE;
 373         spin_unlock(&tcon->tc_lock);
 374
 375         /* list all files open on tree connection and mark them invalid */
 376         spin_lock(&tcon->open_file_lock);
 377         list_for_each_safe(tmp, tmp1, &tcon->openFileList) {
 378                 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
 379                 open_file->invalidHandle = true;
 380                 open_file->oplock_break_cancelled = true;
 381         }
 382         spin_unlock(&tcon->open_file_lock);
 383
 384         invalidate_all_cached_dirs(tcon);
 385         spin_lock(&tcon->tc_lock);
 386         if (tcon->status == TID_IN_FILES_INVALIDATE)
 387                 tcon->status = TID_NEED_TCON;
 388         spin_unlock(&tcon->tc_lock);
 389
 390         /*
 391          * BB Add call to invalidate_inodes(sb) for all superblocks mounted
 392          * to this tcon.
 393          */
 394 }
 395
 396 static inline int cifs_convert_flags(unsigned int flags, int rdwr_for_fscache)
 397 {
 398         if ((flags & O_ACCMODE) == O_RDONLY)
 399                 return GENERIC_READ;
 400         else if ((flags & O_ACCMODE) == O_WRONLY)
 401                 return rdwr_for_fscache == 1 ? (GENERIC_READ | GENERIC_WRITE) : GENERIC_WRITE;
 402         else if ((flags & O_ACCMODE) == O_RDWR) {
 403                 /* GENERIC_ALL is too much permission to request
 404                    can cause unnecessary access denied on create */
 405                 /* return GENERIC_ALL; */
 406                 return (GENERIC_READ | GENERIC_WRITE);
 407         }
 408
 409         return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
 410                 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
 411                 FILE_READ_DATA);
 412 }
 413
 414 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 415 static u32 cifs_posix_convert_flags(unsigned int flags)
 416 {
 417         u32 posix_flags = 0;
 418
 419         if ((flags & O_ACCMODE) == O_RDONLY)
 420                 posix_flags = SMB_O_RDONLY;
 421         else if ((flags & O_ACCMODE) == O_WRONLY)
 422                 posix_flags = SMB_O_WRONLY;
 423         else if ((flags & O_ACCMODE) == O_RDWR)
 424                 posix_flags = SMB_O_RDWR;
 425
 426         if (flags & O_CREAT) {
 427                 posix_flags |= SMB_O_CREAT;
 428                 if (flags & O_EXCL)
 429                         posix_flags |= SMB_O_EXCL;
 430         } else if (flags & O_EXCL)
 431                 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
 432                          current->comm, current->tgid);
 433
 434         if (flags & O_TRUNC)
 435                 posix_flags |= SMB_O_TRUNC;
 436         /* be safe and imply O_SYNC for O_DSYNC */
 437         if (flags & O_DSYNC)
 438                 posix_flags |= SMB_O_SYNC;
 439         if (flags & O_DIRECTORY)
 440                 posix_flags |= SMB_O_DIRECTORY;
 441         if (flags & O_NOFOLLOW)
 442                 posix_flags |= SMB_O_NOFOLLOW;
 443         if (flags & O_DIRECT)
 444                 posix_flags |= SMB_O_DIRECT;
 445
 446         return posix_flags;
 447 }
 448 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 449
 450 static inline int cifs_get_disposition(unsigned int flags)
 451 {
 452         if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
 453                 return FILE_CREATE;
 454         else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
 455                 return FILE_OVERWRITE_IF;
 456         else if ((flags & O_CREAT) == O_CREAT)
 457                 return FILE_OPEN_IF;
 458         else if ((flags & O_TRUNC) == O_TRUNC)
 459                 return FILE_OVERWRITE;
 460         else
 461                 return FILE_OPEN;
 462 }
 463
 464 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
 465 int cifs_posix_open(const char *full_path, struct inode **pinode,
 466                         struct super_block *sb, int mode, unsigned int f_flags,
 467                         __u32 *poplock, __u16 *pnetfid, unsigned int xid)
 468 {
 469         int rc;
 470         FILE_UNIX_BASIC_INFO *presp_data;
 471         __u32 posix_flags = 0;
 472         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 473         struct cifs_fattr fattr;
 474         struct tcon_link *tlink;
 475         struct cifs_tcon *tcon;
 476
 477         cifs_dbg(FYI, "posix open %s\n", full_path);
 478
 479         presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
 480         if (presp_data == NULL)
 481                 return -ENOMEM;
 482
 483         tlink = cifs_sb_tlink(cifs_sb);
 484         if (IS_ERR(tlink)) {
 485                 rc = PTR_ERR(tlink);
 486                 goto posix_open_ret;
 487         }
 488
 489         tcon = tlink_tcon(tlink);
 490         mode &= ~current_umask();
 491
 492         posix_flags = cifs_posix_convert_flags(f_flags);
 493         rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
 494                              poplock, full_path, cifs_sb->local_nls,
 495                              cifs_remap(cifs_sb));
 496         cifs_put_tlink(tlink);
 497
 498         if (rc)
 499                 goto posix_open_ret;
 500
 501         if (presp_data->Type == cpu_to_le32(-1))
 502                 goto posix_open_ret; /* open ok, caller does qpathinfo */
 503
 504         if (!pinode)
 505                 goto posix_open_ret; /* caller does not need info */
 506
 507         cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
 508
 509         /* get new inode and set it up */
 510         if (*pinode == NULL) {
 511                 cifs_fill_uniqueid(sb, &fattr);
 512                 *pinode = cifs_iget(sb, &fattr);
 513                 if (!*pinode) {
 514                         rc = -ENOMEM;
 515                         goto posix_open_ret;
 516                 }
 517         } else {
 518                 cifs_revalidate_mapping(*pinode);
 519                 rc = cifs_fattr_to_inode(*pinode, &fattr, false);
 520         }
 521
 522 posix_open_ret:
 523         kfree(presp_data);
 524         return rc;
 525 }
 526 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
 527
 528 static int cifs_nt_open(const char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
 529                         struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
 530                         struct cifs_fid *fid, unsigned int xid, struct cifs_open_info_data *buf)
 531 {
 532         int rc;
 533         int desired_access;
 534         int disposition;
 535         int create_options = CREATE_NOT_DIR;
 536         struct TCP_Server_Info *server = tcon->ses->server;
 537         struct cifs_open_parms oparms;
 538         int rdwr_for_fscache = 0;
 539
 540         if (!server->ops->open)
 541                 return -ENOSYS;
 542
 543         /* If we're caching, we need to be able to fill in around partial writes. */
 544         if (cifs_fscache_enabled(inode) && (f_flags & O_ACCMODE) == O_WRONLY)
 545                 rdwr_for_fscache = 1;
 546
 547         desired_access = cifs_convert_flags(f_flags, rdwr_for_fscache);
 548
 549 /*********************************************************************
 550  *  open flag mapping table:
 551  *
 552  *      POSIX Flag            CIFS Disposition
 553  *      ----------            ----------------
 554  *      O_CREAT               FILE_OPEN_IF
 555  *      O_CREAT | O_EXCL      FILE_CREATE
 556  *      O_CREAT | O_TRUNC     FILE_OVERWRITE_IF
 557  *      O_TRUNC               FILE_OVERWRITE
 558  *      none of the above     FILE_OPEN
 559  *
 560  *      Note that there is not a direct match between disposition
 561  *      FILE_SUPERSEDE (ie create whether or not file exists although
 562  *      O_CREAT | O_TRUNC is similar but truncates the existing
 563  *      file rather than creating a new file as FILE_SUPERSEDE does
 564  *      (which uses the attributes / metadata passed in on open call)
 565  *?
 566  *?  O_SYNC is a reasonable match to CIFS writethrough flag
 567  *?  and the read write flags match reasonably.  O_LARGEFILE
 568  *?  is irrelevant because largefile support is always used
 569  *?  by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
 570  *       O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
 571  *********************************************************************/
 572
 573         disposition = cifs_get_disposition(f_flags);
 574
 575         /* BB pass O_SYNC flag through on file attributes .. BB */
 576
 577         /* O_SYNC also has bit for O_DSYNC so following check picks up either */
 578         if (f_flags & O_SYNC)
 579                 create_options |= CREATE_WRITE_THROUGH;
 580
 581         if (f_flags & O_DIRECT)
 582                 create_options |= CREATE_NO_BUFFER;
 583
 584 retry_open:
 585         oparms = (struct cifs_open_parms) {
 586                 .tcon = tcon,
 587                 .cifs_sb = cifs_sb,
 588                 .desired_access = desired_access,
 589                 .create_options = cifs_create_options(cifs_sb, create_options),
 590                 .disposition = disposition,
 591                 .path = full_path,
 592                 .fid = fid,
 593         };
 594
 595         rc = server->ops->open(xid, &oparms, oplock, buf);
 596         if (rc) {
 597                 if (rc == -EACCES && rdwr_for_fscache == 1) {
 598                         desired_access = cifs_convert_flags(f_flags, 0);
 599                         rdwr_for_fscache = 2;
 600                         goto retry_open;
 601                 }
 602                 return rc;
 603         }
 604         if (rdwr_for_fscache == 2)
 605                 cifs_invalidate_cache(inode, FSCACHE_INVAL_DIO_WRITE);
 606
 607         /* TODO: Add support for calling posix query info but with passing in fid */
 608         if (tcon->unix_ext)
 609                 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
 610                                               xid);
 611         else
 612                 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
 613                                          xid, fid);
 614
 615         if (rc) {
 616                 server->ops->close(xid, tcon, fid);
 617                 if (rc == -ESTALE)
 618                         rc = -EOPENSTALE;
 619         }
 620
 621         return rc;
 622 }
 623
 624 static bool
 625 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
 626 {
 627         struct cifs_fid_locks *cur;
 628         bool has_locks = false;
 629
 630         down_read(&cinode->lock_sem);
 631         list_for_each_entry(cur, &cinode->llist, llist) {
 632                 if (!list_empty(&cur->locks)) {
 633                         has_locks = true;
 634                         break;
 635                 }
 636         }
 637         up_read(&cinode->lock_sem);
 638         return has_locks;
 639 }
 640
 641 void
 642 cifs_down_write(struct rw_semaphore *sem)
 643 {
 644         while (!down_write_trylock(sem))
 645                 msleep(10);
 646 }
 647
 648 static void cifsFileInfo_put_work(struct work_struct *work);
 649 void serverclose_work(struct work_struct *work);
 650
 651 struct cifsFileInfo *cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
 652                                        struct tcon_link *tlink, __u32 oplock,
 653                                        const char *symlink_target)
 654 {
 655         struct dentry *dentry = file_dentry(file);
 656         struct inode *inode = d_inode(dentry);
 657         struct cifsInodeInfo *cinode = CIFS_I(inode);
 658         struct cifsFileInfo *cfile;
 659         struct cifs_fid_locks *fdlocks;
 660         struct cifs_tcon *tcon = tlink_tcon(tlink);
 661         struct TCP_Server_Info *server = tcon->ses->server;
 662
 663         cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
 664         if (cfile == NULL)
 665                 return cfile;
 666
 667         fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
 668         if (!fdlocks) {
 669                 kfree(cfile);
 670                 return NULL;
 671         }
 672
 673         if (symlink_target) {
 674                 cfile->symlink_target = kstrdup(symlink_target, GFP_KERNEL);
 675                 if (!cfile->symlink_target) {
 676                         kfree(fdlocks);
 677                         kfree(cfile);
 678                         return NULL;
 679                 }
 680         }
 681
 682         INIT_LIST_HEAD(&fdlocks->locks);
 683         fdlocks->cfile = cfile;
 684         cfile->llist = fdlocks;
 685
 686         cfile->count = 1;
 687         cfile->pid = current->tgid;
 688         cfile->uid = current_fsuid();
 689         cfile->dentry = dget(dentry);
 690         cfile->f_flags = file->f_flags;
 691         cfile->invalidHandle = false;
 692         cfile->deferred_close_scheduled = false;
 693         cfile->tlink = cifs_get_tlink(tlink);
 694         INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
 695         INIT_WORK(&cfile->put, cifsFileInfo_put_work);
 696         INIT_WORK(&cfile->serverclose, serverclose_work);
 697         INIT_DELAYED_WORK(&cfile->deferred, smb2_deferred_work_close);
 698         mutex_init(&cfile->fh_mutex);
 699         spin_lock_init(&cfile->file_info_lock);
 700
 701         cifs_sb_active(inode->i_sb);
 702
 703         /*
 704          * If the server returned a read oplock and we have mandatory brlocks,
 705          * set oplock level to None.
 706          */
 707         if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
 708                 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
 709                 oplock = 0;
 710         }
 711
 712         cifs_down_write(&cinode->lock_sem);
 713         list_add(&fdlocks->llist, &cinode->llist);
 714         up_write(&cinode->lock_sem);
 715
 716         spin_lock(&tcon->open_file_lock);
 717         if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
 718                 oplock = fid->pending_open->oplock;
 719         list_del(&fid->pending_open->olist);
 720
 721         fid->purge_cache = false;
 722         server->ops->set_fid(cfile, fid, oplock);
 723
 724         list_add(&cfile->tlist, &tcon->openFileList);
 725         atomic_inc(&tcon->num_local_opens);
 726
 727         /* if readable file instance put first in list*/
 728         spin_lock(&cinode->open_file_lock);
 729         if (file->f_mode & FMODE_READ)
 730                 list_add(&cfile->flist, &cinode->openFileList);
 731         else
 732                 list_add_tail(&cfile->flist, &cinode->openFileList);
 733         spin_unlock(&cinode->open_file_lock);
 734         spin_unlock(&tcon->open_file_lock);
 735
 736         if (fid->purge_cache)
 737                 cifs_zap_mapping(inode);
 738
 739         file->private_data = cfile;
 740         return cfile;
 741 }
 742
 743 struct cifsFileInfo *
 744 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
 745 {
 746         spin_lock(&cifs_file->file_info_lock);
 747         cifsFileInfo_get_locked(cifs_file);
 748         spin_unlock(&cifs_file->file_info_lock);
 749         return cifs_file;
 750 }
 751
 752 static void cifsFileInfo_put_final(struct cifsFileInfo *cifs_file)
 753 {
 754         struct inode *inode = d_inode(cifs_file->dentry);
 755         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 756         struct cifsLockInfo *li, *tmp;
 757         struct super_block *sb = inode->i_sb;
 758
 759         /*
 760          * Delete any outstanding lock records. We'll lose them when the file
 761          * is closed anyway.
 762          */
 763         cifs_down_write(&cifsi->lock_sem);
 764         list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
 765                 list_del(&li->llist);
 766                 cifs_del_lock_waiters(li);
 767                 kfree(li);
 768         }
 769         list_del(&cifs_file->llist->llist);
 770         kfree(cifs_file->llist);
 771         up_write(&cifsi->lock_sem);
 772
 773         cifs_put_tlink(cifs_file->tlink);
 774         dput(cifs_file->dentry);
 775         cifs_sb_deactive(sb);
 776         kfree(cifs_file->symlink_target);
 777         kfree(cifs_file);
 778 }
 779
 780 static void cifsFileInfo_put_work(struct work_struct *work)
 781 {
 782         struct cifsFileInfo *cifs_file = container_of(work,
 783                         struct cifsFileInfo, put);
 784
 785         cifsFileInfo_put_final(cifs_file);
 786 }
 787
 788 void serverclose_work(struct work_struct *work)
 789 {
 790         struct cifsFileInfo *cifs_file = container_of(work,
 791                         struct cifsFileInfo, serverclose);
 792
 793         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 794
 795         struct TCP_Server_Info *server = tcon->ses->server;
 796         int rc = 0;
 797         int retries = 0;
 798         int MAX_RETRIES = 4;
 799
 800         do {
 801                 if (server->ops->close_getattr)
 802                         rc = server->ops->close_getattr(0, tcon, cifs_file);
 803                 else if (server->ops->close)
 804                         rc = server->ops->close(0, tcon, &cifs_file->fid);
 805
 806                 if (rc == -EBUSY || rc == -EAGAIN) {
 807                         retries++;
 808                         msleep(250);
 809                 }
 810         } while ((rc == -EBUSY || rc == -EAGAIN) && (retries < MAX_RETRIES)
 811         );
 812
 813         if (retries == MAX_RETRIES)
 814                 pr_warn("Serverclose failed %d times, giving up\n", MAX_RETRIES);
 815
 816         if (cifs_file->offload)
 817                 queue_work(fileinfo_put_wq, &cifs_file->put);
 818         else
 819                 cifsFileInfo_put_final(cifs_file);
 820 }
 821
 822 /**
 823  * cifsFileInfo_put - release a reference of file priv data
 824  *
 825  * Always potentially wait for oplock handler. See _cifsFileInfo_put().
 826  *
 827  * @cifs_file:  cifs/smb3 specific info (eg refcounts) for an open file
 828  */
 829 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
 830 {
 831         _cifsFileInfo_put(cifs_file, true, true);
 832 }
 833
 834 /**
 835  * _cifsFileInfo_put - release a reference of file priv data
 836  *
 837  * This may involve closing the filehandle @cifs_file out on the
 838  * server. Must be called without holding tcon->open_file_lock,
 839  * cinode->open_file_lock and cifs_file->file_info_lock.
 840  *
 841  * If @wait_for_oplock_handler is true and we are releasing the last
 842  * reference, wait for any running oplock break handler of the file
 843  * and cancel any pending one.
 844  *
 845  * @cifs_file:  cifs/smb3 specific info (eg refcounts) for an open file
 846  * @wait_oplock_handler: must be false if called from oplock_break_handler
 847  * @offload:    not offloaded on close and oplock breaks
 848  *
 849  */
 850 void _cifsFileInfo_put(struct cifsFileInfo *cifs_file,
 851                        bool wait_oplock_handler, bool offload)
 852 {
 853         struct inode *inode = d_inode(cifs_file->dentry);
 854         struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
 855         struct TCP_Server_Info *server = tcon->ses->server;
 856         struct cifsInodeInfo *cifsi = CIFS_I(inode);
 857         struct super_block *sb = inode->i_sb;
 858         struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
 859         struct cifs_fid fid = {};
 860         struct cifs_pending_open open;
 861         bool oplock_break_cancelled;
 862         bool serverclose_offloaded = false;
 863
 864         spin_lock(&tcon->open_file_lock);
 865         spin_lock(&cifsi->open_file_lock);
 866         spin_lock(&cifs_file->file_info_lock);
 867
 868         cifs_file->offload = offload;
 869         if (--cifs_file->count > 0) {
 870                 spin_unlock(&cifs_file->file_info_lock);
 871                 spin_unlock(&cifsi->open_file_lock);
 872                 spin_unlock(&tcon->open_file_lock);
 873                 return;
 874         }
 875         spin_unlock(&cifs_file->file_info_lock);
 876
 877         if (server->ops->get_lease_key)
 878                 server->ops->get_lease_key(inode, &fid);
 879
 880         /* store open in pending opens to make sure we don't miss lease break */
 881         cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
 882
 883         /* remove it from the lists */
 884         list_del(&cifs_file->flist);
 885         list_del(&cifs_file->tlist);
 886         atomic_dec(&tcon->num_local_opens);
 887
 888         if (list_empty(&cifsi->openFileList)) {
 889                 cifs_dbg(FYI, "closing last open instance for inode %p\n",
 890                          d_inode(cifs_file->dentry));
 891                 /*
 892                  * In strict cache mode we need invalidate mapping on the last
 893                  * close  because it may cause a error when we open this file
 894                  * again and get at least level II oplock.
 895                  */
 896                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
 897                         set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
 898                 cifs_set_oplock_level(cifsi, 0);
 899         }
 900
 901         spin_unlock(&cifsi->open_file_lock);
 902         spin_unlock(&tcon->open_file_lock);
 903
 904         oplock_break_cancelled = wait_oplock_handler ?
 905                 cancel_work_sync(&cifs_file->oplock_break) : false;
 906
 907         if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
 908                 struct TCP_Server_Info *server = tcon->ses->server;
 909                 unsigned int xid;
 910                 int rc = 0;
 911
 912                 xid = get_xid();
 913                 if (server->ops->close_getattr)
 914                         rc = server->ops->close_getattr(xid, tcon, cifs_file);
 915                 else if (server->ops->close)
 916                         rc = server->ops->close(xid, tcon, &cifs_file->fid);
 917                 _free_xid(xid);
 918
 919                 if (rc == -EBUSY || rc == -EAGAIN) {
 920                         // Server close failed, hence offloading it as an async op
 921                         queue_work(serverclose_wq, &cifs_file->serverclose);
 922                         serverclose_offloaded = true;
 923                 }
 924         }
 925
 926         if (oplock_break_cancelled)
 927                 cifs_done_oplock_break(cifsi);
 928
 929         cifs_del_pending_open(&open);
 930
 931         // if serverclose has been offloaded to wq (on failure), it will
 932         // handle offloading put as well. If serverclose not offloaded,
 933         // we need to handle offloading put here.
 934         if (!serverclose_offloaded) {
 935                 if (offload)
 936                         queue_work(fileinfo_put_wq, &cifs_file->put);
 937                 else
 938                         cifsFileInfo_put_final(cifs_file);
 939         }
 940 }
 941
 942 int cifs_open(struct inode *inode, struct file *file)
 943
 944 {
 945         int rc = -EACCES;
 946         unsigned int xid;
 947         __u32 oplock;
 948         struct cifs_sb_info *cifs_sb;
 949         struct TCP_Server_Info *server;
 950         struct cifs_tcon *tcon;
 951         struct tcon_link *tlink;
 952         struct cifsFileInfo *cfile = NULL;
 953         void *page;
 954         const char *full_path;
 955         bool posix_open_ok = false;
 956         struct cifs_fid fid = {};
 957         struct cifs_pending_open open;
 958         struct cifs_open_info_data data = {};
 959
 960         xid = get_xid();
 961
 962         cifs_sb = CIFS_SB(inode->i_sb);
 963         if (unlikely(cifs_forced_shutdown(cifs_sb))) {
 964                 free_xid(xid);
 965                 return -EIO;
 966         }
 967
 968         tlink = cifs_sb_tlink(cifs_sb);
 969         if (IS_ERR(tlink)) {
 970                 free_xid(xid);
 971                 return PTR_ERR(tlink);
 972         }
 973         tcon = tlink_tcon(tlink);
 974         server = tcon->ses->server;
 975
 976         page = alloc_dentry_path();
 977         full_path = build_path_from_dentry(file_dentry(file), page);
 978         if (IS_ERR(full_path)) {
 979                 rc = PTR_ERR(full_path);
 980                 goto out;
 981         }
 982
 983         cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
 984                  inode, file->f_flags, full_path);
 985
 986         if (file->f_flags & O_DIRECT &&
 987             cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
 988                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
 989                         file->f_op = &cifs_file_direct_nobrl_ops;
 990                 else
 991                         file->f_op = &cifs_file_direct_ops;
 992         }
 993
 994         /* Get the cached handle as SMB2 close is deferred */
 995         if (OPEN_FMODE(file->f_flags) & FMODE_WRITE) {
 996                 rc = cifs_get_writable_path(tcon, full_path, FIND_WR_FSUID_ONLY, &cfile);
 997         } else {
 998                 rc = cifs_get_readable_path(tcon, full_path, &cfile);
 999         }
1000         if (rc == 0) {
1001                 if (file->f_flags == cfile->f_flags) {
1002                         file->private_data = cfile;
1003                         spin_lock(&CIFS_I(inode)->deferred_lock);
1004                         cifs_del_deferred_close(cfile);
1005                         spin_unlock(&CIFS_I(inode)->deferred_lock);
1006                         goto use_cache;
1007                 } else {
1008                         _cifsFileInfo_put(cfile, true, false);
1009                 }
1010         }
1011
1012         if (server->oplocks)
1013                 oplock = REQ_OPLOCK;
1014         else
1015                 oplock = 0;
1016
1017 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1018         if (!tcon->broken_posix_open && tcon->unix_ext &&
1019             cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1020                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1021                 /* can not refresh inode info since size could be stale */
1022                 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
1023                                 cifs_sb->ctx->file_mode /* ignored */,
1024                                 file->f_flags, &oplock, &fid.netfid, xid);
1025                 if (rc == 0) {
1026                         cifs_dbg(FYI, "posix open succeeded\n");
1027                         posix_open_ok = true;
1028                 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
1029                         if (tcon->ses->serverNOS)
1030                                 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",
1031                                          tcon->ses->ip_addr,
1032                                          tcon->ses->serverNOS);
1033                         tcon->broken_posix_open = true;
1034                 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
1035                          (rc != -EOPNOTSUPP)) /* path not found or net err */
1036                         goto out;
1037                 /*
1038                  * Else fallthrough to retry open the old way on network i/o
1039                  * or DFS errors.
1040                  */
1041         }
1042 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1043
1044         if (server->ops->get_lease_key)
1045                 server->ops->get_lease_key(inode, &fid);
1046
1047         cifs_add_pending_open(&fid, tlink, &open);
1048
1049         if (!posix_open_ok) {
1050                 if (server->ops->get_lease_key)
1051                         server->ops->get_lease_key(inode, &fid);
1052
1053                 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon, file->f_flags, &oplock, &fid,
1054                                   xid, &data);
1055                 if (rc) {
1056                         cifs_del_pending_open(&open);
1057                         goto out;
1058                 }
1059         }
1060
1061         cfile = cifs_new_fileinfo(&fid, file, tlink, oplock, data.symlink_target);
1062         if (cfile == NULL) {
1063                 if (server->ops->close)
1064                         server->ops->close(xid, tcon, &fid);
1065                 cifs_del_pending_open(&open);
1066                 rc = -ENOMEM;
1067                 goto out;
1068         }
1069
1070 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1071         if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
1072                 /*
1073                  * Time to set mode which we can not set earlier due to
1074                  * problems creating new read-only files.
1075                  */
1076                 struct cifs_unix_set_info_args args = {
1077                         .mode   = inode->i_mode,
1078                         .uid    = INVALID_UID, /* no change */
1079                         .gid    = INVALID_GID, /* no change */
1080                         .ctime  = NO_CHANGE_64,
1081                         .atime  = NO_CHANGE_64,
1082                         .mtime  = NO_CHANGE_64,
1083                         .device = 0,
1084                 };
1085                 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
1086                                        cfile->pid);
1087         }
1088 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1089
1090 use_cache:
1091         fscache_use_cookie(cifs_inode_cookie(file_inode(file)),
1092                            file->f_mode & FMODE_WRITE);
1093         if (!(file->f_flags & O_DIRECT))
1094                 goto out;
1095         if ((file->f_flags & (O_ACCMODE | O_APPEND)) == O_RDONLY)
1096                 goto out;
1097         cifs_invalidate_cache(file_inode(file), FSCACHE_INVAL_DIO_WRITE);
1098
1099 out:
1100         free_dentry_path(page);
1101         free_xid(xid);
1102         cifs_put_tlink(tlink);
1103         cifs_free_open_info(&data);
1104         return rc;
1105 }
1106
1107 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1108 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
1109 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1110
1111 /*
1112  * Try to reacquire byte range locks that were released when session
1113  * to server was lost.
1114  */
1115 static int
1116 cifs_relock_file(struct cifsFileInfo *cfile)
1117 {
1118         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1119         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1120         int rc = 0;
1121 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1122         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1123 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1124
1125         down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
1126         if (cinode->can_cache_brlcks) {
1127                 /* can cache locks - no need to relock */
1128                 up_read(&cinode->lock_sem);
1129                 return rc;
1130         }
1131
1132 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1133         if (cap_unix(tcon->ses) &&
1134             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1135             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1136                 rc = cifs_push_posix_locks(cfile);
1137         else
1138 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1139                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1140
1141         up_read(&cinode->lock_sem);
1142         return rc;
1143 }
1144
1145 static int
1146 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
1147 {
1148         int rc = -EACCES;
1149         unsigned int xid;
1150         __u32 oplock;
1151         struct cifs_sb_info *cifs_sb;
1152         struct cifs_tcon *tcon;
1153         struct TCP_Server_Info *server;
1154         struct cifsInodeInfo *cinode;
1155         struct inode *inode;
1156         void *page;
1157         const char *full_path;
1158         int desired_access;
1159         int disposition = FILE_OPEN;
1160         int create_options = CREATE_NOT_DIR;
1161         struct cifs_open_parms oparms;
1162         int rdwr_for_fscache = 0;
1163
1164         xid = get_xid();
1165         mutex_lock(&cfile->fh_mutex);
1166         if (!cfile->invalidHandle) {
1167                 mutex_unlock(&cfile->fh_mutex);
1168                 free_xid(xid);
1169                 return 0;
1170         }
1171
1172         inode = d_inode(cfile->dentry);
1173         cifs_sb = CIFS_SB(inode->i_sb);
1174         tcon = tlink_tcon(cfile->tlink);
1175         server = tcon->ses->server;
1176
1177         /*
1178          * Can not grab rename sem here because various ops, including those
1179          * that already have the rename sem can end up causing writepage to get
1180          * called and if the server was down that means we end up here, and we
1181          * can never tell if the caller already has the rename_sem.
1182          */
1183         page = alloc_dentry_path();
1184         full_path = build_path_from_dentry(cfile->dentry, page);
1185         if (IS_ERR(full_path)) {
1186                 mutex_unlock(&cfile->fh_mutex);
1187                 free_dentry_path(page);
1188                 free_xid(xid);
1189                 return PTR_ERR(full_path);
1190         }
1191
1192         cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
1193                  inode, cfile->f_flags, full_path);
1194
1195         if (tcon->ses->server->oplocks)
1196                 oplock = REQ_OPLOCK;
1197         else
1198                 oplock = 0;
1199
1200 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1201         if (tcon->unix_ext && cap_unix(tcon->ses) &&
1202             (CIFS_UNIX_POSIX_PATH_OPS_CAP &
1203                                 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
1204                 /*
1205                  * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
1206                  * original open. Must mask them off for a reopen.
1207                  */
1208                 unsigned int oflags = cfile->f_flags &
1209                                                 ~(O_CREAT | O_EXCL | O_TRUNC);
1210
1211                 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
1212                                      cifs_sb->ctx->file_mode /* ignored */,
1213                                      oflags, &oplock, &cfile->fid.netfid, xid);
1214                 if (rc == 0) {
1215                         cifs_dbg(FYI, "posix reopen succeeded\n");
1216                         oparms.reconnect = true;
1217                         goto reopen_success;
1218                 }
1219                 /*
1220                  * fallthrough to retry open the old way on errors, especially
1221                  * in the reconnect path it is important to retry hard
1222                  */
1223         }
1224 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1225
1226         /* If we're caching, we need to be able to fill in around partial writes. */
1227         if (cifs_fscache_enabled(inode) && (cfile->f_flags & O_ACCMODE) == O_WRONLY)
1228                 rdwr_for_fscache = 1;
1229
1230         desired_access = cifs_convert_flags(cfile->f_flags, rdwr_for_fscache);
1231
1232         /* O_SYNC also has bit for O_DSYNC so following check picks up either */
1233         if (cfile->f_flags & O_SYNC)
1234                 create_options |= CREATE_WRITE_THROUGH;
1235
1236         if (cfile->f_flags & O_DIRECT)
1237                 create_options |= CREATE_NO_BUFFER;
1238
1239         if (server->ops->get_lease_key)
1240                 server->ops->get_lease_key(inode, &cfile->fid);
1241
1242 retry_open:
1243         oparms = (struct cifs_open_parms) {
1244                 .tcon = tcon,
1245                 .cifs_sb = cifs_sb,
1246                 .desired_access = desired_access,
1247                 .create_options = cifs_create_options(cifs_sb, create_options),
1248                 .disposition = disposition,
1249                 .path = full_path,
1250                 .fid = &cfile->fid,
1251                 .reconnect = true,
1252         };
1253
1254         /*
1255          * Can not refresh inode by passing in file_info buf to be returned by
1256          * ops->open and then calling get_inode_info with returned buf since
1257          * file might have write behind data that needs to be flushed and server
1258          * version of file size can be stale. If we knew for sure that inode was
1259          * not dirty locally we could do this.
1260          */
1261         rc = server->ops->open(xid, &oparms, &oplock, NULL);
1262         if (rc == -ENOENT && oparms.reconnect == false) {
1263                 /* durable handle timeout is expired - open the file again */
1264                 rc = server->ops->open(xid, &oparms, &oplock, NULL);
1265                 /* indicate that we need to relock the file */
1266                 oparms.reconnect = true;
1267         }
1268         if (rc == -EACCES && rdwr_for_fscache == 1) {
1269                 desired_access = cifs_convert_flags(cfile->f_flags, 0);
1270                 rdwr_for_fscache = 2;
1271                 goto retry_open;
1272         }
1273
1274         if (rc) {
1275                 mutex_unlock(&cfile->fh_mutex);
1276                 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
1277                 cifs_dbg(FYI, "oplock: %d\n", oplock);
1278                 goto reopen_error_exit;
1279         }
1280
1281         if (rdwr_for_fscache == 2)
1282                 cifs_invalidate_cache(inode, FSCACHE_INVAL_DIO_WRITE);
1283
1284 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1285 reopen_success:
1286 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1287         cfile->invalidHandle = false;
1288         mutex_unlock(&cfile->fh_mutex);
1289         cinode = CIFS_I(inode);
1290
1291         if (can_flush) {
1292                 rc = filemap_write_and_wait(inode->i_mapping);
1293                 if (!is_interrupt_error(rc))
1294                         mapping_set_error(inode->i_mapping, rc);
1295
1296                 if (tcon->posix_extensions) {
1297                         rc = smb311_posix_get_inode_info(&inode, full_path,
1298                                                          NULL, inode->i_sb, xid);
1299                 } else if (tcon->unix_ext) {
1300                         rc = cifs_get_inode_info_unix(&inode, full_path,
1301                                                       inode->i_sb, xid);
1302                 } else {
1303                         rc = cifs_get_inode_info(&inode, full_path, NULL,
1304                                                  inode->i_sb, xid, NULL);
1305                 }
1306         }
1307         /*
1308          * Else we are writing out data to server already and could deadlock if
1309          * we tried to flush data, and since we do not know if we have data that
1310          * would invalidate the current end of file on the server we can not go
1311          * to the server to get the new inode info.
1312          */
1313
1314         /*
1315          * If the server returned a read oplock and we have mandatory brlocks,
1316          * set oplock level to None.
1317          */
1318         if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
1319                 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
1320                 oplock = 0;
1321         }
1322
1323         server->ops->set_fid(cfile, &cfile->fid, oplock);
1324         if (oparms.reconnect)
1325                 cifs_relock_file(cfile);
1326
1327 reopen_error_exit:
1328         free_dentry_path(page);
1329         free_xid(xid);
1330         return rc;
1331 }
1332
1333 void smb2_deferred_work_close(struct work_struct *work)
1334 {
1335         struct cifsFileInfo *cfile = container_of(work,
1336                         struct cifsFileInfo, deferred.work);
1337
1338         spin_lock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);
1339         cifs_del_deferred_close(cfile);
1340         cfile->deferred_close_scheduled = false;
1341         spin_unlock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);
1342         _cifsFileInfo_put(cfile, true, false);
1343 }
1344
1345 static bool
1346 smb2_can_defer_close(struct inode *inode, struct cifs_deferred_close *dclose)
1347 {
1348         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1349         struct cifsInodeInfo *cinode = CIFS_I(inode);
1350
1351         return (cifs_sb->ctx->closetimeo && cinode->lease_granted && dclose &&
1352                         (cinode->oplock == CIFS_CACHE_RHW_FLG ||
1353                          cinode->oplock == CIFS_CACHE_RH_FLG) &&
1354                         !test_bit(CIFS_INO_CLOSE_ON_LOCK, &cinode->flags));
1355
1356 }
1357
1358 int cifs_close(struct inode *inode, struct file *file)
1359 {
1360         struct cifsFileInfo *cfile;
1361         struct cifsInodeInfo *cinode = CIFS_I(inode);
1362         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1363         struct cifs_deferred_close *dclose;
1364
1365         cifs_fscache_unuse_inode_cookie(inode, file->f_mode & FMODE_WRITE);
1366
1367         if (file->private_data != NULL) {
1368                 cfile = file->private_data;
1369                 file->private_data = NULL;
1370                 dclose = kmalloc(sizeof(struct cifs_deferred_close), GFP_KERNEL);
1371                 if ((cfile->status_file_deleted == false) &&
1372                     (smb2_can_defer_close(inode, dclose))) {
1373                         if (test_and_clear_bit(NETFS_ICTX_MODIFIED_ATTR, &cinode->netfs.flags)) {
1374                                 inode_set_mtime_to_ts(inode,
1375                                                       inode_set_ctime_current(inode));
1376                         }
1377                         spin_lock(&cinode->deferred_lock);
1378                         cifs_add_deferred_close(cfile, dclose);
1379                         if (cfile->deferred_close_scheduled &&
1380                             delayed_work_pending(&cfile->deferred)) {
1381                                 /*
1382                                  * If there is no pending work, mod_delayed_work queues new work.
1383                                  * So, Increase the ref count to avoid use-after-free.
1384                                  */
1385                                 if (!mod_delayed_work(deferredclose_wq,
1386                                                 &cfile->deferred, cifs_sb->ctx->closetimeo))
1387                                         cifsFileInfo_get(cfile);
1388                         } else {
1389                                 /* Deferred close for files */
1390                                 queue_delayed_work(deferredclose_wq,
1391                                                 &cfile->deferred, cifs_sb->ctx->closetimeo);
1392                                 cfile->deferred_close_scheduled = true;
1393                                 spin_unlock(&cinode->deferred_lock);
1394                                 return 0;
1395                         }
1396                         spin_unlock(&cinode->deferred_lock);
1397                         _cifsFileInfo_put(cfile, true, false);
1398                 } else {
1399                         _cifsFileInfo_put(cfile, true, false);
1400                         kfree(dclose);
1401                 }
1402         }
1403
1404         /* return code from the ->release op is always ignored */
1405         return 0;
1406 }
1407
1408 void
1409 cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
1410 {
1411         struct cifsFileInfo *open_file, *tmp;
1412         LIST_HEAD(tmp_list);
1413
1414         if (!tcon->use_persistent || !tcon->need_reopen_files)
1415                 return;
1416
1417         tcon->need_reopen_files = false;
1418
1419         cifs_dbg(FYI, "Reopen persistent handles\n");
1420
1421         /* list all files open on tree connection, reopen resilient handles  */
1422         spin_lock(&tcon->open_file_lock);
1423         list_for_each_entry(open_file, &tcon->openFileList, tlist) {
1424                 if (!open_file->invalidHandle)
1425                         continue;
1426                 cifsFileInfo_get(open_file);
1427                 list_add_tail(&open_file->rlist, &tmp_list);
1428         }
1429         spin_unlock(&tcon->open_file_lock);
1430
1431         list_for_each_entry_safe(open_file, tmp, &tmp_list, rlist) {
1432                 if (cifs_reopen_file(open_file, false /* do not flush */))
1433                         tcon->need_reopen_files = true;
1434                 list_del_init(&open_file->rlist);
1435                 cifsFileInfo_put(open_file);
1436         }
1437 }
1438
1439 int cifs_closedir(struct inode *inode, struct file *file)
1440 {
1441         int rc = 0;
1442         unsigned int xid;
1443         struct cifsFileInfo *cfile = file->private_data;
1444         struct cifs_tcon *tcon;
1445         struct TCP_Server_Info *server;
1446         char *buf;
1447
1448         cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
1449
1450         if (cfile == NULL)
1451                 return rc;
1452
1453         xid = get_xid();
1454         tcon = tlink_tcon(cfile->tlink);
1455         server = tcon->ses->server;
1456
1457         cifs_dbg(FYI, "Freeing private data in close dir\n");
1458         spin_lock(&cfile->file_info_lock);
1459         if (server->ops->dir_needs_close(cfile)) {
1460                 cfile->invalidHandle = true;
1461                 spin_unlock(&cfile->file_info_lock);
1462                 if (server->ops->close_dir)
1463                         rc = server->ops->close_dir(xid, tcon, &cfile->fid);
1464                 else
1465                         rc = -ENOSYS;
1466                 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
1467                 /* not much we can do if it fails anyway, ignore rc */
1468                 rc = 0;
1469         } else
1470                 spin_unlock(&cfile->file_info_lock);
1471
1472         buf = cfile->srch_inf.ntwrk_buf_start;
1473         if (buf) {
1474                 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
1475                 cfile->srch_inf.ntwrk_buf_start = NULL;
1476                 if (cfile->srch_inf.smallBuf)
1477                         cifs_small_buf_release(buf);
1478                 else
1479                         cifs_buf_release(buf);
1480         }
1481
1482         cifs_put_tlink(cfile->tlink);
1483         kfree(file->private_data);
1484         file->private_data = NULL;
1485         /* BB can we lock the filestruct while this is going on? */
1486         free_xid(xid);
1487         return rc;
1488 }
1489
1490 static struct cifsLockInfo *
1491 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 flags)
1492 {
1493         struct cifsLockInfo *lock =
1494                 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
1495         if (!lock)
1496                 return lock;
1497         lock->offset = offset;
1498         lock->length = length;
1499         lock->type = type;
1500         lock->pid = current->tgid;
1501         lock->flags = flags;
1502         INIT_LIST_HEAD(&lock->blist);
1503         init_waitqueue_head(&lock->block_q);
1504         return lock;
1505 }
1506
1507 void
1508 cifs_del_lock_waiters(struct cifsLockInfo *lock)
1509 {
1510         struct cifsLockInfo *li, *tmp;
1511         list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
1512                 list_del_init(&li->blist);
1513                 wake_up(&li->block_q);
1514         }
1515 }
1516
1517 #define CIFS_LOCK_OP    0
1518 #define CIFS_READ_OP    1
1519 #define CIFS_WRITE_OP   2
1520
1521 /* @rw_check : 0 - no op, 1 - read, 2 - write */
1522 static bool
1523 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
1524                             __u64 length, __u8 type, __u16 flags,
1525                             struct cifsFileInfo *cfile,
1526                             struct cifsLockInfo **conf_lock, int rw_check)
1527 {
1528         struct cifsLockInfo *li;
1529         struct cifsFileInfo *cur_cfile = fdlocks->cfile;
1530         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1531
1532         list_for_each_entry(li, &fdlocks->locks, llist) {
1533                 if (offset + length <= li->offset ||
1534                     offset >= li->offset + li->length)
1535                         continue;
1536                 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
1537                     server->ops->compare_fids(cfile, cur_cfile)) {
1538                         /* shared lock prevents write op through the same fid */
1539                         if (!(li->type & server->vals->shared_lock_type) ||
1540                             rw_check != CIFS_WRITE_OP)
1541                                 continue;
1542                 }
1543                 if ((type & server->vals->shared_lock_type) &&
1544                     ((server->ops->compare_fids(cfile, cur_cfile) &&
1545                      current->tgid == li->pid) || type == li->type))
1546                         continue;
1547                 if (rw_check == CIFS_LOCK_OP &&
1548                     (flags & FL_OFDLCK) && (li->flags & FL_OFDLCK) &&
1549                     server->ops->compare_fids(cfile, cur_cfile))
1550                         continue;
1551                 if (conf_lock)
1552                         *conf_lock = li;
1553                 return true;
1554         }
1555         return false;
1556 }
1557
1558 bool
1559 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1560                         __u8 type, __u16 flags,
1561                         struct cifsLockInfo **conf_lock, int rw_check)
1562 {
1563         bool rc = false;
1564         struct cifs_fid_locks *cur;
1565         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1566
1567         list_for_each_entry(cur, &cinode->llist, llist) {
1568                 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
1569                                                  flags, cfile, conf_lock,
1570                                                  rw_check);
1571                 if (rc)
1572                         break;
1573         }
1574
1575         return rc;
1576 }
1577
1578 /*
1579  * Check if there is another lock that prevents us to set the lock (mandatory
1580  * style). If such a lock exists, update the flock structure with its
1581  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1582  * or leave it the same if we can't. Returns 0 if we don't need to request to
1583  * the server or 1 otherwise.
1584  */
1585 static int
1586 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1587                __u8 type, struct file_lock *flock)
1588 {
1589         int rc = 0;
1590         struct cifsLockInfo *conf_lock;
1591         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1592         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1593         bool exist;
1594
1595         down_read(&cinode->lock_sem);
1596
1597         exist = cifs_find_lock_conflict(cfile, offset, length, type,
1598                                         flock->c.flc_flags, &conf_lock,
1599                                         CIFS_LOCK_OP);
1600         if (exist) {
1601                 flock->fl_start = conf_lock->offset;
1602                 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
1603                 flock->c.flc_pid = conf_lock->pid;
1604                 if (conf_lock->type & server->vals->shared_lock_type)
1605                         flock->c.flc_type = F_RDLCK;
1606                 else
1607                         flock->c.flc_type = F_WRLCK;
1608         } else if (!cinode->can_cache_brlcks)
1609                 rc = 1;
1610         else
1611                 flock->c.flc_type = F_UNLCK;
1612
1613         up_read(&cinode->lock_sem);
1614         return rc;
1615 }
1616
1617 static void
1618 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
1619 {
1620         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1621         cifs_down_write(&cinode->lock_sem);
1622         list_add_tail(&lock->llist, &cfile->llist->locks);
1623         up_write(&cinode->lock_sem);
1624 }
1625
1626 /*
1627  * Set the byte-range lock (mandatory style). Returns:
1628  * 1) 0, if we set the lock and don't need to request to the server;
1629  * 2) 1, if no locks prevent us but we need to request to the server;
1630  * 3) -EACCES, if there is a lock that prevents us and wait is false.
1631  */
1632 static int
1633 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1634                  bool wait)
1635 {
1636         struct cifsLockInfo *conf_lock;
1637         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1638         bool exist;
1639         int rc = 0;
1640
1641 try_again:
1642         exist = false;
1643         cifs_down_write(&cinode->lock_sem);
1644
1645         exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1646                                         lock->type, lock->flags, &conf_lock,
1647                                         CIFS_LOCK_OP);
1648         if (!exist && cinode->can_cache_brlcks) {
1649                 list_add_tail(&lock->llist, &cfile->llist->locks);
1650                 up_write(&cinode->lock_sem);
1651                 return rc;
1652         }
1653
1654         if (!exist)
1655                 rc = 1;
1656         else if (!wait)
1657                 rc = -EACCES;
1658         else {
1659                 list_add_tail(&lock->blist, &conf_lock->blist);
1660                 up_write(&cinode->lock_sem);
1661                 rc = wait_event_interruptible(lock->block_q,
1662                                         (lock->blist.prev == &lock->blist) &&
1663                                         (lock->blist.next == &lock->blist));
1664                 if (!rc)
1665                         goto try_again;
1666                 cifs_down_write(&cinode->lock_sem);
1667                 list_del_init(&lock->blist);
1668         }
1669
1670         up_write(&cinode->lock_sem);
1671         return rc;
1672 }
1673
1674 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1675 /*
1676  * Check if there is another lock that prevents us to set the lock (posix
1677  * style). If such a lock exists, update the flock structure with its
1678  * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1679  * or leave it the same if we can't. Returns 0 if we don't need to request to
1680  * the server or 1 otherwise.
1681  */
1682 static int
1683 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1684 {
1685         int rc = 0;
1686         struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1687         unsigned char saved_type = flock->c.flc_type;
1688
1689         if ((flock->c.flc_flags & FL_POSIX) == 0)
1690                 return 1;
1691
1692         down_read(&cinode->lock_sem);
1693         posix_test_lock(file, flock);
1694
1695         if (lock_is_unlock(flock) && !cinode->can_cache_brlcks) {
1696                 flock->c.flc_type = saved_type;
1697                 rc = 1;
1698         }
1699
1700         up_read(&cinode->lock_sem);
1701         return rc;
1702 }
1703
1704 /*
1705  * Set the byte-range lock (posix style). Returns:
1706  * 1) <0, if the error occurs while setting the lock;
1707  * 2) 0, if we set the lock and don't need to request to the server;
1708  * 3) FILE_LOCK_DEFERRED, if we will wait for some other file_lock;
1709  * 4) FILE_LOCK_DEFERRED + 1, if we need to request to the server.
1710  */
1711 static int
1712 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1713 {
1714         struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1715         int rc = FILE_LOCK_DEFERRED + 1;
1716
1717         if ((flock->c.flc_flags & FL_POSIX) == 0)
1718                 return rc;
1719
1720         cifs_down_write(&cinode->lock_sem);
1721         if (!cinode->can_cache_brlcks) {
1722                 up_write(&cinode->lock_sem);
1723                 return rc;
1724         }
1725
1726         rc = posix_lock_file(file, flock, NULL);
1727         up_write(&cinode->lock_sem);
1728         return rc;
1729 }
1730
1731 int
1732 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1733 {
1734         unsigned int xid;
1735         int rc = 0, stored_rc;
1736         struct cifsLockInfo *li, *tmp;
1737         struct cifs_tcon *tcon;
1738         unsigned int num, max_num, max_buf;
1739         LOCKING_ANDX_RANGE *buf, *cur;
1740         static const int types[] = {
1741                 LOCKING_ANDX_LARGE_FILES,
1742                 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1743         };
1744         int i;
1745
1746         xid = get_xid();
1747         tcon = tlink_tcon(cfile->tlink);
1748
1749         /*
1750          * Accessing maxBuf is racy with cifs_reconnect - need to store value
1751          * and check it before using.
1752          */
1753         max_buf = tcon->ses->server->maxBuf;
1754         if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1755                 free_xid(xid);
1756                 return -EINVAL;
1757         }
1758
1759         BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1760                      PAGE_SIZE);
1761         max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1762                         PAGE_SIZE);
1763         max_num = (max_buf - sizeof(struct smb_hdr)) /
1764                                                 sizeof(LOCKING_ANDX_RANGE);
1765         buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1766         if (!buf) {
1767                 free_xid(xid);
1768                 return -ENOMEM;
1769         }
1770
1771         for (i = 0; i < 2; i++) {
1772                 cur = buf;
1773                 num = 0;
1774                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1775                         if (li->type != types[i])
1776                                 continue;
1777                         cur->Pid = cpu_to_le16(li->pid);
1778                         cur->LengthLow = cpu_to_le32((u32)li->length);
1779                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1780                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
1781                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1782                         if (++num == max_num) {
1783                                 stored_rc = cifs_lockv(xid, tcon,
1784                                                        cfile->fid.netfid,
1785                                                        (__u8)li->type, 0, num,
1786                                                        buf);
1787                                 if (stored_rc)
1788                                         rc = stored_rc;
1789                                 cur = buf;
1790                                 num = 0;
1791                         } else
1792                                 cur++;
1793                 }
1794
1795                 if (num) {
1796                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1797                                                (__u8)types[i], 0, num, buf);
1798                         if (stored_rc)
1799                                 rc = stored_rc;
1800                 }
1801         }
1802
1803         kfree(buf);
1804         free_xid(xid);
1805         return rc;
1806 }
1807
1808 static __u32
1809 hash_lockowner(fl_owner_t owner)
1810 {
1811         return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1812 }
1813 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1814
1815 struct lock_to_push {
1816         struct list_head llist;
1817         __u64 offset;
1818         __u64 length;
1819         __u32 pid;
1820         __u16 netfid;
1821         __u8 type;
1822 };
1823
1824 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1825 static int
1826 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1827 {
1828         struct inode *inode = d_inode(cfile->dentry);
1829         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1830         struct file_lock *flock;
1831         struct file_lock_context *flctx = locks_inode_context(inode);
1832         unsigned int count = 0, i;
1833         int rc = 0, xid, type;
1834         struct list_head locks_to_send, *el;
1835         struct lock_to_push *lck, *tmp;
1836         __u64 length;
1837
1838         xid = get_xid();
1839
1840         if (!flctx)
1841                 goto out;
1842
1843         spin_lock(&flctx->flc_lock);
1844         list_for_each(el, &flctx->flc_posix) {
1845                 count++;
1846         }
1847         spin_unlock(&flctx->flc_lock);
1848
1849         INIT_LIST_HEAD(&locks_to_send);
1850
1851         /*
1852          * Allocating count locks is enough because no FL_POSIX locks can be
1853          * added to the list while we are holding cinode->lock_sem that
1854          * protects locking operations of this inode.
1855          */
1856         for (i = 0; i < count; i++) {
1857                 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1858                 if (!lck) {
1859                         rc = -ENOMEM;
1860                         goto err_out;
1861                 }
1862                 list_add_tail(&lck->llist, &locks_to_send);
1863         }
1864
1865         el = locks_to_send.next;
1866         spin_lock(&flctx->flc_lock);
1867         for_each_file_lock(flock, &flctx->flc_posix) {
1868                 unsigned char ftype = flock->c.flc_type;
1869
1870                 if (el == &locks_to_send) {
1871                         /*
1872                          * The list ended. We don't have enough allocated
1873                          * structures - something is really wrong.
1874                          */
1875                         cifs_dbg(VFS, "Can't push all brlocks!\n");
1876                         break;
1877                 }
1878                 length = cifs_flock_len(flock);
1879                 if (ftype == F_RDLCK || ftype == F_SHLCK)
1880                         type = CIFS_RDLCK;
1881                 else
1882                         type = CIFS_WRLCK;
1883                 lck = list_entry(el, struct lock_to_push, llist);
1884                 lck->pid = hash_lockowner(flock->c.flc_owner);
1885                 lck->netfid = cfile->fid.netfid;
1886                 lck->length = length;
1887                 lck->type = type;
1888                 lck->offset = flock->fl_start;
1889         }
1890         spin_unlock(&flctx->flc_lock);
1891
1892         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1893                 int stored_rc;
1894
1895                 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1896                                              lck->offset, lck->length, NULL,
1897                                              lck->type, 0);
1898                 if (stored_rc)
1899                         rc = stored_rc;
1900                 list_del(&lck->llist);
1901                 kfree(lck);
1902         }
1903
1904 out:
1905         free_xid(xid);
1906         return rc;
1907 err_out:
1908         list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1909                 list_del(&lck->llist);
1910                 kfree(lck);
1911         }
1912         goto out;
1913 }
1914 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1915
1916 static int
1917 cifs_push_locks(struct cifsFileInfo *cfile)
1918 {
1919         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1920         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1921         int rc = 0;
1922 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1923         struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1924 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1925
1926         /* we are going to update can_cache_brlcks here - need a write access */
1927         cifs_down_write(&cinode->lock_sem);
1928         if (!cinode->can_cache_brlcks) {
1929                 up_write(&cinode->lock_sem);
1930                 return rc;
1931         }
1932
1933 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
1934         if (cap_unix(tcon->ses) &&
1935             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1936             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1937                 rc = cifs_push_posix_locks(cfile);
1938         else
1939 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
1940                 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1941
1942         cinode->can_cache_brlcks = false;
1943         up_write(&cinode->lock_sem);
1944         return rc;
1945 }
1946
1947 static void
1948 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1949                 bool *wait_flag, struct TCP_Server_Info *server)
1950 {
1951         if (flock->c.flc_flags & FL_POSIX)
1952                 cifs_dbg(FYI, "Posix\n");
1953         if (flock->c.flc_flags & FL_FLOCK)
1954                 cifs_dbg(FYI, "Flock\n");
1955         if (flock->c.flc_flags & FL_SLEEP) {
1956                 cifs_dbg(FYI, "Blocking lock\n");
1957                 *wait_flag = true;
1958         }
1959         if (flock->c.flc_flags & FL_ACCESS)
1960                 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1961         if (flock->c.flc_flags & FL_LEASE)
1962                 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1963         if (flock->c.flc_flags &
1964             (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1965                FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK)))
1966                 cifs_dbg(FYI, "Unknown lock flags 0x%x\n",
1967                          flock->c.flc_flags);
1968
1969         *type = server->vals->large_lock_type;
1970         if (lock_is_write(flock)) {
1971                 cifs_dbg(FYI, "F_WRLCK\n");
1972                 *type |= server->vals->exclusive_lock_type;
1973                 *lock = 1;
1974         } else if (lock_is_unlock(flock)) {
1975                 cifs_dbg(FYI, "F_UNLCK\n");
1976                 *type |= server->vals->unlock_lock_type;
1977                 *unlock = 1;
1978                 /* Check if unlock includes more than one lock range */
1979         } else if (lock_is_read(flock)) {
1980                 cifs_dbg(FYI, "F_RDLCK\n");
1981                 *type |= server->vals->shared_lock_type;
1982                 *lock = 1;
1983         } else if (flock->c.flc_type == F_EXLCK) {
1984                 cifs_dbg(FYI, "F_EXLCK\n");
1985                 *type |= server->vals->exclusive_lock_type;
1986                 *lock = 1;
1987         } else if (flock->c.flc_type == F_SHLCK) {
1988                 cifs_dbg(FYI, "F_SHLCK\n");
1989                 *type |= server->vals->shared_lock_type;
1990                 *lock = 1;
1991         } else
1992                 cifs_dbg(FYI, "Unknown type of lock\n");
1993 }
1994
1995 static int
1996 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1997            bool wait_flag, bool posix_lck, unsigned int xid)
1998 {
1999         int rc = 0;
2000         __u64 length = cifs_flock_len(flock);
2001         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2002         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2003         struct TCP_Server_Info *server = tcon->ses->server;
2004 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2005         __u16 netfid = cfile->fid.netfid;
2006
2007         if (posix_lck) {
2008                 int posix_lock_type;
2009
2010                 rc = cifs_posix_lock_test(file, flock);
2011                 if (!rc)
2012                         return rc;
2013
2014                 if (type & server->vals->shared_lock_type)
2015                         posix_lock_type = CIFS_RDLCK;
2016                 else
2017                         posix_lock_type = CIFS_WRLCK;
2018                 rc = CIFSSMBPosixLock(xid, tcon, netfid,
2019                                       hash_lockowner(flock->c.flc_owner),
2020                                       flock->fl_start, length, flock,
2021                                       posix_lock_type, wait_flag);
2022                 return rc;
2023         }
2024 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2025
2026         rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
2027         if (!rc)
2028                 return rc;
2029
2030         /* BB we could chain these into one lock request BB */
2031         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
2032                                     1, 0, false);
2033         if (rc == 0) {
2034                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
2035                                             type, 0, 1, false);
2036                 flock->c.flc_type = F_UNLCK;
2037                 if (rc != 0)
2038                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
2039                                  rc);
2040                 return 0;
2041         }
2042
2043         if (type & server->vals->shared_lock_type) {
2044                 flock->c.flc_type = F_WRLCK;
2045                 return 0;
2046         }
2047
2048         type &= ~server->vals->exclusive_lock_type;
2049
2050         rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
2051                                     type | server->vals->shared_lock_type,
2052                                     1, 0, false);
2053         if (rc == 0) {
2054                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
2055                         type | server->vals->shared_lock_type, 0, 1, false);
2056                 flock->c.flc_type = F_RDLCK;
2057                 if (rc != 0)
2058                         cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
2059                                  rc);
2060         } else
2061                 flock->c.flc_type = F_WRLCK;
2062
2063         return 0;
2064 }
2065
2066 void
2067 cifs_move_llist(struct list_head *source, struct list_head *dest)
2068 {
2069         struct list_head *li, *tmp;
2070         list_for_each_safe(li, tmp, source)
2071                 list_move(li, dest);
2072 }
2073
2074 void
2075 cifs_free_llist(struct list_head *llist)
2076 {
2077         struct cifsLockInfo *li, *tmp;
2078         list_for_each_entry_safe(li, tmp, llist, llist) {
2079                 cifs_del_lock_waiters(li);
2080                 list_del(&li->llist);
2081                 kfree(li);
2082         }
2083 }
2084
2085 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2086 int
2087 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
2088                   unsigned int xid)
2089 {
2090         int rc = 0, stored_rc;
2091         static const int types[] = {
2092                 LOCKING_ANDX_LARGE_FILES,
2093                 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
2094         };
2095         unsigned int i;
2096         unsigned int max_num, num, max_buf;
2097         LOCKING_ANDX_RANGE *buf, *cur;
2098         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2099         struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
2100         struct cifsLockInfo *li, *tmp;
2101         __u64 length = cifs_flock_len(flock);
2102         LIST_HEAD(tmp_llist);
2103
2104         /*
2105          * Accessing maxBuf is racy with cifs_reconnect - need to store value
2106          * and check it before using.
2107          */
2108         max_buf = tcon->ses->server->maxBuf;
2109         if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
2110                 return -EINVAL;
2111
2112         BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
2113                      PAGE_SIZE);
2114         max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
2115                         PAGE_SIZE);
2116         max_num = (max_buf - sizeof(struct smb_hdr)) /
2117                                                 sizeof(LOCKING_ANDX_RANGE);
2118         buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
2119         if (!buf)
2120                 return -ENOMEM;
2121
2122         cifs_down_write(&cinode->lock_sem);
2123         for (i = 0; i < 2; i++) {
2124                 cur = buf;
2125                 num = 0;
2126                 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
2127                         if (flock->fl_start > li->offset ||
2128                             (flock->fl_start + length) <
2129                             (li->offset + li->length))
2130                                 continue;
2131                         if (current->tgid != li->pid)
2132                                 continue;
2133                         if (types[i] != li->type)
2134                                 continue;
2135                         if (cinode->can_cache_brlcks) {
2136                                 /*
2137                                  * We can cache brlock requests - simply remove
2138                                  * a lock from the file's list.
2139                                  */
2140                                 list_del(&li->llist);
2141                                 cifs_del_lock_waiters(li);
2142                                 kfree(li);
2143                                 continue;
2144                         }
2145                         cur->Pid = cpu_to_le16(li->pid);
2146                         cur->LengthLow = cpu_to_le32((u32)li->length);
2147                         cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
2148                         cur->OffsetLow = cpu_to_le32((u32)li->offset);
2149                         cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
2150                         /*
2151                          * We need to save a lock here to let us add it again to
2152                          * the file's list if the unlock range request fails on
2153                          * the server.
2154                          */
2155                         list_move(&li->llist, &tmp_llist);
2156                         if (++num == max_num) {
2157                                 stored_rc = cifs_lockv(xid, tcon,
2158                                                        cfile->fid.netfid,
2159                                                        li->type, num, 0, buf);
2160                                 if (stored_rc) {
2161                                         /*
2162                                          * We failed on the unlock range
2163                                          * request - add all locks from the tmp
2164                                          * list to the head of the file's list.
2165                                          */
2166                                         cifs_move_llist(&tmp_llist,
2167                                                         &cfile->llist->locks);
2168                                         rc = stored_rc;
2169                                 } else
2170                                         /*
2171                                          * The unlock range request succeed -
2172                                          * free the tmp list.
2173                                          */
2174                                         cifs_free_llist(&tmp_llist);
2175                                 cur = buf;
2176                                 num = 0;
2177                         } else
2178                                 cur++;
2179                 }
2180                 if (num) {
2181                         stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
2182                                                types[i], num, 0, buf);
2183                         if (stored_rc) {
2184                                 cifs_move_llist(&tmp_llist,
2185                                                 &cfile->llist->locks);
2186                                 rc = stored_rc;
2187                         } else
2188                                 cifs_free_llist(&tmp_llist);
2189                 }
2190         }
2191
2192         up_write(&cinode->lock_sem);
2193         kfree(buf);
2194         return rc;
2195 }
2196 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2197
2198 static int
2199 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
2200            bool wait_flag, bool posix_lck, int lock, int unlock,
2201            unsigned int xid)
2202 {
2203         int rc = 0;
2204         __u64 length = cifs_flock_len(flock);
2205         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2206         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2207         struct TCP_Server_Info *server = tcon->ses->server;
2208         struct inode *inode = d_inode(cfile->dentry);
2209
2210 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY
2211         if (posix_lck) {
2212                 int posix_lock_type;
2213
2214                 rc = cifs_posix_lock_set(file, flock);
2215                 if (rc <= FILE_LOCK_DEFERRED)
2216                         return rc;
2217
2218                 if (type & server->vals->shared_lock_type)
2219                         posix_lock_type = CIFS_RDLCK;
2220                 else
2221                         posix_lock_type = CIFS_WRLCK;
2222
2223                 if (unlock == 1)
2224                         posix_lock_type = CIFS_UNLCK;
2225
2226                 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
2227                                       hash_lockowner(flock->c.flc_owner),
2228                                       flock->fl_start, length,
2229                                       NULL, posix_lock_type, wait_flag);
2230                 goto out;
2231         }
2232 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */
2233         if (lock) {
2234                 struct cifsLockInfo *lock;
2235
2236                 lock = cifs_lock_init(flock->fl_start, length, type,
2237                                       flock->c.flc_flags);
2238                 if (!lock)
2239                         return -ENOMEM;
2240
2241                 rc = cifs_lock_add_if(cfile, lock, wait_flag);
2242                 if (rc < 0) {
2243                         kfree(lock);
2244                         return rc;
2245                 }
2246                 if (!rc)
2247                         goto out;
2248
2249                 /*
2250                  * Windows 7 server can delay breaking lease from read to None
2251                  * if we set a byte-range lock on a file - break it explicitly
2252                  * before sending the lock to the server to be sure the next
2253                  * read won't conflict with non-overlapted locks due to
2254                  * pagereading.
2255                  */
2256                 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
2257                                         CIFS_CACHE_READ(CIFS_I(inode))) {
2258                         cifs_zap_mapping(inode);
2259                         cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
2260                                  inode);
2261                         CIFS_I(inode)->oplock = 0;
2262                 }
2263
2264                 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
2265                                             type, 1, 0, wait_flag);
2266                 if (rc) {
2267                         kfree(lock);
2268                         return rc;
2269                 }
2270
2271                 cifs_lock_add(cfile, lock);
2272         } else if (unlock)
2273                 rc = server->ops->mand_unlock_range(cfile, flock, xid);
2274
2275 out:
2276         if ((flock->c.flc_flags & FL_POSIX) || (flock->c.flc_flags & FL_FLOCK)) {
2277                 /*
2278                  * If this is a request to remove all locks because we
2279                  * are closing the file, it doesn't matter if the
2280                  * unlocking failed as both cifs.ko and the SMB server
2281                  * remove the lock on file close
2282                  */
2283                 if (rc) {
2284                         cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
2285                         if (!(flock->c.flc_flags & FL_CLOSE))
2286                                 return rc;
2287                 }
2288                 rc = locks_lock_file_wait(file, flock);
2289         }
2290         return rc;
2291 }
2292
2293 int cifs_flock(struct file *file, int cmd, struct file_lock *fl)
2294 {
2295         int rc, xid;
2296         int lock = 0, unlock = 0;
2297         bool wait_flag = false;
2298         bool posix_lck = false;
2299         struct cifs_sb_info *cifs_sb;
2300         struct cifs_tcon *tcon;
2301         struct cifsFileInfo *cfile;
2302         __u32 type;
2303
2304         xid = get_xid();
2305
2306         if (!(fl->c.flc_flags & FL_FLOCK)) {
2307                 rc = -ENOLCK;
2308                 free_xid(xid);
2309                 return rc;
2310         }
2311
2312         cfile = (struct cifsFileInfo *)file->private_data;
2313         tcon = tlink_tcon(cfile->tlink);
2314
2315         cifs_read_flock(fl, &type, &lock, &unlock, &wait_flag,
2316                         tcon->ses->server);
2317         cifs_sb = CIFS_FILE_SB(file);
2318
2319         if (cap_unix(tcon->ses) &&
2320             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2321             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2322                 posix_lck = true;
2323
2324         if (!lock && !unlock) {
2325                 /*
2326                  * if no lock or unlock then nothing to do since we do not
2327                  * know what it is
2328                  */
2329                 rc = -EOPNOTSUPP;
2330                 free_xid(xid);
2331                 return rc;
2332         }
2333
2334         rc = cifs_setlk(file, fl, type, wait_flag, posix_lck, lock, unlock,
2335                         xid);
2336         free_xid(xid);
2337         return rc;
2338
2339
2340 }
2341
2342 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
2343 {
2344         int rc, xid;
2345         int lock = 0, unlock = 0;
2346         bool wait_flag = false;
2347         bool posix_lck = false;
2348         struct cifs_sb_info *cifs_sb;
2349         struct cifs_tcon *tcon;
2350         struct cifsFileInfo *cfile;
2351         __u32 type;
2352
2353         rc = -EACCES;
2354         xid = get_xid();
2355
2356         cifs_dbg(FYI, "%s: %pD2 cmd=0x%x type=0x%x flags=0x%x r=%lld:%lld\n", __func__, file, cmd,
2357                  flock->c.flc_flags, flock->c.flc_type,
2358                  (long long)flock->fl_start,
2359                  (long long)flock->fl_end);
2360
2361         cfile = (struct cifsFileInfo *)file->private_data;
2362         tcon = tlink_tcon(cfile->tlink);
2363
2364         cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
2365                         tcon->ses->server);
2366         cifs_sb = CIFS_FILE_SB(file);
2367         set_bit(CIFS_INO_CLOSE_ON_LOCK, &CIFS_I(d_inode(cfile->dentry))->flags);
2368
2369         if (cap_unix(tcon->ses) &&
2370             (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2371             ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2372                 posix_lck = true;
2373         /*
2374          * BB add code here to normalize offset and length to account for
2375          * negative length which we can not accept over the wire.
2376          */
2377         if (IS_GETLK(cmd)) {
2378                 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
2379                 free_xid(xid);
2380                 return rc;
2381         }
2382
2383         if (!lock && !unlock) {
2384                 /*
2385                  * if no lock or unlock then nothing to do since we do not
2386                  * know what it is
2387                  */
2388                 free_xid(xid);
2389                 return -EOPNOTSUPP;
2390         }
2391
2392         rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
2393                         xid);
2394         free_xid(xid);
2395         return rc;
2396 }
2397
2398 void cifs_write_subrequest_terminated(struct cifs_io_subrequest *wdata, ssize_t result,
2399                                       bool was_async)
2400 {
2401         struct netfs_io_request *wreq = wdata->rreq;
2402         struct netfs_inode *ictx = netfs_inode(wreq->inode);
2403         loff_t wrend;
2404
2405         if (result > 0) {
2406                 wrend = wdata->subreq.start + wdata->subreq.transferred + result;
2407
2408                 if (wrend > ictx->zero_point &&
2409                     (wdata->rreq->origin == NETFS_UNBUFFERED_WRITE ||
2410                      wdata->rreq->origin == NETFS_DIO_WRITE))
2411                         ictx->zero_point = wrend;
2412                 if (wrend > ictx->remote_i_size)
2413                         netfs_resize_file(ictx, wrend, true);
2414         }
2415
2416         netfs_write_subrequest_terminated(&wdata->subreq, result, was_async);
2417 }
2418
2419 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
2420                                         bool fsuid_only)
2421 {
2422         struct cifsFileInfo *open_file = NULL;
2423         struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->netfs.inode.i_sb);
2424
2425         /* only filter by fsuid on multiuser mounts */
2426         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
2427                 fsuid_only = false;
2428
2429         spin_lock(&cifs_inode->open_file_lock);
2430         /* we could simply get the first_list_entry since write-only entries
2431            are always at the end of the list but since the first entry might
2432            have a close pending, we go through the whole list */
2433         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2434                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
2435                         continue;
2436                 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
2437                         if ((!open_file->invalidHandle)) {
2438                                 /* found a good file */
2439                                 /* lock it so it will not be closed on us */
2440                                 cifsFileInfo_get(open_file);
2441                                 spin_unlock(&cifs_inode->open_file_lock);
2442                                 return open_file;
2443                         } /* else might as well continue, and look for
2444                              another, or simply have the caller reopen it
2445                              again rather than trying to fix this handle */
2446                 } else /* write only file */
2447                         break; /* write only files are last so must be done */
2448         }
2449         spin_unlock(&cifs_inode->open_file_lock);
2450         return NULL;
2451 }
2452
2453 /* Return -EBADF if no handle is found and general rc otherwise */
2454 int
2455 cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, int flags,
2456                        struct cifsFileInfo **ret_file)
2457 {
2458         struct cifsFileInfo *open_file, *inv_file = NULL;
2459         struct cifs_sb_info *cifs_sb;
2460         bool any_available = false;
2461         int rc = -EBADF;
2462         unsigned int refind = 0;
2463         bool fsuid_only = flags & FIND_WR_FSUID_ONLY;
2464         bool with_delete = flags & FIND_WR_WITH_DELETE;
2465         *ret_file = NULL;
2466
2467         /*
2468          * Having a null inode here (because mapping->host was set to zero by
2469          * the VFS or MM) should not happen but we had reports of on oops (due
2470          * to it being zero) during stress testcases so we need to check for it
2471          */
2472
2473         if (cifs_inode == NULL) {
2474                 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
2475                 dump_stack();
2476                 return rc;
2477         }
2478
2479         cifs_sb = CIFS_SB(cifs_inode->netfs.inode.i_sb);
2480
2481         /* only filter by fsuid on multiuser mounts */
2482         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
2483                 fsuid_only = false;
2484
2485         spin_lock(&cifs_inode->open_file_lock);
2486 refind_writable:
2487         if (refind > MAX_REOPEN_ATT) {
2488                 spin_unlock(&cifs_inode->open_file_lock);
2489                 return rc;
2490         }
2491         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2492                 if (!any_available && open_file->pid != current->tgid)
2493                         continue;
2494                 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
2495                         continue;
2496                 if (with_delete && !(open_file->fid.access & DELETE))
2497                         continue;
2498                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2499                         if (!open_file->invalidHandle) {
2500                                 /* found a good writable file */
2501                                 cifsFileInfo_get(open_file);
2502                                 spin_unlock(&cifs_inode->open_file_lock);
2503                                 *ret_file = open_file;
2504                                 return 0;
2505                         } else {
2506                                 if (!inv_file)
2507                                         inv_file = open_file;
2508                         }
2509                 }
2510         }
2511         /* couldn't find usable FH with same pid, try any available */
2512         if (!any_available) {
2513                 any_available = true;
2514                 goto refind_writable;
2515         }
2516
2517         if (inv_file) {
2518                 any_available = false;
2519                 cifsFileInfo_get(inv_file);
2520         }
2521
2522         spin_unlock(&cifs_inode->open_file_lock);
2523
2524         if (inv_file) {
2525                 rc = cifs_reopen_file(inv_file, false);
2526                 if (!rc) {
2527                         *ret_file = inv_file;
2528                         return 0;
2529                 }
2530
2531                 spin_lock(&cifs_inode->open_file_lock);
2532                 list_move_tail(&inv_file->flist, &cifs_inode->openFileList);
2533                 spin_unlock(&cifs_inode->open_file_lock);
2534                 cifsFileInfo_put(inv_file);
2535                 ++refind;
2536                 inv_file = NULL;
2537                 spin_lock(&cifs_inode->open_file_lock);
2538                 goto refind_writable;
2539         }
2540
2541         return rc;
2542 }
2543
2544 struct cifsFileInfo *
2545 find_writable_file(struct cifsInodeInfo *cifs_inode, int flags)
2546 {
2547         struct cifsFileInfo *cfile;
2548         int rc;
2549
2550         rc = cifs_get_writable_file(cifs_inode, flags, &cfile);
2551         if (rc)
2552                 cifs_dbg(FYI, "Couldn't find writable handle rc=%d\n", rc);
2553
2554         return cfile;
2555 }
2556
2557 int
2558 cifs_get_writable_path(struct cifs_tcon *tcon, const char *name,
2559                        int flags,
2560                        struct cifsFileInfo **ret_file)
2561 {
2562         struct cifsFileInfo *cfile;
2563         void *page = alloc_dentry_path();
2564
2565         *ret_file = NULL;
2566
2567         spin_lock(&tcon->open_file_lock);
2568         list_for_each_entry(cfile, &tcon->openFileList, tlist) {
2569                 struct cifsInodeInfo *cinode;
2570                 const char *full_path = build_path_from_dentry(cfile->dentry, page);
2571                 if (IS_ERR(full_path)) {
2572                         spin_unlock(&tcon->open_file_lock);
2573                         free_dentry_path(page);
2574                         return PTR_ERR(full_path);
2575                 }
2576                 if (strcmp(full_path, name))
2577                         continue;
2578
2579                 cinode = CIFS_I(d_inode(cfile->dentry));
2580                 spin_unlock(&tcon->open_file_lock);
2581                 free_dentry_path(page);
2582                 return cifs_get_writable_file(cinode, flags, ret_file);
2583         }
2584
2585         spin_unlock(&tcon->open_file_lock);
2586         free_dentry_path(page);
2587         return -ENOENT;
2588 }
2589
2590 int
2591 cifs_get_readable_path(struct cifs_tcon *tcon, const char *name,
2592                        struct cifsFileInfo **ret_file)
2593 {
2594         struct cifsFileInfo *cfile;
2595         void *page = alloc_dentry_path();
2596
2597         *ret_file = NULL;
2598
2599         spin_lock(&tcon->open_file_lock);
2600         list_for_each_entry(cfile, &tcon->openFileList, tlist) {
2601                 struct cifsInodeInfo *cinode;
2602                 const char *full_path = build_path_from_dentry(cfile->dentry, page);
2603                 if (IS_ERR(full_path)) {
2604                         spin_unlock(&tcon->open_file_lock);
2605                         free_dentry_path(page);
2606                         return PTR_ERR(full_path);
2607                 }
2608                 if (strcmp(full_path, name))
2609                         continue;
2610
2611                 cinode = CIFS_I(d_inode(cfile->dentry));
2612                 spin_unlock(&tcon->open_file_lock);
2613                 free_dentry_path(page);
2614                 *ret_file = find_readable_file(cinode, 0);
2615                 return *ret_file ? 0 : -ENOENT;
2616         }
2617
2618         spin_unlock(&tcon->open_file_lock);
2619         free_dentry_path(page);
2620         return -ENOENT;
2621 }
2622
2623 /*
2624  * Flush data on a strict file.
2625  */
2626 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2627                       int datasync)
2628 {
2629         unsigned int xid;
2630         int rc = 0;
2631         struct cifs_tcon *tcon;
2632         struct TCP_Server_Info *server;
2633         struct cifsFileInfo *smbfile = file->private_data;
2634         struct inode *inode = file_inode(file);
2635         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2636
2637         rc = file_write_and_wait_range(file, start, end);
2638         if (rc) {
2639                 trace_cifs_fsync_err(inode->i_ino, rc);
2640                 return rc;
2641         }
2642
2643         xid = get_xid();
2644
2645         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2646                  file, datasync);
2647
2648         if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2649                 rc = cifs_zap_mapping(inode);
2650                 if (rc) {
2651                         cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2652                         rc = 0; /* don't care about it in fsync */
2653                 }
2654         }
2655
2656         tcon = tlink_tcon(smbfile->tlink);
2657         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2658                 server = tcon->ses->server;
2659                 if (server->ops->flush == NULL) {
2660                         rc = -ENOSYS;
2661                         goto strict_fsync_exit;
2662                 }
2663
2664                 if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) {
2665                         smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
2666                         if (smbfile) {
2667                                 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2668                                 cifsFileInfo_put(smbfile);
2669                         } else
2670                                 cifs_dbg(FYI, "ignore fsync for file not open for write\n");
2671                 } else
2672                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2673         }
2674
2675 strict_fsync_exit:
2676         free_xid(xid);
2677         return rc;
2678 }
2679
2680 /*
2681  * Flush data on a non-strict data.
2682  */
2683 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2684 {
2685         unsigned int xid;
2686         int rc = 0;
2687         struct cifs_tcon *tcon;
2688         struct TCP_Server_Info *server;
2689         struct cifsFileInfo *smbfile = file->private_data;
2690         struct inode *inode = file_inode(file);
2691         struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2692
2693         rc = file_write_and_wait_range(file, start, end);
2694         if (rc) {
2695                 trace_cifs_fsync_err(file_inode(file)->i_ino, rc);
2696                 return rc;
2697         }
2698
2699         xid = get_xid();
2700
2701         cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2702                  file, datasync);
2703
2704         tcon = tlink_tcon(smbfile->tlink);
2705         if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2706                 server = tcon->ses->server;
2707                 if (server->ops->flush == NULL) {
2708                         rc = -ENOSYS;
2709                         goto fsync_exit;
2710                 }
2711
2712                 if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) {
2713                         smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
2714                         if (smbfile) {
2715                                 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2716                                 cifsFileInfo_put(smbfile);
2717                         } else
2718                                 cifs_dbg(FYI, "ignore fsync for file not open for write\n");
2719                 } else
2720                         rc = server->ops->flush(xid, tcon, &smbfile->fid);
2721         }
2722
2723 fsync_exit:
2724         free_xid(xid);
2725         return rc;
2726 }
2727
2728 /*
2729  * As file closes, flush all cached write data for this inode checking
2730  * for write behind errors.
2731  */
2732 int cifs_flush(struct file *file, fl_owner_t id)
2733 {
2734         struct inode *inode = file_inode(file);
2735         int rc = 0;
2736
2737         if (file->f_mode & FMODE_WRITE)
2738                 rc = filemap_write_and_wait(inode->i_mapping);
2739
2740         cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2741         if (rc) {
2742                 /* get more nuanced writeback errors */
2743                 rc = filemap_check_wb_err(file->f_mapping, 0);
2744                 trace_cifs_flush_err(inode->i_ino, rc);
2745         }
2746         return rc;
2747 }
2748
2749 static ssize_t
2750 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2751 {
2752         struct file *file = iocb->ki_filp;
2753         struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2754         struct inode *inode = file->f_mapping->host;
2755         struct cifsInodeInfo *cinode = CIFS_I(inode);
2756         struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2757         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2758         ssize_t rc;
2759
2760         rc = netfs_start_io_write(inode);
2761         if (rc < 0)
2762                 return rc;
2763
2764         /*
2765          * We need to hold the sem to be sure nobody modifies lock list
2766          * with a brlock that prevents writing.
2767          */
2768         down_read(&cinode->lock_sem);
2769
2770         rc = generic_write_checks(iocb, from);
2771         if (rc <= 0)
2772                 goto out;
2773
2774         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) &&
2775             (cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
2776                                      server->vals->exclusive_lock_type, 0,
2777                                      NULL, CIFS_WRITE_OP))) {
2778                 rc = -EACCES;
2779                 goto out;
2780         }
2781
2782         rc = netfs_buffered_write_iter_locked(iocb, from, NULL);
2783
2784 out:
2785         up_read(&cinode->lock_sem);
2786         netfs_end_io_write(inode);
2787         if (rc > 0)
2788                 rc = generic_write_sync(iocb, rc);
2789         return rc;
2790 }
2791
2792 ssize_t
2793 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2794 {
2795         struct inode *inode = file_inode(iocb->ki_filp);
2796         struct cifsInodeInfo *cinode = CIFS_I(inode);
2797         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2798         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2799                                                 iocb->ki_filp->private_data;
2800         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2801         ssize_t written;
2802
2803         written = cifs_get_writer(cinode);
2804         if (written)
2805                 return written;
2806
2807         if (CIFS_CACHE_WRITE(cinode)) {
2808                 if (cap_unix(tcon->ses) &&
2809                     (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2810                     ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
2811                         written = netfs_file_write_iter(iocb, from);
2812                         goto out;
2813                 }
2814                 written = cifs_writev(iocb, from);
2815                 goto out;
2816         }
2817         /*
2818          * For non-oplocked files in strict cache mode we need to write the data
2819          * to the server exactly from the pos to pos+len-1 rather than flush all
2820          * affected pages because it may cause a error with mandatory locks on
2821          * these pages but not on the region from pos to ppos+len-1.
2822          */
2823         written = netfs_file_write_iter(iocb, from);
2824         if (CIFS_CACHE_READ(cinode)) {
2825                 /*
2826                  * We have read level caching and we have just sent a write
2827                  * request to the server thus making data in the cache stale.
2828                  * Zap the cache and set oplock/lease level to NONE to avoid
2829                  * reading stale data from the cache. All subsequent read
2830                  * operations will read new data from the server.
2831                  */
2832                 cifs_zap_mapping(inode);
2833                 cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
2834                          inode);
2835                 cinode->oplock = 0;
2836         }
2837 out:
2838         cifs_put_writer(cinode);
2839         return written;
2840 }
2841
2842 ssize_t cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter)
2843 {
2844         ssize_t rc;
2845         struct inode *inode = file_inode(iocb->ki_filp);
2846
2847         if (iocb->ki_flags & IOCB_DIRECT)
2848                 return netfs_unbuffered_read_iter(iocb, iter);
2849
2850         rc = cifs_revalidate_mapping(inode);
2851         if (rc)
2852                 return rc;
2853
2854         return netfs_file_read_iter(iocb, iter);
2855 }
2856
2857 ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from)
2858 {
2859         struct inode *inode = file_inode(iocb->ki_filp);
2860         struct cifsInodeInfo *cinode = CIFS_I(inode);
2861         ssize_t written;
2862         int rc;
2863
2864         if (iocb->ki_filp->f_flags & O_DIRECT) {
2865                 written = netfs_unbuffered_write_iter(iocb, from);
2866                 if (written > 0 && CIFS_CACHE_READ(cinode)) {
2867                         cifs_zap_mapping(inode);
2868                         cifs_dbg(FYI,
2869                                  "Set no oplock for inode=%p after a write operation\n",
2870                                  inode);
2871                         cinode->oplock = 0;
2872                 }
2873                 return written;
2874         }
2875
2876         written = cifs_get_writer(cinode);
2877         if (written)
2878                 return written;
2879
2880         written = netfs_file_write_iter(iocb, from);
2881
2882         if (!CIFS_CACHE_WRITE(CIFS_I(inode))) {
2883                 rc = filemap_fdatawrite(inode->i_mapping);
2884                 if (rc)
2885                         cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n",
2886                                  rc, inode);
2887         }
2888
2889         cifs_put_writer(cinode);
2890         return written;
2891 }
2892
2893 ssize_t
2894 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
2895 {
2896         struct inode *inode = file_inode(iocb->ki_filp);
2897         struct cifsInodeInfo *cinode = CIFS_I(inode);
2898         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2899         struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2900                                                 iocb->ki_filp->private_data;
2901         struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2902         int rc = -EACCES;
2903
2904         /*
2905          * In strict cache mode we need to read from the server all the time
2906          * if we don't have level II oplock because the server can delay mtime
2907          * change - so we can't make a decision about inode invalidating.
2908          * And we can also fail with pagereading if there are mandatory locks
2909          * on pages affected by this read but not on the region from pos to
2910          * pos+len-1.
2911          */
2912         if (!CIFS_CACHE_READ(cinode))
2913                 return netfs_unbuffered_read_iter(iocb, to);
2914
2915         if ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0) {
2916                 if (iocb->ki_flags & IOCB_DIRECT)
2917                         return netfs_unbuffered_read_iter(iocb, to);
2918                 return netfs_buffered_read_iter(iocb, to);
2919         }
2920
2921         /*
2922          * We need to hold the sem to be sure nobody modifies lock list
2923          * with a brlock that prevents reading.
2924          */
2925         if (iocb->ki_flags & IOCB_DIRECT) {
2926                 rc = netfs_start_io_direct(inode);
2927                 if (rc < 0)
2928                         goto out;
2929                 rc = -EACCES;
2930                 down_read(&cinode->lock_sem);
2931                 if (!cifs_find_lock_conflict(
2932                             cfile, iocb->ki_pos, iov_iter_count(to),
2933                             tcon->ses->server->vals->shared_lock_type,
2934                             0, NULL, CIFS_READ_OP))
2935                         rc = netfs_unbuffered_read_iter_locked(iocb, to);
2936                 up_read(&cinode->lock_sem);
2937                 netfs_end_io_direct(inode);
2938         } else {
2939                 rc = netfs_start_io_read(inode);
2940                 if (rc < 0)
2941                         goto out;
2942                 rc = -EACCES;
2943                 down_read(&cinode->lock_sem);
2944                 if (!cifs_find_lock_conflict(
2945                             cfile, iocb->ki_pos, iov_iter_count(to),
2946                             tcon->ses->server->vals->shared_lock_type,
2947                             0, NULL, CIFS_READ_OP))
2948                         rc = filemap_read(iocb, to, 0);
2949                 up_read(&cinode->lock_sem);
2950                 netfs_end_io_read(inode);
2951         }
2952 out:
2953         return rc;
2954 }
2955
2956 static vm_fault_t cifs_page_mkwrite(struct vm_fault *vmf)
2957 {
2958         return netfs_page_mkwrite(vmf, NULL);
2959 }
2960
2961 static const struct vm_operations_struct cifs_file_vm_ops = {
2962         .fault = filemap_fault,
2963         .map_pages = filemap_map_pages,
2964         .page_mkwrite = cifs_page_mkwrite,
2965 };
2966
2967 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2968 {
2969         int xid, rc = 0;
2970         struct inode *inode = file_inode(file);
2971
2972         xid = get_xid();
2973
2974         if (!CIFS_CACHE_READ(CIFS_I(inode)))
2975                 rc = cifs_zap_mapping(inode);
2976         if (!rc)
2977                 rc = generic_file_mmap(file, vma);
2978         if (!rc)
2979                 vma->vm_ops = &cifs_file_vm_ops;
2980
2981         free_xid(xid);
2982         return rc;
2983 }
2984
2985 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2986 {
2987         int rc, xid;
2988
2989         xid = get_xid();
2990
2991         rc = cifs_revalidate_file(file);
2992         if (rc)
2993                 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
2994                          rc);
2995         if (!rc)
2996                 rc = generic_file_mmap(file, vma);
2997         if (!rc)
2998                 vma->vm_ops = &cifs_file_vm_ops;
2999
3000         free_xid(xid);
3001         return rc;
3002 }
3003
3004 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3005 {
3006         struct cifsFileInfo *open_file;
3007
3008         spin_lock(&cifs_inode->open_file_lock);
3009         list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3010                 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3011                         spin_unlock(&cifs_inode->open_file_lock);
3012                         return 1;
3013                 }
3014         }
3015         spin_unlock(&cifs_inode->open_file_lock);
3016         return 0;
3017 }
3018
3019 /* We do not want to update the file size from server for inodes
3020    open for write - to avoid races with writepage extending
3021    the file - in the future we could consider allowing
3022    refreshing the inode only on increases in the file size
3023    but this is tricky to do without racing with writebehind
3024    page caching in the current Linux kernel design */
3025 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file,
3026                             bool from_readdir)
3027 {
3028         if (!cifsInode)
3029                 return true;
3030
3031         if (is_inode_writable(cifsInode) ||
3032                 ((cifsInode->oplock & CIFS_CACHE_RW_FLG) != 0 && from_readdir)) {
3033                 /* This inode is open for write at least once */
3034                 struct cifs_sb_info *cifs_sb;
3035
3036                 cifs_sb = CIFS_SB(cifsInode->netfs.inode.i_sb);
3037                 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3038                         /* since no page cache to corrupt on directio
3039                         we can change size safely */
3040                         return true;
3041                 }
3042
3043                 if (i_size_read(&cifsInode->netfs.inode) < end_of_file)
3044                         return true;
3045
3046                 return false;
3047         } else
3048                 return true;
3049 }
3050
3051 void cifs_oplock_break(struct work_struct *work)
3052 {
3053         struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3054                                                   oplock_break);
3055         struct inode *inode = d_inode(cfile->dentry);
3056         struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3057         struct cifsInodeInfo *cinode = CIFS_I(inode);
3058         struct cifs_tcon *tcon;
3059         struct TCP_Server_Info *server;
3060         struct tcon_link *tlink;
3061         int rc = 0;
3062         bool purge_cache = false, oplock_break_cancelled;
3063         __u64 persistent_fid, volatile_fid;
3064         __u16 net_fid;
3065
3066         wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
3067                         TASK_UNINTERRUPTIBLE);
3068
3069         tlink = cifs_sb_tlink(cifs_sb);
3070         if (IS_ERR(tlink))
3071                 goto out;
3072         tcon = tlink_tcon(tlink);
3073         server = tcon->ses->server;
3074
3075         server->ops->downgrade_oplock(server, cinode, cfile->oplock_level,
3076                                       cfile->oplock_epoch, &purge_cache);
3077
3078         if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
3079                                                 cifs_has_mand_locks(cinode)) {
3080                 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3081                          inode);
3082                 cinode->oplock = 0;
3083         }
3084
3085         if (inode && S_ISREG(inode->i_mode)) {
3086                 if (CIFS_CACHE_READ(cinode))
3087                         break_lease(inode, O_RDONLY);
3088                 else
3089                         break_lease(inode, O_WRONLY);
3090                 rc = filemap_fdatawrite(inode->i_mapping);
3091                 if (!CIFS_CACHE_READ(cinode) || purge_cache) {
3092                         rc = filemap_fdatawait(inode->i_mapping);
3093                         mapping_set_error(inode->i_mapping, rc);
3094                         cifs_zap_mapping(inode);
3095                 }
3096                 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
3097                 if (CIFS_CACHE_WRITE(cinode))
3098                         goto oplock_break_ack;
3099         }
3100
3101         rc = cifs_push_locks(cfile);
3102         if (rc)
3103                 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
3104
3105 oplock_break_ack:
3106         /*
3107          * When oplock break is received and there are no active
3108          * file handles but cached, then schedule deferred close immediately.
3109          * So, new open will not use cached handle.
3110          */
3111
3112         if (!CIFS_CACHE_HANDLE(cinode) && !list_empty(&cinode->deferred_closes))
3113                 cifs_close_deferred_file(cinode);
3114
3115         persistent_fid = cfile->fid.persistent_fid;
3116         volatile_fid = cfile->fid.volatile_fid;
3117         net_fid = cfile->fid.netfid;
3118         oplock_break_cancelled = cfile->oplock_break_cancelled;
3119
3120         _cifsFileInfo_put(cfile, false /* do not wait for ourself */, false);
3121         /*
3122          * MS-SMB2 3.2.5.19.1 and 3.2.5.19.2 (and MS-CIFS 3.2.5.42) do not require
3123          * an acknowledgment to be sent when the file has already been closed.
3124          */
3125         spin_lock(&cinode->open_file_lock);
3126         /* check list empty since can race with kill_sb calling tree disconnect */
3127         if (!oplock_break_cancelled && !list_empty(&cinode->openFileList)) {
3128                 spin_unlock(&cinode->open_file_lock);
3129                 rc = server->ops->oplock_response(tcon, persistent_fid,
3130                                                   volatile_fid, net_fid, cinode);
3131                 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
3132         } else
3133                 spin_unlock(&cinode->open_file_lock);
3134
3135         cifs_put_tlink(tlink);
3136 out:
3137         cifs_done_oplock_break(cinode);
3138 }
3139
3140 static int cifs_swap_activate(struct swap_info_struct *sis,
3141                               struct file *swap_file, sector_t *span)
3142 {
3143         struct cifsFileInfo *cfile = swap_file->private_data;
3144         struct inode *inode = swap_file->f_mapping->host;
3145         unsigned long blocks;
3146         long long isize;
3147
3148         cifs_dbg(FYI, "swap activate\n");
3149
3150         if (!swap_file->f_mapping->a_ops->swap_rw)
3151                 /* Cannot support swap */
3152                 return -EINVAL;
3153
3154         spin_lock(&inode->i_lock);
3155         blocks = inode->i_blocks;
3156         isize = inode->i_size;
3157         spin_unlock(&inode->i_lock);
3158         if (blocks*512 < isize) {
3159                 pr_warn("swap activate: swapfile has holes\n");
3160                 return -EINVAL;
3161         }
3162         *span = sis->pages;
3163
3164         pr_warn_once("Swap support over SMB3 is experimental\n");
3165
3166         /*
3167          * TODO: consider adding ACL (or documenting how) to prevent other
3168          * users (on this or other systems) from reading it
3169          */
3170
3171
3172         /* TODO: add sk_set_memalloc(inet) or similar */
3173
3174         if (cfile)
3175                 cfile->swapfile = true;
3176         /*
3177          * TODO: Since file already open, we can't open with DENY_ALL here
3178          * but we could add call to grab a byte range lock to prevent others
3179          * from reading or writing the file
3180          */
3181
3182         sis->flags |= SWP_FS_OPS;
3183         return add_swap_extent(sis, 0, sis->max, 0);
3184 }
3185
3186 static void cifs_swap_deactivate(struct file *file)
3187 {
3188         struct cifsFileInfo *cfile = file->private_data;
3189
3190         cifs_dbg(FYI, "swap deactivate\n");
3191
3192         /* TODO: undo sk_set_memalloc(inet) will eventually be needed */
3193
3194         if (cfile)
3195                 cfile->swapfile = false;
3196
3197         /* do we need to unpin (or unlock) the file */
3198 }
3199
3200 /**
3201  * cifs_swap_rw - SMB3 address space operation for swap I/O
3202  * @iocb: target I/O control block
3203  * @iter: I/O buffer
3204  *
3205  * Perform IO to the swap-file.  This is much like direct IO.
3206  */
3207 static int cifs_swap_rw(struct kiocb *iocb, struct iov_iter *iter)
3208 {
3209         ssize_t ret;
3210
3211         if (iov_iter_rw(iter) == READ)
3212                 ret = netfs_unbuffered_read_iter_locked(iocb, iter);
3213         else
3214                 ret = netfs_unbuffered_write_iter_locked(iocb, iter, NULL);
3215         if (ret < 0)
3216                 return ret;
3217         return 0;
3218 }
3219
3220 const struct address_space_operations cifs_addr_ops = {
3221         .read_folio     = netfs_read_folio,
3222         .readahead      = netfs_readahead,
3223         .writepages     = netfs_writepages,
3224         .dirty_folio    = netfs_dirty_folio,
3225         .release_folio  = netfs_release_folio,
3226         .direct_IO      = noop_direct_IO,
3227         .invalidate_folio = netfs_invalidate_folio,
3228         .migrate_folio  = filemap_migrate_folio,
3229         /*
3230          * TODO: investigate and if useful we could add an is_dirty_writeback
3231          * helper if needed
3232          */
3233         .swap_activate  = cifs_swap_activate,
3234         .swap_deactivate = cifs_swap_deactivate,
3235         .swap_rw = cifs_swap_rw,
3236 };
3237
3238 /*
3239  * cifs_readahead requires the server to support a buffer large enough to
3240  * contain the header plus one complete page of data.  Otherwise, we need
3241  * to leave cifs_readahead out of the address space operations.
3242  */
3243 const struct address_space_operations cifs_addr_ops_smallbuf = {
3244         .read_folio     = netfs_read_folio,
3245         .writepages     = netfs_writepages,
3246         .dirty_folio    = netfs_dirty_folio,
3247         .release_folio  = netfs_release_folio,
3248         .invalidate_folio = netfs_invalidate_folio,
3249         .migrate_folio  = filemap_migrate_folio,
3250 };