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