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 <asm/div64.h>
39 #include "cifsproto.h"
40 #include "cifs_unicode.h"
41 #include "cifs_debug.h"
42 #include "cifs_fs_sb.h"
45 static inline int cifs_convert_flags(unsigned int flags)
47 if ((flags & O_ACCMODE) == O_RDONLY)
49 else if ((flags & O_ACCMODE) == O_WRONLY)
51 else if ((flags & O_ACCMODE) == O_RDWR) {
52 /* GENERIC_ALL is too much permission to request
53 can cause unnecessary access denied on create */
54 /* return GENERIC_ALL; */
55 return (GENERIC_READ | GENERIC_WRITE);
58 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
59 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
63 static u32 cifs_posix_convert_flags(unsigned int flags)
67 if ((flags & O_ACCMODE) == O_RDONLY)
68 posix_flags = SMB_O_RDONLY;
69 else if ((flags & O_ACCMODE) == O_WRONLY)
70 posix_flags = SMB_O_WRONLY;
71 else if ((flags & O_ACCMODE) == O_RDWR)
72 posix_flags = SMB_O_RDWR;
75 posix_flags |= SMB_O_CREAT;
77 posix_flags |= SMB_O_EXCL;
79 posix_flags |= SMB_O_TRUNC;
80 /* be safe and imply O_SYNC for O_DSYNC */
82 posix_flags |= SMB_O_SYNC;
83 if (flags & O_DIRECTORY)
84 posix_flags |= SMB_O_DIRECTORY;
85 if (flags & O_NOFOLLOW)
86 posix_flags |= SMB_O_NOFOLLOW;
88 posix_flags |= SMB_O_DIRECT;
93 static inline int cifs_get_disposition(unsigned int flags)
95 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
97 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
98 return FILE_OVERWRITE_IF;
99 else if ((flags & O_CREAT) == O_CREAT)
101 else if ((flags & O_TRUNC) == O_TRUNC)
102 return FILE_OVERWRITE;
107 static inline int cifs_open_inode_helper(struct inode *inode,
108 struct cifsTconInfo *pTcon, __u32 oplock, FILE_ALL_INFO *buf,
109 char *full_path, int xid)
111 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
112 struct timespec temp;
115 if (pCifsInode->clientCanCacheRead) {
116 /* we have the inode open somewhere else
117 no need to discard cache data */
118 goto client_can_cache;
121 /* BB need same check in cifs_create too? */
122 /* if not oplocked, invalidate inode pages if mtime or file
124 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
125 if (timespec_equal(&inode->i_mtime, &temp) &&
127 (loff_t)le64_to_cpu(buf->EndOfFile))) {
128 cFYI(1, "inode unchanged on server");
130 if (inode->i_mapping) {
131 /* BB no need to lock inode until after invalidate
132 since namei code should already have it locked? */
133 rc = filemap_write_and_wait(inode->i_mapping);
135 pCifsInode->write_behind_rc = rc;
137 cFYI(1, "invalidating remote inode since open detected it "
139 invalidate_remote_inode(inode);
144 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
147 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
150 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
151 pCifsInode->clientCanCacheAll = true;
152 pCifsInode->clientCanCacheRead = true;
153 cFYI(1, "Exclusive Oplock granted on inode %p", inode);
154 } else if ((oplock & 0xF) == OPLOCK_READ)
155 pCifsInode->clientCanCacheRead = true;
160 int cifs_posix_open(char *full_path, struct inode **pinode,
161 struct super_block *sb, int mode, unsigned int f_flags,
162 __u32 *poplock, __u16 *pnetfid, int xid)
165 FILE_UNIX_BASIC_INFO *presp_data;
166 __u32 posix_flags = 0;
167 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
168 struct cifs_fattr fattr;
169 struct tcon_link *tlink;
170 struct cifsTconInfo *tcon;
172 cFYI(1, "posix open %s", full_path);
174 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
175 if (presp_data == NULL)
178 tlink = cifs_sb_tlink(cifs_sb);
184 tcon = tlink_tcon(tlink);
185 mode &= ~current_umask();
187 posix_flags = cifs_posix_convert_flags(f_flags);
188 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
189 poplock, full_path, cifs_sb->local_nls,
190 cifs_sb->mnt_cifs_flags &
191 CIFS_MOUNT_MAP_SPECIAL_CHR);
192 cifs_put_tlink(tlink);
197 if (presp_data->Type == cpu_to_le32(-1))
198 goto posix_open_ret; /* open ok, caller does qpathinfo */
201 goto posix_open_ret; /* caller does not need info */
203 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
205 /* get new inode and set it up */
206 if (*pinode == NULL) {
207 cifs_fill_uniqueid(sb, &fattr);
208 *pinode = cifs_iget(sb, &fattr);
214 cifs_fattr_to_inode(*pinode, &fattr);
222 struct cifsFileInfo *
223 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
224 struct tcon_link *tlink, __u32 oplock)
226 struct dentry *dentry = file->f_path.dentry;
227 struct inode *inode = dentry->d_inode;
228 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
229 struct cifsFileInfo *pCifsFile;
231 pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
232 if (pCifsFile == NULL)
235 pCifsFile->netfid = fileHandle;
236 pCifsFile->pid = current->tgid;
237 pCifsFile->uid = current_fsuid();
238 pCifsFile->dentry = dget(dentry);
239 pCifsFile->f_flags = file->f_flags;
240 pCifsFile->invalidHandle = false;
241 pCifsFile->tlink = cifs_get_tlink(tlink);
242 mutex_init(&pCifsFile->fh_mutex);
243 mutex_init(&pCifsFile->lock_mutex);
244 INIT_LIST_HEAD(&pCifsFile->llist);
245 atomic_set(&pCifsFile->count, 1);
246 INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
248 spin_lock(&cifs_file_list_lock);
249 list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
250 /* if readable file instance put first in list*/
251 if (file->f_mode & FMODE_READ)
252 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
254 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
255 spin_unlock(&cifs_file_list_lock);
257 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
258 pCifsInode->clientCanCacheAll = true;
259 pCifsInode->clientCanCacheRead = true;
260 cFYI(1, "Exclusive Oplock inode %p", inode);
261 } else if ((oplock & 0xF) == OPLOCK_READ)
262 pCifsInode->clientCanCacheRead = true;
264 file->private_data = pCifsFile;
269 * Release a reference on the file private data. This may involve closing
270 * the filehandle out on the server.
272 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
274 struct cifsTconInfo *tcon = tlink_tcon(cifs_file->tlink);
275 struct cifsInodeInfo *cifsi = CIFS_I(cifs_file->dentry->d_inode);
276 struct cifsLockInfo *li, *tmp;
278 spin_lock(&cifs_file_list_lock);
279 if (!atomic_dec_and_test(&cifs_file->count)) {
280 spin_unlock(&cifs_file_list_lock);
284 /* remove it from the lists */
285 list_del(&cifs_file->flist);
286 list_del(&cifs_file->tlist);
288 if (list_empty(&cifsi->openFileList)) {
289 cFYI(1, "closing last open instance for inode %p",
290 cifs_file->dentry->d_inode);
291 cifsi->clientCanCacheRead = false;
292 cifsi->clientCanCacheAll = false;
294 spin_unlock(&cifs_file_list_lock);
296 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
300 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
304 /* Delete any outstanding lock records. We'll lose them when the file
307 mutex_lock(&cifs_file->lock_mutex);
308 list_for_each_entry_safe(li, tmp, &cifs_file->llist, llist) {
309 list_del(&li->llist);
312 mutex_unlock(&cifs_file->lock_mutex);
314 cifs_put_tlink(cifs_file->tlink);
315 dput(cifs_file->dentry);
319 int cifs_open(struct inode *inode, struct file *file)
324 struct cifs_sb_info *cifs_sb;
325 struct cifsTconInfo *tcon;
326 struct tcon_link *tlink;
327 struct cifsFileInfo *pCifsFile = NULL;
328 struct cifsInodeInfo *pCifsInode;
329 char *full_path = NULL;
333 FILE_ALL_INFO *buf = NULL;
337 cifs_sb = CIFS_SB(inode->i_sb);
338 tlink = cifs_sb_tlink(cifs_sb);
341 return PTR_ERR(tlink);
343 tcon = tlink_tcon(tlink);
345 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
347 full_path = build_path_from_dentry(file->f_path.dentry);
348 if (full_path == NULL) {
353 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
354 inode, file->f_flags, full_path);
361 if (!tcon->broken_posix_open && tcon->unix_ext &&
362 (tcon->ses->capabilities & CAP_UNIX) &&
363 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
364 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
365 /* can not refresh inode info since size could be stale */
366 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
367 cifs_sb->mnt_file_mode /* ignored */,
368 file->f_flags, &oplock, &netfid, xid);
370 cFYI(1, "posix open succeeded");
372 pCifsFile = cifs_new_fileinfo(netfid, file, tlink,
374 if (pCifsFile == NULL) {
375 CIFSSMBClose(xid, tcon, netfid);
379 cifs_fscache_set_inode_cookie(inode, file);
382 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
383 if (tcon->ses->serverNOS)
384 cERROR(1, "server %s of type %s returned"
385 " unexpected error on SMB posix open"
386 ", disabling posix open support."
387 " Check if server update available.",
388 tcon->ses->serverName,
389 tcon->ses->serverNOS);
390 tcon->broken_posix_open = true;
391 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
392 (rc != -EOPNOTSUPP)) /* path not found or net err */
394 /* else fallthrough to retry open the old way on network i/o
398 desiredAccess = cifs_convert_flags(file->f_flags);
400 /*********************************************************************
401 * open flag mapping table:
403 * POSIX Flag CIFS Disposition
404 * ---------- ----------------
405 * O_CREAT FILE_OPEN_IF
406 * O_CREAT | O_EXCL FILE_CREATE
407 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
408 * O_TRUNC FILE_OVERWRITE
409 * none of the above FILE_OPEN
411 * Note that there is not a direct match between disposition
412 * FILE_SUPERSEDE (ie create whether or not file exists although
413 * O_CREAT | O_TRUNC is similar but truncates the existing
414 * file rather than creating a new file as FILE_SUPERSEDE does
415 * (which uses the attributes / metadata passed in on open call)
417 *? O_SYNC is a reasonable match to CIFS writethrough flag
418 *? and the read write flags match reasonably. O_LARGEFILE
419 *? is irrelevant because largefile support is always used
420 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
421 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
422 *********************************************************************/
424 disposition = cifs_get_disposition(file->f_flags);
426 /* BB pass O_SYNC flag through on file attributes .. BB */
428 /* Also refresh inode by passing in file_info buf returned by SMBOpen
429 and calling get_inode_info with returned buf (at least helps
430 non-Unix server case) */
432 /* BB we can not do this if this is the second open of a file
433 and the first handle has writebehind data, we might be
434 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
435 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
441 if (tcon->ses->capabilities & CAP_NT_SMBS)
442 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
443 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
444 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
445 & CIFS_MOUNT_MAP_SPECIAL_CHR);
447 rc = -EIO; /* no NT SMB support fall into legacy open below */
450 /* Old server, try legacy style OpenX */
451 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
452 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
453 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
454 & CIFS_MOUNT_MAP_SPECIAL_CHR);
457 cFYI(1, "cifs_open returned 0x%x", rc);
461 rc = cifs_open_inode_helper(inode, tcon, oplock, buf, full_path, xid);
465 pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
466 if (pCifsFile == NULL) {
471 cifs_fscache_set_inode_cookie(inode, file);
473 if (oplock & CIFS_CREATE_ACTION) {
474 /* time to set mode which we can not set earlier due to
475 problems creating new read-only files */
476 if (tcon->unix_ext) {
477 struct cifs_unix_set_info_args args = {
478 .mode = inode->i_mode,
481 .ctime = NO_CHANGE_64,
482 .atime = NO_CHANGE_64,
483 .mtime = NO_CHANGE_64,
486 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
488 cifs_sb->mnt_cifs_flags &
489 CIFS_MOUNT_MAP_SPECIAL_CHR);
497 cifs_put_tlink(tlink);
501 /* Try to reacquire byte range locks that were released when session */
502 /* to server was lost */
503 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
507 /* BB list all locks open on this file and relock */
512 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
517 struct cifs_sb_info *cifs_sb;
518 struct cifsTconInfo *tcon;
519 struct cifsInodeInfo *pCifsInode;
521 char *full_path = NULL;
523 int disposition = FILE_OPEN;
527 mutex_lock(&pCifsFile->fh_mutex);
528 if (!pCifsFile->invalidHandle) {
529 mutex_unlock(&pCifsFile->fh_mutex);
535 inode = pCifsFile->dentry->d_inode;
536 cifs_sb = CIFS_SB(inode->i_sb);
537 tcon = tlink_tcon(pCifsFile->tlink);
539 /* can not grab rename sem here because various ops, including
540 those that already have the rename sem can end up causing writepage
541 to get called and if the server was down that means we end up here,
542 and we can never tell if the caller already has the rename_sem */
543 full_path = build_path_from_dentry(pCifsFile->dentry);
544 if (full_path == NULL) {
546 mutex_unlock(&pCifsFile->fh_mutex);
551 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
552 inode, pCifsFile->f_flags, full_path);
559 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
560 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
561 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
564 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
565 * original open. Must mask them off for a reopen.
567 unsigned int oflags = pCifsFile->f_flags &
568 ~(O_CREAT | O_EXCL | O_TRUNC);
570 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
571 cifs_sb->mnt_file_mode /* ignored */,
572 oflags, &oplock, &netfid, xid);
574 cFYI(1, "posix reopen succeeded");
577 /* fallthrough to retry open the old way on errors, especially
578 in the reconnect path it is important to retry hard */
581 desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
583 /* Can not refresh inode by passing in file_info buf to be returned
584 by SMBOpen and then calling get_inode_info with returned buf
585 since file might have write behind data that needs to be flushed
586 and server version of file size can be stale. If we knew for sure
587 that inode was not dirty locally we could do this */
589 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
590 CREATE_NOT_DIR, &netfid, &oplock, NULL,
591 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
592 CIFS_MOUNT_MAP_SPECIAL_CHR);
594 mutex_unlock(&pCifsFile->fh_mutex);
595 cFYI(1, "cifs_open returned 0x%x", rc);
596 cFYI(1, "oplock: %d", oplock);
597 goto reopen_error_exit;
601 pCifsFile->netfid = netfid;
602 pCifsFile->invalidHandle = false;
603 mutex_unlock(&pCifsFile->fh_mutex);
604 pCifsInode = CIFS_I(inode);
607 rc = filemap_write_and_wait(inode->i_mapping);
609 CIFS_I(inode)->write_behind_rc = rc;
611 pCifsInode->clientCanCacheAll = false;
612 pCifsInode->clientCanCacheRead = false;
614 rc = cifs_get_inode_info_unix(&inode,
615 full_path, inode->i_sb, xid);
617 rc = cifs_get_inode_info(&inode,
618 full_path, NULL, inode->i_sb,
620 } /* else we are writing out data to server already
621 and could deadlock if we tried to flush data, and
622 since we do not know if we have data that would
623 invalidate the current end of file on the server
624 we can not go to the server to get the new inod
626 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
627 pCifsInode->clientCanCacheAll = true;
628 pCifsInode->clientCanCacheRead = true;
629 cFYI(1, "Exclusive Oplock granted on inode %p",
630 pCifsFile->dentry->d_inode);
631 } else if ((oplock & 0xF) == OPLOCK_READ) {
632 pCifsInode->clientCanCacheRead = true;
633 pCifsInode->clientCanCacheAll = false;
635 pCifsInode->clientCanCacheRead = false;
636 pCifsInode->clientCanCacheAll = false;
638 cifs_relock_file(pCifsFile);
646 int cifs_close(struct inode *inode, struct file *file)
648 cifsFileInfo_put(file->private_data);
649 file->private_data = NULL;
651 /* return code from the ->release op is always ignored */
655 int cifs_closedir(struct inode *inode, struct file *file)
659 struct cifsFileInfo *pCFileStruct = file->private_data;
662 cFYI(1, "Closedir inode = 0x%p", inode);
667 struct cifsTconInfo *pTcon = tlink_tcon(pCFileStruct->tlink);
669 cFYI(1, "Freeing private data in close dir");
670 spin_lock(&cifs_file_list_lock);
671 if (!pCFileStruct->srch_inf.endOfSearch &&
672 !pCFileStruct->invalidHandle) {
673 pCFileStruct->invalidHandle = true;
674 spin_unlock(&cifs_file_list_lock);
675 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
676 cFYI(1, "Closing uncompleted readdir with rc %d",
678 /* not much we can do if it fails anyway, ignore rc */
681 spin_unlock(&cifs_file_list_lock);
682 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
684 cFYI(1, "closedir free smb buf in srch struct");
685 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
686 if (pCFileStruct->srch_inf.smallBuf)
687 cifs_small_buf_release(ptmp);
689 cifs_buf_release(ptmp);
691 cifs_put_tlink(pCFileStruct->tlink);
692 kfree(file->private_data);
693 file->private_data = NULL;
695 /* BB can we lock the filestruct while this is going on? */
700 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
701 __u64 offset, __u8 lockType)
703 struct cifsLockInfo *li =
704 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
710 mutex_lock(&fid->lock_mutex);
711 list_add(&li->llist, &fid->llist);
712 mutex_unlock(&fid->lock_mutex);
716 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
722 bool wait_flag = false;
723 struct cifs_sb_info *cifs_sb;
724 struct cifsTconInfo *tcon;
726 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
727 bool posix_locking = 0;
729 length = 1 + pfLock->fl_end - pfLock->fl_start;
733 cFYI(1, "Lock parm: 0x%x flockflags: "
734 "0x%x flocktype: 0x%x start: %lld end: %lld",
735 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
738 if (pfLock->fl_flags & FL_POSIX)
740 if (pfLock->fl_flags & FL_FLOCK)
742 if (pfLock->fl_flags & FL_SLEEP) {
743 cFYI(1, "Blocking lock");
746 if (pfLock->fl_flags & FL_ACCESS)
747 cFYI(1, "Process suspended by mandatory locking - "
748 "not implemented yet");
749 if (pfLock->fl_flags & FL_LEASE)
750 cFYI(1, "Lease on file - not implemented yet");
751 if (pfLock->fl_flags &
752 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
753 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
755 if (pfLock->fl_type == F_WRLCK) {
758 } else if (pfLock->fl_type == F_UNLCK) {
761 /* Check if unlock includes more than
763 } else if (pfLock->fl_type == F_RDLCK) {
765 lockType |= LOCKING_ANDX_SHARED_LOCK;
767 } else if (pfLock->fl_type == F_EXLCK) {
770 } else if (pfLock->fl_type == F_SHLCK) {
772 lockType |= LOCKING_ANDX_SHARED_LOCK;
775 cFYI(1, "Unknown type of lock");
777 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
778 tcon = tlink_tcon(((struct cifsFileInfo *)file->private_data)->tlink);
780 if (file->private_data == NULL) {
785 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
787 if ((tcon->ses->capabilities & CAP_UNIX) &&
788 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
789 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
791 /* BB add code here to normalize offset and length to
792 account for negative length which we can not accept over the
797 if (lockType & LOCKING_ANDX_SHARED_LOCK)
798 posix_lock_type = CIFS_RDLCK;
800 posix_lock_type = CIFS_WRLCK;
801 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
803 posix_lock_type, wait_flag);
808 /* BB we could chain these into one lock request BB */
809 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
810 0, 1, lockType, 0 /* wait flag */ );
812 rc = CIFSSMBLock(xid, tcon, netfid, length,
813 pfLock->fl_start, 1 /* numUnlock */ ,
814 0 /* numLock */ , lockType,
816 pfLock->fl_type = F_UNLCK;
818 cERROR(1, "Error unlocking previously locked "
819 "range %d during test of lock", rc);
823 /* if rc == ERR_SHARING_VIOLATION ? */
826 if (lockType & LOCKING_ANDX_SHARED_LOCK) {
827 pfLock->fl_type = F_WRLCK;
829 rc = CIFSSMBLock(xid, tcon, netfid, length,
830 pfLock->fl_start, 0, 1,
831 lockType | LOCKING_ANDX_SHARED_LOCK,
834 rc = CIFSSMBLock(xid, tcon, netfid,
835 length, pfLock->fl_start, 1, 0,
837 LOCKING_ANDX_SHARED_LOCK,
839 pfLock->fl_type = F_RDLCK;
841 cERROR(1, "Error unlocking "
842 "previously locked range %d "
843 "during test of lock", rc);
846 pfLock->fl_type = F_WRLCK;
856 if (!numLock && !numUnlock) {
857 /* if no lock or unlock then nothing
858 to do since we do not know what it is */
865 if (lockType & LOCKING_ANDX_SHARED_LOCK)
866 posix_lock_type = CIFS_RDLCK;
868 posix_lock_type = CIFS_WRLCK;
871 posix_lock_type = CIFS_UNLCK;
873 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
875 posix_lock_type, wait_flag);
877 struct cifsFileInfo *fid = file->private_data;
880 rc = CIFSSMBLock(xid, tcon, netfid, length,
882 0, numLock, lockType, wait_flag);
885 /* For Windows locks we must store them. */
886 rc = store_file_lock(fid, length,
887 pfLock->fl_start, lockType);
889 } else if (numUnlock) {
890 /* For each stored lock that this unlock overlaps
891 completely, unlock it. */
893 struct cifsLockInfo *li, *tmp;
896 mutex_lock(&fid->lock_mutex);
897 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
898 if (pfLock->fl_start <= li->offset &&
899 (pfLock->fl_start + length) >=
900 (li->offset + li->length)) {
901 stored_rc = CIFSSMBLock(xid, tcon,
903 li->length, li->offset,
904 1, 0, li->type, false);
908 list_del(&li->llist);
913 mutex_unlock(&fid->lock_mutex);
917 if (pfLock->fl_flags & FL_POSIX)
918 posix_lock_file_wait(file, pfLock);
924 * Set the timeout on write requests past EOF. For some servers (Windows)
925 * these calls can be very long.
927 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
928 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
929 * The 10M cutoff is totally arbitrary. A better scheme for this would be
930 * welcome if someone wants to suggest one.
932 * We may be able to do a better job with this if there were some way to
933 * declare that a file should be sparse.
936 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
938 if (offset <= cifsi->server_eof)
940 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
941 return CIFS_VLONG_OP;
946 /* update the file size (if needed) after a write */
948 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
949 unsigned int bytes_written)
951 loff_t end_of_write = offset + bytes_written;
953 if (end_of_write > cifsi->server_eof)
954 cifsi->server_eof = end_of_write;
957 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
958 size_t write_size, loff_t *poffset)
961 unsigned int bytes_written = 0;
962 unsigned int total_written;
963 struct cifs_sb_info *cifs_sb;
964 struct cifsTconInfo *pTcon;
966 struct cifsFileInfo *open_file;
967 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
969 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
971 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
972 *poffset, file->f_path.dentry->d_name.name); */
974 if (file->private_data == NULL)
977 open_file = file->private_data;
978 pTcon = tlink_tcon(open_file->tlink);
980 rc = generic_write_checks(file, poffset, &write_size, 0);
986 long_op = cifs_write_timeout(cifsi, *poffset);
987 for (total_written = 0; write_size > total_written;
988 total_written += bytes_written) {
990 while (rc == -EAGAIN) {
991 if (file->private_data == NULL) {
992 /* file has been closed on us */
994 /* if we have gotten here we have written some data
995 and blocked, and the file has been freed on us while
996 we blocked so return what we managed to write */
997 return total_written;
999 if (open_file->invalidHandle) {
1000 /* we could deadlock if we called
1001 filemap_fdatawait from here so tell
1002 reopen_file not to flush data to server
1004 rc = cifs_reopen_file(open_file, false);
1009 rc = CIFSSMBWrite(xid, pTcon,
1011 min_t(const int, cifs_sb->wsize,
1012 write_size - total_written),
1013 *poffset, &bytes_written,
1014 NULL, write_data + total_written, long_op);
1016 if (rc || (bytes_written == 0)) {
1024 cifs_update_eof(cifsi, *poffset, bytes_written);
1025 *poffset += bytes_written;
1027 long_op = CIFS_STD_OP; /* subsequent writes fast -
1028 15 seconds is plenty */
1031 cifs_stats_bytes_written(pTcon, total_written);
1033 /* since the write may have blocked check these pointers again */
1034 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1035 struct inode *inode = file->f_path.dentry->d_inode;
1036 /* Do not update local mtime - server will set its actual value on write
1037 * inode->i_ctime = inode->i_mtime =
1038 * current_fs_time(inode->i_sb);*/
1039 if (total_written > 0) {
1040 spin_lock(&inode->i_lock);
1041 if (*poffset > file->f_path.dentry->d_inode->i_size)
1042 i_size_write(file->f_path.dentry->d_inode,
1044 spin_unlock(&inode->i_lock);
1046 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1049 return total_written;
1052 static ssize_t cifs_write(struct cifsFileInfo *open_file,
1053 const char *write_data, size_t write_size,
1057 unsigned int bytes_written = 0;
1058 unsigned int total_written;
1059 struct cifs_sb_info *cifs_sb;
1060 struct cifsTconInfo *pTcon;
1062 struct dentry *dentry = open_file->dentry;
1063 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1065 cifs_sb = CIFS_SB(dentry->d_sb);
1067 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1068 *poffset, dentry->d_name.name);
1070 pTcon = tlink_tcon(open_file->tlink);
1074 long_op = cifs_write_timeout(cifsi, *poffset);
1075 for (total_written = 0; write_size > total_written;
1076 total_written += bytes_written) {
1078 while (rc == -EAGAIN) {
1079 if (open_file->invalidHandle) {
1080 /* we could deadlock if we called
1081 filemap_fdatawait from here so tell
1082 reopen_file not to flush data to
1084 rc = cifs_reopen_file(open_file, false);
1088 if (experimEnabled || (pTcon->ses->server &&
1089 ((pTcon->ses->server->secMode &
1090 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1095 len = min((size_t)cifs_sb->wsize,
1096 write_size - total_written);
1097 /* iov[0] is reserved for smb header */
1098 iov[1].iov_base = (char *)write_data +
1100 iov[1].iov_len = len;
1101 rc = CIFSSMBWrite2(xid, pTcon,
1102 open_file->netfid, len,
1103 *poffset, &bytes_written,
1106 rc = CIFSSMBWrite(xid, pTcon,
1108 min_t(const int, cifs_sb->wsize,
1109 write_size - total_written),
1110 *poffset, &bytes_written,
1111 write_data + total_written,
1114 if (rc || (bytes_written == 0)) {
1122 cifs_update_eof(cifsi, *poffset, bytes_written);
1123 *poffset += bytes_written;
1125 long_op = CIFS_STD_OP; /* subsequent writes fast -
1126 15 seconds is plenty */
1129 cifs_stats_bytes_written(pTcon, total_written);
1131 if (total_written > 0) {
1132 spin_lock(&dentry->d_inode->i_lock);
1133 if (*poffset > dentry->d_inode->i_size)
1134 i_size_write(dentry->d_inode, *poffset);
1135 spin_unlock(&dentry->d_inode->i_lock);
1137 mark_inode_dirty_sync(dentry->d_inode);
1139 return total_written;
1142 #ifdef CONFIG_CIFS_EXPERIMENTAL
1143 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1146 struct cifsFileInfo *open_file = NULL;
1147 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1149 /* only filter by fsuid on multiuser mounts */
1150 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1153 spin_lock(&cifs_file_list_lock);
1154 /* we could simply get the first_list_entry since write-only entries
1155 are always at the end of the list but since the first entry might
1156 have a close pending, we go through the whole list */
1157 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1158 if (fsuid_only && open_file->uid != current_fsuid())
1160 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1161 if (!open_file->invalidHandle) {
1162 /* found a good file */
1163 /* lock it so it will not be closed on us */
1164 cifsFileInfo_get(open_file);
1165 spin_unlock(&cifs_file_list_lock);
1167 } /* else might as well continue, and look for
1168 another, or simply have the caller reopen it
1169 again rather than trying to fix this handle */
1170 } else /* write only file */
1171 break; /* write only files are last so must be done */
1173 spin_unlock(&cifs_file_list_lock);
1178 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1181 struct cifsFileInfo *open_file;
1182 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1183 bool any_available = false;
1186 /* Having a null inode here (because mapping->host was set to zero by
1187 the VFS or MM) should not happen but we had reports of on oops (due to
1188 it being zero) during stress testcases so we need to check for it */
1190 if (cifs_inode == NULL) {
1191 cERROR(1, "Null inode passed to cifs_writeable_file");
1196 /* only filter by fsuid on multiuser mounts */
1197 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1200 spin_lock(&cifs_file_list_lock);
1202 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1203 if (!any_available && open_file->pid != current->tgid)
1205 if (fsuid_only && open_file->uid != current_fsuid())
1207 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1208 cifsFileInfo_get(open_file);
1210 if (!open_file->invalidHandle) {
1211 /* found a good writable file */
1212 spin_unlock(&cifs_file_list_lock);
1216 spin_unlock(&cifs_file_list_lock);
1218 /* Had to unlock since following call can block */
1219 rc = cifs_reopen_file(open_file, false);
1223 /* if it fails, try another handle if possible */
1224 cFYI(1, "wp failed on reopen file");
1225 cifsFileInfo_put(open_file);
1227 spin_lock(&cifs_file_list_lock);
1229 /* else we simply continue to the next entry. Thus
1230 we do not loop on reopen errors. If we
1231 can not reopen the file, for example if we
1232 reconnected to a server with another client
1233 racing to delete or lock the file we would not
1234 make progress if we restarted before the beginning
1235 of the loop here. */
1238 /* couldn't find useable FH with same pid, try any available */
1239 if (!any_available) {
1240 any_available = true;
1241 goto refind_writable;
1243 spin_unlock(&cifs_file_list_lock);
1247 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1249 struct address_space *mapping = page->mapping;
1250 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1253 int bytes_written = 0;
1254 struct cifs_sb_info *cifs_sb;
1255 struct inode *inode;
1256 struct cifsFileInfo *open_file;
1258 if (!mapping || !mapping->host)
1261 inode = page->mapping->host;
1262 cifs_sb = CIFS_SB(inode->i_sb);
1264 offset += (loff_t)from;
1265 write_data = kmap(page);
1268 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1273 /* racing with truncate? */
1274 if (offset > mapping->host->i_size) {
1276 return 0; /* don't care */
1279 /* check to make sure that we are not extending the file */
1280 if (mapping->host->i_size - offset < (loff_t)to)
1281 to = (unsigned)(mapping->host->i_size - offset);
1283 open_file = find_writable_file(CIFS_I(mapping->host), false);
1285 bytes_written = cifs_write(open_file, write_data,
1286 to - from, &offset);
1287 cifsFileInfo_put(open_file);
1288 /* Does mm or vfs already set times? */
1289 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1290 if ((bytes_written > 0) && (offset))
1292 else if (bytes_written < 0)
1295 cFYI(1, "No writeable filehandles for inode");
1303 static int cifs_writepages(struct address_space *mapping,
1304 struct writeback_control *wbc)
1306 unsigned int bytes_to_write;
1307 unsigned int bytes_written;
1308 struct cifs_sb_info *cifs_sb;
1312 int range_whole = 0;
1319 struct cifsFileInfo *open_file;
1320 struct cifsTconInfo *tcon;
1321 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1323 struct pagevec pvec;
1328 cifs_sb = CIFS_SB(mapping->host->i_sb);
1331 * If wsize is smaller that the page cache size, default to writing
1332 * one page at a time via cifs_writepage
1334 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1335 return generic_writepages(mapping, wbc);
1337 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1339 return generic_writepages(mapping, wbc);
1342 * if there's no open file, then this is likely to fail too,
1343 * but it'll at least handle the return. Maybe it should be
1346 open_file = find_writable_file(CIFS_I(mapping->host), false);
1349 return generic_writepages(mapping, wbc);
1352 tcon = tlink_tcon(open_file->tlink);
1353 if (!experimEnabled && tcon->ses->server->secMode &
1354 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1355 cifsFileInfo_put(open_file);
1356 return generic_writepages(mapping, wbc);
1358 cifsFileInfo_put(open_file);
1362 pagevec_init(&pvec, 0);
1363 if (wbc->range_cyclic) {
1364 index = mapping->writeback_index; /* Start from prev offset */
1367 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1368 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1369 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1374 while (!done && (index <= end) &&
1375 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1376 PAGECACHE_TAG_DIRTY,
1377 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1386 for (i = 0; i < nr_pages; i++) {
1387 page = pvec.pages[i];
1389 * At this point we hold neither mapping->tree_lock nor
1390 * lock on the page itself: the page may be truncated or
1391 * invalidated (changing page->mapping to NULL), or even
1392 * swizzled back from swapper_space to tmpfs file
1398 else if (!trylock_page(page))
1401 if (unlikely(page->mapping != mapping)) {
1406 if (!wbc->range_cyclic && page->index > end) {
1412 if (next && (page->index != next)) {
1413 /* Not next consecutive page */
1418 if (wbc->sync_mode != WB_SYNC_NONE)
1419 wait_on_page_writeback(page);
1421 if (PageWriteback(page) ||
1422 !clear_page_dirty_for_io(page)) {
1428 * This actually clears the dirty bit in the radix tree.
1429 * See cifs_writepage() for more commentary.
1431 set_page_writeback(page);
1433 if (page_offset(page) >= mapping->host->i_size) {
1436 end_page_writeback(page);
1441 * BB can we get rid of this? pages are held by pvec
1443 page_cache_get(page);
1445 len = min(mapping->host->i_size - page_offset(page),
1446 (loff_t)PAGE_CACHE_SIZE);
1448 /* reserve iov[0] for the smb header */
1450 iov[n_iov].iov_base = kmap(page);
1451 iov[n_iov].iov_len = len;
1452 bytes_to_write += len;
1456 offset = page_offset(page);
1458 next = page->index + 1;
1459 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1463 open_file = find_writable_file(CIFS_I(mapping->host),
1466 cERROR(1, "No writable handles for inode");
1469 long_op = cifs_write_timeout(cifsi, offset);
1470 rc = CIFSSMBWrite2(xid, tcon, open_file->netfid,
1471 bytes_to_write, offset,
1472 &bytes_written, iov, n_iov,
1474 cifsFileInfo_put(open_file);
1475 cifs_update_eof(cifsi, offset, bytes_written);
1478 if (rc || bytes_written < bytes_to_write) {
1479 cERROR(1, "Write2 ret %d, wrote %d",
1481 /* BB what if continued retry is
1482 requested via mount flags? */
1484 set_bit(AS_ENOSPC, &mapping->flags);
1486 set_bit(AS_EIO, &mapping->flags);
1488 cifs_stats_bytes_written(tcon, bytes_written);
1491 for (i = 0; i < n_iov; i++) {
1492 page = pvec.pages[first + i];
1493 /* Should we also set page error on
1494 success rc but too little data written? */
1495 /* BB investigate retry logic on temporary
1496 server crash cases and how recovery works
1497 when page marked as error */
1502 end_page_writeback(page);
1503 page_cache_release(page);
1505 if ((wbc->nr_to_write -= n_iov) <= 0)
1509 /* Need to re-find the pages we skipped */
1510 index = pvec.pages[0]->index + 1;
1512 pagevec_release(&pvec);
1514 if (!scanned && !done) {
1516 * We hit the last page and there is more work to be done: wrap
1517 * back to the start of the file
1523 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1524 mapping->writeback_index = index;
1531 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1537 /* BB add check for wbc flags */
1538 page_cache_get(page);
1539 if (!PageUptodate(page))
1540 cFYI(1, "ppw - page not up to date");
1543 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1545 * A writepage() implementation always needs to do either this,
1546 * or re-dirty the page with "redirty_page_for_writepage()" in
1547 * the case of a failure.
1549 * Just unlocking the page will cause the radix tree tag-bits
1550 * to fail to update with the state of the page correctly.
1552 set_page_writeback(page);
1553 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1554 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1556 end_page_writeback(page);
1557 page_cache_release(page);
1562 static int cifs_write_end(struct file *file, struct address_space *mapping,
1563 loff_t pos, unsigned len, unsigned copied,
1564 struct page *page, void *fsdata)
1567 struct inode *inode = mapping->host;
1569 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1572 if (PageChecked(page)) {
1574 SetPageUptodate(page);
1575 ClearPageChecked(page);
1576 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1577 SetPageUptodate(page);
1579 if (!PageUptodate(page)) {
1581 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1585 /* this is probably better than directly calling
1586 partialpage_write since in this function the file handle is
1587 known which we might as well leverage */
1588 /* BB check if anything else missing out of ppw
1589 such as updating last write time */
1590 page_data = kmap(page);
1591 rc = cifs_write(file->private_data, page_data + offset,
1593 /* if (rc < 0) should we set writebehind rc? */
1600 set_page_dirty(page);
1604 spin_lock(&inode->i_lock);
1605 if (pos > inode->i_size)
1606 i_size_write(inode, pos);
1607 spin_unlock(&inode->i_lock);
1611 page_cache_release(page);
1616 int cifs_fsync(struct file *file, int datasync)
1620 struct cifsTconInfo *tcon;
1621 struct cifsFileInfo *smbfile = file->private_data;
1622 struct inode *inode = file->f_path.dentry->d_inode;
1626 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1627 file->f_path.dentry->d_name.name, datasync);
1629 rc = filemap_write_and_wait(inode->i_mapping);
1631 rc = CIFS_I(inode)->write_behind_rc;
1632 CIFS_I(inode)->write_behind_rc = 0;
1633 tcon = tlink_tcon(smbfile->tlink);
1634 if (!rc && tcon && smbfile &&
1635 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1636 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1643 /* static void cifs_sync_page(struct page *page)
1645 struct address_space *mapping;
1646 struct inode *inode;
1647 unsigned long index = page->index;
1648 unsigned int rpages = 0;
1651 cFYI(1, "sync page %p", page);
1652 mapping = page->mapping;
1655 inode = mapping->host;
1659 /* fill in rpages then
1660 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1662 /* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1672 * As file closes, flush all cached write data for this inode checking
1673 * for write behind errors.
1675 int cifs_flush(struct file *file, fl_owner_t id)
1677 struct inode *inode = file->f_path.dentry->d_inode;
1680 /* Rather than do the steps manually:
1681 lock the inode for writing
1682 loop through pages looking for write behind data (dirty pages)
1683 coalesce into contiguous 16K (or smaller) chunks to write to server
1684 send to server (prefer in parallel)
1685 deal with writebehind errors
1686 unlock inode for writing
1687 filemapfdatawrite appears easier for the time being */
1689 rc = filemap_fdatawrite(inode->i_mapping);
1690 /* reset wb rc if we were able to write out dirty pages */
1692 rc = CIFS_I(inode)->write_behind_rc;
1693 CIFS_I(inode)->write_behind_rc = 0;
1696 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1701 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1702 size_t read_size, loff_t *poffset)
1705 unsigned int bytes_read = 0;
1706 unsigned int total_read = 0;
1707 unsigned int current_read_size;
1708 struct cifs_sb_info *cifs_sb;
1709 struct cifsTconInfo *pTcon;
1711 struct cifsFileInfo *open_file;
1712 char *smb_read_data;
1713 char __user *current_offset;
1714 struct smb_com_read_rsp *pSMBr;
1717 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1719 if (file->private_data == NULL) {
1724 open_file = file->private_data;
1725 pTcon = tlink_tcon(open_file->tlink);
1727 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1728 cFYI(1, "attempting read on write only file instance");
1730 for (total_read = 0, current_offset = read_data;
1731 read_size > total_read;
1732 total_read += bytes_read, current_offset += bytes_read) {
1733 current_read_size = min_t(const int, read_size - total_read,
1736 smb_read_data = NULL;
1737 while (rc == -EAGAIN) {
1738 int buf_type = CIFS_NO_BUFFER;
1739 if (open_file->invalidHandle) {
1740 rc = cifs_reopen_file(open_file, true);
1744 rc = CIFSSMBRead(xid, pTcon,
1746 current_read_size, *poffset,
1747 &bytes_read, &smb_read_data,
1749 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1750 if (smb_read_data) {
1751 if (copy_to_user(current_offset,
1753 4 /* RFC1001 length field */ +
1754 le16_to_cpu(pSMBr->DataOffset),
1758 if (buf_type == CIFS_SMALL_BUFFER)
1759 cifs_small_buf_release(smb_read_data);
1760 else if (buf_type == CIFS_LARGE_BUFFER)
1761 cifs_buf_release(smb_read_data);
1762 smb_read_data = NULL;
1765 if (rc || (bytes_read == 0)) {
1773 cifs_stats_bytes_read(pTcon, bytes_read);
1774 *poffset += bytes_read;
1782 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1786 unsigned int bytes_read = 0;
1787 unsigned int total_read;
1788 unsigned int current_read_size;
1789 struct cifs_sb_info *cifs_sb;
1790 struct cifsTconInfo *pTcon;
1792 char *current_offset;
1793 struct cifsFileInfo *open_file;
1794 int buf_type = CIFS_NO_BUFFER;
1797 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1799 if (file->private_data == NULL) {
1804 open_file = file->private_data;
1805 pTcon = tlink_tcon(open_file->tlink);
1807 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1808 cFYI(1, "attempting read on write only file instance");
1810 for (total_read = 0, current_offset = read_data;
1811 read_size > total_read;
1812 total_read += bytes_read, current_offset += bytes_read) {
1813 current_read_size = min_t(const int, read_size - total_read,
1815 /* For windows me and 9x we do not want to request more
1816 than it negotiated since it will refuse the read then */
1818 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1819 current_read_size = min_t(const int, current_read_size,
1820 pTcon->ses->server->maxBuf - 128);
1823 while (rc == -EAGAIN) {
1824 if (open_file->invalidHandle) {
1825 rc = cifs_reopen_file(open_file, true);
1829 rc = CIFSSMBRead(xid, pTcon,
1831 current_read_size, *poffset,
1832 &bytes_read, ¤t_offset,
1835 if (rc || (bytes_read == 0)) {
1843 cifs_stats_bytes_read(pTcon, total_read);
1844 *poffset += bytes_read;
1851 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1856 rc = cifs_revalidate_file(file);
1858 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1862 rc = generic_file_mmap(file, vma);
1868 static void cifs_copy_cache_pages(struct address_space *mapping,
1869 struct list_head *pages, int bytes_read, char *data)
1874 while (bytes_read > 0) {
1875 if (list_empty(pages))
1878 page = list_entry(pages->prev, struct page, lru);
1879 list_del(&page->lru);
1881 if (add_to_page_cache_lru(page, mapping, page->index,
1883 page_cache_release(page);
1884 cFYI(1, "Add page cache failed");
1885 data += PAGE_CACHE_SIZE;
1886 bytes_read -= PAGE_CACHE_SIZE;
1889 page_cache_release(page);
1891 target = kmap_atomic(page, KM_USER0);
1893 if (PAGE_CACHE_SIZE > bytes_read) {
1894 memcpy(target, data, bytes_read);
1895 /* zero the tail end of this partial page */
1896 memset(target + bytes_read, 0,
1897 PAGE_CACHE_SIZE - bytes_read);
1900 memcpy(target, data, PAGE_CACHE_SIZE);
1901 bytes_read -= PAGE_CACHE_SIZE;
1903 kunmap_atomic(target, KM_USER0);
1905 flush_dcache_page(page);
1906 SetPageUptodate(page);
1908 data += PAGE_CACHE_SIZE;
1910 /* add page to FS-Cache */
1911 cifs_readpage_to_fscache(mapping->host, page);
1916 static int cifs_readpages(struct file *file, struct address_space *mapping,
1917 struct list_head *page_list, unsigned num_pages)
1923 struct cifs_sb_info *cifs_sb;
1924 struct cifsTconInfo *pTcon;
1925 unsigned int bytes_read = 0;
1926 unsigned int read_size, i;
1927 char *smb_read_data = NULL;
1928 struct smb_com_read_rsp *pSMBr;
1929 struct cifsFileInfo *open_file;
1930 int buf_type = CIFS_NO_BUFFER;
1933 if (file->private_data == NULL) {
1938 open_file = file->private_data;
1939 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1940 pTcon = tlink_tcon(open_file->tlink);
1943 * Reads as many pages as possible from fscache. Returns -ENOBUFS
1944 * immediately if the cookie is negative
1946 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
1951 cFYI(DBG2, "rpages: num pages %d", num_pages);
1952 for (i = 0; i < num_pages; ) {
1953 unsigned contig_pages;
1954 struct page *tmp_page;
1955 unsigned long expected_index;
1957 if (list_empty(page_list))
1960 page = list_entry(page_list->prev, struct page, lru);
1961 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1963 /* count adjacent pages that we will read into */
1966 list_entry(page_list->prev, struct page, lru)->index;
1967 list_for_each_entry_reverse(tmp_page, page_list, lru) {
1968 if (tmp_page->index == expected_index) {
1974 if (contig_pages + i > num_pages)
1975 contig_pages = num_pages - i;
1977 /* for reads over a certain size could initiate async
1980 read_size = contig_pages * PAGE_CACHE_SIZE;
1981 /* Read size needs to be in multiples of one page */
1982 read_size = min_t(const unsigned int, read_size,
1983 cifs_sb->rsize & PAGE_CACHE_MASK);
1984 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
1985 read_size, contig_pages);
1987 while (rc == -EAGAIN) {
1988 if (open_file->invalidHandle) {
1989 rc = cifs_reopen_file(open_file, true);
1994 rc = CIFSSMBRead(xid, pTcon,
1997 &bytes_read, &smb_read_data,
1999 /* BB more RC checks ? */
2000 if (rc == -EAGAIN) {
2001 if (smb_read_data) {
2002 if (buf_type == CIFS_SMALL_BUFFER)
2003 cifs_small_buf_release(smb_read_data);
2004 else if (buf_type == CIFS_LARGE_BUFFER)
2005 cifs_buf_release(smb_read_data);
2006 smb_read_data = NULL;
2010 if ((rc < 0) || (smb_read_data == NULL)) {
2011 cFYI(1, "Read error in readpages: %d", rc);
2013 } else if (bytes_read > 0) {
2014 task_io_account_read(bytes_read);
2015 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2016 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2017 smb_read_data + 4 /* RFC1001 hdr */ +
2018 le16_to_cpu(pSMBr->DataOffset));
2020 i += bytes_read >> PAGE_CACHE_SHIFT;
2021 cifs_stats_bytes_read(pTcon, bytes_read);
2022 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2023 i++; /* account for partial page */
2025 /* server copy of file can have smaller size
2027 /* BB do we need to verify this common case ?
2028 this case is ok - if we are at server EOF
2029 we will hit it on next read */
2034 cFYI(1, "No bytes read (%d) at offset %lld . "
2035 "Cleaning remaining pages from readahead list",
2036 bytes_read, offset);
2037 /* BB turn off caching and do new lookup on
2038 file size at server? */
2041 if (smb_read_data) {
2042 if (buf_type == CIFS_SMALL_BUFFER)
2043 cifs_small_buf_release(smb_read_data);
2044 else if (buf_type == CIFS_LARGE_BUFFER)
2045 cifs_buf_release(smb_read_data);
2046 smb_read_data = NULL;
2051 /* need to free smb_read_data buf before exit */
2052 if (smb_read_data) {
2053 if (buf_type == CIFS_SMALL_BUFFER)
2054 cifs_small_buf_release(smb_read_data);
2055 else if (buf_type == CIFS_LARGE_BUFFER)
2056 cifs_buf_release(smb_read_data);
2057 smb_read_data = NULL;
2065 static int cifs_readpage_worker(struct file *file, struct page *page,
2071 /* Is the page cached? */
2072 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2076 page_cache_get(page);
2077 read_data = kmap(page);
2078 /* for reads over a certain size could initiate async read ahead */
2080 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2085 cFYI(1, "Bytes read %d", rc);
2087 file->f_path.dentry->d_inode->i_atime =
2088 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2090 if (PAGE_CACHE_SIZE > rc)
2091 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2093 flush_dcache_page(page);
2094 SetPageUptodate(page);
2096 /* send this page to the cache */
2097 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2103 page_cache_release(page);
2109 static int cifs_readpage(struct file *file, struct page *page)
2111 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2117 if (file->private_data == NULL) {
2123 cFYI(1, "readpage %p at offset %d 0x%x\n",
2124 page, (int)offset, (int)offset);
2126 rc = cifs_readpage_worker(file, page, &offset);
2134 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2136 struct cifsFileInfo *open_file;
2138 spin_lock(&cifs_file_list_lock);
2139 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2140 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2141 spin_unlock(&cifs_file_list_lock);
2145 spin_unlock(&cifs_file_list_lock);
2149 /* We do not want to update the file size from server for inodes
2150 open for write - to avoid races with writepage extending
2151 the file - in the future we could consider allowing
2152 refreshing the inode only on increases in the file size
2153 but this is tricky to do without racing with writebehind
2154 page caching in the current Linux kernel design */
2155 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2160 if (is_inode_writable(cifsInode)) {
2161 /* This inode is open for write at least once */
2162 struct cifs_sb_info *cifs_sb;
2164 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2165 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2166 /* since no page cache to corrupt on directio
2167 we can change size safely */
2171 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2179 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2180 loff_t pos, unsigned len, unsigned flags,
2181 struct page **pagep, void **fsdata)
2183 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2184 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2185 loff_t page_start = pos & PAGE_MASK;
2190 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2192 page = grab_cache_page_write_begin(mapping, index, flags);
2198 if (PageUptodate(page))
2202 * If we write a full page it will be up to date, no need to read from
2203 * the server. If the write is short, we'll end up doing a sync write
2206 if (len == PAGE_CACHE_SIZE)
2210 * optimize away the read when we have an oplock, and we're not
2211 * expecting to use any of the data we'd be reading in. That
2212 * is, when the page lies beyond the EOF, or straddles the EOF
2213 * and the write will cover all of the existing data.
2215 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2216 i_size = i_size_read(mapping->host);
2217 if (page_start >= i_size ||
2218 (offset == 0 && (pos + len) >= i_size)) {
2219 zero_user_segments(page, 0, offset,
2223 * PageChecked means that the parts of the page
2224 * to which we're not writing are considered up
2225 * to date. Once the data is copied to the
2226 * page, it can be set uptodate.
2228 SetPageChecked(page);
2233 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2235 * might as well read a page, it is fast enough. If we get
2236 * an error, we don't need to return it. cifs_write_end will
2237 * do a sync write instead since PG_uptodate isn't set.
2239 cifs_readpage_worker(file, page, &page_start);
2241 /* we could try using another file handle if there is one -
2242 but how would we lock it to prevent close of that handle
2243 racing with this read? In any case
2244 this will be written out by write_end so is fine */
2251 static int cifs_release_page(struct page *page, gfp_t gfp)
2253 if (PagePrivate(page))
2256 return cifs_fscache_release_page(page, gfp);
2259 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2261 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2264 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2267 void cifs_oplock_break(struct work_struct *work)
2269 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2271 struct inode *inode = cfile->dentry->d_inode;
2272 struct cifsInodeInfo *cinode = CIFS_I(inode);
2275 if (inode && S_ISREG(inode->i_mode)) {
2276 if (cinode->clientCanCacheRead)
2277 break_lease(inode, O_RDONLY);
2279 break_lease(inode, O_WRONLY);
2280 rc = filemap_fdatawrite(inode->i_mapping);
2281 if (cinode->clientCanCacheRead == 0) {
2282 waitrc = filemap_fdatawait(inode->i_mapping);
2283 invalidate_remote_inode(inode);
2288 cinode->write_behind_rc = rc;
2289 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2293 * releasing stale oplock after recent reconnect of smb session using
2294 * a now incorrect file handle is not a data integrity issue but do
2295 * not bother sending an oplock release if session to server still is
2296 * disconnected since oplock already released by the server
2298 if (!cfile->oplock_break_cancelled) {
2299 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2300 0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false);
2301 cFYI(1, "Oplock release rc = %d", rc);
2305 * We might have kicked in before is_valid_oplock_break()
2306 * finished grabbing reference for us. Make sure it's done by
2307 * waiting for GlobalSMSSeslock.
2309 spin_lock(&cifs_file_list_lock);
2310 spin_unlock(&cifs_file_list_lock);
2312 cifs_oplock_break_put(cfile);
2315 void cifs_oplock_break_get(struct cifsFileInfo *cfile)
2317 cifs_sb_active(cfile->dentry->d_sb);
2318 cifsFileInfo_get(cfile);
2321 void cifs_oplock_break_put(struct cifsFileInfo *cfile)
2323 cifsFileInfo_put(cfile);
2324 cifs_sb_deactive(cfile->dentry->d_sb);
2327 const struct address_space_operations cifs_addr_ops = {
2328 .readpage = cifs_readpage,
2329 .readpages = cifs_readpages,
2330 .writepage = cifs_writepage,
2331 .writepages = cifs_writepages,
2332 .write_begin = cifs_write_begin,
2333 .write_end = cifs_write_end,
2334 .set_page_dirty = __set_page_dirty_nobuffers,
2335 .releasepage = cifs_release_page,
2336 .invalidatepage = cifs_invalidate_page,
2337 /* .sync_page = cifs_sync_page, */
2342 * cifs_readpages requires the server to support a buffer large enough to
2343 * contain the header plus one complete page of data. Otherwise, we need
2344 * to leave cifs_readpages out of the address space operations.
2346 const struct address_space_operations cifs_addr_ops_smallbuf = {
2347 .readpage = cifs_readpage,
2348 .writepage = cifs_writepage,
2349 .writepages = cifs_writepages,
2350 .write_begin = cifs_write_begin,
2351 .write_end = cifs_write_end,
2352 .set_page_dirty = __set_page_dirty_nobuffers,
2353 .releasepage = cifs_release_page,
2354 .invalidatepage = cifs_invalidate_page,
2355 /* .sync_page = cifs_sync_page, */