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