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>
36 #include <asm/div64.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
46 static inline int cifs_convert_flags(unsigned int flags)
48 if ((flags & O_ACCMODE) == O_RDONLY)
50 else if ((flags & O_ACCMODE) == O_WRONLY)
52 else if ((flags & O_ACCMODE) == O_RDWR) {
53 /* GENERIC_ALL is too much permission to request
54 can cause unnecessary access denied on create */
55 /* return GENERIC_ALL; */
56 return (GENERIC_READ | GENERIC_WRITE);
59 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
60 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
64 static u32 cifs_posix_convert_flags(unsigned int flags)
68 if ((flags & O_ACCMODE) == O_RDONLY)
69 posix_flags = SMB_O_RDONLY;
70 else if ((flags & O_ACCMODE) == O_WRONLY)
71 posix_flags = SMB_O_WRONLY;
72 else if ((flags & O_ACCMODE) == O_RDWR)
73 posix_flags = SMB_O_RDWR;
76 posix_flags |= SMB_O_CREAT;
78 posix_flags |= SMB_O_EXCL;
80 posix_flags |= SMB_O_TRUNC;
81 /* be safe and imply O_SYNC for O_DSYNC */
83 posix_flags |= SMB_O_SYNC;
84 if (flags & O_DIRECTORY)
85 posix_flags |= SMB_O_DIRECTORY;
86 if (flags & O_NOFOLLOW)
87 posix_flags |= SMB_O_NOFOLLOW;
89 posix_flags |= SMB_O_DIRECT;
94 static inline int cifs_get_disposition(unsigned int flags)
96 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
98 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
99 return FILE_OVERWRITE_IF;
100 else if ((flags & O_CREAT) == O_CREAT)
102 else if ((flags & O_TRUNC) == O_TRUNC)
103 return FILE_OVERWRITE;
108 int cifs_posix_open(char *full_path, struct inode **pinode,
109 struct super_block *sb, int mode, unsigned int f_flags,
110 __u32 *poplock, __u16 *pnetfid, unsigned int xid)
113 FILE_UNIX_BASIC_INFO *presp_data;
114 __u32 posix_flags = 0;
115 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
116 struct cifs_fattr fattr;
117 struct tcon_link *tlink;
118 struct cifs_tcon *tcon;
120 cFYI(1, "posix open %s", full_path);
122 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
123 if (presp_data == NULL)
126 tlink = cifs_sb_tlink(cifs_sb);
132 tcon = tlink_tcon(tlink);
133 mode &= ~current_umask();
135 posix_flags = cifs_posix_convert_flags(f_flags);
136 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
137 poplock, full_path, cifs_sb->local_nls,
138 cifs_sb->mnt_cifs_flags &
139 CIFS_MOUNT_MAP_SPECIAL_CHR);
140 cifs_put_tlink(tlink);
145 if (presp_data->Type == cpu_to_le32(-1))
146 goto posix_open_ret; /* open ok, caller does qpathinfo */
149 goto posix_open_ret; /* caller does not need info */
151 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
153 /* get new inode and set it up */
154 if (*pinode == NULL) {
155 cifs_fill_uniqueid(sb, &fattr);
156 *pinode = cifs_iget(sb, &fattr);
162 cifs_fattr_to_inode(*pinode, &fattr);
171 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
172 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
173 struct cifs_fid *fid, unsigned int xid)
178 int create_options = CREATE_NOT_DIR;
180 struct TCP_Server_Info *server = tcon->ses->server;
182 if (!server->ops->open)
185 desired_access = cifs_convert_flags(f_flags);
187 /*********************************************************************
188 * open flag mapping table:
190 * POSIX Flag CIFS Disposition
191 * ---------- ----------------
192 * O_CREAT FILE_OPEN_IF
193 * O_CREAT | O_EXCL FILE_CREATE
194 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
195 * O_TRUNC FILE_OVERWRITE
196 * none of the above FILE_OPEN
198 * Note that there is not a direct match between disposition
199 * FILE_SUPERSEDE (ie create whether or not file exists although
200 * O_CREAT | O_TRUNC is similar but truncates the existing
201 * file rather than creating a new file as FILE_SUPERSEDE does
202 * (which uses the attributes / metadata passed in on open call)
204 *? O_SYNC is a reasonable match to CIFS writethrough flag
205 *? and the read write flags match reasonably. O_LARGEFILE
206 *? is irrelevant because largefile support is always used
207 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
208 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
209 *********************************************************************/
211 disposition = cifs_get_disposition(f_flags);
213 /* BB pass O_SYNC flag through on file attributes .. BB */
215 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
219 if (backup_cred(cifs_sb))
220 create_options |= CREATE_OPEN_BACKUP_INTENT;
222 rc = server->ops->open(xid, tcon, full_path, disposition,
223 desired_access, create_options, fid, oplock, buf,
230 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
233 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
241 struct cifsFileInfo *
242 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
243 struct tcon_link *tlink, __u32 oplock)
245 struct dentry *dentry = file->f_path.dentry;
246 struct inode *inode = dentry->d_inode;
247 struct cifsInodeInfo *cinode = CIFS_I(inode);
248 struct cifsFileInfo *cfile;
249 struct cifs_fid_locks *fdlocks;
250 struct cifs_tcon *tcon = tlink_tcon(tlink);
252 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
256 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
262 INIT_LIST_HEAD(&fdlocks->locks);
263 fdlocks->cfile = cfile;
264 cfile->llist = fdlocks;
265 down_write(&cinode->lock_sem);
266 list_add(&fdlocks->llist, &cinode->llist);
267 up_write(&cinode->lock_sem);
270 cfile->pid = current->tgid;
271 cfile->uid = current_fsuid();
272 cfile->dentry = dget(dentry);
273 cfile->f_flags = file->f_flags;
274 cfile->invalidHandle = false;
275 cfile->tlink = cifs_get_tlink(tlink);
276 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
277 mutex_init(&cfile->fh_mutex);
279 spin_lock(&cifs_file_list_lock);
280 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE)
281 oplock = fid->pending_open->oplock;
282 list_del(&fid->pending_open->olist);
284 tlink_tcon(tlink)->ses->server->ops->set_fid(cfile, fid, oplock);
286 list_add(&cfile->tlist, &tcon->openFileList);
287 /* if readable file instance put first in list*/
288 if (file->f_mode & FMODE_READ)
289 list_add(&cfile->flist, &cinode->openFileList);
291 list_add_tail(&cfile->flist, &cinode->openFileList);
292 spin_unlock(&cifs_file_list_lock);
294 file->private_data = cfile;
298 struct cifsFileInfo *
299 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
301 spin_lock(&cifs_file_list_lock);
302 cifsFileInfo_get_locked(cifs_file);
303 spin_unlock(&cifs_file_list_lock);
308 * Release a reference on the file private data. This may involve closing
309 * the filehandle out on the server. Must be called without holding
310 * cifs_file_list_lock.
312 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
314 struct inode *inode = cifs_file->dentry->d_inode;
315 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
316 struct TCP_Server_Info *server = tcon->ses->server;
317 struct cifsInodeInfo *cifsi = CIFS_I(inode);
318 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
319 struct cifsLockInfo *li, *tmp;
321 struct cifs_pending_open open;
323 spin_lock(&cifs_file_list_lock);
324 if (--cifs_file->count > 0) {
325 spin_unlock(&cifs_file_list_lock);
329 if (server->ops->get_lease_key)
330 server->ops->get_lease_key(inode, &fid);
332 /* store open in pending opens to make sure we don't miss lease break */
333 cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
335 /* remove it from the lists */
336 list_del(&cifs_file->flist);
337 list_del(&cifs_file->tlist);
339 if (list_empty(&cifsi->openFileList)) {
340 cFYI(1, "closing last open instance for inode %p",
341 cifs_file->dentry->d_inode);
343 * In strict cache mode we need invalidate mapping on the last
344 * close because it may cause a error when we open this file
345 * again and get at least level II oplock.
347 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
348 CIFS_I(inode)->invalid_mapping = true;
349 cifs_set_oplock_level(cifsi, 0);
351 spin_unlock(&cifs_file_list_lock);
353 cancel_work_sync(&cifs_file->oplock_break);
355 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
356 struct TCP_Server_Info *server = tcon->ses->server;
360 if (server->ops->close)
361 server->ops->close(xid, tcon, &cifs_file->fid);
365 cifs_del_pending_open(&open);
368 * Delete any outstanding lock records. We'll lose them when the file
371 down_write(&cifsi->lock_sem);
372 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
373 list_del(&li->llist);
374 cifs_del_lock_waiters(li);
377 list_del(&cifs_file->llist->llist);
378 kfree(cifs_file->llist);
379 up_write(&cifsi->lock_sem);
381 cifs_put_tlink(cifs_file->tlink);
382 dput(cifs_file->dentry);
386 int cifs_open(struct inode *inode, struct file *file)
392 struct cifs_sb_info *cifs_sb;
393 struct TCP_Server_Info *server;
394 struct cifs_tcon *tcon;
395 struct tcon_link *tlink;
396 struct cifsFileInfo *cfile = NULL;
397 char *full_path = NULL;
398 bool posix_open_ok = false;
400 struct cifs_pending_open open;
404 cifs_sb = CIFS_SB(inode->i_sb);
405 tlink = cifs_sb_tlink(cifs_sb);
408 return PTR_ERR(tlink);
410 tcon = tlink_tcon(tlink);
411 server = tcon->ses->server;
413 full_path = build_path_from_dentry(file->f_path.dentry);
414 if (full_path == NULL) {
419 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
420 inode, file->f_flags, full_path);
427 if (!tcon->broken_posix_open && tcon->unix_ext &&
428 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
429 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
430 /* can not refresh inode info since size could be stale */
431 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
432 cifs_sb->mnt_file_mode /* ignored */,
433 file->f_flags, &oplock, &fid.netfid, xid);
435 cFYI(1, "posix open succeeded");
436 posix_open_ok = true;
437 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
438 if (tcon->ses->serverNOS)
439 cERROR(1, "server %s of type %s returned"
440 " unexpected error on SMB posix open"
441 ", disabling posix open support."
442 " Check if server update available.",
443 tcon->ses->serverName,
444 tcon->ses->serverNOS);
445 tcon->broken_posix_open = true;
446 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
447 (rc != -EOPNOTSUPP)) /* path not found or net err */
450 * Else fallthrough to retry open the old way on network i/o
455 if (server->ops->get_lease_key)
456 server->ops->get_lease_key(inode, &fid);
458 cifs_add_pending_open(&fid, tlink, &open);
460 if (!posix_open_ok) {
461 if (server->ops->get_lease_key)
462 server->ops->get_lease_key(inode, &fid);
464 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
465 file->f_flags, &oplock, &fid, xid);
467 cifs_del_pending_open(&open);
472 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
474 if (server->ops->close)
475 server->ops->close(xid, tcon, &fid);
476 cifs_del_pending_open(&open);
481 cifs_fscache_set_inode_cookie(inode, file);
483 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
485 * Time to set mode which we can not set earlier due to
486 * problems creating new read-only files.
488 struct cifs_unix_set_info_args args = {
489 .mode = inode->i_mode,
492 .ctime = NO_CHANGE_64,
493 .atime = NO_CHANGE_64,
494 .mtime = NO_CHANGE_64,
497 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
504 cifs_put_tlink(tlink);
508 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
511 * Try to reacquire byte range locks that were released when session
512 * to server was lost.
515 cifs_relock_file(struct cifsFileInfo *cfile)
517 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
518 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
519 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
522 /* we are going to update can_cache_brlcks here - need a write access */
523 down_write(&cinode->lock_sem);
524 if (cinode->can_cache_brlcks) {
525 /* can cache locks - no need to push them */
526 up_write(&cinode->lock_sem);
530 if (cap_unix(tcon->ses) &&
531 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
532 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
533 rc = cifs_push_posix_locks(cfile);
535 rc = tcon->ses->server->ops->push_mand_locks(cfile);
537 up_write(&cinode->lock_sem);
542 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
547 struct cifs_sb_info *cifs_sb;
548 struct cifs_tcon *tcon;
549 struct TCP_Server_Info *server;
550 struct cifsInodeInfo *cinode;
552 char *full_path = NULL;
554 int disposition = FILE_OPEN;
555 int create_options = CREATE_NOT_DIR;
559 mutex_lock(&cfile->fh_mutex);
560 if (!cfile->invalidHandle) {
561 mutex_unlock(&cfile->fh_mutex);
567 inode = cfile->dentry->d_inode;
568 cifs_sb = CIFS_SB(inode->i_sb);
569 tcon = tlink_tcon(cfile->tlink);
570 server = tcon->ses->server;
573 * Can not grab rename sem here because various ops, including those
574 * that already have the rename sem can end up causing writepage to get
575 * called and if the server was down that means we end up here, and we
576 * can never tell if the caller already has the rename_sem.
578 full_path = build_path_from_dentry(cfile->dentry);
579 if (full_path == NULL) {
581 mutex_unlock(&cfile->fh_mutex);
586 cFYI(1, "inode = 0x%p file flags 0x%x for %s", inode, cfile->f_flags,
589 if (tcon->ses->server->oplocks)
594 if (tcon->unix_ext && cap_unix(tcon->ses) &&
595 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
596 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
598 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
599 * original open. Must mask them off for a reopen.
601 unsigned int oflags = cfile->f_flags &
602 ~(O_CREAT | O_EXCL | O_TRUNC);
604 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
605 cifs_sb->mnt_file_mode /* ignored */,
606 oflags, &oplock, &fid.netfid, xid);
608 cFYI(1, "posix reopen succeeded");
612 * fallthrough to retry open the old way on errors, especially
613 * in the reconnect path it is important to retry hard
617 desired_access = cifs_convert_flags(cfile->f_flags);
619 if (backup_cred(cifs_sb))
620 create_options |= CREATE_OPEN_BACKUP_INTENT;
622 if (server->ops->get_lease_key)
623 server->ops->get_lease_key(inode, &fid);
626 * Can not refresh inode by passing in file_info buf to be returned by
627 * CIFSSMBOpen and then calling get_inode_info with returned buf since
628 * file might have write behind data that needs to be flushed and server
629 * version of file size can be stale. If we knew for sure that inode was
630 * not dirty locally we could do this.
632 rc = server->ops->open(xid, tcon, full_path, disposition,
633 desired_access, create_options, &fid, &oplock,
636 mutex_unlock(&cfile->fh_mutex);
637 cFYI(1, "cifs_reopen returned 0x%x", rc);
638 cFYI(1, "oplock: %d", oplock);
639 goto reopen_error_exit;
643 cfile->invalidHandle = false;
644 mutex_unlock(&cfile->fh_mutex);
645 cinode = CIFS_I(inode);
648 rc = filemap_write_and_wait(inode->i_mapping);
649 mapping_set_error(inode->i_mapping, rc);
652 rc = cifs_get_inode_info_unix(&inode, full_path,
655 rc = cifs_get_inode_info(&inode, full_path, NULL,
656 inode->i_sb, xid, NULL);
659 * Else we are writing out data to server already and could deadlock if
660 * we tried to flush data, and since we do not know if we have data that
661 * would invalidate the current end of file on the server we can not go
662 * to the server to get the new inode info.
665 server->ops->set_fid(cfile, &fid, oplock);
666 cifs_relock_file(cfile);
674 int cifs_close(struct inode *inode, struct file *file)
676 if (file->private_data != NULL) {
677 cifsFileInfo_put(file->private_data);
678 file->private_data = NULL;
681 /* return code from the ->release op is always ignored */
685 int cifs_closedir(struct inode *inode, struct file *file)
689 struct cifsFileInfo *cfile = file->private_data;
690 struct cifs_tcon *tcon;
691 struct TCP_Server_Info *server;
694 cFYI(1, "Closedir inode = 0x%p", inode);
700 tcon = tlink_tcon(cfile->tlink);
701 server = tcon->ses->server;
703 cFYI(1, "Freeing private data in close dir");
704 spin_lock(&cifs_file_list_lock);
705 if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
706 cfile->invalidHandle = true;
707 spin_unlock(&cifs_file_list_lock);
708 if (server->ops->close_dir)
709 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
712 cFYI(1, "Closing uncompleted readdir with rc %d", rc);
713 /* not much we can do if it fails anyway, ignore rc */
716 spin_unlock(&cifs_file_list_lock);
718 buf = cfile->srch_inf.ntwrk_buf_start;
720 cFYI(1, "closedir free smb buf in srch struct");
721 cfile->srch_inf.ntwrk_buf_start = NULL;
722 if (cfile->srch_inf.smallBuf)
723 cifs_small_buf_release(buf);
725 cifs_buf_release(buf);
728 cifs_put_tlink(cfile->tlink);
729 kfree(file->private_data);
730 file->private_data = NULL;
731 /* BB can we lock the filestruct while this is going on? */
736 static struct cifsLockInfo *
737 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
739 struct cifsLockInfo *lock =
740 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
743 lock->offset = offset;
744 lock->length = length;
746 lock->pid = current->tgid;
747 INIT_LIST_HEAD(&lock->blist);
748 init_waitqueue_head(&lock->block_q);
753 cifs_del_lock_waiters(struct cifsLockInfo *lock)
755 struct cifsLockInfo *li, *tmp;
756 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
757 list_del_init(&li->blist);
758 wake_up(&li->block_q);
763 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
764 __u64 length, __u8 type, struct cifsFileInfo *cfile,
765 struct cifsLockInfo **conf_lock, bool rw_check)
767 struct cifsLockInfo *li;
768 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
769 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
771 list_for_each_entry(li, &fdlocks->locks, llist) {
772 if (offset + length <= li->offset ||
773 offset >= li->offset + li->length)
775 if (rw_check && server->ops->compare_fids(cfile, cur_cfile) &&
776 current->tgid == li->pid)
778 if ((type & server->vals->shared_lock_type) &&
779 ((server->ops->compare_fids(cfile, cur_cfile) &&
780 current->tgid == li->pid) || type == li->type))
790 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
791 __u8 type, struct cifsLockInfo **conf_lock,
795 struct cifs_fid_locks *cur;
796 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
798 list_for_each_entry(cur, &cinode->llist, llist) {
799 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
800 cfile, conf_lock, rw_check);
809 * Check if there is another lock that prevents us to set the lock (mandatory
810 * style). If such a lock exists, update the flock structure with its
811 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
812 * or leave it the same if we can't. Returns 0 if we don't need to request to
813 * the server or 1 otherwise.
816 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
817 __u8 type, struct file_lock *flock)
820 struct cifsLockInfo *conf_lock;
821 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
822 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
825 down_read(&cinode->lock_sem);
827 exist = cifs_find_lock_conflict(cfile, offset, length, type,
830 flock->fl_start = conf_lock->offset;
831 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
832 flock->fl_pid = conf_lock->pid;
833 if (conf_lock->type & server->vals->shared_lock_type)
834 flock->fl_type = F_RDLCK;
836 flock->fl_type = F_WRLCK;
837 } else if (!cinode->can_cache_brlcks)
840 flock->fl_type = F_UNLCK;
842 up_read(&cinode->lock_sem);
847 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
849 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
850 down_write(&cinode->lock_sem);
851 list_add_tail(&lock->llist, &cfile->llist->locks);
852 up_write(&cinode->lock_sem);
856 * Set the byte-range lock (mandatory style). Returns:
857 * 1) 0, if we set the lock and don't need to request to the server;
858 * 2) 1, if no locks prevent us but we need to request to the server;
859 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
862 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
865 struct cifsLockInfo *conf_lock;
866 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
872 down_write(&cinode->lock_sem);
874 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
875 lock->type, &conf_lock, false);
876 if (!exist && cinode->can_cache_brlcks) {
877 list_add_tail(&lock->llist, &cfile->llist->locks);
878 up_write(&cinode->lock_sem);
887 list_add_tail(&lock->blist, &conf_lock->blist);
888 up_write(&cinode->lock_sem);
889 rc = wait_event_interruptible(lock->block_q,
890 (lock->blist.prev == &lock->blist) &&
891 (lock->blist.next == &lock->blist));
894 down_write(&cinode->lock_sem);
895 list_del_init(&lock->blist);
898 up_write(&cinode->lock_sem);
903 * Check if there is another lock that prevents us to set the lock (posix
904 * style). If such a lock exists, update the flock structure with its
905 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
906 * or leave it the same if we can't. Returns 0 if we don't need to request to
907 * the server or 1 otherwise.
910 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
913 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
914 unsigned char saved_type = flock->fl_type;
916 if ((flock->fl_flags & FL_POSIX) == 0)
919 down_read(&cinode->lock_sem);
920 posix_test_lock(file, flock);
922 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
923 flock->fl_type = saved_type;
927 up_read(&cinode->lock_sem);
932 * Set the byte-range lock (posix style). Returns:
933 * 1) 0, if we set the lock and don't need to request to the server;
934 * 2) 1, if we need to request to the server;
935 * 3) <0, if the error occurs while setting the lock.
938 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
940 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
943 if ((flock->fl_flags & FL_POSIX) == 0)
947 down_write(&cinode->lock_sem);
948 if (!cinode->can_cache_brlcks) {
949 up_write(&cinode->lock_sem);
953 rc = posix_lock_file(file, flock, NULL);
954 up_write(&cinode->lock_sem);
955 if (rc == FILE_LOCK_DEFERRED) {
956 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
959 locks_delete_block(flock);
965 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
968 int rc = 0, stored_rc;
969 struct cifsLockInfo *li, *tmp;
970 struct cifs_tcon *tcon;
971 unsigned int num, max_num, max_buf;
972 LOCKING_ANDX_RANGE *buf, *cur;
973 int types[] = {LOCKING_ANDX_LARGE_FILES,
974 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
978 tcon = tlink_tcon(cfile->tlink);
981 * Accessing maxBuf is racy with cifs_reconnect - need to store value
982 * and check it for zero before using.
984 max_buf = tcon->ses->server->maxBuf;
990 max_num = (max_buf - sizeof(struct smb_hdr)) /
991 sizeof(LOCKING_ANDX_RANGE);
992 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
998 for (i = 0; i < 2; i++) {
1001 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1002 if (li->type != types[i])
1004 cur->Pid = cpu_to_le16(li->pid);
1005 cur->LengthLow = cpu_to_le32((u32)li->length);
1006 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1007 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1008 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1009 if (++num == max_num) {
1010 stored_rc = cifs_lockv(xid, tcon,
1012 (__u8)li->type, 0, num,
1023 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1024 (__u8)types[i], 0, num, buf);
1035 /* copied from fs/locks.c with a name change */
1036 #define cifs_for_each_lock(inode, lockp) \
1037 for (lockp = &inode->i_flock; *lockp != NULL; \
1038 lockp = &(*lockp)->fl_next)
1040 struct lock_to_push {
1041 struct list_head llist;
1050 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1052 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1053 struct file_lock *flock, **before;
1054 unsigned int count = 0, i = 0;
1055 int rc = 0, xid, type;
1056 struct list_head locks_to_send, *el;
1057 struct lock_to_push *lck, *tmp;
1063 cifs_for_each_lock(cfile->dentry->d_inode, before) {
1064 if ((*before)->fl_flags & FL_POSIX)
1069 INIT_LIST_HEAD(&locks_to_send);
1072 * Allocating count locks is enough because no FL_POSIX locks can be
1073 * added to the list while we are holding cinode->lock_sem that
1074 * protects locking operations of this inode.
1076 for (; i < count; i++) {
1077 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1082 list_add_tail(&lck->llist, &locks_to_send);
1085 el = locks_to_send.next;
1087 cifs_for_each_lock(cfile->dentry->d_inode, before) {
1089 if ((flock->fl_flags & FL_POSIX) == 0)
1091 if (el == &locks_to_send) {
1093 * The list ended. We don't have enough allocated
1094 * structures - something is really wrong.
1096 cERROR(1, "Can't push all brlocks!");
1099 length = 1 + flock->fl_end - flock->fl_start;
1100 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1104 lck = list_entry(el, struct lock_to_push, llist);
1105 lck->pid = flock->fl_pid;
1106 lck->netfid = cfile->fid.netfid;
1107 lck->length = length;
1109 lck->offset = flock->fl_start;
1114 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1117 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1118 lck->offset, lck->length, NULL,
1122 list_del(&lck->llist);
1130 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1131 list_del(&lck->llist);
1138 cifs_push_locks(struct cifsFileInfo *cfile)
1140 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1141 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1142 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1145 /* we are going to update can_cache_brlcks here - need a write access */
1146 down_write(&cinode->lock_sem);
1147 if (!cinode->can_cache_brlcks) {
1148 up_write(&cinode->lock_sem);
1152 if (cap_unix(tcon->ses) &&
1153 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1154 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1155 rc = cifs_push_posix_locks(cfile);
1157 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1159 cinode->can_cache_brlcks = false;
1160 up_write(&cinode->lock_sem);
1165 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1166 bool *wait_flag, struct TCP_Server_Info *server)
1168 if (flock->fl_flags & FL_POSIX)
1170 if (flock->fl_flags & FL_FLOCK)
1172 if (flock->fl_flags & FL_SLEEP) {
1173 cFYI(1, "Blocking lock");
1176 if (flock->fl_flags & FL_ACCESS)
1177 cFYI(1, "Process suspended by mandatory locking - "
1178 "not implemented yet");
1179 if (flock->fl_flags & FL_LEASE)
1180 cFYI(1, "Lease on file - not implemented yet");
1181 if (flock->fl_flags &
1182 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1183 FL_ACCESS | FL_LEASE | FL_CLOSE)))
1184 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1186 *type = server->vals->large_lock_type;
1187 if (flock->fl_type == F_WRLCK) {
1188 cFYI(1, "F_WRLCK ");
1189 *type |= server->vals->exclusive_lock_type;
1191 } else if (flock->fl_type == F_UNLCK) {
1193 *type |= server->vals->unlock_lock_type;
1195 /* Check if unlock includes more than one lock range */
1196 } else if (flock->fl_type == F_RDLCK) {
1198 *type |= server->vals->shared_lock_type;
1200 } else if (flock->fl_type == F_EXLCK) {
1202 *type |= server->vals->exclusive_lock_type;
1204 } else if (flock->fl_type == F_SHLCK) {
1206 *type |= server->vals->shared_lock_type;
1209 cFYI(1, "Unknown type of lock");
1213 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1214 bool wait_flag, bool posix_lck, unsigned int xid)
1217 __u64 length = 1 + flock->fl_end - flock->fl_start;
1218 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1219 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1220 struct TCP_Server_Info *server = tcon->ses->server;
1221 __u16 netfid = cfile->fid.netfid;
1224 int posix_lock_type;
1226 rc = cifs_posix_lock_test(file, flock);
1230 if (type & server->vals->shared_lock_type)
1231 posix_lock_type = CIFS_RDLCK;
1233 posix_lock_type = CIFS_WRLCK;
1234 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1235 flock->fl_start, length, flock,
1236 posix_lock_type, wait_flag);
1240 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1244 /* BB we could chain these into one lock request BB */
1245 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1248 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1250 flock->fl_type = F_UNLCK;
1252 cERROR(1, "Error unlocking previously locked "
1253 "range %d during test of lock", rc);
1257 if (type & server->vals->shared_lock_type) {
1258 flock->fl_type = F_WRLCK;
1262 type &= ~server->vals->exclusive_lock_type;
1264 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1265 type | server->vals->shared_lock_type,
1268 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1269 type | server->vals->shared_lock_type, 0, 1, false);
1270 flock->fl_type = F_RDLCK;
1272 cERROR(1, "Error unlocking previously locked "
1273 "range %d during test of lock", rc);
1275 flock->fl_type = F_WRLCK;
1281 cifs_move_llist(struct list_head *source, struct list_head *dest)
1283 struct list_head *li, *tmp;
1284 list_for_each_safe(li, tmp, source)
1285 list_move(li, dest);
1289 cifs_free_llist(struct list_head *llist)
1291 struct cifsLockInfo *li, *tmp;
1292 list_for_each_entry_safe(li, tmp, llist, llist) {
1293 cifs_del_lock_waiters(li);
1294 list_del(&li->llist);
1300 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1303 int rc = 0, stored_rc;
1304 int types[] = {LOCKING_ANDX_LARGE_FILES,
1305 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1307 unsigned int max_num, num, max_buf;
1308 LOCKING_ANDX_RANGE *buf, *cur;
1309 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1310 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1311 struct cifsLockInfo *li, *tmp;
1312 __u64 length = 1 + flock->fl_end - flock->fl_start;
1313 struct list_head tmp_llist;
1315 INIT_LIST_HEAD(&tmp_llist);
1318 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1319 * and check it for zero before using.
1321 max_buf = tcon->ses->server->maxBuf;
1325 max_num = (max_buf - sizeof(struct smb_hdr)) /
1326 sizeof(LOCKING_ANDX_RANGE);
1327 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1331 down_write(&cinode->lock_sem);
1332 for (i = 0; i < 2; i++) {
1335 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1336 if (flock->fl_start > li->offset ||
1337 (flock->fl_start + length) <
1338 (li->offset + li->length))
1340 if (current->tgid != li->pid)
1342 if (types[i] != li->type)
1344 if (cinode->can_cache_brlcks) {
1346 * We can cache brlock requests - simply remove
1347 * a lock from the file's list.
1349 list_del(&li->llist);
1350 cifs_del_lock_waiters(li);
1354 cur->Pid = cpu_to_le16(li->pid);
1355 cur->LengthLow = cpu_to_le32((u32)li->length);
1356 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1357 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1358 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1360 * We need to save a lock here to let us add it again to
1361 * the file's list if the unlock range request fails on
1364 list_move(&li->llist, &tmp_llist);
1365 if (++num == max_num) {
1366 stored_rc = cifs_lockv(xid, tcon,
1368 li->type, num, 0, buf);
1371 * We failed on the unlock range
1372 * request - add all locks from the tmp
1373 * list to the head of the file's list.
1375 cifs_move_llist(&tmp_llist,
1376 &cfile->llist->locks);
1380 * The unlock range request succeed -
1381 * free the tmp list.
1383 cifs_free_llist(&tmp_llist);
1390 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1391 types[i], num, 0, buf);
1393 cifs_move_llist(&tmp_llist,
1394 &cfile->llist->locks);
1397 cifs_free_llist(&tmp_llist);
1401 up_write(&cinode->lock_sem);
1407 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1408 bool wait_flag, bool posix_lck, int lock, int unlock,
1412 __u64 length = 1 + flock->fl_end - flock->fl_start;
1413 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1414 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1415 struct TCP_Server_Info *server = tcon->ses->server;
1418 int posix_lock_type;
1420 rc = cifs_posix_lock_set(file, flock);
1424 if (type & server->vals->shared_lock_type)
1425 posix_lock_type = CIFS_RDLCK;
1427 posix_lock_type = CIFS_WRLCK;
1430 posix_lock_type = CIFS_UNLCK;
1432 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1433 current->tgid, flock->fl_start, length,
1434 NULL, posix_lock_type, wait_flag);
1439 struct cifsLockInfo *lock;
1441 lock = cifs_lock_init(flock->fl_start, length, type);
1445 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1451 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1452 type, 1, 0, wait_flag);
1458 cifs_lock_add(cfile, lock);
1460 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1463 if (flock->fl_flags & FL_POSIX)
1464 posix_lock_file_wait(file, flock);
1468 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1471 int lock = 0, unlock = 0;
1472 bool wait_flag = false;
1473 bool posix_lck = false;
1474 struct cifs_sb_info *cifs_sb;
1475 struct cifs_tcon *tcon;
1476 struct cifsInodeInfo *cinode;
1477 struct cifsFileInfo *cfile;
1484 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1485 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1486 flock->fl_start, flock->fl_end);
1488 cfile = (struct cifsFileInfo *)file->private_data;
1489 tcon = tlink_tcon(cfile->tlink);
1491 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1494 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1495 netfid = cfile->fid.netfid;
1496 cinode = CIFS_I(file->f_path.dentry->d_inode);
1498 if (cap_unix(tcon->ses) &&
1499 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1500 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1503 * BB add code here to normalize offset and length to account for
1504 * negative length which we can not accept over the wire.
1506 if (IS_GETLK(cmd)) {
1507 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1512 if (!lock && !unlock) {
1514 * if no lock or unlock then nothing to do since we do not
1521 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1528 * update the file size (if needed) after a write. Should be called with
1529 * the inode->i_lock held
1532 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1533 unsigned int bytes_written)
1535 loff_t end_of_write = offset + bytes_written;
1537 if (end_of_write > cifsi->server_eof)
1538 cifsi->server_eof = end_of_write;
1542 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1543 size_t write_size, loff_t *offset)
1546 unsigned int bytes_written = 0;
1547 unsigned int total_written;
1548 struct cifs_sb_info *cifs_sb;
1549 struct cifs_tcon *tcon;
1550 struct TCP_Server_Info *server;
1552 struct dentry *dentry = open_file->dentry;
1553 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1554 struct cifs_io_parms io_parms;
1556 cifs_sb = CIFS_SB(dentry->d_sb);
1558 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1559 *offset, dentry->d_name.name);
1561 tcon = tlink_tcon(open_file->tlink);
1562 server = tcon->ses->server;
1564 if (!server->ops->sync_write)
1569 for (total_written = 0; write_size > total_written;
1570 total_written += bytes_written) {
1572 while (rc == -EAGAIN) {
1576 if (open_file->invalidHandle) {
1577 /* we could deadlock if we called
1578 filemap_fdatawait from here so tell
1579 reopen_file not to flush data to
1581 rc = cifs_reopen_file(open_file, false);
1586 len = min((size_t)cifs_sb->wsize,
1587 write_size - total_written);
1588 /* iov[0] is reserved for smb header */
1589 iov[1].iov_base = (char *)write_data + total_written;
1590 iov[1].iov_len = len;
1592 io_parms.tcon = tcon;
1593 io_parms.offset = *offset;
1594 io_parms.length = len;
1595 rc = server->ops->sync_write(xid, open_file, &io_parms,
1596 &bytes_written, iov, 1);
1598 if (rc || (bytes_written == 0)) {
1606 spin_lock(&dentry->d_inode->i_lock);
1607 cifs_update_eof(cifsi, *offset, bytes_written);
1608 spin_unlock(&dentry->d_inode->i_lock);
1609 *offset += bytes_written;
1613 cifs_stats_bytes_written(tcon, total_written);
1615 if (total_written > 0) {
1616 spin_lock(&dentry->d_inode->i_lock);
1617 if (*offset > dentry->d_inode->i_size)
1618 i_size_write(dentry->d_inode, *offset);
1619 spin_unlock(&dentry->d_inode->i_lock);
1621 mark_inode_dirty_sync(dentry->d_inode);
1623 return total_written;
1626 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1629 struct cifsFileInfo *open_file = NULL;
1630 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1632 /* only filter by fsuid on multiuser mounts */
1633 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1636 spin_lock(&cifs_file_list_lock);
1637 /* we could simply get the first_list_entry since write-only entries
1638 are always at the end of the list but since the first entry might
1639 have a close pending, we go through the whole list */
1640 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1641 if (fsuid_only && open_file->uid != current_fsuid())
1643 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1644 if (!open_file->invalidHandle) {
1645 /* found a good file */
1646 /* lock it so it will not be closed on us */
1647 cifsFileInfo_get_locked(open_file);
1648 spin_unlock(&cifs_file_list_lock);
1650 } /* else might as well continue, and look for
1651 another, or simply have the caller reopen it
1652 again rather than trying to fix this handle */
1653 } else /* write only file */
1654 break; /* write only files are last so must be done */
1656 spin_unlock(&cifs_file_list_lock);
1660 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1663 struct cifsFileInfo *open_file, *inv_file = NULL;
1664 struct cifs_sb_info *cifs_sb;
1665 bool any_available = false;
1667 unsigned int refind = 0;
1669 /* Having a null inode here (because mapping->host was set to zero by
1670 the VFS or MM) should not happen but we had reports of on oops (due to
1671 it being zero) during stress testcases so we need to check for it */
1673 if (cifs_inode == NULL) {
1674 cERROR(1, "Null inode passed to cifs_writeable_file");
1679 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1681 /* only filter by fsuid on multiuser mounts */
1682 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1685 spin_lock(&cifs_file_list_lock);
1687 if (refind > MAX_REOPEN_ATT) {
1688 spin_unlock(&cifs_file_list_lock);
1691 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1692 if (!any_available && open_file->pid != current->tgid)
1694 if (fsuid_only && open_file->uid != current_fsuid())
1696 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1697 if (!open_file->invalidHandle) {
1698 /* found a good writable file */
1699 cifsFileInfo_get_locked(open_file);
1700 spin_unlock(&cifs_file_list_lock);
1704 inv_file = open_file;
1708 /* couldn't find useable FH with same pid, try any available */
1709 if (!any_available) {
1710 any_available = true;
1711 goto refind_writable;
1715 any_available = false;
1716 cifsFileInfo_get_locked(inv_file);
1719 spin_unlock(&cifs_file_list_lock);
1722 rc = cifs_reopen_file(inv_file, false);
1726 spin_lock(&cifs_file_list_lock);
1727 list_move_tail(&inv_file->flist,
1728 &cifs_inode->openFileList);
1729 spin_unlock(&cifs_file_list_lock);
1730 cifsFileInfo_put(inv_file);
1731 spin_lock(&cifs_file_list_lock);
1733 goto refind_writable;
1740 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1742 struct address_space *mapping = page->mapping;
1743 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1746 int bytes_written = 0;
1747 struct inode *inode;
1748 struct cifsFileInfo *open_file;
1750 if (!mapping || !mapping->host)
1753 inode = page->mapping->host;
1755 offset += (loff_t)from;
1756 write_data = kmap(page);
1759 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1764 /* racing with truncate? */
1765 if (offset > mapping->host->i_size) {
1767 return 0; /* don't care */
1770 /* check to make sure that we are not extending the file */
1771 if (mapping->host->i_size - offset < (loff_t)to)
1772 to = (unsigned)(mapping->host->i_size - offset);
1774 open_file = find_writable_file(CIFS_I(mapping->host), false);
1776 bytes_written = cifs_write(open_file, open_file->pid,
1777 write_data, to - from, &offset);
1778 cifsFileInfo_put(open_file);
1779 /* Does mm or vfs already set times? */
1780 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1781 if ((bytes_written > 0) && (offset))
1783 else if (bytes_written < 0)
1786 cFYI(1, "No writeable filehandles for inode");
1794 static int cifs_writepages(struct address_space *mapping,
1795 struct writeback_control *wbc)
1797 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1798 bool done = false, scanned = false, range_whole = false;
1800 struct cifs_writedata *wdata;
1801 struct TCP_Server_Info *server;
1806 * If wsize is smaller than the page cache size, default to writing
1807 * one page at a time via cifs_writepage
1809 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1810 return generic_writepages(mapping, wbc);
1812 if (wbc->range_cyclic) {
1813 index = mapping->writeback_index; /* Start from prev offset */
1816 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1817 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1818 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1823 while (!done && index <= end) {
1824 unsigned int i, nr_pages, found_pages;
1825 pgoff_t next = 0, tofind;
1826 struct page **pages;
1828 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1831 wdata = cifs_writedata_alloc((unsigned int)tofind,
1832 cifs_writev_complete);
1839 * find_get_pages_tag seems to return a max of 256 on each
1840 * iteration, so we must call it several times in order to
1841 * fill the array or the wsize is effectively limited to
1842 * 256 * PAGE_CACHE_SIZE.
1845 pages = wdata->pages;
1847 nr_pages = find_get_pages_tag(mapping, &index,
1848 PAGECACHE_TAG_DIRTY,
1850 found_pages += nr_pages;
1853 } while (nr_pages && tofind && index <= end);
1855 if (found_pages == 0) {
1856 kref_put(&wdata->refcount, cifs_writedata_release);
1861 for (i = 0; i < found_pages; i++) {
1862 page = wdata->pages[i];
1864 * At this point we hold neither mapping->tree_lock nor
1865 * lock on the page itself: the page may be truncated or
1866 * invalidated (changing page->mapping to NULL), or even
1867 * swizzled back from swapper_space to tmpfs file
1873 else if (!trylock_page(page))
1876 if (unlikely(page->mapping != mapping)) {
1881 if (!wbc->range_cyclic && page->index > end) {
1887 if (next && (page->index != next)) {
1888 /* Not next consecutive page */
1893 if (wbc->sync_mode != WB_SYNC_NONE)
1894 wait_on_page_writeback(page);
1896 if (PageWriteback(page) ||
1897 !clear_page_dirty_for_io(page)) {
1903 * This actually clears the dirty bit in the radix tree.
1904 * See cifs_writepage() for more commentary.
1906 set_page_writeback(page);
1908 if (page_offset(page) >= i_size_read(mapping->host)) {
1911 end_page_writeback(page);
1915 wdata->pages[i] = page;
1916 next = page->index + 1;
1920 /* reset index to refind any pages skipped */
1922 index = wdata->pages[0]->index + 1;
1924 /* put any pages we aren't going to use */
1925 for (i = nr_pages; i < found_pages; i++) {
1926 page_cache_release(wdata->pages[i]);
1927 wdata->pages[i] = NULL;
1930 /* nothing to write? */
1931 if (nr_pages == 0) {
1932 kref_put(&wdata->refcount, cifs_writedata_release);
1936 wdata->sync_mode = wbc->sync_mode;
1937 wdata->nr_pages = nr_pages;
1938 wdata->offset = page_offset(wdata->pages[0]);
1939 wdata->pagesz = PAGE_CACHE_SIZE;
1941 min(i_size_read(mapping->host) -
1942 page_offset(wdata->pages[nr_pages - 1]),
1943 (loff_t)PAGE_CACHE_SIZE);
1944 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) +
1948 if (wdata->cfile != NULL)
1949 cifsFileInfo_put(wdata->cfile);
1950 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1952 if (!wdata->cfile) {
1953 cERROR(1, "No writable handles for inode");
1957 wdata->pid = wdata->cfile->pid;
1958 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
1959 rc = server->ops->async_writev(wdata);
1960 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1962 for (i = 0; i < nr_pages; ++i)
1963 unlock_page(wdata->pages[i]);
1965 /* send failure -- clean up the mess */
1967 for (i = 0; i < nr_pages; ++i) {
1969 redirty_page_for_writepage(wbc,
1972 SetPageError(wdata->pages[i]);
1973 end_page_writeback(wdata->pages[i]);
1974 page_cache_release(wdata->pages[i]);
1977 mapping_set_error(mapping, rc);
1979 kref_put(&wdata->refcount, cifs_writedata_release);
1981 wbc->nr_to_write -= nr_pages;
1982 if (wbc->nr_to_write <= 0)
1988 if (!scanned && !done) {
1990 * We hit the last page and there is more work to be done: wrap
1991 * back to the start of the file
1998 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1999 mapping->writeback_index = index;
2005 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2011 /* BB add check for wbc flags */
2012 page_cache_get(page);
2013 if (!PageUptodate(page))
2014 cFYI(1, "ppw - page not up to date");
2017 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2019 * A writepage() implementation always needs to do either this,
2020 * or re-dirty the page with "redirty_page_for_writepage()" in
2021 * the case of a failure.
2023 * Just unlocking the page will cause the radix tree tag-bits
2024 * to fail to update with the state of the page correctly.
2026 set_page_writeback(page);
2028 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
2029 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2031 else if (rc == -EAGAIN)
2032 redirty_page_for_writepage(wbc, page);
2036 SetPageUptodate(page);
2037 end_page_writeback(page);
2038 page_cache_release(page);
2043 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2045 int rc = cifs_writepage_locked(page, wbc);
2050 static int cifs_write_end(struct file *file, struct address_space *mapping,
2051 loff_t pos, unsigned len, unsigned copied,
2052 struct page *page, void *fsdata)
2055 struct inode *inode = mapping->host;
2056 struct cifsFileInfo *cfile = file->private_data;
2057 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2060 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2063 pid = current->tgid;
2065 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
2068 if (PageChecked(page)) {
2070 SetPageUptodate(page);
2071 ClearPageChecked(page);
2072 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
2073 SetPageUptodate(page);
2075 if (!PageUptodate(page)) {
2077 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
2081 /* this is probably better than directly calling
2082 partialpage_write since in this function the file handle is
2083 known which we might as well leverage */
2084 /* BB check if anything else missing out of ppw
2085 such as updating last write time */
2086 page_data = kmap(page);
2087 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2088 /* if (rc < 0) should we set writebehind rc? */
2095 set_page_dirty(page);
2099 spin_lock(&inode->i_lock);
2100 if (pos > inode->i_size)
2101 i_size_write(inode, pos);
2102 spin_unlock(&inode->i_lock);
2106 page_cache_release(page);
2111 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2116 struct cifs_tcon *tcon;
2117 struct TCP_Server_Info *server;
2118 struct cifsFileInfo *smbfile = file->private_data;
2119 struct inode *inode = file->f_path.dentry->d_inode;
2120 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2122 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2125 mutex_lock(&inode->i_mutex);
2129 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2130 file->f_path.dentry->d_name.name, datasync);
2132 if (!CIFS_I(inode)->clientCanCacheRead) {
2133 rc = cifs_invalidate_mapping(inode);
2135 cFYI(1, "rc: %d during invalidate phase", rc);
2136 rc = 0; /* don't care about it in fsync */
2140 tcon = tlink_tcon(smbfile->tlink);
2141 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2142 server = tcon->ses->server;
2143 if (server->ops->flush)
2144 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2150 mutex_unlock(&inode->i_mutex);
2154 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2158 struct cifs_tcon *tcon;
2159 struct TCP_Server_Info *server;
2160 struct cifsFileInfo *smbfile = file->private_data;
2161 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2162 struct inode *inode = file->f_mapping->host;
2164 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2167 mutex_lock(&inode->i_mutex);
2171 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2172 file->f_path.dentry->d_name.name, datasync);
2174 tcon = tlink_tcon(smbfile->tlink);
2175 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2176 server = tcon->ses->server;
2177 if (server->ops->flush)
2178 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2184 mutex_unlock(&inode->i_mutex);
2189 * As file closes, flush all cached write data for this inode checking
2190 * for write behind errors.
2192 int cifs_flush(struct file *file, fl_owner_t id)
2194 struct inode *inode = file->f_path.dentry->d_inode;
2197 if (file->f_mode & FMODE_WRITE)
2198 rc = filemap_write_and_wait(inode->i_mapping);
2200 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2206 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2211 for (i = 0; i < num_pages; i++) {
2212 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2215 * save number of pages we have already allocated and
2216 * return with ENOMEM error
2225 for (i = 0; i < num_pages; i++)
2232 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2237 clen = min_t(const size_t, len, wsize);
2238 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2247 cifs_uncached_writev_complete(struct work_struct *work)
2250 struct cifs_writedata *wdata = container_of(work,
2251 struct cifs_writedata, work);
2252 struct inode *inode = wdata->cfile->dentry->d_inode;
2253 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2255 spin_lock(&inode->i_lock);
2256 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2257 if (cifsi->server_eof > inode->i_size)
2258 i_size_write(inode, cifsi->server_eof);
2259 spin_unlock(&inode->i_lock);
2261 complete(&wdata->done);
2263 if (wdata->result != -EAGAIN) {
2264 for (i = 0; i < wdata->nr_pages; i++)
2265 put_page(wdata->pages[i]);
2268 kref_put(&wdata->refcount, cifs_writedata_release);
2271 /* attempt to send write to server, retry on any -EAGAIN errors */
2273 cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2276 struct TCP_Server_Info *server;
2278 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2281 if (wdata->cfile->invalidHandle) {
2282 rc = cifs_reopen_file(wdata->cfile, false);
2286 rc = server->ops->async_writev(wdata);
2287 } while (rc == -EAGAIN);
2293 cifs_iovec_write(struct file *file, const struct iovec *iov,
2294 unsigned long nr_segs, loff_t *poffset)
2296 unsigned long nr_pages, i;
2297 size_t copied, len, cur_len;
2298 ssize_t total_written = 0;
2301 struct cifsFileInfo *open_file;
2302 struct cifs_tcon *tcon;
2303 struct cifs_sb_info *cifs_sb;
2304 struct cifs_writedata *wdata, *tmp;
2305 struct list_head wdata_list;
2309 len = iov_length(iov, nr_segs);
2313 rc = generic_write_checks(file, poffset, &len, 0);
2317 INIT_LIST_HEAD(&wdata_list);
2318 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2319 open_file = file->private_data;
2320 tcon = tlink_tcon(open_file->tlink);
2322 if (!tcon->ses->server->ops->async_writev)
2327 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2328 pid = open_file->pid;
2330 pid = current->tgid;
2332 iov_iter_init(&it, iov, nr_segs, len, 0);
2336 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2337 wdata = cifs_writedata_alloc(nr_pages,
2338 cifs_uncached_writev_complete);
2344 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2351 for (i = 0; i < nr_pages; i++) {
2352 copied = min_t(const size_t, cur_len, PAGE_SIZE);
2353 copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2356 iov_iter_advance(&it, copied);
2358 cur_len = save_len - cur_len;
2360 wdata->sync_mode = WB_SYNC_ALL;
2361 wdata->nr_pages = nr_pages;
2362 wdata->offset = (__u64)offset;
2363 wdata->cfile = cifsFileInfo_get(open_file);
2365 wdata->bytes = cur_len;
2366 wdata->pagesz = PAGE_SIZE;
2367 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2368 rc = cifs_uncached_retry_writev(wdata);
2370 kref_put(&wdata->refcount, cifs_writedata_release);
2374 list_add_tail(&wdata->list, &wdata_list);
2380 * If at least one write was successfully sent, then discard any rc
2381 * value from the later writes. If the other write succeeds, then
2382 * we'll end up returning whatever was written. If it fails, then
2383 * we'll get a new rc value from that.
2385 if (!list_empty(&wdata_list))
2389 * Wait for and collect replies for any successful sends in order of
2390 * increasing offset. Once an error is hit or we get a fatal signal
2391 * while waiting, then return without waiting for any more replies.
2394 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2396 /* FIXME: freezable too? */
2397 rc = wait_for_completion_killable(&wdata->done);
2400 else if (wdata->result)
2403 total_written += wdata->bytes;
2405 /* resend call if it's a retryable error */
2406 if (rc == -EAGAIN) {
2407 rc = cifs_uncached_retry_writev(wdata);
2411 list_del_init(&wdata->list);
2412 kref_put(&wdata->refcount, cifs_writedata_release);
2415 if (total_written > 0)
2416 *poffset += total_written;
2418 cifs_stats_bytes_written(tcon, total_written);
2419 return total_written ? total_written : (ssize_t)rc;
2422 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2423 unsigned long nr_segs, loff_t pos)
2426 struct inode *inode;
2428 inode = iocb->ki_filp->f_path.dentry->d_inode;
2431 * BB - optimize the way when signing is disabled. We can drop this
2432 * extra memory-to-memory copying and use iovec buffers for constructing
2436 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2438 CIFS_I(inode)->invalid_mapping = true;
2446 cifs_writev(struct kiocb *iocb, const struct iovec *iov,
2447 unsigned long nr_segs, loff_t pos)
2449 struct file *file = iocb->ki_filp;
2450 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2451 struct inode *inode = file->f_mapping->host;
2452 struct cifsInodeInfo *cinode = CIFS_I(inode);
2453 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2454 ssize_t rc = -EACCES;
2456 BUG_ON(iocb->ki_pos != pos);
2458 sb_start_write(inode->i_sb);
2461 * We need to hold the sem to be sure nobody modifies lock list
2462 * with a brlock that prevents writing.
2464 down_read(&cinode->lock_sem);
2465 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2466 server->vals->exclusive_lock_type, NULL,
2468 mutex_lock(&inode->i_mutex);
2469 rc = __generic_file_aio_write(iocb, iov, nr_segs,
2471 mutex_unlock(&inode->i_mutex);
2474 if (rc > 0 || rc == -EIOCBQUEUED) {
2477 err = generic_write_sync(file, pos, rc);
2478 if (err < 0 && rc > 0)
2482 up_read(&cinode->lock_sem);
2483 sb_end_write(inode->i_sb);
2488 cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2489 unsigned long nr_segs, loff_t pos)
2491 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2492 struct cifsInodeInfo *cinode = CIFS_I(inode);
2493 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2494 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2495 iocb->ki_filp->private_data;
2496 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2498 #ifdef CONFIG_CIFS_SMB2
2500 * If we have an oplock for read and want to write a data to the file
2501 * we need to store it in the page cache and then push it to the server
2502 * to be sure the next read will get a valid data.
2504 if (!cinode->clientCanCacheAll && cinode->clientCanCacheRead) {
2508 written = generic_file_aio_write(iocb, iov, nr_segs, pos);
2509 rc = filemap_fdatawrite(inode->i_mapping);
2518 * For non-oplocked files in strict cache mode we need to write the data
2519 * to the server exactly from the pos to pos+len-1 rather than flush all
2520 * affected pages because it may cause a error with mandatory locks on
2521 * these pages but not on the region from pos to ppos+len-1.
2524 if (!cinode->clientCanCacheAll)
2525 return cifs_user_writev(iocb, iov, nr_segs, pos);
2527 if (cap_unix(tcon->ses) &&
2528 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2529 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2530 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2532 return cifs_writev(iocb, iov, nr_segs, pos);
2535 static struct cifs_readdata *
2536 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2538 struct cifs_readdata *rdata;
2540 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2542 if (rdata != NULL) {
2543 kref_init(&rdata->refcount);
2544 INIT_LIST_HEAD(&rdata->list);
2545 init_completion(&rdata->done);
2546 INIT_WORK(&rdata->work, complete);
2553 cifs_readdata_release(struct kref *refcount)
2555 struct cifs_readdata *rdata = container_of(refcount,
2556 struct cifs_readdata, refcount);
2559 cifsFileInfo_put(rdata->cfile);
2565 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2571 for (i = 0; i < nr_pages; i++) {
2572 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2577 rdata->pages[i] = page;
2581 for (i = 0; i < nr_pages; i++) {
2582 put_page(rdata->pages[i]);
2583 rdata->pages[i] = NULL;
2590 cifs_uncached_readdata_release(struct kref *refcount)
2592 struct cifs_readdata *rdata = container_of(refcount,
2593 struct cifs_readdata, refcount);
2596 for (i = 0; i < rdata->nr_pages; i++) {
2597 put_page(rdata->pages[i]);
2598 rdata->pages[i] = NULL;
2600 cifs_readdata_release(refcount);
2604 cifs_retry_async_readv(struct cifs_readdata *rdata)
2607 struct TCP_Server_Info *server;
2609 server = tlink_tcon(rdata->cfile->tlink)->ses->server;
2612 if (rdata->cfile->invalidHandle) {
2613 rc = cifs_reopen_file(rdata->cfile, true);
2617 rc = server->ops->async_readv(rdata);
2618 } while (rc == -EAGAIN);
2624 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2625 * @rdata: the readdata response with list of pages holding data
2626 * @iov: vector in which we should copy the data
2627 * @nr_segs: number of segments in vector
2628 * @offset: offset into file of the first iovec
2629 * @copied: used to return the amount of data copied to the iov
2631 * This function copies data from a list of pages in a readdata response into
2632 * an array of iovecs. It will first calculate where the data should go
2633 * based on the info in the readdata and then copy the data into that spot.
2636 cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2637 unsigned long nr_segs, loff_t offset, ssize_t *copied)
2641 size_t pos = rdata->offset - offset;
2642 ssize_t remaining = rdata->bytes;
2643 unsigned char *pdata;
2646 /* set up iov_iter and advance to the correct offset */
2647 iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2648 iov_iter_advance(&ii, pos);
2651 for (i = 0; i < rdata->nr_pages; i++) {
2653 struct page *page = rdata->pages[i];
2655 /* copy a whole page or whatever's left */
2656 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2658 /* ...but limit it to whatever space is left in the iov */
2659 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2661 /* go while there's data to be copied and no errors */
2664 rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2670 iov_iter_advance(&ii, copy);
2679 cifs_uncached_readv_complete(struct work_struct *work)
2681 struct cifs_readdata *rdata = container_of(work,
2682 struct cifs_readdata, work);
2684 complete(&rdata->done);
2685 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2689 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2690 struct cifs_readdata *rdata, unsigned int len)
2692 int total_read = 0, result = 0;
2694 unsigned int nr_pages = rdata->nr_pages;
2697 rdata->tailsz = PAGE_SIZE;
2698 for (i = 0; i < nr_pages; i++) {
2699 struct page *page = rdata->pages[i];
2701 if (len >= PAGE_SIZE) {
2702 /* enough data to fill the page */
2703 iov.iov_base = kmap(page);
2704 iov.iov_len = PAGE_SIZE;
2705 cFYI(1, "%u: iov_base=%p iov_len=%zu",
2706 i, iov.iov_base, iov.iov_len);
2708 } else if (len > 0) {
2709 /* enough for partial page, fill and zero the rest */
2710 iov.iov_base = kmap(page);
2712 cFYI(1, "%u: iov_base=%p iov_len=%zu",
2713 i, iov.iov_base, iov.iov_len);
2714 memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2715 rdata->tailsz = len;
2718 /* no need to hold page hostage */
2719 rdata->pages[i] = NULL;
2725 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2730 total_read += result;
2733 return total_read > 0 ? total_read : result;
2737 cifs_iovec_read(struct file *file, const struct iovec *iov,
2738 unsigned long nr_segs, loff_t *poffset)
2741 size_t len, cur_len;
2742 ssize_t total_read = 0;
2743 loff_t offset = *poffset;
2744 unsigned int npages;
2745 struct cifs_sb_info *cifs_sb;
2746 struct cifs_tcon *tcon;
2747 struct cifsFileInfo *open_file;
2748 struct cifs_readdata *rdata, *tmp;
2749 struct list_head rdata_list;
2755 len = iov_length(iov, nr_segs);
2759 INIT_LIST_HEAD(&rdata_list);
2760 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2761 open_file = file->private_data;
2762 tcon = tlink_tcon(open_file->tlink);
2764 if (!tcon->ses->server->ops->async_readv)
2767 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2768 pid = open_file->pid;
2770 pid = current->tgid;
2772 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2773 cFYI(1, "attempting read on write only file instance");
2776 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2777 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2779 /* allocate a readdata struct */
2780 rdata = cifs_readdata_alloc(npages,
2781 cifs_uncached_readv_complete);
2787 rc = cifs_read_allocate_pages(rdata, npages);
2791 rdata->cfile = cifsFileInfo_get(open_file);
2792 rdata->nr_pages = npages;
2793 rdata->offset = offset;
2794 rdata->bytes = cur_len;
2796 rdata->pagesz = PAGE_SIZE;
2797 rdata->read_into_pages = cifs_uncached_read_into_pages;
2799 rc = cifs_retry_async_readv(rdata);
2802 kref_put(&rdata->refcount,
2803 cifs_uncached_readdata_release);
2807 list_add_tail(&rdata->list, &rdata_list);
2812 /* if at least one read request send succeeded, then reset rc */
2813 if (!list_empty(&rdata_list))
2816 /* the loop below should proceed in the order of increasing offsets */
2818 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2822 /* FIXME: freezable sleep too? */
2823 rc = wait_for_completion_killable(&rdata->done);
2826 else if (rdata->result)
2829 rc = cifs_readdata_to_iov(rdata, iov,
2832 total_read += copied;
2835 /* resend call if it's a retryable error */
2836 if (rc == -EAGAIN) {
2837 rc = cifs_retry_async_readv(rdata);
2841 list_del_init(&rdata->list);
2842 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2845 cifs_stats_bytes_read(tcon, total_read);
2846 *poffset += total_read;
2848 /* mask nodata case */
2852 return total_read ? total_read : rc;
2855 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2856 unsigned long nr_segs, loff_t pos)
2860 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2868 cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2869 unsigned long nr_segs, loff_t pos)
2871 struct inode *inode = iocb->ki_filp->f_path.dentry->d_inode;
2872 struct cifsInodeInfo *cinode = CIFS_I(inode);
2873 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2874 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2875 iocb->ki_filp->private_data;
2876 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2880 * In strict cache mode we need to read from the server all the time
2881 * if we don't have level II oplock because the server can delay mtime
2882 * change - so we can't make a decision about inode invalidating.
2883 * And we can also fail with pagereading if there are mandatory locks
2884 * on pages affected by this read but not on the region from pos to
2887 if (!cinode->clientCanCacheRead)
2888 return cifs_user_readv(iocb, iov, nr_segs, pos);
2890 if (cap_unix(tcon->ses) &&
2891 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2892 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2893 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2896 * We need to hold the sem to be sure nobody modifies lock list
2897 * with a brlock that prevents reading.
2899 down_read(&cinode->lock_sem);
2900 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2901 tcon->ses->server->vals->shared_lock_type,
2903 rc = generic_file_aio_read(iocb, iov, nr_segs, pos);
2904 up_read(&cinode->lock_sem);
2909 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
2912 unsigned int bytes_read = 0;
2913 unsigned int total_read;
2914 unsigned int current_read_size;
2916 struct cifs_sb_info *cifs_sb;
2917 struct cifs_tcon *tcon;
2918 struct TCP_Server_Info *server;
2921 struct cifsFileInfo *open_file;
2922 struct cifs_io_parms io_parms;
2923 int buf_type = CIFS_NO_BUFFER;
2927 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2929 /* FIXME: set up handlers for larger reads and/or convert to async */
2930 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2932 if (file->private_data == NULL) {
2937 open_file = file->private_data;
2938 tcon = tlink_tcon(open_file->tlink);
2939 server = tcon->ses->server;
2941 if (!server->ops->sync_read) {
2946 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2947 pid = open_file->pid;
2949 pid = current->tgid;
2951 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2952 cFYI(1, "attempting read on write only file instance");
2954 for (total_read = 0, cur_offset = read_data; read_size > total_read;
2955 total_read += bytes_read, cur_offset += bytes_read) {
2956 current_read_size = min_t(uint, read_size - total_read, rsize);
2958 * For windows me and 9x we do not want to request more than it
2959 * negotiated since it will refuse the read then.
2961 if ((tcon->ses) && !(tcon->ses->capabilities &
2962 tcon->ses->server->vals->cap_large_files)) {
2963 current_read_size = min_t(uint, current_read_size,
2967 while (rc == -EAGAIN) {
2968 if (open_file->invalidHandle) {
2969 rc = cifs_reopen_file(open_file, true);
2974 io_parms.tcon = tcon;
2975 io_parms.offset = *offset;
2976 io_parms.length = current_read_size;
2977 rc = server->ops->sync_read(xid, open_file, &io_parms,
2978 &bytes_read, &cur_offset,
2981 if (rc || (bytes_read == 0)) {
2989 cifs_stats_bytes_read(tcon, total_read);
2990 *offset += bytes_read;
2998 * If the page is mmap'ed into a process' page tables, then we need to make
2999 * sure that it doesn't change while being written back.
3002 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3004 struct page *page = vmf->page;
3007 return VM_FAULT_LOCKED;
3010 static struct vm_operations_struct cifs_file_vm_ops = {
3011 .fault = filemap_fault,
3012 .page_mkwrite = cifs_page_mkwrite,
3013 .remap_pages = generic_file_remap_pages,
3016 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3019 struct inode *inode = file->f_path.dentry->d_inode;
3023 if (!CIFS_I(inode)->clientCanCacheRead) {
3024 rc = cifs_invalidate_mapping(inode);
3029 rc = generic_file_mmap(file, vma);
3031 vma->vm_ops = &cifs_file_vm_ops;
3036 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3041 rc = cifs_revalidate_file(file);
3043 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
3047 rc = generic_file_mmap(file, vma);
3049 vma->vm_ops = &cifs_file_vm_ops;
3055 cifs_readv_complete(struct work_struct *work)
3058 struct cifs_readdata *rdata = container_of(work,
3059 struct cifs_readdata, work);
3061 for (i = 0; i < rdata->nr_pages; i++) {
3062 struct page *page = rdata->pages[i];
3064 lru_cache_add_file(page);
3066 if (rdata->result == 0) {
3067 flush_dcache_page(page);
3068 SetPageUptodate(page);
3073 if (rdata->result == 0)
3074 cifs_readpage_to_fscache(rdata->mapping->host, page);
3076 page_cache_release(page);
3077 rdata->pages[i] = NULL;
3079 kref_put(&rdata->refcount, cifs_readdata_release);
3083 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3084 struct cifs_readdata *rdata, unsigned int len)
3086 int total_read = 0, result = 0;
3090 unsigned int nr_pages = rdata->nr_pages;
3093 /* determine the eof that the server (probably) has */
3094 eof = CIFS_I(rdata->mapping->host)->server_eof;
3095 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
3096 cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
3098 rdata->tailsz = PAGE_CACHE_SIZE;
3099 for (i = 0; i < nr_pages; i++) {
3100 struct page *page = rdata->pages[i];
3102 if (len >= PAGE_CACHE_SIZE) {
3103 /* enough data to fill the page */
3104 iov.iov_base = kmap(page);
3105 iov.iov_len = PAGE_CACHE_SIZE;
3106 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
3107 i, page->index, iov.iov_base, iov.iov_len);
3108 len -= PAGE_CACHE_SIZE;
3109 } else if (len > 0) {
3110 /* enough for partial page, fill and zero the rest */
3111 iov.iov_base = kmap(page);
3113 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
3114 i, page->index, iov.iov_base, iov.iov_len);
3115 memset(iov.iov_base + len,
3116 '\0', PAGE_CACHE_SIZE - len);
3117 rdata->tailsz = len;
3119 } else if (page->index > eof_index) {
3121 * The VFS will not try to do readahead past the
3122 * i_size, but it's possible that we have outstanding
3123 * writes with gaps in the middle and the i_size hasn't
3124 * caught up yet. Populate those with zeroed out pages
3125 * to prevent the VFS from repeatedly attempting to
3126 * fill them until the writes are flushed.
3128 zero_user(page, 0, PAGE_CACHE_SIZE);
3129 lru_cache_add_file(page);
3130 flush_dcache_page(page);
3131 SetPageUptodate(page);
3133 page_cache_release(page);
3134 rdata->pages[i] = NULL;
3138 /* no need to hold page hostage */
3139 lru_cache_add_file(page);
3141 page_cache_release(page);
3142 rdata->pages[i] = NULL;
3147 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3152 total_read += result;
3155 return total_read > 0 ? total_read : result;
3158 static int cifs_readpages(struct file *file, struct address_space *mapping,
3159 struct list_head *page_list, unsigned num_pages)
3162 struct list_head tmplist;
3163 struct cifsFileInfo *open_file = file->private_data;
3164 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3165 unsigned int rsize = cifs_sb->rsize;
3169 * Give up immediately if rsize is too small to read an entire page.
3170 * The VFS will fall back to readpage. We should never reach this
3171 * point however since we set ra_pages to 0 when the rsize is smaller
3172 * than a cache page.
3174 if (unlikely(rsize < PAGE_CACHE_SIZE))
3178 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3179 * immediately if the cookie is negative
3181 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3186 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3187 pid = open_file->pid;
3189 pid = current->tgid;
3192 INIT_LIST_HEAD(&tmplist);
3194 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
3195 mapping, num_pages);
3198 * Start with the page at end of list and move it to private
3199 * list. Do the same with any following pages until we hit
3200 * the rsize limit, hit an index discontinuity, or run out of
3201 * pages. Issue the async read and then start the loop again
3202 * until the list is empty.
3204 * Note that list order is important. The page_list is in
3205 * the order of declining indexes. When we put the pages in
3206 * the rdata->pages, then we want them in increasing order.
3208 while (!list_empty(page_list)) {
3210 unsigned int bytes = PAGE_CACHE_SIZE;
3211 unsigned int expected_index;
3212 unsigned int nr_pages = 1;
3214 struct page *page, *tpage;
3215 struct cifs_readdata *rdata;
3217 page = list_entry(page_list->prev, struct page, lru);
3220 * Lock the page and put it in the cache. Since no one else
3221 * should have access to this page, we're safe to simply set
3222 * PG_locked without checking it first.
3224 __set_page_locked(page);
3225 rc = add_to_page_cache_locked(page, mapping,
3226 page->index, GFP_KERNEL);
3228 /* give up if we can't stick it in the cache */
3230 __clear_page_locked(page);
3234 /* move first page to the tmplist */
3235 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3236 list_move_tail(&page->lru, &tmplist);
3238 /* now try and add more pages onto the request */
3239 expected_index = page->index + 1;
3240 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3241 /* discontinuity ? */
3242 if (page->index != expected_index)
3245 /* would this page push the read over the rsize? */
3246 if (bytes + PAGE_CACHE_SIZE > rsize)
3249 __set_page_locked(page);
3250 if (add_to_page_cache_locked(page, mapping,
3251 page->index, GFP_KERNEL)) {
3252 __clear_page_locked(page);
3255 list_move_tail(&page->lru, &tmplist);
3256 bytes += PAGE_CACHE_SIZE;
3261 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3263 /* best to give up if we're out of mem */
3264 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3265 list_del(&page->lru);
3266 lru_cache_add_file(page);
3268 page_cache_release(page);
3274 rdata->cfile = cifsFileInfo_get(open_file);
3275 rdata->mapping = mapping;
3276 rdata->offset = offset;
3277 rdata->bytes = bytes;
3279 rdata->pagesz = PAGE_CACHE_SIZE;
3280 rdata->read_into_pages = cifs_readpages_read_into_pages;
3282 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3283 list_del(&page->lru);
3284 rdata->pages[rdata->nr_pages++] = page;
3287 rc = cifs_retry_async_readv(rdata);
3289 for (i = 0; i < rdata->nr_pages; i++) {
3290 page = rdata->pages[i];
3291 lru_cache_add_file(page);
3293 page_cache_release(page);
3295 kref_put(&rdata->refcount, cifs_readdata_release);
3299 kref_put(&rdata->refcount, cifs_readdata_release);
3305 static int cifs_readpage_worker(struct file *file, struct page *page,
3311 /* Is the page cached? */
3312 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
3316 page_cache_get(page);
3317 read_data = kmap(page);
3318 /* for reads over a certain size could initiate async read ahead */
3320 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
3325 cFYI(1, "Bytes read %d", rc);
3327 file->f_path.dentry->d_inode->i_atime =
3328 current_fs_time(file->f_path.dentry->d_inode->i_sb);
3330 if (PAGE_CACHE_SIZE > rc)
3331 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3333 flush_dcache_page(page);
3334 SetPageUptodate(page);
3336 /* send this page to the cache */
3337 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
3343 page_cache_release(page);
3349 static int cifs_readpage(struct file *file, struct page *page)
3351 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3357 if (file->private_data == NULL) {
3363 cFYI(1, "readpage %p at offset %d 0x%x",
3364 page, (int)offset, (int)offset);
3366 rc = cifs_readpage_worker(file, page, &offset);
3374 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3376 struct cifsFileInfo *open_file;
3378 spin_lock(&cifs_file_list_lock);
3379 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3380 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3381 spin_unlock(&cifs_file_list_lock);
3385 spin_unlock(&cifs_file_list_lock);
3389 /* We do not want to update the file size from server for inodes
3390 open for write - to avoid races with writepage extending
3391 the file - in the future we could consider allowing
3392 refreshing the inode only on increases in the file size
3393 but this is tricky to do without racing with writebehind
3394 page caching in the current Linux kernel design */
3395 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3400 if (is_inode_writable(cifsInode)) {
3401 /* This inode is open for write at least once */
3402 struct cifs_sb_info *cifs_sb;
3404 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3405 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3406 /* since no page cache to corrupt on directio
3407 we can change size safely */
3411 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3419 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3420 loff_t pos, unsigned len, unsigned flags,
3421 struct page **pagep, void **fsdata)
3423 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3424 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
3425 loff_t page_start = pos & PAGE_MASK;
3430 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
3432 page = grab_cache_page_write_begin(mapping, index, flags);
3438 if (PageUptodate(page))
3442 * If we write a full page it will be up to date, no need to read from
3443 * the server. If the write is short, we'll end up doing a sync write
3446 if (len == PAGE_CACHE_SIZE)
3450 * optimize away the read when we have an oplock, and we're not
3451 * expecting to use any of the data we'd be reading in. That
3452 * is, when the page lies beyond the EOF, or straddles the EOF
3453 * and the write will cover all of the existing data.
3455 if (CIFS_I(mapping->host)->clientCanCacheRead) {
3456 i_size = i_size_read(mapping->host);
3457 if (page_start >= i_size ||
3458 (offset == 0 && (pos + len) >= i_size)) {
3459 zero_user_segments(page, 0, offset,
3463 * PageChecked means that the parts of the page
3464 * to which we're not writing are considered up
3465 * to date. Once the data is copied to the
3466 * page, it can be set uptodate.
3468 SetPageChecked(page);
3473 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
3475 * might as well read a page, it is fast enough. If we get
3476 * an error, we don't need to return it. cifs_write_end will
3477 * do a sync write instead since PG_uptodate isn't set.
3479 cifs_readpage_worker(file, page, &page_start);
3481 /* we could try using another file handle if there is one -
3482 but how would we lock it to prevent close of that handle
3483 racing with this read? In any case
3484 this will be written out by write_end so is fine */
3491 static int cifs_release_page(struct page *page, gfp_t gfp)
3493 if (PagePrivate(page))
3496 return cifs_fscache_release_page(page, gfp);
3499 static void cifs_invalidate_page(struct page *page, unsigned long offset)
3501 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3504 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3507 static int cifs_launder_page(struct page *page)
3510 loff_t range_start = page_offset(page);
3511 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3512 struct writeback_control wbc = {
3513 .sync_mode = WB_SYNC_ALL,
3515 .range_start = range_start,
3516 .range_end = range_end,
3519 cFYI(1, "Launder page: %p", page);
3521 if (clear_page_dirty_for_io(page))
3522 rc = cifs_writepage_locked(page, &wbc);
3524 cifs_fscache_invalidate_page(page, page->mapping->host);
3528 void cifs_oplock_break(struct work_struct *work)
3530 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3532 struct inode *inode = cfile->dentry->d_inode;
3533 struct cifsInodeInfo *cinode = CIFS_I(inode);
3534 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3537 if (inode && S_ISREG(inode->i_mode)) {
3538 if (cinode->clientCanCacheRead)
3539 break_lease(inode, O_RDONLY);
3541 break_lease(inode, O_WRONLY);
3542 rc = filemap_fdatawrite(inode->i_mapping);
3543 if (cinode->clientCanCacheRead == 0) {
3544 rc = filemap_fdatawait(inode->i_mapping);
3545 mapping_set_error(inode->i_mapping, rc);
3546 invalidate_remote_inode(inode);
3548 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
3551 rc = cifs_push_locks(cfile);
3553 cERROR(1, "Push locks rc = %d", rc);
3556 * releasing stale oplock after recent reconnect of smb session using
3557 * a now incorrect file handle is not a data integrity issue but do
3558 * not bother sending an oplock release if session to server still is
3559 * disconnected since oplock already released by the server
3561 if (!cfile->oplock_break_cancelled) {
3562 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3564 cFYI(1, "Oplock release rc = %d", rc);
3568 const struct address_space_operations cifs_addr_ops = {
3569 .readpage = cifs_readpage,
3570 .readpages = cifs_readpages,
3571 .writepage = cifs_writepage,
3572 .writepages = cifs_writepages,
3573 .write_begin = cifs_write_begin,
3574 .write_end = cifs_write_end,
3575 .set_page_dirty = __set_page_dirty_nobuffers,
3576 .releasepage = cifs_release_page,
3577 .invalidatepage = cifs_invalidate_page,
3578 .launder_page = cifs_launder_page,
3582 * cifs_readpages requires the server to support a buffer large enough to
3583 * contain the header plus one complete page of data. Otherwise, we need
3584 * to leave cifs_readpages out of the address space operations.
3586 const struct address_space_operations cifs_addr_ops_smallbuf = {
3587 .readpage = cifs_readpage,
3588 .writepage = cifs_writepage,
3589 .writepages = cifs_writepages,
3590 .write_begin = cifs_write_begin,
3591 .write_end = cifs_write_end,
3592 .set_page_dirty = __set_page_dirty_nobuffers,
3593 .releasepage = cifs_release_page,
3594 .invalidatepage = cifs_invalidate_page,
3595 .launder_page = cifs_launder_page,