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