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 inline fmode_t cifs_posix_convert_flags(unsigned int flags)
65 fmode_t posix_flags = 0;
67 if ((flags & O_ACCMODE) == O_RDONLY)
68 posix_flags = FMODE_READ;
69 else if ((flags & O_ACCMODE) == O_WRONLY)
70 posix_flags = FMODE_WRITE;
71 else if ((flags & O_ACCMODE) == O_RDWR) {
72 /* GENERIC_ALL is too much permission to request
73 can cause unnecessary access denied on create */
74 /* return GENERIC_ALL; */
75 posix_flags = FMODE_READ | FMODE_WRITE;
77 /* can not map O_CREAT or O_EXCL or O_TRUNC flags when
78 reopening a file. They had their effect on the original open */
80 posix_flags |= (fmode_t)O_APPEND;
82 posix_flags |= (fmode_t)O_DSYNC;
84 posix_flags |= (fmode_t)__O_SYNC;
85 if (flags & O_DIRECTORY)
86 posix_flags |= (fmode_t)O_DIRECTORY;
87 if (flags & O_NOFOLLOW)
88 posix_flags |= (fmode_t)O_NOFOLLOW;
90 posix_flags |= (fmode_t)O_DIRECT;
95 static inline int cifs_get_disposition(unsigned int flags)
97 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
99 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
100 return FILE_OVERWRITE_IF;
101 else if ((flags & O_CREAT) == O_CREAT)
103 else if ((flags & O_TRUNC) == O_TRUNC)
104 return FILE_OVERWRITE;
109 /* all arguments to this function must be checked for validity in caller */
111 cifs_posix_open_inode_helper(struct inode *inode, struct file *file,
112 struct cifsInodeInfo *pCifsInode, __u32 oplock,
116 write_lock(&GlobalSMBSeslock);
118 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
119 if (pCifsInode == NULL) {
120 write_unlock(&GlobalSMBSeslock);
124 if (pCifsInode->clientCanCacheRead) {
125 /* we have the inode open somewhere else
126 no need to discard cache data */
127 goto psx_client_can_cache;
130 /* BB FIXME need to fix this check to move it earlier into posix_open
131 BB fIX following section BB FIXME */
133 /* if not oplocked, invalidate inode pages if mtime or file
135 /* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
136 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
137 (file->f_path.dentry->d_inode->i_size ==
138 (loff_t)le64_to_cpu(buf->EndOfFile))) {
139 cFYI(1, "inode unchanged on server");
141 if (file->f_path.dentry->d_inode->i_mapping) {
142 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
144 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
146 cFYI(1, "invalidating remote inode since open detected it "
148 invalidate_remote_inode(file->f_path.dentry->d_inode);
151 psx_client_can_cache:
152 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
153 pCifsInode->clientCanCacheAll = true;
154 pCifsInode->clientCanCacheRead = true;
155 cFYI(1, "Exclusive Oplock granted on inode %p",
156 file->f_path.dentry->d_inode);
157 } else if ((oplock & 0xF) == OPLOCK_READ)
158 pCifsInode->clientCanCacheRead = true;
160 /* will have to change the unlock if we reenable the
161 filemap_fdatawrite (which does not seem necessary */
162 write_unlock(&GlobalSMBSeslock);
166 /* all arguments to this function must be checked for validity in caller */
167 static inline int cifs_open_inode_helper(struct inode *inode,
168 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
169 char *full_path, int xid)
171 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
172 struct timespec temp;
175 if (pCifsInode->clientCanCacheRead) {
176 /* we have the inode open somewhere else
177 no need to discard cache data */
178 goto client_can_cache;
181 /* BB need same check in cifs_create too? */
182 /* if not oplocked, invalidate inode pages if mtime or file
184 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
185 if (timespec_equal(&inode->i_mtime, &temp) &&
187 (loff_t)le64_to_cpu(buf->EndOfFile))) {
188 cFYI(1, "inode unchanged on server");
190 if (inode->i_mapping) {
191 /* BB no need to lock inode until after invalidate
192 since namei code should already have it locked? */
193 rc = filemap_write_and_wait(inode->i_mapping);
195 pCifsInode->write_behind_rc = rc;
197 cFYI(1, "invalidating remote inode since open detected it "
199 invalidate_remote_inode(inode);
204 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
207 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
210 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
211 pCifsInode->clientCanCacheAll = true;
212 pCifsInode->clientCanCacheRead = true;
213 cFYI(1, "Exclusive Oplock granted on inode %p", inode);
214 } else if ((*oplock & 0xF) == OPLOCK_READ)
215 pCifsInode->clientCanCacheRead = true;
220 int cifs_open(struct inode *inode, struct file *file)
225 struct cifs_sb_info *cifs_sb;
226 struct cifsTconInfo *tcon;
227 struct cifsFileInfo *pCifsFile = NULL;
228 struct cifsInodeInfo *pCifsInode;
229 char *full_path = NULL;
233 FILE_ALL_INFO *buf = NULL;
237 cifs_sb = CIFS_SB(inode->i_sb);
238 tcon = cifs_sb->tcon;
240 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
242 full_path = build_path_from_dentry(file->f_path.dentry);
243 if (full_path == NULL) {
249 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
250 inode, file->f_flags, full_path);
257 if (!tcon->broken_posix_open && tcon->unix_ext &&
258 (tcon->ses->capabilities & CAP_UNIX) &&
259 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
260 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
261 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
262 oflags |= SMB_O_CREAT;
263 /* can not refresh inode info since size could be stale */
264 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
265 cifs_sb->mnt_file_mode /* ignored */,
266 oflags, &oplock, &netfid, xid);
268 cFYI(1, "posix open succeeded");
269 /* no need for special case handling of setting mode
270 on read only files needed here */
272 rc = cifs_posix_open_inode_helper(inode, file,
273 pCifsInode, oplock, netfid);
275 CIFSSMBClose(xid, tcon, netfid);
279 pCifsFile = cifs_new_fileinfo(inode, netfid, file,
282 if (pCifsFile == NULL) {
283 CIFSSMBClose(xid, tcon, netfid);
287 cifs_fscache_set_inode_cookie(inode, file);
290 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
291 if (tcon->ses->serverNOS)
292 cERROR(1, "server %s of type %s returned"
293 " unexpected error on SMB posix open"
294 ", disabling posix open support."
295 " Check if server update available.",
296 tcon->ses->serverName,
297 tcon->ses->serverNOS);
298 tcon->broken_posix_open = true;
299 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
300 (rc != -EOPNOTSUPP)) /* path not found or net err */
302 /* else fallthrough to retry open the old way on network i/o
306 desiredAccess = cifs_convert_flags(file->f_flags);
308 /*********************************************************************
309 * open flag mapping table:
311 * POSIX Flag CIFS Disposition
312 * ---------- ----------------
313 * O_CREAT FILE_OPEN_IF
314 * O_CREAT | O_EXCL FILE_CREATE
315 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
316 * O_TRUNC FILE_OVERWRITE
317 * none of the above FILE_OPEN
319 * Note that there is not a direct match between disposition
320 * FILE_SUPERSEDE (ie create whether or not file exists although
321 * O_CREAT | O_TRUNC is similar but truncates the existing
322 * file rather than creating a new file as FILE_SUPERSEDE does
323 * (which uses the attributes / metadata passed in on open call)
325 *? O_SYNC is a reasonable match to CIFS writethrough flag
326 *? and the read write flags match reasonably. O_LARGEFILE
327 *? is irrelevant because largefile support is always used
328 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
329 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
330 *********************************************************************/
332 disposition = cifs_get_disposition(file->f_flags);
334 /* BB pass O_SYNC flag through on file attributes .. BB */
336 /* Also refresh inode by passing in file_info buf returned by SMBOpen
337 and calling get_inode_info with returned buf (at least helps
338 non-Unix server case) */
340 /* BB we can not do this if this is the second open of a file
341 and the first handle has writebehind data, we might be
342 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
343 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
349 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
350 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
351 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
352 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
353 & CIFS_MOUNT_MAP_SPECIAL_CHR);
355 rc = -EIO; /* no NT SMB support fall into legacy open below */
358 /* Old server, try legacy style OpenX */
359 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
360 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
361 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
362 & CIFS_MOUNT_MAP_SPECIAL_CHR);
365 cFYI(1, "cifs_open returned 0x%x", rc);
369 rc = cifs_open_inode_helper(inode, tcon, &oplock, buf, full_path, xid);
373 pCifsFile = cifs_new_fileinfo(inode, netfid, file, file->f_path.mnt,
375 if (pCifsFile == NULL) {
380 cifs_fscache_set_inode_cookie(inode, file);
382 if (oplock & CIFS_CREATE_ACTION) {
383 /* time to set mode which we can not set earlier due to
384 problems creating new read-only files */
385 if (tcon->unix_ext) {
386 struct cifs_unix_set_info_args args = {
387 .mode = inode->i_mode,
390 .ctime = NO_CHANGE_64,
391 .atime = NO_CHANGE_64,
392 .mtime = NO_CHANGE_64,
395 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
397 cifs_sb->mnt_cifs_flags &
398 CIFS_MOUNT_MAP_SPECIAL_CHR);
409 /* Try to reacquire byte range locks that were released when session */
410 /* to server was lost */
411 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
415 /* BB list all locks open on this file and relock */
420 static int cifs_reopen_file(struct file *file, bool can_flush)
425 struct cifs_sb_info *cifs_sb;
426 struct cifsTconInfo *tcon;
427 struct cifsFileInfo *pCifsFile;
428 struct cifsInodeInfo *pCifsInode;
430 char *full_path = NULL;
432 int disposition = FILE_OPEN;
435 if (file->private_data)
436 pCifsFile = file->private_data;
441 mutex_lock(&pCifsFile->fh_mutex);
442 if (!pCifsFile->invalidHandle) {
443 mutex_unlock(&pCifsFile->fh_mutex);
449 if (file->f_path.dentry == NULL) {
450 cERROR(1, "no valid name if dentry freed");
453 goto reopen_error_exit;
456 inode = file->f_path.dentry->d_inode;
458 cERROR(1, "inode not valid");
461 goto reopen_error_exit;
464 cifs_sb = CIFS_SB(inode->i_sb);
465 tcon = cifs_sb->tcon;
467 /* can not grab rename sem here because various ops, including
468 those that already have the rename sem can end up causing writepage
469 to get called and if the server was down that means we end up here,
470 and we can never tell if the caller already has the rename_sem */
471 full_path = build_path_from_dentry(file->f_path.dentry);
472 if (full_path == NULL) {
475 mutex_unlock(&pCifsFile->fh_mutex);
480 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
481 inode, file->f_flags, full_path);
488 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
489 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
490 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
491 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
492 /* can not refresh inode info since size could be stale */
493 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
494 cifs_sb->mnt_file_mode /* ignored */,
495 oflags, &oplock, &netfid, xid);
497 cFYI(1, "posix reopen succeeded");
500 /* fallthrough to retry open the old way on errors, especially
501 in the reconnect path it is important to retry hard */
504 desiredAccess = cifs_convert_flags(file->f_flags);
506 /* Can not refresh inode by passing in file_info buf to be returned
507 by SMBOpen and then calling get_inode_info with returned buf
508 since file might have write behind data that needs to be flushed
509 and server version of file size can be stale. If we knew for sure
510 that inode was not dirty locally we could do this */
512 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
513 CREATE_NOT_DIR, &netfid, &oplock, NULL,
514 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
515 CIFS_MOUNT_MAP_SPECIAL_CHR);
517 mutex_unlock(&pCifsFile->fh_mutex);
518 cFYI(1, "cifs_open returned 0x%x", rc);
519 cFYI(1, "oplock: %d", oplock);
522 pCifsFile->netfid = netfid;
523 pCifsFile->invalidHandle = false;
524 mutex_unlock(&pCifsFile->fh_mutex);
525 pCifsInode = CIFS_I(inode);
528 rc = filemap_write_and_wait(inode->i_mapping);
530 CIFS_I(inode)->write_behind_rc = rc;
531 /* temporarily disable caching while we
532 go to server to get inode info */
533 pCifsInode->clientCanCacheAll = false;
534 pCifsInode->clientCanCacheRead = false;
536 rc = cifs_get_inode_info_unix(&inode,
537 full_path, inode->i_sb, xid);
539 rc = cifs_get_inode_info(&inode,
540 full_path, NULL, inode->i_sb,
542 } /* else we are writing out data to server already
543 and could deadlock if we tried to flush data, and
544 since we do not know if we have data that would
545 invalidate the current end of file on the server
546 we can not go to the server to get the new inod
548 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
549 pCifsInode->clientCanCacheAll = true;
550 pCifsInode->clientCanCacheRead = true;
551 cFYI(1, "Exclusive Oplock granted on inode %p",
552 file->f_path.dentry->d_inode);
553 } else if ((oplock & 0xF) == OPLOCK_READ) {
554 pCifsInode->clientCanCacheRead = true;
555 pCifsInode->clientCanCacheAll = false;
557 pCifsInode->clientCanCacheRead = false;
558 pCifsInode->clientCanCacheAll = false;
560 cifs_relock_file(pCifsFile);
568 int cifs_close(struct inode *inode, struct file *file)
572 struct cifs_sb_info *cifs_sb;
573 struct cifsTconInfo *pTcon;
574 struct cifsFileInfo *pSMBFile = file->private_data;
578 cifs_sb = CIFS_SB(inode->i_sb);
579 pTcon = cifs_sb->tcon;
581 struct cifsLockInfo *li, *tmp;
582 write_lock(&GlobalSMBSeslock);
583 pSMBFile->closePend = true;
585 /* no sense reconnecting to close a file that is
587 if (!pTcon->need_reconnect) {
588 write_unlock(&GlobalSMBSeslock);
590 while ((atomic_read(&pSMBFile->count) != 1)
591 && (timeout <= 2048)) {
592 /* Give write a better chance to get to
593 server ahead of the close. We do not
594 want to add a wait_q here as it would
595 increase the memory utilization as
596 the struct would be in each open file,
597 but this should give enough time to
599 cFYI(DBG2, "close delay, write pending");
603 if (!pTcon->need_reconnect &&
604 !pSMBFile->invalidHandle)
605 rc = CIFSSMBClose(xid, pTcon,
608 write_unlock(&GlobalSMBSeslock);
610 write_unlock(&GlobalSMBSeslock);
612 /* Delete any outstanding lock records.
613 We'll lose them when the file is closed anyway. */
614 mutex_lock(&pSMBFile->lock_mutex);
615 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
616 list_del(&li->llist);
619 mutex_unlock(&pSMBFile->lock_mutex);
621 write_lock(&GlobalSMBSeslock);
622 list_del(&pSMBFile->flist);
623 list_del(&pSMBFile->tlist);
624 write_unlock(&GlobalSMBSeslock);
625 cifsFileInfo_put(file->private_data);
626 file->private_data = NULL;
630 read_lock(&GlobalSMBSeslock);
631 if (list_empty(&(CIFS_I(inode)->openFileList))) {
632 cFYI(1, "closing last open instance for inode %p", inode);
633 /* if the file is not open we do not know if we can cache info
634 on this inode, much less write behind and read ahead */
635 CIFS_I(inode)->clientCanCacheRead = false;
636 CIFS_I(inode)->clientCanCacheAll = false;
638 read_unlock(&GlobalSMBSeslock);
639 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
640 rc = CIFS_I(inode)->write_behind_rc;
645 int cifs_closedir(struct inode *inode, struct file *file)
649 struct cifsFileInfo *pCFileStruct = file->private_data;
652 cFYI(1, "Closedir inode = 0x%p", inode);
657 struct cifsTconInfo *pTcon;
658 struct cifs_sb_info *cifs_sb =
659 CIFS_SB(file->f_path.dentry->d_sb);
661 pTcon = cifs_sb->tcon;
663 cFYI(1, "Freeing private data in close dir");
664 write_lock(&GlobalSMBSeslock);
665 if (!pCFileStruct->srch_inf.endOfSearch &&
666 !pCFileStruct->invalidHandle) {
667 pCFileStruct->invalidHandle = true;
668 write_unlock(&GlobalSMBSeslock);
669 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
670 cFYI(1, "Closing uncompleted readdir with rc %d",
672 /* not much we can do if it fails anyway, ignore rc */
675 write_unlock(&GlobalSMBSeslock);
676 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
678 cFYI(1, "closedir free smb buf in srch struct");
679 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
680 if (pCFileStruct->srch_inf.smallBuf)
681 cifs_small_buf_release(ptmp);
683 cifs_buf_release(ptmp);
685 kfree(file->private_data);
686 file->private_data = NULL;
688 /* BB can we lock the filestruct while this is going on? */
693 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
694 __u64 offset, __u8 lockType)
696 struct cifsLockInfo *li =
697 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
703 mutex_lock(&fid->lock_mutex);
704 list_add(&li->llist, &fid->llist);
705 mutex_unlock(&fid->lock_mutex);
709 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
715 bool wait_flag = false;
716 struct cifs_sb_info *cifs_sb;
717 struct cifsTconInfo *tcon;
719 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
720 bool posix_locking = 0;
722 length = 1 + pfLock->fl_end - pfLock->fl_start;
726 cFYI(1, "Lock parm: 0x%x flockflags: "
727 "0x%x flocktype: 0x%x start: %lld end: %lld",
728 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
731 if (pfLock->fl_flags & FL_POSIX)
733 if (pfLock->fl_flags & FL_FLOCK)
735 if (pfLock->fl_flags & FL_SLEEP) {
736 cFYI(1, "Blocking lock");
739 if (pfLock->fl_flags & FL_ACCESS)
740 cFYI(1, "Process suspended by mandatory locking - "
741 "not implemented yet");
742 if (pfLock->fl_flags & FL_LEASE)
743 cFYI(1, "Lease on file - not implemented yet");
744 if (pfLock->fl_flags &
745 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
746 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
748 if (pfLock->fl_type == F_WRLCK) {
751 } else if (pfLock->fl_type == F_UNLCK) {
754 /* Check if unlock includes more than
756 } else if (pfLock->fl_type == F_RDLCK) {
758 lockType |= LOCKING_ANDX_SHARED_LOCK;
760 } else if (pfLock->fl_type == F_EXLCK) {
763 } else if (pfLock->fl_type == F_SHLCK) {
765 lockType |= LOCKING_ANDX_SHARED_LOCK;
768 cFYI(1, "Unknown type of lock");
770 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
771 tcon = cifs_sb->tcon;
773 if (file->private_data == NULL) {
778 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
780 if ((tcon->ses->capabilities & CAP_UNIX) &&
781 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
782 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
784 /* BB add code here to normalize offset and length to
785 account for negative length which we can not accept over the
790 if (lockType & LOCKING_ANDX_SHARED_LOCK)
791 posix_lock_type = CIFS_RDLCK;
793 posix_lock_type = CIFS_WRLCK;
794 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
796 posix_lock_type, wait_flag);
801 /* BB we could chain these into one lock request BB */
802 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
803 0, 1, lockType, 0 /* wait flag */ );
805 rc = CIFSSMBLock(xid, tcon, netfid, length,
806 pfLock->fl_start, 1 /* numUnlock */ ,
807 0 /* numLock */ , lockType,
809 pfLock->fl_type = F_UNLCK;
811 cERROR(1, "Error unlocking previously locked "
812 "range %d during test of lock", rc);
816 /* if rc == ERR_SHARING_VIOLATION ? */
819 if (lockType & LOCKING_ANDX_SHARED_LOCK) {
820 pfLock->fl_type = F_WRLCK;
822 rc = CIFSSMBLock(xid, tcon, netfid, length,
823 pfLock->fl_start, 0, 1,
824 lockType | LOCKING_ANDX_SHARED_LOCK,
827 rc = CIFSSMBLock(xid, tcon, netfid,
828 length, pfLock->fl_start, 1, 0,
830 LOCKING_ANDX_SHARED_LOCK,
832 pfLock->fl_type = F_RDLCK;
834 cERROR(1, "Error unlocking "
835 "previously locked range %d "
836 "during test of lock", rc);
839 pfLock->fl_type = F_WRLCK;
849 if (!numLock && !numUnlock) {
850 /* if no lock or unlock then nothing
851 to do since we do not know what it is */
858 if (lockType & LOCKING_ANDX_SHARED_LOCK)
859 posix_lock_type = CIFS_RDLCK;
861 posix_lock_type = CIFS_WRLCK;
864 posix_lock_type = CIFS_UNLCK;
866 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
868 posix_lock_type, wait_flag);
870 struct cifsFileInfo *fid = file->private_data;
873 rc = CIFSSMBLock(xid, tcon, netfid, length,
875 0, numLock, lockType, wait_flag);
878 /* For Windows locks we must store them. */
879 rc = store_file_lock(fid, length,
880 pfLock->fl_start, lockType);
882 } else if (numUnlock) {
883 /* For each stored lock that this unlock overlaps
884 completely, unlock it. */
886 struct cifsLockInfo *li, *tmp;
889 mutex_lock(&fid->lock_mutex);
890 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
891 if (pfLock->fl_start <= li->offset &&
892 (pfLock->fl_start + length) >=
893 (li->offset + li->length)) {
894 stored_rc = CIFSSMBLock(xid, tcon,
896 li->length, li->offset,
897 1, 0, li->type, false);
901 list_del(&li->llist);
906 mutex_unlock(&fid->lock_mutex);
910 if (pfLock->fl_flags & FL_POSIX)
911 posix_lock_file_wait(file, pfLock);
917 * Set the timeout on write requests past EOF. For some servers (Windows)
918 * these calls can be very long.
920 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
921 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
922 * The 10M cutoff is totally arbitrary. A better scheme for this would be
923 * welcome if someone wants to suggest one.
925 * We may be able to do a better job with this if there were some way to
926 * declare that a file should be sparse.
929 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
931 if (offset <= cifsi->server_eof)
933 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
934 return CIFS_VLONG_OP;
939 /* update the file size (if needed) after a write */
941 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
942 unsigned int bytes_written)
944 loff_t end_of_write = offset + bytes_written;
946 if (end_of_write > cifsi->server_eof)
947 cifsi->server_eof = end_of_write;
950 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
951 size_t write_size, loff_t *poffset)
954 unsigned int bytes_written = 0;
955 unsigned int total_written;
956 struct cifs_sb_info *cifs_sb;
957 struct cifsTconInfo *pTcon;
959 struct cifsFileInfo *open_file;
960 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
962 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
964 pTcon = cifs_sb->tcon;
966 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
967 *poffset, file->f_path.dentry->d_name.name); */
969 if (file->private_data == NULL)
971 open_file = file->private_data;
973 rc = generic_write_checks(file, poffset, &write_size, 0);
979 long_op = cifs_write_timeout(cifsi, *poffset);
980 for (total_written = 0; write_size > total_written;
981 total_written += bytes_written) {
983 while (rc == -EAGAIN) {
984 if (file->private_data == NULL) {
985 /* file has been closed on us */
987 /* if we have gotten here we have written some data
988 and blocked, and the file has been freed on us while
989 we blocked so return what we managed to write */
990 return total_written;
992 if (open_file->closePend) {
995 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(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 file *file, const char *write_data,
1053 size_t write_size, loff_t *poffset)
1056 unsigned int bytes_written = 0;
1057 unsigned int total_written;
1058 struct cifs_sb_info *cifs_sb;
1059 struct cifsTconInfo *pTcon;
1061 struct cifsFileInfo *open_file;
1062 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1064 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1066 pTcon = cifs_sb->tcon;
1068 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1069 *poffset, file->f_path.dentry->d_name.name);
1071 if (file->private_data == NULL)
1073 open_file = file->private_data;
1077 long_op = cifs_write_timeout(cifsi, *poffset);
1078 for (total_written = 0; write_size > total_written;
1079 total_written += bytes_written) {
1081 while (rc == -EAGAIN) {
1082 if (file->private_data == NULL) {
1083 /* file has been closed on us */
1085 /* if we have gotten here we have written some data
1086 and blocked, and the file has been freed on us
1087 while we blocked so return what we managed to
1089 return total_written;
1091 if (open_file->closePend) {
1094 return total_written;
1098 if (open_file->invalidHandle) {
1099 /* we could deadlock if we called
1100 filemap_fdatawait from here so tell
1101 reopen_file not to flush data to
1103 rc = cifs_reopen_file(file, false);
1107 if (experimEnabled || (pTcon->ses->server &&
1108 ((pTcon->ses->server->secMode &
1109 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1114 len = min((size_t)cifs_sb->wsize,
1115 write_size - total_written);
1116 /* iov[0] is reserved for smb header */
1117 iov[1].iov_base = (char *)write_data +
1119 iov[1].iov_len = len;
1120 rc = CIFSSMBWrite2(xid, pTcon,
1121 open_file->netfid, len,
1122 *poffset, &bytes_written,
1125 rc = CIFSSMBWrite(xid, pTcon,
1127 min_t(const int, cifs_sb->wsize,
1128 write_size - total_written),
1129 *poffset, &bytes_written,
1130 write_data + total_written,
1133 if (rc || (bytes_written == 0)) {
1141 cifs_update_eof(cifsi, *poffset, bytes_written);
1142 *poffset += bytes_written;
1144 long_op = CIFS_STD_OP; /* subsequent writes fast -
1145 15 seconds is plenty */
1148 cifs_stats_bytes_written(pTcon, total_written);
1150 /* since the write may have blocked check these pointers again */
1151 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1152 /*BB We could make this contingent on superblock ATIME flag too */
1153 /* file->f_path.dentry->d_inode->i_ctime =
1154 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1155 if (total_written > 0) {
1156 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1157 if (*poffset > file->f_path.dentry->d_inode->i_size)
1158 i_size_write(file->f_path.dentry->d_inode,
1160 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1162 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1165 return total_written;
1168 #ifdef CONFIG_CIFS_EXPERIMENTAL
1169 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1171 struct cifsFileInfo *open_file = NULL;
1173 read_lock(&GlobalSMBSeslock);
1174 /* we could simply get the first_list_entry since write-only entries
1175 are always at the end of the list but since the first entry might
1176 have a close pending, we go through the whole list */
1177 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1178 if (open_file->closePend)
1180 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1181 (open_file->pfile->f_flags & O_RDONLY))) {
1182 if (!open_file->invalidHandle) {
1183 /* found a good file */
1184 /* lock it so it will not be closed on us */
1185 cifsFileInfo_get(open_file);
1186 read_unlock(&GlobalSMBSeslock);
1188 } /* else might as well continue, and look for
1189 another, or simply have the caller reopen it
1190 again rather than trying to fix this handle */
1191 } else /* write only file */
1192 break; /* write only files are last so must be done */
1194 read_unlock(&GlobalSMBSeslock);
1199 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1201 struct cifsFileInfo *open_file;
1202 bool any_available = false;
1205 /* Having a null inode here (because mapping->host was set to zero by
1206 the VFS or MM) should not happen but we had reports of on oops (due to
1207 it being zero) during stress testcases so we need to check for it */
1209 if (cifs_inode == NULL) {
1210 cERROR(1, "Null inode passed to cifs_writeable_file");
1215 read_lock(&GlobalSMBSeslock);
1217 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1218 if (open_file->closePend ||
1219 (!any_available && open_file->pid != current->tgid))
1222 if (open_file->pfile &&
1223 ((open_file->pfile->f_flags & O_RDWR) ||
1224 (open_file->pfile->f_flags & O_WRONLY))) {
1225 cifsFileInfo_get(open_file);
1227 if (!open_file->invalidHandle) {
1228 /* found a good writable file */
1229 read_unlock(&GlobalSMBSeslock);
1233 read_unlock(&GlobalSMBSeslock);
1234 /* Had to unlock since following call can block */
1235 rc = cifs_reopen_file(open_file->pfile, false);
1237 if (!open_file->closePend)
1239 else { /* start over in case this was deleted */
1240 /* since the list could be modified */
1241 read_lock(&GlobalSMBSeslock);
1242 cifsFileInfo_put(open_file);
1243 goto refind_writable;
1247 /* if it fails, try another handle if possible -
1248 (we can not do this if closePending since
1249 loop could be modified - in which case we
1250 have to start at the beginning of the list
1251 again. Note that it would be bad
1252 to hold up writepages here (rather than
1253 in caller) with continuous retries */
1254 cFYI(1, "wp failed on reopen file");
1255 read_lock(&GlobalSMBSeslock);
1256 /* can not use this handle, no write
1257 pending on this one after all */
1258 cifsFileInfo_put(open_file);
1260 if (open_file->closePend) /* list could have changed */
1261 goto refind_writable;
1262 /* else we simply continue to the next entry. Thus
1263 we do not loop on reopen errors. If we
1264 can not reopen the file, for example if we
1265 reconnected to a server with another client
1266 racing to delete or lock the file we would not
1267 make progress if we restarted before the beginning
1268 of the loop here. */
1271 /* couldn't find useable FH with same pid, try any available */
1272 if (!any_available) {
1273 any_available = true;
1274 goto refind_writable;
1276 read_unlock(&GlobalSMBSeslock);
1280 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1282 struct address_space *mapping = page->mapping;
1283 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1286 int bytes_written = 0;
1287 struct cifs_sb_info *cifs_sb;
1288 struct cifsTconInfo *pTcon;
1289 struct inode *inode;
1290 struct cifsFileInfo *open_file;
1292 if (!mapping || !mapping->host)
1295 inode = page->mapping->host;
1296 cifs_sb = CIFS_SB(inode->i_sb);
1297 pTcon = cifs_sb->tcon;
1299 offset += (loff_t)from;
1300 write_data = kmap(page);
1303 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1308 /* racing with truncate? */
1309 if (offset > mapping->host->i_size) {
1311 return 0; /* don't care */
1314 /* check to make sure that we are not extending the file */
1315 if (mapping->host->i_size - offset < (loff_t)to)
1316 to = (unsigned)(mapping->host->i_size - offset);
1318 open_file = find_writable_file(CIFS_I(mapping->host));
1320 bytes_written = cifs_write(open_file->pfile, write_data,
1322 cifsFileInfo_put(open_file);
1323 /* Does mm or vfs already set times? */
1324 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1325 if ((bytes_written > 0) && (offset))
1327 else if (bytes_written < 0)
1330 cFYI(1, "No writeable filehandles for inode");
1338 static int cifs_writepages(struct address_space *mapping,
1339 struct writeback_control *wbc)
1341 struct backing_dev_info *bdi = mapping->backing_dev_info;
1342 unsigned int bytes_to_write;
1343 unsigned int bytes_written;
1344 struct cifs_sb_info *cifs_sb;
1348 int range_whole = 0;
1355 struct cifsFileInfo *open_file;
1356 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1358 struct pagevec pvec;
1363 cifs_sb = CIFS_SB(mapping->host->i_sb);
1366 * If wsize is smaller that the page cache size, default to writing
1367 * one page at a time via cifs_writepage
1369 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1370 return generic_writepages(mapping, wbc);
1372 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1373 if (cifs_sb->tcon->ses->server->secMode &
1374 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1375 if (!experimEnabled)
1376 return generic_writepages(mapping, wbc);
1378 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1380 return generic_writepages(mapping, wbc);
1384 * BB: Is this meaningful for a non-block-device file system?
1385 * If it is, we should test it again after we do I/O
1387 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1388 wbc->encountered_congestion = 1;
1395 pagevec_init(&pvec, 0);
1396 if (wbc->range_cyclic) {
1397 index = mapping->writeback_index; /* Start from prev offset */
1400 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1401 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1402 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1407 while (!done && (index <= end) &&
1408 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1409 PAGECACHE_TAG_DIRTY,
1410 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1419 for (i = 0; i < nr_pages; i++) {
1420 page = pvec.pages[i];
1422 * At this point we hold neither mapping->tree_lock nor
1423 * lock on the page itself: the page may be truncated or
1424 * invalidated (changing page->mapping to NULL), or even
1425 * swizzled back from swapper_space to tmpfs file
1431 else if (!trylock_page(page))
1434 if (unlikely(page->mapping != mapping)) {
1439 if (!wbc->range_cyclic && page->index > end) {
1445 if (next && (page->index != next)) {
1446 /* Not next consecutive page */
1451 if (wbc->sync_mode != WB_SYNC_NONE)
1452 wait_on_page_writeback(page);
1454 if (PageWriteback(page) ||
1455 !clear_page_dirty_for_io(page)) {
1461 * This actually clears the dirty bit in the radix tree.
1462 * See cifs_writepage() for more commentary.
1464 set_page_writeback(page);
1466 if (page_offset(page) >= mapping->host->i_size) {
1469 end_page_writeback(page);
1474 * BB can we get rid of this? pages are held by pvec
1476 page_cache_get(page);
1478 len = min(mapping->host->i_size - page_offset(page),
1479 (loff_t)PAGE_CACHE_SIZE);
1481 /* reserve iov[0] for the smb header */
1483 iov[n_iov].iov_base = kmap(page);
1484 iov[n_iov].iov_len = len;
1485 bytes_to_write += len;
1489 offset = page_offset(page);
1491 next = page->index + 1;
1492 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1496 /* Search for a writable handle every time we call
1497 * CIFSSMBWrite2. We can't rely on the last handle
1498 * we used to still be valid
1500 open_file = find_writable_file(CIFS_I(mapping->host));
1502 cERROR(1, "No writable handles for inode");
1505 long_op = cifs_write_timeout(cifsi, offset);
1506 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1508 bytes_to_write, offset,
1509 &bytes_written, iov, n_iov,
1511 cifsFileInfo_put(open_file);
1512 cifs_update_eof(cifsi, offset, bytes_written);
1514 if (rc || bytes_written < bytes_to_write) {
1515 cERROR(1, "Write2 ret %d, wrote %d",
1517 /* BB what if continued retry is
1518 requested via mount flags? */
1520 set_bit(AS_ENOSPC, &mapping->flags);
1522 set_bit(AS_EIO, &mapping->flags);
1524 cifs_stats_bytes_written(cifs_sb->tcon,
1528 for (i = 0; i < n_iov; i++) {
1529 page = pvec.pages[first + i];
1530 /* Should we also set page error on
1531 success rc but too little data written? */
1532 /* BB investigate retry logic on temporary
1533 server crash cases and how recovery works
1534 when page marked as error */
1539 end_page_writeback(page);
1540 page_cache_release(page);
1542 if ((wbc->nr_to_write -= n_iov) <= 0)
1546 /* Need to re-find the pages we skipped */
1547 index = pvec.pages[0]->index + 1;
1549 pagevec_release(&pvec);
1551 if (!scanned && !done) {
1553 * We hit the last page and there is more work to be done: wrap
1554 * back to the start of the file
1560 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1561 mapping->writeback_index = index;
1568 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1574 /* BB add check for wbc flags */
1575 page_cache_get(page);
1576 if (!PageUptodate(page))
1577 cFYI(1, "ppw - page not up to date");
1580 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1582 * A writepage() implementation always needs to do either this,
1583 * or re-dirty the page with "redirty_page_for_writepage()" in
1584 * the case of a failure.
1586 * Just unlocking the page will cause the radix tree tag-bits
1587 * to fail to update with the state of the page correctly.
1589 set_page_writeback(page);
1590 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1591 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1593 end_page_writeback(page);
1594 page_cache_release(page);
1599 static int cifs_write_end(struct file *file, struct address_space *mapping,
1600 loff_t pos, unsigned len, unsigned copied,
1601 struct page *page, void *fsdata)
1604 struct inode *inode = mapping->host;
1606 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1609 if (PageChecked(page)) {
1611 SetPageUptodate(page);
1612 ClearPageChecked(page);
1613 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1614 SetPageUptodate(page);
1616 if (!PageUptodate(page)) {
1618 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1622 /* this is probably better than directly calling
1623 partialpage_write since in this function the file handle is
1624 known which we might as well leverage */
1625 /* BB check if anything else missing out of ppw
1626 such as updating last write time */
1627 page_data = kmap(page);
1628 rc = cifs_write(file, page_data + offset, copied, &pos);
1629 /* if (rc < 0) should we set writebehind rc? */
1636 set_page_dirty(page);
1640 spin_lock(&inode->i_lock);
1641 if (pos > inode->i_size)
1642 i_size_write(inode, pos);
1643 spin_unlock(&inode->i_lock);
1647 page_cache_release(page);
1652 int cifs_fsync(struct file *file, int datasync)
1656 struct cifsTconInfo *tcon;
1657 struct cifsFileInfo *smbfile = file->private_data;
1658 struct inode *inode = file->f_path.dentry->d_inode;
1662 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1663 file->f_path.dentry->d_name.name, datasync);
1665 rc = filemap_write_and_wait(inode->i_mapping);
1667 rc = CIFS_I(inode)->write_behind_rc;
1668 CIFS_I(inode)->write_behind_rc = 0;
1669 tcon = CIFS_SB(inode->i_sb)->tcon;
1670 if (!rc && tcon && smbfile &&
1671 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1672 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1679 /* static void cifs_sync_page(struct page *page)
1681 struct address_space *mapping;
1682 struct inode *inode;
1683 unsigned long index = page->index;
1684 unsigned int rpages = 0;
1687 cFYI(1, "sync page %p", page);
1688 mapping = page->mapping;
1691 inode = mapping->host;
1695 /* fill in rpages then
1696 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1698 /* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1708 * As file closes, flush all cached write data for this inode checking
1709 * for write behind errors.
1711 int cifs_flush(struct file *file, fl_owner_t id)
1713 struct inode *inode = file->f_path.dentry->d_inode;
1716 /* Rather than do the steps manually:
1717 lock the inode for writing
1718 loop through pages looking for write behind data (dirty pages)
1719 coalesce into contiguous 16K (or smaller) chunks to write to server
1720 send to server (prefer in parallel)
1721 deal with writebehind errors
1722 unlock inode for writing
1723 filemapfdatawrite appears easier for the time being */
1725 rc = filemap_fdatawrite(inode->i_mapping);
1726 /* reset wb rc if we were able to write out dirty pages */
1728 rc = CIFS_I(inode)->write_behind_rc;
1729 CIFS_I(inode)->write_behind_rc = 0;
1732 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1737 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1738 size_t read_size, loff_t *poffset)
1741 unsigned int bytes_read = 0;
1742 unsigned int total_read = 0;
1743 unsigned int current_read_size;
1744 struct cifs_sb_info *cifs_sb;
1745 struct cifsTconInfo *pTcon;
1747 struct cifsFileInfo *open_file;
1748 char *smb_read_data;
1749 char __user *current_offset;
1750 struct smb_com_read_rsp *pSMBr;
1753 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1754 pTcon = cifs_sb->tcon;
1756 if (file->private_data == NULL) {
1761 open_file = file->private_data;
1763 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1764 cFYI(1, "attempting read on write only file instance");
1766 for (total_read = 0, current_offset = read_data;
1767 read_size > total_read;
1768 total_read += bytes_read, current_offset += bytes_read) {
1769 current_read_size = min_t(const int, read_size - total_read,
1772 smb_read_data = NULL;
1773 while (rc == -EAGAIN) {
1774 int buf_type = CIFS_NO_BUFFER;
1775 if ((open_file->invalidHandle) &&
1776 (!open_file->closePend)) {
1777 rc = cifs_reopen_file(file, true);
1781 rc = CIFSSMBRead(xid, pTcon,
1783 current_read_size, *poffset,
1784 &bytes_read, &smb_read_data,
1786 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1787 if (smb_read_data) {
1788 if (copy_to_user(current_offset,
1790 4 /* RFC1001 length field */ +
1791 le16_to_cpu(pSMBr->DataOffset),
1795 if (buf_type == CIFS_SMALL_BUFFER)
1796 cifs_small_buf_release(smb_read_data);
1797 else if (buf_type == CIFS_LARGE_BUFFER)
1798 cifs_buf_release(smb_read_data);
1799 smb_read_data = NULL;
1802 if (rc || (bytes_read == 0)) {
1810 cifs_stats_bytes_read(pTcon, bytes_read);
1811 *poffset += bytes_read;
1819 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1823 unsigned int bytes_read = 0;
1824 unsigned int total_read;
1825 unsigned int current_read_size;
1826 struct cifs_sb_info *cifs_sb;
1827 struct cifsTconInfo *pTcon;
1829 char *current_offset;
1830 struct cifsFileInfo *open_file;
1831 int buf_type = CIFS_NO_BUFFER;
1834 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1835 pTcon = cifs_sb->tcon;
1837 if (file->private_data == NULL) {
1842 open_file = file->private_data;
1844 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1845 cFYI(1, "attempting read on write only file instance");
1847 for (total_read = 0, current_offset = read_data;
1848 read_size > total_read;
1849 total_read += bytes_read, current_offset += bytes_read) {
1850 current_read_size = min_t(const int, read_size - total_read,
1852 /* For windows me and 9x we do not want to request more
1853 than it negotiated since it will refuse the read then */
1855 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1856 current_read_size = min_t(const int, current_read_size,
1857 pTcon->ses->server->maxBuf - 128);
1860 while (rc == -EAGAIN) {
1861 if ((open_file->invalidHandle) &&
1862 (!open_file->closePend)) {
1863 rc = cifs_reopen_file(file, true);
1867 rc = CIFSSMBRead(xid, pTcon,
1869 current_read_size, *poffset,
1870 &bytes_read, ¤t_offset,
1873 if (rc || (bytes_read == 0)) {
1881 cifs_stats_bytes_read(pTcon, total_read);
1882 *poffset += bytes_read;
1889 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1894 rc = cifs_revalidate_file(file);
1896 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1900 rc = generic_file_mmap(file, vma);
1906 static void cifs_copy_cache_pages(struct address_space *mapping,
1907 struct list_head *pages, int bytes_read, char *data)
1912 while (bytes_read > 0) {
1913 if (list_empty(pages))
1916 page = list_entry(pages->prev, struct page, lru);
1917 list_del(&page->lru);
1919 if (add_to_page_cache_lru(page, mapping, page->index,
1921 page_cache_release(page);
1922 cFYI(1, "Add page cache failed");
1923 data += PAGE_CACHE_SIZE;
1924 bytes_read -= PAGE_CACHE_SIZE;
1927 page_cache_release(page);
1929 target = kmap_atomic(page, KM_USER0);
1931 if (PAGE_CACHE_SIZE > bytes_read) {
1932 memcpy(target, data, bytes_read);
1933 /* zero the tail end of this partial page */
1934 memset(target + bytes_read, 0,
1935 PAGE_CACHE_SIZE - bytes_read);
1938 memcpy(target, data, PAGE_CACHE_SIZE);
1939 bytes_read -= PAGE_CACHE_SIZE;
1941 kunmap_atomic(target, KM_USER0);
1943 flush_dcache_page(page);
1944 SetPageUptodate(page);
1946 data += PAGE_CACHE_SIZE;
1948 /* add page to FS-Cache */
1949 cifs_readpage_to_fscache(mapping->host, page);
1954 static int cifs_readpages(struct file *file, struct address_space *mapping,
1955 struct list_head *page_list, unsigned num_pages)
1961 struct cifs_sb_info *cifs_sb;
1962 struct cifsTconInfo *pTcon;
1963 unsigned int bytes_read = 0;
1964 unsigned int read_size, i;
1965 char *smb_read_data = NULL;
1966 struct smb_com_read_rsp *pSMBr;
1967 struct cifsFileInfo *open_file;
1968 int buf_type = CIFS_NO_BUFFER;
1971 if (file->private_data == NULL) {
1976 open_file = file->private_data;
1977 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1978 pTcon = cifs_sb->tcon;
1981 * Reads as many pages as possible from fscache. Returns -ENOBUFS
1982 * immediately if the cookie is negative
1984 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
1989 cFYI(DBG2, "rpages: num pages %d", num_pages);
1990 for (i = 0; i < num_pages; ) {
1991 unsigned contig_pages;
1992 struct page *tmp_page;
1993 unsigned long expected_index;
1995 if (list_empty(page_list))
1998 page = list_entry(page_list->prev, struct page, lru);
1999 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2001 /* count adjacent pages that we will read into */
2004 list_entry(page_list->prev, struct page, lru)->index;
2005 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2006 if (tmp_page->index == expected_index) {
2012 if (contig_pages + i > num_pages)
2013 contig_pages = num_pages - i;
2015 /* for reads over a certain size could initiate async
2018 read_size = contig_pages * PAGE_CACHE_SIZE;
2019 /* Read size needs to be in multiples of one page */
2020 read_size = min_t(const unsigned int, read_size,
2021 cifs_sb->rsize & PAGE_CACHE_MASK);
2022 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
2023 read_size, contig_pages);
2025 while (rc == -EAGAIN) {
2026 if ((open_file->invalidHandle) &&
2027 (!open_file->closePend)) {
2028 rc = cifs_reopen_file(file, true);
2033 rc = CIFSSMBRead(xid, pTcon,
2036 &bytes_read, &smb_read_data,
2038 /* BB more RC checks ? */
2039 if (rc == -EAGAIN) {
2040 if (smb_read_data) {
2041 if (buf_type == CIFS_SMALL_BUFFER)
2042 cifs_small_buf_release(smb_read_data);
2043 else if (buf_type == CIFS_LARGE_BUFFER)
2044 cifs_buf_release(smb_read_data);
2045 smb_read_data = NULL;
2049 if ((rc < 0) || (smb_read_data == NULL)) {
2050 cFYI(1, "Read error in readpages: %d", rc);
2052 } else if (bytes_read > 0) {
2053 task_io_account_read(bytes_read);
2054 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2055 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2056 smb_read_data + 4 /* RFC1001 hdr */ +
2057 le16_to_cpu(pSMBr->DataOffset));
2059 i += bytes_read >> PAGE_CACHE_SHIFT;
2060 cifs_stats_bytes_read(pTcon, bytes_read);
2061 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2062 i++; /* account for partial page */
2064 /* server copy of file can have smaller size
2066 /* BB do we need to verify this common case ?
2067 this case is ok - if we are at server EOF
2068 we will hit it on next read */
2073 cFYI(1, "No bytes read (%d) at offset %lld . "
2074 "Cleaning remaining pages from readahead list",
2075 bytes_read, offset);
2076 /* BB turn off caching and do new lookup on
2077 file size at server? */
2080 if (smb_read_data) {
2081 if (buf_type == CIFS_SMALL_BUFFER)
2082 cifs_small_buf_release(smb_read_data);
2083 else if (buf_type == CIFS_LARGE_BUFFER)
2084 cifs_buf_release(smb_read_data);
2085 smb_read_data = NULL;
2090 /* need to free smb_read_data buf before exit */
2091 if (smb_read_data) {
2092 if (buf_type == CIFS_SMALL_BUFFER)
2093 cifs_small_buf_release(smb_read_data);
2094 else if (buf_type == CIFS_LARGE_BUFFER)
2095 cifs_buf_release(smb_read_data);
2096 smb_read_data = NULL;
2104 static int cifs_readpage_worker(struct file *file, struct page *page,
2110 /* Is the page cached? */
2111 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2115 page_cache_get(page);
2116 read_data = kmap(page);
2117 /* for reads over a certain size could initiate async read ahead */
2119 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2124 cFYI(1, "Bytes read %d", rc);
2126 file->f_path.dentry->d_inode->i_atime =
2127 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2129 if (PAGE_CACHE_SIZE > rc)
2130 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2132 flush_dcache_page(page);
2133 SetPageUptodate(page);
2135 /* send this page to the cache */
2136 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2142 page_cache_release(page);
2148 static int cifs_readpage(struct file *file, struct page *page)
2150 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2156 if (file->private_data == NULL) {
2162 cFYI(1, "readpage %p at offset %d 0x%x\n",
2163 page, (int)offset, (int)offset);
2165 rc = cifs_readpage_worker(file, page, &offset);
2173 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2175 struct cifsFileInfo *open_file;
2177 read_lock(&GlobalSMBSeslock);
2178 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2179 if (open_file->closePend)
2181 if (open_file->pfile &&
2182 ((open_file->pfile->f_flags & O_RDWR) ||
2183 (open_file->pfile->f_flags & O_WRONLY))) {
2184 read_unlock(&GlobalSMBSeslock);
2188 read_unlock(&GlobalSMBSeslock);
2192 /* We do not want to update the file size from server for inodes
2193 open for write - to avoid races with writepage extending
2194 the file - in the future we could consider allowing
2195 refreshing the inode only on increases in the file size
2196 but this is tricky to do without racing with writebehind
2197 page caching in the current Linux kernel design */
2198 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2203 if (is_inode_writable(cifsInode)) {
2204 /* This inode is open for write at least once */
2205 struct cifs_sb_info *cifs_sb;
2207 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2208 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2209 /* since no page cache to corrupt on directio
2210 we can change size safely */
2214 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2222 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2223 loff_t pos, unsigned len, unsigned flags,
2224 struct page **pagep, void **fsdata)
2226 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2227 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2228 loff_t page_start = pos & PAGE_MASK;
2233 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2235 page = grab_cache_page_write_begin(mapping, index, flags);
2241 if (PageUptodate(page))
2245 * If we write a full page it will be up to date, no need to read from
2246 * the server. If the write is short, we'll end up doing a sync write
2249 if (len == PAGE_CACHE_SIZE)
2253 * optimize away the read when we have an oplock, and we're not
2254 * expecting to use any of the data we'd be reading in. That
2255 * is, when the page lies beyond the EOF, or straddles the EOF
2256 * and the write will cover all of the existing data.
2258 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2259 i_size = i_size_read(mapping->host);
2260 if (page_start >= i_size ||
2261 (offset == 0 && (pos + len) >= i_size)) {
2262 zero_user_segments(page, 0, offset,
2266 * PageChecked means that the parts of the page
2267 * to which we're not writing are considered up
2268 * to date. Once the data is copied to the
2269 * page, it can be set uptodate.
2271 SetPageChecked(page);
2276 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2278 * might as well read a page, it is fast enough. If we get
2279 * an error, we don't need to return it. cifs_write_end will
2280 * do a sync write instead since PG_uptodate isn't set.
2282 cifs_readpage_worker(file, page, &page_start);
2284 /* we could try using another file handle if there is one -
2285 but how would we lock it to prevent close of that handle
2286 racing with this read? In any case
2287 this will be written out by write_end so is fine */
2294 static int cifs_release_page(struct page *page, gfp_t gfp)
2296 if (PagePrivate(page))
2299 return cifs_fscache_release_page(page, gfp);
2302 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2304 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2307 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2311 cifs_oplock_break(struct slow_work *work)
2313 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2315 struct inode *inode = cfile->pInode;
2316 struct cifsInodeInfo *cinode = CIFS_I(inode);
2317 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->mnt->mnt_sb);
2320 if (inode && S_ISREG(inode->i_mode)) {
2321 if (cinode->clientCanCacheRead)
2322 break_lease(inode, O_RDONLY);
2324 break_lease(inode, O_WRONLY);
2325 rc = filemap_fdatawrite(inode->i_mapping);
2326 if (cinode->clientCanCacheRead == 0) {
2327 waitrc = filemap_fdatawait(inode->i_mapping);
2328 invalidate_remote_inode(inode);
2333 cinode->write_behind_rc = rc;
2334 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2338 * releasing stale oplock after recent reconnect of smb session using
2339 * a now incorrect file handle is not a data integrity issue but do
2340 * not bother sending an oplock release if session to server still is
2341 * disconnected since oplock already released by the server
2343 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2344 rc = CIFSSMBLock(0, cifs_sb->tcon, cfile->netfid, 0, 0, 0, 0,
2345 LOCKING_ANDX_OPLOCK_RELEASE, false);
2346 cFYI(1, "Oplock release rc = %d", rc);
2351 cifs_oplock_break_get(struct slow_work *work)
2353 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2356 cifsFileInfo_get(cfile);
2361 cifs_oplock_break_put(struct slow_work *work)
2363 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2366 cifsFileInfo_put(cfile);
2369 const struct slow_work_ops cifs_oplock_break_ops = {
2370 .get_ref = cifs_oplock_break_get,
2371 .put_ref = cifs_oplock_break_put,
2372 .execute = cifs_oplock_break,
2375 const struct address_space_operations cifs_addr_ops = {
2376 .readpage = cifs_readpage,
2377 .readpages = cifs_readpages,
2378 .writepage = cifs_writepage,
2379 .writepages = cifs_writepages,
2380 .write_begin = cifs_write_begin,
2381 .write_end = cifs_write_end,
2382 .set_page_dirty = __set_page_dirty_nobuffers,
2383 .releasepage = cifs_release_page,
2384 .invalidatepage = cifs_invalidate_page,
2385 /* .sync_page = cifs_sync_page, */
2390 * cifs_readpages requires the server to support a buffer large enough to
2391 * contain the header plus one complete page of data. Otherwise, we need
2392 * to leave cifs_readpages out of the address space operations.
2394 const struct address_space_operations cifs_addr_ops_smallbuf = {
2395 .readpage = cifs_readpage,
2396 .writepage = cifs_writepage,
2397 .writepages = cifs_writepages,
2398 .write_begin = cifs_write_begin,
2399 .write_end = cifs_write_end,
2400 .set_page_dirty = __set_page_dirty_nobuffers,
2401 .releasepage = cifs_release_page,
2402 .invalidatepage = cifs_invalidate_page,
2403 /* .sync_page = cifs_sync_page, */