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)
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/writeback.h>
31 #include <linux/task_io_accounting_ops.h>
32 #include <linux/delay.h>
33 #include <linux/mount.h>
34 #include <linux/slab.h>
35 #include <linux/swap.h>
37 #include <asm/div64.h>
41 #include "cifsproto.h"
42 #include "cifs_unicode.h"
43 #include "cifs_debug.h"
44 #include "cifs_fs_sb.h"
46 #include "smbdirect.h"
48 static inline int cifs_convert_flags(unsigned int flags)
50 if ((flags & O_ACCMODE) == O_RDONLY)
52 else if ((flags & O_ACCMODE) == O_WRONLY)
54 else if ((flags & O_ACCMODE) == O_RDWR) {
55 /* GENERIC_ALL is too much permission to request
56 can cause unnecessary access denied on create */
57 /* return GENERIC_ALL; */
58 return (GENERIC_READ | GENERIC_WRITE);
61 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
62 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
66 static u32 cifs_posix_convert_flags(unsigned int flags)
70 if ((flags & O_ACCMODE) == O_RDONLY)
71 posix_flags = SMB_O_RDONLY;
72 else if ((flags & O_ACCMODE) == O_WRONLY)
73 posix_flags = SMB_O_WRONLY;
74 else if ((flags & O_ACCMODE) == O_RDWR)
75 posix_flags = SMB_O_RDWR;
77 if (flags & O_CREAT) {
78 posix_flags |= SMB_O_CREAT;
80 posix_flags |= SMB_O_EXCL;
81 } else if (flags & O_EXCL)
82 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
83 current->comm, current->tgid);
86 posix_flags |= SMB_O_TRUNC;
87 /* be safe and imply O_SYNC for O_DSYNC */
89 posix_flags |= SMB_O_SYNC;
90 if (flags & O_DIRECTORY)
91 posix_flags |= SMB_O_DIRECTORY;
92 if (flags & O_NOFOLLOW)
93 posix_flags |= SMB_O_NOFOLLOW;
95 posix_flags |= SMB_O_DIRECT;
100 static inline int cifs_get_disposition(unsigned int flags)
102 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
104 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
105 return FILE_OVERWRITE_IF;
106 else if ((flags & O_CREAT) == O_CREAT)
108 else if ((flags & O_TRUNC) == O_TRUNC)
109 return FILE_OVERWRITE;
114 int cifs_posix_open(char *full_path, struct inode **pinode,
115 struct super_block *sb, int mode, unsigned int f_flags,
116 __u32 *poplock, __u16 *pnetfid, unsigned int xid)
119 FILE_UNIX_BASIC_INFO *presp_data;
120 __u32 posix_flags = 0;
121 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
122 struct cifs_fattr fattr;
123 struct tcon_link *tlink;
124 struct cifs_tcon *tcon;
126 cifs_dbg(FYI, "posix open %s\n", full_path);
128 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
129 if (presp_data == NULL)
132 tlink = cifs_sb_tlink(cifs_sb);
138 tcon = tlink_tcon(tlink);
139 mode &= ~current_umask();
141 posix_flags = cifs_posix_convert_flags(f_flags);
142 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
143 poplock, full_path, cifs_sb->local_nls,
144 cifs_remap(cifs_sb));
145 cifs_put_tlink(tlink);
150 if (presp_data->Type == cpu_to_le32(-1))
151 goto posix_open_ret; /* open ok, caller does qpathinfo */
154 goto posix_open_ret; /* caller does not need info */
156 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
158 /* get new inode and set it up */
159 if (*pinode == NULL) {
160 cifs_fill_uniqueid(sb, &fattr);
161 *pinode = cifs_iget(sb, &fattr);
167 cifs_fattr_to_inode(*pinode, &fattr);
176 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
177 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
178 struct cifs_fid *fid, unsigned int xid)
183 int create_options = CREATE_NOT_DIR;
185 struct TCP_Server_Info *server = tcon->ses->server;
186 struct cifs_open_parms oparms;
188 if (!server->ops->open)
191 desired_access = cifs_convert_flags(f_flags);
193 /*********************************************************************
194 * open flag mapping table:
196 * POSIX Flag CIFS Disposition
197 * ---------- ----------------
198 * O_CREAT FILE_OPEN_IF
199 * O_CREAT | O_EXCL FILE_CREATE
200 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
201 * O_TRUNC FILE_OVERWRITE
202 * none of the above FILE_OPEN
204 * Note that there is not a direct match between disposition
205 * FILE_SUPERSEDE (ie create whether or not file exists although
206 * O_CREAT | O_TRUNC is similar but truncates the existing
207 * file rather than creating a new file as FILE_SUPERSEDE does
208 * (which uses the attributes / metadata passed in on open call)
210 *? O_SYNC is a reasonable match to CIFS writethrough flag
211 *? and the read write flags match reasonably. O_LARGEFILE
212 *? is irrelevant because largefile support is always used
213 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
214 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
215 *********************************************************************/
217 disposition = cifs_get_disposition(f_flags);
219 /* BB pass O_SYNC flag through on file attributes .. BB */
221 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
225 if (backup_cred(cifs_sb))
226 create_options |= CREATE_OPEN_BACKUP_INTENT;
228 /* O_SYNC also has bit for O_DSYNC so following check picks up either */
229 if (f_flags & O_SYNC)
230 create_options |= CREATE_WRITE_THROUGH;
232 if (f_flags & O_DIRECT)
233 create_options |= CREATE_NO_BUFFER;
236 oparms.cifs_sb = cifs_sb;
237 oparms.desired_access = desired_access;
238 oparms.create_options = create_options;
239 oparms.disposition = disposition;
240 oparms.path = full_path;
242 oparms.reconnect = false;
244 rc = server->ops->open(xid, &oparms, oplock, buf);
250 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
253 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
262 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
264 struct cifs_fid_locks *cur;
265 bool has_locks = false;
267 down_read(&cinode->lock_sem);
268 list_for_each_entry(cur, &cinode->llist, llist) {
269 if (!list_empty(&cur->locks)) {
274 up_read(&cinode->lock_sem);
278 struct cifsFileInfo *
279 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
280 struct tcon_link *tlink, __u32 oplock)
282 struct dentry *dentry = file_dentry(file);
283 struct inode *inode = d_inode(dentry);
284 struct cifsInodeInfo *cinode = CIFS_I(inode);
285 struct cifsFileInfo *cfile;
286 struct cifs_fid_locks *fdlocks;
287 struct cifs_tcon *tcon = tlink_tcon(tlink);
288 struct TCP_Server_Info *server = tcon->ses->server;
290 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
294 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
300 INIT_LIST_HEAD(&fdlocks->locks);
301 fdlocks->cfile = cfile;
302 cfile->llist = fdlocks;
303 down_write(&cinode->lock_sem);
304 list_add(&fdlocks->llist, &cinode->llist);
305 up_write(&cinode->lock_sem);
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->tlink = cifs_get_tlink(tlink);
314 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
315 mutex_init(&cfile->fh_mutex);
316 spin_lock_init(&cfile->file_info_lock);
318 cifs_sb_active(inode->i_sb);
321 * If the server returned a read oplock and we have mandatory brlocks,
322 * set oplock level to None.
324 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
325 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
329 spin_lock(&tcon->open_file_lock);
330 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
331 oplock = fid->pending_open->oplock;
332 list_del(&fid->pending_open->olist);
334 fid->purge_cache = false;
335 server->ops->set_fid(cfile, fid, oplock);
337 list_add(&cfile->tlist, &tcon->openFileList);
338 atomic_inc(&tcon->num_local_opens);
340 /* if readable file instance put first in list*/
341 if (file->f_mode & FMODE_READ)
342 list_add(&cfile->flist, &cinode->openFileList);
344 list_add_tail(&cfile->flist, &cinode->openFileList);
345 spin_unlock(&tcon->open_file_lock);
347 if (fid->purge_cache)
348 cifs_zap_mapping(inode);
350 file->private_data = cfile;
354 struct cifsFileInfo *
355 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
357 spin_lock(&cifs_file->file_info_lock);
358 cifsFileInfo_get_locked(cifs_file);
359 spin_unlock(&cifs_file->file_info_lock);
364 * cifsFileInfo_put - release a reference of file priv data
366 * Always potentially wait for oplock handler. See _cifsFileInfo_put().
368 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
370 _cifsFileInfo_put(cifs_file, true);
374 * _cifsFileInfo_put - release a reference of file priv data
376 * This may involve closing the filehandle @cifs_file out on the
377 * server. Must be called without holding tcon->open_file_lock and
378 * cifs_file->file_info_lock.
380 * If @wait_for_oplock_handler is true and we are releasing the last
381 * reference, wait for any running oplock break handler of the file
382 * and cancel any pending one. If calling this function from the
383 * oplock break handler, you need to pass false.
386 void _cifsFileInfo_put(struct cifsFileInfo *cifs_file, bool wait_oplock_handler)
388 struct inode *inode = d_inode(cifs_file->dentry);
389 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
390 struct TCP_Server_Info *server = tcon->ses->server;
391 struct cifsInodeInfo *cifsi = CIFS_I(inode);
392 struct super_block *sb = inode->i_sb;
393 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
394 struct cifsLockInfo *li, *tmp;
396 struct cifs_pending_open open;
397 bool oplock_break_cancelled;
399 spin_lock(&tcon->open_file_lock);
401 spin_lock(&cifs_file->file_info_lock);
402 if (--cifs_file->count > 0) {
403 spin_unlock(&cifs_file->file_info_lock);
404 spin_unlock(&tcon->open_file_lock);
407 spin_unlock(&cifs_file->file_info_lock);
409 if (server->ops->get_lease_key)
410 server->ops->get_lease_key(inode, &fid);
412 /* store open in pending opens to make sure we don't miss lease break */
413 cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
415 /* remove it from the lists */
416 list_del(&cifs_file->flist);
417 list_del(&cifs_file->tlist);
418 atomic_dec(&tcon->num_local_opens);
420 if (list_empty(&cifsi->openFileList)) {
421 cifs_dbg(FYI, "closing last open instance for inode %p\n",
422 d_inode(cifs_file->dentry));
424 * In strict cache mode we need invalidate mapping on the last
425 * close because it may cause a error when we open this file
426 * again and get at least level II oplock.
428 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
429 set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
430 cifs_set_oplock_level(cifsi, 0);
433 spin_unlock(&tcon->open_file_lock);
435 oplock_break_cancelled = wait_oplock_handler ?
436 cancel_work_sync(&cifs_file->oplock_break) : false;
438 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
439 struct TCP_Server_Info *server = tcon->ses->server;
443 if (server->ops->close)
444 server->ops->close(xid, tcon, &cifs_file->fid);
448 if (oplock_break_cancelled)
449 cifs_done_oplock_break(cifsi);
451 cifs_del_pending_open(&open);
454 * Delete any outstanding lock records. We'll lose them when the file
457 down_write(&cifsi->lock_sem);
458 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
459 list_del(&li->llist);
460 cifs_del_lock_waiters(li);
463 list_del(&cifs_file->llist->llist);
464 kfree(cifs_file->llist);
465 up_write(&cifsi->lock_sem);
467 cifs_put_tlink(cifs_file->tlink);
468 dput(cifs_file->dentry);
469 cifs_sb_deactive(sb);
473 int cifs_open(struct inode *inode, struct file *file)
479 struct cifs_sb_info *cifs_sb;
480 struct TCP_Server_Info *server;
481 struct cifs_tcon *tcon;
482 struct tcon_link *tlink;
483 struct cifsFileInfo *cfile = NULL;
484 char *full_path = NULL;
485 bool posix_open_ok = false;
487 struct cifs_pending_open open;
491 cifs_sb = CIFS_SB(inode->i_sb);
492 tlink = cifs_sb_tlink(cifs_sb);
495 return PTR_ERR(tlink);
497 tcon = tlink_tcon(tlink);
498 server = tcon->ses->server;
500 full_path = build_path_from_dentry(file_dentry(file));
501 if (full_path == NULL) {
506 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
507 inode, file->f_flags, full_path);
509 if (file->f_flags & O_DIRECT &&
510 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
511 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
512 file->f_op = &cifs_file_direct_nobrl_ops;
514 file->f_op = &cifs_file_direct_ops;
522 if (!tcon->broken_posix_open && tcon->unix_ext &&
523 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
524 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
525 /* can not refresh inode info since size could be stale */
526 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
527 cifs_sb->mnt_file_mode /* ignored */,
528 file->f_flags, &oplock, &fid.netfid, xid);
530 cifs_dbg(FYI, "posix open succeeded\n");
531 posix_open_ok = true;
532 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
533 if (tcon->ses->serverNOS)
534 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",
535 tcon->ses->serverName,
536 tcon->ses->serverNOS);
537 tcon->broken_posix_open = true;
538 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
539 (rc != -EOPNOTSUPP)) /* path not found or net err */
542 * Else fallthrough to retry open the old way on network i/o
547 if (server->ops->get_lease_key)
548 server->ops->get_lease_key(inode, &fid);
550 cifs_add_pending_open(&fid, tlink, &open);
552 if (!posix_open_ok) {
553 if (server->ops->get_lease_key)
554 server->ops->get_lease_key(inode, &fid);
556 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
557 file->f_flags, &oplock, &fid, xid);
559 cifs_del_pending_open(&open);
564 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
566 if (server->ops->close)
567 server->ops->close(xid, tcon, &fid);
568 cifs_del_pending_open(&open);
573 cifs_fscache_set_inode_cookie(inode, file);
575 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
577 * Time to set mode which we can not set earlier due to
578 * problems creating new read-only files.
580 struct cifs_unix_set_info_args args = {
581 .mode = inode->i_mode,
582 .uid = INVALID_UID, /* no change */
583 .gid = INVALID_GID, /* no change */
584 .ctime = NO_CHANGE_64,
585 .atime = NO_CHANGE_64,
586 .mtime = NO_CHANGE_64,
589 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
596 cifs_put_tlink(tlink);
600 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
603 * Try to reacquire byte range locks that were released when session
604 * to server was lost.
607 cifs_relock_file(struct cifsFileInfo *cfile)
609 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
610 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
611 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
614 down_read_nested(&cinode->lock_sem, SINGLE_DEPTH_NESTING);
615 if (cinode->can_cache_brlcks) {
616 /* can cache locks - no need to relock */
617 up_read(&cinode->lock_sem);
621 if (cap_unix(tcon->ses) &&
622 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
623 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
624 rc = cifs_push_posix_locks(cfile);
626 rc = tcon->ses->server->ops->push_mand_locks(cfile);
628 up_read(&cinode->lock_sem);
633 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
638 struct cifs_sb_info *cifs_sb;
639 struct cifs_tcon *tcon;
640 struct TCP_Server_Info *server;
641 struct cifsInodeInfo *cinode;
643 char *full_path = NULL;
645 int disposition = FILE_OPEN;
646 int create_options = CREATE_NOT_DIR;
647 struct cifs_open_parms oparms;
650 mutex_lock(&cfile->fh_mutex);
651 if (!cfile->invalidHandle) {
652 mutex_unlock(&cfile->fh_mutex);
658 inode = d_inode(cfile->dentry);
659 cifs_sb = CIFS_SB(inode->i_sb);
660 tcon = tlink_tcon(cfile->tlink);
661 server = tcon->ses->server;
664 * Can not grab rename sem here because various ops, including those
665 * that already have the rename sem can end up causing writepage to get
666 * called and if the server was down that means we end up here, and we
667 * can never tell if the caller already has the rename_sem.
669 full_path = build_path_from_dentry(cfile->dentry);
670 if (full_path == NULL) {
672 mutex_unlock(&cfile->fh_mutex);
677 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
678 inode, cfile->f_flags, full_path);
680 if (tcon->ses->server->oplocks)
685 if (tcon->unix_ext && cap_unix(tcon->ses) &&
686 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
687 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
689 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
690 * original open. Must mask them off for a reopen.
692 unsigned int oflags = cfile->f_flags &
693 ~(O_CREAT | O_EXCL | O_TRUNC);
695 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
696 cifs_sb->mnt_file_mode /* ignored */,
697 oflags, &oplock, &cfile->fid.netfid, xid);
699 cifs_dbg(FYI, "posix reopen succeeded\n");
700 oparms.reconnect = true;
704 * fallthrough to retry open the old way on errors, especially
705 * in the reconnect path it is important to retry hard
709 desired_access = cifs_convert_flags(cfile->f_flags);
711 if (backup_cred(cifs_sb))
712 create_options |= CREATE_OPEN_BACKUP_INTENT;
714 if (server->ops->get_lease_key)
715 server->ops->get_lease_key(inode, &cfile->fid);
718 oparms.cifs_sb = cifs_sb;
719 oparms.desired_access = desired_access;
720 oparms.create_options = create_options;
721 oparms.disposition = disposition;
722 oparms.path = full_path;
723 oparms.fid = &cfile->fid;
724 oparms.reconnect = true;
727 * Can not refresh inode by passing in file_info buf to be returned by
728 * ops->open and then calling get_inode_info with returned buf since
729 * file might have write behind data that needs to be flushed and server
730 * version of file size can be stale. If we knew for sure that inode was
731 * not dirty locally we could do this.
733 rc = server->ops->open(xid, &oparms, &oplock, NULL);
734 if (rc == -ENOENT && oparms.reconnect == false) {
735 /* durable handle timeout is expired - open the file again */
736 rc = server->ops->open(xid, &oparms, &oplock, NULL);
737 /* indicate that we need to relock the file */
738 oparms.reconnect = true;
742 mutex_unlock(&cfile->fh_mutex);
743 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
744 cifs_dbg(FYI, "oplock: %d\n", oplock);
745 goto reopen_error_exit;
749 cfile->invalidHandle = false;
750 mutex_unlock(&cfile->fh_mutex);
751 cinode = CIFS_I(inode);
754 rc = filemap_write_and_wait(inode->i_mapping);
755 if (!is_interrupt_error(rc))
756 mapping_set_error(inode->i_mapping, rc);
759 rc = cifs_get_inode_info_unix(&inode, full_path,
762 rc = cifs_get_inode_info(&inode, full_path, NULL,
763 inode->i_sb, xid, NULL);
766 * Else we are writing out data to server already and could deadlock if
767 * we tried to flush data, and since we do not know if we have data that
768 * would invalidate the current end of file on the server we can not go
769 * to the server to get the new inode info.
773 * If the server returned a read oplock and we have mandatory brlocks,
774 * set oplock level to None.
776 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
777 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
781 server->ops->set_fid(cfile, &cfile->fid, oplock);
782 if (oparms.reconnect)
783 cifs_relock_file(cfile);
791 int cifs_close(struct inode *inode, struct file *file)
793 if (file->private_data != NULL) {
794 cifsFileInfo_put(file->private_data);
795 file->private_data = NULL;
798 /* return code from the ->release op is always ignored */
803 cifs_reopen_persistent_handles(struct cifs_tcon *tcon)
805 struct cifsFileInfo *open_file;
806 struct list_head *tmp;
807 struct list_head *tmp1;
808 struct list_head tmp_list;
810 if (!tcon->use_persistent || !tcon->need_reopen_files)
813 tcon->need_reopen_files = false;
815 cifs_dbg(FYI, "Reopen persistent handles");
816 INIT_LIST_HEAD(&tmp_list);
818 /* list all files open on tree connection, reopen resilient handles */
819 spin_lock(&tcon->open_file_lock);
820 list_for_each(tmp, &tcon->openFileList) {
821 open_file = list_entry(tmp, struct cifsFileInfo, tlist);
822 if (!open_file->invalidHandle)
824 cifsFileInfo_get(open_file);
825 list_add_tail(&open_file->rlist, &tmp_list);
827 spin_unlock(&tcon->open_file_lock);
829 list_for_each_safe(tmp, tmp1, &tmp_list) {
830 open_file = list_entry(tmp, struct cifsFileInfo, rlist);
831 if (cifs_reopen_file(open_file, false /* do not flush */))
832 tcon->need_reopen_files = true;
833 list_del_init(&open_file->rlist);
834 cifsFileInfo_put(open_file);
838 int cifs_closedir(struct inode *inode, struct file *file)
842 struct cifsFileInfo *cfile = file->private_data;
843 struct cifs_tcon *tcon;
844 struct TCP_Server_Info *server;
847 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
853 tcon = tlink_tcon(cfile->tlink);
854 server = tcon->ses->server;
856 cifs_dbg(FYI, "Freeing private data in close dir\n");
857 spin_lock(&cfile->file_info_lock);
858 if (server->ops->dir_needs_close(cfile)) {
859 cfile->invalidHandle = true;
860 spin_unlock(&cfile->file_info_lock);
861 if (server->ops->close_dir)
862 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
865 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
866 /* not much we can do if it fails anyway, ignore rc */
869 spin_unlock(&cfile->file_info_lock);
871 buf = cfile->srch_inf.ntwrk_buf_start;
873 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
874 cfile->srch_inf.ntwrk_buf_start = NULL;
875 if (cfile->srch_inf.smallBuf)
876 cifs_small_buf_release(buf);
878 cifs_buf_release(buf);
881 cifs_put_tlink(cfile->tlink);
882 kfree(file->private_data);
883 file->private_data = NULL;
884 /* BB can we lock the filestruct while this is going on? */
889 static struct cifsLockInfo *
890 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 flags)
892 struct cifsLockInfo *lock =
893 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
896 lock->offset = offset;
897 lock->length = length;
899 lock->pid = current->tgid;
901 INIT_LIST_HEAD(&lock->blist);
902 init_waitqueue_head(&lock->block_q);
907 cifs_del_lock_waiters(struct cifsLockInfo *lock)
909 struct cifsLockInfo *li, *tmp;
910 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
911 list_del_init(&li->blist);
912 wake_up(&li->block_q);
916 #define CIFS_LOCK_OP 0
917 #define CIFS_READ_OP 1
918 #define CIFS_WRITE_OP 2
920 /* @rw_check : 0 - no op, 1 - read, 2 - write */
922 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
923 __u64 length, __u8 type, __u16 flags,
924 struct cifsFileInfo *cfile,
925 struct cifsLockInfo **conf_lock, int rw_check)
927 struct cifsLockInfo *li;
928 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
929 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
931 list_for_each_entry(li, &fdlocks->locks, llist) {
932 if (offset + length <= li->offset ||
933 offset >= li->offset + li->length)
935 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
936 server->ops->compare_fids(cfile, cur_cfile)) {
937 /* shared lock prevents write op through the same fid */
938 if (!(li->type & server->vals->shared_lock_type) ||
939 rw_check != CIFS_WRITE_OP)
942 if ((type & server->vals->shared_lock_type) &&
943 ((server->ops->compare_fids(cfile, cur_cfile) &&
944 current->tgid == li->pid) || type == li->type))
946 if (rw_check == CIFS_LOCK_OP &&
947 (flags & FL_OFDLCK) && (li->flags & FL_OFDLCK) &&
948 server->ops->compare_fids(cfile, cur_cfile))
958 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
959 __u8 type, __u16 flags,
960 struct cifsLockInfo **conf_lock, int rw_check)
963 struct cifs_fid_locks *cur;
964 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
966 list_for_each_entry(cur, &cinode->llist, llist) {
967 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
968 flags, cfile, conf_lock,
978 * Check if there is another lock that prevents us to set the lock (mandatory
979 * style). If such a lock exists, update the flock structure with its
980 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
981 * or leave it the same if we can't. Returns 0 if we don't need to request to
982 * the server or 1 otherwise.
985 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
986 __u8 type, struct file_lock *flock)
989 struct cifsLockInfo *conf_lock;
990 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
991 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
994 down_read(&cinode->lock_sem);
996 exist = cifs_find_lock_conflict(cfile, offset, length, type,
997 flock->fl_flags, &conf_lock,
1000 flock->fl_start = conf_lock->offset;
1001 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
1002 flock->fl_pid = conf_lock->pid;
1003 if (conf_lock->type & server->vals->shared_lock_type)
1004 flock->fl_type = F_RDLCK;
1006 flock->fl_type = F_WRLCK;
1007 } else if (!cinode->can_cache_brlcks)
1010 flock->fl_type = F_UNLCK;
1012 up_read(&cinode->lock_sem);
1017 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
1019 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1020 down_write(&cinode->lock_sem);
1021 list_add_tail(&lock->llist, &cfile->llist->locks);
1022 up_write(&cinode->lock_sem);
1026 * Set the byte-range lock (mandatory style). Returns:
1027 * 1) 0, if we set the lock and don't need to request to the server;
1028 * 2) 1, if no locks prevent us but we need to request to the server;
1029 * 3) -EACCES, if there is a lock that prevents us and wait is false.
1032 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
1035 struct cifsLockInfo *conf_lock;
1036 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1042 down_write(&cinode->lock_sem);
1044 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
1045 lock->type, lock->flags, &conf_lock,
1047 if (!exist && cinode->can_cache_brlcks) {
1048 list_add_tail(&lock->llist, &cfile->llist->locks);
1049 up_write(&cinode->lock_sem);
1058 list_add_tail(&lock->blist, &conf_lock->blist);
1059 up_write(&cinode->lock_sem);
1060 rc = wait_event_interruptible(lock->block_q,
1061 (lock->blist.prev == &lock->blist) &&
1062 (lock->blist.next == &lock->blist));
1065 down_write(&cinode->lock_sem);
1066 list_del_init(&lock->blist);
1069 up_write(&cinode->lock_sem);
1074 * Check if there is another lock that prevents us to set the lock (posix
1075 * style). If such a lock exists, update the flock structure with its
1076 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
1077 * or leave it the same if we can't. Returns 0 if we don't need to request to
1078 * the server or 1 otherwise.
1081 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1084 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1085 unsigned char saved_type = flock->fl_type;
1087 if ((flock->fl_flags & FL_POSIX) == 0)
1090 down_read(&cinode->lock_sem);
1091 posix_test_lock(file, flock);
1093 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1094 flock->fl_type = saved_type;
1098 up_read(&cinode->lock_sem);
1103 * Set the byte-range lock (posix style). Returns:
1104 * 1) 0, if we set the lock and don't need to request to the server;
1105 * 2) 1, if we need to request to the server;
1106 * 3) <0, if the error occurs while setting the lock.
1109 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1111 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1114 if ((flock->fl_flags & FL_POSIX) == 0)
1118 down_write(&cinode->lock_sem);
1119 if (!cinode->can_cache_brlcks) {
1120 up_write(&cinode->lock_sem);
1124 rc = posix_lock_file(file, flock, NULL);
1125 up_write(&cinode->lock_sem);
1126 if (rc == FILE_LOCK_DEFERRED) {
1127 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_blocker);
1130 locks_delete_block(flock);
1136 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1139 int rc = 0, stored_rc;
1140 struct cifsLockInfo *li, *tmp;
1141 struct cifs_tcon *tcon;
1142 unsigned int num, max_num, max_buf;
1143 LOCKING_ANDX_RANGE *buf, *cur;
1144 static const int types[] = {
1145 LOCKING_ANDX_LARGE_FILES,
1146 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1151 tcon = tlink_tcon(cfile->tlink);
1154 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1155 * and check it before using.
1157 max_buf = tcon->ses->server->maxBuf;
1158 if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE))) {
1163 BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1165 max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1167 max_num = (max_buf - sizeof(struct smb_hdr)) /
1168 sizeof(LOCKING_ANDX_RANGE);
1169 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1175 for (i = 0; i < 2; i++) {
1178 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1179 if (li->type != types[i])
1181 cur->Pid = cpu_to_le16(li->pid);
1182 cur->LengthLow = cpu_to_le32((u32)li->length);
1183 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1184 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1185 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1186 if (++num == max_num) {
1187 stored_rc = cifs_lockv(xid, tcon,
1189 (__u8)li->type, 0, num,
1200 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1201 (__u8)types[i], 0, num, buf);
1213 hash_lockowner(fl_owner_t owner)
1215 return cifs_lock_secret ^ hash32_ptr((const void *)owner);
1218 struct lock_to_push {
1219 struct list_head llist;
1228 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1230 struct inode *inode = d_inode(cfile->dentry);
1231 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1232 struct file_lock *flock;
1233 struct file_lock_context *flctx = inode->i_flctx;
1234 unsigned int count = 0, i;
1235 int rc = 0, xid, type;
1236 struct list_head locks_to_send, *el;
1237 struct lock_to_push *lck, *tmp;
1245 spin_lock(&flctx->flc_lock);
1246 list_for_each(el, &flctx->flc_posix) {
1249 spin_unlock(&flctx->flc_lock);
1251 INIT_LIST_HEAD(&locks_to_send);
1254 * Allocating count locks is enough because no FL_POSIX locks can be
1255 * added to the list while we are holding cinode->lock_sem that
1256 * protects locking operations of this inode.
1258 for (i = 0; i < count; i++) {
1259 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1264 list_add_tail(&lck->llist, &locks_to_send);
1267 el = locks_to_send.next;
1268 spin_lock(&flctx->flc_lock);
1269 list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1270 if (el == &locks_to_send) {
1272 * The list ended. We don't have enough allocated
1273 * structures - something is really wrong.
1275 cifs_dbg(VFS, "Can't push all brlocks!\n");
1278 length = 1 + flock->fl_end - flock->fl_start;
1279 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1283 lck = list_entry(el, struct lock_to_push, llist);
1284 lck->pid = hash_lockowner(flock->fl_owner);
1285 lck->netfid = cfile->fid.netfid;
1286 lck->length = length;
1288 lck->offset = flock->fl_start;
1290 spin_unlock(&flctx->flc_lock);
1292 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1295 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1296 lck->offset, lck->length, NULL,
1300 list_del(&lck->llist);
1308 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1309 list_del(&lck->llist);
1316 cifs_push_locks(struct cifsFileInfo *cfile)
1318 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1319 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1320 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1323 /* we are going to update can_cache_brlcks here - need a write access */
1324 down_write(&cinode->lock_sem);
1325 if (!cinode->can_cache_brlcks) {
1326 up_write(&cinode->lock_sem);
1330 if (cap_unix(tcon->ses) &&
1331 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1332 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1333 rc = cifs_push_posix_locks(cfile);
1335 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1337 cinode->can_cache_brlcks = false;
1338 up_write(&cinode->lock_sem);
1343 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1344 bool *wait_flag, struct TCP_Server_Info *server)
1346 if (flock->fl_flags & FL_POSIX)
1347 cifs_dbg(FYI, "Posix\n");
1348 if (flock->fl_flags & FL_FLOCK)
1349 cifs_dbg(FYI, "Flock\n");
1350 if (flock->fl_flags & FL_SLEEP) {
1351 cifs_dbg(FYI, "Blocking lock\n");
1354 if (flock->fl_flags & FL_ACCESS)
1355 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1356 if (flock->fl_flags & FL_LEASE)
1357 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1358 if (flock->fl_flags &
1359 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1360 FL_ACCESS | FL_LEASE | FL_CLOSE | FL_OFDLCK)))
1361 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1363 *type = server->vals->large_lock_type;
1364 if (flock->fl_type == F_WRLCK) {
1365 cifs_dbg(FYI, "F_WRLCK\n");
1366 *type |= server->vals->exclusive_lock_type;
1368 } else if (flock->fl_type == F_UNLCK) {
1369 cifs_dbg(FYI, "F_UNLCK\n");
1370 *type |= server->vals->unlock_lock_type;
1372 /* Check if unlock includes more than one lock range */
1373 } else if (flock->fl_type == F_RDLCK) {
1374 cifs_dbg(FYI, "F_RDLCK\n");
1375 *type |= server->vals->shared_lock_type;
1377 } else if (flock->fl_type == F_EXLCK) {
1378 cifs_dbg(FYI, "F_EXLCK\n");
1379 *type |= server->vals->exclusive_lock_type;
1381 } else if (flock->fl_type == F_SHLCK) {
1382 cifs_dbg(FYI, "F_SHLCK\n");
1383 *type |= server->vals->shared_lock_type;
1386 cifs_dbg(FYI, "Unknown type of lock\n");
1390 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1391 bool wait_flag, bool posix_lck, unsigned int xid)
1394 __u64 length = 1 + flock->fl_end - flock->fl_start;
1395 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1396 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1397 struct TCP_Server_Info *server = tcon->ses->server;
1398 __u16 netfid = cfile->fid.netfid;
1401 int posix_lock_type;
1403 rc = cifs_posix_lock_test(file, flock);
1407 if (type & server->vals->shared_lock_type)
1408 posix_lock_type = CIFS_RDLCK;
1410 posix_lock_type = CIFS_WRLCK;
1411 rc = CIFSSMBPosixLock(xid, tcon, netfid,
1412 hash_lockowner(flock->fl_owner),
1413 flock->fl_start, length, flock,
1414 posix_lock_type, wait_flag);
1418 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1422 /* BB we could chain these into one lock request BB */
1423 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1426 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1428 flock->fl_type = F_UNLCK;
1430 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1435 if (type & server->vals->shared_lock_type) {
1436 flock->fl_type = F_WRLCK;
1440 type &= ~server->vals->exclusive_lock_type;
1442 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1443 type | server->vals->shared_lock_type,
1446 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1447 type | server->vals->shared_lock_type, 0, 1, false);
1448 flock->fl_type = F_RDLCK;
1450 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1453 flock->fl_type = F_WRLCK;
1459 cifs_move_llist(struct list_head *source, struct list_head *dest)
1461 struct list_head *li, *tmp;
1462 list_for_each_safe(li, tmp, source)
1463 list_move(li, dest);
1467 cifs_free_llist(struct list_head *llist)
1469 struct cifsLockInfo *li, *tmp;
1470 list_for_each_entry_safe(li, tmp, llist, llist) {
1471 cifs_del_lock_waiters(li);
1472 list_del(&li->llist);
1478 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1481 int rc = 0, stored_rc;
1482 static const int types[] = {
1483 LOCKING_ANDX_LARGE_FILES,
1484 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES
1487 unsigned int max_num, num, max_buf;
1488 LOCKING_ANDX_RANGE *buf, *cur;
1489 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1490 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1491 struct cifsLockInfo *li, *tmp;
1492 __u64 length = 1 + flock->fl_end - flock->fl_start;
1493 struct list_head tmp_llist;
1495 INIT_LIST_HEAD(&tmp_llist);
1498 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1499 * and check it before using.
1501 max_buf = tcon->ses->server->maxBuf;
1502 if (max_buf < (sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE)))
1505 BUILD_BUG_ON(sizeof(struct smb_hdr) + sizeof(LOCKING_ANDX_RANGE) >
1507 max_buf = min_t(unsigned int, max_buf - sizeof(struct smb_hdr),
1509 max_num = (max_buf - sizeof(struct smb_hdr)) /
1510 sizeof(LOCKING_ANDX_RANGE);
1511 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1515 down_write(&cinode->lock_sem);
1516 for (i = 0; i < 2; i++) {
1519 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1520 if (flock->fl_start > li->offset ||
1521 (flock->fl_start + length) <
1522 (li->offset + li->length))
1524 if (current->tgid != li->pid)
1526 if (types[i] != li->type)
1528 if (cinode->can_cache_brlcks) {
1530 * We can cache brlock requests - simply remove
1531 * a lock from the file's list.
1533 list_del(&li->llist);
1534 cifs_del_lock_waiters(li);
1538 cur->Pid = cpu_to_le16(li->pid);
1539 cur->LengthLow = cpu_to_le32((u32)li->length);
1540 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1541 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1542 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1544 * We need to save a lock here to let us add it again to
1545 * the file's list if the unlock range request fails on
1548 list_move(&li->llist, &tmp_llist);
1549 if (++num == max_num) {
1550 stored_rc = cifs_lockv(xid, tcon,
1552 li->type, num, 0, buf);
1555 * We failed on the unlock range
1556 * request - add all locks from the tmp
1557 * list to the head of the file's list.
1559 cifs_move_llist(&tmp_llist,
1560 &cfile->llist->locks);
1564 * The unlock range request succeed -
1565 * free the tmp list.
1567 cifs_free_llist(&tmp_llist);
1574 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1575 types[i], num, 0, buf);
1577 cifs_move_llist(&tmp_llist,
1578 &cfile->llist->locks);
1581 cifs_free_llist(&tmp_llist);
1585 up_write(&cinode->lock_sem);
1591 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1592 bool wait_flag, bool posix_lck, int lock, int unlock,
1596 __u64 length = 1 + flock->fl_end - flock->fl_start;
1597 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1598 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1599 struct TCP_Server_Info *server = tcon->ses->server;
1600 struct inode *inode = d_inode(cfile->dentry);
1603 int posix_lock_type;
1605 rc = cifs_posix_lock_set(file, flock);
1609 if (type & server->vals->shared_lock_type)
1610 posix_lock_type = CIFS_RDLCK;
1612 posix_lock_type = CIFS_WRLCK;
1615 posix_lock_type = CIFS_UNLCK;
1617 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1618 hash_lockowner(flock->fl_owner),
1619 flock->fl_start, length,
1620 NULL, posix_lock_type, wait_flag);
1625 struct cifsLockInfo *lock;
1627 lock = cifs_lock_init(flock->fl_start, length, type,
1632 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1641 * Windows 7 server can delay breaking lease from read to None
1642 * if we set a byte-range lock on a file - break it explicitly
1643 * before sending the lock to the server to be sure the next
1644 * read won't conflict with non-overlapted locks due to
1647 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1648 CIFS_CACHE_READ(CIFS_I(inode))) {
1649 cifs_zap_mapping(inode);
1650 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1652 CIFS_I(inode)->oplock = 0;
1655 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1656 type, 1, 0, wait_flag);
1662 cifs_lock_add(cfile, lock);
1664 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1667 if (flock->fl_flags & FL_POSIX) {
1669 * If this is a request to remove all locks because we
1670 * are closing the file, it doesn't matter if the
1671 * unlocking failed as both cifs.ko and the SMB server
1672 * remove the lock on file close
1675 cifs_dbg(VFS, "%s failed rc=%d\n", __func__, rc);
1676 if (!(flock->fl_flags & FL_CLOSE))
1679 rc = locks_lock_file_wait(file, flock);
1684 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1687 int lock = 0, unlock = 0;
1688 bool wait_flag = false;
1689 bool posix_lck = false;
1690 struct cifs_sb_info *cifs_sb;
1691 struct cifs_tcon *tcon;
1692 struct cifsInodeInfo *cinode;
1693 struct cifsFileInfo *cfile;
1700 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1701 cmd, flock->fl_flags, flock->fl_type,
1702 flock->fl_start, flock->fl_end);
1704 cfile = (struct cifsFileInfo *)file->private_data;
1705 tcon = tlink_tcon(cfile->tlink);
1707 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1709 cifs_sb = CIFS_FILE_SB(file);
1710 netfid = cfile->fid.netfid;
1711 cinode = CIFS_I(file_inode(file));
1713 if (cap_unix(tcon->ses) &&
1714 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1715 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1718 * BB add code here to normalize offset and length to account for
1719 * negative length which we can not accept over the wire.
1721 if (IS_GETLK(cmd)) {
1722 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1727 if (!lock && !unlock) {
1729 * if no lock or unlock then nothing to do since we do not
1736 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1743 * update the file size (if needed) after a write. Should be called with
1744 * the inode->i_lock held
1747 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1748 unsigned int bytes_written)
1750 loff_t end_of_write = offset + bytes_written;
1752 if (end_of_write > cifsi->server_eof)
1753 cifsi->server_eof = end_of_write;
1757 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1758 size_t write_size, loff_t *offset)
1761 unsigned int bytes_written = 0;
1762 unsigned int total_written;
1763 struct cifs_sb_info *cifs_sb;
1764 struct cifs_tcon *tcon;
1765 struct TCP_Server_Info *server;
1767 struct dentry *dentry = open_file->dentry;
1768 struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1769 struct cifs_io_parms io_parms;
1771 cifs_sb = CIFS_SB(dentry->d_sb);
1773 cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1774 write_size, *offset, dentry);
1776 tcon = tlink_tcon(open_file->tlink);
1777 server = tcon->ses->server;
1779 if (!server->ops->sync_write)
1784 for (total_written = 0; write_size > total_written;
1785 total_written += bytes_written) {
1787 while (rc == -EAGAIN) {
1791 if (open_file->invalidHandle) {
1792 /* we could deadlock if we called
1793 filemap_fdatawait from here so tell
1794 reopen_file not to flush data to
1796 rc = cifs_reopen_file(open_file, false);
1801 len = min(server->ops->wp_retry_size(d_inode(dentry)),
1802 (unsigned int)write_size - total_written);
1803 /* iov[0] is reserved for smb header */
1804 iov[1].iov_base = (char *)write_data + total_written;
1805 iov[1].iov_len = len;
1807 io_parms.tcon = tcon;
1808 io_parms.offset = *offset;
1809 io_parms.length = len;
1810 rc = server->ops->sync_write(xid, &open_file->fid,
1811 &io_parms, &bytes_written, iov, 1);
1813 if (rc || (bytes_written == 0)) {
1821 spin_lock(&d_inode(dentry)->i_lock);
1822 cifs_update_eof(cifsi, *offset, bytes_written);
1823 spin_unlock(&d_inode(dentry)->i_lock);
1824 *offset += bytes_written;
1828 cifs_stats_bytes_written(tcon, total_written);
1830 if (total_written > 0) {
1831 spin_lock(&d_inode(dentry)->i_lock);
1832 if (*offset > d_inode(dentry)->i_size)
1833 i_size_write(d_inode(dentry), *offset);
1834 spin_unlock(&d_inode(dentry)->i_lock);
1836 mark_inode_dirty_sync(d_inode(dentry));
1838 return total_written;
1841 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1844 struct cifsFileInfo *open_file = NULL;
1845 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1846 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1848 /* only filter by fsuid on multiuser mounts */
1849 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1852 spin_lock(&tcon->open_file_lock);
1853 /* we could simply get the first_list_entry since write-only entries
1854 are always at the end of the list but since the first entry might
1855 have a close pending, we go through the whole list */
1856 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1857 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1859 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1860 if (!open_file->invalidHandle) {
1861 /* found a good file */
1862 /* lock it so it will not be closed on us */
1863 cifsFileInfo_get(open_file);
1864 spin_unlock(&tcon->open_file_lock);
1866 } /* else might as well continue, and look for
1867 another, or simply have the caller reopen it
1868 again rather than trying to fix this handle */
1869 } else /* write only file */
1870 break; /* write only files are last so must be done */
1872 spin_unlock(&tcon->open_file_lock);
1876 /* Return -EBADF if no handle is found and general rc otherwise */
1878 cifs_get_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only,
1879 struct cifsFileInfo **ret_file)
1881 struct cifsFileInfo *open_file, *inv_file = NULL;
1882 struct cifs_sb_info *cifs_sb;
1883 struct cifs_tcon *tcon;
1884 bool any_available = false;
1886 unsigned int refind = 0;
1891 * Having a null inode here (because mapping->host was set to zero by
1892 * the VFS or MM) should not happen but we had reports of on oops (due
1893 * to it being zero) during stress testcases so we need to check for it
1896 if (cifs_inode == NULL) {
1897 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1902 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1903 tcon = cifs_sb_master_tcon(cifs_sb);
1905 /* only filter by fsuid on multiuser mounts */
1906 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1909 spin_lock(&tcon->open_file_lock);
1911 if (refind > MAX_REOPEN_ATT) {
1912 spin_unlock(&tcon->open_file_lock);
1915 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1916 if (!any_available && open_file->pid != current->tgid)
1918 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1920 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1921 if (!open_file->invalidHandle) {
1922 /* found a good writable file */
1923 cifsFileInfo_get(open_file);
1924 spin_unlock(&tcon->open_file_lock);
1925 *ret_file = open_file;
1929 inv_file = open_file;
1933 /* couldn't find useable FH with same pid, try any available */
1934 if (!any_available) {
1935 any_available = true;
1936 goto refind_writable;
1940 any_available = false;
1941 cifsFileInfo_get(inv_file);
1944 spin_unlock(&tcon->open_file_lock);
1947 rc = cifs_reopen_file(inv_file, false);
1949 *ret_file = inv_file;
1953 spin_lock(&tcon->open_file_lock);
1954 list_move_tail(&inv_file->flist, &cifs_inode->openFileList);
1955 spin_unlock(&tcon->open_file_lock);
1956 cifsFileInfo_put(inv_file);
1959 spin_lock(&tcon->open_file_lock);
1960 goto refind_writable;
1966 struct cifsFileInfo *
1967 find_writable_file(struct cifsInodeInfo *cifs_inode, bool fsuid_only)
1969 struct cifsFileInfo *cfile;
1972 rc = cifs_get_writable_file(cifs_inode, fsuid_only, &cfile);
1974 cifs_dbg(FYI, "couldn't find writable handle rc=%d", rc);
1979 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1981 struct address_space *mapping = page->mapping;
1982 loff_t offset = (loff_t)page->index << PAGE_SHIFT;
1985 int bytes_written = 0;
1986 struct inode *inode;
1987 struct cifsFileInfo *open_file;
1989 if (!mapping || !mapping->host)
1992 inode = page->mapping->host;
1994 offset += (loff_t)from;
1995 write_data = kmap(page);
1998 if ((to > PAGE_SIZE) || (from > to)) {
2003 /* racing with truncate? */
2004 if (offset > mapping->host->i_size) {
2006 return 0; /* don't care */
2009 /* check to make sure that we are not extending the file */
2010 if (mapping->host->i_size - offset < (loff_t)to)
2011 to = (unsigned)(mapping->host->i_size - offset);
2013 rc = cifs_get_writable_file(CIFS_I(mapping->host), false, &open_file);
2015 bytes_written = cifs_write(open_file, open_file->pid,
2016 write_data, to - from, &offset);
2017 cifsFileInfo_put(open_file);
2018 /* Does mm or vfs already set times? */
2019 inode->i_atime = inode->i_mtime = current_time(inode);
2020 if ((bytes_written > 0) && (offset))
2022 else if (bytes_written < 0)
2027 cifs_dbg(FYI, "No writable handle for write page rc=%d\n", rc);
2028 if (!is_retryable_error(rc))
2036 static struct cifs_writedata *
2037 wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
2038 pgoff_t end, pgoff_t *index,
2039 unsigned int *found_pages)
2041 struct cifs_writedata *wdata;
2043 wdata = cifs_writedata_alloc((unsigned int)tofind,
2044 cifs_writev_complete);
2048 *found_pages = find_get_pages_range_tag(mapping, index, end,
2049 PAGECACHE_TAG_DIRTY, tofind, wdata->pages);
2054 wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
2055 struct address_space *mapping,
2056 struct writeback_control *wbc,
2057 pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
2059 unsigned int nr_pages = 0, i;
2062 for (i = 0; i < found_pages; i++) {
2063 page = wdata->pages[i];
2065 * At this point we hold neither the i_pages lock nor the
2066 * page lock: the page may be truncated or invalidated
2067 * (changing page->mapping to NULL), or even swizzled
2068 * back from swapper_space to tmpfs file mapping
2073 else if (!trylock_page(page))
2076 if (unlikely(page->mapping != mapping)) {
2081 if (!wbc->range_cyclic && page->index > end) {
2087 if (*next && (page->index != *next)) {
2088 /* Not next consecutive page */
2093 if (wbc->sync_mode != WB_SYNC_NONE)
2094 wait_on_page_writeback(page);
2096 if (PageWriteback(page) ||
2097 !clear_page_dirty_for_io(page)) {
2103 * This actually clears the dirty bit in the radix tree.
2104 * See cifs_writepage() for more commentary.
2106 set_page_writeback(page);
2107 if (page_offset(page) >= i_size_read(mapping->host)) {
2110 end_page_writeback(page);
2114 wdata->pages[i] = page;
2115 *next = page->index + 1;
2119 /* reset index to refind any pages skipped */
2121 *index = wdata->pages[0]->index + 1;
2123 /* put any pages we aren't going to use */
2124 for (i = nr_pages; i < found_pages; i++) {
2125 put_page(wdata->pages[i]);
2126 wdata->pages[i] = NULL;
2133 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2134 struct address_space *mapping, struct writeback_control *wbc)
2137 struct TCP_Server_Info *server =
2138 tlink_tcon(wdata->cfile->tlink)->ses->server;
2140 wdata->sync_mode = wbc->sync_mode;
2141 wdata->nr_pages = nr_pages;
2142 wdata->offset = page_offset(wdata->pages[0]);
2143 wdata->pagesz = PAGE_SIZE;
2144 wdata->tailsz = min(i_size_read(mapping->host) -
2145 page_offset(wdata->pages[nr_pages - 1]),
2147 wdata->bytes = ((nr_pages - 1) * PAGE_SIZE) + wdata->tailsz;
2148 wdata->pid = wdata->cfile->pid;
2150 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2154 if (wdata->cfile->invalidHandle)
2157 rc = server->ops->async_writev(wdata, cifs_writedata_release);
2162 static int cifs_writepages(struct address_space *mapping,
2163 struct writeback_control *wbc)
2165 struct inode *inode = mapping->host;
2166 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2167 struct TCP_Server_Info *server;
2168 bool done = false, scanned = false, range_whole = false;
2170 struct cifs_writedata *wdata;
2171 struct cifsFileInfo *cfile = NULL;
2177 * If wsize is smaller than the page cache size, default to writing
2178 * one page at a time via cifs_writepage
2180 if (cifs_sb->wsize < PAGE_SIZE)
2181 return generic_writepages(mapping, wbc);
2184 if (wbc->range_cyclic) {
2185 index = mapping->writeback_index; /* Start from prev offset */
2188 index = wbc->range_start >> PAGE_SHIFT;
2189 end = wbc->range_end >> PAGE_SHIFT;
2190 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2194 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2196 while (!done && index <= end) {
2197 unsigned int i, nr_pages, found_pages, wsize;
2198 pgoff_t next = 0, tofind, saved_index = index;
2199 struct cifs_credits credits_on_stack;
2200 struct cifs_credits *credits = &credits_on_stack;
2201 int get_file_rc = 0;
2204 cifsFileInfo_put(cfile);
2206 rc = cifs_get_writable_file(CIFS_I(inode), false, &cfile);
2208 /* in case of an error store it to return later */
2212 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2219 tofind = min((wsize / PAGE_SIZE) - 1, end - index) + 1;
2221 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2226 add_credits_and_wake_if(server, credits, 0);
2230 if (found_pages == 0) {
2231 kref_put(&wdata->refcount, cifs_writedata_release);
2232 add_credits_and_wake_if(server, credits, 0);
2236 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2237 end, &index, &next, &done);
2239 /* nothing to write? */
2240 if (nr_pages == 0) {
2241 kref_put(&wdata->refcount, cifs_writedata_release);
2242 add_credits_and_wake_if(server, credits, 0);
2246 wdata->credits = credits_on_stack;
2247 wdata->cfile = cfile;
2250 if (!wdata->cfile) {
2251 cifs_dbg(VFS, "No writable handle in writepages rc=%d\n",
2253 if (is_retryable_error(get_file_rc))
2258 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2260 for (i = 0; i < nr_pages; ++i)
2261 unlock_page(wdata->pages[i]);
2263 /* send failure -- clean up the mess */
2265 add_credits_and_wake_if(server, &wdata->credits, 0);
2266 for (i = 0; i < nr_pages; ++i) {
2267 if (is_retryable_error(rc))
2268 redirty_page_for_writepage(wbc,
2271 SetPageError(wdata->pages[i]);
2272 end_page_writeback(wdata->pages[i]);
2273 put_page(wdata->pages[i]);
2275 if (!is_retryable_error(rc))
2276 mapping_set_error(mapping, rc);
2278 kref_put(&wdata->refcount, cifs_writedata_release);
2280 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2281 index = saved_index;
2285 /* Return immediately if we received a signal during writing */
2286 if (is_interrupt_error(rc)) {
2291 if (rc != 0 && saved_rc == 0)
2294 wbc->nr_to_write -= nr_pages;
2295 if (wbc->nr_to_write <= 0)
2301 if (!scanned && !done) {
2303 * We hit the last page and there is more work to be done: wrap
2304 * back to the start of the file
2314 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2315 mapping->writeback_index = index;
2318 cifsFileInfo_put(cfile);
2324 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2330 /* BB add check for wbc flags */
2332 if (!PageUptodate(page))
2333 cifs_dbg(FYI, "ppw - page not up to date\n");
2336 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2338 * A writepage() implementation always needs to do either this,
2339 * or re-dirty the page with "redirty_page_for_writepage()" in
2340 * the case of a failure.
2342 * Just unlocking the page will cause the radix tree tag-bits
2343 * to fail to update with the state of the page correctly.
2345 set_page_writeback(page);
2347 rc = cifs_partialpagewrite(page, 0, PAGE_SIZE);
2348 if (is_retryable_error(rc)) {
2349 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN)
2351 redirty_page_for_writepage(wbc, page);
2352 } else if (rc != 0) {
2354 mapping_set_error(page->mapping, rc);
2356 SetPageUptodate(page);
2358 end_page_writeback(page);
2364 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2366 int rc = cifs_writepage_locked(page, wbc);
2371 static int cifs_write_end(struct file *file, struct address_space *mapping,
2372 loff_t pos, unsigned len, unsigned copied,
2373 struct page *page, void *fsdata)
2376 struct inode *inode = mapping->host;
2377 struct cifsFileInfo *cfile = file->private_data;
2378 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2381 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2384 pid = current->tgid;
2386 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2389 if (PageChecked(page)) {
2391 SetPageUptodate(page);
2392 ClearPageChecked(page);
2393 } else if (!PageUptodate(page) && copied == PAGE_SIZE)
2394 SetPageUptodate(page);
2396 if (!PageUptodate(page)) {
2398 unsigned offset = pos & (PAGE_SIZE - 1);
2402 /* this is probably better than directly calling
2403 partialpage_write since in this function the file handle is
2404 known which we might as well leverage */
2405 /* BB check if anything else missing out of ppw
2406 such as updating last write time */
2407 page_data = kmap(page);
2408 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2409 /* if (rc < 0) should we set writebehind rc? */
2416 set_page_dirty(page);
2420 spin_lock(&inode->i_lock);
2421 if (pos > inode->i_size)
2422 i_size_write(inode, pos);
2423 spin_unlock(&inode->i_lock);
2432 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2437 struct cifs_tcon *tcon;
2438 struct TCP_Server_Info *server;
2439 struct cifsFileInfo *smbfile = file->private_data;
2440 struct inode *inode = file_inode(file);
2441 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2443 rc = file_write_and_wait_range(file, start, end);
2450 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2453 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2454 rc = cifs_zap_mapping(inode);
2456 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2457 rc = 0; /* don't care about it in fsync */
2461 tcon = tlink_tcon(smbfile->tlink);
2462 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2463 server = tcon->ses->server;
2464 if (server->ops->flush)
2465 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2471 inode_unlock(inode);
2475 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2479 struct cifs_tcon *tcon;
2480 struct TCP_Server_Info *server;
2481 struct cifsFileInfo *smbfile = file->private_data;
2482 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2483 struct inode *inode = file->f_mapping->host;
2485 rc = file_write_and_wait_range(file, start, end);
2492 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2495 tcon = tlink_tcon(smbfile->tlink);
2496 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2497 server = tcon->ses->server;
2498 if (server->ops->flush)
2499 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2505 inode_unlock(inode);
2510 * As file closes, flush all cached write data for this inode checking
2511 * for write behind errors.
2513 int cifs_flush(struct file *file, fl_owner_t id)
2515 struct inode *inode = file_inode(file);
2518 if (file->f_mode & FMODE_WRITE)
2519 rc = filemap_write_and_wait(inode->i_mapping);
2521 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2527 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2532 for (i = 0; i < num_pages; i++) {
2533 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2536 * save number of pages we have already allocated and
2537 * return with ENOMEM error
2546 for (i = 0; i < num_pages; i++)
2553 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2558 clen = min_t(const size_t, len, wsize);
2559 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2568 cifs_uncached_writedata_release(struct kref *refcount)
2571 struct cifs_writedata *wdata = container_of(refcount,
2572 struct cifs_writedata, refcount);
2574 kref_put(&wdata->ctx->refcount, cifs_aio_ctx_release);
2575 for (i = 0; i < wdata->nr_pages; i++)
2576 put_page(wdata->pages[i]);
2577 cifs_writedata_release(refcount);
2580 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx);
2583 cifs_uncached_writev_complete(struct work_struct *work)
2585 struct cifs_writedata *wdata = container_of(work,
2586 struct cifs_writedata, work);
2587 struct inode *inode = d_inode(wdata->cfile->dentry);
2588 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2590 spin_lock(&inode->i_lock);
2591 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2592 if (cifsi->server_eof > inode->i_size)
2593 i_size_write(inode, cifsi->server_eof);
2594 spin_unlock(&inode->i_lock);
2596 complete(&wdata->done);
2597 collect_uncached_write_data(wdata->ctx);
2598 /* the below call can possibly free the last ref to aio ctx */
2599 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2603 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2604 size_t *len, unsigned long *num_pages)
2606 size_t save_len, copied, bytes, cur_len = *len;
2607 unsigned long i, nr_pages = *num_pages;
2610 for (i = 0; i < nr_pages; i++) {
2611 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2612 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2615 * If we didn't copy as much as we expected, then that
2616 * may mean we trod into an unmapped area. Stop copying
2617 * at that point. On the next pass through the big
2618 * loop, we'll likely end up getting a zero-length
2619 * write and bailing out of it.
2624 cur_len = save_len - cur_len;
2628 * If we have no data to send, then that probably means that
2629 * the copy above failed altogether. That's most likely because
2630 * the address in the iovec was bogus. Return -EFAULT and let
2631 * the caller free anything we allocated and bail out.
2637 * i + 1 now represents the number of pages we actually used in
2638 * the copy phase above.
2645 cifs_resend_wdata(struct cifs_writedata *wdata, struct list_head *wdata_list,
2646 struct cifs_aio_ctx *ctx)
2649 struct cifs_credits credits;
2651 struct TCP_Server_Info *server =
2652 tlink_tcon(wdata->cfile->tlink)->ses->server;
2655 if (wdata->cfile->invalidHandle) {
2656 rc = cifs_reopen_file(wdata->cfile, false);
2665 * Wait for credits to resend this wdata.
2666 * Note: we are attempting to resend the whole wdata not in
2670 rc = server->ops->wait_mtu_credits(server, wdata->bytes,
2675 if (wsize < wdata->bytes) {
2676 add_credits_and_wake_if(server, &credits, 0);
2679 } while (wsize < wdata->bytes);
2680 wdata->credits = credits;
2682 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2685 if (wdata->cfile->invalidHandle)
2688 rc = server->ops->async_writev(wdata,
2689 cifs_uncached_writedata_release);
2692 /* If the write was successfully sent, we are done */
2694 list_add_tail(&wdata->list, wdata_list);
2698 /* Roll back credits and retry if needed */
2699 add_credits_and_wake_if(server, &wdata->credits, 0);
2700 } while (rc == -EAGAIN);
2703 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2708 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2709 struct cifsFileInfo *open_file,
2710 struct cifs_sb_info *cifs_sb, struct list_head *wdata_list,
2711 struct cifs_aio_ctx *ctx)
2715 unsigned long nr_pages, num_pages, i;
2716 struct cifs_writedata *wdata;
2717 struct iov_iter saved_from = *from;
2718 loff_t saved_offset = offset;
2720 struct TCP_Server_Info *server;
2721 struct page **pagevec;
2725 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2726 pid = open_file->pid;
2728 pid = current->tgid;
2730 server = tlink_tcon(open_file->tlink)->ses->server;
2735 struct cifs_credits credits_on_stack;
2736 struct cifs_credits *credits = &credits_on_stack;
2738 if (open_file->invalidHandle) {
2739 rc = cifs_reopen_file(open_file, false);
2746 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2751 cur_len = min_t(const size_t, len, wsize);
2753 if (ctx->direct_io) {
2756 result = iov_iter_get_pages_alloc(
2757 from, &pagevec, cur_len, &start);
2760 "direct_writev couldn't get user pages "
2761 "(rc=%zd) iter type %d iov_offset %zd "
2764 from->iov_offset, from->count);
2768 add_credits_and_wake_if(server, credits, 0);
2771 cur_len = (size_t)result;
2772 iov_iter_advance(from, cur_len);
2775 (cur_len + start + PAGE_SIZE - 1) / PAGE_SIZE;
2777 wdata = cifs_writedata_direct_alloc(pagevec,
2778 cifs_uncached_writev_complete);
2781 add_credits_and_wake_if(server, credits, 0);
2786 wdata->page_offset = start;
2789 cur_len - (PAGE_SIZE - start) -
2790 (nr_pages - 2) * PAGE_SIZE :
2793 nr_pages = get_numpages(wsize, len, &cur_len);
2794 wdata = cifs_writedata_alloc(nr_pages,
2795 cifs_uncached_writev_complete);
2798 add_credits_and_wake_if(server, credits, 0);
2802 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2804 kvfree(wdata->pages);
2806 add_credits_and_wake_if(server, credits, 0);
2810 num_pages = nr_pages;
2811 rc = wdata_fill_from_iovec(
2812 wdata, from, &cur_len, &num_pages);
2814 for (i = 0; i < nr_pages; i++)
2815 put_page(wdata->pages[i]);
2816 kvfree(wdata->pages);
2818 add_credits_and_wake_if(server, credits, 0);
2823 * Bring nr_pages down to the number of pages we
2824 * actually used, and free any pages that we didn't use.
2826 for ( ; nr_pages > num_pages; nr_pages--)
2827 put_page(wdata->pages[nr_pages - 1]);
2829 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2832 wdata->sync_mode = WB_SYNC_ALL;
2833 wdata->nr_pages = nr_pages;
2834 wdata->offset = (__u64)offset;
2835 wdata->cfile = cifsFileInfo_get(open_file);
2837 wdata->bytes = cur_len;
2838 wdata->pagesz = PAGE_SIZE;
2839 wdata->credits = credits_on_stack;
2841 kref_get(&ctx->refcount);
2843 rc = adjust_credits(server, &wdata->credits, wdata->bytes);
2846 if (wdata->cfile->invalidHandle)
2849 rc = server->ops->async_writev(wdata,
2850 cifs_uncached_writedata_release);
2854 add_credits_and_wake_if(server, &wdata->credits, 0);
2855 kref_put(&wdata->refcount,
2856 cifs_uncached_writedata_release);
2857 if (rc == -EAGAIN) {
2859 iov_iter_advance(from, offset - saved_offset);
2865 list_add_tail(&wdata->list, wdata_list);
2874 static void collect_uncached_write_data(struct cifs_aio_ctx *ctx)
2876 struct cifs_writedata *wdata, *tmp;
2877 struct cifs_tcon *tcon;
2878 struct cifs_sb_info *cifs_sb;
2879 struct dentry *dentry = ctx->cfile->dentry;
2882 tcon = tlink_tcon(ctx->cfile->tlink);
2883 cifs_sb = CIFS_SB(dentry->d_sb);
2885 mutex_lock(&ctx->aio_mutex);
2887 if (list_empty(&ctx->list)) {
2888 mutex_unlock(&ctx->aio_mutex);
2894 * Wait for and collect replies for any successful sends in order of
2895 * increasing offset. Once an error is hit, then return without waiting
2896 * for any more replies.
2899 list_for_each_entry_safe(wdata, tmp, &ctx->list, list) {
2901 if (!try_wait_for_completion(&wdata->done)) {
2902 mutex_unlock(&ctx->aio_mutex);
2909 ctx->total_len += wdata->bytes;
2911 /* resend call if it's a retryable error */
2912 if (rc == -EAGAIN) {
2913 struct list_head tmp_list;
2914 struct iov_iter tmp_from = ctx->iter;
2916 INIT_LIST_HEAD(&tmp_list);
2917 list_del_init(&wdata->list);
2920 rc = cifs_resend_wdata(
2921 wdata, &tmp_list, ctx);
2923 iov_iter_advance(&tmp_from,
2924 wdata->offset - ctx->pos);
2926 rc = cifs_write_from_iter(wdata->offset,
2927 wdata->bytes, &tmp_from,
2928 ctx->cfile, cifs_sb, &tmp_list,
2931 kref_put(&wdata->refcount,
2932 cifs_uncached_writedata_release);
2935 list_splice(&tmp_list, &ctx->list);
2939 list_del_init(&wdata->list);
2940 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2943 cifs_stats_bytes_written(tcon, ctx->total_len);
2944 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(dentry->d_inode)->flags);
2946 ctx->rc = (rc == 0) ? ctx->total_len : rc;
2948 mutex_unlock(&ctx->aio_mutex);
2950 if (ctx->iocb && ctx->iocb->ki_complete)
2951 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
2953 complete(&ctx->done);
2956 static ssize_t __cifs_writev(
2957 struct kiocb *iocb, struct iov_iter *from, bool direct)
2959 struct file *file = iocb->ki_filp;
2960 ssize_t total_written = 0;
2961 struct cifsFileInfo *cfile;
2962 struct cifs_tcon *tcon;
2963 struct cifs_sb_info *cifs_sb;
2964 struct cifs_aio_ctx *ctx;
2965 struct iov_iter saved_from = *from;
2966 size_t len = iov_iter_count(from);
2970 * iov_iter_get_pages_alloc doesn't work with ITER_KVEC.
2971 * In this case, fall back to non-direct write function.
2972 * this could be improved by getting pages directly in ITER_KVEC
2974 if (direct && from->type & ITER_KVEC) {
2975 cifs_dbg(FYI, "use non-direct cifs_writev for kvec I/O\n");
2979 rc = generic_write_checks(iocb, from);
2983 cifs_sb = CIFS_FILE_SB(file);
2984 cfile = file->private_data;
2985 tcon = tlink_tcon(cfile->tlink);
2987 if (!tcon->ses->server->ops->async_writev)
2990 ctx = cifs_aio_ctx_alloc();
2994 ctx->cfile = cifsFileInfo_get(cfile);
2996 if (!is_sync_kiocb(iocb))
2999 ctx->pos = iocb->ki_pos;
3002 ctx->direct_io = true;
3006 rc = setup_aio_ctx_iter(ctx, from, WRITE);
3008 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3013 /* grab a lock here due to read response handlers can access ctx */
3014 mutex_lock(&ctx->aio_mutex);
3016 rc = cifs_write_from_iter(iocb->ki_pos, ctx->len, &saved_from,
3017 cfile, cifs_sb, &ctx->list, ctx);
3020 * If at least one write was successfully sent, then discard any rc
3021 * value from the later writes. If the other write succeeds, then
3022 * we'll end up returning whatever was written. If it fails, then
3023 * we'll get a new rc value from that.
3025 if (!list_empty(&ctx->list))
3028 mutex_unlock(&ctx->aio_mutex);
3031 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3035 if (!is_sync_kiocb(iocb)) {
3036 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3037 return -EIOCBQUEUED;
3040 rc = wait_for_completion_killable(&ctx->done);
3042 mutex_lock(&ctx->aio_mutex);
3043 ctx->rc = rc = -EINTR;
3044 total_written = ctx->total_len;
3045 mutex_unlock(&ctx->aio_mutex);
3048 total_written = ctx->total_len;
3051 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3053 if (unlikely(!total_written))
3056 iocb->ki_pos += total_written;
3057 return total_written;
3060 ssize_t cifs_direct_writev(struct kiocb *iocb, struct iov_iter *from)
3062 return __cifs_writev(iocb, from, true);
3065 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
3067 return __cifs_writev(iocb, from, false);
3071 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
3073 struct file *file = iocb->ki_filp;
3074 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
3075 struct inode *inode = file->f_mapping->host;
3076 struct cifsInodeInfo *cinode = CIFS_I(inode);
3077 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
3082 * We need to hold the sem to be sure nobody modifies lock list
3083 * with a brlock that prevents writing.
3085 down_read(&cinode->lock_sem);
3087 rc = generic_write_checks(iocb, from);
3091 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
3092 server->vals->exclusive_lock_type, 0,
3093 NULL, CIFS_WRITE_OP))
3094 rc = __generic_file_write_iter(iocb, from);
3098 up_read(&cinode->lock_sem);
3099 inode_unlock(inode);
3102 rc = generic_write_sync(iocb, rc);
3107 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
3109 struct inode *inode = file_inode(iocb->ki_filp);
3110 struct cifsInodeInfo *cinode = CIFS_I(inode);
3111 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3112 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3113 iocb->ki_filp->private_data;
3114 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3117 written = cifs_get_writer(cinode);
3121 if (CIFS_CACHE_WRITE(cinode)) {
3122 if (cap_unix(tcon->ses) &&
3123 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
3124 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
3125 written = generic_file_write_iter(iocb, from);
3128 written = cifs_writev(iocb, from);
3132 * For non-oplocked files in strict cache mode we need to write the data
3133 * to the server exactly from the pos to pos+len-1 rather than flush all
3134 * affected pages because it may cause a error with mandatory locks on
3135 * these pages but not on the region from pos to ppos+len-1.
3137 written = cifs_user_writev(iocb, from);
3138 if (CIFS_CACHE_READ(cinode)) {
3140 * We have read level caching and we have just sent a write
3141 * request to the server thus making data in the cache stale.
3142 * Zap the cache and set oplock/lease level to NONE to avoid
3143 * reading stale data from the cache. All subsequent read
3144 * operations will read new data from the server.
3146 cifs_zap_mapping(inode);
3147 cifs_dbg(FYI, "Set Oplock/Lease to NONE for inode=%p after write\n",
3152 cifs_put_writer(cinode);
3156 static struct cifs_readdata *
3157 cifs_readdata_direct_alloc(struct page **pages, work_func_t complete)
3159 struct cifs_readdata *rdata;
3161 rdata = kzalloc(sizeof(*rdata), GFP_KERNEL);
3162 if (rdata != NULL) {
3163 rdata->pages = pages;
3164 kref_init(&rdata->refcount);
3165 INIT_LIST_HEAD(&rdata->list);
3166 init_completion(&rdata->done);
3167 INIT_WORK(&rdata->work, complete);
3173 static struct cifs_readdata *
3174 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
3176 struct page **pages =
3177 kcalloc(nr_pages, sizeof(struct page *), GFP_KERNEL);
3178 struct cifs_readdata *ret = NULL;
3181 ret = cifs_readdata_direct_alloc(pages, complete);
3190 cifs_readdata_release(struct kref *refcount)
3192 struct cifs_readdata *rdata = container_of(refcount,
3193 struct cifs_readdata, refcount);
3194 #ifdef CONFIG_CIFS_SMB_DIRECT
3196 smbd_deregister_mr(rdata->mr);
3201 cifsFileInfo_put(rdata->cfile);
3203 kvfree(rdata->pages);
3208 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
3214 for (i = 0; i < nr_pages; i++) {
3215 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
3220 rdata->pages[i] = page;
3224 for (i = 0; i < nr_pages; i++) {
3225 put_page(rdata->pages[i]);
3226 rdata->pages[i] = NULL;
3233 cifs_uncached_readdata_release(struct kref *refcount)
3235 struct cifs_readdata *rdata = container_of(refcount,
3236 struct cifs_readdata, refcount);
3239 kref_put(&rdata->ctx->refcount, cifs_aio_ctx_release);
3240 for (i = 0; i < rdata->nr_pages; i++) {
3241 put_page(rdata->pages[i]);
3243 cifs_readdata_release(refcount);
3247 * cifs_readdata_to_iov - copy data from pages in response to an iovec
3248 * @rdata: the readdata response with list of pages holding data
3249 * @iter: destination for our data
3251 * This function copies data from a list of pages in a readdata response into
3252 * an array of iovecs. It will first calculate where the data should go
3253 * based on the info in the readdata and then copy the data into that spot.
3256 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
3258 size_t remaining = rdata->got_bytes;
3261 for (i = 0; i < rdata->nr_pages; i++) {
3262 struct page *page = rdata->pages[i];
3263 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
3266 if (unlikely(iov_iter_is_pipe(iter))) {
3267 void *addr = kmap_atomic(page);
3269 written = copy_to_iter(addr, copy, iter);
3270 kunmap_atomic(addr);
3272 written = copy_page_to_iter(page, 0, copy, iter);
3273 remaining -= written;
3274 if (written < copy && iov_iter_count(iter) > 0)
3277 return remaining ? -EFAULT : 0;
3280 static void collect_uncached_read_data(struct cifs_aio_ctx *ctx);
3283 cifs_uncached_readv_complete(struct work_struct *work)
3285 struct cifs_readdata *rdata = container_of(work,
3286 struct cifs_readdata, work);
3288 complete(&rdata->done);
3289 collect_uncached_read_data(rdata->ctx);
3290 /* the below call can possibly free the last ref to aio ctx */
3291 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3295 uncached_fill_pages(struct TCP_Server_Info *server,
3296 struct cifs_readdata *rdata, struct iov_iter *iter,
3301 unsigned int nr_pages = rdata->nr_pages;
3302 unsigned int page_offset = rdata->page_offset;
3304 rdata->got_bytes = 0;
3305 rdata->tailsz = PAGE_SIZE;
3306 for (i = 0; i < nr_pages; i++) {
3307 struct page *page = rdata->pages[i];
3309 unsigned int segment_size = rdata->pagesz;
3312 segment_size -= page_offset;
3318 /* no need to hold page hostage */
3319 rdata->pages[i] = NULL;
3326 if (len >= segment_size)
3327 /* enough data to fill the page */
3330 rdata->tailsz = len;
3334 result = copy_page_from_iter(
3335 page, page_offset, n, iter);
3336 #ifdef CONFIG_CIFS_SMB_DIRECT
3341 result = cifs_read_page_from_socket(
3342 server, page, page_offset, n);
3346 rdata->got_bytes += result;
3349 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3350 rdata->got_bytes : result;
3354 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
3355 struct cifs_readdata *rdata, unsigned int len)
3357 return uncached_fill_pages(server, rdata, NULL, len);
3361 cifs_uncached_copy_into_pages(struct TCP_Server_Info *server,
3362 struct cifs_readdata *rdata,
3363 struct iov_iter *iter)
3365 return uncached_fill_pages(server, rdata, iter, iter->count);
3368 static int cifs_resend_rdata(struct cifs_readdata *rdata,
3369 struct list_head *rdata_list,
3370 struct cifs_aio_ctx *ctx)
3373 struct cifs_credits credits;
3375 struct TCP_Server_Info *server =
3376 tlink_tcon(rdata->cfile->tlink)->ses->server;
3379 if (rdata->cfile->invalidHandle) {
3380 rc = cifs_reopen_file(rdata->cfile, true);
3388 * Wait for credits to resend this rdata.
3389 * Note: we are attempting to resend the whole rdata not in
3393 rc = server->ops->wait_mtu_credits(server, rdata->bytes,
3399 if (rsize < rdata->bytes) {
3400 add_credits_and_wake_if(server, &credits, 0);
3403 } while (rsize < rdata->bytes);
3404 rdata->credits = credits;
3406 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3408 if (rdata->cfile->invalidHandle)
3411 rc = server->ops->async_readv(rdata);
3414 /* If the read was successfully sent, we are done */
3416 /* Add to aio pending list */
3417 list_add_tail(&rdata->list, rdata_list);
3421 /* Roll back credits and retry if needed */
3422 add_credits_and_wake_if(server, &rdata->credits, 0);
3423 } while (rc == -EAGAIN);
3426 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3431 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
3432 struct cifs_sb_info *cifs_sb, struct list_head *rdata_list,
3433 struct cifs_aio_ctx *ctx)
3435 struct cifs_readdata *rdata;
3436 unsigned int npages, rsize;
3437 struct cifs_credits credits_on_stack;
3438 struct cifs_credits *credits = &credits_on_stack;
3442 struct TCP_Server_Info *server;
3443 struct page **pagevec;
3445 struct iov_iter direct_iov = ctx->iter;
3447 server = tlink_tcon(open_file->tlink)->ses->server;
3449 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3450 pid = open_file->pid;
3452 pid = current->tgid;
3455 iov_iter_advance(&direct_iov, offset - ctx->pos);
3458 if (open_file->invalidHandle) {
3459 rc = cifs_reopen_file(open_file, true);
3466 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3471 cur_len = min_t(const size_t, len, rsize);
3473 if (ctx->direct_io) {
3476 result = iov_iter_get_pages_alloc(
3477 &direct_iov, &pagevec,
3481 "couldn't get user pages (rc=%zd)"
3483 " iov_offset %zd count %zd\n",
3484 result, direct_iov.type,
3485 direct_iov.iov_offset,
3490 add_credits_and_wake_if(server, credits, 0);
3493 cur_len = (size_t)result;
3494 iov_iter_advance(&direct_iov, cur_len);
3496 rdata = cifs_readdata_direct_alloc(
3497 pagevec, cifs_uncached_readv_complete);
3499 add_credits_and_wake_if(server, credits, 0);
3504 npages = (cur_len + start + PAGE_SIZE-1) / PAGE_SIZE;
3505 rdata->page_offset = start;
3506 rdata->tailsz = npages > 1 ?
3507 cur_len-(PAGE_SIZE-start)-(npages-2)*PAGE_SIZE :
3512 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
3513 /* allocate a readdata struct */
3514 rdata = cifs_readdata_alloc(npages,
3515 cifs_uncached_readv_complete);
3517 add_credits_and_wake_if(server, credits, 0);
3522 rc = cifs_read_allocate_pages(rdata, npages);
3524 kvfree(rdata->pages);
3526 add_credits_and_wake_if(server, credits, 0);
3530 rdata->tailsz = PAGE_SIZE;
3533 rdata->cfile = cifsFileInfo_get(open_file);
3534 rdata->nr_pages = npages;
3535 rdata->offset = offset;
3536 rdata->bytes = cur_len;
3538 rdata->pagesz = PAGE_SIZE;
3539 rdata->read_into_pages = cifs_uncached_read_into_pages;
3540 rdata->copy_into_pages = cifs_uncached_copy_into_pages;
3541 rdata->credits = credits_on_stack;
3543 kref_get(&ctx->refcount);
3545 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
3548 if (rdata->cfile->invalidHandle)
3551 rc = server->ops->async_readv(rdata);
3555 add_credits_and_wake_if(server, &rdata->credits, 0);
3556 kref_put(&rdata->refcount,
3557 cifs_uncached_readdata_release);
3558 if (rc == -EAGAIN) {
3559 iov_iter_revert(&direct_iov, cur_len);
3565 list_add_tail(&rdata->list, rdata_list);
3574 collect_uncached_read_data(struct cifs_aio_ctx *ctx)
3576 struct cifs_readdata *rdata, *tmp;
3577 struct iov_iter *to = &ctx->iter;
3578 struct cifs_sb_info *cifs_sb;
3579 struct cifs_tcon *tcon;
3582 tcon = tlink_tcon(ctx->cfile->tlink);
3583 cifs_sb = CIFS_SB(ctx->cfile->dentry->d_sb);
3585 mutex_lock(&ctx->aio_mutex);
3587 if (list_empty(&ctx->list)) {
3588 mutex_unlock(&ctx->aio_mutex);
3593 /* the loop below should proceed in the order of increasing offsets */
3595 list_for_each_entry_safe(rdata, tmp, &ctx->list, list) {
3597 if (!try_wait_for_completion(&rdata->done)) {
3598 mutex_unlock(&ctx->aio_mutex);
3602 if (rdata->result == -EAGAIN) {
3603 /* resend call if it's a retryable error */
3604 struct list_head tmp_list;
3605 unsigned int got_bytes = rdata->got_bytes;
3607 list_del_init(&rdata->list);
3608 INIT_LIST_HEAD(&tmp_list);
3611 * Got a part of data and then reconnect has
3612 * happened -- fill the buffer and continue
3615 if (got_bytes && got_bytes < rdata->bytes) {
3617 if (!ctx->direct_io)
3618 rc = cifs_readdata_to_iov(rdata, to);
3620 kref_put(&rdata->refcount,
3621 cifs_uncached_readdata_release);
3626 if (ctx->direct_io) {
3628 * Re-use rdata as this is a
3631 rc = cifs_resend_rdata(
3635 rc = cifs_send_async_read(
3636 rdata->offset + got_bytes,
3637 rdata->bytes - got_bytes,
3638 rdata->cfile, cifs_sb,
3641 kref_put(&rdata->refcount,
3642 cifs_uncached_readdata_release);
3645 list_splice(&tmp_list, &ctx->list);
3648 } else if (rdata->result)
3650 else if (!ctx->direct_io)
3651 rc = cifs_readdata_to_iov(rdata, to);
3653 /* if there was a short read -- discard anything left */
3654 if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3657 ctx->total_len += rdata->got_bytes;
3659 list_del_init(&rdata->list);
3660 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3663 if (!ctx->direct_io)
3664 ctx->total_len = ctx->len - iov_iter_count(to);
3666 /* mask nodata case */
3670 ctx->rc = (rc == 0) ? ctx->total_len : rc;
3672 mutex_unlock(&ctx->aio_mutex);
3674 if (ctx->iocb && ctx->iocb->ki_complete)
3675 ctx->iocb->ki_complete(ctx->iocb, ctx->rc, 0);
3677 complete(&ctx->done);
3680 static ssize_t __cifs_readv(
3681 struct kiocb *iocb, struct iov_iter *to, bool direct)
3684 struct file *file = iocb->ki_filp;
3685 struct cifs_sb_info *cifs_sb;
3686 struct cifsFileInfo *cfile;
3687 struct cifs_tcon *tcon;
3688 ssize_t rc, total_read = 0;
3689 loff_t offset = iocb->ki_pos;
3690 struct cifs_aio_ctx *ctx;
3693 * iov_iter_get_pages_alloc() doesn't work with ITER_KVEC,
3694 * fall back to data copy read path
3695 * this could be improved by getting pages directly in ITER_KVEC
3697 if (direct && to->type & ITER_KVEC) {
3698 cifs_dbg(FYI, "use non-direct cifs_user_readv for kvec I/O\n");
3702 len = iov_iter_count(to);
3706 cifs_sb = CIFS_FILE_SB(file);
3707 cfile = file->private_data;
3708 tcon = tlink_tcon(cfile->tlink);
3710 if (!tcon->ses->server->ops->async_readv)
3713 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3714 cifs_dbg(FYI, "attempting read on write only file instance\n");
3716 ctx = cifs_aio_ctx_alloc();
3720 ctx->cfile = cifsFileInfo_get(cfile);
3722 if (!is_sync_kiocb(iocb))
3725 if (iter_is_iovec(to))
3726 ctx->should_dirty = true;
3730 ctx->direct_io = true;
3734 rc = setup_aio_ctx_iter(ctx, to, READ);
3736 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3742 /* grab a lock here due to read response handlers can access ctx */
3743 mutex_lock(&ctx->aio_mutex);
3745 rc = cifs_send_async_read(offset, len, cfile, cifs_sb, &ctx->list, ctx);
3747 /* if at least one read request send succeeded, then reset rc */
3748 if (!list_empty(&ctx->list))
3751 mutex_unlock(&ctx->aio_mutex);
3754 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3758 if (!is_sync_kiocb(iocb)) {
3759 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3760 return -EIOCBQUEUED;
3763 rc = wait_for_completion_killable(&ctx->done);
3765 mutex_lock(&ctx->aio_mutex);
3766 ctx->rc = rc = -EINTR;
3767 total_read = ctx->total_len;
3768 mutex_unlock(&ctx->aio_mutex);
3771 total_read = ctx->total_len;
3774 kref_put(&ctx->refcount, cifs_aio_ctx_release);
3777 iocb->ki_pos += total_read;
3783 ssize_t cifs_direct_readv(struct kiocb *iocb, struct iov_iter *to)
3785 return __cifs_readv(iocb, to, true);
3788 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
3790 return __cifs_readv(iocb, to, false);
3794 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3796 struct inode *inode = file_inode(iocb->ki_filp);
3797 struct cifsInodeInfo *cinode = CIFS_I(inode);
3798 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3799 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3800 iocb->ki_filp->private_data;
3801 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3805 * In strict cache mode we need to read from the server all the time
3806 * if we don't have level II oplock because the server can delay mtime
3807 * change - so we can't make a decision about inode invalidating.
3808 * And we can also fail with pagereading if there are mandatory locks
3809 * on pages affected by this read but not on the region from pos to
3812 if (!CIFS_CACHE_READ(cinode))
3813 return cifs_user_readv(iocb, to);
3815 if (cap_unix(tcon->ses) &&
3816 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3817 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3818 return generic_file_read_iter(iocb, to);
3821 * We need to hold the sem to be sure nobody modifies lock list
3822 * with a brlock that prevents reading.
3824 down_read(&cinode->lock_sem);
3825 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3826 tcon->ses->server->vals->shared_lock_type,
3827 0, NULL, CIFS_READ_OP))
3828 rc = generic_file_read_iter(iocb, to);
3829 up_read(&cinode->lock_sem);
3834 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3837 unsigned int bytes_read = 0;
3838 unsigned int total_read;
3839 unsigned int current_read_size;
3841 struct cifs_sb_info *cifs_sb;
3842 struct cifs_tcon *tcon;
3843 struct TCP_Server_Info *server;
3846 struct cifsFileInfo *open_file;
3847 struct cifs_io_parms io_parms;
3848 int buf_type = CIFS_NO_BUFFER;
3852 cifs_sb = CIFS_FILE_SB(file);
3854 /* FIXME: set up handlers for larger reads and/or convert to async */
3855 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3857 if (file->private_data == NULL) {
3862 open_file = file->private_data;
3863 tcon = tlink_tcon(open_file->tlink);
3864 server = tcon->ses->server;
3866 if (!server->ops->sync_read) {
3871 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3872 pid = open_file->pid;
3874 pid = current->tgid;
3876 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3877 cifs_dbg(FYI, "attempting read on write only file instance\n");
3879 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3880 total_read += bytes_read, cur_offset += bytes_read) {
3882 current_read_size = min_t(uint, read_size - total_read,
3885 * For windows me and 9x we do not want to request more
3886 * than it negotiated since it will refuse the read
3889 if ((tcon->ses) && !(tcon->ses->capabilities &
3890 tcon->ses->server->vals->cap_large_files)) {
3891 current_read_size = min_t(uint,
3892 current_read_size, CIFSMaxBufSize);
3894 if (open_file->invalidHandle) {
3895 rc = cifs_reopen_file(open_file, true);
3900 io_parms.tcon = tcon;
3901 io_parms.offset = *offset;
3902 io_parms.length = current_read_size;
3903 rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3904 &bytes_read, &cur_offset,
3906 } while (rc == -EAGAIN);
3908 if (rc || (bytes_read == 0)) {
3916 cifs_stats_bytes_read(tcon, total_read);
3917 *offset += bytes_read;
3925 * If the page is mmap'ed into a process' page tables, then we need to make
3926 * sure that it doesn't change while being written back.
3929 cifs_page_mkwrite(struct vm_fault *vmf)
3931 struct page *page = vmf->page;
3934 return VM_FAULT_LOCKED;
3937 static const struct vm_operations_struct cifs_file_vm_ops = {
3938 .fault = filemap_fault,
3939 .map_pages = filemap_map_pages,
3940 .page_mkwrite = cifs_page_mkwrite,
3943 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3946 struct inode *inode = file_inode(file);
3950 if (!CIFS_CACHE_READ(CIFS_I(inode)))
3951 rc = cifs_zap_mapping(inode);
3953 rc = generic_file_mmap(file, vma);
3955 vma->vm_ops = &cifs_file_vm_ops;
3961 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3967 rc = cifs_revalidate_file(file);
3969 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3972 rc = generic_file_mmap(file, vma);
3974 vma->vm_ops = &cifs_file_vm_ops;
3981 cifs_readv_complete(struct work_struct *work)
3983 unsigned int i, got_bytes;
3984 struct cifs_readdata *rdata = container_of(work,
3985 struct cifs_readdata, work);
3987 got_bytes = rdata->got_bytes;
3988 for (i = 0; i < rdata->nr_pages; i++) {
3989 struct page *page = rdata->pages[i];
3991 lru_cache_add_file(page);
3993 if (rdata->result == 0 ||
3994 (rdata->result == -EAGAIN && got_bytes)) {
3995 flush_dcache_page(page);
3996 SetPageUptodate(page);
4001 if (rdata->result == 0 ||
4002 (rdata->result == -EAGAIN && got_bytes))
4003 cifs_readpage_to_fscache(rdata->mapping->host, page);
4005 got_bytes -= min_t(unsigned int, PAGE_SIZE, got_bytes);
4008 rdata->pages[i] = NULL;
4010 kref_put(&rdata->refcount, cifs_readdata_release);
4014 readpages_fill_pages(struct TCP_Server_Info *server,
4015 struct cifs_readdata *rdata, struct iov_iter *iter,
4022 unsigned int nr_pages = rdata->nr_pages;
4023 unsigned int page_offset = rdata->page_offset;
4025 /* determine the eof that the server (probably) has */
4026 eof = CIFS_I(rdata->mapping->host)->server_eof;
4027 eof_index = eof ? (eof - 1) >> PAGE_SHIFT : 0;
4028 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
4030 rdata->got_bytes = 0;
4031 rdata->tailsz = PAGE_SIZE;
4032 for (i = 0; i < nr_pages; i++) {
4033 struct page *page = rdata->pages[i];
4034 unsigned int to_read = rdata->pagesz;
4038 to_read -= page_offset;
4044 if (len >= to_read) {
4046 } else if (len > 0) {
4047 /* enough for partial page, fill and zero the rest */
4048 zero_user(page, len + page_offset, to_read - len);
4049 n = rdata->tailsz = len;
4051 } else if (page->index > eof_index) {
4053 * The VFS will not try to do readahead past the
4054 * i_size, but it's possible that we have outstanding
4055 * writes with gaps in the middle and the i_size hasn't
4056 * caught up yet. Populate those with zeroed out pages
4057 * to prevent the VFS from repeatedly attempting to
4058 * fill them until the writes are flushed.
4060 zero_user(page, 0, PAGE_SIZE);
4061 lru_cache_add_file(page);
4062 flush_dcache_page(page);
4063 SetPageUptodate(page);
4066 rdata->pages[i] = NULL;
4070 /* no need to hold page hostage */
4071 lru_cache_add_file(page);
4074 rdata->pages[i] = NULL;
4080 result = copy_page_from_iter(
4081 page, page_offset, n, iter);
4082 #ifdef CONFIG_CIFS_SMB_DIRECT
4087 result = cifs_read_page_from_socket(
4088 server, page, page_offset, n);
4092 rdata->got_bytes += result;
4095 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
4096 rdata->got_bytes : result;
4100 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
4101 struct cifs_readdata *rdata, unsigned int len)
4103 return readpages_fill_pages(server, rdata, NULL, len);
4107 cifs_readpages_copy_into_pages(struct TCP_Server_Info *server,
4108 struct cifs_readdata *rdata,
4109 struct iov_iter *iter)
4111 return readpages_fill_pages(server, rdata, iter, iter->count);
4115 readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
4116 unsigned int rsize, struct list_head *tmplist,
4117 unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
4119 struct page *page, *tpage;
4120 unsigned int expected_index;
4122 gfp_t gfp = readahead_gfp_mask(mapping);
4124 INIT_LIST_HEAD(tmplist);
4126 page = lru_to_page(page_list);
4129 * Lock the page and put it in the cache. Since no one else
4130 * should have access to this page, we're safe to simply set
4131 * PG_locked without checking it first.
4133 __SetPageLocked(page);
4134 rc = add_to_page_cache_locked(page, mapping,
4137 /* give up if we can't stick it in the cache */
4139 __ClearPageLocked(page);
4143 /* move first page to the tmplist */
4144 *offset = (loff_t)page->index << PAGE_SHIFT;
4147 list_move_tail(&page->lru, tmplist);
4149 /* now try and add more pages onto the request */
4150 expected_index = page->index + 1;
4151 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
4152 /* discontinuity ? */
4153 if (page->index != expected_index)
4156 /* would this page push the read over the rsize? */
4157 if (*bytes + PAGE_SIZE > rsize)
4160 __SetPageLocked(page);
4161 if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
4162 __ClearPageLocked(page);
4165 list_move_tail(&page->lru, tmplist);
4166 (*bytes) += PAGE_SIZE;
4173 static int cifs_readpages(struct file *file, struct address_space *mapping,
4174 struct list_head *page_list, unsigned num_pages)
4177 struct list_head tmplist;
4178 struct cifsFileInfo *open_file = file->private_data;
4179 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
4180 struct TCP_Server_Info *server;
4186 * Reads as many pages as possible from fscache. Returns -ENOBUFS
4187 * immediately if the cookie is negative
4189 * After this point, every page in the list might have PG_fscache set,
4190 * so we will need to clean that up off of every page we don't use.
4192 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
4199 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
4200 pid = open_file->pid;
4202 pid = current->tgid;
4205 server = tlink_tcon(open_file->tlink)->ses->server;
4207 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
4208 __func__, file, mapping, num_pages);
4211 * Start with the page at end of list and move it to private
4212 * list. Do the same with any following pages until we hit
4213 * the rsize limit, hit an index discontinuity, or run out of
4214 * pages. Issue the async read and then start the loop again
4215 * until the list is empty.
4217 * Note that list order is important. The page_list is in
4218 * the order of declining indexes. When we put the pages in
4219 * the rdata->pages, then we want them in increasing order.
4221 while (!list_empty(page_list)) {
4222 unsigned int i, nr_pages, bytes, rsize;
4224 struct page *page, *tpage;
4225 struct cifs_readdata *rdata;
4226 struct cifs_credits credits_on_stack;
4227 struct cifs_credits *credits = &credits_on_stack;
4229 if (open_file->invalidHandle) {
4230 rc = cifs_reopen_file(open_file, true);
4237 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
4243 * Give up immediately if rsize is too small to read an entire
4244 * page. The VFS will fall back to readpage. We should never
4245 * reach this point however since we set ra_pages to 0 when the
4246 * rsize is smaller than a cache page.
4248 if (unlikely(rsize < PAGE_SIZE)) {
4249 add_credits_and_wake_if(server, credits, 0);
4254 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
4255 &nr_pages, &offset, &bytes);
4257 add_credits_and_wake_if(server, credits, 0);
4261 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
4263 /* best to give up if we're out of mem */
4264 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4265 list_del(&page->lru);
4266 lru_cache_add_file(page);
4271 add_credits_and_wake_if(server, credits, 0);
4275 rdata->cfile = cifsFileInfo_get(open_file);
4276 rdata->mapping = mapping;
4277 rdata->offset = offset;
4278 rdata->bytes = bytes;
4280 rdata->pagesz = PAGE_SIZE;
4281 rdata->tailsz = PAGE_SIZE;
4282 rdata->read_into_pages = cifs_readpages_read_into_pages;
4283 rdata->copy_into_pages = cifs_readpages_copy_into_pages;
4284 rdata->credits = credits_on_stack;
4286 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
4287 list_del(&page->lru);
4288 rdata->pages[rdata->nr_pages++] = page;
4291 rc = adjust_credits(server, &rdata->credits, rdata->bytes);
4294 if (rdata->cfile->invalidHandle)
4297 rc = server->ops->async_readv(rdata);
4301 add_credits_and_wake_if(server, &rdata->credits, 0);
4302 for (i = 0; i < rdata->nr_pages; i++) {
4303 page = rdata->pages[i];
4304 lru_cache_add_file(page);
4308 /* Fallback to the readpage in error/reconnect cases */
4309 kref_put(&rdata->refcount, cifs_readdata_release);
4313 kref_put(&rdata->refcount, cifs_readdata_release);
4316 /* Any pages that have been shown to fscache but didn't get added to
4317 * the pagecache must be uncached before they get returned to the
4320 cifs_fscache_readpages_cancel(mapping->host, page_list);
4326 * cifs_readpage_worker must be called with the page pinned
4328 static int cifs_readpage_worker(struct file *file, struct page *page,
4334 /* Is the page cached? */
4335 rc = cifs_readpage_from_fscache(file_inode(file), page);
4339 read_data = kmap(page);
4340 /* for reads over a certain size could initiate async read ahead */
4342 rc = cifs_read(file, read_data, PAGE_SIZE, poffset);
4347 cifs_dbg(FYI, "Bytes read %d\n", rc);
4349 /* we do not want atime to be less than mtime, it broke some apps */
4350 file_inode(file)->i_atime = current_time(file_inode(file));
4351 if (timespec64_compare(&(file_inode(file)->i_atime), &(file_inode(file)->i_mtime)))
4352 file_inode(file)->i_atime = file_inode(file)->i_mtime;
4354 file_inode(file)->i_atime = current_time(file_inode(file));
4357 memset(read_data + rc, 0, PAGE_SIZE - rc);
4359 flush_dcache_page(page);
4360 SetPageUptodate(page);
4362 /* send this page to the cache */
4363 cifs_readpage_to_fscache(file_inode(file), page);
4375 static int cifs_readpage(struct file *file, struct page *page)
4377 loff_t offset = (loff_t)page->index << PAGE_SHIFT;
4383 if (file->private_data == NULL) {
4389 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
4390 page, (int)offset, (int)offset);
4392 rc = cifs_readpage_worker(file, page, &offset);
4398 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
4400 struct cifsFileInfo *open_file;
4401 struct cifs_tcon *tcon =
4402 cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
4404 spin_lock(&tcon->open_file_lock);
4405 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
4406 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
4407 spin_unlock(&tcon->open_file_lock);
4411 spin_unlock(&tcon->open_file_lock);
4415 /* We do not want to update the file size from server for inodes
4416 open for write - to avoid races with writepage extending
4417 the file - in the future we could consider allowing
4418 refreshing the inode only on increases in the file size
4419 but this is tricky to do without racing with writebehind
4420 page caching in the current Linux kernel design */
4421 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
4426 if (is_inode_writable(cifsInode)) {
4427 /* This inode is open for write at least once */
4428 struct cifs_sb_info *cifs_sb;
4430 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
4431 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
4432 /* since no page cache to corrupt on directio
4433 we can change size safely */
4437 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
4445 static int cifs_write_begin(struct file *file, struct address_space *mapping,
4446 loff_t pos, unsigned len, unsigned flags,
4447 struct page **pagep, void **fsdata)
4450 pgoff_t index = pos >> PAGE_SHIFT;
4451 loff_t offset = pos & (PAGE_SIZE - 1);
4452 loff_t page_start = pos & PAGE_MASK;
4457 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
4460 page = grab_cache_page_write_begin(mapping, index, flags);
4466 if (PageUptodate(page))
4470 * If we write a full page it will be up to date, no need to read from
4471 * the server. If the write is short, we'll end up doing a sync write
4474 if (len == PAGE_SIZE)
4478 * optimize away the read when we have an oplock, and we're not
4479 * expecting to use any of the data we'd be reading in. That
4480 * is, when the page lies beyond the EOF, or straddles the EOF
4481 * and the write will cover all of the existing data.
4483 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
4484 i_size = i_size_read(mapping->host);
4485 if (page_start >= i_size ||
4486 (offset == 0 && (pos + len) >= i_size)) {
4487 zero_user_segments(page, 0, offset,
4491 * PageChecked means that the parts of the page
4492 * to which we're not writing are considered up
4493 * to date. Once the data is copied to the
4494 * page, it can be set uptodate.
4496 SetPageChecked(page);
4501 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
4503 * might as well read a page, it is fast enough. If we get
4504 * an error, we don't need to return it. cifs_write_end will
4505 * do a sync write instead since PG_uptodate isn't set.
4507 cifs_readpage_worker(file, page, &page_start);
4512 /* we could try using another file handle if there is one -
4513 but how would we lock it to prevent close of that handle
4514 racing with this read? In any case
4515 this will be written out by write_end so is fine */
4522 static int cifs_release_page(struct page *page, gfp_t gfp)
4524 if (PagePrivate(page))
4527 return cifs_fscache_release_page(page, gfp);
4530 static void cifs_invalidate_page(struct page *page, unsigned int offset,
4531 unsigned int length)
4533 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
4535 if (offset == 0 && length == PAGE_SIZE)
4536 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
4539 static int cifs_launder_page(struct page *page)
4542 loff_t range_start = page_offset(page);
4543 loff_t range_end = range_start + (loff_t)(PAGE_SIZE - 1);
4544 struct writeback_control wbc = {
4545 .sync_mode = WB_SYNC_ALL,
4547 .range_start = range_start,
4548 .range_end = range_end,
4551 cifs_dbg(FYI, "Launder page: %p\n", page);
4553 if (clear_page_dirty_for_io(page))
4554 rc = cifs_writepage_locked(page, &wbc);
4556 cifs_fscache_invalidate_page(page, page->mapping->host);
4560 void cifs_oplock_break(struct work_struct *work)
4562 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
4564 struct inode *inode = d_inode(cfile->dentry);
4565 struct cifsInodeInfo *cinode = CIFS_I(inode);
4566 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
4567 struct TCP_Server_Info *server = tcon->ses->server;
4570 wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
4571 TASK_UNINTERRUPTIBLE);
4573 server->ops->downgrade_oplock(server, cinode,
4574 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
4576 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
4577 cifs_has_mand_locks(cinode)) {
4578 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
4583 if (inode && S_ISREG(inode->i_mode)) {
4584 if (CIFS_CACHE_READ(cinode))
4585 break_lease(inode, O_RDONLY);
4587 break_lease(inode, O_WRONLY);
4588 rc = filemap_fdatawrite(inode->i_mapping);
4589 if (!CIFS_CACHE_READ(cinode)) {
4590 rc = filemap_fdatawait(inode->i_mapping);
4591 mapping_set_error(inode->i_mapping, rc);
4592 cifs_zap_mapping(inode);
4594 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
4597 rc = cifs_push_locks(cfile);
4599 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
4602 * releasing stale oplock after recent reconnect of smb session using
4603 * a now incorrect file handle is not a data integrity issue but do
4604 * not bother sending an oplock release if session to server still is
4605 * disconnected since oplock already released by the server
4607 if (!cfile->oplock_break_cancelled) {
4608 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
4610 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
4612 _cifsFileInfo_put(cfile, false /* do not wait for ourself */);
4613 cifs_done_oplock_break(cinode);
4617 * The presence of cifs_direct_io() in the address space ops vector
4618 * allowes open() O_DIRECT flags which would have failed otherwise.
4620 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
4621 * so this method should never be called.
4623 * Direct IO is not yet supported in the cached mode.
4626 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter)
4630 * Eventually need to support direct IO for non forcedirectio mounts
4636 const struct address_space_operations cifs_addr_ops = {
4637 .readpage = cifs_readpage,
4638 .readpages = cifs_readpages,
4639 .writepage = cifs_writepage,
4640 .writepages = cifs_writepages,
4641 .write_begin = cifs_write_begin,
4642 .write_end = cifs_write_end,
4643 .set_page_dirty = __set_page_dirty_nobuffers,
4644 .releasepage = cifs_release_page,
4645 .direct_IO = cifs_direct_io,
4646 .invalidatepage = cifs_invalidate_page,
4647 .launder_page = cifs_launder_page,
4651 * cifs_readpages requires the server to support a buffer large enough to
4652 * contain the header plus one complete page of data. Otherwise, we need
4653 * to leave cifs_readpages out of the address space operations.
4655 const struct address_space_operations cifs_addr_ops_smallbuf = {
4656 .readpage = cifs_readpage,
4657 .writepage = cifs_writepage,
4658 .writepages = cifs_writepages,
4659 .write_begin = cifs_write_begin,
4660 .write_end = cifs_write_end,
4661 .set_page_dirty = __set_page_dirty_nobuffers,
4662 .releasepage = cifs_release_page,
4663 .invalidatepage = cifs_invalidate_page,
4664 .launder_page = cifs_launder_page,