1 // SPDX-License-Identifier: LGPL-2.1
4 * vfs operations that deal with files
6 * Copyright (C) International Business Machines Corp., 2002,2010
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 * Jeremy Allison (jra@samba.org)
12 #include <linux/backing-dev.h>
13 #include <linux/stat.h>
14 #include <linux/fcntl.h>
15 #include <linux/pagemap.h>
16 #include <linux/pagevec.h>
17 #include <linux/writeback.h>
18 #include <linux/task_io_accounting_ops.h>
19 #include <linux/delay.h>
20 #include <linux/mount.h>
21 #include <linux/slab.h>
22 #include <linux/swap.h>
24 #include <asm/div64.h>
28 #include "cifsproto.h"
29 #include "cifs_unicode.h"
30 #include "cifs_debug.h"
31 #include "cifs_fs_sb.h"
33 #include "smbdirect.h"
34 #include "fs_context.h"
35 #include "cifs_ioctl.h"
37 static inline int cifs_convert_flags(unsigned int flags)
39 if ((flags & O_ACCMODE) == O_RDONLY)
41 else if ((flags & O_ACCMODE) == O_WRONLY)
43 else if ((flags & O_ACCMODE) == O_RDWR) {
44 /* GENERIC_ALL is too much permission to request
45 can cause unnecessary access denied on create */
46 /* return GENERIC_ALL; */
47 return (GENERIC_READ | GENERIC_WRITE);
50 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
51 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
55 static u32 cifs_posix_convert_flags(unsigned int flags)
59 if ((flags & O_ACCMODE) == O_RDONLY)
60 posix_flags = SMB_O_RDONLY;
61 else if ((flags & O_ACCMODE) == O_WRONLY)
62 posix_flags = SMB_O_WRONLY;
63 else if ((flags & O_ACCMODE) == O_RDWR)
64 posix_flags = SMB_O_RDWR;
66 if (flags & O_CREAT) {
67 posix_flags |= SMB_O_CREAT;
69 posix_flags |= SMB_O_EXCL;
70 } else if (flags & O_EXCL)
71 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
72 current->comm, current->tgid);
75 posix_flags |= SMB_O_TRUNC;
76 /* be safe and imply O_SYNC for O_DSYNC */
78 posix_flags |= SMB_O_SYNC;
79 if (flags & O_DIRECTORY)
80 posix_flags |= SMB_O_DIRECTORY;
81 if (flags & O_NOFOLLOW)
82 posix_flags |= SMB_O_NOFOLLOW;
84 posix_flags |= SMB_O_DIRECT;
89 static inline int cifs_get_disposition(unsigned int flags)
91 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
93 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
94 return FILE_OVERWRITE_IF;
95 else if ((flags & O_CREAT) == O_CREAT)
97 else if ((flags & O_TRUNC) == O_TRUNC)
98 return FILE_OVERWRITE;
103 int cifs_posix_open(const char *full_path, struct inode **pinode,
104 struct super_block *sb, int mode, unsigned int f_flags,
105 __u32 *poplock, __u16 *pnetfid, unsigned int xid)
108 FILE_UNIX_BASIC_INFO *presp_data;
109 __u32 posix_flags = 0;
110 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
111 struct cifs_fattr fattr;
112 struct tcon_link *tlink;
113 struct cifs_tcon *tcon;
115 cifs_dbg(FYI, "posix open %s\n", full_path);
117 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
118 if (presp_data == NULL)
121 tlink = cifs_sb_tlink(cifs_sb);
127 tcon = tlink_tcon(tlink);
128 mode &= ~current_umask();
130 posix_flags = cifs_posix_convert_flags(f_flags);
131 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
132 poplock, full_path, cifs_sb->local_nls,
133 cifs_remap(cifs_sb));
134 cifs_put_tlink(tlink);
139 if (presp_data->Type == cpu_to_le32(-1))
140 goto posix_open_ret; /* open ok, caller does qpathinfo */
143 goto posix_open_ret; /* caller does not need info */
145 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
147 /* get new inode and set it up */
148 if (*pinode == NULL) {
149 cifs_fill_uniqueid(sb, &fattr);
150 *pinode = cifs_iget(sb, &fattr);
156 cifs_revalidate_mapping(*pinode);
157 rc = cifs_fattr_to_inode(*pinode, &fattr);
166 cifs_nt_open(const char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
167 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
168 struct cifs_fid *fid, unsigned int xid)
173 int create_options = CREATE_NOT_DIR;
175 struct TCP_Server_Info *server = tcon->ses->server;
176 struct cifs_open_parms oparms;
178 if (!server->ops->open)
181 desired_access = cifs_convert_flags(f_flags);
183 /*********************************************************************
184 * open flag mapping table:
186 * POSIX Flag CIFS Disposition
187 * ---------- ----------------
188 * O_CREAT FILE_OPEN_IF
189 * O_CREAT | O_EXCL FILE_CREATE
190 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
191 * O_TRUNC FILE_OVERWRITE
192 * none of the above FILE_OPEN
194 * Note that there is not a direct match between disposition
195 * FILE_SUPERSEDE (ie create whether or not file exists although
196 * O_CREAT | O_TRUNC is similar but truncates the existing
197 * file rather than creating a new file as FILE_SUPERSEDE does
198 * (which uses the attributes / metadata passed in on open call)
200 *? O_SYNC is a reasonable match to CIFS writethrough flag
201 *? and the read write flags match reasonably. O_LARGEFILE
202 *? is irrelevant because largefile support is always used
203 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
204 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
205 *********************************************************************/
207 disposition = cifs_get_disposition(f_flags);
209 /* BB pass O_SYNC flag through on file attributes .. BB */
211 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
215 /* O_SYNC also has bit for O_DSYNC so following check picks up either */
216 if (f_flags & O_SYNC)
217 create_options |= CREATE_WRITE_THROUGH;
219 if (f_flags & O_DIRECT)
220 create_options |= CREATE_NO_BUFFER;
223 oparms.cifs_sb = cifs_sb;
224 oparms.desired_access = desired_access;
225 oparms.create_options = cifs_create_options(cifs_sb, create_options);
226 oparms.disposition = disposition;
227 oparms.path = full_path;
229 oparms.reconnect = false;
231 rc = server->ops->open(xid, &oparms, oplock, buf);
236 /* TODO: Add support for calling posix query info but with passing in fid */
238 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
241 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
245 server->ops->close(xid, tcon, fid);
256 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
258 struct cifs_fid_locks *cur;
259 bool has_locks = false;
261 down_read(&cinode->lock_sem);
262 list_for_each_entry(cur, &cinode->llist, llist) {
263 if (!list_empty(&cur->locks)) {
268 up_read(&cinode->lock_sem);
273 cifs_down_write(struct rw_semaphore *sem)
275 while (!down_write_trylock(sem))
279 static void cifsFileInfo_put_work(struct work_struct *work);
281 struct cifsFileInfo *
282 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
283 struct tcon_link *tlink, __u32 oplock)
285 struct dentry *dentry = file_dentry(file);
286 struct inode *inode = d_inode(dentry);
287 struct cifsInodeInfo *cinode = CIFS_I(inode);
288 struct cifsFileInfo *cfile;
289 struct cifs_fid_locks *fdlocks;
290 struct cifs_tcon *tcon = tlink_tcon(tlink);
291 struct TCP_Server_Info *server = tcon->ses->server;
293 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
297 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
303 INIT_LIST_HEAD(&fdlocks->locks);
304 fdlocks->cfile = cfile;
305 cfile->llist = fdlocks;
308 cfile->pid = current->tgid;
309 cfile->uid = current_fsuid();
310 cfile->dentry = dget(dentry);
311 cfile->f_flags = file->f_flags;
312 cfile->invalidHandle = false;
313 cfile->deferred_close_scheduled = false;
314 cfile->tlink = cifs_get_tlink(tlink);
315 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
316 INIT_WORK(&cfile->put, cifsFileInfo_put_work);
317 INIT_DELAYED_WORK(&cfile->deferred, smb2_deferred_work_close);
318 mutex_init(&cfile->fh_mutex);
319 spin_lock_init(&cfile->file_info_lock);
321 cifs_sb_active(inode->i_sb);
324 * If the server returned a read oplock and we have mandatory brlocks,
325 * set oplock level to None.
327 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
328 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
332 cifs_down_write(&cinode->lock_sem);
333 list_add(&fdlocks->llist, &cinode->llist);
334 up_write(&cinode->lock_sem);
336 spin_lock(&tcon->open_file_lock);
337 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
338 oplock = fid->pending_open->oplock;
339 list_del(&fid->pending_open->olist);
341 fid->purge_cache = false;
342 server->ops->set_fid(cfile, fid, oplock);
344 list_add(&cfile->tlist, &tcon->openFileList);
345 atomic_inc(&tcon->num_local_opens);
347 /* if readable file instance put first in list*/
348 spin_lock(&cinode->open_file_lock);
349 if (file->f_mode & FMODE_READ)
350 list_add(&cfile->flist, &cinode->openFileList);
352 list_add_tail(&cfile->flist, &cinode->openFileList);
353 spin_unlock(&cinode->open_file_lock);
354 spin_unlock(&tcon->open_file_lock);
356 if (fid->purge_cache)
357 cifs_zap_mapping(inode);
359 file->private_data = cfile;
363 struct cifsFileInfo *
364 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
366 spin_lock(&cifs_file->file_info_lock);
367 cifsFileInfo_get_locked(cifs_file);
368 spin_unlock(&cifs_file->file_info_lock);
372 static void cifsFileInfo_put_final(struct cifsFileInfo *cifs_file)
374 struct inode *inode = d_inode(cifs_file->dentry);
375 struct cifsInodeInfo *cifsi = CIFS_I(inode);
376 struct cifsLockInfo *li, *tmp;
377 struct super_block *sb = inode->i_sb;
379 cifs_fscache_release_inode_cookie(inode);
382 * Delete any outstanding lock records. We'll lose them when the file
385 cifs_down_write(&cifsi->lock_sem);
386 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
387 list_del(&li->llist);
388 cifs_del_lock_waiters(li);
391 list_del(&cifs_file->llist->llist);
392 kfree(cifs_file->llist);
393 up_write(&cifsi->lock_sem);
395 cifs_put_tlink(cifs_file->tlink);
396 dput(cifs_file->dentry);
397 cifs_sb_deactive(sb);
401 static void cifsFileInfo_put_work(struct work_struct *work)
403 struct cifsFileInfo *cifs_file = container_of(work,
404 struct cifsFileInfo, put);
406 cifsFileInfo_put_final(cifs_file);
410 * cifsFileInfo_put - release a reference of file priv data
412 * Always potentially wait for oplock handler. See _cifsFileInfo_put().
414 * @cifs_file: cifs/smb3 specific info (eg refcounts) for an open file
416 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
418 _cifsFileInfo_put(cifs_file, true, true);
422 * _cifsFileInfo_put - release a reference of file priv data
424 * This may involve closing the filehandle @cifs_file out on the
425 * server. Must be called without holding tcon->open_file_lock,
426 * cinode->open_file_lock and cifs_file->file_info_lock.
428 * If @wait_for_oplock_handler is true and we are releasing the last
429 * reference, wait for any running oplock break handler of the file
430 * and cancel any pending one.
432 * @cifs_file: cifs/smb3 specific info (eg refcounts) for an open file
433 * @wait_oplock_handler: must be false if called from oplock_break_handler
434 * @offload: not offloaded on close and oplock breaks
437 void _cifsFileInfo_put(struct cifsFileInfo *cifs_file,
438 bool wait_oplock_handler, bool offload)
440 struct inode *inode = d_inode(cifs_file->dentry);
441 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
442 struct TCP_Server_Info *server = tcon->ses->server;
443 struct cifsInodeInfo *cifsi = CIFS_I(inode);
444 struct super_block *sb = inode->i_sb;
445 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
447 struct cifs_pending_open open;
448 bool oplock_break_cancelled;
450 spin_lock(&tcon->open_file_lock);
451 spin_lock(&cifsi->open_file_lock);
452 spin_lock(&cifs_file->file_info_lock);
453 if (--cifs_file->count > 0) {
454 spin_unlock(&cifs_file->file_info_lock);
455 spin_unlock(&cifsi->open_file_lock);
456 spin_unlock(&tcon->open_file_lock);
459 spin_unlock(&cifs_file->file_info_lock);
461 if (server->ops->get_lease_key)
462 server->ops->get_lease_key(inode, &fid);
464 /* store open in pending opens to make sure we don't miss lease break */
465 cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
467 /* remove it from the lists */
468 list_del(&cifs_file->flist);
469 list_del(&cifs_file->tlist);
470 atomic_dec(&tcon->num_local_opens);
472 if (list_empty(&cifsi->openFileList)) {
473 cifs_dbg(FYI, "closing last open instance for inode %p\n",
474 d_inode(cifs_file->dentry));
476 * In strict cache mode we need invalidate mapping on the last
477 * close because it may cause a error when we open this file
478 * again and get at least level II oplock.
480 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
481 set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
482 cifs_set_oplock_level(cifsi, 0);
485 spin_unlock(&cifsi->open_file_lock);
486 spin_unlock(&tcon->open_file_lock);
488 oplock_break_cancelled = wait_oplock_handler ?
489 cancel_work_sync(&cifs_file->oplock_break) : false;
491 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
492 struct TCP_Server_Info *server = tcon->ses->server;
496 if (server->ops->close_getattr)
497 server->ops->close_getattr(xid, tcon, cifs_file);
498 else if (server->ops->close)
499 server->ops->close(xid, tcon, &cifs_file->fid);
503 if (oplock_break_cancelled)
504 cifs_done_oplock_break(cifsi);
506 cifs_del_pending_open(&open);
509 queue_work(fileinfo_put_wq, &cifs_file->put);
511 cifsFileInfo_put_final(cifs_file);
514 int cifs_open(struct inode *inode, struct file *file)
520 struct cifs_sb_info *cifs_sb;
521 struct TCP_Server_Info *server;
522 struct cifs_tcon *tcon;
523 struct tcon_link *tlink;
524 struct cifsFileInfo *cfile = NULL;
526 const char *full_path;
527 bool posix_open_ok = false;
529 struct cifs_pending_open open;
533 cifs_sb = CIFS_SB(inode->i_sb);
534 if (unlikely(cifs_forced_shutdown(cifs_sb))) {
539 tlink = cifs_sb_tlink(cifs_sb);
542 return PTR_ERR(tlink);
544 tcon = tlink_tcon(tlink);
545 server = tcon->ses->server;
547 page = alloc_dentry_path();
548 full_path = build_path_from_dentry(file_dentry(file), page);
549 if (IS_ERR(full_path)) {
550 rc = PTR_ERR(full_path);
554 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
555 inode, file->f_flags, full_path);
557 if (file->f_flags & O_DIRECT &&
558 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
559 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
560 file->f_op = &cifs_file_direct_nobrl_ops;
562 file->f_op = &cifs_file_direct_ops;
565 /* Get the cached handle as SMB2 close is deferred */
566 rc = cifs_get_readable_path(tcon, full_path, &cfile);
568 if (file->f_flags == cfile->f_flags) {
569 file->private_data = cfile;
570 spin_lock(&CIFS_I(inode)->deferred_lock);
571 cifs_del_deferred_close(cfile);
572 spin_unlock(&CIFS_I(inode)->deferred_lock);
575 _cifsFileInfo_put(cfile, true, false);
584 if (!tcon->broken_posix_open && tcon->unix_ext &&
585 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
586 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
587 /* can not refresh inode info since size could be stale */
588 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
589 cifs_sb->ctx->file_mode /* ignored */,
590 file->f_flags, &oplock, &fid.netfid, xid);
592 cifs_dbg(FYI, "posix open succeeded\n");
593 posix_open_ok = true;
594 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
595 if (tcon->ses->serverNOS)
596 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",
598 tcon->ses->serverNOS);
599 tcon->broken_posix_open = true;
600 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
601 (rc != -EOPNOTSUPP)) /* path not found or net err */
604 * Else fallthrough to retry open the old way on network i/o
609 if (server->ops->get_lease_key)
610 server->ops->get_lease_key(inode, &fid);
612 cifs_add_pending_open(&fid, tlink, &open);
614 if (!posix_open_ok) {
615 if (server->ops->get_lease_key)
616 server->ops->get_lease_key(inode, &fid);
618 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
619 file->f_flags, &oplock, &fid, xid);
621 cifs_del_pending_open(&open);
626 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
628 if (server->ops->close)
629 server->ops->close(xid, tcon, &fid);
630 cifs_del_pending_open(&open);
635 cifs_fscache_set_inode_cookie(inode, file);
637 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
639 * Time to set mode which we can not set earlier due to
640 * problems creating new read-only files.
642 struct cifs_unix_set_info_args args = {
643 .mode = inode->i_mode,
644 .uid = INVALID_UID, /* no change */
645 .gid = INVALID_GID, /* no change */
646 .ctime = NO_CHANGE_64,
647 .atime = NO_CHANGE_64,
648 .mtime = NO_CHANGE_64,
651 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
656 free_dentry_path(page);
658 cifs_put_tlink(tlink);
662 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
665 * Try to reacquire byte range locks that were released when session
666 * to server was lost.
669 cifs_relock_file(struct cifsFileInfo *cfile)
671 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
672 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
673 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
676 down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
677 if (cinode->can_cache_brlcks) {
678 /* can cache locks - no need to relock */
679 up_read(&cinode->lock_sem);
683 if (cap_unix(tcon->ses) &&
684 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
685 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
686 rc = cifs_push_posix_locks(cfile);
688 rc = tcon->ses->server->ops->push_mand_locks(cfile);
690 up_read(&cinode->lock_sem);
695 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
700 struct cifs_sb_info *cifs_sb;
701 struct cifs_tcon *tcon;
702 struct TCP_Server_Info *server;
703 struct cifsInodeInfo *cinode;
706 const char *full_path;
708 int disposition = FILE_OPEN;
709 int create_options = CREATE_NOT_DIR;
710 struct cifs_open_parms oparms;
713 mutex_lock(&cfile->fh_mutex);
714 if (!cfile->invalidHandle) {
715 mutex_unlock(&cfile->fh_mutex);
720 inode = d_inode(cfile->dentry);
721 cifs_sb = CIFS_SB(inode->i_sb);
722 tcon = tlink_tcon(cfile->tlink);
723 server = tcon->ses->server;
726 * Can not grab rename sem here because various ops, including those
727 * that already have the rename sem can end up causing writepage to get
728 * called and if the server was down that means we end up here, and we
729 * can never tell if the caller already has the rename_sem.
731 page = alloc_dentry_path();
732 full_path = build_path_from_dentry(cfile->dentry, page);
733 if (IS_ERR(full_path)) {
734 mutex_unlock(&cfile->fh_mutex);
735 free_dentry_path(page);
737 return PTR_ERR(full_path);
740 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
741 inode, cfile->f_flags, full_path);
743 if (tcon->ses->server->oplocks)
748 if (tcon->unix_ext && cap_unix(tcon->ses) &&
749 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
750 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
752 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
753 * original open. Must mask them off for a reopen.
755 unsigned int oflags = cfile->f_flags &
756 ~(O_CREAT | O_EXCL | O_TRUNC);
758 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
759 cifs_sb->ctx->file_mode /* ignored */,
760 oflags, &oplock, &cfile->fid.netfid, xid);
762 cifs_dbg(FYI, "posix reopen succeeded\n");
763 oparms.reconnect = true;
767 * fallthrough to retry open the old way on errors, especially
768 * in the reconnect path it is important to retry hard
772 desired_access = cifs_convert_flags(cfile->f_flags);
774 /* O_SYNC also has bit for O_DSYNC so following check picks up either */
775 if (cfile->f_flags & O_SYNC)
776 create_options |= CREATE_WRITE_THROUGH;
778 if (cfile->f_flags & O_DIRECT)
779 create_options |= CREATE_NO_BUFFER;
781 if (server->ops->get_lease_key)
782 server->ops->get_lease_key(inode, &cfile->fid);
785 oparms.cifs_sb = cifs_sb;
786 oparms.desired_access = desired_access;
787 oparms.create_options = cifs_create_options(cifs_sb, create_options);
788 oparms.disposition = disposition;
789 oparms.path = full_path;
790 oparms.fid = &cfile->fid;
791 oparms.reconnect = true;
794 * Can not refresh inode by passing in file_info buf to be returned by
795 * ops->open and then calling get_inode_info with returned buf since
796 * file might have write behind data that needs to be flushed and server
797 * version of file size can be stale. If we knew for sure that inode was
798 * not dirty locally we could do this.
800 rc = server->ops->open(xid, &oparms, &oplock, NULL);
801 if (rc == -ENOENT && oparms.reconnect == false) {
802 /* durable handle timeout is expired - open the file again */
803 rc = server->ops->open(xid, &oparms, &oplock, NULL);
804 /* indicate that we need to relock the file */
805 oparms.reconnect = true;
809 mutex_unlock(&cfile->fh_mutex);
810 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
811 cifs_dbg(FYI, "oplock: %d\n", oplock);
812 goto reopen_error_exit;
816 cfile->invalidHandle = false;
817 mutex_unlock(&cfile->fh_mutex);
818 cinode = CIFS_I(inode);
821 rc = filemap_write_and_wait(inode->i_mapping);
822 if (!is_interrupt_error(rc))
823 mapping_set_error(inode->i_mapping, rc);
825 if (tcon->posix_extensions)
826 rc = smb311_posix_get_inode_info(&inode, full_path, inode->i_sb, xid);
827 else if (tcon->unix_ext)
828 rc = cifs_get_inode_info_unix(&inode, full_path,
831 rc = cifs_get_inode_info(&inode, full_path, NULL,
832 inode->i_sb, xid, NULL);
835 * Else we are writing out data to server already and could deadlock if
836 * we tried to flush data, and since we do not know if we have data that
837 * would invalidate the current end of file on the server we can not go
838 * to the server to get the new inode info.
842 * If the server returned a read oplock and we have mandatory brlocks,
843 * set oplock level to None.
845 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
846 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
850 server->ops->set_fid(cfile, &cfile->fid, oplock);
851 if (oparms.reconnect)
852 cifs_relock_file(cfile);
855 free_dentry_path(page);
860 void smb2_deferred_work_close(struct work_struct *work)
862 struct cifsFileInfo *cfile = container_of(work,
863 struct cifsFileInfo, deferred.work);
865 spin_lock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);
866 cifs_del_deferred_close(cfile);
867 cfile->deferred_close_scheduled = false;
868 spin_unlock(&CIFS_I(d_inode(cfile->dentry))->deferred_lock);
869 _cifsFileInfo_put(cfile, true, false);
872 int cifs_close(struct inode *inode, struct file *file)
874 struct cifsFileInfo *cfile;
875 struct cifsInodeInfo *cinode = CIFS_I(inode);
876 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
877 struct cifs_deferred_close *dclose;
879 if (file->private_data != NULL) {
880 cfile = file->private_data;
881 file->private_data = NULL;
882 dclose = kmalloc(sizeof(struct cifs_deferred_close), GFP_KERNEL);
883 if ((cifs_sb->ctx->closetimeo && cinode->oplock == CIFS_CACHE_RHW_FLG)
884 && cinode->lease_granted &&
885 !test_bit(CIFS_INO_CLOSE_ON_LOCK, &cinode->flags) &&
887 if (test_and_clear_bit(CIFS_INO_MODIFIED_ATTR, &cinode->flags)) {
888 inode->i_ctime = inode->i_mtime = current_time(inode);
889 cifs_fscache_update_inode_cookie(inode);
891 spin_lock(&cinode->deferred_lock);
892 cifs_add_deferred_close(cfile, dclose);
893 if (cfile->deferred_close_scheduled &&
894 delayed_work_pending(&cfile->deferred)) {
896 * If there is no pending work, mod_delayed_work queues new work.
897 * So, Increase the ref count to avoid use-after-free.
899 if (!mod_delayed_work(deferredclose_wq,
900 &cfile->deferred, cifs_sb->ctx->closetimeo))
901 cifsFileInfo_get(cfile);
903 /* Deferred close for files */
904 queue_delayed_work(deferredclose_wq,
905 &cfile->deferred, cifs_sb->ctx->closetimeo);
906 cfile->deferred_close_scheduled = true;
907 spin_unlock(&cinode->deferred_lock);
910 spin_unlock(&cinode->deferred_lock);
911 _cifsFileInfo_put(cfile, true, false);
913 _cifsFileInfo_put(cfile, true, false);
918 /* return code from the ->release op is always ignored */
923 cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
925 struct cifsFileInfo *open_file;
926 struct list_head *tmp;
927 struct list_head *tmp1;
928 struct list_head tmp_list;
930 if (!tcon->use_persistent || !tcon->need_reopen_files)
933 tcon->need_reopen_files = false;
935 cifs_dbg(FYI, "Reopen persistent handles\n");
936 INIT_LIST_HEAD(&tmp_list);
938 /* list all files open on tree connection, reopen resilient handles */
939 spin_lock(&tcon->open_file_lock);
940 list_for_each(tmp, &tcon->openFileList) {
941 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
942 if (!open_file->invalidHandle)
944 cifsFileInfo_get(open_file);
945 list_add_tail(&open_file->rlist, &tmp_list);
947 spin_unlock(&tcon->open_file_lock);
949 list_for_each_safe(tmp, tmp1, &tmp_list) {
950 open_file = list_entry(tmp, struct cifsFileInfo, rlist);
951 if (cifs_reopen_file(open_file, false /* do not flush */))
952 tcon->need_reopen_files = true;
953 list_del_init(&open_file->rlist);
954 cifsFileInfo_put(open_file);
958 int cifs_closedir(struct inode *inode, struct file *file)
962 struct cifsFileInfo *cfile = file->private_data;
963 struct cifs_tcon *tcon;
964 struct TCP_Server_Info *server;
967 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
973 tcon = tlink_tcon(cfile->tlink);
974 server = tcon->ses->server;
976 cifs_dbg(FYI, "Freeing private data in close dir\n");
977 spin_lock(&cfile->file_info_lock);
978 if (server->ops->dir_needs_close(cfile)) {
979 cfile->invalidHandle = true;
980 spin_unlock(&cfile->file_info_lock);
981 if (server->ops->close_dir)
982 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
985 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
986 /* not much we can do if it fails anyway, ignore rc */
989 spin_unlock(&cfile->file_info_lock);
991 buf = cfile->srch_inf.ntwrk_buf_start;
993 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
994 cfile->srch_inf.ntwrk_buf_start = NULL;
995 if (cfile->srch_inf.smallBuf)
996 cifs_small_buf_release(buf);
998 cifs_buf_release(buf);
1001 cifs_put_tlink(cfile->tlink);
1002 kfree(file->private_data);
1003 file->private_data = NULL;
1004 /* BB can we lock the filestruct while this is going on? */
1009 static struct cifsLockInfo *
1010 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 flags)
1012 struct cifsLockInfo *lock =
1013 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
1016 lock->offset = offset;
1017 lock->length = length;
1019 lock->pid = current->tgid;
1020 lock->flags = flags;
1021 INIT_LIST_HEAD(&lock->blist);
1022 init_waitqueue_head(&lock->block_q);
1027 cifs_del_lock_waiters(struct cifsLockInfo *lock)
1029 struct cifsLockInfo *li, *tmp;
1030 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
1031 list_del_init(&li->blist);
1032 wake_up(&li->block_q);
1036 #define CIFS_LOCK_OP 0
1037 #define CIFS_READ_OP 1
1038 #define CIFS_WRITE_OP 2
1040 /* @rw_check : 0 - no op, 1 - read, 2 - write */
1042 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
1043 __u64 length, __u8 type, __u16 flags,
1044 struct cifsFileInfo *cfile,
1045 struct cifsLockInfo **conf_lock, int rw_check)
1047 struct cifsLockInfo *li;
1048 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
1049 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1051 list_for_each_entry(li, &fdlocks->locks, llist) {
1052 if (offset + length <= li->offset ||
1053 offset >= li->offset + li->length)
1055 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
1056 server->ops->compare_fids(cfile, cur_cfile)) {
1057 /* shared lock prevents write op through the same fid */
1058 if (!(li->type & server->vals->shared_lock_type) ||
1059 rw_check != CIFS_WRITE_OP)
1062 if ((type & server->vals->shared_lock_type) &&
1063 ((server->ops->compare_fids(cfile, cur_cfile) &&
1064 current->tgid == li->pid) || type == li->type))
1066 if (rw_check == CIFS_LOCK_OP &&
1067 (flags & FL_OFDLCK) && (li->flags & FL_OFDLCK) &&
1068 server->ops->compare_fids(cfile, cur_cfile))
1078 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1079 __u8 type, __u16 flags,
1080 struct cifsLockInfo **conf_lock, int rw_check)
1083 struct cifs_fid_locks *cur;
1084 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1086 list_for_each_entry(cur, &cinode->llist, llist) {
1087 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
1088 flags, cfile, conf_lock,
1098 * Check if there is another lock that prevents us to set the lock (mandatory
1099 * style). If such a lock exists, update the flock structure with its
1100 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1101 * or leave it the same if we can't. Returns 0 if we don't need to request to
1102 * the server or 1 otherwise.
1105 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
1106 __u8 type, struct file_lock *flock)
1109 struct cifsLockInfo *conf_lock;
1110 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1111 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
1114 down_read(&cinode->lock_sem);
1116 exist = cifs_find_lock_conflict(cfile, offset, length, type,
1117 flock->fl_flags, &conf_lock,
1120 flock->fl_start = conf_lock->offset;
1121 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
1122 flock->fl_pid = conf_lock->pid;
1123 if (conf_lock->type & server->vals->shared_lock_type)
1124 flock->fl_type = F_RDLCK;
1126 flock->fl_type = F_WRLCK;
1127 } else if (!cinode->can_cache_brlcks)
1130 flock->fl_type = F_UNLCK;
1132 up_read(&cinode->lock_sem);
1137 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
1139 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1140 cifs_down_write(&cinode->lock_sem);
1141 list_add_tail(&lock->llist, &cfile->llist->locks);
1142 up_write(&cinode->lock_sem);
1146 * Set the byte-range lock (mandatory style). Returns:
1147 * 1) 0, if we set the lock and don't need to request to the server;
1148 * 2) 1, if no locks prevent us but we need to request to the server;
1149 * 3) -EACCES, if there is a lock that prevents us and wait is false.
1152 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1155 struct cifsLockInfo *conf_lock;
1156 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1162 cifs_down_write(&cinode->lock_sem);
1164 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1165 lock->type, lock->flags, &conf_lock,
1167 if (!exist && cinode->can_cache_brlcks) {
1168 list_add_tail(&lock->llist, &cfile->llist->locks);
1169 up_write(&cinode->lock_sem);
1178 list_add_tail(&lock->blist, &conf_lock->blist);
1179 up_write(&cinode->lock_sem);
1180 rc = wait_event_interruptible(lock->block_q,
1181 (lock->blist.prev == &lock->blist) &&
1182 (lock->blist.next == &lock->blist));
1185 cifs_down_write(&cinode->lock_sem);
1186 list_del_init(&lock->blist);
1189 up_write(&cinode->lock_sem);
1194 * Check if there is another lock that prevents us to set the lock (posix
1195 * style). If such a lock exists, update the flock structure with its
1196 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1197 * or leave it the same if we can't. Returns 0 if we don't need to request to
1198 * the server or 1 otherwise.
1201 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1204 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1205 unsigned char saved_type = flock->fl_type;
1207 if ((flock->fl_flags & FL_POSIX) == 0)
1210 down_read(&cinode->lock_sem);
1211 posix_test_lock(file, flock);
1213 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1214 flock->fl_type = saved_type;
1218 up_read(&cinode->lock_sem);
1223 * Set the byte-range lock (posix style). Returns:
1224 * 1) <0, if the error occurs while setting the lock;
1225 * 2) 0, if we set the lock and don't need to request to the server;
1226 * 3) FILE_LOCK_DEFERRED, if we will wait for some other file_lock;
1227 * 4) FILE_LOCK_DEFERRED + 1, if we need to request to the server.
1230 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1232 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1233 int rc = FILE_LOCK_DEFERRED + 1;
1235 if ((flock->fl_flags & FL_POSIX) == 0)
1238 cifs_down_write(&cinode->lock_sem);
1239 if (!cinode->can_cache_brlcks) {
1240 up_write(&cinode->lock_sem);
1244 rc = posix_lock_file(file, flock, NULL);
1245 up_write(&cinode->lock_sem);
1250 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1253 int rc = 0, stored_rc;
1254 struct cifsLockInfo *li, *tmp;
1255 struct cifs_tcon *tcon;
1256 unsigned int num, max_num, max_buf;
1257 LOCKING_ANDX_RANGE *buf, *cur;
1258 static const int types[] = {
1259 LOCKING_ANDX_LARGE_FILES,
1260 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1265 tcon = tlink_tcon(cfile->tlink);
1268 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1269 * and check it before using.
1271 max_buf = tcon->ses->server->maxBuf;
1272 if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1277 BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1279 max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1281 max_num = (max_buf - sizeof(struct smb_hdr)) /
1282 sizeof(LOCKING_ANDX_RANGE);
1283 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1289 for (i = 0; i < 2; i++) {
1292 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1293 if (li->type != types[i])
1295 cur->Pid = cpu_to_le16(li->pid);
1296 cur->LengthLow = cpu_to_le32((u32)li->length);
1297 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1298 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1299 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1300 if (++num == max_num) {
1301 stored_rc = cifs_lockv(xid, tcon,
1303 (__u8)li->type, 0, num,
1314 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1315 (__u8)types[i], 0, num, buf);
1327 hash_lockowner(fl_owner_t owner)
1329 return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1332 struct lock_to_push {
1333 struct list_head llist;
1342 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1344 struct inode *inode = d_inode(cfile->dentry);
1345 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1346 struct file_lock *flock;
1347 struct file_lock_context *flctx = inode->i_flctx;
1348 unsigned int count = 0, i;
1349 int rc = 0, xid, type;
1350 struct list_head locks_to_send, *el;
1351 struct lock_to_push *lck, *tmp;
1359 spin_lock(&flctx->flc_lock);
1360 list_for_each(el, &flctx->flc_posix) {
1363 spin_unlock(&flctx->flc_lock);
1365 INIT_LIST_HEAD(&locks_to_send);
1368 * Allocating count locks is enough because no FL_POSIX locks can be
1369 * added to the list while we are holding cinode->lock_sem that
1370 * protects locking operations of this inode.
1372 for (i = 0; i < count; i++) {
1373 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1378 list_add_tail(&lck->llist, &locks_to_send);
1381 el = locks_to_send.next;
1382 spin_lock(&flctx->flc_lock);
1383 list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1384 if (el == &locks_to_send) {
1386 * The list ended. We don't have enough allocated
1387 * structures - something is really wrong.
1389 cifs_dbg(VFS, "Can't push all brlocks!\n");
1392 length = 1 + flock->fl_end - flock->fl_start;
1393 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1397 lck = list_entry(el, struct lock_to_push, llist);
1398 lck->pid = hash_lockowner(flock->fl_owner);
1399 lck->netfid = cfile->fid.netfid;
1400 lck->length = length;
1402 lck->offset = flock->fl_start;
1404 spin_unlock(&flctx->flc_lock);
1406 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1409 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1410 lck->offset, lck->length, NULL,
1414 list_del(&lck->llist);
1422 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1423 list_del(&lck->llist);
1430 cifs_push_locks(struct cifsFileInfo *cfile)
1432 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1433 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1434 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1437 /* we are going to update can_cache_brlcks here - need a write access */
1438 cifs_down_write(&cinode->lock_sem);
1439 if (!cinode->can_cache_brlcks) {
1440 up_write(&cinode->lock_sem);
1444 if (cap_unix(tcon->ses) &&
1445 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1446 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1447 rc = cifs_push_posix_locks(cfile);
1449 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1451 cinode->can_cache_brlcks = false;
1452 up_write(&cinode->lock_sem);
1457 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1458 bool *wait_flag, struct TCP_Server_Info *server)
1460 if (flock->fl_flags & FL_POSIX)
1461 cifs_dbg(FYI, "Posix\n");
1462 if (flock->fl_flags & FL_FLOCK)
1463 cifs_dbg(FYI, "Flock\n");
1464 if (flock->fl_flags & FL_SLEEP) {
1465 cifs_dbg(FYI, "Blocking lock\n");
1468 if (flock->fl_flags & FL_ACCESS)
1469 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1470 if (flock->fl_flags & FL_LEASE)
1471 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1472 if (flock->fl_flags &
1473 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1474 FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK)))
1475 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1477 *type = server->vals->large_lock_type;
1478 if (flock->fl_type == F_WRLCK) {
1479 cifs_dbg(FYI, "F_WRLCK\n");
1480 *type |= server->vals->exclusive_lock_type;
1482 } else if (flock->fl_type == F_UNLCK) {
1483 cifs_dbg(FYI, "F_UNLCK\n");
1484 *type |= server->vals->unlock_lock_type;
1486 /* Check if unlock includes more than one lock range */
1487 } else if (flock->fl_type == F_RDLCK) {
1488 cifs_dbg(FYI, "F_RDLCK\n");
1489 *type |= server->vals->shared_lock_type;
1491 } else if (flock->fl_type == F_EXLCK) {
1492 cifs_dbg(FYI, "F_EXLCK\n");
1493 *type |= server->vals->exclusive_lock_type;
1495 } else if (flock->fl_type == F_SHLCK) {
1496 cifs_dbg(FYI, "F_SHLCK\n");
1497 *type |= server->vals->shared_lock_type;
1500 cifs_dbg(FYI, "Unknown type of lock\n");
1504 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1505 bool wait_flag, bool posix_lck, unsigned int xid)
1508 __u64 length = 1 + flock->fl_end - flock->fl_start;
1509 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1510 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1511 struct TCP_Server_Info *server = tcon->ses->server;
1512 __u16 netfid = cfile->fid.netfid;
1515 int posix_lock_type;
1517 rc = cifs_posix_lock_test(file, flock);
1521 if (type & server->vals->shared_lock_type)
1522 posix_lock_type = CIFS_RDLCK;
1524 posix_lock_type = CIFS_WRLCK;
1525 rc = CIFSSMBPosixLock(xid, tcon, netfid,
1526 hash_lockowner(flock->fl_owner),
1527 flock->fl_start, length, flock,
1528 posix_lock_type, wait_flag);
1532 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1536 /* BB we could chain these into one lock request BB */
1537 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1540 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1542 flock->fl_type = F_UNLCK;
1544 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1549 if (type & server->vals->shared_lock_type) {
1550 flock->fl_type = F_WRLCK;
1554 type &= ~server->vals->exclusive_lock_type;
1556 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1557 type | server->vals->shared_lock_type,
1560 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1561 type | server->vals->shared_lock_type, 0, 1, false);
1562 flock->fl_type = F_RDLCK;
1564 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1567 flock->fl_type = F_WRLCK;
1573 cifs_move_llist(struct list_head *source, struct list_head *dest)
1575 struct list_head *li, *tmp;
1576 list_for_each_safe(li, tmp, source)
1577 list_move(li, dest);
1581 cifs_free_llist(struct list_head *llist)
1583 struct cifsLockInfo *li, *tmp;
1584 list_for_each_entry_safe(li, tmp, llist, llist) {
1585 cifs_del_lock_waiters(li);
1586 list_del(&li->llist);
1592 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1595 int rc = 0, stored_rc;
1596 static const int types[] = {
1597 LOCKING_ANDX_LARGE_FILES,
1598 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1601 unsigned int max_num, num, max_buf;
1602 LOCKING_ANDX_RANGE *buf, *cur;
1603 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1604 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1605 struct cifsLockInfo *li, *tmp;
1606 __u64 length = 1 + flock->fl_end - flock->fl_start;
1607 struct list_head tmp_llist;
1609 INIT_LIST_HEAD(&tmp_llist);
1612 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1613 * and check it before using.
1615 max_buf = tcon->ses->server->maxBuf;
1616 if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
1619 BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1621 max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1623 max_num = (max_buf - sizeof(struct smb_hdr)) /
1624 sizeof(LOCKING_ANDX_RANGE);
1625 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1629 cifs_down_write(&cinode->lock_sem);
1630 for (i = 0; i < 2; i++) {
1633 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1634 if (flock->fl_start > li->offset ||
1635 (flock->fl_start + length) <
1636 (li->offset + li->length))
1638 if (current->tgid != li->pid)
1640 if (types[i] != li->type)
1642 if (cinode->can_cache_brlcks) {
1644 * We can cache brlock requests - simply remove
1645 * a lock from the file's list.
1647 list_del(&li->llist);
1648 cifs_del_lock_waiters(li);
1652 cur->Pid = cpu_to_le16(li->pid);
1653 cur->LengthLow = cpu_to_le32((u32)li->length);
1654 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1655 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1656 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1658 * We need to save a lock here to let us add it again to
1659 * the file's list if the unlock range request fails on
1662 list_move(&li->llist, &tmp_llist);
1663 if (++num == max_num) {
1664 stored_rc = cifs_lockv(xid, tcon,
1666 li->type, num, 0, buf);
1669 * We failed on the unlock range
1670 * request - add all locks from the tmp
1671 * list to the head of the file's list.
1673 cifs_move_llist(&tmp_llist,
1674 &cfile->llist->locks);
1678 * The unlock range request succeed -
1679 * free the tmp list.
1681 cifs_free_llist(&tmp_llist);
1688 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1689 types[i], num, 0, buf);
1691 cifs_move_llist(&tmp_llist,
1692 &cfile->llist->locks);
1695 cifs_free_llist(&tmp_llist);
1699 up_write(&cinode->lock_sem);
1705 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1706 bool wait_flag, bool posix_lck, int lock, int unlock,
1710 __u64 length = 1 + flock->fl_end - flock->fl_start;
1711 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1712 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1713 struct TCP_Server_Info *server = tcon->ses->server;
1714 struct inode *inode = d_inode(cfile->dentry);
1717 int posix_lock_type;
1719 rc = cifs_posix_lock_set(file, flock);
1720 if (rc <= FILE_LOCK_DEFERRED)
1723 if (type & server->vals->shared_lock_type)
1724 posix_lock_type = CIFS_RDLCK;
1726 posix_lock_type = CIFS_WRLCK;
1729 posix_lock_type = CIFS_UNLCK;
1731 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1732 hash_lockowner(flock->fl_owner),
1733 flock->fl_start, length,
1734 NULL, posix_lock_type, wait_flag);
1739 struct cifsLockInfo *lock;
1741 lock = cifs_lock_init(flock->fl_start, length, type,
1746 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1755 * Windows 7 server can delay breaking lease from read to None
1756 * if we set a byte-range lock on a file - break it explicitly
1757 * before sending the lock to the server to be sure the next
1758 * read won't conflict with non-overlapted locks due to
1761 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1762 CIFS_CACHE_READ(CIFS_I(inode))) {
1763 cifs_zap_mapping(inode);
1764 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1766 CIFS_I(inode)->oplock = 0;
1769 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1770 type, 1, 0, wait_flag);
1776 cifs_lock_add(cfile, lock);
1778 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1781 if ((flock->fl_flags & FL_POSIX) || (flock->fl_flags & FL_FLOCK)) {
1783 * If this is a request to remove all locks because we
1784 * are closing the file, it doesn't matter if the
1785 * unlocking failed as both cifs.ko and the SMB server
1786 * remove the lock on file close
1789 cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
1790 if (!(flock->fl_flags & FL_CLOSE))
1793 rc = locks_lock_file_wait(file, flock);
1798 int cifs_flock(struct file *file, int cmd, struct file_lock *fl)
1801 int lock = 0, unlock = 0;
1802 bool wait_flag = false;
1803 bool posix_lck = false;
1804 struct cifs_sb_info *cifs_sb;
1805 struct cifs_tcon *tcon;
1806 struct cifsFileInfo *cfile;
1811 if (!(fl->fl_flags & FL_FLOCK)) {
1817 cfile = (struct cifsFileInfo *)file->private_data;
1818 tcon = tlink_tcon(cfile->tlink);
1820 cifs_read_flock(fl, &type, &lock, &unlock, &wait_flag,
1822 cifs_sb = CIFS_FILE_SB(file);
1824 if (cap_unix(tcon->ses) &&
1825 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1826 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1829 if (!lock && !unlock) {
1831 * if no lock or unlock then nothing to do since we do not
1839 rc = cifs_setlk(file, fl, type, wait_flag, posix_lck, lock, unlock,
1847 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1850 int lock = 0, unlock = 0;
1851 bool wait_flag = false;
1852 bool posix_lck = false;
1853 struct cifs_sb_info *cifs_sb;
1854 struct cifs_tcon *tcon;
1855 struct cifsFileInfo *cfile;
1861 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1862 cmd, flock->fl_flags, flock->fl_type,
1863 flock->fl_start, flock->fl_end);
1865 cfile = (struct cifsFileInfo *)file->private_data;
1866 tcon = tlink_tcon(cfile->tlink);
1868 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1870 cifs_sb = CIFS_FILE_SB(file);
1871 set_bit(CIFS_INO_CLOSE_ON_LOCK, &CIFS_I(d_inode(cfile->dentry))->flags);
1873 if (cap_unix(tcon->ses) &&
1874 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1875 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1878 * BB add code here to normalize offset and length to account for
1879 * negative length which we can not accept over the wire.
1881 if (IS_GETLK(cmd)) {
1882 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1887 if (!lock && !unlock) {
1889 * if no lock or unlock then nothing to do since we do not
1896 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1903 * update the file size (if needed) after a write. Should be called with
1904 * the inode->i_lock held
1907 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1908 unsigned int bytes_written)
1910 loff_t end_of_write = offset + bytes_written;
1912 if (end_of_write > cifsi->server_eof)
1913 cifsi->server_eof = end_of_write;
1917 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1918 size_t write_size, loff_t *offset)
1921 unsigned int bytes_written = 0;
1922 unsigned int total_written;
1923 struct cifs_tcon *tcon;
1924 struct TCP_Server_Info *server;
1926 struct dentry *dentry = open_file->dentry;
1927 struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1928 struct cifs_io_parms io_parms = {0};
1930 cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1931 write_size, *offset, dentry);
1933 tcon = tlink_tcon(open_file->tlink);
1934 server = tcon->ses->server;
1936 if (!server->ops->sync_write)
1941 for (total_written = 0; write_size > total_written;
1942 total_written += bytes_written) {
1944 while (rc == -EAGAIN) {
1948 if (open_file->invalidHandle) {
1949 /* we could deadlock if we called
1950 filemap_fdatawait from here so tell
1951 reopen_file not to flush data to
1953 rc = cifs_reopen_file(open_file, false);
1958 len = min(server->ops->wp_retry_size(d_inode(dentry)),
1959 (unsigned int)write_size - total_written);
1960 /* iov[0] is reserved for smb header */
1961 iov[1].iov_base = (char *)write_data + total_written;
1962 iov[1].iov_len = len;
1964 io_parms.tcon = tcon;
1965 io_parms.offset = *offset;
1966 io_parms.length = len;
1967 rc = server->ops->sync_write(xid, &open_file->fid,
1968 &io_parms, &bytes_written, iov, 1);
1970 if (rc || (bytes_written == 0)) {
1978 spin_lock(&d_inode(dentry)->i_lock);
1979 cifs_update_eof(cifsi, *offset, bytes_written);
1980 spin_unlock(&d_inode(dentry)->i_lock);
1981 *offset += bytes_written;
1985 cifs_stats_bytes_written(tcon, total_written);
1987 if (total_written > 0) {
1988 spin_lock(&d_inode(dentry)->i_lock);
1989 if (*offset > d_inode(dentry)->i_size) {
1990 i_size_write(d_inode(dentry), *offset);
1991 d_inode(dentry)->i_blocks = (512 - 1 + *offset) >> 9;
1993 spin_unlock(&d_inode(dentry)->i_lock);
1995 mark_inode_dirty_sync(d_inode(dentry));
1997 return total_written;
2000 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
2003 struct cifsFileInfo *open_file = NULL;
2004 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
2006 /* only filter by fsuid on multiuser mounts */
2007 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
2010 spin_lock(&cifs_inode->open_file_lock);
2011 /* we could simply get the first_list_entry since write-only entries
2012 are always at the end of the list but since the first entry might
2013 have a close pending, we go through the whole list */
2014 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2015 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
2017 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
2018 if ((!open_file->invalidHandle)) {
2019 /* found a good file */
2020 /* lock it so it will not be closed on us */
2021 cifsFileInfo_get(open_file);
2022 spin_unlock(&cifs_inode->open_file_lock);
2024 } /* else might as well continue, and look for
2025 another, or simply have the caller reopen it
2026 again rather than trying to fix this handle */
2027 } else /* write only file */
2028 break; /* write only files are last so must be done */
2030 spin_unlock(&cifs_inode->open_file_lock);
2034 /* Return -EBADF if no handle is found and general rc otherwise */
2036 cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, int flags,
2037 struct cifsFileInfo **ret_file)
2039 struct cifsFileInfo *open_file, *inv_file = NULL;
2040 struct cifs_sb_info *cifs_sb;
2041 bool any_available = false;
2043 unsigned int refind = 0;
2044 bool fsuid_only = flags & FIND_WR_FSUID_ONLY;
2045 bool with_delete = flags & FIND_WR_WITH_DELETE;
2049 * Having a null inode here (because mapping->host was set to zero by
2050 * the VFS or MM) should not happen but we had reports of on oops (due
2051 * to it being zero) during stress testcases so we need to check for it
2054 if (cifs_inode == NULL) {
2055 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
2060 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
2062 /* only filter by fsuid on multiuser mounts */
2063 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
2066 spin_lock(&cifs_inode->open_file_lock);
2068 if (refind > MAX_REOPEN_ATT) {
2069 spin_unlock(&cifs_inode->open_file_lock);
2072 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2073 if (!any_available && open_file->pid != current->tgid)
2075 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
2077 if (with_delete && !(open_file->fid.access & DELETE))
2079 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2080 if (!open_file->invalidHandle) {
2081 /* found a good writable file */
2082 cifsFileInfo_get(open_file);
2083 spin_unlock(&cifs_inode->open_file_lock);
2084 *ret_file = open_file;
2088 inv_file = open_file;
2092 /* couldn't find useable FH with same pid, try any available */
2093 if (!any_available) {
2094 any_available = true;
2095 goto refind_writable;
2099 any_available = false;
2100 cifsFileInfo_get(inv_file);
2103 spin_unlock(&cifs_inode->open_file_lock);
2106 rc = cifs_reopen_file(inv_file, false);
2108 *ret_file = inv_file;
2112 spin_lock(&cifs_inode->open_file_lock);
2113 list_move_tail(&inv_file->flist, &cifs_inode->openFileList);
2114 spin_unlock(&cifs_inode->open_file_lock);
2115 cifsFileInfo_put(inv_file);
2118 spin_lock(&cifs_inode->open_file_lock);
2119 goto refind_writable;
2125 struct cifsFileInfo *
2126 find_writable_file(struct cifsInodeInfo *cifs_inode, int flags)
2128 struct cifsFileInfo *cfile;
2131 rc = cifs_get_writable_file(cifs_inode, flags, &cfile);
2133 cifs_dbg(FYI, "Couldn't find writable handle rc=%d\n", rc);
2139 cifs_get_writable_path(struct cifs_tcon *tcon, const char *name,
2141 struct cifsFileInfo **ret_file)
2143 struct cifsFileInfo *cfile;
2144 void *page = alloc_dentry_path();
2148 spin_lock(&tcon->open_file_lock);
2149 list_for_each_entry(cfile, &tcon->openFileList, tlist) {
2150 struct cifsInodeInfo *cinode;
2151 const char *full_path = build_path_from_dentry(cfile->dentry, page);
2152 if (IS_ERR(full_path)) {
2153 spin_unlock(&tcon->open_file_lock);
2154 free_dentry_path(page);
2155 return PTR_ERR(full_path);
2157 if (strcmp(full_path, name))
2160 cinode = CIFS_I(d_inode(cfile->dentry));
2161 spin_unlock(&tcon->open_file_lock);
2162 free_dentry_path(page);
2163 return cifs_get_writable_file(cinode, flags, ret_file);
2166 spin_unlock(&tcon->open_file_lock);
2167 free_dentry_path(page);
2172 cifs_get_readable_path(struct cifs_tcon *tcon, const char *name,
2173 struct cifsFileInfo **ret_file)
2175 struct cifsFileInfo *cfile;
2176 void *page = alloc_dentry_path();
2180 spin_lock(&tcon->open_file_lock);
2181 list_for_each_entry(cfile, &tcon->openFileList, tlist) {
2182 struct cifsInodeInfo *cinode;
2183 const char *full_path = build_path_from_dentry(cfile->dentry, page);
2184 if (IS_ERR(full_path)) {
2185 spin_unlock(&tcon->open_file_lock);
2186 free_dentry_path(page);
2187 return PTR_ERR(full_path);
2189 if (strcmp(full_path, name))
2192 cinode = CIFS_I(d_inode(cfile->dentry));
2193 spin_unlock(&tcon->open_file_lock);
2194 free_dentry_path(page);
2195 *ret_file = find_readable_file(cinode, 0);
2196 return *ret_file ? 0 : -ENOENT;
2199 spin_unlock(&tcon->open_file_lock);
2200 free_dentry_path(page);
2204 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
2206 struct address_space *mapping = page->mapping;
2207 loff_t offset = (loff_t)page->index << PAGE_SHIFT;
2210 int bytes_written = 0;
2211 struct inode *inode;
2212 struct cifsFileInfo *open_file;
2214 if (!mapping || !mapping->host)
2217 inode = page->mapping->host;
2219 offset += (loff_t)from;
2220 write_data = kmap(page);
2223 if ((to > PAGE_SIZE) || (from > to)) {
2228 /* racing with truncate? */
2229 if (offset > mapping->host->i_size) {
2231 return 0; /* don't care */
2234 /* check to make sure that we are not extending the file */
2235 if (mapping->host->i_size - offset < (loff_t)to)
2236 to = (unsigned)(mapping->host->i_size - offset);
2238 rc = cifs_get_writable_file(CIFS_I(mapping->host), FIND_WR_ANY,
2241 bytes_written = cifs_write(open_file, open_file->pid,
2242 write_data, to - from, &offset);
2243 cifsFileInfo_put(open_file);
2244 /* Does mm or vfs already set times? */
2245 inode->i_atime = inode->i_mtime = current_time(inode);
2246 if ((bytes_written > 0) && (offset))
2248 else if (bytes_written < 0)
2253 cifs_dbg(FYI, "No writable handle for write page rc=%d\n", rc);
2254 if (!is_retryable_error(rc))
2262 static struct cifs_writedata *
2263 wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
2264 pgoff_t end, pgoff_t *index,
2265 unsigned int *found_pages)
2267 struct cifs_writedata *wdata;
2269 wdata = cifs_writedata_alloc((unsigned int)tofind,
2270 cifs_writev_complete);
2274 *found_pages = find_get_pages_range_tag(mapping, index, end,
2275 PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
2280 wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
2281 struct address_space *mapping,
2282 struct writeback_control *wbc,
2283 pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
2285 unsigned int nr_pages = 0, i;
2288 for (i = 0; i < found_pages; i++) {
2289 page = wdata->pages[i];
2291 * At this point we hold neither the i_pages lock nor the
2292 * page lock: the page may be truncated or invalidated
2293 * (changing page->mapping to NULL), or even swizzled
2294 * back from swapper_space to tmpfs file mapping
2299 else if (!trylock_page(page))
2302 if (unlikely(page->mapping != mapping)) {
2307 if (!wbc->range_cyclic && page->index > end) {
2313 if (*next && (page->index != *next)) {
2314 /* Not next consecutive page */
2319 if (wbc->sync_mode != WB_SYNC_NONE)
2320 wait_on_page_writeback(page);
2322 if (PageWriteback(page) ||
2323 !clear_page_dirty_for_io(page)) {
2329 * This actually clears the dirty bit in the radix tree.
2330 * See cifs_writepage() for more commentary.
2332 set_page_writeback(page);
2333 if (page_offset(page) >= i_size_read(mapping->host)) {
2336 end_page_writeback(page);
2340 wdata->pages[i] = page;
2341 *next = page->index + 1;
2345 /* reset index to refind any pages skipped */
2347 *index = wdata->pages[0]->index + 1;
2349 /* put any pages we aren't going to use */
2350 for (i = nr_pages; i < found_pages; i++) {
2351 put_page(wdata->pages[i]);
2352 wdata->pages[i] = NULL;
2359 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2360 struct address_space *mapping, struct writeback_control *wbc)
2364 wdata->sync_mode = wbc->sync_mode;
2365 wdata->nr_pages = nr_pages;
2366 wdata->offset = page_offset(wdata->pages[0]);
2367 wdata->pagesz = PAGE_SIZE;
2368 wdata->tailsz = min(i_size_read(mapping->host) -
2369 page_offset(wdata->pages[nr_pages - 1]),
2371 wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2372 wdata->pid = wdata->cfile->pid;
2374 rc = adjust_credits(wdata->server, &wdata->credits, wdata->bytes);
2378 if (wdata->cfile->invalidHandle)
2381 rc = wdata->server->ops->async_writev(wdata,
2382 cifs_writedata_release);
2387 static int cifs_writepages(struct address_space *mapping,
2388 struct writeback_control *wbc)
2390 struct inode *inode = mapping->host;
2391 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2392 struct TCP_Server_Info *server;
2393 bool done = false, scanned = false, range_whole = false;
2395 struct cifs_writedata *wdata;
2396 struct cifsFileInfo *cfile = NULL;
2402 * If wsize is smaller than the page cache size, default to writing
2403 * one page at a time via cifs_writepage
2405 if (cifs_sb->ctx->wsize < PAGE_SIZE)
2406 return generic_writepages(mapping, wbc);
2409 if (wbc->range_cyclic) {
2410 index = mapping->writeback_index; /* Start from prev offset */
2413 index = wbc->range_start >> PAGE_SHIFT;
2414 end = wbc->range_end >> PAGE_SHIFT;
2415 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2419 server = cifs_pick_channel(cifs_sb_master_tcon(cifs_sb)->ses);
2422 while (!done && index <= end) {
2423 unsigned int i, nr_pages, found_pages, wsize;
2424 pgoff_t next = 0, tofind, saved_index = index;
2425 struct cifs_credits credits_on_stack;
2426 struct cifs_credits *credits = &credits_on_stack;
2427 int get_file_rc = 0;
2430 cifsFileInfo_put(cfile);
2432 rc = cifs_get_writable_file(CIFS_I(inode), FIND_WR_ANY, &cfile);
2434 /* in case of an error store it to return later */
2438 rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->wsize,
2445 tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2447 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2452 add_credits_and_wake_if(server, credits, 0);
2456 if (found_pages == 0) {
2457 kref_put(&wdata->refcount, cifs_writedata_release);
2458 add_credits_and_wake_if(server, credits, 0);
2462 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2463 end, &index, &next, &done);
2465 /* nothing to write? */
2466 if (nr_pages == 0) {
2467 kref_put(&wdata->refcount, cifs_writedata_release);
2468 add_credits_and_wake_if(server, credits, 0);
2472 wdata->credits = credits_on_stack;
2473 wdata->cfile = cfile;
2474 wdata->server = server;
2477 if (!wdata->cfile) {
2478 cifs_dbg(VFS, "No writable handle in writepages rc=%d\n",
2480 if (is_retryable_error(get_file_rc))
2485 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2487 for (i = 0; i < nr_pages; ++i)
2488 unlock_page(wdata->pages[i]);
2490 /* send failure -- clean up the mess */
2492 add_credits_and_wake_if(server, &wdata->credits, 0);
2493 for (i = 0; i < nr_pages; ++i) {
2494 if (is_retryable_error(rc))
2495 redirty_page_for_writepage(wbc,
2498 SetPageError(wdata->pages[i]);
2499 end_page_writeback(wdata->pages[i]);
2500 put_page(wdata->pages[i]);
2502 if (!is_retryable_error(rc))
2503 mapping_set_error(mapping, rc);
2505 kref_put(&wdata->refcount, cifs_writedata_release);
2507 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2508 index = saved_index;
2512 /* Return immediately if we received a signal during writing */
2513 if (is_interrupt_error(rc)) {
2518 if (rc != 0 && saved_rc == 0)
2521 wbc->nr_to_write -= nr_pages;
2522 if (wbc->nr_to_write <= 0)
2528 if (!scanned && !done) {
2530 * We hit the last page and there is more work to be done: wrap
2531 * back to the start of the file
2541 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2542 mapping->writeback_index = index;
2545 cifsFileInfo_put(cfile);
2547 /* Indication to update ctime and mtime as close is deferred */
2548 set_bit(CIFS_INO_MODIFIED_ATTR, &CIFS_I(inode)->flags);
2553 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2559 /* BB add check for wbc flags */
2561 if (!PageUptodate(page))
2562 cifs_dbg(FYI, "ppw - page not up to date\n");
2565 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2567 * A writepage() implementation always needs to do either this,
2568 * or re-dirty the page with "redirty_page_for_writepage()" in
2569 * the case of a failure.
2571 * Just unlocking the page will cause the radix tree tag-bits
2572 * to fail to update with the state of the page correctly.
2574 set_page_writeback(page);
2576 rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2577 if (is_retryable_error(rc)) {
2578 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2580 redirty_page_for_writepage(wbc, page);
2581 } else if (rc != 0) {
2583 mapping_set_error(page->mapping, rc);
2585 SetPageUptodate(page);
2587 end_page_writeback(page);
2593 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2595 int rc = cifs_writepage_locked(page, wbc);
2600 static int cifs_write_end(struct file *file, struct address_space *mapping,
2601 loff_t pos, unsigned len, unsigned copied,
2602 struct page *page, void *fsdata)
2605 struct inode *inode = mapping->host;
2606 struct cifsFileInfo *cfile = file->private_data;
2607 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2610 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2613 pid = current->tgid;
2615 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2618 if (PageChecked(page)) {
2620 SetPageUptodate(page);
2621 ClearPageChecked(page);
2622 } else if (!PageUptodate(page) && copied == PAGE_SIZE)
2623 SetPageUptodate(page);
2625 if (!PageUptodate(page)) {
2627 unsigned offset = pos & (PAGE_SIZE - 1);
2631 /* this is probably better than directly calling
2632 partialpage_write since in this function the file handle is
2633 known which we might as well leverage */
2634 /* BB check if anything else missing out of ppw
2635 such as updating last write time */
2636 page_data = kmap(page);
2637 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2638 /* if (rc < 0) should we set writebehind rc? */
2645 set_page_dirty(page);
2649 spin_lock(&inode->i_lock);
2650 if (pos > inode->i_size) {
2651 i_size_write(inode, pos);
2652 inode->i_blocks = (512 - 1 + pos) >> 9;
2654 spin_unlock(&inode->i_lock);
2659 /* Indication to update ctime and mtime as close is deferred */
2660 set_bit(CIFS_INO_MODIFIED_ATTR, &CIFS_I(inode)->flags);
2665 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2670 struct cifs_tcon *tcon;
2671 struct TCP_Server_Info *server;
2672 struct cifsFileInfo *smbfile = file->private_data;
2673 struct inode *inode = file_inode(file);
2674 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2676 rc = file_write_and_wait_range(file, start, end);
2678 trace_cifs_fsync_err(inode->i_ino, rc);
2684 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2687 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2688 rc = cifs_zap_mapping(inode);
2690 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2691 rc = 0; /* don't care about it in fsync */
2695 tcon = tlink_tcon(smbfile->tlink);
2696 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2697 server = tcon->ses->server;
2698 if (server->ops->flush == NULL) {
2700 goto strict_fsync_exit;
2703 if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) {
2704 smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
2706 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2707 cifsFileInfo_put(smbfile);
2709 cifs_dbg(FYI, "ignore fsync for file not open for write\n");
2711 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2719 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2723 struct cifs_tcon *tcon;
2724 struct TCP_Server_Info *server;
2725 struct cifsFileInfo *smbfile = file->private_data;
2726 struct inode *inode = file_inode(file);
2727 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2729 rc = file_write_and_wait_range(file, start, end);
2731 trace_cifs_fsync_err(file_inode(file)->i_ino, rc);
2737 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2740 tcon = tlink_tcon(smbfile->tlink);
2741 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2742 server = tcon->ses->server;
2743 if (server->ops->flush == NULL) {
2748 if ((OPEN_FMODE(smbfile->f_flags) & FMODE_WRITE) == 0) {
2749 smbfile = find_writable_file(CIFS_I(inode), FIND_WR_ANY);
2751 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2752 cifsFileInfo_put(smbfile);
2754 cifs_dbg(FYI, "ignore fsync for file not open for write\n");
2756 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2765 * As file closes, flush all cached write data for this inode checking
2766 * for write behind errors.
2768 int cifs_flush(struct file *file, fl_owner_t id)
2770 struct inode *inode = file_inode(file);
2773 if (file->f_mode & FMODE_WRITE)
2774 rc = filemap_write_and_wait(inode->i_mapping);
2776 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2778 trace_cifs_flush_err(inode->i_ino, rc);
2783 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2788 for (i = 0; i < num_pages; i++) {
2789 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2792 * save number of pages we have already allocated and
2793 * return with ENOMEM error
2802 for (i = 0; i < num_pages; i++)
2809 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2814 clen = min_t(const size_t, len, wsize);
2815 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2824 cifs_uncached_writedata_release(struct kref *refcount)
2827 struct cifs_writedata *wdata = container_of(refcount,
2828 struct cifs_writedata, refcount);
2830 kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2831 for (i = 0; i < wdata->nr_pages; i++)
2832 put_page(wdata->pages[i]);
2833 cifs_writedata_release(refcount);
2836 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
2839 cifs_uncached_writev_complete(struct work_struct *work)
2841 struct cifs_writedata *wdata = container_of(work,
2842 struct cifs_writedata, work);
2843 struct inode *inode = d_inode(wdata->cfile->dentry);
2844 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2846 spin_lock(&inode->i_lock);
2847 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2848 if (cifsi->server_eof > inode->i_size)
2849 i_size_write(inode, cifsi->server_eof);
2850 spin_unlock(&inode->i_lock);
2852 complete(&wdata->done);
2853 collect_uncached_write_data(wdata->ctx);
2854 /* the below call can possibly free the last ref to aio ctx */
2855 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2859 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2860 size_t *len, unsigned long *num_pages)
2862 size_t save_len, copied, bytes, cur_len = *len;
2863 unsigned long i, nr_pages = *num_pages;
2866 for (i = 0; i < nr_pages; i++) {
2867 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2868 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2871 * If we didn't copy as much as we expected, then that
2872 * may mean we trod into an unmapped area. Stop copying
2873 * at that point. On the next pass through the big
2874 * loop, we'll likely end up getting a zero-length
2875 * write and bailing out of it.
2880 cur_len = save_len - cur_len;
2884 * If we have no data to send, then that probably means that
2885 * the copy above failed altogether. That's most likely because
2886 * the address in the iovec was bogus. Return -EFAULT and let
2887 * the caller free anything we allocated and bail out.
2893 * i + 1 now represents the number of pages we actually used in
2894 * the copy phase above.
2901 cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
2902 struct cifs_aio_ctx *ctx)
2905 struct cifs_credits credits;
2907 struct TCP_Server_Info *server = wdata->server;
2910 if (wdata->cfile->invalidHandle) {
2911 rc = cifs_reopen_file(wdata->cfile, false);
2920 * Wait for credits to resend this wdata.
2921 * Note: we are attempting to resend the whole wdata not in
2925 rc = server->ops->wait_mtu_credits(server, wdata->bytes,
2930 if (wsize < wdata->bytes) {
2931 add_credits_and_wake_if(server, &credits, 0);
2934 } while (wsize < wdata->bytes);
2935 wdata->credits = credits;
2937 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2940 if (wdata->cfile->invalidHandle)
2943 #ifdef CONFIG_CIFS_SMB_DIRECT
2945 wdata->mr->need_invalidate = true;
2946 smbd_deregister_mr(wdata->mr);
2950 rc = server->ops->async_writev(wdata,
2951 cifs_uncached_writedata_release);
2955 /* If the write was successfully sent, we are done */
2957 list_add_tail(&wdata->list, wdata_list);
2961 /* Roll back credits and retry if needed */
2962 add_credits_and_wake_if(server, &wdata->credits, 0);
2963 } while (rc == -EAGAIN);
2966 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2971 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2972 struct cifsFileInfo *open_file,
2973 struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
2974 struct cifs_aio_ctx *ctx)
2978 unsigned long nr_pages, num_pages, i;
2979 struct cifs_writedata *wdata;
2980 struct iov_iter saved_from = *from;
2981 loff_t saved_offset = offset;
2983 struct TCP_Server_Info *server;
2984 struct page **pagevec;
2988 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2989 pid = open_file->pid;
2991 pid = current->tgid;
2993 server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
2998 struct cifs_credits credits_on_stack;
2999 struct cifs_credits *credits = &credits_on_stack;
3001 if (open_file->invalidHandle) {
3002 rc = cifs_reopen_file(open_file, false);
3009 rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->wsize,
3014 cur_len = min_t(const size_t, len, wsize);
3016 if (ctx->direct_io) {
3019 result = iov_iter_get_pages_alloc(
3020 from, &pagevec, cur_len, &start);
3023 "direct_writev couldn't get user pages (rc=%zd) iter type %d iov_offset %zd count %zd\n",
3024 result, iov_iter_type(from),
3025 from->iov_offset, from->count);
3029 add_credits_and_wake_if(server, credits, 0);
3032 cur_len = (size_t)result;
3033 iov_iter_advance(from, cur_len);
3036 (cur_len + start + PAGE_SIZE - 1) / PAGE_SIZE;
3038 wdata = cifs_writedata_direct_alloc(pagevec,
3039 cifs_uncached_writev_complete);
3042 add_credits_and_wake_if(server, credits, 0);
3047 wdata->page_offset = start;
3050 cur_len - (PAGE_SIZE - start) -
3051 (nr_pages - 2) * PAGE_SIZE :
3054 nr_pages = get_numpages(wsize, len, &cur_len);
3055 wdata = cifs_writedata_alloc(nr_pages,
3056 cifs_uncached_writev_complete);
3059 add_credits_and_wake_if(server, credits, 0);
3063 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
3065 kvfree(wdata->pages);
3067 add_credits_and_wake_if(server, credits, 0);
3071 num_pages = nr_pages;
3072 rc = wdata_fill_from_iovec(
3073 wdata, from, &cur_len, &num_pages);
3075 for (i = 0; i < nr_pages; i++)
3076 put_page(wdata->pages[i]);
3077 kvfree(wdata->pages);
3079 add_credits_and_wake_if(server, credits, 0);
3084 * Bring nr_pages down to the number of pages we
3085 * actually used, and free any pages that we didn't use.
3087 for ( ; nr_pages > num_pages; nr_pages--)
3088 put_page(wdata->pages[nr_pages - 1]);
3090 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
3093 wdata->sync_mode = WB_SYNC_ALL;
3094 wdata->nr_pages = nr_pages;
3095 wdata->offset = (__u64)offset;
3096 wdata->cfile = cifsFileInfo_get(open_file);
3097 wdata->server = server;
3099 wdata->bytes = cur_len;
3100 wdata->pagesz = PAGE_SIZE;
3101 wdata->credits = credits_on_stack;
3103 kref_get(&ctx->refcount);
3105 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
3108 if (wdata->cfile->invalidHandle)
3111 rc = server->ops->async_writev(wdata,
3112 cifs_uncached_writedata_release);
3116 add_credits_and_wake_if(server, &wdata->credits, 0);
3117 kref_put(&wdata->refcount,
3118 cifs_uncached_writedata_release);
3119 if (rc == -EAGAIN) {
3121 iov_iter_advance(from, offset - saved_offset);
3127 list_add_tail(&wdata->list, wdata_list);
3136 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
3138 struct cifs_writedata *wdata, *tmp;
3139 struct cifs_tcon *tcon;
3140 struct cifs_sb_info *cifs_sb;
3141 struct dentry *dentry = ctx->cfile->dentry;
3144 tcon = tlink_tcon(ctx->cfile->tlink);
3145 cifs_sb = CIFS_SB(dentry->d_sb);
3147 mutex_lock(&ctx->aio_mutex);
3149 if (list_empty(&ctx->list)) {
3150 mutex_unlock(&ctx->aio_mutex);
3156 * Wait for and collect replies for any successful sends in order of
3157 * increasing offset. Once an error is hit, then return without waiting
3158 * for any more replies.
3161 list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
3163 if (!try_wait_for_completion(&wdata->done)) {
3164 mutex_unlock(&ctx->aio_mutex);
3171 ctx->total_len += wdata->bytes;
3173 /* resend call if it's a retryable error */
3174 if (rc == -EAGAIN) {
3175 struct list_head tmp_list;
3176 struct iov_iter tmp_from = ctx->iter;
3178 INIT_LIST_HEAD(&tmp_list);
3179 list_del_init(&wdata->list);
3182 rc = cifs_resend_wdata(
3183 wdata, &tmp_list, ctx);
3185 iov_iter_advance(&tmp_from,
3186 wdata->offset - ctx->pos);
3188 rc = cifs_write_from_iter(wdata->offset,
3189 wdata->bytes, &tmp_from,
3190 ctx->cfile, cifs_sb, &tmp_list,
3193 kref_put(&wdata->refcount,
3194 cifs_uncached_writedata_release);
3197 list_splice(&tmp_list, &ctx->list);
3201 list_del_init(&wdata->list);
3202 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
3205 cifs_stats_bytes_written(tcon, ctx->total_len);
3206 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
3208 ctx->rc = (rc == 0) ? ctx->total_len : rc;
3210 mutex_unlock(&ctx->aio_mutex);
3212 if (ctx->iocb && ctx->iocb->ki_complete)
3213 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3215 complete(&ctx->done);
3218 static ssize_t __cifs_writev(
3219 struct kiocb *iocb, struct iov_iter *from, bool direct)
3221 struct file *file = iocb->ki_filp;
3222 ssize_t total_written = 0;
3223 struct cifsFileInfo *cfile;
3224 struct cifs_tcon *tcon;
3225 struct cifs_sb_info *cifs_sb;
3226 struct cifs_aio_ctx *ctx;
3227 struct iov_iter saved_from = *from;
3228 size_t len = iov_iter_count(from);
3232 * iov_iter_get_pages_alloc doesn't work with ITER_KVEC.
3233 * In this case, fall back to non-direct write function.
3234 * this could be improved by getting pages directly in ITER_KVEC
3236 if (direct && iov_iter_is_kvec(from)) {
3237 cifs_dbg(FYI, "use non-direct cifs_writev for kvec I/O\n");
3241 rc = generic_write_checks(iocb, from);
3245 cifs_sb = CIFS_FILE_SB(file);
3246 cfile = file->private_data;
3247 tcon = tlink_tcon(cfile->tlink);
3249 if (!tcon->ses->server->ops->async_writev)
3252 ctx = cifs_aio_ctx_alloc();
3256 ctx->cfile = cifsFileInfo_get(cfile);
3258 if (!is_sync_kiocb(iocb))
3261 ctx->pos = iocb->ki_pos;
3264 ctx->direct_io = true;
3268 rc = setup_aio_ctx_iter(ctx, from, WRITE);
3270 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3275 /* grab a lock here due to read response handlers can access ctx */
3276 mutex_lock(&ctx->aio_mutex);
3278 rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
3279 cfile, cifs_sb, &ctx->list, ctx);
3282 * If at least one write was successfully sent, then discard any rc
3283 * value from the later writes. If the other write succeeds, then
3284 * we'll end up returning whatever was written. If it fails, then
3285 * we'll get a new rc value from that.
3287 if (!list_empty(&ctx->list))
3290 mutex_unlock(&ctx->aio_mutex);
3293 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3297 if (!is_sync_kiocb(iocb)) {
3298 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3299 return -EIOCBQUEUED;
3302 rc = wait_for_completion_killable(&ctx->done);
3304 mutex_lock(&ctx->aio_mutex);
3305 ctx->rc = rc = -EINTR;
3306 total_written = ctx->total_len;
3307 mutex_unlock(&ctx->aio_mutex);
3310 total_written = ctx->total_len;
3313 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3315 if (unlikely(!total_written))
3318 iocb->ki_pos += total_written;
3319 return total_written;
3322 ssize_t cifs_direct_writev(struct kiocb *iocb, struct iov_iter *from)
3324 struct file *file = iocb->ki_filp;
3326 cifs_revalidate_mapping(file->f_inode);
3327 return __cifs_writev(iocb, from, true);
3330 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
3332 return __cifs_writev(iocb, from, false);
3336 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
3338 struct file *file = iocb->ki_filp;
3339 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
3340 struct inode *inode = file->f_mapping->host;
3341 struct cifsInodeInfo *cinode = CIFS_I(inode);
3342 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
3347 * We need to hold the sem to be sure nobody modifies lock list
3348 * with a brlock that prevents writing.
3350 down_read(&cinode->lock_sem);
3352 rc = generic_write_checks(iocb, from);
3356 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
3357 server->vals->exclusive_lock_type, 0,
3358 NULL, CIFS_WRITE_OP))
3359 rc = __generic_file_write_iter(iocb, from);
3363 up_read(&cinode->lock_sem);
3364 inode_unlock(inode);
3367 rc = generic_write_sync(iocb, rc);
3372 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
3374 struct inode *inode = file_inode(iocb->ki_filp);
3375 struct cifsInodeInfo *cinode = CIFS_I(inode);
3376 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3377 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3378 iocb->ki_filp->private_data;
3379 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3382 written = cifs_get_writer(cinode);
3386 if (CIFS_CACHE_WRITE(cinode)) {
3387 if (cap_unix(tcon->ses) &&
3388 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
3389 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
3390 written = generic_file_write_iter(iocb, from);
3393 written = cifs_writev(iocb, from);
3397 * For non-oplocked files in strict cache mode we need to write the data
3398 * to the server exactly from the pos to pos+len-1 rather than flush all
3399 * affected pages because it may cause a error with mandatory locks on
3400 * these pages but not on the region from pos to ppos+len-1.
3402 written = cifs_user_writev(iocb, from);
3403 if (CIFS_CACHE_READ(cinode)) {
3405 * We have read level caching and we have just sent a write
3406 * request to the server thus making data in the cache stale.
3407 * Zap the cache and set oplock/lease level to NONE to avoid
3408 * reading stale data from the cache. All subsequent read
3409 * operations will read new data from the server.
3411 cifs_zap_mapping(inode);
3412 cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3417 cifs_put_writer(cinode);
3421 static struct cifs_readdata *
3422 cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
3424 struct cifs_readdata *rdata;
3426 rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
3427 if (rdata != NULL) {
3428 rdata->pages = pages;
3429 kref_init(&rdata->refcount);
3430 INIT_LIST_HEAD(&rdata->list);
3431 init_completion(&rdata->done);
3432 INIT_WORK(&rdata->work, complete);
3438 static struct cifs_readdata *
3439 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
3441 struct page **pages =
3442 kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
3443 struct cifs_readdata *ret = NULL;
3446 ret = cifs_readdata_direct_alloc(pages, complete);
3455 cifs_readdata_release(struct kref *refcount)
3457 struct cifs_readdata *rdata = container_of(refcount,
3458 struct cifs_readdata, refcount);
3459 #ifdef CONFIG_CIFS_SMB_DIRECT
3461 smbd_deregister_mr(rdata->mr);
3466 cifsFileInfo_put(rdata->cfile);
3468 kvfree(rdata->pages);
3473 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3479 for (i = 0; i < nr_pages; i++) {
3480 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3485 rdata->pages[i] = page;
3489 unsigned int nr_page_failed = i;
3491 for (i = 0; i < nr_page_failed; i++) {
3492 put_page(rdata->pages[i]);
3493 rdata->pages[i] = NULL;
3500 cifs_uncached_readdata_release(struct kref *refcount)
3502 struct cifs_readdata *rdata = container_of(refcount,
3503 struct cifs_readdata, refcount);
3506 kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3507 for (i = 0; i < rdata->nr_pages; i++) {
3508 put_page(rdata->pages[i]);
3510 cifs_readdata_release(refcount);
3514 * cifs_readdata_to_iov - copy data from pages in response to an iovec
3515 * @rdata: the readdata response with list of pages holding data
3516 * @iter: destination for our data
3518 * This function copies data from a list of pages in a readdata response into
3519 * an array of iovecs. It will first calculate where the data should go
3520 * based on the info in the readdata and then copy the data into that spot.
3523 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3525 size_t remaining = rdata->got_bytes;
3528 for (i = 0; i < rdata->nr_pages; i++) {
3529 struct page *page = rdata->pages[i];
3530 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3533 if (unlikely(iov_iter_is_pipe(iter))) {
3534 void *addr = kmap_atomic(page);
3536 written = copy_to_iter(addr, copy, iter);
3537 kunmap_atomic(addr);
3539 written = copy_page_to_iter(page, 0, copy, iter);
3540 remaining -= written;
3541 if (written < copy && iov_iter_count(iter) > 0)
3544 return remaining ? -EFAULT : 0;
3547 static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3550 cifs_uncached_readv_complete(struct work_struct *work)
3552 struct cifs_readdata *rdata = container_of(work,
3553 struct cifs_readdata, work);
3555 complete(&rdata->done);
3556 collect_uncached_read_data(rdata->ctx);
3557 /* the below call can possibly free the last ref to aio ctx */
3558 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3562 uncached_fill_pages(struct TCP_Server_Info *server,
3563 struct cifs_readdata *rdata, struct iov_iter *iter,
3568 unsigned int nr_pages = rdata->nr_pages;
3569 unsigned int page_offset = rdata->page_offset;
3571 rdata->got_bytes = 0;
3572 rdata->tailsz = PAGE_SIZE;
3573 for (i = 0; i < nr_pages; i++) {
3574 struct page *page = rdata->pages[i];
3576 unsigned int segment_size = rdata->pagesz;
3579 segment_size -= page_offset;
3585 /* no need to hold page hostage */
3586 rdata->pages[i] = NULL;
3593 if (len >= segment_size)
3594 /* enough data to fill the page */
3597 rdata->tailsz = len;
3601 result = copy_page_from_iter(
3602 page, page_offset, n, iter);
3603 #ifdef CONFIG_CIFS_SMB_DIRECT
3608 result = cifs_read_page_from_socket(
3609 server, page, page_offset, n);
3613 rdata->got_bytes += result;
3616 return result != -ECONNABORTED && rdata->got_bytes > 0 ?
3617 rdata->got_bytes : result;
3621 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3622 struct cifs_readdata *rdata, unsigned int len)
3624 return uncached_fill_pages(server, rdata, NULL, len);
3628 cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3629 struct cifs_readdata *rdata,
3630 struct iov_iter *iter)
3632 return uncached_fill_pages(server, rdata, iter, iter->count);
3635 static int cifs_resend_rdata(struct cifs_readdata *rdata,
3636 struct list_head *rdata_list,
3637 struct cifs_aio_ctx *ctx)
3640 struct cifs_credits credits;
3642 struct TCP_Server_Info *server;
3644 /* XXX: should we pick a new channel here? */
3645 server = rdata->server;
3648 if (rdata->cfile->invalidHandle) {
3649 rc = cifs_reopen_file(rdata->cfile, true);
3657 * Wait for credits to resend this rdata.
3658 * Note: we are attempting to resend the whole rdata not in
3662 rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3668 if (rsize < rdata->bytes) {
3669 add_credits_and_wake_if(server, &credits, 0);
3672 } while (rsize < rdata->bytes);
3673 rdata->credits = credits;
3675 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3677 if (rdata->cfile->invalidHandle)
3680 #ifdef CONFIG_CIFS_SMB_DIRECT
3682 rdata->mr->need_invalidate = true;
3683 smbd_deregister_mr(rdata->mr);
3687 rc = server->ops->async_readv(rdata);
3691 /* If the read was successfully sent, we are done */
3693 /* Add to aio pending list */
3694 list_add_tail(&rdata->list, rdata_list);
3698 /* Roll back credits and retry if needed */
3699 add_credits_and_wake_if(server, &rdata->credits, 0);
3700 } while (rc == -EAGAIN);
3703 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3708 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3709 struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3710 struct cifs_aio_ctx *ctx)
3712 struct cifs_readdata *rdata;
3713 unsigned int npages, rsize;
3714 struct cifs_credits credits_on_stack;
3715 struct cifs_credits *credits = &credits_on_stack;
3719 struct TCP_Server_Info *server;
3720 struct page **pagevec;
3722 struct iov_iter direct_iov = ctx->iter;
3724 server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
3726 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3727 pid = open_file->pid;
3729 pid = current->tgid;
3732 iov_iter_advance(&direct_iov, offset - ctx->pos);
3735 if (open_file->invalidHandle) {
3736 rc = cifs_reopen_file(open_file, true);
3743 if (cifs_sb->ctx->rsize == 0)
3744 cifs_sb->ctx->rsize =
3745 server->ops->negotiate_rsize(tlink_tcon(open_file->tlink),
3748 rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
3753 cur_len = min_t(const size_t, len, rsize);
3755 if (ctx->direct_io) {
3758 result = iov_iter_get_pages_alloc(
3759 &direct_iov, &pagevec,
3763 "Couldn't get user pages (rc=%zd) iter type %d iov_offset %zd count %zd\n",
3764 result, iov_iter_type(&direct_iov),
3765 direct_iov.iov_offset,
3770 add_credits_and_wake_if(server, credits, 0);
3773 cur_len = (size_t)result;
3774 iov_iter_advance(&direct_iov, cur_len);
3776 rdata = cifs_readdata_direct_alloc(
3777 pagevec, cifs_uncached_readv_complete);
3779 add_credits_and_wake_if(server, credits, 0);
3784 npages = (cur_len + start + PAGE_SIZE-1) / PAGE_SIZE;
3785 rdata->page_offset = start;
3786 rdata->tailsz = npages > 1 ?
3787 cur_len-(PAGE_SIZE-start)-(npages-2)*PAGE_SIZE :
3792 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3793 /* allocate a readdata struct */
3794 rdata = cifs_readdata_alloc(npages,
3795 cifs_uncached_readv_complete);
3797 add_credits_and_wake_if(server, credits, 0);
3802 rc = cifs_read_allocate_pages(rdata, npages);
3804 kvfree(rdata->pages);
3806 add_credits_and_wake_if(server, credits, 0);
3810 rdata->tailsz = PAGE_SIZE;
3813 rdata->server = server;
3814 rdata->cfile = cifsFileInfo_get(open_file);
3815 rdata->nr_pages = npages;
3816 rdata->offset = offset;
3817 rdata->bytes = cur_len;
3819 rdata->pagesz = PAGE_SIZE;
3820 rdata->read_into_pages = cifs_uncached_read_into_pages;
3821 rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3822 rdata->credits = credits_on_stack;
3824 kref_get(&ctx->refcount);
3826 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3829 if (rdata->cfile->invalidHandle)
3832 rc = server->ops->async_readv(rdata);
3836 add_credits_and_wake_if(server, &rdata->credits, 0);
3837 kref_put(&rdata->refcount,
3838 cifs_uncached_readdata_release);
3839 if (rc == -EAGAIN) {
3840 iov_iter_revert(&direct_iov, cur_len);
3846 list_add_tail(&rdata->list, rdata_list);
3855 collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3857 struct cifs_readdata *rdata, *tmp;
3858 struct iov_iter *to = &ctx->iter;
3859 struct cifs_sb_info *cifs_sb;
3862 cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3864 mutex_lock(&ctx->aio_mutex);
3866 if (list_empty(&ctx->list)) {
3867 mutex_unlock(&ctx->aio_mutex);
3872 /* the loop below should proceed in the order of increasing offsets */
3874 list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3876 if (!try_wait_for_completion(&rdata->done)) {
3877 mutex_unlock(&ctx->aio_mutex);
3881 if (rdata->result == -EAGAIN) {
3882 /* resend call if it's a retryable error */
3883 struct list_head tmp_list;
3884 unsigned int got_bytes = rdata->got_bytes;
3886 list_del_init(&rdata->list);
3887 INIT_LIST_HEAD(&tmp_list);
3890 * Got a part of data and then reconnect has
3891 * happened -- fill the buffer and continue
3894 if (got_bytes && got_bytes < rdata->bytes) {
3896 if (!ctx->direct_io)
3897 rc = cifs_readdata_to_iov(rdata, to);
3899 kref_put(&rdata->refcount,
3900 cifs_uncached_readdata_release);
3905 if (ctx->direct_io) {
3907 * Re-use rdata as this is a
3910 rc = cifs_resend_rdata(
3914 rc = cifs_send_async_read(
3915 rdata->offset + got_bytes,
3916 rdata->bytes - got_bytes,
3917 rdata->cfile, cifs_sb,
3920 kref_put(&rdata->refcount,
3921 cifs_uncached_readdata_release);
3924 list_splice(&tmp_list, &ctx->list);
3927 } else if (rdata->result)
3929 else if (!ctx->direct_io)
3930 rc = cifs_readdata_to_iov(rdata, to);
3932 /* if there was a short read -- discard anything left */
3933 if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3936 ctx->total_len += rdata->got_bytes;
3938 list_del_init(&rdata->list);
3939 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3942 if (!ctx->direct_io)
3943 ctx->total_len = ctx->len - iov_iter_count(to);
3945 /* mask nodata case */
3949 ctx->rc = (rc == 0) ? (ssize_t)ctx->total_len : rc;
3951 mutex_unlock(&ctx->aio_mutex);
3953 if (ctx->iocb && ctx->iocb->ki_complete)
3954 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3956 complete(&ctx->done);
3959 static ssize_t __cifs_readv(
3960 struct kiocb *iocb, struct iov_iter *to, bool direct)
3963 struct file *file = iocb->ki_filp;
3964 struct cifs_sb_info *cifs_sb;
3965 struct cifsFileInfo *cfile;
3966 struct cifs_tcon *tcon;
3967 ssize_t rc, total_read = 0;
3968 loff_t offset = iocb->ki_pos;
3969 struct cifs_aio_ctx *ctx;
3972 * iov_iter_get_pages_alloc() doesn't work with ITER_KVEC,
3973 * fall back to data copy read path
3974 * this could be improved by getting pages directly in ITER_KVEC
3976 if (direct && iov_iter_is_kvec(to)) {
3977 cifs_dbg(FYI, "use non-direct cifs_user_readv for kvec I/O\n");
3981 len = iov_iter_count(to);
3985 cifs_sb = CIFS_FILE_SB(file);
3986 cfile = file->private_data;
3987 tcon = tlink_tcon(cfile->tlink);
3989 if (!tcon->ses->server->ops->async_readv)
3992 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3993 cifs_dbg(FYI, "attempting read on write only file instance\n");
3995 ctx = cifs_aio_ctx_alloc();
3999 ctx->cfile = cifsFileInfo_get(cfile);
4001 if (!is_sync_kiocb(iocb))
4004 if (iter_is_iovec(to))
4005 ctx->should_dirty = true;
4009 ctx->direct_io = true;
4013 rc = setup_aio_ctx_iter(ctx, to, READ);
4015 kref_put(&ctx->refcount, cifs_aio_ctx_release);
4022 rc = filemap_write_and_wait_range(file->f_inode->i_mapping,
4023 offset, offset + len - 1);
4025 kref_put(&ctx->refcount, cifs_aio_ctx_release);
4030 /* grab a lock here due to read response handlers can access ctx */
4031 mutex_lock(&ctx->aio_mutex);
4033 rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
4035 /* if at least one read request send succeeded, then reset rc */
4036 if (!list_empty(&ctx->list))
4039 mutex_unlock(&ctx->aio_mutex);
4042 kref_put(&ctx->refcount, cifs_aio_ctx_release);
4046 if (!is_sync_kiocb(iocb)) {
4047 kref_put(&ctx->refcount, cifs_aio_ctx_release);
4048 return -EIOCBQUEUED;
4051 rc = wait_for_completion_killable(&ctx->done);
4053 mutex_lock(&ctx->aio_mutex);
4054 ctx->rc = rc = -EINTR;
4055 total_read = ctx->total_len;
4056 mutex_unlock(&ctx->aio_mutex);
4059 total_read = ctx->total_len;
4062 kref_put(&ctx->refcount, cifs_aio_ctx_release);
4065 iocb->ki_pos += total_read;
4071 ssize_t cifs_direct_readv(struct kiocb *iocb, struct iov_iter *to)
4073 return __cifs_readv(iocb, to, true);
4076 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
4078 return __cifs_readv(iocb, to, false);
4082 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
4084 struct inode *inode = file_inode(iocb->ki_filp);
4085 struct cifsInodeInfo *cinode = CIFS_I(inode);
4086 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
4087 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
4088 iocb->ki_filp->private_data;
4089 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4093 * In strict cache mode we need to read from the server all the time
4094 * if we don't have level II oplock because the server can delay mtime
4095 * change - so we can't make a decision about inode invalidating.
4096 * And we can also fail with pagereading if there are mandatory locks
4097 * on pages affected by this read but not on the region from pos to
4100 if (!CIFS_CACHE_READ(cinode))
4101 return cifs_user_readv(iocb, to);
4103 if (cap_unix(tcon->ses) &&
4104 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
4105 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
4106 return generic_file_read_iter(iocb, to);
4109 * We need to hold the sem to be sure nobody modifies lock list
4110 * with a brlock that prevents reading.
4112 down_read(&cinode->lock_sem);
4113 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
4114 tcon->ses->server->vals->shared_lock_type,
4115 0, NULL, CIFS_READ_OP))
4116 rc = generic_file_read_iter(iocb, to);
4117 up_read(&cinode->lock_sem);
4122 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
4125 unsigned int bytes_read = 0;
4126 unsigned int total_read;
4127 unsigned int current_read_size;
4129 struct cifs_sb_info *cifs_sb;
4130 struct cifs_tcon *tcon;
4131 struct TCP_Server_Info *server;
4134 struct cifsFileInfo *open_file;
4135 struct cifs_io_parms io_parms = {0};
4136 int buf_type = CIFS_NO_BUFFER;
4140 cifs_sb = CIFS_FILE_SB(file);
4142 /* FIXME: set up handlers for larger reads and/or convert to async */
4143 rsize = min_t(unsigned int, cifs_sb->ctx->rsize, CIFSMaxBufSize);
4145 if (file->private_data == NULL) {
4150 open_file = file->private_data;
4151 tcon = tlink_tcon(open_file->tlink);
4152 server = cifs_pick_channel(tcon->ses);
4154 if (!server->ops->sync_read) {
4159 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4160 pid = open_file->pid;
4162 pid = current->tgid;
4164 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
4165 cifs_dbg(FYI, "attempting read on write only file instance\n");
4167 for (total_read = 0, cur_offset = read_data; read_size > total_read;
4168 total_read += bytes_read, cur_offset += bytes_read) {
4170 current_read_size = min_t(uint, read_size - total_read,
4173 * For windows me and 9x we do not want to request more
4174 * than it negotiated since it will refuse the read
4177 if (!(tcon->ses->capabilities &
4178 tcon->ses->server->vals->cap_large_files)) {
4179 current_read_size = min_t(uint,
4180 current_read_size, CIFSMaxBufSize);
4182 if (open_file->invalidHandle) {
4183 rc = cifs_reopen_file(open_file, true);
4188 io_parms.tcon = tcon;
4189 io_parms.offset = *offset;
4190 io_parms.length = current_read_size;
4191 io_parms.server = server;
4192 rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
4193 &bytes_read, &cur_offset,
4195 } while (rc == -EAGAIN);
4197 if (rc || (bytes_read == 0)) {
4205 cifs_stats_bytes_read(tcon, total_read);
4206 *offset += bytes_read;
4214 * If the page is mmap'ed into a process' page tables, then we need to make
4215 * sure that it doesn't change while being written back.
4218 cifs_page_mkwrite(struct vm_fault *vmf)
4220 struct page *page = vmf->page;
4221 struct file *file = vmf->vma->vm_file;
4222 struct inode *inode = file_inode(file);
4224 cifs_fscache_wait_on_page_write(inode, page);
4227 return VM_FAULT_LOCKED;
4230 static const struct vm_operations_struct cifs_file_vm_ops = {
4231 .fault = filemap_fault,
4232 .map_pages = filemap_map_pages,
4233 .page_mkwrite = cifs_page_mkwrite,
4236 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
4239 struct inode *inode = file_inode(file);
4243 if (!CIFS_CACHE_READ(CIFS_I(inode)))
4244 rc = cifs_zap_mapping(inode);
4246 rc = generic_file_mmap(file, vma);
4248 vma->vm_ops = &cifs_file_vm_ops;
4254 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
4260 rc = cifs_revalidate_file(file);
4262 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
4265 rc = generic_file_mmap(file, vma);
4267 vma->vm_ops = &cifs_file_vm_ops;
4274 cifs_readv_complete(struct work_struct *work)
4276 unsigned int i, got_bytes;
4277 struct cifs_readdata *rdata = container_of(work,
4278 struct cifs_readdata, work);
4280 got_bytes = rdata->got_bytes;
4281 for (i = 0; i < rdata->nr_pages; i++) {
4282 struct page *page = rdata->pages[i];
4284 lru_cache_add(page);
4286 if (rdata->result == 0 ||
4287 (rdata->result == -EAGAIN && got_bytes)) {
4288 flush_dcache_page(page);
4289 SetPageUptodate(page);
4295 if (rdata->result == 0 ||
4296 (rdata->result == -EAGAIN && got_bytes))
4297 cifs_readpage_to_fscache(rdata->mapping->host, page);
4299 cifs_fscache_uncache_page(rdata->mapping->host, page);
4301 got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
4304 rdata->pages[i] = NULL;
4306 kref_put(&rdata->refcount, cifs_readdata_release);
4310 readpages_fill_pages(struct TCP_Server_Info *server,
4311 struct cifs_readdata *rdata, struct iov_iter *iter,
4318 unsigned int nr_pages = rdata->nr_pages;
4319 unsigned int page_offset = rdata->page_offset;
4321 /* determine the eof that the server (probably) has */
4322 eof = CIFS_I(rdata->mapping->host)->server_eof;
4323 eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
4324 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
4326 rdata->got_bytes = 0;
4327 rdata->tailsz = PAGE_SIZE;
4328 for (i = 0; i < nr_pages; i++) {
4329 struct page *page = rdata->pages[i];
4330 unsigned int to_read = rdata->pagesz;
4334 to_read -= page_offset;
4340 if (len >= to_read) {
4342 } else if (len > 0) {
4343 /* enough for partial page, fill and zero the rest */
4344 zero_user(page, len + page_offset, to_read - len);
4345 n = rdata->tailsz = len;
4347 } else if (page->index > eof_index) {
4349 * The VFS will not try to do readahead past the
4350 * i_size, but it's possible that we have outstanding
4351 * writes with gaps in the middle and the i_size hasn't
4352 * caught up yet. Populate those with zeroed out pages
4353 * to prevent the VFS from repeatedly attempting to
4354 * fill them until the writes are flushed.
4356 zero_user(page, 0, PAGE_SIZE);
4357 lru_cache_add(page);
4358 flush_dcache_page(page);
4359 SetPageUptodate(page);
4362 rdata->pages[i] = NULL;
4366 /* no need to hold page hostage */
4367 lru_cache_add(page);
4370 rdata->pages[i] = NULL;
4376 result = copy_page_from_iter(
4377 page, page_offset, n, iter);
4378 #ifdef CONFIG_CIFS_SMB_DIRECT
4383 result = cifs_read_page_from_socket(
4384 server, page, page_offset, n);
4388 rdata->got_bytes += result;
4391 return result != -ECONNABORTED && rdata->got_bytes > 0 ?
4392 rdata->got_bytes : result;
4396 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
4397 struct cifs_readdata *rdata, unsigned int len)
4399 return readpages_fill_pages(server, rdata, NULL, len);
4403 cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
4404 struct cifs_readdata *rdata,
4405 struct iov_iter *iter)
4407 return readpages_fill_pages(server, rdata, iter, iter->count);
4411 readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
4412 unsigned int rsize, struct list_head *tmplist,
4413 unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
4415 struct page *page, *tpage;
4416 unsigned int expected_index;
4418 gfp_t gfp = readahead_gfp_mask(mapping);
4420 INIT_LIST_HEAD(tmplist);
4422 page = lru_to_page(page_list);
4425 * Lock the page and put it in the cache. Since no one else
4426 * should have access to this page, we're safe to simply set
4427 * PG_locked without checking it first.
4429 __SetPageLocked(page);
4430 rc = add_to_page_cache_locked(page, mapping,
4433 /* give up if we can't stick it in the cache */
4435 __ClearPageLocked(page);
4439 /* move first page to the tmplist */
4440 *offset = (loff_t)page->index << PAGE_SHIFT;
4443 list_move_tail(&page->lru, tmplist);
4445 /* now try and add more pages onto the request */
4446 expected_index = page->index + 1;
4447 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
4448 /* discontinuity ? */
4449 if (page->index != expected_index)
4452 /* would this page push the read over the rsize? */
4453 if (*bytes + PAGE_SIZE > rsize)
4456 __SetPageLocked(page);
4457 rc = add_to_page_cache_locked(page, mapping, page->index, gfp);
4459 __ClearPageLocked(page);
4462 list_move_tail(&page->lru, tmplist);
4463 (*bytes) += PAGE_SIZE;
4470 static int cifs_readpages(struct file *file, struct address_space *mapping,
4471 struct list_head *page_list, unsigned num_pages)
4475 struct list_head tmplist;
4476 struct cifsFileInfo *open_file = file->private_data;
4477 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
4478 struct TCP_Server_Info *server;
4484 * Reads as many pages as possible from fscache. Returns -ENOBUFS
4485 * immediately if the cookie is negative
4487 * After this point, every page in the list might have PG_fscache set,
4488 * so we will need to clean that up off of every page we don't use.
4490 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
4497 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4498 pid = open_file->pid;
4500 pid = current->tgid;
4503 server = cifs_pick_channel(tlink_tcon(open_file->tlink)->ses);
4505 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
4506 __func__, file, mapping, num_pages);
4509 * Start with the page at end of list and move it to private
4510 * list. Do the same with any following pages until we hit
4511 * the rsize limit, hit an index discontinuity, or run out of
4512 * pages. Issue the async read and then start the loop again
4513 * until the list is empty.
4515 * Note that list order is important. The page_list is in
4516 * the order of declining indexes. When we put the pages in
4517 * the rdata->pages, then we want them in increasing order.
4519 while (!list_empty(page_list) && !err) {
4520 unsigned int i, nr_pages, bytes, rsize;
4522 struct page *page, *tpage;
4523 struct cifs_readdata *rdata;
4524 struct cifs_credits credits_on_stack;
4525 struct cifs_credits *credits = &credits_on_stack;
4527 if (open_file->invalidHandle) {
4528 rc = cifs_reopen_file(open_file, true);
4535 if (cifs_sb->ctx->rsize == 0)
4536 cifs_sb->ctx->rsize =
4537 server->ops->negotiate_rsize(tlink_tcon(open_file->tlink),
4540 rc = server->ops->wait_mtu_credits(server, cifs_sb->ctx->rsize,
4546 * Give up immediately if rsize is too small to read an entire
4547 * page. The VFS will fall back to readpage. We should never
4548 * reach this point however since we set ra_pages to 0 when the
4549 * rsize is smaller than a cache page.
4551 if (unlikely(rsize < PAGE_SIZE)) {
4552 add_credits_and_wake_if(server, credits, 0);
4558 err = readpages_get_pages(mapping, page_list, rsize, &tmplist,
4559 &nr_pages, &offset, &bytes);
4561 add_credits_and_wake_if(server, credits, 0);
4565 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4567 /* best to give up if we're out of mem */
4568 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4569 list_del(&page->lru);
4570 lru_cache_add(page);
4575 add_credits_and_wake_if(server, credits, 0);
4579 rdata->cfile = cifsFileInfo_get(open_file);
4580 rdata->server = server;
4581 rdata->mapping = mapping;
4582 rdata->offset = offset;
4583 rdata->bytes = bytes;
4585 rdata->pagesz = PAGE_SIZE;
4586 rdata->tailsz = PAGE_SIZE;
4587 rdata->read_into_pages = cifs_readpages_read_into_pages;
4588 rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4589 rdata->credits = credits_on_stack;
4591 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4592 list_del(&page->lru);
4593 rdata->pages[rdata->nr_pages++] = page;
4596 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4599 if (rdata->cfile->invalidHandle)
4602 rc = server->ops->async_readv(rdata);
4606 add_credits_and_wake_if(server, &rdata->credits, 0);
4607 for (i = 0; i < rdata->nr_pages; i++) {
4608 page = rdata->pages[i];
4609 lru_cache_add(page);
4613 /* Fallback to the readpage in error/reconnect cases */
4614 kref_put(&rdata->refcount, cifs_readdata_release);
4618 kref_put(&rdata->refcount, cifs_readdata_release);
4621 /* Any pages that have been shown to fscache but didn't get added to
4622 * the pagecache must be uncached before they get returned to the
4625 cifs_fscache_readpages_cancel(mapping->host, page_list);
4631 * cifs_readpage_worker must be called with the page pinned
4633 static int cifs_readpage_worker(struct file *file, struct page *page,
4639 /* Is the page cached? */
4640 rc = cifs_readpage_from_fscache(file_inode(file), page);
4644 read_data = kmap(page);
4645 /* for reads over a certain size could initiate async read ahead */
4647 rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
4652 cifs_dbg(FYI, "Bytes read %d\n", rc);
4654 /* we do not want atime to be less than mtime, it broke some apps */
4655 file_inode(file)->i_atime = current_time(file_inode(file));
4656 if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime)))
4657 file_inode(file)->i_atime = file_inode(file)->i_mtime;
4659 file_inode(file)->i_atime = current_time(file_inode(file));
4662 memset(read_data + rc, 0, PAGE_SIZE - rc);
4664 flush_dcache_page(page);
4665 SetPageUptodate(page);
4667 /* send this page to the cache */
4668 cifs_readpage_to_fscache(file_inode(file), page);
4680 static int cifs_readpage(struct file *file, struct page *page)
4682 loff_t offset = page_file_offset(page);
4688 if (file->private_data == NULL) {
4694 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
4695 page, (int)offset, (int)offset);
4697 rc = cifs_readpage_worker(file, page, &offset);
4703 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
4705 struct cifsFileInfo *open_file;
4707 spin_lock(&cifs_inode->open_file_lock);
4708 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4709 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4710 spin_unlock(&cifs_inode->open_file_lock);
4714 spin_unlock(&cifs_inode->open_file_lock);
4718 /* We do not want to update the file size from server for inodes
4719 open for write - to avoid races with writepage extending
4720 the file - in the future we could consider allowing
4721 refreshing the inode only on increases in the file size
4722 but this is tricky to do without racing with writebehind
4723 page caching in the current Linux kernel design */
4724 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
4729 if (is_inode_writable(cifsInode)) {
4730 /* This inode is open for write at least once */
4731 struct cifs_sb_info *cifs_sb;
4733 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
4734 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
4735 /* since no page cache to corrupt on directio
4736 we can change size safely */
4740 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4748 static int cifs_write_begin(struct file *file, struct address_space *mapping,
4749 loff_t pos, unsigned len, unsigned flags,
4750 struct page **pagep, void **fsdata)
4753 pgoff_t index = pos >> PAGE_SHIFT;
4754 loff_t offset = pos & (PAGE_SIZE - 1);
4755 loff_t page_start = pos & PAGE_MASK;
4760 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
4763 page = grab_cache_page_write_begin(mapping, index, flags);
4769 if (PageUptodate(page))
4773 * If we write a full page it will be up to date, no need to read from
4774 * the server. If the write is short, we'll end up doing a sync write
4777 if (len == PAGE_SIZE)
4781 * optimize away the read when we have an oplock, and we're not
4782 * expecting to use any of the data we'd be reading in. That
4783 * is, when the page lies beyond the EOF, or straddles the EOF
4784 * and the write will cover all of the existing data.
4786 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4787 i_size = i_size_read(mapping->host);
4788 if (page_start >= i_size ||
4789 (offset == 0 && (pos + len) >= i_size)) {
4790 zero_user_segments(page, 0, offset,
4794 * PageChecked means that the parts of the page
4795 * to which we're not writing are considered up
4796 * to date. Once the data is copied to the
4797 * page, it can be set uptodate.
4799 SetPageChecked(page);
4804 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4806 * might as well read a page, it is fast enough. If we get
4807 * an error, we don't need to return it. cifs_write_end will
4808 * do a sync write instead since PG_uptodate isn't set.
4810 cifs_readpage_worker(file, page, &page_start);
4815 /* we could try using another file handle if there is one -
4816 but how would we lock it to prevent close of that handle
4817 racing with this read? In any case
4818 this will be written out by write_end so is fine */
4825 static int cifs_release_page(struct page *page, gfp_t gfp)
4827 if (PagePrivate(page))
4830 return cifs_fscache_release_page(page, gfp);
4833 static void cifs_invalidate_page(struct page *page, unsigned int offset,
4834 unsigned int length)
4836 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
4838 if (offset == 0 && length == PAGE_SIZE)
4839 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
4842 static int cifs_launder_page(struct page *page)
4845 loff_t range_start = page_offset(page);
4846 loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4847 struct writeback_control wbc = {
4848 .sync_mode = WB_SYNC_ALL,
4850 .range_start = range_start,
4851 .range_end = range_end,
4854 cifs_dbg(FYI, "Launder page: %p\n", page);
4856 if (clear_page_dirty_for_io(page))
4857 rc = cifs_writepage_locked(page, &wbc);
4859 cifs_fscache_invalidate_page(page, page->mapping->host);
4863 void cifs_oplock_break(struct work_struct *work)
4865 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
4867 struct inode *inode = d_inode(cfile->dentry);
4868 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
4869 struct cifsInodeInfo *cinode = CIFS_I(inode);
4870 struct cifs_tcon *tcon;
4871 struct TCP_Server_Info *server;
4872 struct tcon_link *tlink;
4874 bool purge_cache = false, oplock_break_cancelled;
4875 __u64 persistent_fid, volatile_fid;
4878 wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4879 TASK_UNINTERRUPTIBLE);
4881 tlink = cifs_sb_tlink(cifs_sb);
4884 tcon = tlink_tcon(tlink);
4885 server = tcon->ses->server;
4887 server->ops->downgrade_oplock(server, cinode, cfile->oplock_level,
4888 cfile->oplock_epoch, &purge_cache);
4890 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4891 cifs_has_mand_locks(cinode)) {
4892 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4897 if (inode && S_ISREG(inode->i_mode)) {
4898 if (CIFS_CACHE_READ(cinode))
4899 break_lease(inode, O_RDONLY);
4901 break_lease(inode, O_WRONLY);
4902 rc = filemap_fdatawrite(inode->i_mapping);
4903 if (!CIFS_CACHE_READ(cinode) || purge_cache) {
4904 rc = filemap_fdatawait(inode->i_mapping);
4905 mapping_set_error(inode->i_mapping, rc);
4906 cifs_zap_mapping(inode);
4908 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4909 if (CIFS_CACHE_WRITE(cinode))
4910 goto oplock_break_ack;
4913 rc = cifs_push_locks(cfile);
4915 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4919 * When oplock break is received and there are no active
4920 * file handles but cached, then schedule deferred close immediately.
4921 * So, new open will not use cached handle.
4924 if (!CIFS_CACHE_HANDLE(cinode) && !list_empty(&cinode->deferred_closes))
4925 cifs_close_deferred_file(cinode);
4927 persistent_fid = cfile->fid.persistent_fid;
4928 volatile_fid = cfile->fid.volatile_fid;
4929 net_fid = cfile->fid.netfid;
4930 oplock_break_cancelled = cfile->oplock_break_cancelled;
4932 _cifsFileInfo_put(cfile, false /* do not wait for ourself */, false);
4934 * MS-SMB2 3.2.5.19.1 and 3.2.5.19.2 (and MS-CIFS 3.2.5.42) do not require
4935 * an acknowledgment to be sent when the file has already been closed.
4937 spin_lock(&cinode->open_file_lock);
4938 /* check list empty since can race with kill_sb calling tree disconnect */
4939 if (!oplock_break_cancelled && !list_empty(&cinode->openFileList)) {
4940 spin_unlock(&cinode->open_file_lock);
4941 rc = server->ops->oplock_response(tcon, persistent_fid,
4942 volatile_fid, net_fid, cinode);
4943 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4945 spin_unlock(&cinode->open_file_lock);
4947 cifs_put_tlink(tlink);
4949 cifs_done_oplock_break(cinode);
4953 * The presence of cifs_direct_io() in the address space ops vector
4954 * allowes open() O_DIRECT flags which would have failed otherwise.
4956 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4957 * so this method should never be called.
4959 * Direct IO is not yet supported in the cached mode.
4962 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4966 * Eventually need to support direct IO for non forcedirectio mounts
4971 static int cifs_swap_activate(struct swap_info_struct *sis,
4972 struct file *swap_file, sector_t *span)
4974 struct cifsFileInfo *cfile = swap_file->private_data;
4975 struct inode *inode = swap_file->f_mapping->host;
4976 unsigned long blocks;
4979 cifs_dbg(FYI, "swap activate\n");
4981 spin_lock(&inode->i_lock);
4982 blocks = inode->i_blocks;
4983 isize = inode->i_size;
4984 spin_unlock(&inode->i_lock);
4985 if (blocks*512 < isize) {
4986 pr_warn("swap activate: swapfile has holes\n");
4991 pr_warn_once("Swap support over SMB3 is experimental\n");
4994 * TODO: consider adding ACL (or documenting how) to prevent other
4995 * users (on this or other systems) from reading it
4999 /* TODO: add sk_set_memalloc(inet) or similar */
5002 cfile->swapfile = true;
5004 * TODO: Since file already open, we can't open with DENY_ALL here
5005 * but we could add call to grab a byte range lock to prevent others
5006 * from reading or writing the file
5012 static void cifs_swap_deactivate(struct file *file)
5014 struct cifsFileInfo *cfile = file->private_data;
5016 cifs_dbg(FYI, "swap deactivate\n");
5018 /* TODO: undo sk_set_memalloc(inet) will eventually be needed */
5021 cfile->swapfile = false;
5023 /* do we need to unpin (or unlock) the file */
5026 const struct address_space_operations cifs_addr_ops = {
5027 .readpage = cifs_readpage,
5028 .readpages = cifs_readpages,
5029 .writepage = cifs_writepage,
5030 .writepages = cifs_writepages,
5031 .write_begin = cifs_write_begin,
5032 .write_end = cifs_write_end,
5033 .set_page_dirty = __set_page_dirty_nobuffers,
5034 .releasepage = cifs_release_page,
5035 .direct_IO = cifs_direct_io,
5036 .invalidatepage = cifs_invalidate_page,
5037 .launder_page = cifs_launder_page,
5039 * TODO: investigate and if useful we could add an cifs_migratePage
5040 * helper (under an CONFIG_MIGRATION) in the future, and also
5041 * investigate and add an is_dirty_writeback helper if needed
5043 .swap_activate = cifs_swap_activate,
5044 .swap_deactivate = cifs_swap_deactivate,
5048 * cifs_readpages requires the server to support a buffer large enough to
5049 * contain the header plus one complete page of data. Otherwise, we need
5050 * to leave cifs_readpages out of the address space operations.
5052 const struct address_space_operations cifs_addr_ops_smallbuf = {
5053 .readpage = cifs_readpage,
5054 .writepage = cifs_writepage,
5055 .writepages = cifs_writepages,
5056 .write_begin = cifs_write_begin,
5057 .write_end = cifs_write_end,
5058 .set_page_dirty = __set_page_dirty_nobuffers,
5059 .releasepage = cifs_release_page,
5060 .invalidatepage = cifs_invalidate_page,
5061 .launder_page = cifs_launder_page,