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"
47 static inline int cifs_convert_flags(unsigned int flags)
49 if ((flags & O_ACCMODE) == O_RDONLY)
51 else if ((flags & O_ACCMODE) == O_WRONLY)
53 else if ((flags & O_ACCMODE) == O_RDWR) {
54 /* GENERIC_ALL is too much permission to request
55 can cause unnecessary access denied on create */
56 /* return GENERIC_ALL; */
57 return (GENERIC_READ | GENERIC_WRITE);
60 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
61 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
65 static u32 cifs_posix_convert_flags(unsigned int flags)
69 if ((flags & O_ACCMODE) == O_RDONLY)
70 posix_flags = SMB_O_RDONLY;
71 else if ((flags & O_ACCMODE) == O_WRONLY)
72 posix_flags = SMB_O_WRONLY;
73 else if ((flags & O_ACCMODE) == O_RDWR)
74 posix_flags = SMB_O_RDWR;
76 if (flags & O_CREAT) {
77 posix_flags |= SMB_O_CREAT;
79 posix_flags |= SMB_O_EXCL;
80 } else if (flags & O_EXCL)
81 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
82 current->comm, current->tgid);
85 posix_flags |= SMB_O_TRUNC;
86 /* be safe and imply O_SYNC for O_DSYNC */
88 posix_flags |= SMB_O_SYNC;
89 if (flags & O_DIRECTORY)
90 posix_flags |= SMB_O_DIRECTORY;
91 if (flags & O_NOFOLLOW)
92 posix_flags |= SMB_O_NOFOLLOW;
94 posix_flags |= SMB_O_DIRECT;
99 static inline int cifs_get_disposition(unsigned int flags)
101 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
103 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
104 return FILE_OVERWRITE_IF;
105 else if ((flags & O_CREAT) == O_CREAT)
107 else if ((flags & O_TRUNC) == O_TRUNC)
108 return FILE_OVERWRITE;
113 int cifs_posix_open(char *full_path, struct inode **pinode,
114 struct super_block *sb, int mode, unsigned int f_flags,
115 __u32 *poplock, __u16 *pnetfid, unsigned int xid)
118 FILE_UNIX_BASIC_INFO *presp_data;
119 __u32 posix_flags = 0;
120 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
121 struct cifs_fattr fattr;
122 struct tcon_link *tlink;
123 struct cifs_tcon *tcon;
125 cifs_dbg(FYI, "posix open %s\n", full_path);
127 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
128 if (presp_data == NULL)
131 tlink = cifs_sb_tlink(cifs_sb);
137 tcon = tlink_tcon(tlink);
138 mode &= ~current_umask();
140 posix_flags = cifs_posix_convert_flags(f_flags);
141 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
142 poplock, full_path, cifs_sb->local_nls,
143 cifs_sb->mnt_cifs_flags &
144 CIFS_MOUNT_MAP_SPECIAL_CHR);
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;
187 if (!server->ops->open)
190 desired_access = cifs_convert_flags(f_flags);
192 /*********************************************************************
193 * open flag mapping table:
195 * POSIX Flag CIFS Disposition
196 * ---------- ----------------
197 * O_CREAT FILE_OPEN_IF
198 * O_CREAT | O_EXCL FILE_CREATE
199 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
200 * O_TRUNC FILE_OVERWRITE
201 * none of the above FILE_OPEN
203 * Note that there is not a direct match between disposition
204 * FILE_SUPERSEDE (ie create whether or not file exists although
205 * O_CREAT | O_TRUNC is similar but truncates the existing
206 * file rather than creating a new file as FILE_SUPERSEDE does
207 * (which uses the attributes / metadata passed in on open call)
209 *? O_SYNC is a reasonable match to CIFS writethrough flag
210 *? and the read write flags match reasonably. O_LARGEFILE
211 *? is irrelevant because largefile support is always used
212 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
213 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
214 *********************************************************************/
216 disposition = cifs_get_disposition(f_flags);
218 /* BB pass O_SYNC flag through on file attributes .. BB */
220 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
224 if (backup_cred(cifs_sb))
225 create_options |= CREATE_OPEN_BACKUP_INTENT;
227 rc = server->ops->open(xid, tcon, full_path, disposition,
228 desired_access, create_options, fid, oplock, buf,
235 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
238 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
247 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
249 struct cifs_fid_locks *cur;
250 bool has_locks = false;
252 down_read(&cinode->lock_sem);
253 list_for_each_entry(cur, &cinode->llist, llist) {
254 if (!list_empty(&cur->locks)) {
259 up_read(&cinode->lock_sem);
263 struct cifsFileInfo *
264 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
265 struct tcon_link *tlink, __u32 oplock)
267 struct dentry *dentry = file->f_path.dentry;
268 struct inode *inode = dentry->d_inode;
269 struct cifsInodeInfo *cinode = CIFS_I(inode);
270 struct cifsFileInfo *cfile;
271 struct cifs_fid_locks *fdlocks;
272 struct cifs_tcon *tcon = tlink_tcon(tlink);
273 struct TCP_Server_Info *server = tcon->ses->server;
275 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
279 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
285 INIT_LIST_HEAD(&fdlocks->locks);
286 fdlocks->cfile = cfile;
287 cfile->llist = fdlocks;
288 down_write(&cinode->lock_sem);
289 list_add(&fdlocks->llist, &cinode->llist);
290 up_write(&cinode->lock_sem);
293 cfile->pid = current->tgid;
294 cfile->uid = current_fsuid();
295 cfile->dentry = dget(dentry);
296 cfile->f_flags = file->f_flags;
297 cfile->invalidHandle = false;
298 cfile->tlink = cifs_get_tlink(tlink);
299 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
300 mutex_init(&cfile->fh_mutex);
302 cifs_sb_active(inode->i_sb);
305 * If the server returned a read oplock and we have mandatory brlocks,
306 * set oplock level to None.
308 if (oplock == server->vals->oplock_read &&
309 cifs_has_mand_locks(cinode)) {
310 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
314 spin_lock(&cifs_file_list_lock);
315 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
316 oplock = fid->pending_open->oplock;
317 list_del(&fid->pending_open->olist);
319 server->ops->set_fid(cfile, fid, oplock);
321 list_add(&cfile->tlist, &tcon->openFileList);
322 /* if readable file instance put first in list*/
323 if (file->f_mode & FMODE_READ)
324 list_add(&cfile->flist, &cinode->openFileList);
326 list_add_tail(&cfile->flist, &cinode->openFileList);
327 spin_unlock(&cifs_file_list_lock);
329 file->private_data = cfile;
333 struct cifsFileInfo *
334 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
336 spin_lock(&cifs_file_list_lock);
337 cifsFileInfo_get_locked(cifs_file);
338 spin_unlock(&cifs_file_list_lock);
343 * Release a reference on the file private data. This may involve closing
344 * the filehandle out on the server. Must be called without holding
345 * cifs_file_list_lock.
347 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
349 struct inode *inode = cifs_file->dentry->d_inode;
350 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
351 struct TCP_Server_Info *server = tcon->ses->server;
352 struct cifsInodeInfo *cifsi = CIFS_I(inode);
353 struct super_block *sb = inode->i_sb;
354 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
355 struct cifsLockInfo *li, *tmp;
357 struct cifs_pending_open open;
359 spin_lock(&cifs_file_list_lock);
360 if (--cifs_file->count > 0) {
361 spin_unlock(&cifs_file_list_lock);
365 if (server->ops->get_lease_key)
366 server->ops->get_lease_key(inode, &fid);
368 /* store open in pending opens to make sure we don't miss lease break */
369 cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
371 /* remove it from the lists */
372 list_del(&cifs_file->flist);
373 list_del(&cifs_file->tlist);
375 if (list_empty(&cifsi->openFileList)) {
376 cifs_dbg(FYI, "closing last open instance for inode %p\n",
377 cifs_file->dentry->d_inode);
379 * In strict cache mode we need invalidate mapping on the last
380 * close because it may cause a error when we open this file
381 * again and get at least level II oplock.
383 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
384 CIFS_I(inode)->invalid_mapping = true;
385 cifs_set_oplock_level(cifsi, 0);
387 spin_unlock(&cifs_file_list_lock);
389 cancel_work_sync(&cifs_file->oplock_break);
391 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
392 struct TCP_Server_Info *server = tcon->ses->server;
396 if (server->ops->close)
397 server->ops->close(xid, tcon, &cifs_file->fid);
401 cifs_del_pending_open(&open);
404 * Delete any outstanding lock records. We'll lose them when the file
407 down_write(&cifsi->lock_sem);
408 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
409 list_del(&li->llist);
410 cifs_del_lock_waiters(li);
413 list_del(&cifs_file->llist->llist);
414 kfree(cifs_file->llist);
415 up_write(&cifsi->lock_sem);
417 cifs_put_tlink(cifs_file->tlink);
418 dput(cifs_file->dentry);
419 cifs_sb_deactive(sb);
423 int cifs_open(struct inode *inode, struct file *file)
429 struct cifs_sb_info *cifs_sb;
430 struct TCP_Server_Info *server;
431 struct cifs_tcon *tcon;
432 struct tcon_link *tlink;
433 struct cifsFileInfo *cfile = NULL;
434 char *full_path = NULL;
435 bool posix_open_ok = false;
437 struct cifs_pending_open open;
441 cifs_sb = CIFS_SB(inode->i_sb);
442 tlink = cifs_sb_tlink(cifs_sb);
445 return PTR_ERR(tlink);
447 tcon = tlink_tcon(tlink);
448 server = tcon->ses->server;
450 full_path = build_path_from_dentry(file->f_path.dentry);
451 if (full_path == NULL) {
456 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
457 inode, file->f_flags, full_path);
464 if (!tcon->broken_posix_open && tcon->unix_ext &&
465 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
466 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
467 /* can not refresh inode info since size could be stale */
468 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
469 cifs_sb->mnt_file_mode /* ignored */,
470 file->f_flags, &oplock, &fid.netfid, xid);
472 cifs_dbg(FYI, "posix open succeeded\n");
473 posix_open_ok = true;
474 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
475 if (tcon->ses->serverNOS)
476 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",
477 tcon->ses->serverName,
478 tcon->ses->serverNOS);
479 tcon->broken_posix_open = true;
480 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
481 (rc != -EOPNOTSUPP)) /* path not found or net err */
484 * Else fallthrough to retry open the old way on network i/o
489 if (server->ops->get_lease_key)
490 server->ops->get_lease_key(inode, &fid);
492 cifs_add_pending_open(&fid, tlink, &open);
494 if (!posix_open_ok) {
495 if (server->ops->get_lease_key)
496 server->ops->get_lease_key(inode, &fid);
498 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
499 file->f_flags, &oplock, &fid, xid);
501 cifs_del_pending_open(&open);
506 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
508 if (server->ops->close)
509 server->ops->close(xid, tcon, &fid);
510 cifs_del_pending_open(&open);
515 cifs_fscache_set_inode_cookie(inode, file);
517 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
519 * Time to set mode which we can not set earlier due to
520 * problems creating new read-only files.
522 struct cifs_unix_set_info_args args = {
523 .mode = inode->i_mode,
524 .uid = INVALID_UID, /* no change */
525 .gid = INVALID_GID, /* no change */
526 .ctime = NO_CHANGE_64,
527 .atime = NO_CHANGE_64,
528 .mtime = NO_CHANGE_64,
531 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
538 cifs_put_tlink(tlink);
542 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
545 * Try to reacquire byte range locks that were released when session
546 * to server was lost.
549 cifs_relock_file(struct cifsFileInfo *cfile)
551 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
552 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
553 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
556 down_read(&cinode->lock_sem);
557 if (cinode->can_cache_brlcks) {
558 /* can cache locks - no need to relock */
559 up_read(&cinode->lock_sem);
563 if (cap_unix(tcon->ses) &&
564 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
565 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
566 rc = cifs_push_posix_locks(cfile);
568 rc = tcon->ses->server->ops->push_mand_locks(cfile);
570 up_read(&cinode->lock_sem);
575 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
580 struct cifs_sb_info *cifs_sb;
581 struct cifs_tcon *tcon;
582 struct TCP_Server_Info *server;
583 struct cifsInodeInfo *cinode;
585 char *full_path = NULL;
587 int disposition = FILE_OPEN;
588 int create_options = CREATE_NOT_DIR;
592 mutex_lock(&cfile->fh_mutex);
593 if (!cfile->invalidHandle) {
594 mutex_unlock(&cfile->fh_mutex);
600 inode = cfile->dentry->d_inode;
601 cifs_sb = CIFS_SB(inode->i_sb);
602 tcon = tlink_tcon(cfile->tlink);
603 server = tcon->ses->server;
606 * Can not grab rename sem here because various ops, including those
607 * that already have the rename sem can end up causing writepage to get
608 * called and if the server was down that means we end up here, and we
609 * can never tell if the caller already has the rename_sem.
611 full_path = build_path_from_dentry(cfile->dentry);
612 if (full_path == NULL) {
614 mutex_unlock(&cfile->fh_mutex);
619 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
620 inode, cfile->f_flags, full_path);
622 if (tcon->ses->server->oplocks)
627 if (tcon->unix_ext && cap_unix(tcon->ses) &&
628 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
629 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
631 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
632 * original open. Must mask them off for a reopen.
634 unsigned int oflags = cfile->f_flags &
635 ~(O_CREAT | O_EXCL | O_TRUNC);
637 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
638 cifs_sb->mnt_file_mode /* ignored */,
639 oflags, &oplock, &fid.netfid, xid);
641 cifs_dbg(FYI, "posix reopen succeeded\n");
645 * fallthrough to retry open the old way on errors, especially
646 * in the reconnect path it is important to retry hard
650 desired_access = cifs_convert_flags(cfile->f_flags);
652 if (backup_cred(cifs_sb))
653 create_options |= CREATE_OPEN_BACKUP_INTENT;
655 if (server->ops->get_lease_key)
656 server->ops->get_lease_key(inode, &fid);
659 * Can not refresh inode by passing in file_info buf to be returned by
660 * CIFSSMBOpen and then calling get_inode_info with returned buf since
661 * file might have write behind data that needs to be flushed and server
662 * version of file size can be stale. If we knew for sure that inode was
663 * not dirty locally we could do this.
665 rc = server->ops->open(xid, tcon, full_path, disposition,
666 desired_access, create_options, &fid, &oplock,
669 mutex_unlock(&cfile->fh_mutex);
670 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
671 cifs_dbg(FYI, "oplock: %d\n", oplock);
672 goto reopen_error_exit;
676 cfile->invalidHandle = false;
677 mutex_unlock(&cfile->fh_mutex);
678 cinode = CIFS_I(inode);
681 rc = filemap_write_and_wait(inode->i_mapping);
682 mapping_set_error(inode->i_mapping, rc);
685 rc = cifs_get_inode_info_unix(&inode, full_path,
688 rc = cifs_get_inode_info(&inode, full_path, NULL,
689 inode->i_sb, xid, NULL);
692 * Else we are writing out data to server already and could deadlock if
693 * we tried to flush data, and since we do not know if we have data that
694 * would invalidate the current end of file on the server we can not go
695 * to the server to get the new inode info.
698 server->ops->set_fid(cfile, &fid, oplock);
699 cifs_relock_file(cfile);
707 int cifs_close(struct inode *inode, struct file *file)
709 if (file->private_data != NULL) {
710 cifsFileInfo_put(file->private_data);
711 file->private_data = NULL;
714 /* return code from the ->release op is always ignored */
718 int cifs_closedir(struct inode *inode, struct file *file)
722 struct cifsFileInfo *cfile = file->private_data;
723 struct cifs_tcon *tcon;
724 struct TCP_Server_Info *server;
727 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
733 tcon = tlink_tcon(cfile->tlink);
734 server = tcon->ses->server;
736 cifs_dbg(FYI, "Freeing private data in close dir\n");
737 spin_lock(&cifs_file_list_lock);
738 if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
739 cfile->invalidHandle = true;
740 spin_unlock(&cifs_file_list_lock);
741 if (server->ops->close_dir)
742 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
745 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
746 /* not much we can do if it fails anyway, ignore rc */
749 spin_unlock(&cifs_file_list_lock);
751 buf = cfile->srch_inf.ntwrk_buf_start;
753 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
754 cfile->srch_inf.ntwrk_buf_start = NULL;
755 if (cfile->srch_inf.smallBuf)
756 cifs_small_buf_release(buf);
758 cifs_buf_release(buf);
761 cifs_put_tlink(cfile->tlink);
762 kfree(file->private_data);
763 file->private_data = NULL;
764 /* BB can we lock the filestruct while this is going on? */
769 static struct cifsLockInfo *
770 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
772 struct cifsLockInfo *lock =
773 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
776 lock->offset = offset;
777 lock->length = length;
779 lock->pid = current->tgid;
780 INIT_LIST_HEAD(&lock->blist);
781 init_waitqueue_head(&lock->block_q);
786 cifs_del_lock_waiters(struct cifsLockInfo *lock)
788 struct cifsLockInfo *li, *tmp;
789 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
790 list_del_init(&li->blist);
791 wake_up(&li->block_q);
795 #define CIFS_LOCK_OP 0
796 #define CIFS_READ_OP 1
797 #define CIFS_WRITE_OP 2
799 /* @rw_check : 0 - no op, 1 - read, 2 - write */
801 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
802 __u64 length, __u8 type, struct cifsFileInfo *cfile,
803 struct cifsLockInfo **conf_lock, int rw_check)
805 struct cifsLockInfo *li;
806 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
807 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
809 list_for_each_entry(li, &fdlocks->locks, llist) {
810 if (offset + length <= li->offset ||
811 offset >= li->offset + li->length)
813 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
814 server->ops->compare_fids(cfile, cur_cfile)) {
815 /* shared lock prevents write op through the same fid */
816 if (!(li->type & server->vals->shared_lock_type) ||
817 rw_check != CIFS_WRITE_OP)
820 if ((type & server->vals->shared_lock_type) &&
821 ((server->ops->compare_fids(cfile, cur_cfile) &&
822 current->tgid == li->pid) || type == li->type))
832 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
833 __u8 type, struct cifsLockInfo **conf_lock,
837 struct cifs_fid_locks *cur;
838 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
840 list_for_each_entry(cur, &cinode->llist, llist) {
841 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
842 cfile, conf_lock, rw_check);
851 * Check if there is another lock that prevents us to set the lock (mandatory
852 * style). If such a lock exists, update the flock structure with its
853 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
854 * or leave it the same if we can't. Returns 0 if we don't need to request to
855 * the server or 1 otherwise.
858 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
859 __u8 type, struct file_lock *flock)
862 struct cifsLockInfo *conf_lock;
863 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
864 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
867 down_read(&cinode->lock_sem);
869 exist = cifs_find_lock_conflict(cfile, offset, length, type,
870 &conf_lock, CIFS_LOCK_OP);
872 flock->fl_start = conf_lock->offset;
873 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
874 flock->fl_pid = conf_lock->pid;
875 if (conf_lock->type & server->vals->shared_lock_type)
876 flock->fl_type = F_RDLCK;
878 flock->fl_type = F_WRLCK;
879 } else if (!cinode->can_cache_brlcks)
882 flock->fl_type = F_UNLCK;
884 up_read(&cinode->lock_sem);
889 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
891 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
892 down_write(&cinode->lock_sem);
893 list_add_tail(&lock->llist, &cfile->llist->locks);
894 up_write(&cinode->lock_sem);
898 * Set the byte-range lock (mandatory style). Returns:
899 * 1) 0, if we set the lock and don't need to request to the server;
900 * 2) 1, if no locks prevent us but we need to request to the server;
901 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
904 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
907 struct cifsLockInfo *conf_lock;
908 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
914 down_write(&cinode->lock_sem);
916 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
917 lock->type, &conf_lock, CIFS_LOCK_OP);
918 if (!exist && cinode->can_cache_brlcks) {
919 list_add_tail(&lock->llist, &cfile->llist->locks);
920 up_write(&cinode->lock_sem);
929 list_add_tail(&lock->blist, &conf_lock->blist);
930 up_write(&cinode->lock_sem);
931 rc = wait_event_interruptible(lock->block_q,
932 (lock->blist.prev == &lock->blist) &&
933 (lock->blist.next == &lock->blist));
936 down_write(&cinode->lock_sem);
937 list_del_init(&lock->blist);
940 up_write(&cinode->lock_sem);
945 * Check if there is another lock that prevents us to set the lock (posix
946 * style). If such a lock exists, update the flock structure with its
947 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
948 * or leave it the same if we can't. Returns 0 if we don't need to request to
949 * the server or 1 otherwise.
952 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
955 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
956 unsigned char saved_type = flock->fl_type;
958 if ((flock->fl_flags & FL_POSIX) == 0)
961 down_read(&cinode->lock_sem);
962 posix_test_lock(file, flock);
964 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
965 flock->fl_type = saved_type;
969 up_read(&cinode->lock_sem);
974 * Set the byte-range lock (posix style). Returns:
975 * 1) 0, if we set the lock and don't need to request to the server;
976 * 2) 1, if we need to request to the server;
977 * 3) <0, if the error occurs while setting the lock.
980 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
982 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
985 if ((flock->fl_flags & FL_POSIX) == 0)
989 down_write(&cinode->lock_sem);
990 if (!cinode->can_cache_brlcks) {
991 up_write(&cinode->lock_sem);
995 rc = posix_lock_file(file, flock, NULL);
996 up_write(&cinode->lock_sem);
997 if (rc == FILE_LOCK_DEFERRED) {
998 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
1001 locks_delete_block(flock);
1007 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1010 int rc = 0, stored_rc;
1011 struct cifsLockInfo *li, *tmp;
1012 struct cifs_tcon *tcon;
1013 unsigned int num, max_num, max_buf;
1014 LOCKING_ANDX_RANGE *buf, *cur;
1015 int types[] = {LOCKING_ANDX_LARGE_FILES,
1016 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1020 tcon = tlink_tcon(cfile->tlink);
1023 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1024 * and check it for zero before using.
1026 max_buf = tcon->ses->server->maxBuf;
1032 max_num = (max_buf - sizeof(struct smb_hdr)) /
1033 sizeof(LOCKING_ANDX_RANGE);
1034 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1040 for (i = 0; i < 2; i++) {
1043 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1044 if (li->type != types[i])
1046 cur->Pid = cpu_to_le16(li->pid);
1047 cur->LengthLow = cpu_to_le32((u32)li->length);
1048 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1049 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1050 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1051 if (++num == max_num) {
1052 stored_rc = cifs_lockv(xid, tcon,
1054 (__u8)li->type, 0, num,
1065 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1066 (__u8)types[i], 0, num, buf);
1077 /* copied from fs/locks.c with a name change */
1078 #define cifs_for_each_lock(inode, lockp) \
1079 for (lockp = &inode->i_flock; *lockp != NULL; \
1080 lockp = &(*lockp)->fl_next)
1082 struct lock_to_push {
1083 struct list_head llist;
1092 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1094 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1095 struct file_lock *flock, **before;
1096 unsigned int count = 0, i = 0;
1097 int rc = 0, xid, type;
1098 struct list_head locks_to_send, *el;
1099 struct lock_to_push *lck, *tmp;
1105 cifs_for_each_lock(cfile->dentry->d_inode, before) {
1106 if ((*before)->fl_flags & FL_POSIX)
1111 INIT_LIST_HEAD(&locks_to_send);
1114 * Allocating count locks is enough because no FL_POSIX locks can be
1115 * added to the list while we are holding cinode->lock_sem that
1116 * protects locking operations of this inode.
1118 for (; i < count; i++) {
1119 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1124 list_add_tail(&lck->llist, &locks_to_send);
1127 el = locks_to_send.next;
1129 cifs_for_each_lock(cfile->dentry->d_inode, before) {
1131 if ((flock->fl_flags & FL_POSIX) == 0)
1133 if (el == &locks_to_send) {
1135 * The list ended. We don't have enough allocated
1136 * structures - something is really wrong.
1138 cifs_dbg(VFS, "Can't push all brlocks!\n");
1141 length = 1 + flock->fl_end - flock->fl_start;
1142 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1146 lck = list_entry(el, struct lock_to_push, llist);
1147 lck->pid = flock->fl_pid;
1148 lck->netfid = cfile->fid.netfid;
1149 lck->length = length;
1151 lck->offset = flock->fl_start;
1156 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1159 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1160 lck->offset, lck->length, NULL,
1164 list_del(&lck->llist);
1172 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1173 list_del(&lck->llist);
1180 cifs_push_locks(struct cifsFileInfo *cfile)
1182 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1183 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1184 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1187 /* we are going to update can_cache_brlcks here - need a write access */
1188 down_write(&cinode->lock_sem);
1189 if (!cinode->can_cache_brlcks) {
1190 up_write(&cinode->lock_sem);
1194 if (cap_unix(tcon->ses) &&
1195 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1196 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1197 rc = cifs_push_posix_locks(cfile);
1199 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1201 cinode->can_cache_brlcks = false;
1202 up_write(&cinode->lock_sem);
1207 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1208 bool *wait_flag, struct TCP_Server_Info *server)
1210 if (flock->fl_flags & FL_POSIX)
1211 cifs_dbg(FYI, "Posix\n");
1212 if (flock->fl_flags & FL_FLOCK)
1213 cifs_dbg(FYI, "Flock\n");
1214 if (flock->fl_flags & FL_SLEEP) {
1215 cifs_dbg(FYI, "Blocking lock\n");
1218 if (flock->fl_flags & FL_ACCESS)
1219 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1220 if (flock->fl_flags & FL_LEASE)
1221 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1222 if (flock->fl_flags &
1223 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1224 FL_ACCESS | FL_LEASE | FL_CLOSE)))
1225 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1227 *type = server->vals->large_lock_type;
1228 if (flock->fl_type == F_WRLCK) {
1229 cifs_dbg(FYI, "F_WRLCK\n");
1230 *type |= server->vals->exclusive_lock_type;
1232 } else if (flock->fl_type == F_UNLCK) {
1233 cifs_dbg(FYI, "F_UNLCK\n");
1234 *type |= server->vals->unlock_lock_type;
1236 /* Check if unlock includes more than one lock range */
1237 } else if (flock->fl_type == F_RDLCK) {
1238 cifs_dbg(FYI, "F_RDLCK\n");
1239 *type |= server->vals->shared_lock_type;
1241 } else if (flock->fl_type == F_EXLCK) {
1242 cifs_dbg(FYI, "F_EXLCK\n");
1243 *type |= server->vals->exclusive_lock_type;
1245 } else if (flock->fl_type == F_SHLCK) {
1246 cifs_dbg(FYI, "F_SHLCK\n");
1247 *type |= server->vals->shared_lock_type;
1250 cifs_dbg(FYI, "Unknown type of lock\n");
1254 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1255 bool wait_flag, bool posix_lck, unsigned int xid)
1258 __u64 length = 1 + flock->fl_end - flock->fl_start;
1259 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1260 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1261 struct TCP_Server_Info *server = tcon->ses->server;
1262 __u16 netfid = cfile->fid.netfid;
1265 int posix_lock_type;
1267 rc = cifs_posix_lock_test(file, flock);
1271 if (type & server->vals->shared_lock_type)
1272 posix_lock_type = CIFS_RDLCK;
1274 posix_lock_type = CIFS_WRLCK;
1275 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1276 flock->fl_start, length, flock,
1277 posix_lock_type, wait_flag);
1281 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1285 /* BB we could chain these into one lock request BB */
1286 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1289 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1291 flock->fl_type = F_UNLCK;
1293 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1298 if (type & server->vals->shared_lock_type) {
1299 flock->fl_type = F_WRLCK;
1303 type &= ~server->vals->exclusive_lock_type;
1305 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1306 type | server->vals->shared_lock_type,
1309 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1310 type | server->vals->shared_lock_type, 0, 1, false);
1311 flock->fl_type = F_RDLCK;
1313 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1316 flock->fl_type = F_WRLCK;
1322 cifs_move_llist(struct list_head *source, struct list_head *dest)
1324 struct list_head *li, *tmp;
1325 list_for_each_safe(li, tmp, source)
1326 list_move(li, dest);
1330 cifs_free_llist(struct list_head *llist)
1332 struct cifsLockInfo *li, *tmp;
1333 list_for_each_entry_safe(li, tmp, llist, llist) {
1334 cifs_del_lock_waiters(li);
1335 list_del(&li->llist);
1341 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1344 int rc = 0, stored_rc;
1345 int types[] = {LOCKING_ANDX_LARGE_FILES,
1346 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1348 unsigned int max_num, num, max_buf;
1349 LOCKING_ANDX_RANGE *buf, *cur;
1350 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1351 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1352 struct cifsLockInfo *li, *tmp;
1353 __u64 length = 1 + flock->fl_end - flock->fl_start;
1354 struct list_head tmp_llist;
1356 INIT_LIST_HEAD(&tmp_llist);
1359 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1360 * and check it for zero before using.
1362 max_buf = tcon->ses->server->maxBuf;
1366 max_num = (max_buf - sizeof(struct smb_hdr)) /
1367 sizeof(LOCKING_ANDX_RANGE);
1368 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1372 down_write(&cinode->lock_sem);
1373 for (i = 0; i < 2; i++) {
1376 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1377 if (flock->fl_start > li->offset ||
1378 (flock->fl_start + length) <
1379 (li->offset + li->length))
1381 if (current->tgid != li->pid)
1383 if (types[i] != li->type)
1385 if (cinode->can_cache_brlcks) {
1387 * We can cache brlock requests - simply remove
1388 * a lock from the file's list.
1390 list_del(&li->llist);
1391 cifs_del_lock_waiters(li);
1395 cur->Pid = cpu_to_le16(li->pid);
1396 cur->LengthLow = cpu_to_le32((u32)li->length);
1397 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1398 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1399 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1401 * We need to save a lock here to let us add it again to
1402 * the file's list if the unlock range request fails on
1405 list_move(&li->llist, &tmp_llist);
1406 if (++num == max_num) {
1407 stored_rc = cifs_lockv(xid, tcon,
1409 li->type, num, 0, buf);
1412 * We failed on the unlock range
1413 * request - add all locks from the tmp
1414 * list to the head of the file's list.
1416 cifs_move_llist(&tmp_llist,
1417 &cfile->llist->locks);
1421 * The unlock range request succeed -
1422 * free the tmp list.
1424 cifs_free_llist(&tmp_llist);
1431 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1432 types[i], num, 0, buf);
1434 cifs_move_llist(&tmp_llist,
1435 &cfile->llist->locks);
1438 cifs_free_llist(&tmp_llist);
1442 up_write(&cinode->lock_sem);
1448 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1449 bool wait_flag, bool posix_lck, int lock, int unlock,
1453 __u64 length = 1 + flock->fl_end - flock->fl_start;
1454 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1455 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1456 struct TCP_Server_Info *server = tcon->ses->server;
1457 struct inode *inode = cfile->dentry->d_inode;
1460 int posix_lock_type;
1462 rc = cifs_posix_lock_set(file, flock);
1466 if (type & server->vals->shared_lock_type)
1467 posix_lock_type = CIFS_RDLCK;
1469 posix_lock_type = CIFS_WRLCK;
1472 posix_lock_type = CIFS_UNLCK;
1474 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1475 current->tgid, flock->fl_start, length,
1476 NULL, posix_lock_type, wait_flag);
1481 struct cifsLockInfo *lock;
1483 lock = cifs_lock_init(flock->fl_start, length, type);
1487 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1496 * Windows 7 server can delay breaking lease from read to None
1497 * if we set a byte-range lock on a file - break it explicitly
1498 * before sending the lock to the server to be sure the next
1499 * read won't conflict with non-overlapted locks due to
1502 if (!CIFS_I(inode)->clientCanCacheAll &&
1503 CIFS_I(inode)->clientCanCacheRead) {
1504 cifs_invalidate_mapping(inode);
1505 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1507 CIFS_I(inode)->clientCanCacheRead = false;
1510 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1511 type, 1, 0, wait_flag);
1517 cifs_lock_add(cfile, lock);
1519 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1522 if (flock->fl_flags & FL_POSIX)
1523 posix_lock_file_wait(file, flock);
1527 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1530 int lock = 0, unlock = 0;
1531 bool wait_flag = false;
1532 bool posix_lck = false;
1533 struct cifs_sb_info *cifs_sb;
1534 struct cifs_tcon *tcon;
1535 struct cifsInodeInfo *cinode;
1536 struct cifsFileInfo *cfile;
1543 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1544 cmd, flock->fl_flags, flock->fl_type,
1545 flock->fl_start, flock->fl_end);
1547 cfile = (struct cifsFileInfo *)file->private_data;
1548 tcon = tlink_tcon(cfile->tlink);
1550 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1553 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1554 netfid = cfile->fid.netfid;
1555 cinode = CIFS_I(file_inode(file));
1557 if (cap_unix(tcon->ses) &&
1558 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1559 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1562 * BB add code here to normalize offset and length to account for
1563 * negative length which we can not accept over the wire.
1565 if (IS_GETLK(cmd)) {
1566 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1571 if (!lock && !unlock) {
1573 * if no lock or unlock then nothing to do since we do not
1580 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1587 * update the file size (if needed) after a write. Should be called with
1588 * the inode->i_lock held
1591 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1592 unsigned int bytes_written)
1594 loff_t end_of_write = offset + bytes_written;
1596 if (end_of_write > cifsi->server_eof)
1597 cifsi->server_eof = end_of_write;
1601 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1602 size_t write_size, loff_t *offset)
1605 unsigned int bytes_written = 0;
1606 unsigned int total_written;
1607 struct cifs_sb_info *cifs_sb;
1608 struct cifs_tcon *tcon;
1609 struct TCP_Server_Info *server;
1611 struct dentry *dentry = open_file->dentry;
1612 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1613 struct cifs_io_parms io_parms;
1615 cifs_sb = CIFS_SB(dentry->d_sb);
1617 cifs_dbg(FYI, "write %zd bytes to offset %lld of %s\n",
1618 write_size, *offset, dentry->d_name.name);
1620 tcon = tlink_tcon(open_file->tlink);
1621 server = tcon->ses->server;
1623 if (!server->ops->sync_write)
1628 for (total_written = 0; write_size > total_written;
1629 total_written += bytes_written) {
1631 while (rc == -EAGAIN) {
1635 if (open_file->invalidHandle) {
1636 /* we could deadlock if we called
1637 filemap_fdatawait from here so tell
1638 reopen_file not to flush data to
1640 rc = cifs_reopen_file(open_file, false);
1645 len = min((size_t)cifs_sb->wsize,
1646 write_size - total_written);
1647 /* iov[0] is reserved for smb header */
1648 iov[1].iov_base = (char *)write_data + total_written;
1649 iov[1].iov_len = len;
1651 io_parms.tcon = tcon;
1652 io_parms.offset = *offset;
1653 io_parms.length = len;
1654 rc = server->ops->sync_write(xid, open_file, &io_parms,
1655 &bytes_written, iov, 1);
1657 if (rc || (bytes_written == 0)) {
1665 spin_lock(&dentry->d_inode->i_lock);
1666 cifs_update_eof(cifsi, *offset, bytes_written);
1667 spin_unlock(&dentry->d_inode->i_lock);
1668 *offset += bytes_written;
1672 cifs_stats_bytes_written(tcon, total_written);
1674 if (total_written > 0) {
1675 spin_lock(&dentry->d_inode->i_lock);
1676 if (*offset > dentry->d_inode->i_size)
1677 i_size_write(dentry->d_inode, *offset);
1678 spin_unlock(&dentry->d_inode->i_lock);
1680 mark_inode_dirty_sync(dentry->d_inode);
1682 return total_written;
1685 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1688 struct cifsFileInfo *open_file = NULL;
1689 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1691 /* only filter by fsuid on multiuser mounts */
1692 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1695 spin_lock(&cifs_file_list_lock);
1696 /* we could simply get the first_list_entry since write-only entries
1697 are always at the end of the list but since the first entry might
1698 have a close pending, we go through the whole list */
1699 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1700 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1702 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1703 if (!open_file->invalidHandle) {
1704 /* found a good file */
1705 /* lock it so it will not be closed on us */
1706 cifsFileInfo_get_locked(open_file);
1707 spin_unlock(&cifs_file_list_lock);
1709 } /* else might as well continue, and look for
1710 another, or simply have the caller reopen it
1711 again rather than trying to fix this handle */
1712 } else /* write only file */
1713 break; /* write only files are last so must be done */
1715 spin_unlock(&cifs_file_list_lock);
1719 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1722 struct cifsFileInfo *open_file, *inv_file = NULL;
1723 struct cifs_sb_info *cifs_sb;
1724 bool any_available = false;
1726 unsigned int refind = 0;
1728 /* Having a null inode here (because mapping->host was set to zero by
1729 the VFS or MM) should not happen but we had reports of on oops (due to
1730 it being zero) during stress testcases so we need to check for it */
1732 if (cifs_inode == NULL) {
1733 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1738 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1740 /* only filter by fsuid on multiuser mounts */
1741 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1744 spin_lock(&cifs_file_list_lock);
1746 if (refind > MAX_REOPEN_ATT) {
1747 spin_unlock(&cifs_file_list_lock);
1750 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1751 if (!any_available && open_file->pid != current->tgid)
1753 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1755 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1756 if (!open_file->invalidHandle) {
1757 /* found a good writable file */
1758 cifsFileInfo_get_locked(open_file);
1759 spin_unlock(&cifs_file_list_lock);
1763 inv_file = open_file;
1767 /* couldn't find useable FH with same pid, try any available */
1768 if (!any_available) {
1769 any_available = true;
1770 goto refind_writable;
1774 any_available = false;
1775 cifsFileInfo_get_locked(inv_file);
1778 spin_unlock(&cifs_file_list_lock);
1781 rc = cifs_reopen_file(inv_file, false);
1785 spin_lock(&cifs_file_list_lock);
1786 list_move_tail(&inv_file->flist,
1787 &cifs_inode->openFileList);
1788 spin_unlock(&cifs_file_list_lock);
1789 cifsFileInfo_put(inv_file);
1790 spin_lock(&cifs_file_list_lock);
1792 goto refind_writable;
1799 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1801 struct address_space *mapping = page->mapping;
1802 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1805 int bytes_written = 0;
1806 struct inode *inode;
1807 struct cifsFileInfo *open_file;
1809 if (!mapping || !mapping->host)
1812 inode = page->mapping->host;
1814 offset += (loff_t)from;
1815 write_data = kmap(page);
1818 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1823 /* racing with truncate? */
1824 if (offset > mapping->host->i_size) {
1826 return 0; /* don't care */
1829 /* check to make sure that we are not extending the file */
1830 if (mapping->host->i_size - offset < (loff_t)to)
1831 to = (unsigned)(mapping->host->i_size - offset);
1833 open_file = find_writable_file(CIFS_I(mapping->host), false);
1835 bytes_written = cifs_write(open_file, open_file->pid,
1836 write_data, to - from, &offset);
1837 cifsFileInfo_put(open_file);
1838 /* Does mm or vfs already set times? */
1839 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1840 if ((bytes_written > 0) && (offset))
1842 else if (bytes_written < 0)
1845 cifs_dbg(FYI, "No writeable filehandles for inode\n");
1853 static int cifs_writepages(struct address_space *mapping,
1854 struct writeback_control *wbc)
1856 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1857 bool done = false, scanned = false, range_whole = false;
1859 struct cifs_writedata *wdata;
1860 struct TCP_Server_Info *server;
1865 * If wsize is smaller than the page cache size, default to writing
1866 * one page at a time via cifs_writepage
1868 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1869 return generic_writepages(mapping, wbc);
1871 if (wbc->range_cyclic) {
1872 index = mapping->writeback_index; /* Start from prev offset */
1875 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1876 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1877 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1882 while (!done && index <= end) {
1883 unsigned int i, nr_pages, found_pages;
1884 pgoff_t next = 0, tofind;
1885 struct page **pages;
1887 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1890 wdata = cifs_writedata_alloc((unsigned int)tofind,
1891 cifs_writev_complete);
1898 * find_get_pages_tag seems to return a max of 256 on each
1899 * iteration, so we must call it several times in order to
1900 * fill the array or the wsize is effectively limited to
1901 * 256 * PAGE_CACHE_SIZE.
1904 pages = wdata->pages;
1906 nr_pages = find_get_pages_tag(mapping, &index,
1907 PAGECACHE_TAG_DIRTY,
1909 found_pages += nr_pages;
1912 } while (nr_pages && tofind && index <= end);
1914 if (found_pages == 0) {
1915 kref_put(&wdata->refcount, cifs_writedata_release);
1920 for (i = 0; i < found_pages; i++) {
1921 page = wdata->pages[i];
1923 * At this point we hold neither mapping->tree_lock nor
1924 * lock on the page itself: the page may be truncated or
1925 * invalidated (changing page->mapping to NULL), or even
1926 * swizzled back from swapper_space to tmpfs file
1932 else if (!trylock_page(page))
1935 if (unlikely(page->mapping != mapping)) {
1940 if (!wbc->range_cyclic && page->index > end) {
1946 if (next && (page->index != next)) {
1947 /* Not next consecutive page */
1952 if (wbc->sync_mode != WB_SYNC_NONE)
1953 wait_on_page_writeback(page);
1955 if (PageWriteback(page) ||
1956 !clear_page_dirty_for_io(page)) {
1962 * This actually clears the dirty bit in the radix tree.
1963 * See cifs_writepage() for more commentary.
1965 set_page_writeback(page);
1967 if (page_offset(page) >= i_size_read(mapping->host)) {
1970 end_page_writeback(page);
1974 wdata->pages[i] = page;
1975 next = page->index + 1;
1979 /* reset index to refind any pages skipped */
1981 index = wdata->pages[0]->index + 1;
1983 /* put any pages we aren't going to use */
1984 for (i = nr_pages; i < found_pages; i++) {
1985 page_cache_release(wdata->pages[i]);
1986 wdata->pages[i] = NULL;
1989 /* nothing to write? */
1990 if (nr_pages == 0) {
1991 kref_put(&wdata->refcount, cifs_writedata_release);
1995 wdata->sync_mode = wbc->sync_mode;
1996 wdata->nr_pages = nr_pages;
1997 wdata->offset = page_offset(wdata->pages[0]);
1998 wdata->pagesz = PAGE_CACHE_SIZE;
2000 min(i_size_read(mapping->host) -
2001 page_offset(wdata->pages[nr_pages - 1]),
2002 (loff_t)PAGE_CACHE_SIZE);
2003 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) +
2007 if (wdata->cfile != NULL)
2008 cifsFileInfo_put(wdata->cfile);
2009 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
2011 if (!wdata->cfile) {
2012 cifs_dbg(VFS, "No writable handles for inode\n");
2016 wdata->pid = wdata->cfile->pid;
2017 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2018 rc = server->ops->async_writev(wdata);
2019 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
2021 for (i = 0; i < nr_pages; ++i)
2022 unlock_page(wdata->pages[i]);
2024 /* send failure -- clean up the mess */
2026 for (i = 0; i < nr_pages; ++i) {
2028 redirty_page_for_writepage(wbc,
2031 SetPageError(wdata->pages[i]);
2032 end_page_writeback(wdata->pages[i]);
2033 page_cache_release(wdata->pages[i]);
2036 mapping_set_error(mapping, rc);
2038 kref_put(&wdata->refcount, cifs_writedata_release);
2040 wbc->nr_to_write -= nr_pages;
2041 if (wbc->nr_to_write <= 0)
2047 if (!scanned && !done) {
2049 * We hit the last page and there is more work to be done: wrap
2050 * back to the start of the file
2057 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2058 mapping->writeback_index = index;
2064 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2070 /* BB add check for wbc flags */
2071 page_cache_get(page);
2072 if (!PageUptodate(page))
2073 cifs_dbg(FYI, "ppw - page not up to date\n");
2076 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2078 * A writepage() implementation always needs to do either this,
2079 * or re-dirty the page with "redirty_page_for_writepage()" in
2080 * the case of a failure.
2082 * Just unlocking the page will cause the radix tree tag-bits
2083 * to fail to update with the state of the page correctly.
2085 set_page_writeback(page);
2087 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
2088 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2090 else if (rc == -EAGAIN)
2091 redirty_page_for_writepage(wbc, page);
2095 SetPageUptodate(page);
2096 end_page_writeback(page);
2097 page_cache_release(page);
2102 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2104 int rc = cifs_writepage_locked(page, wbc);
2109 static int cifs_write_end(struct file *file, struct address_space *mapping,
2110 loff_t pos, unsigned len, unsigned copied,
2111 struct page *page, void *fsdata)
2114 struct inode *inode = mapping->host;
2115 struct cifsFileInfo *cfile = file->private_data;
2116 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2119 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2122 pid = current->tgid;
2124 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2127 if (PageChecked(page)) {
2129 SetPageUptodate(page);
2130 ClearPageChecked(page);
2131 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
2132 SetPageUptodate(page);
2134 if (!PageUptodate(page)) {
2136 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
2140 /* this is probably better than directly calling
2141 partialpage_write since in this function the file handle is
2142 known which we might as well leverage */
2143 /* BB check if anything else missing out of ppw
2144 such as updating last write time */
2145 page_data = kmap(page);
2146 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2147 /* if (rc < 0) should we set writebehind rc? */
2154 set_page_dirty(page);
2158 spin_lock(&inode->i_lock);
2159 if (pos > inode->i_size)
2160 i_size_write(inode, pos);
2161 spin_unlock(&inode->i_lock);
2165 page_cache_release(page);
2170 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2175 struct cifs_tcon *tcon;
2176 struct TCP_Server_Info *server;
2177 struct cifsFileInfo *smbfile = file->private_data;
2178 struct inode *inode = file_inode(file);
2179 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2181 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2184 mutex_lock(&inode->i_mutex);
2188 cifs_dbg(FYI, "Sync file - name: %s datasync: 0x%x\n",
2189 file->f_path.dentry->d_name.name, datasync);
2191 if (!CIFS_I(inode)->clientCanCacheRead) {
2192 rc = cifs_invalidate_mapping(inode);
2194 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2195 rc = 0; /* don't care about it in fsync */
2199 tcon = tlink_tcon(smbfile->tlink);
2200 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2201 server = tcon->ses->server;
2202 if (server->ops->flush)
2203 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2209 mutex_unlock(&inode->i_mutex);
2213 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2217 struct cifs_tcon *tcon;
2218 struct TCP_Server_Info *server;
2219 struct cifsFileInfo *smbfile = file->private_data;
2220 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2221 struct inode *inode = file->f_mapping->host;
2223 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2226 mutex_lock(&inode->i_mutex);
2230 cifs_dbg(FYI, "Sync file - name: %s datasync: 0x%x\n",
2231 file->f_path.dentry->d_name.name, datasync);
2233 tcon = tlink_tcon(smbfile->tlink);
2234 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2235 server = tcon->ses->server;
2236 if (server->ops->flush)
2237 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2243 mutex_unlock(&inode->i_mutex);
2248 * As file closes, flush all cached write data for this inode checking
2249 * for write behind errors.
2251 int cifs_flush(struct file *file, fl_owner_t id)
2253 struct inode *inode = file_inode(file);
2256 if (file->f_mode & FMODE_WRITE)
2257 rc = filemap_write_and_wait(inode->i_mapping);
2259 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2265 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2270 for (i = 0; i < num_pages; i++) {
2271 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2274 * save number of pages we have already allocated and
2275 * return with ENOMEM error
2284 for (i = 0; i < num_pages; i++)
2291 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2296 clen = min_t(const size_t, len, wsize);
2297 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2306 cifs_uncached_writev_complete(struct work_struct *work)
2309 struct cifs_writedata *wdata = container_of(work,
2310 struct cifs_writedata, work);
2311 struct inode *inode = wdata->cfile->dentry->d_inode;
2312 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2314 spin_lock(&inode->i_lock);
2315 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2316 if (cifsi->server_eof > inode->i_size)
2317 i_size_write(inode, cifsi->server_eof);
2318 spin_unlock(&inode->i_lock);
2320 complete(&wdata->done);
2322 if (wdata->result != -EAGAIN) {
2323 for (i = 0; i < wdata->nr_pages; i++)
2324 put_page(wdata->pages[i]);
2327 kref_put(&wdata->refcount, cifs_writedata_release);
2330 /* attempt to send write to server, retry on any -EAGAIN errors */
2332 cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2335 struct TCP_Server_Info *server;
2337 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2340 if (wdata->cfile->invalidHandle) {
2341 rc = cifs_reopen_file(wdata->cfile, false);
2345 rc = server->ops->async_writev(wdata);
2346 } while (rc == -EAGAIN);
2352 cifs_iovec_write(struct file *file, const struct iovec *iov,
2353 unsigned long nr_segs, loff_t *poffset)
2355 unsigned long nr_pages, i;
2356 size_t bytes, copied, len, cur_len;
2357 ssize_t total_written = 0;
2360 struct cifsFileInfo *open_file;
2361 struct cifs_tcon *tcon;
2362 struct cifs_sb_info *cifs_sb;
2363 struct cifs_writedata *wdata, *tmp;
2364 struct list_head wdata_list;
2368 len = iov_length(iov, nr_segs);
2372 rc = generic_write_checks(file, poffset, &len, 0);
2376 INIT_LIST_HEAD(&wdata_list);
2377 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2378 open_file = file->private_data;
2379 tcon = tlink_tcon(open_file->tlink);
2381 if (!tcon->ses->server->ops->async_writev)
2386 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2387 pid = open_file->pid;
2389 pid = current->tgid;
2391 iov_iter_init(&it, iov, nr_segs, len, 0);
2395 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2396 wdata = cifs_writedata_alloc(nr_pages,
2397 cifs_uncached_writev_complete);
2403 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2410 for (i = 0; i < nr_pages; i++) {
2411 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2412 copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2415 iov_iter_advance(&it, copied);
2417 * If we didn't copy as much as we expected, then that
2418 * may mean we trod into an unmapped area. Stop copying
2419 * at that point. On the next pass through the big
2420 * loop, we'll likely end up getting a zero-length
2421 * write and bailing out of it.
2426 cur_len = save_len - cur_len;
2429 * If we have no data to send, then that probably means that
2430 * the copy above failed altogether. That's most likely because
2431 * the address in the iovec was bogus. Set the rc to -EFAULT,
2432 * free anything we allocated and bail out.
2435 for (i = 0; i < nr_pages; i++)
2436 put_page(wdata->pages[i]);
2443 * i + 1 now represents the number of pages we actually used in
2444 * the copy phase above. Bring nr_pages down to that, and free
2445 * any pages that we didn't use.
2447 for ( ; nr_pages > i + 1; nr_pages--)
2448 put_page(wdata->pages[nr_pages - 1]);
2450 wdata->sync_mode = WB_SYNC_ALL;
2451 wdata->nr_pages = nr_pages;
2452 wdata->offset = (__u64)offset;
2453 wdata->cfile = cifsFileInfo_get(open_file);
2455 wdata->bytes = cur_len;
2456 wdata->pagesz = PAGE_SIZE;
2457 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2458 rc = cifs_uncached_retry_writev(wdata);
2460 kref_put(&wdata->refcount, cifs_writedata_release);
2464 list_add_tail(&wdata->list, &wdata_list);
2470 * If at least one write was successfully sent, then discard any rc
2471 * value from the later writes. If the other write succeeds, then
2472 * we'll end up returning whatever was written. If it fails, then
2473 * we'll get a new rc value from that.
2475 if (!list_empty(&wdata_list))
2479 * Wait for and collect replies for any successful sends in order of
2480 * increasing offset. Once an error is hit or we get a fatal signal
2481 * while waiting, then return without waiting for any more replies.
2484 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2486 /* FIXME: freezable too? */
2487 rc = wait_for_completion_killable(&wdata->done);
2490 else if (wdata->result)
2493 total_written += wdata->bytes;
2495 /* resend call if it's a retryable error */
2496 if (rc == -EAGAIN) {
2497 rc = cifs_uncached_retry_writev(wdata);
2501 list_del_init(&wdata->list);
2502 kref_put(&wdata->refcount, cifs_writedata_release);
2505 if (total_written > 0)
2506 *poffset += total_written;
2508 cifs_stats_bytes_written(tcon, total_written);
2509 return total_written ? total_written : (ssize_t)rc;
2512 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2513 unsigned long nr_segs, loff_t pos)
2516 struct inode *inode;
2518 inode = file_inode(iocb->ki_filp);
2521 * BB - optimize the way when signing is disabled. We can drop this
2522 * extra memory-to-memory copying and use iovec buffers for constructing
2526 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2528 CIFS_I(inode)->invalid_mapping = true;
2536 cifs_writev(struct kiocb *iocb, const struct iovec *iov,
2537 unsigned long nr_segs, loff_t pos)
2539 struct file *file = iocb->ki_filp;
2540 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2541 struct inode *inode = file->f_mapping->host;
2542 struct cifsInodeInfo *cinode = CIFS_I(inode);
2543 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2544 ssize_t rc = -EACCES;
2546 BUG_ON(iocb->ki_pos != pos);
2549 * We need to hold the sem to be sure nobody modifies lock list
2550 * with a brlock that prevents writing.
2552 down_read(&cinode->lock_sem);
2553 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2554 server->vals->exclusive_lock_type, NULL,
2556 mutex_lock(&inode->i_mutex);
2557 rc = __generic_file_aio_write(iocb, iov, nr_segs,
2559 mutex_unlock(&inode->i_mutex);
2562 if (rc > 0 || rc == -EIOCBQUEUED) {
2565 err = generic_write_sync(file, pos, rc);
2566 if (err < 0 && rc > 0)
2570 up_read(&cinode->lock_sem);
2575 cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2576 unsigned long nr_segs, loff_t pos)
2578 struct inode *inode = file_inode(iocb->ki_filp);
2579 struct cifsInodeInfo *cinode = CIFS_I(inode);
2580 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2581 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2582 iocb->ki_filp->private_data;
2583 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2586 if (cinode->clientCanCacheAll) {
2587 if (cap_unix(tcon->ses) &&
2588 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2589 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2590 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2591 return cifs_writev(iocb, iov, nr_segs, pos);
2594 * For non-oplocked files in strict cache mode we need to write the data
2595 * to the server exactly from the pos to pos+len-1 rather than flush all
2596 * affected pages because it may cause a error with mandatory locks on
2597 * these pages but not on the region from pos to ppos+len-1.
2599 written = cifs_user_writev(iocb, iov, nr_segs, pos);
2600 if (written > 0 && cinode->clientCanCacheRead) {
2602 * Windows 7 server can delay breaking level2 oplock if a write
2603 * request comes - break it on the client to prevent reading
2606 cifs_invalidate_mapping(inode);
2607 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2609 cinode->clientCanCacheRead = false;
2614 static struct cifs_readdata *
2615 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2617 struct cifs_readdata *rdata;
2619 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2621 if (rdata != NULL) {
2622 kref_init(&rdata->refcount);
2623 INIT_LIST_HEAD(&rdata->list);
2624 init_completion(&rdata->done);
2625 INIT_WORK(&rdata->work, complete);
2632 cifs_readdata_release(struct kref *refcount)
2634 struct cifs_readdata *rdata = container_of(refcount,
2635 struct cifs_readdata, refcount);
2638 cifsFileInfo_put(rdata->cfile);
2644 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2650 for (i = 0; i < nr_pages; i++) {
2651 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2656 rdata->pages[i] = page;
2660 for (i = 0; i < nr_pages; i++) {
2661 put_page(rdata->pages[i]);
2662 rdata->pages[i] = NULL;
2669 cifs_uncached_readdata_release(struct kref *refcount)
2671 struct cifs_readdata *rdata = container_of(refcount,
2672 struct cifs_readdata, refcount);
2675 for (i = 0; i < rdata->nr_pages; i++) {
2676 put_page(rdata->pages[i]);
2677 rdata->pages[i] = NULL;
2679 cifs_readdata_release(refcount);
2683 cifs_retry_async_readv(struct cifs_readdata *rdata)
2686 struct TCP_Server_Info *server;
2688 server = tlink_tcon(rdata->cfile->tlink)->ses->server;
2691 if (rdata->cfile->invalidHandle) {
2692 rc = cifs_reopen_file(rdata->cfile, true);
2696 rc = server->ops->async_readv(rdata);
2697 } while (rc == -EAGAIN);
2703 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2704 * @rdata: the readdata response with list of pages holding data
2705 * @iov: vector in which we should copy the data
2706 * @nr_segs: number of segments in vector
2707 * @offset: offset into file of the first iovec
2708 * @copied: used to return the amount of data copied to the iov
2710 * This function copies data from a list of pages in a readdata response into
2711 * an array of iovecs. It will first calculate where the data should go
2712 * based on the info in the readdata and then copy the data into that spot.
2715 cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2716 unsigned long nr_segs, loff_t offset, ssize_t *copied)
2720 size_t pos = rdata->offset - offset;
2721 ssize_t remaining = rdata->bytes;
2722 unsigned char *pdata;
2725 /* set up iov_iter and advance to the correct offset */
2726 iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2727 iov_iter_advance(&ii, pos);
2730 for (i = 0; i < rdata->nr_pages; i++) {
2732 struct page *page = rdata->pages[i];
2734 /* copy a whole page or whatever's left */
2735 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2737 /* ...but limit it to whatever space is left in the iov */
2738 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2740 /* go while there's data to be copied and no errors */
2743 rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2749 iov_iter_advance(&ii, copy);
2758 cifs_uncached_readv_complete(struct work_struct *work)
2760 struct cifs_readdata *rdata = container_of(work,
2761 struct cifs_readdata, work);
2763 complete(&rdata->done);
2764 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2768 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2769 struct cifs_readdata *rdata, unsigned int len)
2771 int total_read = 0, result = 0;
2773 unsigned int nr_pages = rdata->nr_pages;
2776 rdata->tailsz = PAGE_SIZE;
2777 for (i = 0; i < nr_pages; i++) {
2778 struct page *page = rdata->pages[i];
2780 if (len >= PAGE_SIZE) {
2781 /* enough data to fill the page */
2782 iov.iov_base = kmap(page);
2783 iov.iov_len = PAGE_SIZE;
2784 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2785 i, iov.iov_base, iov.iov_len);
2787 } else if (len > 0) {
2788 /* enough for partial page, fill and zero the rest */
2789 iov.iov_base = kmap(page);
2791 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2792 i, iov.iov_base, iov.iov_len);
2793 memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2794 rdata->tailsz = len;
2797 /* no need to hold page hostage */
2798 rdata->pages[i] = NULL;
2804 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2809 total_read += result;
2812 return total_read > 0 ? total_read : result;
2816 cifs_iovec_read(struct file *file, const struct iovec *iov,
2817 unsigned long nr_segs, loff_t *poffset)
2820 size_t len, cur_len;
2821 ssize_t total_read = 0;
2822 loff_t offset = *poffset;
2823 unsigned int npages;
2824 struct cifs_sb_info *cifs_sb;
2825 struct cifs_tcon *tcon;
2826 struct cifsFileInfo *open_file;
2827 struct cifs_readdata *rdata, *tmp;
2828 struct list_head rdata_list;
2834 len = iov_length(iov, nr_segs);
2838 INIT_LIST_HEAD(&rdata_list);
2839 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2840 open_file = file->private_data;
2841 tcon = tlink_tcon(open_file->tlink);
2843 if (!tcon->ses->server->ops->async_readv)
2846 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2847 pid = open_file->pid;
2849 pid = current->tgid;
2851 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2852 cifs_dbg(FYI, "attempting read on write only file instance\n");
2855 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2856 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2858 /* allocate a readdata struct */
2859 rdata = cifs_readdata_alloc(npages,
2860 cifs_uncached_readv_complete);
2866 rc = cifs_read_allocate_pages(rdata, npages);
2870 rdata->cfile = cifsFileInfo_get(open_file);
2871 rdata->nr_pages = npages;
2872 rdata->offset = offset;
2873 rdata->bytes = cur_len;
2875 rdata->pagesz = PAGE_SIZE;
2876 rdata->read_into_pages = cifs_uncached_read_into_pages;
2878 rc = cifs_retry_async_readv(rdata);
2881 kref_put(&rdata->refcount,
2882 cifs_uncached_readdata_release);
2886 list_add_tail(&rdata->list, &rdata_list);
2891 /* if at least one read request send succeeded, then reset rc */
2892 if (!list_empty(&rdata_list))
2895 /* the loop below should proceed in the order of increasing offsets */
2897 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2901 /* FIXME: freezable sleep too? */
2902 rc = wait_for_completion_killable(&rdata->done);
2905 else if (rdata->result)
2908 rc = cifs_readdata_to_iov(rdata, iov,
2911 total_read += copied;
2914 /* resend call if it's a retryable error */
2915 if (rc == -EAGAIN) {
2916 rc = cifs_retry_async_readv(rdata);
2920 list_del_init(&rdata->list);
2921 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2924 cifs_stats_bytes_read(tcon, total_read);
2925 *poffset += total_read;
2927 /* mask nodata case */
2931 return total_read ? total_read : rc;
2934 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2935 unsigned long nr_segs, loff_t pos)
2939 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2947 cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2948 unsigned long nr_segs, loff_t pos)
2950 struct inode *inode = file_inode(iocb->ki_filp);
2951 struct cifsInodeInfo *cinode = CIFS_I(inode);
2952 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2953 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2954 iocb->ki_filp->private_data;
2955 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2959 * In strict cache mode we need to read from the server all the time
2960 * if we don't have level II oplock because the server can delay mtime
2961 * change - so we can't make a decision about inode invalidating.
2962 * And we can also fail with pagereading if there are mandatory locks
2963 * on pages affected by this read but not on the region from pos to
2966 if (!cinode->clientCanCacheRead)
2967 return cifs_user_readv(iocb, iov, nr_segs, pos);
2969 if (cap_unix(tcon->ses) &&
2970 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2971 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2972 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2975 * We need to hold the sem to be sure nobody modifies lock list
2976 * with a brlock that prevents reading.
2978 down_read(&cinode->lock_sem);
2979 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2980 tcon->ses->server->vals->shared_lock_type,
2981 NULL, CIFS_READ_OP))
2982 rc = generic_file_aio_read(iocb, iov, nr_segs, pos);
2983 up_read(&cinode->lock_sem);
2988 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
2991 unsigned int bytes_read = 0;
2992 unsigned int total_read;
2993 unsigned int current_read_size;
2995 struct cifs_sb_info *cifs_sb;
2996 struct cifs_tcon *tcon;
2997 struct TCP_Server_Info *server;
3000 struct cifsFileInfo *open_file;
3001 struct cifs_io_parms io_parms;
3002 int buf_type = CIFS_NO_BUFFER;
3006 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3008 /* FIXME: set up handlers for larger reads and/or convert to async */
3009 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3011 if (file->private_data == NULL) {
3016 open_file = file->private_data;
3017 tcon = tlink_tcon(open_file->tlink);
3018 server = tcon->ses->server;
3020 if (!server->ops->sync_read) {
3025 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3026 pid = open_file->pid;
3028 pid = current->tgid;
3030 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3031 cifs_dbg(FYI, "attempting read on write only file instance\n");
3033 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3034 total_read += bytes_read, cur_offset += bytes_read) {
3035 current_read_size = min_t(uint, read_size - total_read, rsize);
3037 * For windows me and 9x we do not want to request more than it
3038 * negotiated since it will refuse the read then.
3040 if ((tcon->ses) && !(tcon->ses->capabilities &
3041 tcon->ses->server->vals->cap_large_files)) {
3042 current_read_size = min_t(uint, current_read_size,
3046 while (rc == -EAGAIN) {
3047 if (open_file->invalidHandle) {
3048 rc = cifs_reopen_file(open_file, true);
3053 io_parms.tcon = tcon;
3054 io_parms.offset = *offset;
3055 io_parms.length = current_read_size;
3056 rc = server->ops->sync_read(xid, open_file, &io_parms,
3057 &bytes_read, &cur_offset,
3060 if (rc || (bytes_read == 0)) {
3068 cifs_stats_bytes_read(tcon, total_read);
3069 *offset += bytes_read;
3077 * If the page is mmap'ed into a process' page tables, then we need to make
3078 * sure that it doesn't change while being written back.
3081 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3083 struct page *page = vmf->page;
3086 return VM_FAULT_LOCKED;
3089 static struct vm_operations_struct cifs_file_vm_ops = {
3090 .fault = filemap_fault,
3091 .page_mkwrite = cifs_page_mkwrite,
3092 .remap_pages = generic_file_remap_pages,
3095 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3098 struct inode *inode = file_inode(file);
3102 if (!CIFS_I(inode)->clientCanCacheRead) {
3103 rc = cifs_invalidate_mapping(inode);
3108 rc = generic_file_mmap(file, vma);
3110 vma->vm_ops = &cifs_file_vm_ops;
3115 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3120 rc = cifs_revalidate_file(file);
3122 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3127 rc = generic_file_mmap(file, vma);
3129 vma->vm_ops = &cifs_file_vm_ops;
3135 cifs_readv_complete(struct work_struct *work)
3138 struct cifs_readdata *rdata = container_of(work,
3139 struct cifs_readdata, work);
3141 for (i = 0; i < rdata->nr_pages; i++) {
3142 struct page *page = rdata->pages[i];
3144 lru_cache_add_file(page);
3146 if (rdata->result == 0) {
3147 flush_dcache_page(page);
3148 SetPageUptodate(page);
3153 if (rdata->result == 0)
3154 cifs_readpage_to_fscache(rdata->mapping->host, page);
3156 page_cache_release(page);
3157 rdata->pages[i] = NULL;
3159 kref_put(&rdata->refcount, cifs_readdata_release);
3163 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3164 struct cifs_readdata *rdata, unsigned int len)
3166 int total_read = 0, result = 0;
3170 unsigned int nr_pages = rdata->nr_pages;
3173 /* determine the eof that the server (probably) has */
3174 eof = CIFS_I(rdata->mapping->host)->server_eof;
3175 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
3176 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
3178 rdata->tailsz = PAGE_CACHE_SIZE;
3179 for (i = 0; i < nr_pages; i++) {
3180 struct page *page = rdata->pages[i];
3182 if (len >= PAGE_CACHE_SIZE) {
3183 /* enough data to fill the page */
3184 iov.iov_base = kmap(page);
3185 iov.iov_len = PAGE_CACHE_SIZE;
3186 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3187 i, page->index, iov.iov_base, iov.iov_len);
3188 len -= PAGE_CACHE_SIZE;
3189 } else if (len > 0) {
3190 /* enough for partial page, fill and zero the rest */
3191 iov.iov_base = kmap(page);
3193 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3194 i, page->index, iov.iov_base, iov.iov_len);
3195 memset(iov.iov_base + len,
3196 '\0', PAGE_CACHE_SIZE - len);
3197 rdata->tailsz = len;
3199 } else if (page->index > eof_index) {
3201 * The VFS will not try to do readahead past the
3202 * i_size, but it's possible that we have outstanding
3203 * writes with gaps in the middle and the i_size hasn't
3204 * caught up yet. Populate those with zeroed out pages
3205 * to prevent the VFS from repeatedly attempting to
3206 * fill them until the writes are flushed.
3208 zero_user(page, 0, PAGE_CACHE_SIZE);
3209 lru_cache_add_file(page);
3210 flush_dcache_page(page);
3211 SetPageUptodate(page);
3213 page_cache_release(page);
3214 rdata->pages[i] = NULL;
3218 /* no need to hold page hostage */
3219 lru_cache_add_file(page);
3221 page_cache_release(page);
3222 rdata->pages[i] = NULL;
3227 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3232 total_read += result;
3235 return total_read > 0 ? total_read : result;
3238 static int cifs_readpages(struct file *file, struct address_space *mapping,
3239 struct list_head *page_list, unsigned num_pages)
3242 struct list_head tmplist;
3243 struct cifsFileInfo *open_file = file->private_data;
3244 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3245 unsigned int rsize = cifs_sb->rsize;
3249 * Give up immediately if rsize is too small to read an entire page.
3250 * The VFS will fall back to readpage. We should never reach this
3251 * point however since we set ra_pages to 0 when the rsize is smaller
3252 * than a cache page.
3254 if (unlikely(rsize < PAGE_CACHE_SIZE))
3258 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3259 * immediately if the cookie is negative
3261 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3266 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3267 pid = open_file->pid;
3269 pid = current->tgid;
3272 INIT_LIST_HEAD(&tmplist);
3274 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3275 __func__, file, mapping, num_pages);
3278 * Start with the page at end of list and move it to private
3279 * list. Do the same with any following pages until we hit
3280 * the rsize limit, hit an index discontinuity, or run out of
3281 * pages. Issue the async read and then start the loop again
3282 * until the list is empty.
3284 * Note that list order is important. The page_list is in
3285 * the order of declining indexes. When we put the pages in
3286 * the rdata->pages, then we want them in increasing order.
3288 while (!list_empty(page_list)) {
3290 unsigned int bytes = PAGE_CACHE_SIZE;
3291 unsigned int expected_index;
3292 unsigned int nr_pages = 1;
3294 struct page *page, *tpage;
3295 struct cifs_readdata *rdata;
3297 page = list_entry(page_list->prev, struct page, lru);
3300 * Lock the page and put it in the cache. Since no one else
3301 * should have access to this page, we're safe to simply set
3302 * PG_locked without checking it first.
3304 __set_page_locked(page);
3305 rc = add_to_page_cache_locked(page, mapping,
3306 page->index, GFP_KERNEL);
3308 /* give up if we can't stick it in the cache */
3310 __clear_page_locked(page);
3314 /* move first page to the tmplist */
3315 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3316 list_move_tail(&page->lru, &tmplist);
3318 /* now try and add more pages onto the request */
3319 expected_index = page->index + 1;
3320 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3321 /* discontinuity ? */
3322 if (page->index != expected_index)
3325 /* would this page push the read over the rsize? */
3326 if (bytes + PAGE_CACHE_SIZE > rsize)
3329 __set_page_locked(page);
3330 if (add_to_page_cache_locked(page, mapping,
3331 page->index, GFP_KERNEL)) {
3332 __clear_page_locked(page);
3335 list_move_tail(&page->lru, &tmplist);
3336 bytes += PAGE_CACHE_SIZE;
3341 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3343 /* best to give up if we're out of mem */
3344 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3345 list_del(&page->lru);
3346 lru_cache_add_file(page);
3348 page_cache_release(page);
3354 rdata->cfile = cifsFileInfo_get(open_file);
3355 rdata->mapping = mapping;
3356 rdata->offset = offset;
3357 rdata->bytes = bytes;
3359 rdata->pagesz = PAGE_CACHE_SIZE;
3360 rdata->read_into_pages = cifs_readpages_read_into_pages;
3362 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3363 list_del(&page->lru);
3364 rdata->pages[rdata->nr_pages++] = page;
3367 rc = cifs_retry_async_readv(rdata);
3369 for (i = 0; i < rdata->nr_pages; i++) {
3370 page = rdata->pages[i];
3371 lru_cache_add_file(page);
3373 page_cache_release(page);
3375 kref_put(&rdata->refcount, cifs_readdata_release);
3379 kref_put(&rdata->refcount, cifs_readdata_release);
3385 static int cifs_readpage_worker(struct file *file, struct page *page,
3391 /* Is the page cached? */
3392 rc = cifs_readpage_from_fscache(file_inode(file), page);
3396 page_cache_get(page);
3397 read_data = kmap(page);
3398 /* for reads over a certain size could initiate async read ahead */
3400 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
3405 cifs_dbg(FYI, "Bytes read %d\n", rc);
3407 file_inode(file)->i_atime =
3408 current_fs_time(file_inode(file)->i_sb);
3410 if (PAGE_CACHE_SIZE > rc)
3411 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3413 flush_dcache_page(page);
3414 SetPageUptodate(page);
3416 /* send this page to the cache */
3417 cifs_readpage_to_fscache(file_inode(file), page);
3423 page_cache_release(page);
3429 static int cifs_readpage(struct file *file, struct page *page)
3431 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3437 if (file->private_data == NULL) {
3443 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3444 page, (int)offset, (int)offset);
3446 rc = cifs_readpage_worker(file, page, &offset);
3454 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3456 struct cifsFileInfo *open_file;
3458 spin_lock(&cifs_file_list_lock);
3459 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3460 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3461 spin_unlock(&cifs_file_list_lock);
3465 spin_unlock(&cifs_file_list_lock);
3469 /* We do not want to update the file size from server for inodes
3470 open for write - to avoid races with writepage extending
3471 the file - in the future we could consider allowing
3472 refreshing the inode only on increases in the file size
3473 but this is tricky to do without racing with writebehind
3474 page caching in the current Linux kernel design */
3475 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3480 if (is_inode_writable(cifsInode)) {
3481 /* This inode is open for write at least once */
3482 struct cifs_sb_info *cifs_sb;
3484 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3485 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3486 /* since no page cache to corrupt on directio
3487 we can change size safely */
3491 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3499 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3500 loff_t pos, unsigned len, unsigned flags,
3501 struct page **pagep, void **fsdata)
3503 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3504 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
3505 loff_t page_start = pos & PAGE_MASK;
3510 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
3512 page = grab_cache_page_write_begin(mapping, index, flags);
3518 if (PageUptodate(page))
3522 * If we write a full page it will be up to date, no need to read from
3523 * the server. If the write is short, we'll end up doing a sync write
3526 if (len == PAGE_CACHE_SIZE)
3530 * optimize away the read when we have an oplock, and we're not
3531 * expecting to use any of the data we'd be reading in. That
3532 * is, when the page lies beyond the EOF, or straddles the EOF
3533 * and the write will cover all of the existing data.
3535 if (CIFS_I(mapping->host)->clientCanCacheRead) {
3536 i_size = i_size_read(mapping->host);
3537 if (page_start >= i_size ||
3538 (offset == 0 && (pos + len) >= i_size)) {
3539 zero_user_segments(page, 0, offset,
3543 * PageChecked means that the parts of the page
3544 * to which we're not writing are considered up
3545 * to date. Once the data is copied to the
3546 * page, it can be set uptodate.
3548 SetPageChecked(page);
3553 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
3555 * might as well read a page, it is fast enough. If we get
3556 * an error, we don't need to return it. cifs_write_end will
3557 * do a sync write instead since PG_uptodate isn't set.
3559 cifs_readpage_worker(file, page, &page_start);
3561 /* we could try using another file handle if there is one -
3562 but how would we lock it to prevent close of that handle
3563 racing with this read? In any case
3564 this will be written out by write_end so is fine */
3571 static int cifs_release_page(struct page *page, gfp_t gfp)
3573 if (PagePrivate(page))
3576 return cifs_fscache_release_page(page, gfp);
3579 static void cifs_invalidate_page(struct page *page, unsigned long offset)
3581 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3584 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3587 static int cifs_launder_page(struct page *page)
3590 loff_t range_start = page_offset(page);
3591 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3592 struct writeback_control wbc = {
3593 .sync_mode = WB_SYNC_ALL,
3595 .range_start = range_start,
3596 .range_end = range_end,
3599 cifs_dbg(FYI, "Launder page: %p\n", page);
3601 if (clear_page_dirty_for_io(page))
3602 rc = cifs_writepage_locked(page, &wbc);
3604 cifs_fscache_invalidate_page(page, page->mapping->host);
3608 void cifs_oplock_break(struct work_struct *work)
3610 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3612 struct inode *inode = cfile->dentry->d_inode;
3613 struct cifsInodeInfo *cinode = CIFS_I(inode);
3614 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3617 if (!cinode->clientCanCacheAll && cinode->clientCanCacheRead &&
3618 cifs_has_mand_locks(cinode)) {
3619 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3621 cinode->clientCanCacheRead = false;
3624 if (inode && S_ISREG(inode->i_mode)) {
3625 if (cinode->clientCanCacheRead)
3626 break_lease(inode, O_RDONLY);
3628 break_lease(inode, O_WRONLY);
3629 rc = filemap_fdatawrite(inode->i_mapping);
3630 if (cinode->clientCanCacheRead == 0) {
3631 rc = filemap_fdatawait(inode->i_mapping);
3632 mapping_set_error(inode->i_mapping, rc);
3633 cifs_invalidate_mapping(inode);
3635 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
3638 rc = cifs_push_locks(cfile);
3640 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
3643 * releasing stale oplock after recent reconnect of smb session using
3644 * a now incorrect file handle is not a data integrity issue but do
3645 * not bother sending an oplock release if session to server still is
3646 * disconnected since oplock already released by the server
3648 if (!cfile->oplock_break_cancelled) {
3649 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3651 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
3655 const struct address_space_operations cifs_addr_ops = {
3656 .readpage = cifs_readpage,
3657 .readpages = cifs_readpages,
3658 .writepage = cifs_writepage,
3659 .writepages = cifs_writepages,
3660 .write_begin = cifs_write_begin,
3661 .write_end = cifs_write_end,
3662 .set_page_dirty = __set_page_dirty_nobuffers,
3663 .releasepage = cifs_release_page,
3664 .invalidatepage = cifs_invalidate_page,
3665 .launder_page = cifs_launder_page,
3669 * cifs_readpages requires the server to support a buffer large enough to
3670 * contain the header plus one complete page of data. Otherwise, we need
3671 * to leave cifs_readpages out of the address space operations.
3673 const struct address_space_operations cifs_addr_ops_smallbuf = {
3674 .readpage = cifs_readpage,
3675 .writepage = cifs_writepage,
3676 .writepages = cifs_writepages,
3677 .write_begin = cifs_write_begin,
3678 .write_end = cifs_write_end,
3679 .set_page_dirty = __set_page_dirty_nobuffers,
3680 .releasepage = cifs_release_page,
3681 .invalidatepage = cifs_invalidate_page,
3682 .launder_page = cifs_launder_page,