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 cfile = find_writable_file(cinode, FIND_FSUID_ONLY); 1016 rc = cifs_file_flush(xid, inode, cfile); 1017 if (!rc) { 1018 if (cfile) { 1019 struct netfs_inode *ictx = netfs_inode(inode); 1020 1021 tcon = tlink_tcon(cfile->tlink); 1022 server = tcon->ses->server; 1023 netfs_wb_begin(ictx, false); 1024 rc = server->ops->set_file_size(xid, tcon, 1025 cfile, 0, false); 1026 if (!rc) { 1027 netfs_resize_file(&cinode->netfs, 0, true); 1028 cifs_setsize(inode, 0); 1029 cifs_invalidate_cache(inode, 0); 1030 } 1031 netfs_wb_end(ictx); 1032 } else { 1033 /* 1034 * No cached handle; evict stale pages so they can't 1035 * be served after the file is later extended; let 1036 * the server's O_TRUNC open response set the i_size 1037 */ 1038 truncate_inode_pages(inode->i_mapping, 0); 1039 cifs_invalidate_cache(inode, 0); 1040 } 1041 } 1042 1043 out: 1044 filemap_invalidate_unlock(inode->i_mapping); 1045 inode_unlock(inode); 1046 if (cfile) 1047 cifsFileInfo_put(cfile); 1048 return rc; 1049 } 1050 1051 int cifs_open(struct inode *inode, struct file *file) 1052 1053 { 1054 struct cifs_sb_info *cifs_sb = CIFS_SB(inode); 1055 struct cifs_open_info_data data = {}; 1056 struct cifsFileInfo *cfile = NULL; 1057 struct TCP_Server_Info *server; 1058 struct cifs_pending_open open; 1059 bool posix_open_ok = false; 1060 struct cifs_fid fid = {}; 1061 struct tcon_link *tlink; 1062 struct cifs_tcon *tcon; 1063 const char *full_path; 1064 unsigned int sbflags; 1065 int rc = -EACCES; 1066 unsigned int xid; 1067 __u32 oplock; 1068 void *page; 1069 1070 xid = get_xid(); 1071 1072 if (unlikely(cifs_forced_shutdown(cifs_sb))) { 1073 free_xid(xid); 1074 return smb_EIO(smb_eio_trace_forced_shutdown); 1075 } 1076 1077 tlink = cifs_sb_tlink(cifs_sb); 1078 if (IS_ERR(tlink)) { 1079 free_xid(xid); 1080 return PTR_ERR(tlink); 1081 } 1082 tcon = tlink_tcon(tlink); 1083 server = tcon->ses->server; 1084 1085 page = alloc_dentry_path(); 1086 full_path = build_path_from_dentry(file_dentry(file), page); 1087 if (IS_ERR(full_path)) { 1088 rc = PTR_ERR(full_path); 1089 goto out; 1090 } 1091 1092 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n", 1093 inode, file->f_flags, full_path); 1094 1095 sbflags = cifs_sb_flags(cifs_sb); 1096 if ((file->f_flags & O_DIRECT) && (sbflags & CIFS_MOUNT_STRICT_IO)) { 1097 if (sbflags & CIFS_MOUNT_NO_BRL) 1098 file->f_op = &cifs_file_direct_nobrl_ops; 1099 else 1100 file->f_op = &cifs_file_direct_ops; 1101 } 1102 1103 if (file->f_flags & O_TRUNC) { 1104 rc = cifs_do_truncate(xid, file_dentry(file)); 1105 if (rc) 1106 goto out; 1107 } 1108 1109 /* Get the cached handle as SMB2 close is deferred */ 1110 if (OPEN_FMODE(file->f_flags) & FMODE_WRITE) { 1111 rc = __cifs_get_writable_file(CIFS_I(inode), 1112 FIND_FSUID_ONLY | 1113 FIND_NO_PENDING_DELETE | 1114 FIND_OPEN_FLAGS, 1115 file->f_flags, &cfile); 1116 } else { 1117 cfile = __find_readable_file(CIFS_I(inode), 1118 FIND_NO_PENDING_DELETE | 1119 FIND_OPEN_FLAGS, 1120 file->f_flags); 1121 rc = cfile ? 0 : -ENOENT; 1122 } 1123 if (rc == 0) { 1124 trace_smb3_open_cached(xid, tcon->tid, tcon->ses->Suid, 1125 cfile->fid.persistent_fid, 1126 file->f_flags, cfile->f_flags); 1127 file->private_data = cfile; 1128 spin_lock(&CIFS_I(inode)->deferred_lock); 1129 cifs_del_deferred_close(cfile); 1130 spin_unlock(&CIFS_I(inode)->deferred_lock); 1131 goto use_cache; 1132 } 1133 /* hard link on the deferred close file */ 1134 rc = cifs_get_hardlink_path(tcon, inode, file); 1135 if (rc) 1136 cifs_close_deferred_file(CIFS_I(inode)); 1137 1138 if (server->oplocks) 1139 oplock = REQ_OPLOCK; 1140 else 1141 oplock = 0; 1142 1143 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1144 if (!tcon->broken_posix_open && tcon->unix_ext && 1145 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP & 1146 le64_to_cpu(tcon->fsUnixInfo.Capability))) { 1147 /* can not refresh inode info since size could be stale */ 1148 rc = cifs_posix_open(full_path, &inode, inode->i_sb, 1149 cifs_sb->ctx->file_mode /* ignored */, 1150 file->f_flags, &oplock, &fid.netfid, xid); 1151 if (rc == 0) { 1152 cifs_dbg(FYI, "posix open succeeded\n"); 1153 posix_open_ok = true; 1154 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) { 1155 if (tcon->ses->serverNOS) 1156 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", 1157 tcon->ses->ip_addr, 1158 tcon->ses->serverNOS); 1159 tcon->broken_posix_open = true; 1160 } else if ((rc != -EIO) && (rc != -EREMOTE) && 1161 (rc != -EOPNOTSUPP)) /* path not found or net err */ 1162 goto out; 1163 /* 1164 * Else fallthrough to retry open the old way on network i/o 1165 * or DFS errors. 1166 */ 1167 } 1168 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1169 1170 if (server->ops->get_lease_key) 1171 server->ops->get_lease_key(inode, &fid); 1172 1173 cifs_add_pending_open(&fid, tlink, &open); 1174 1175 if (!posix_open_ok) { 1176 if (server->ops->get_lease_key) 1177 server->ops->get_lease_key(inode, &fid); 1178 1179 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon, file->f_flags, &oplock, &fid, 1180 xid, &data); 1181 if (rc) { 1182 cifs_del_pending_open(&open); 1183 goto out; 1184 } 1185 } 1186 1187 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock, data.symlink_target); 1188 if (cfile == NULL) { 1189 if (server->ops->close) 1190 server->ops->close(xid, tcon, &fid); 1191 cifs_del_pending_open(&open); 1192 rc = -ENOMEM; 1193 goto out; 1194 } 1195 1196 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1197 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) { 1198 /* 1199 * Time to set mode which we can not set earlier due to 1200 * problems creating new read-only files. 1201 */ 1202 struct cifs_unix_set_info_args args = { 1203 .mode = inode->i_mode, 1204 .uid = INVALID_UID, /* no change */ 1205 .gid = INVALID_GID, /* no change */ 1206 .ctime = NO_CHANGE_64, 1207 .atime = NO_CHANGE_64, 1208 .mtime = NO_CHANGE_64, 1209 .device = 0, 1210 }; 1211 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid, 1212 cfile->pid); 1213 } 1214 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1215 1216 use_cache: 1217 fscache_use_cookie(cifs_inode_cookie(file_inode(file)), 1218 file->f_mode & FMODE_WRITE); 1219 if (!(file->f_flags & O_DIRECT)) 1220 goto out; 1221 if ((file->f_flags & (O_ACCMODE | O_APPEND)) == O_RDONLY) 1222 goto out; 1223 cifs_invalidate_cache(file_inode(file), FSCACHE_INVAL_DIO_WRITE); 1224 1225 out: 1226 free_dentry_path(page); 1227 free_xid(xid); 1228 cifs_put_tlink(tlink); 1229 cifs_free_open_info(&data); 1230 return rc; 1231 } 1232 1233 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1234 static int cifs_push_posix_locks(struct cifsFileInfo *cfile); 1235 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1236 1237 /* 1238 * Try to reacquire byte range locks that were released when session 1239 * to server was lost. 1240 */ 1241 static int 1242 cifs_relock_file(struct cifsFileInfo *cfile) 1243 { 1244 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1245 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1246 int rc = 0; 1247 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1248 struct cifs_sb_info *cifs_sb = CIFS_SB(cinode); 1249 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1250 1251 down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING); 1252 if (cinode->can_cache_brlcks) { 1253 /* can cache locks - no need to relock */ 1254 up_read(&cinode->lock_sem); 1255 return rc; 1256 } 1257 1258 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1259 if (cap_unix(tcon->ses) && 1260 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) && 1261 ((cifs_sb_flags(cifs_sb) & CIFS_MOUNT_NOPOSIXBRL) == 0)) 1262 rc = cifs_push_posix_locks(cfile); 1263 else 1264 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1265 rc = tcon->ses->server->ops->push_mand_locks(cfile); 1266 1267 up_read(&cinode->lock_sem); 1268 return rc; 1269 } 1270 1271 static int 1272 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush) 1273 { 1274 int rc = -EACCES; 1275 unsigned int xid; 1276 __u32 oplock; 1277 struct cifs_sb_info *cifs_sb; 1278 struct cifs_tcon *tcon; 1279 struct TCP_Server_Info *server; 1280 struct cifsInodeInfo *cinode; 1281 struct inode *inode; 1282 void *page; 1283 const char *full_path; 1284 int desired_access; 1285 int disposition = FILE_OPEN; 1286 int create_options = CREATE_NOT_DIR; 1287 struct cifs_open_parms oparms; 1288 int rdwr_for_fscache = 0; 1289 1290 xid = get_xid(); 1291 mutex_lock(&cfile->fh_mutex); 1292 if (!cfile->invalidHandle) { 1293 mutex_unlock(&cfile->fh_mutex); 1294 free_xid(xid); 1295 return 0; 1296 } 1297 1298 inode = d_inode(cfile->dentry); 1299 cifs_sb = CIFS_SB(inode->i_sb); 1300 tcon = tlink_tcon(cfile->tlink); 1301 server = tcon->ses->server; 1302 1303 /* 1304 * Can not grab rename sem here because various ops, including those 1305 * that already have the rename sem can end up causing writepage to get 1306 * called and if the server was down that means we end up here, and we 1307 * can never tell if the caller already has the rename_sem. 1308 */ 1309 page = alloc_dentry_path(); 1310 full_path = build_path_from_dentry(cfile->dentry, page); 1311 if (IS_ERR(full_path)) { 1312 mutex_unlock(&cfile->fh_mutex); 1313 free_dentry_path(page); 1314 free_xid(xid); 1315 return PTR_ERR(full_path); 1316 } 1317 1318 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n", 1319 inode, cfile->f_flags, full_path); 1320 1321 if (tcon->ses->server->oplocks) 1322 oplock = REQ_OPLOCK; 1323 else 1324 oplock = 0; 1325 1326 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1327 if (tcon->unix_ext && cap_unix(tcon->ses) && 1328 (CIFS_UNIX_POSIX_PATH_OPS_CAP & 1329 le64_to_cpu(tcon->fsUnixInfo.Capability))) { 1330 /* 1331 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the 1332 * original open. Must mask them off for a reopen. 1333 */ 1334 unsigned int oflags = cfile->f_flags & 1335 ~(O_CREAT | O_EXCL | O_TRUNC); 1336 1337 rc = cifs_posix_open(full_path, NULL, inode->i_sb, 1338 cifs_sb->ctx->file_mode /* ignored */, 1339 oflags, &oplock, &cfile->fid.netfid, xid); 1340 if (rc == 0) { 1341 cifs_dbg(FYI, "posix reopen succeeded\n"); 1342 oparms.reconnect = true; 1343 goto reopen_success; 1344 } 1345 /* 1346 * fallthrough to retry open the old way on errors, especially 1347 * in the reconnect path it is important to retry hard 1348 */ 1349 } 1350 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1351 1352 /* If we're caching, we need to be able to fill in around partial writes. */ 1353 if (cifs_fscache_enabled(inode) && (cfile->f_flags & O_ACCMODE) == O_WRONLY) 1354 rdwr_for_fscache = 1; 1355 1356 desired_access = cifs_convert_flags(cfile->f_flags, rdwr_for_fscache); 1357 create_options |= cifs_open_create_options(cfile->f_flags, 1358 create_options); 1359 1360 if (server->ops->get_lease_key) 1361 server->ops->get_lease_key(inode, &cfile->fid); 1362 1363 retry_open: 1364 oparms = (struct cifs_open_parms) { 1365 .tcon = tcon, 1366 .cifs_sb = cifs_sb, 1367 .desired_access = desired_access, 1368 .create_options = cifs_create_options(cifs_sb, create_options), 1369 .disposition = disposition, 1370 .path = full_path, 1371 .fid = &cfile->fid, 1372 .reconnect = true, 1373 }; 1374 1375 /* 1376 * Can not refresh inode by passing in file_info buf to be returned by 1377 * ops->open and then calling get_inode_info with returned buf since 1378 * file might have write behind data that needs to be flushed and server 1379 * version of file size can be stale. If we knew for sure that inode was 1380 * not dirty locally we could do this. 1381 */ 1382 rc = server->ops->open(xid, &oparms, &oplock, NULL); 1383 if (rc == -ENOENT && oparms.reconnect == false) { 1384 /* durable handle timeout is expired - open the file again */ 1385 rc = server->ops->open(xid, &oparms, &oplock, NULL); 1386 /* indicate that we need to relock the file */ 1387 oparms.reconnect = true; 1388 } 1389 if (rc == -EACCES && rdwr_for_fscache == 1) { 1390 desired_access = cifs_convert_flags(cfile->f_flags, 0); 1391 rdwr_for_fscache = 2; 1392 goto retry_open; 1393 } 1394 1395 if (rc) { 1396 mutex_unlock(&cfile->fh_mutex); 1397 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc); 1398 cifs_dbg(FYI, "oplock: %d\n", oplock); 1399 goto reopen_error_exit; 1400 } 1401 1402 if (rdwr_for_fscache == 2) 1403 cifs_invalidate_cache(inode, FSCACHE_INVAL_DIO_WRITE); 1404 1405 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1406 reopen_success: 1407 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1408 cfile->invalidHandle = false; 1409 mutex_unlock(&cfile->fh_mutex); 1410 cinode = CIFS_I(inode); 1411 1412 if (can_flush) { 1413 rc = filemap_write_and_wait(inode->i_mapping); 1414 if (!is_interrupt_error(rc)) 1415 mapping_set_error(inode->i_mapping, rc); 1416 1417 if (tcon->posix_extensions) { 1418 rc = smb311_posix_get_inode_info(&inode, full_path, 1419 NULL, inode->i_sb, xid); 1420 } else if (tcon->unix_ext) { 1421 rc = cifs_get_inode_info_unix(&inode, full_path, 1422 inode->i_sb, xid); 1423 } else { 1424 rc = cifs_get_inode_info(&inode, full_path, NULL, 1425 inode->i_sb, xid, NULL); 1426 } 1427 } 1428 /* 1429 * Else we are writing out data to server already and could deadlock if 1430 * we tried to flush data, and since we do not know if we have data that 1431 * would invalidate the current end of file on the server we can not go 1432 * to the server to get the new inode info. 1433 */ 1434 1435 /* 1436 * If the server returned a read oplock and we have mandatory brlocks, 1437 * set oplock level to None. 1438 */ 1439 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) { 1440 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n"); 1441 oplock = 0; 1442 } 1443 1444 scoped_guard(spinlock, &cinode->open_file_lock) 1445 server->ops->set_fid(cfile, &cfile->fid, oplock); 1446 if (oparms.reconnect) 1447 cifs_relock_file(cfile); 1448 1449 reopen_error_exit: 1450 free_dentry_path(page); 1451 free_xid(xid); 1452 return rc; 1453 } 1454 1455 void smb2_deferred_work_close(struct work_struct *work) 1456 { 1457 struct cifsFileInfo *cfile = container_of(work, 1458 struct cifsFileInfo, deferred.work); 1459 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1460 1461 spin_lock(&cinode->deferred_lock); 1462 cifs_del_deferred_close(cfile); 1463 cfile->deferred_close_scheduled = false; 1464 spin_unlock(&cinode->deferred_lock); 1465 _cifsFileInfo_put(cfile, true, false); 1466 } 1467 1468 static bool 1469 smb2_can_defer_close(struct inode *inode, struct cifs_deferred_close *dclose) 1470 { 1471 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1472 struct cifsInodeInfo *cinode = CIFS_I(inode); 1473 unsigned int oplock = READ_ONCE(cinode->oplock); 1474 1475 return cifs_sb->ctx->closetimeo && cinode->lease_granted && dclose && 1476 (oplock == CIFS_CACHE_RHW_FLG || oplock == CIFS_CACHE_RH_FLG) && 1477 !test_bit(CIFS_INO_CLOSE_ON_LOCK, &cinode->flags); 1478 1479 } 1480 1481 int cifs_close(struct inode *inode, struct file *file) 1482 { 1483 struct cifsFileInfo *cfile; 1484 struct cifsInodeInfo *cinode = CIFS_I(inode); 1485 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb); 1486 struct cifs_deferred_close *dclose; 1487 struct cifs_tcon *tcon; 1488 1489 cifs_fscache_unuse_inode_cookie(inode, file->f_mode & FMODE_WRITE); 1490 1491 if (file->private_data != NULL) { 1492 cfile = file->private_data; 1493 file->private_data = NULL; 1494 dclose = kmalloc_obj(struct cifs_deferred_close); 1495 if ((cfile->status_file_deleted == false) && 1496 (smb2_can_defer_close(inode, dclose))) { 1497 if (test_and_clear_bit(NETFS_ICTX_MODIFIED_ATTR, &cinode->netfs.flags)) { 1498 inode_set_mtime_to_ts(inode, 1499 inode_set_ctime_current(inode)); 1500 } 1501 spin_lock(&cinode->deferred_lock); 1502 cifs_add_deferred_close(cfile, dclose); 1503 if (cfile->deferred_close_scheduled && 1504 delayed_work_pending(&cfile->deferred)) { 1505 /* 1506 * If there is no pending work, mod_delayed_work queues new work. 1507 * So, Increase the ref count to avoid use-after-free. 1508 */ 1509 if (!mod_delayed_work(deferredclose_wq, 1510 &cfile->deferred, cifs_sb->ctx->closetimeo)) 1511 cifsFileInfo_get(cfile); 1512 } else { 1513 /* Deferred close for files */ 1514 tcon = tlink_tcon(cfile->tlink); 1515 trace_smb3_close_cached(tcon->tid, tcon->ses->Suid, 1516 cfile->fid.persistent_fid, 1517 cifs_sb->ctx->closetimeo); 1518 /* 1519 * Each queued execution owns one reference. 1520 * If nothing was queued, the reference of 1521 * the closing file is dropped below. 1522 */ 1523 if (queue_delayed_work(deferredclose_wq, 1524 &cfile->deferred, 1525 cifs_sb->ctx->closetimeo)) { 1526 cfile->deferred_close_scheduled = true; 1527 spin_unlock(&cinode->deferred_lock); 1528 return 0; 1529 } 1530 } 1531 spin_unlock(&cinode->deferred_lock); 1532 _cifsFileInfo_put(cfile, true, false); 1533 } else { 1534 _cifsFileInfo_put(cfile, true, false); 1535 kfree(dclose); 1536 } 1537 } 1538 1539 /* return code from the ->release op is always ignored */ 1540 return 0; 1541 } 1542 1543 void 1544 cifs_reopen_persistent_handles(struct cifs_tcon *tcon) 1545 { 1546 struct cifsFileInfo *open_file, *tmp; 1547 LIST_HEAD(tmp_list); 1548 1549 if (!tcon->use_persistent || !tcon->need_reopen_files) 1550 return; 1551 1552 tcon->need_reopen_files = false; 1553 1554 cifs_dbg(FYI, "Reopen persistent handles\n"); 1555 1556 /* list all files open on tree connection, reopen resilient handles */ 1557 spin_lock(&tcon->open_file_lock); 1558 list_for_each_entry(open_file, &tcon->openFileList, tlist) { 1559 if (!open_file->invalidHandle) 1560 continue; 1561 cifsFileInfo_get(open_file); 1562 list_add_tail(&open_file->rlist, &tmp_list); 1563 } 1564 spin_unlock(&tcon->open_file_lock); 1565 1566 list_for_each_entry_safe(open_file, tmp, &tmp_list, rlist) { 1567 if (cifs_reopen_file(open_file, false /* do not flush */)) 1568 tcon->need_reopen_files = true; 1569 list_del_init(&open_file->rlist); 1570 cifsFileInfo_put(open_file); 1571 } 1572 } 1573 1574 int cifs_closedir(struct inode *inode, struct file *file) 1575 { 1576 int rc = 0; 1577 unsigned int xid; 1578 struct cifsFileInfo *cfile = file->private_data; 1579 struct cifs_tcon *tcon; 1580 struct TCP_Server_Info *server; 1581 char *buf; 1582 1583 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode); 1584 1585 if (cfile == NULL) 1586 return rc; 1587 1588 xid = get_xid(); 1589 tcon = tlink_tcon(cfile->tlink); 1590 server = tcon->ses->server; 1591 1592 cifs_dbg(FYI, "Freeing private data in close dir\n"); 1593 spin_lock(&cfile->file_info_lock); 1594 if (server->ops->dir_needs_close(cfile)) { 1595 cfile->invalidHandle = true; 1596 spin_unlock(&cfile->file_info_lock); 1597 if (server->ops->close_dir) 1598 rc = server->ops->close_dir(xid, tcon, &cfile->fid); 1599 else 1600 rc = -ENOSYS; 1601 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc); 1602 /* not much we can do if it fails anyway, ignore rc */ 1603 rc = 0; 1604 } else 1605 spin_unlock(&cfile->file_info_lock); 1606 1607 buf = cfile->srch_inf.ntwrk_buf_start; 1608 if (buf) { 1609 cifs_dbg(FYI, "closedir free smb buf in srch struct\n"); 1610 cfile->srch_inf.ntwrk_buf_start = NULL; 1611 if (cfile->srch_inf.smallBuf) 1612 cifs_small_buf_release(buf); 1613 else if (cfile->srch_inf.is_dynamic_buf) 1614 kfree(buf); 1615 else 1616 cifs_buf_release(buf); 1617 } 1618 1619 cifs_put_tlink(cfile->tlink); 1620 kfree(file->private_data); 1621 file->private_data = NULL; 1622 /* BB can we lock the filestruct while this is going on? */ 1623 free_xid(xid); 1624 return rc; 1625 } 1626 1627 static struct cifsLockInfo * 1628 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 flags) 1629 { 1630 struct cifsLockInfo *lock = 1631 kmalloc_obj(struct cifsLockInfo); 1632 if (!lock) 1633 return lock; 1634 lock->offset = offset; 1635 lock->length = length; 1636 lock->type = type; 1637 lock->pid = current->tgid; 1638 lock->flags = flags; 1639 INIT_LIST_HEAD(&lock->blist); 1640 init_waitqueue_head(&lock->block_q); 1641 return lock; 1642 } 1643 1644 void 1645 cifs_del_lock_waiters(struct cifsLockInfo *lock) 1646 { 1647 struct cifsLockInfo *li, *tmp; 1648 list_for_each_entry_safe(li, tmp, &lock->blist, blist) { 1649 list_del_init(&li->blist); 1650 wake_up(&li->block_q); 1651 } 1652 } 1653 1654 #define CIFS_LOCK_OP 0 1655 #define CIFS_READ_OP 1 1656 #define CIFS_WRITE_OP 2 1657 1658 /* @rw_check : 0 - no op, 1 - read, 2 - write */ 1659 static bool 1660 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset, 1661 __u64 length, __u8 type, __u16 flags, 1662 struct cifsFileInfo *cfile, 1663 struct cifsLockInfo **conf_lock, int rw_check) 1664 { 1665 struct cifsLockInfo *li; 1666 struct cifsFileInfo *cur_cfile = fdlocks->cfile; 1667 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server; 1668 1669 list_for_each_entry(li, &fdlocks->locks, llist) { 1670 if (offset + length <= li->offset || 1671 offset >= li->offset + li->length) 1672 continue; 1673 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid && 1674 server->ops->compare_fids(cfile, cur_cfile)) { 1675 /* shared lock prevents write op through the same fid */ 1676 if (!(li->type & server->vals->shared_lock_type) || 1677 rw_check != CIFS_WRITE_OP) 1678 continue; 1679 } 1680 if ((type & server->vals->shared_lock_type) && 1681 ((server->ops->compare_fids(cfile, cur_cfile) && 1682 current->tgid == li->pid) || type == li->type)) 1683 continue; 1684 if (rw_check == CIFS_LOCK_OP && 1685 (flags & FL_OFDLCK) && (li->flags & FL_OFDLCK) && 1686 server->ops->compare_fids(cfile, cur_cfile)) 1687 continue; 1688 if (conf_lock) 1689 *conf_lock = li; 1690 trace_smb3_lock_conflict(cfile->fid.persistent_fid, 1691 offset, length, type, 1692 li->offset, li->length, li->type, li->pid); 1693 return true; 1694 } 1695 return false; 1696 } 1697 1698 bool 1699 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length, 1700 __u8 type, __u16 flags, 1701 struct cifsLockInfo **conf_lock, int rw_check) 1702 { 1703 bool rc = false; 1704 struct cifs_fid_locks *cur; 1705 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1706 1707 list_for_each_entry(cur, &cinode->llist, llist) { 1708 rc = cifs_find_fid_lock_conflict(cur, offset, length, type, 1709 flags, cfile, conf_lock, 1710 rw_check); 1711 if (rc) 1712 break; 1713 } 1714 1715 return rc; 1716 } 1717 1718 /* 1719 * Check if there is another lock that prevents us to set the lock (mandatory 1720 * style). If such a lock exists, update the flock structure with its 1721 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks 1722 * or leave it the same if we can't. Returns 0 if we don't need to request to 1723 * the server or 1 otherwise. 1724 */ 1725 static int 1726 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length, 1727 __u8 type, struct file_lock *flock) 1728 { 1729 int rc = 0; 1730 struct cifsLockInfo *conf_lock; 1731 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1732 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server; 1733 bool exist; 1734 1735 down_read(&cinode->lock_sem); 1736 1737 exist = cifs_find_lock_conflict(cfile, offset, length, type, 1738 flock->c.flc_flags, &conf_lock, 1739 CIFS_LOCK_OP); 1740 if (exist) { 1741 flock->fl_start = conf_lock->offset; 1742 flock->fl_end = conf_lock->offset + conf_lock->length - 1; 1743 flock->c.flc_pid = conf_lock->pid; 1744 if (conf_lock->type & server->vals->shared_lock_type) 1745 flock->c.flc_type = F_RDLCK; 1746 else 1747 flock->c.flc_type = F_WRLCK; 1748 } else if (!cinode->can_cache_brlcks) 1749 rc = 1; 1750 else 1751 flock->c.flc_type = F_UNLCK; 1752 1753 up_read(&cinode->lock_sem); 1754 return rc; 1755 } 1756 1757 static void 1758 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock) 1759 { 1760 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1761 cifs_down_write(&cinode->lock_sem); 1762 list_add_tail(&lock->llist, &cfile->llist->locks); 1763 up_write(&cinode->lock_sem); 1764 } 1765 1766 /* 1767 * Set the byte-range lock (mandatory style). Returns: 1768 * 1) 0, if we set the lock and don't need to request to the server; 1769 * 2) 1, if no locks prevent us but we need to request to the server; 1770 * 3) -EACCES, if there is a lock that prevents us and wait is false. 1771 */ 1772 static int 1773 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock, 1774 bool wait, unsigned int xid) 1775 { 1776 struct cifsLockInfo *conf_lock; 1777 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 1778 bool exist; 1779 int rc = 0; 1780 1781 try_again: 1782 exist = false; 1783 cifs_down_write(&cinode->lock_sem); 1784 1785 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length, 1786 lock->type, lock->flags, &conf_lock, 1787 CIFS_LOCK_OP); 1788 if (!exist && cinode->can_cache_brlcks) { 1789 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1790 1791 list_add_tail(&lock->llist, &cfile->llist->locks); 1792 trace_smb3_lock_cached(xid, cfile->fid.persistent_fid, 1793 tcon->tid, tcon->ses->Suid, 1794 lock->offset, lock->length, 1795 lock->type, 1, 0); 1796 up_write(&cinode->lock_sem); 1797 return rc; 1798 } 1799 1800 if (!exist) 1801 rc = 1; 1802 else if (!wait) 1803 rc = -EACCES; 1804 else { 1805 list_add_tail(&lock->blist, &conf_lock->blist); 1806 up_write(&cinode->lock_sem); 1807 rc = wait_event_interruptible(lock->block_q, 1808 (lock->blist.prev == &lock->blist) && 1809 (lock->blist.next == &lock->blist)); 1810 if (!rc) 1811 goto try_again; 1812 cifs_down_write(&cinode->lock_sem); 1813 list_del_init(&lock->blist); 1814 } 1815 1816 up_write(&cinode->lock_sem); 1817 return rc; 1818 } 1819 1820 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1821 /* 1822 * Check if there is another lock that prevents us to set the lock (posix 1823 * style). If such a lock exists, update the flock structure with its 1824 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks 1825 * or leave it the same if we can't. Returns 0 if we don't need to request to 1826 * the server or 1 otherwise. 1827 */ 1828 static int 1829 cifs_posix_lock_test(struct file *file, struct file_lock *flock) 1830 { 1831 int rc = 0; 1832 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file)); 1833 unsigned char saved_type = flock->c.flc_type; 1834 1835 if ((flock->c.flc_flags & FL_POSIX) == 0) 1836 return 1; 1837 1838 down_read(&cinode->lock_sem); 1839 posix_test_lock(file, flock); 1840 1841 if (lock_is_unlock(flock) && !cinode->can_cache_brlcks) { 1842 flock->c.flc_type = saved_type; 1843 rc = 1; 1844 } 1845 1846 up_read(&cinode->lock_sem); 1847 return rc; 1848 } 1849 1850 /* 1851 * Set the byte-range lock (posix style). Returns: 1852 * 1) <0, if the error occurs while setting the lock; 1853 * 2) 0, if we set the lock and don't need to request to the server; 1854 * 3) FILE_LOCK_DEFERRED, if we will wait for some other file_lock; 1855 * 4) FILE_LOCK_DEFERRED + 1, if we need to request to the server. 1856 */ 1857 static int 1858 cifs_posix_lock_set(struct file *file, struct file_lock *flock) 1859 { 1860 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file)); 1861 int rc = FILE_LOCK_DEFERRED + 1; 1862 1863 if ((flock->c.flc_flags & FL_POSIX) == 0) 1864 return rc; 1865 1866 cifs_down_write(&cinode->lock_sem); 1867 if (!cinode->can_cache_brlcks) { 1868 up_write(&cinode->lock_sem); 1869 return rc; 1870 } 1871 1872 rc = posix_lock_file(file, flock, NULL); 1873 up_write(&cinode->lock_sem); 1874 return rc; 1875 } 1876 1877 int 1878 cifs_push_mandatory_locks(struct cifsFileInfo *cfile) 1879 { 1880 unsigned int xid; 1881 int rc = 0, stored_rc; 1882 struct cifsLockInfo *li, *tmp; 1883 struct cifs_tcon *tcon; 1884 unsigned int num, max_num, max_buf; 1885 LOCKING_ANDX_RANGE *buf, *cur; 1886 static const int types[] = { 1887 LOCKING_ANDX_LARGE_FILES, 1888 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES 1889 }; 1890 int i; 1891 1892 xid = get_xid(); 1893 tcon = tlink_tcon(cfile->tlink); 1894 1895 /* 1896 * Accessing maxBuf is racy with cifs_reconnect - need to store value 1897 * and check it before using. 1898 */ 1899 max_buf = tcon->ses->server->maxBuf; 1900 if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) { 1901 free_xid(xid); 1902 return -EINVAL; 1903 } 1904 1905 BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) > 1906 PAGE_SIZE); 1907 max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr), 1908 PAGE_SIZE); 1909 max_num = (max_buf - sizeof(struct smb_hdr)) / 1910 sizeof(LOCKING_ANDX_RANGE); 1911 buf = kzalloc_objs(LOCKING_ANDX_RANGE, max_num); 1912 if (!buf) { 1913 free_xid(xid); 1914 return -ENOMEM; 1915 } 1916 1917 for (i = 0; i < 2; i++) { 1918 cur = buf; 1919 num = 0; 1920 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) { 1921 if (li->type != types[i]) 1922 continue; 1923 cur->Pid = cpu_to_le16(li->pid); 1924 cur->LengthLow = cpu_to_le32((u32)li->length); 1925 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32)); 1926 cur->OffsetLow = cpu_to_le32((u32)li->offset); 1927 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32)); 1928 if (++num == max_num) { 1929 stored_rc = cifs_lockv(xid, tcon, 1930 cfile->fid.netfid, 1931 (__u8)li->type, 0, num, 1932 buf); 1933 if (stored_rc) 1934 rc = stored_rc; 1935 cur = buf; 1936 num = 0; 1937 } else 1938 cur++; 1939 } 1940 1941 if (num) { 1942 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid, 1943 (__u8)types[i], 0, num, buf); 1944 if (stored_rc) 1945 rc = stored_rc; 1946 } 1947 } 1948 1949 kfree(buf); 1950 free_xid(xid); 1951 return rc; 1952 } 1953 1954 static __u32 1955 hash_lockowner(fl_owner_t owner) 1956 { 1957 return cifs_lock_secret ^ hash32_ptr((const void *)owner); 1958 } 1959 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 1960 1961 struct lock_to_push { 1962 struct list_head llist; 1963 __u64 offset; 1964 __u64 length; 1965 __u32 pid; 1966 __u16 netfid; 1967 __u8 type; 1968 }; 1969 1970 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 1971 static int 1972 cifs_push_posix_locks(struct cifsFileInfo *cfile) 1973 { 1974 struct inode *inode = d_inode(cfile->dentry); 1975 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 1976 struct file_lock *flock; 1977 struct file_lock_context *flctx = locks_inode_context(inode); 1978 unsigned int count = 0, i; 1979 int rc = 0, xid, type; 1980 struct list_head locks_to_send, *el; 1981 struct lock_to_push *lck, *tmp; 1982 __u64 length; 1983 1984 xid = get_xid(); 1985 1986 if (!flctx) 1987 goto out; 1988 1989 spin_lock(&flctx->flc_lock); 1990 list_for_each(el, &flctx->flc_posix) { 1991 count++; 1992 } 1993 spin_unlock(&flctx->flc_lock); 1994 1995 INIT_LIST_HEAD(&locks_to_send); 1996 1997 /* 1998 * Allocating count locks is enough because no FL_POSIX locks can be 1999 * added to the list while we are holding cinode->lock_sem that 2000 * protects locking operations of this inode. 2001 */ 2002 for (i = 0; i < count; i++) { 2003 lck = kmalloc_obj(struct lock_to_push); 2004 if (!lck) { 2005 rc = -ENOMEM; 2006 goto err_out; 2007 } 2008 list_add_tail(&lck->llist, &locks_to_send); 2009 } 2010 2011 el = locks_to_send.next; 2012 spin_lock(&flctx->flc_lock); 2013 for_each_file_lock(flock, &flctx->flc_posix) { 2014 unsigned char ftype = flock->c.flc_type; 2015 2016 if (el == &locks_to_send) { 2017 /* 2018 * The list ended. We don't have enough allocated 2019 * structures - something is really wrong. 2020 */ 2021 cifs_dbg(VFS, "Can't push all brlocks!\n"); 2022 break; 2023 } 2024 length = cifs_flock_len(flock); 2025 if (ftype == F_RDLCK || ftype == F_SHLCK) 2026 type = CIFS_RDLCK; 2027 else 2028 type = CIFS_WRLCK; 2029 lck = list_entry(el, struct lock_to_push, llist); 2030 lck->pid = hash_lockowner(flock->c.flc_owner); 2031 lck->netfid = cfile->fid.netfid; 2032 lck->length = length; 2033 lck->type = type; 2034 lck->offset = flock->fl_start; 2035 } 2036 spin_unlock(&flctx->flc_lock); 2037 2038 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) { 2039 int stored_rc; 2040 2041 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid, 2042 lck->offset, lck->length, NULL, 2043 lck->type, 0); 2044 if (stored_rc) 2045 rc = stored_rc; 2046 list_del(&lck->llist); 2047 kfree(lck); 2048 } 2049 2050 out: 2051 free_xid(xid); 2052 return rc; 2053 err_out: 2054 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) { 2055 list_del(&lck->llist); 2056 kfree(lck); 2057 } 2058 goto out; 2059 } 2060 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2061 2062 static int 2063 cifs_push_locks(struct cifsFileInfo *cfile) 2064 { 2065 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 2066 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 2067 int rc = 0; 2068 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2069 struct cifs_sb_info *cifs_sb = CIFS_SB(cinode); 2070 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2071 2072 /* we are going to update can_cache_brlcks here - need a write access */ 2073 cifs_down_write(&cinode->lock_sem); 2074 if (!cinode->can_cache_brlcks) { 2075 up_write(&cinode->lock_sem); 2076 return rc; 2077 } 2078 2079 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2080 if (cap_unix(tcon->ses) && 2081 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) && 2082 ((cifs_sb_flags(cifs_sb) & CIFS_MOUNT_NOPOSIXBRL) == 0)) 2083 rc = cifs_push_posix_locks(cfile); 2084 else 2085 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2086 rc = tcon->ses->server->ops->push_mand_locks(cfile); 2087 2088 cinode->can_cache_brlcks = false; 2089 up_write(&cinode->lock_sem); 2090 return rc; 2091 } 2092 2093 static void 2094 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock, 2095 bool *wait_flag, struct TCP_Server_Info *server) 2096 { 2097 if (flock->c.flc_flags & FL_POSIX) 2098 cifs_dbg(FYI, "Posix\n"); 2099 if (flock->c.flc_flags & FL_FLOCK) 2100 cifs_dbg(FYI, "Flock\n"); 2101 if (flock->c.flc_flags & FL_SLEEP) { 2102 cifs_dbg(FYI, "Blocking lock\n"); 2103 *wait_flag = true; 2104 } 2105 if (flock->c.flc_flags & FL_ACCESS) 2106 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n"); 2107 if (flock->c.flc_flags & FL_LEASE) 2108 cifs_dbg(FYI, "Lease on file - not implemented yet\n"); 2109 if (flock->c.flc_flags & 2110 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | 2111 FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK))) 2112 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", 2113 flock->c.flc_flags); 2114 2115 *type = server->vals->large_lock_type; 2116 if (lock_is_write(flock)) { 2117 cifs_dbg(FYI, "F_WRLCK\n"); 2118 *type |= server->vals->exclusive_lock_type; 2119 *lock = 1; 2120 } else if (lock_is_unlock(flock)) { 2121 cifs_dbg(FYI, "F_UNLCK\n"); 2122 *type |= server->vals->unlock_lock_type; 2123 *unlock = 1; 2124 /* Check if unlock includes more than one lock range */ 2125 } else if (lock_is_read(flock)) { 2126 cifs_dbg(FYI, "F_RDLCK\n"); 2127 *type |= server->vals->shared_lock_type; 2128 *lock = 1; 2129 } else if (flock->c.flc_type == F_EXLCK) { 2130 cifs_dbg(FYI, "F_EXLCK\n"); 2131 *type |= server->vals->exclusive_lock_type; 2132 *lock = 1; 2133 } else if (flock->c.flc_type == F_SHLCK) { 2134 cifs_dbg(FYI, "F_SHLCK\n"); 2135 *type |= server->vals->shared_lock_type; 2136 *lock = 1; 2137 } else 2138 cifs_dbg(FYI, "Unknown type of lock\n"); 2139 } 2140 2141 static int 2142 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type, 2143 bool wait_flag, bool posix_lck, unsigned int xid) 2144 { 2145 int rc = 0; 2146 __u64 length = cifs_flock_len(flock); 2147 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data; 2148 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 2149 struct TCP_Server_Info *server = tcon->ses->server; 2150 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2151 __u16 netfid = cfile->fid.netfid; 2152 2153 if (posix_lck) { 2154 int posix_lock_type; 2155 2156 rc = cifs_posix_lock_test(file, flock); 2157 if (!rc) 2158 return rc; 2159 2160 if (type & server->vals->shared_lock_type) 2161 posix_lock_type = CIFS_RDLCK; 2162 else 2163 posix_lock_type = CIFS_WRLCK; 2164 rc = CIFSSMBPosixLock(xid, tcon, netfid, 2165 hash_lockowner(flock->c.flc_owner), 2166 flock->fl_start, length, flock, 2167 posix_lock_type, wait_flag); 2168 return rc; 2169 } 2170 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2171 2172 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock); 2173 if (!rc) 2174 return rc; 2175 2176 /* BB we could chain these into one lock request BB */ 2177 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type, 2178 1, 0, false); 2179 if (rc == 0) { 2180 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, 2181 type, 0, 1, false); 2182 flock->c.flc_type = F_UNLCK; 2183 if (rc != 0) 2184 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n", 2185 rc); 2186 return 0; 2187 } 2188 2189 if (type & server->vals->shared_lock_type) { 2190 flock->c.flc_type = F_WRLCK; 2191 return 0; 2192 } 2193 2194 type &= ~server->vals->exclusive_lock_type; 2195 2196 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, 2197 type | server->vals->shared_lock_type, 2198 1, 0, false); 2199 if (rc == 0) { 2200 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, 2201 type | server->vals->shared_lock_type, 0, 1, false); 2202 flock->c.flc_type = F_RDLCK; 2203 if (rc != 0) 2204 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n", 2205 rc); 2206 } else 2207 flock->c.flc_type = F_WRLCK; 2208 2209 return 0; 2210 } 2211 2212 void 2213 cifs_move_llist(struct list_head *source, struct list_head *dest) 2214 { 2215 struct list_head *li, *tmp; 2216 list_for_each_safe(li, tmp, source) 2217 list_move(li, dest); 2218 } 2219 2220 int 2221 cifs_get_hardlink_path(struct cifs_tcon *tcon, struct inode *inode, 2222 struct file *file) 2223 { 2224 struct cifsFileInfo *open_file = NULL; 2225 struct cifsInodeInfo *cinode = CIFS_I(inode); 2226 int rc = 0; 2227 2228 spin_lock(&tcon->open_file_lock); 2229 spin_lock(&cinode->open_file_lock); 2230 2231 list_for_each_entry(open_file, &cinode->openFileList, flist) { 2232 if (file->f_flags == open_file->f_flags) { 2233 rc = -EINVAL; 2234 break; 2235 } 2236 } 2237 2238 spin_unlock(&cinode->open_file_lock); 2239 spin_unlock(&tcon->open_file_lock); 2240 return rc; 2241 } 2242 2243 void 2244 cifs_free_llist(struct list_head *llist) 2245 { 2246 struct cifsLockInfo *li, *tmp; 2247 list_for_each_entry_safe(li, tmp, llist, llist) { 2248 cifs_del_lock_waiters(li); 2249 list_del(&li->llist); 2250 kfree(li); 2251 } 2252 } 2253 2254 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2255 int 2256 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, 2257 unsigned int xid) 2258 { 2259 int rc = 0, stored_rc; 2260 static const int types[] = { 2261 LOCKING_ANDX_LARGE_FILES, 2262 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES 2263 }; 2264 unsigned int i; 2265 unsigned int max_num, num, max_buf; 2266 LOCKING_ANDX_RANGE *buf, *cur; 2267 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 2268 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry)); 2269 struct cifsLockInfo *li, *tmp; 2270 __u64 length = cifs_flock_len(flock); 2271 LIST_HEAD(tmp_llist); 2272 2273 /* 2274 * Accessing maxBuf is racy with cifs_reconnect - need to store value 2275 * and check it before using. 2276 */ 2277 max_buf = tcon->ses->server->maxBuf; 2278 if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) 2279 return -EINVAL; 2280 2281 BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) > 2282 PAGE_SIZE); 2283 max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr), 2284 PAGE_SIZE); 2285 max_num = (max_buf - sizeof(struct smb_hdr)) / 2286 sizeof(LOCKING_ANDX_RANGE); 2287 buf = kzalloc_objs(LOCKING_ANDX_RANGE, max_num); 2288 if (!buf) 2289 return -ENOMEM; 2290 2291 cifs_down_write(&cinode->lock_sem); 2292 for (i = 0; i < 2; i++) { 2293 cur = buf; 2294 num = 0; 2295 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) { 2296 if (flock->fl_start > li->offset || 2297 (flock->fl_start + length) < 2298 (li->offset + li->length)) 2299 continue; 2300 if (current->tgid != li->pid) 2301 continue; 2302 if (types[i] != li->type) 2303 continue; 2304 if (cinode->can_cache_brlcks) { 2305 /* 2306 * We can cache brlock requests - simply remove 2307 * a lock from the file's list. 2308 */ 2309 list_del(&li->llist); 2310 cifs_del_lock_waiters(li); 2311 kfree(li); 2312 continue; 2313 } 2314 cur->Pid = cpu_to_le16(li->pid); 2315 cur->LengthLow = cpu_to_le32((u32)li->length); 2316 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32)); 2317 cur->OffsetLow = cpu_to_le32((u32)li->offset); 2318 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32)); 2319 /* 2320 * We need to save a lock here to let us add it again to 2321 * the file's list if the unlock range request fails on 2322 * the server. 2323 */ 2324 list_move(&li->llist, &tmp_llist); 2325 if (++num == max_num) { 2326 stored_rc = cifs_lockv(xid, tcon, 2327 cfile->fid.netfid, 2328 li->type, num, 0, buf); 2329 if (stored_rc) { 2330 /* 2331 * We failed on the unlock range 2332 * request - add all locks from the tmp 2333 * list to the head of the file's list. 2334 */ 2335 cifs_move_llist(&tmp_llist, 2336 &cfile->llist->locks); 2337 rc = stored_rc; 2338 } else 2339 /* 2340 * The unlock range request succeed - 2341 * free the tmp list. 2342 */ 2343 cifs_free_llist(&tmp_llist); 2344 cur = buf; 2345 num = 0; 2346 } else 2347 cur++; 2348 } 2349 if (num) { 2350 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid, 2351 types[i], num, 0, buf); 2352 if (stored_rc) { 2353 cifs_move_llist(&tmp_llist, 2354 &cfile->llist->locks); 2355 rc = stored_rc; 2356 } else 2357 cifs_free_llist(&tmp_llist); 2358 } 2359 } 2360 2361 up_write(&cinode->lock_sem); 2362 kfree(buf); 2363 return rc; 2364 } 2365 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2366 2367 static int 2368 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type, 2369 bool wait_flag, bool posix_lck, int lock, int unlock, 2370 unsigned int xid) 2371 { 2372 int rc = 0; 2373 __u64 length = cifs_flock_len(flock); 2374 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data; 2375 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 2376 struct TCP_Server_Info *server = tcon->ses->server; 2377 struct inode *inode = d_inode(cfile->dentry); 2378 2379 #ifdef CONFIG_CIFS_ALLOW_INSECURE_LEGACY 2380 if (posix_lck) { 2381 int posix_lock_type; 2382 2383 rc = cifs_posix_lock_set(file, flock); 2384 if (rc <= FILE_LOCK_DEFERRED) 2385 return rc; 2386 2387 if (type & server->vals->shared_lock_type) 2388 posix_lock_type = CIFS_RDLCK; 2389 else 2390 posix_lock_type = CIFS_WRLCK; 2391 2392 if (unlock == 1) 2393 posix_lock_type = CIFS_UNLCK; 2394 2395 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid, 2396 hash_lockowner(flock->c.flc_owner), 2397 flock->fl_start, length, 2398 NULL, posix_lock_type, wait_flag); 2399 goto out; 2400 } 2401 #endif /* CONFIG_CIFS_ALLOW_INSECURE_LEGACY */ 2402 if (lock) { 2403 struct cifsLockInfo *lock; 2404 2405 lock = cifs_lock_init(flock->fl_start, length, type, 2406 flock->c.flc_flags); 2407 if (!lock) 2408 return -ENOMEM; 2409 2410 rc = cifs_lock_add_if(cfile, lock, wait_flag, xid); 2411 if (rc < 0) { 2412 kfree(lock); 2413 return rc; 2414 } 2415 if (!rc) 2416 goto out; 2417 2418 /* 2419 * Windows 7 server can delay breaking lease from read to None 2420 * if we set a byte-range lock on a file - break it explicitly 2421 * before sending the lock to the server to be sure the next 2422 * read won't conflict with non-overlapted locks due to 2423 * pagereading. 2424 */ 2425 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) && 2426 CIFS_CACHE_READ(CIFS_I(inode))) { 2427 cifs_zap_mapping(inode); 2428 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n", 2429 inode); 2430 cifs_reset_oplock(CIFS_I(inode)); 2431 } 2432 2433 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, 2434 type, 1, 0, wait_flag); 2435 if (rc) { 2436 kfree(lock); 2437 return rc; 2438 } 2439 2440 cifs_lock_add(cfile, lock); 2441 } else if (unlock) 2442 rc = server->ops->mand_unlock_range(cfile, flock, xid); 2443 2444 out: 2445 if ((flock->c.flc_flags & FL_POSIX) || (flock->c.flc_flags & FL_FLOCK)) { 2446 /* 2447 * If this is a request to remove all locks because we 2448 * are closing the file, it doesn't matter if the 2449 * unlocking failed as both cifs.ko and the SMB server 2450 * remove the lock on file close 2451 */ 2452 if (rc) { 2453 cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc); 2454 if (!(flock->c.flc_flags & FL_CLOSE)) 2455 return rc; 2456 } 2457 rc = locks_lock_file_wait(file, flock); 2458 } 2459 return rc; 2460 } 2461 2462 int cifs_flock(struct file *file, int cmd, struct file_lock *fl) 2463 { 2464 int rc, xid; 2465 int lock = 0, unlock = 0; 2466 bool wait_flag = false; 2467 bool posix_lck = false; 2468 struct cifs_sb_info *cifs_sb; 2469 struct cifs_tcon *tcon; 2470 struct cifsFileInfo *cfile; 2471 __u32 type; 2472 2473 xid = get_xid(); 2474 2475 if (!(fl->c.flc_flags & FL_FLOCK)) { 2476 rc = -ENOLCK; 2477 free_xid(xid); 2478 return rc; 2479 } 2480 2481 cfile = (struct cifsFileInfo *)file->private_data; 2482 tcon = tlink_tcon(cfile->tlink); 2483 2484 cifs_read_flock(fl, &type, &lock, &unlock, &wait_flag, 2485 tcon->ses->server); 2486 cifs_sb = CIFS_SB(file); 2487 2488 if (cap_unix(tcon->ses) && 2489 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) && 2490 ((cifs_sb_flags(cifs_sb) & CIFS_MOUNT_NOPOSIXBRL) == 0)) 2491 posix_lck = true; 2492 2493 if (!lock && !unlock) { 2494 /* 2495 * if no lock or unlock then nothing to do since we do not 2496 * know what it is 2497 */ 2498 rc = -EOPNOTSUPP; 2499 free_xid(xid); 2500 return rc; 2501 } 2502 2503 rc = cifs_setlk(file, fl, type, wait_flag, posix_lck, lock, unlock, 2504 xid); 2505 free_xid(xid); 2506 return rc; 2507 2508 2509 } 2510 2511 int cifs_lock(struct file *file, int cmd, struct file_lock *flock) 2512 { 2513 struct cifs_sb_info *cifs_sb = CIFS_SB(file); 2514 struct cifsFileInfo *cfile; 2515 int lock = 0, unlock = 0; 2516 bool wait_flag = false; 2517 bool posix_lck = false; 2518 struct cifs_tcon *tcon; 2519 __u32 type; 2520 int rc, xid; 2521 2522 rc = -EACCES; 2523 xid = get_xid(); 2524 2525 cifs_dbg(FYI, "%s: %pD2 cmd=0x%x type=0x%x flags=0x%x r=%lld:%lld\n", __func__, file, cmd, 2526 flock->c.flc_flags, flock->c.flc_type, 2527 (long long)flock->fl_start, 2528 (long long)flock->fl_end); 2529 2530 cfile = (struct cifsFileInfo *)file->private_data; 2531 tcon = tlink_tcon(cfile->tlink); 2532 2533 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag, 2534 tcon->ses->server); 2535 set_bit(CIFS_INO_CLOSE_ON_LOCK, &CIFS_I(d_inode(cfile->dentry))->flags); 2536 2537 if (cap_unix(tcon->ses) && 2538 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) && 2539 ((cifs_sb_flags(cifs_sb) & CIFS_MOUNT_NOPOSIXBRL) == 0)) 2540 posix_lck = true; 2541 /* 2542 * BB add code here to normalize offset and length to account for 2543 * negative length which we can not accept over the wire. 2544 */ 2545 if (IS_GETLK(cmd)) { 2546 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid); 2547 free_xid(xid); 2548 return rc; 2549 } 2550 2551 if (!lock && !unlock) { 2552 /* 2553 * if no lock or unlock then nothing to do since we do not 2554 * know what it is 2555 */ 2556 free_xid(xid); 2557 return -EOPNOTSUPP; 2558 } 2559 2560 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock, 2561 xid); 2562 free_xid(xid); 2563 return rc; 2564 } 2565 2566 static void cifs_update_i_blocks_for_write(struct inode *inode, loff_t start, 2567 loff_t end) 2568 { 2569 struct cifsInodeInfo *cinode = CIFS_I(inode); 2570 u64 allocated_end = CIFS_INO_BYTES(inode->i_blocks); 2571 u64 blocks; 2572 2573 if (cinode->cifsAttrs & FILE_ATTRIBUTE_SPARSE_FILE) 2574 return; 2575 2576 /* 2577 * Grow the local estimate only across the currently known allocated 2578 * prefix. A write beyond that may leave a hole. 2579 */ 2580 if ((u64)start > allocated_end) 2581 return; 2582 2583 blocks = CIFS_INO_BLOCKS(end); 2584 if ((u64)inode->i_blocks < blocks) 2585 inode->i_blocks = blocks; 2586 } 2587 2588 static void cifs_update_i_blocks_after_write(struct kiocb *iocb, 2589 ssize_t written) 2590 { 2591 struct inode *inode = file_inode(iocb->ki_filp); 2592 loff_t end = iocb->ki_pos; 2593 2594 if (written <= 0) 2595 return; 2596 2597 spin_lock(&inode->i_lock); 2598 cifs_update_i_blocks_for_write(inode, end - written, end); 2599 spin_unlock(&inode->i_lock); 2600 } 2601 2602 void cifs_write_subrequest_terminated(struct cifs_io_subrequest *wdata, ssize_t result) 2603 { 2604 struct netfs_io_request *wreq = wdata->rreq; 2605 struct inode *inode = wreq->inode; 2606 struct netfs_inode *ictx = netfs_inode(inode); 2607 loff_t wrend; 2608 2609 if (result > 0) { 2610 spin_lock(&inode->i_lock); 2611 2612 wrend = wdata->subreq.start + wdata->subreq.transferred + result; 2613 2614 if (wrend > ictx->_zero_point && 2615 (wdata->rreq->origin == NETFS_UNBUFFERED_WRITE || 2616 wdata->rreq->origin == NETFS_DIO_WRITE)) 2617 netfs_write_zero_point(inode, wrend); 2618 if (wrend > ictx->_remote_i_size) 2619 netfs_resize_file(ictx, wrend, true); 2620 cifs_update_i_blocks_for_write(inode, wdata->subreq.start, 2621 wrend); 2622 2623 spin_unlock(&inode->i_lock); 2624 } 2625 2626 netfs_write_subrequest_terminated(&wdata->subreq, result); 2627 } 2628 2629 static bool open_flags_match(struct cifsInodeInfo *cinode, 2630 unsigned int oflags, unsigned int cflags) 2631 { 2632 struct inode *inode = &cinode->netfs.inode; 2633 int crw = 0, orw = 0; 2634 2635 oflags &= ~(O_CREAT | O_EXCL | O_TRUNC); 2636 cflags &= ~(O_CREAT | O_EXCL | O_TRUNC); 2637 2638 if (cifs_fscache_enabled(inode)) { 2639 if (OPEN_FMODE(cflags) & FMODE_WRITE) 2640 crw = 1; 2641 if (OPEN_FMODE(oflags) & FMODE_WRITE) 2642 orw = 1; 2643 } 2644 if (cifs_convert_flags(oflags, orw) != cifs_convert_flags(cflags, crw)) 2645 return false; 2646 2647 return (oflags & (O_SYNC | O_DIRECT)) == (cflags & (O_SYNC | O_DIRECT)); 2648 } 2649 2650 struct cifsFileInfo *__find_readable_file(struct cifsInodeInfo *cifs_inode, 2651 unsigned int find_flags, 2652 unsigned int open_flags) 2653 { 2654 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode); 2655 bool fsuid_only = find_flags & FIND_FSUID_ONLY; 2656 struct cifsFileInfo *open_file = NULL; 2657 2658 /* only filter by fsuid on multiuser mounts */ 2659 if (!(cifs_sb_flags(cifs_sb) & CIFS_MOUNT_MULTIUSER)) 2660 fsuid_only = false; 2661 2662 spin_lock(&cifs_inode->open_file_lock); 2663 /* we could simply get the first_list_entry since write-only entries 2664 are always at the end of the list but since the first entry might 2665 have a close pending, we go through the whole list */ 2666 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) { 2667 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid())) 2668 continue; 2669 if ((find_flags & FIND_NO_PENDING_DELETE) && 2670 open_file->status_file_deleted) 2671 continue; 2672 if ((find_flags & FIND_OPEN_FLAGS) && 2673 !open_flags_match(cifs_inode, open_flags, 2674 open_file->f_flags)) 2675 continue; 2676 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) { 2677 if ((!open_file->invalidHandle)) { 2678 /* found a good file */ 2679 /* lock it so it will not be closed on us */ 2680 cifsFileInfo_get(open_file); 2681 spin_unlock(&cifs_inode->open_file_lock); 2682 return open_file; 2683 } /* else might as well continue, and look for 2684 another, or simply have the caller reopen it 2685 again rather than trying to fix this handle */ 2686 } else /* write only file */ 2687 break; /* write only files are last so must be done */ 2688 } 2689 spin_unlock(&cifs_inode->open_file_lock); 2690 return NULL; 2691 } 2692 2693 /* Return -EBADF if no handle is found and general rc otherwise */ 2694 int __cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, 2695 unsigned int find_flags, unsigned int open_flags, 2696 struct cifsFileInfo **ret_file) 2697 { 2698 struct cifsFileInfo *open_file, *inv_file = NULL; 2699 bool fsuid_only, with_delete; 2700 struct cifs_sb_info *cifs_sb; 2701 bool any_available = false; 2702 unsigned int refind = 0; 2703 *ret_file = NULL; 2704 int rc = -EBADF; 2705 2706 /* 2707 * Having a null inode here (because mapping->host was set to zero by 2708 * the VFS or MM) should not happen but we had reports of on oops (due 2709 * to it being zero) during stress testcases so we need to check for it 2710 */ 2711 2712 if (cifs_inode == NULL) { 2713 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n"); 2714 dump_stack(); 2715 return rc; 2716 } 2717 2718 if (test_bit(CIFS_INO_TMPFILE, &cifs_inode->flags)) 2719 find_flags = FIND_ANY; 2720 2721 cifs_sb = CIFS_SB(cifs_inode); 2722 2723 with_delete = find_flags & FIND_WITH_DELETE; 2724 fsuid_only = find_flags & FIND_FSUID_ONLY; 2725 /* only filter by fsuid on multiuser mounts */ 2726 if (!(cifs_sb_flags(cifs_sb) & CIFS_MOUNT_MULTIUSER)) 2727 fsuid_only = false; 2728 2729 spin_lock(&cifs_inode->open_file_lock); 2730 refind_writable: 2731 if (refind > MAX_REOPEN_ATT) { 2732 spin_unlock(&cifs_inode->open_file_lock); 2733 return rc; 2734 } 2735 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) { 2736 if (!any_available && open_file->pid != current->tgid) 2737 continue; 2738 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid())) 2739 continue; 2740 if (with_delete && !(open_file->fid.access & DELETE)) 2741 continue; 2742 if ((find_flags & FIND_NO_PENDING_DELETE) && 2743 open_file->status_file_deleted) 2744 continue; 2745 if ((find_flags & FIND_OPEN_FLAGS) && 2746 !open_flags_match(cifs_inode, open_flags, 2747 open_file->f_flags)) 2748 continue; 2749 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) { 2750 if (!open_file->invalidHandle) { 2751 /* found a good writable file */ 2752 cifsFileInfo_get(open_file); 2753 spin_unlock(&cifs_inode->open_file_lock); 2754 *ret_file = open_file; 2755 return 0; 2756 } else { 2757 if (!inv_file) 2758 inv_file = open_file; 2759 } 2760 } 2761 } 2762 /* couldn't find usable FH with same pid, try any available */ 2763 if (!any_available) { 2764 any_available = true; 2765 goto refind_writable; 2766 } 2767 2768 if (inv_file) { 2769 any_available = false; 2770 cifsFileInfo_get(inv_file); 2771 } 2772 2773 spin_unlock(&cifs_inode->open_file_lock); 2774 2775 if (inv_file) { 2776 rc = cifs_reopen_file(inv_file, false); 2777 if (!rc) { 2778 *ret_file = inv_file; 2779 return 0; 2780 } 2781 2782 spin_lock(&cifs_inode->open_file_lock); 2783 list_move_tail(&inv_file->flist, &cifs_inode->openFileList); 2784 spin_unlock(&cifs_inode->open_file_lock); 2785 cifsFileInfo_put(inv_file); 2786 ++refind; 2787 inv_file = NULL; 2788 spin_lock(&cifs_inode->open_file_lock); 2789 goto refind_writable; 2790 } 2791 2792 return rc; 2793 } 2794 2795 struct cifsFileInfo * 2796 find_writable_file(struct cifsInodeInfo *cifs_inode, int flags) 2797 { 2798 struct cifsFileInfo *cfile; 2799 int rc; 2800 2801 rc = cifs_get_writable_file(cifs_inode, flags, &cfile); 2802 if (rc) 2803 cifs_dbg(FYI, "Couldn't find writable handle rc=%d\n", rc); 2804 2805 return cfile; 2806 } 2807 2808 int cifs_get_writable_path(struct cifs_tcon *tcon, const char *name, 2809 struct inode *inode, int flags, 2810 struct cifsFileInfo **ret_file) 2811 { 2812 struct cifsFileInfo *cfile; 2813 void *page; 2814 2815 *ret_file = NULL; 2816 2817 if (inode) 2818 return cifs_get_writable_file(CIFS_I(inode), flags, ret_file); 2819 2820 page = alloc_dentry_path(); 2821 spin_lock(&tcon->open_file_lock); 2822 list_for_each_entry(cfile, &tcon->openFileList, tlist) { 2823 struct cifsInodeInfo *cinode; 2824 const char *full_path = build_path_from_dentry(cfile->dentry, page); 2825 if (IS_ERR(full_path)) { 2826 spin_unlock(&tcon->open_file_lock); 2827 free_dentry_path(page); 2828 return PTR_ERR(full_path); 2829 } 2830 if (strcmp(full_path, name)) 2831 continue; 2832 2833 cinode = CIFS_I(d_inode(cfile->dentry)); 2834 spin_unlock(&tcon->open_file_lock); 2835 free_dentry_path(page); 2836 return cifs_get_writable_file(cinode, flags, ret_file); 2837 } 2838 2839 spin_unlock(&tcon->open_file_lock); 2840 free_dentry_path(page); 2841 return -ENOENT; 2842 } 2843 2844 int 2845 cifs_get_readable_path(struct cifs_tcon *tcon, const char *name, 2846 struct cifsFileInfo **ret_file) 2847 { 2848 struct cifsFileInfo *cfile; 2849 void *page = alloc_dentry_path(); 2850 2851 *ret_file = NULL; 2852 2853 spin_lock(&tcon->open_file_lock); 2854 list_for_each_entry(cfile, &tcon->openFileList, tlist) { 2855 struct cifsInodeInfo *cinode; 2856 const char *full_path = build_path_from_dentry(cfile->dentry, page); 2857 if (IS_ERR(full_path)) { 2858 spin_unlock(&tcon->open_file_lock); 2859 free_dentry_path(page); 2860 return PTR_ERR(full_path); 2861 } 2862 if (strcmp(full_path, name)) 2863 continue; 2864 2865 cinode = CIFS_I(d_inode(cfile->dentry)); 2866 spin_unlock(&tcon->open_file_lock); 2867 free_dentry_path(page); 2868 *ret_file = find_readable_file(cinode, FIND_ANY); 2869 return *ret_file ? 0 : -ENOENT; 2870 } 2871 2872 spin_unlock(&tcon->open_file_lock); 2873 free_dentry_path(page); 2874 return -ENOENT; 2875 } 2876 2877 /* 2878 * Flush data on a strict file. 2879 */ 2880 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end, 2881 int datasync) 2882 { 2883 struct cifsFileInfo *smbfile = file->private_data; 2884 struct inode *inode = file_inode(file); 2885 unsigned int xid; 2886 int rc; 2887 2888 rc = file_write_and_wait_range(file, start, end); 2889 if (rc) { 2890 trace_cifs_fsync_err(inode->i_ino, rc); 2891 return rc; 2892 } 2893 2894 cifs_dbg(FYI, "%s: name=%pD datasync=0x%x\n", __func__, file, datasync); 2895 2896 if (!CIFS_CACHE_READ(CIFS_I(inode))) { 2897 rc = cifs_zap_mapping(inode); 2898 cifs_dbg(FYI, "%s: invalidate mapping: rc = %d\n", __func__, rc); 2899 } 2900 2901 xid = get_xid(); 2902 rc = cifs_file_flush(xid, inode, smbfile); 2903 free_xid(xid); 2904 return rc; 2905 } 2906 2907 /* 2908 * Flush data on a non-strict data. 2909 */ 2910 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync) 2911 { 2912 unsigned int xid; 2913 int rc = 0; 2914 struct cifs_tcon *tcon; 2915 struct TCP_Server_Info *server; 2916 struct cifsFileInfo *smbfile = file->private_data; 2917 struct inode *inode = file_inode(file); 2918 struct cifs_sb_info *cifs_sb = CIFS_SB(file); 2919 2920 rc = file_write_and_wait_range(file, start, end); 2921 if (rc) { 2922 trace_cifs_fsync_err(file_inode(file)->i_ino, rc); 2923 return rc; 2924 } 2925 2926 xid = get_xid(); 2927 2928 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n", 2929 file, datasync); 2930 2931 tcon = tlink_tcon(smbfile->tlink); 2932 if (!(cifs_sb_flags(cifs_sb) & CIFS_MOUNT_NOSSYNC)) { 2933 server = tcon->ses->server; 2934 if (server->ops->flush == NULL) { 2935 rc = -ENOSYS; 2936 goto fsync_exit; 2937 } 2938 2939 if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) { 2940 smbfile = find_writable_file(CIFS_I(inode), FIND_ANY); 2941 if (smbfile) { 2942 rc = server->ops->flush(xid, tcon, &smbfile->fid); 2943 cifsFileInfo_put(smbfile); 2944 } else 2945 cifs_dbg(FYI, "ignore fsync for file not open for write\n"); 2946 } else 2947 rc = server->ops->flush(xid, tcon, &smbfile->fid); 2948 } 2949 2950 fsync_exit: 2951 free_xid(xid); 2952 return rc; 2953 } 2954 2955 /* 2956 * As file closes, flush all cached write data for this inode checking 2957 * for write behind errors. 2958 */ 2959 int cifs_flush(struct file *file, fl_owner_t id) 2960 { 2961 struct inode *inode = file_inode(file); 2962 int rc = 0; 2963 2964 if (file->f_mode & FMODE_WRITE) 2965 rc = filemap_write_and_wait(inode->i_mapping); 2966 2967 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc); 2968 if (rc) { 2969 /* get more nuanced writeback errors */ 2970 rc = filemap_check_wb_err(file->f_mapping, 0); 2971 trace_cifs_flush_err(inode->i_ino, rc); 2972 } 2973 return rc; 2974 } 2975 2976 static ssize_t 2977 cifs_writev(struct kiocb *iocb, struct iov_iter *from) 2978 { 2979 struct file *file = iocb->ki_filp; 2980 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data; 2981 struct inode *inode = file->f_mapping->host; 2982 struct cifsInodeInfo *cinode = CIFS_I(inode); 2983 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server; 2984 struct cifs_sb_info *cifs_sb = CIFS_SB(inode); 2985 ssize_t rc; 2986 2987 rc = netfs_start_io_write(inode); 2988 if (rc < 0) 2989 return rc; 2990 2991 /* 2992 * We need to hold the sem to be sure nobody modifies lock list 2993 * with a brlock that prevents writing. 2994 */ 2995 down_read(&cinode->lock_sem); 2996 2997 rc = generic_write_checks(iocb, from); 2998 if (rc <= 0) 2999 goto out; 3000 3001 if ((cifs_sb_flags(cifs_sb) & CIFS_MOUNT_NOPOSIXBRL) && 3002 (cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from), 3003 server->vals->exclusive_lock_type, 0, 3004 NULL, CIFS_WRITE_OP))) { 3005 rc = -EACCES; 3006 goto out; 3007 } 3008 3009 rc = netfs_buffered_write_iter_locked(iocb, from, NULL); 3010 cifs_update_i_blocks_after_write(iocb, rc); 3011 3012 out: 3013 up_read(&cinode->lock_sem); 3014 netfs_end_io_write(inode); 3015 if (rc > 0) 3016 rc = generic_write_sync(iocb, rc); 3017 return rc; 3018 } 3019 3020 ssize_t 3021 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from) 3022 { 3023 struct inode *inode = file_inode(iocb->ki_filp); 3024 struct cifsInodeInfo *cinode = CIFS_I(inode); 3025 struct cifs_sb_info *cifs_sb = CIFS_SB(inode); 3026 struct cifsFileInfo *cfile = (struct cifsFileInfo *) 3027 iocb->ki_filp->private_data; 3028 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 3029 ssize_t written; 3030 3031 written = cifs_get_writer(cinode); 3032 if (written) 3033 return written; 3034 3035 if (CIFS_CACHE_WRITE(cinode)) { 3036 if (cap_unix(tcon->ses) && 3037 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) && 3038 ((cifs_sb_flags(cifs_sb) & CIFS_MOUNT_NOPOSIXBRL) == 0)) { 3039 written = netfs_file_write_iter(iocb, from); 3040 cifs_update_i_blocks_after_write(iocb, written); 3041 goto out; 3042 } 3043 written = cifs_writev(iocb, from); 3044 goto out; 3045 } 3046 /* 3047 * For non-oplocked files in strict cache mode we need to write the data 3048 * to the server exactly from the pos to pos+len-1 rather than flush all 3049 * affected pages because it may cause a error with mandatory locks on 3050 * these pages but not on the region from pos to ppos+len-1. 3051 */ 3052 written = netfs_file_write_iter(iocb, from); 3053 cifs_update_i_blocks_after_write(iocb, written); 3054 if (CIFS_CACHE_READ(cinode)) { 3055 /* 3056 * We have read level caching and we have just sent a write 3057 * request to the server thus making data in the cache stale. 3058 * Zap the cache and set oplock/lease level to NONE to avoid 3059 * reading stale data from the cache. All subsequent read 3060 * operations will read new data from the server. 3061 */ 3062 cifs_zap_mapping(inode); 3063 cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n", 3064 inode); 3065 cifs_reset_oplock(cinode); 3066 } 3067 out: 3068 cifs_put_writer(cinode); 3069 return written; 3070 } 3071 3072 ssize_t cifs_direct_write_iter(struct kiocb *iocb, struct iov_iter *from) 3073 { 3074 ssize_t written; 3075 3076 written = netfs_file_write_iter(iocb, from); 3077 cifs_update_i_blocks_after_write(iocb, written); 3078 return written; 3079 } 3080 3081 ssize_t cifs_loose_read_iter(struct kiocb *iocb, struct iov_iter *iter) 3082 { 3083 ssize_t rc; 3084 struct inode *inode = file_inode(iocb->ki_filp); 3085 3086 if (iocb->ki_flags & IOCB_DIRECT) 3087 return netfs_unbuffered_read_iter(iocb, iter); 3088 3089 rc = cifs_revalidate_mapping(inode); 3090 if (rc) 3091 return rc; 3092 3093 return netfs_file_read_iter(iocb, iter); 3094 } 3095 3096 ssize_t cifs_file_write_iter(struct kiocb *iocb, struct iov_iter *from) 3097 { 3098 struct inode *inode = file_inode(iocb->ki_filp); 3099 struct cifsInodeInfo *cinode = CIFS_I(inode); 3100 ssize_t written; 3101 int rc; 3102 3103 if (iocb->ki_filp->f_flags & O_DIRECT) { 3104 written = netfs_unbuffered_write_iter(iocb, from); 3105 cifs_update_i_blocks_after_write(iocb, written); 3106 if (written > 0 && CIFS_CACHE_READ(cinode)) { 3107 cifs_zap_mapping(inode); 3108 cifs_dbg(FYI, 3109 "Set no oplock for inode=%p after a write operation\n", 3110 inode); 3111 cifs_reset_oplock(cinode); 3112 } 3113 return written; 3114 } 3115 3116 written = cifs_get_writer(cinode); 3117 if (written) 3118 return written; 3119 3120 written = netfs_file_write_iter(iocb, from); 3121 cifs_update_i_blocks_after_write(iocb, written); 3122 3123 if (!CIFS_CACHE_WRITE(CIFS_I(inode))) { 3124 rc = filemap_fdatawrite(inode->i_mapping); 3125 if (rc) 3126 cifs_dbg(FYI, "cifs_file_write_iter: %d rc on %p inode\n", 3127 rc, inode); 3128 } 3129 3130 cifs_put_writer(cinode); 3131 return written; 3132 } 3133 3134 ssize_t 3135 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to) 3136 { 3137 struct inode *inode = file_inode(iocb->ki_filp); 3138 struct cifsInodeInfo *cinode = CIFS_I(inode); 3139 struct cifs_sb_info *cifs_sb = CIFS_SB(inode); 3140 struct cifsFileInfo *cfile = (struct cifsFileInfo *) 3141 iocb->ki_filp->private_data; 3142 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink); 3143 int rc = -EACCES; 3144 3145 /* 3146 * In strict cache mode we need to read from the server all the time 3147 * if we don't have level II oplock because the server can delay mtime 3148 * change - so we can't make a decision about inode invalidating. 3149 * And we can also fail with pagereading if there are mandatory locks 3150 * on pages affected by this read but not on the region from pos to 3151 * pos+len-1. 3152 */ 3153 if (!CIFS_CACHE_READ(cinode)) 3154 return netfs_unbuffered_read_iter(iocb, to); 3155 3156 if ((cifs_sb_flags(cifs_sb) & CIFS_MOUNT_NOPOSIXBRL) == 0) { 3157 if (iocb->ki_flags & IOCB_DIRECT) 3158 return netfs_unbuffered_read_iter(iocb, to); 3159 return netfs_buffered_read_iter(iocb, to); 3160 } 3161 3162 /* 3163 * We need to hold the sem to be sure nobody modifies lock list 3164 * with a brlock that prevents reading. 3165 */ 3166 if (iocb->ki_flags & IOCB_DIRECT) { 3167 rc = netfs_start_io_direct(inode); 3168 if (rc < 0) 3169 goto out; 3170 rc = -EACCES; 3171 down_read(&cinode->lock_sem); 3172 if (!cifs_find_lock_conflict( 3173 cfile, iocb->ki_pos, iov_iter_count(to), 3174 tcon->ses->server->vals->shared_lock_type, 3175 0, NULL, CIFS_READ_OP)) 3176 rc = netfs_unbuffered_read_iter_locked(iocb, to); 3177 up_read(&cinode->lock_sem); 3178 netfs_end_io_direct(inode); 3179 } else { 3180 rc = netfs_start_io_read(inode); 3181 if (rc < 0) 3182 goto out; 3183 rc = -EACCES; 3184 down_read(&cinode->lock_sem); 3185 if (!cifs_find_lock_conflict( 3186 cfile, iocb->ki_pos, iov_iter_count(to), 3187 tcon->ses->server->vals->shared_lock_type, 3188 0, NULL, CIFS_READ_OP)) 3189 rc = filemap_read(iocb, to, 0); 3190 up_read(&cinode->lock_sem); 3191 netfs_end_io_read(inode); 3192 } 3193 out: 3194 return rc; 3195 } 3196 3197 static vm_fault_t cifs_page_mkwrite(struct vm_fault *vmf) 3198 { 3199 return netfs_page_mkwrite(vmf, NULL); 3200 } 3201 3202 static const struct vm_operations_struct cifs_file_vm_ops = { 3203 .fault = filemap_fault, 3204 .map_pages = filemap_map_pages, 3205 .page_mkwrite = cifs_page_mkwrite, 3206 }; 3207 3208 int cifs_file_strict_mmap_prepare(struct vm_area_desc *desc) 3209 { 3210 int xid, rc = 0; 3211 struct inode *inode = file_inode(desc->file); 3212 3213 xid = get_xid(); 3214 3215 if (!CIFS_CACHE_READ(CIFS_I(inode))) 3216 rc = cifs_zap_mapping(inode); 3217 if (!rc) 3218 rc = generic_file_mmap_prepare(desc); 3219 if (!rc) 3220 desc->vm_ops = &cifs_file_vm_ops; 3221 3222 free_xid(xid); 3223 return rc; 3224 } 3225 3226 int cifs_file_mmap_prepare(struct vm_area_desc *desc) 3227 { 3228 int rc, xid; 3229 3230 xid = get_xid(); 3231 3232 rc = cifs_revalidate_file(desc->file); 3233 if (rc) 3234 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n", 3235 rc); 3236 if (!rc) 3237 rc = generic_file_mmap_prepare(desc); 3238 if (!rc) 3239 desc->vm_ops = &cifs_file_vm_ops; 3240 3241 free_xid(xid); 3242 return rc; 3243 } 3244 3245 static int is_inode_writable(struct cifsInodeInfo *cifs_inode) 3246 { 3247 struct cifsFileInfo *open_file; 3248 3249 spin_lock(&cifs_inode->open_file_lock); 3250 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) { 3251 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) { 3252 spin_unlock(&cifs_inode->open_file_lock); 3253 return 1; 3254 } 3255 } 3256 spin_unlock(&cifs_inode->open_file_lock); 3257 return 0; 3258 } 3259 3260 /* We do not want to update the file size from server for inodes 3261 open for write - to avoid races with writepage extending 3262 the file - in the future we could consider allowing 3263 refreshing the inode only on increases in the file size 3264 but this is tricky to do without racing with writebehind 3265 page caching in the current Linux kernel design */ 3266 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file, 3267 bool from_readdir) 3268 { 3269 struct cifs_sb_info *cifs_sb; 3270 unsigned long tlw; 3271 3272 if (!cifsInode) 3273 return true; 3274 3275 cifs_sb = CIFS_SB(cifsInode); 3276 3277 if (is_inode_writable(cifsInode) || 3278 ((cifsInode->oplock & CIFS_CACHE_RW_FLG) != 0 && from_readdir)) { 3279 /* This inode is open for write at least once */ 3280 3281 /* 3282 * Readdir data is unreliable when we have writable handles or 3283 * an exclusive lease -- never allow it to change i_size, even 3284 * on direct-IO mounts where the server's directory metadata 3285 * can still lag behind the actual file state. 3286 */ 3287 if (from_readdir) 3288 return false; 3289 3290 if (cifs_sb_flags(cifs_sb) & CIFS_MOUNT_DIRECT_IO) { 3291 /* since no page cache to corrupt on directio 3292 we can change size safely */ 3293 return true; 3294 } 3295 3296 if (i_size_read(&cifsInode->netfs.inode) < end_of_file) 3297 return true; 3298 3299 return false; 3300 } 3301 3302 /* 3303 * No writable handles open. Check whether we are within the attribute 3304 * cache validity window of a recent local modification. 3305 * 3306 * For the close() path: _cifsFileInfo_put() stamps time_last_write 3307 * (via smp_store_release()) before releasing open_file_lock. That 3308 * spin_unlock() is a store-release that pairs with the spin_lock() 3309 * (load-acquire) in is_inode_writable() above, so if 3310 * is_inode_writable() returned false the smp_load_acquire() below is 3311 * guaranteed to observe any time_last_write update from a concurrent 3312 * close(), covering all close paths including background I/O. 3313 * 3314 * For the setattr/truncate paths: those callers use smp_store_release() 3315 * directly; the smp_load_acquire() below pairs with that store. There 3316 * is no shared lock between setattr and readdir, so this relies on 3317 * acquire-release semantics alone. The store propagation latency on 3318 * weakly-ordered architectures (nanoseconds) is negligible relative to 3319 * the acregmax window (seconds) and the readdir RPC round-trip 3320 * (milliseconds), making this a sound design choice in practice. 3321 * 3322 * time_last_write == 0 means the inode has never been written locally; 3323 * skip the window check to avoid false positives near boot time when 3324 * jiffies is still close to INITIAL_JIFFIES on 32-bit systems. 3325 */ 3326 if (from_readdir) { 3327 /* Pairs with smp_store_release() in _cifsFileInfo_put() and setattr. */ 3328 tlw = smp_load_acquire(&cifsInode->time_last_write); 3329 if (tlw && time_before(jiffies, tlw + cifs_sb->ctx->acregmax)) 3330 return false; 3331 } 3332 3333 return true; 3334 } 3335 3336 void cifs_oplock_break(struct work_struct *work) 3337 { 3338 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo, 3339 oplock_break); 3340 struct inode *inode = d_inode(cfile->dentry); 3341 struct super_block *sb = inode->i_sb; 3342 struct cifs_sb_info *cifs_sb = CIFS_SB(sb); 3343 struct cifsInodeInfo *cinode = CIFS_I(inode); 3344 bool cache_read, cache_write, cache_handle; 3345 struct cifs_tcon *tcon; 3346 struct TCP_Server_Info *server; 3347 struct tcon_link *tlink; 3348 unsigned int oplock; 3349 int rc = 0; 3350 bool purge_cache = false, oplock_break_cancelled; 3351 __u64 persistent_fid, volatile_fid; 3352 __u16 net_fid; 3353 3354 wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS, 3355 TASK_UNINTERRUPTIBLE); 3356 3357 tlink = cifs_sb_tlink(cifs_sb); 3358 if (IS_ERR(tlink)) { 3359 /* drop the reference taken when the break was queued */ 3360 _cifsFileInfo_put(cfile, false /* do not wait for ourself */, false); 3361 goto out; 3362 } 3363 tcon = tlink_tcon(tlink); 3364 server = tcon->ses->server; 3365 3366 scoped_guard(spinlock, &cinode->open_file_lock) { 3367 unsigned int sbflags = cifs_sb_flags(cifs_sb); 3368 3369 server->ops->downgrade_oplock(server, cinode, cfile->oplock_level, 3370 cfile->oplock_epoch, &purge_cache); 3371 oplock = READ_ONCE(cinode->oplock); 3372 cache_read = (oplock & CIFS_CACHE_READ_FLG) || 3373 (sbflags & CIFS_MOUNT_RO_CACHE); 3374 cache_write = (oplock & CIFS_CACHE_WRITE_FLG) || 3375 (sbflags & CIFS_MOUNT_RW_CACHE); 3376 cache_handle = oplock & CIFS_CACHE_HANDLE_FLG; 3377 } 3378 3379 if (!cache_write && cache_read && cifs_has_mand_locks(cinode)) { 3380 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n", 3381 inode); 3382 cifs_reset_oplock(cinode); 3383 oplock = 0; 3384 cache_read = cache_write = cache_handle = false; 3385 } 3386 3387 if (S_ISREG(inode->i_mode)) { 3388 if (cache_read) 3389 break_lease(inode, O_RDONLY); 3390 else 3391 break_lease(inode, O_WRONLY); 3392 rc = filemap_fdatawrite(inode->i_mapping); 3393 if (!cache_read || purge_cache) { 3394 rc = filemap_fdatawait(inode->i_mapping); 3395 mapping_set_error(inode->i_mapping, rc); 3396 cifs_zap_mapping(inode); 3397 } 3398 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc); 3399 if (cache_write) 3400 goto oplock_break_ack; 3401 } 3402 3403 rc = cifs_push_locks(cfile); 3404 if (rc) 3405 cifs_dbg(VFS, "Push locks rc = %d\n", rc); 3406 3407 oplock_break_ack: 3408 /* 3409 * When oplock break is received and there are no active 3410 * file handles but cached, then schedule deferred close immediately. 3411 * So, new open will not use cached handle. 3412 */ 3413 3414 if (!cache_handle && !list_empty(&cinode->deferred_closes)) 3415 cifs_close_deferred_file(cinode); 3416 3417 persistent_fid = cfile->fid.persistent_fid; 3418 volatile_fid = cfile->fid.volatile_fid; 3419 net_fid = cfile->fid.netfid; 3420 oplock_break_cancelled = cfile->oplock_break_cancelled; 3421 3422 _cifsFileInfo_put(cfile, false /* do not wait for ourself */, false); 3423 /* 3424 * MS-SMB2 3.2.5.19.1 and 3.2.5.19.2 (and MS-CIFS 3.2.5.42) do not require 3425 * an acknowledgment to be sent when the file has already been closed. 3426 */ 3427 spin_lock(&cinode->open_file_lock); 3428 /* check list empty since can race with kill_sb calling tree disconnect */ 3429 if (!oplock_break_cancelled && !list_empty(&cinode->openFileList)) { 3430 spin_unlock(&cinode->open_file_lock); 3431 rc = server->ops->oplock_response(tcon, persistent_fid, 3432 volatile_fid, net_fid, 3433 cinode, oplock); 3434 cifs_dbg(FYI, "Oplock release rc = %d\n", rc); 3435 } else 3436 spin_unlock(&cinode->open_file_lock); 3437 3438 cifs_put_tlink(tlink); 3439 out: 3440 cifs_done_oplock_break(cinode); 3441 } 3442 3443 #ifdef CONFIG_SWAP 3444 static void cifs_swap_submit_write(struct swap_io_ctx *ctx) 3445 { 3446 struct swap_iocb *sio = ctx->sio; 3447 struct iov_iter iter; 3448 int ret; 3449 3450 swap_fs_prepare_rw(ctx, WRITE, &iter); 3451 ret = netfs_unbuffered_write_iter_locked(&sio->iocb, &iter, NULL); 3452 if (ret != -EIOCBQUEUED) 3453 sio->iocb.ki_complete(&sio->iocb, ret); 3454 } 3455 3456 static void cifs_swap_submit_read(struct swap_io_ctx *ctx) 3457 { 3458 struct swap_iocb *sio = ctx->sio; 3459 struct iov_iter iter; 3460 int ret; 3461 3462 swap_fs_prepare_rw(ctx, READ, &iter); 3463 ret = netfs_unbuffered_read_iter_locked(&sio->iocb, &iter); 3464 if (ret != -EIOCBQUEUED) 3465 sio->iocb.ki_complete(&sio->iocb, ret); 3466 } 3467 3468 static const struct swap_ops cifs_swap_ops = { 3469 .flags = SWAP_OPS_F_REQUIRE_NOFS, 3470 .submit_write = cifs_swap_submit_write, 3471 .submit_read = cifs_swap_submit_read, 3472 .can_merge = swap_fs_can_merge, 3473 }; 3474 3475 static int cifs_swap_activate(struct swap_info_struct *sis, 3476 struct file *swap_file, sector_t *span) 3477 { 3478 struct cifsFileInfo *cfile = swap_file->private_data; 3479 struct inode *inode = swap_file->f_mapping->host; 3480 unsigned long blocks; 3481 long long isize; 3482 3483 cifs_dbg(FYI, "swap activate\n"); 3484 3485 if (swap_file->f_mapping->a_ops != &cifs_addr_ops) 3486 /* Cannot support swap */ 3487 return -EINVAL; 3488 3489 spin_lock(&inode->i_lock); 3490 blocks = inode->i_blocks; 3491 isize = inode->i_size; 3492 spin_unlock(&inode->i_lock); 3493 if (blocks*512 < isize) { 3494 pr_warn("swap activate: swapfile has holes\n"); 3495 return -EINVAL; 3496 } 3497 *span = sis->pages; 3498 3499 pr_warn_once("Swap support over SMB3 is experimental\n"); 3500 3501 /* 3502 * TODO: consider adding ACL (or documenting how) to prevent other 3503 * users (on this or other systems) from reading it 3504 */ 3505 3506 3507 /* TODO: add sk_set_memalloc(inet) or similar */ 3508 3509 if (cfile) 3510 cfile->swapfile = true; 3511 /* 3512 * TODO: Since file already open, we can't open with DENY_ALL here 3513 * but we could add call to grab a byte range lock to prevent others 3514 * from reading or writing the file 3515 */ 3516 return swap_fs_activate(sis, &cifs_swap_ops); 3517 } 3518 3519 static void cifs_swap_deactivate(struct file *file) 3520 { 3521 struct cifsFileInfo *cfile = file->private_data; 3522 3523 cifs_dbg(FYI, "swap deactivate\n"); 3524 3525 /* TODO: undo sk_set_memalloc(inet) will eventually be needed */ 3526 3527 if (cfile) 3528 cfile->swapfile = false; 3529 3530 /* do we need to unpin (or unlock) the file */ 3531 } 3532 #else 3533 #define cifs_swap_activate NULL 3534 #define cifs_swap_deactivate NULL 3535 #endif /* CONFIG_SWAP */ 3536 3537 const struct address_space_operations cifs_addr_ops = { 3538 .read_folio = netfs_read_folio, 3539 .readahead = netfs_readahead, 3540 .writepages = netfs_writepages, 3541 .dirty_folio = netfs_dirty_folio, 3542 .release_folio = netfs_release_folio, 3543 .direct_IO = noop_direct_IO, 3544 .invalidate_folio = netfs_invalidate_folio, 3545 .migrate_folio = filemap_migrate_folio, 3546 /* 3547 * TODO: investigate and if useful we could add an is_dirty_writeback 3548 * helper if needed 3549 */ 3550 .swap_activate = cifs_swap_activate, 3551 .swap_deactivate = cifs_swap_deactivate, 3552 }; 3553 3554 /* 3555 * cifs_readahead requires the server to support a buffer large enough to 3556 * contain the header plus one complete page of data. Otherwise, we need 3557 * to leave cifs_readahead out of the address space operations. 3558 */ 3559 const struct address_space_operations cifs_addr_ops_smallbuf = { 3560 .read_folio = netfs_read_folio, 3561 .writepages = netfs_writepages, 3562 .dirty_folio = netfs_dirty_folio, 3563 .release_folio = netfs_release_folio, 3564 .invalidate_folio = netfs_invalidate_folio, 3565 .migrate_folio = filemap_migrate_folio, 3566 }; 3567