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, __u32 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 tcon_link *tlink;
228 struct cifsFileInfo *pCifsFile = NULL;
229 struct cifsInodeInfo *pCifsInode;
230 char *full_path = NULL;
234 FILE_ALL_INFO *buf = NULL;
238 cifs_sb = CIFS_SB(inode->i_sb);
239 tlink = cifs_sb_tlink(cifs_sb);
242 return PTR_ERR(tlink);
244 tcon = tlink_tcon(tlink);
246 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
248 full_path = build_path_from_dentry(file->f_path.dentry);
249 if (full_path == NULL) {
254 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
255 inode, file->f_flags, full_path);
262 if (!tcon->broken_posix_open && tcon->unix_ext &&
263 (tcon->ses->capabilities & CAP_UNIX) &&
264 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
265 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
266 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
267 oflags |= SMB_O_CREAT;
268 /* can not refresh inode info since size could be stale */
269 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
270 cifs_sb->mnt_file_mode /* ignored */,
271 oflags, &oplock, &netfid, xid);
273 cFYI(1, "posix open succeeded");
274 /* no need for special case handling of setting mode
275 on read only files needed here */
277 rc = cifs_posix_open_inode_helper(inode, file,
278 pCifsInode, oplock, netfid);
280 CIFSSMBClose(xid, tcon, netfid);
284 pCifsFile = cifs_new_fileinfo(inode, netfid, file,
286 tlink, oflags, oplock);
287 if (pCifsFile == NULL) {
288 CIFSSMBClose(xid, tcon, netfid);
292 cifs_fscache_set_inode_cookie(inode, file);
295 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
296 if (tcon->ses->serverNOS)
297 cERROR(1, "server %s of type %s returned"
298 " unexpected error on SMB posix open"
299 ", disabling posix open support."
300 " Check if server update available.",
301 tcon->ses->serverName,
302 tcon->ses->serverNOS);
303 tcon->broken_posix_open = true;
304 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
305 (rc != -EOPNOTSUPP)) /* path not found or net err */
307 /* else fallthrough to retry open the old way on network i/o
311 desiredAccess = cifs_convert_flags(file->f_flags);
313 /*********************************************************************
314 * open flag mapping table:
316 * POSIX Flag CIFS Disposition
317 * ---------- ----------------
318 * O_CREAT FILE_OPEN_IF
319 * O_CREAT | O_EXCL FILE_CREATE
320 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
321 * O_TRUNC FILE_OVERWRITE
322 * none of the above FILE_OPEN
324 * Note that there is not a direct match between disposition
325 * FILE_SUPERSEDE (ie create whether or not file exists although
326 * O_CREAT | O_TRUNC is similar but truncates the existing
327 * file rather than creating a new file as FILE_SUPERSEDE does
328 * (which uses the attributes / metadata passed in on open call)
330 *? O_SYNC is a reasonable match to CIFS writethrough flag
331 *? and the read write flags match reasonably. O_LARGEFILE
332 *? is irrelevant because largefile support is always used
333 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
334 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
335 *********************************************************************/
337 disposition = cifs_get_disposition(file->f_flags);
339 /* BB pass O_SYNC flag through on file attributes .. BB */
341 /* Also refresh inode by passing in file_info buf returned by SMBOpen
342 and calling get_inode_info with returned buf (at least helps
343 non-Unix server case) */
345 /* BB we can not do this if this is the second open of a file
346 and the first handle has writebehind data, we might be
347 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
348 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
354 if (tcon->ses->capabilities & CAP_NT_SMBS)
355 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
356 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
357 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
358 & CIFS_MOUNT_MAP_SPECIAL_CHR);
360 rc = -EIO; /* no NT SMB support fall into legacy open below */
363 /* Old server, try legacy style OpenX */
364 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
365 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
366 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
367 & CIFS_MOUNT_MAP_SPECIAL_CHR);
370 cFYI(1, "cifs_open returned 0x%x", rc);
374 rc = cifs_open_inode_helper(inode, tcon, oplock, buf, full_path, xid);
378 pCifsFile = cifs_new_fileinfo(inode, netfid, file, file->f_path.mnt,
379 tlink, file->f_flags, oplock);
380 if (pCifsFile == NULL) {
385 cifs_fscache_set_inode_cookie(inode, file);
387 if (oplock & CIFS_CREATE_ACTION) {
388 /* time to set mode which we can not set earlier due to
389 problems creating new read-only files */
390 if (tcon->unix_ext) {
391 struct cifs_unix_set_info_args args = {
392 .mode = inode->i_mode,
395 .ctime = NO_CHANGE_64,
396 .atime = NO_CHANGE_64,
397 .mtime = NO_CHANGE_64,
400 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
402 cifs_sb->mnt_cifs_flags &
403 CIFS_MOUNT_MAP_SPECIAL_CHR);
411 cifs_put_tlink(tlink);
415 /* Try to reacquire byte range locks that were released when session */
416 /* to server was lost */
417 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
421 /* BB list all locks open on this file and relock */
426 static int cifs_reopen_file(struct file *file, bool can_flush)
431 struct cifs_sb_info *cifs_sb;
432 struct cifsTconInfo *tcon;
433 struct cifsFileInfo *pCifsFile;
434 struct cifsInodeInfo *pCifsInode;
436 char *full_path = NULL;
438 int disposition = FILE_OPEN;
441 if (file->private_data)
442 pCifsFile = file->private_data;
447 mutex_lock(&pCifsFile->fh_mutex);
448 if (!pCifsFile->invalidHandle) {
449 mutex_unlock(&pCifsFile->fh_mutex);
455 if (file->f_path.dentry == NULL) {
456 cERROR(1, "no valid name if dentry freed");
459 goto reopen_error_exit;
462 inode = file->f_path.dentry->d_inode;
464 cERROR(1, "inode not valid");
467 goto reopen_error_exit;
470 cifs_sb = CIFS_SB(inode->i_sb);
471 tcon = tlink_tcon(pCifsFile->tlink);
473 /* can not grab rename sem here because various ops, including
474 those that already have the rename sem can end up causing writepage
475 to get called and if the server was down that means we end up here,
476 and we can never tell if the caller already has the rename_sem */
477 full_path = build_path_from_dentry(file->f_path.dentry);
478 if (full_path == NULL) {
481 mutex_unlock(&pCifsFile->fh_mutex);
486 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
487 inode, file->f_flags, full_path);
494 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
495 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
496 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
497 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
498 /* can not refresh inode info since size could be stale */
499 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
500 cifs_sb->mnt_file_mode /* ignored */,
501 oflags, &oplock, &netfid, xid);
503 cFYI(1, "posix reopen succeeded");
506 /* fallthrough to retry open the old way on errors, especially
507 in the reconnect path it is important to retry hard */
510 desiredAccess = cifs_convert_flags(file->f_flags);
512 /* Can not refresh inode by passing in file_info buf to be returned
513 by SMBOpen and then calling get_inode_info with returned buf
514 since file might have write behind data that needs to be flushed
515 and server version of file size can be stale. If we knew for sure
516 that inode was not dirty locally we could do this */
518 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
519 CREATE_NOT_DIR, &netfid, &oplock, NULL,
520 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
521 CIFS_MOUNT_MAP_SPECIAL_CHR);
523 mutex_unlock(&pCifsFile->fh_mutex);
524 cFYI(1, "cifs_open returned 0x%x", rc);
525 cFYI(1, "oplock: %d", oplock);
528 pCifsFile->netfid = netfid;
529 pCifsFile->invalidHandle = false;
530 mutex_unlock(&pCifsFile->fh_mutex);
531 pCifsInode = CIFS_I(inode);
534 rc = filemap_write_and_wait(inode->i_mapping);
536 CIFS_I(inode)->write_behind_rc = rc;
537 /* temporarily disable caching while we
538 go to server to get inode info */
539 pCifsInode->clientCanCacheAll = false;
540 pCifsInode->clientCanCacheRead = false;
542 rc = cifs_get_inode_info_unix(&inode,
543 full_path, inode->i_sb, xid);
545 rc = cifs_get_inode_info(&inode,
546 full_path, NULL, inode->i_sb,
548 } /* else we are writing out data to server already
549 and could deadlock if we tried to flush data, and
550 since we do not know if we have data that would
551 invalidate the current end of file on the server
552 we can not go to the server to get the new inod
554 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
555 pCifsInode->clientCanCacheAll = true;
556 pCifsInode->clientCanCacheRead = true;
557 cFYI(1, "Exclusive Oplock granted on inode %p",
558 file->f_path.dentry->d_inode);
559 } else if ((oplock & 0xF) == OPLOCK_READ) {
560 pCifsInode->clientCanCacheRead = true;
561 pCifsInode->clientCanCacheAll = false;
563 pCifsInode->clientCanCacheRead = false;
564 pCifsInode->clientCanCacheAll = false;
566 cifs_relock_file(pCifsFile);
574 int cifs_close(struct inode *inode, struct file *file)
578 struct cifs_sb_info *cifs_sb;
579 struct cifsTconInfo *pTcon;
580 struct cifsFileInfo *pSMBFile = file->private_data;
584 cifs_sb = CIFS_SB(inode->i_sb);
585 pTcon = tlink_tcon(pSMBFile->tlink);
587 struct cifsLockInfo *li, *tmp;
588 write_lock(&GlobalSMBSeslock);
589 pSMBFile->closePend = true;
591 /* no sense reconnecting to close a file that is
593 if (!pTcon->need_reconnect) {
594 write_unlock(&GlobalSMBSeslock);
596 while ((atomic_read(&pSMBFile->count) != 1)
597 && (timeout <= 2048)) {
598 /* Give write a better chance to get to
599 server ahead of the close. We do not
600 want to add a wait_q here as it would
601 increase the memory utilization as
602 the struct would be in each open file,
603 but this should give enough time to
605 cFYI(DBG2, "close delay, write pending");
609 if (!pTcon->need_reconnect &&
610 !pSMBFile->invalidHandle)
611 rc = CIFSSMBClose(xid, pTcon,
614 write_unlock(&GlobalSMBSeslock);
616 write_unlock(&GlobalSMBSeslock);
618 /* Delete any outstanding lock records.
619 We'll lose them when the file is closed anyway. */
620 mutex_lock(&pSMBFile->lock_mutex);
621 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
622 list_del(&li->llist);
625 mutex_unlock(&pSMBFile->lock_mutex);
627 write_lock(&GlobalSMBSeslock);
628 list_del(&pSMBFile->flist);
629 list_del(&pSMBFile->tlist);
630 write_unlock(&GlobalSMBSeslock);
631 cifsFileInfo_put(file->private_data);
632 file->private_data = NULL;
636 read_lock(&GlobalSMBSeslock);
637 if (list_empty(&(CIFS_I(inode)->openFileList))) {
638 cFYI(1, "closing last open instance for inode %p", inode);
639 /* if the file is not open we do not know if we can cache info
640 on this inode, much less write behind and read ahead */
641 CIFS_I(inode)->clientCanCacheRead = false;
642 CIFS_I(inode)->clientCanCacheAll = false;
644 read_unlock(&GlobalSMBSeslock);
645 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
646 rc = CIFS_I(inode)->write_behind_rc;
651 int cifs_closedir(struct inode *inode, struct file *file)
655 struct cifsFileInfo *pCFileStruct = file->private_data;
658 cFYI(1, "Closedir inode = 0x%p", inode);
663 struct cifsTconInfo *pTcon = tlink_tcon(pCFileStruct->tlink);
665 cFYI(1, "Freeing private data in close dir");
666 write_lock(&GlobalSMBSeslock);
667 if (!pCFileStruct->srch_inf.endOfSearch &&
668 !pCFileStruct->invalidHandle) {
669 pCFileStruct->invalidHandle = true;
670 write_unlock(&GlobalSMBSeslock);
671 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
672 cFYI(1, "Closing uncompleted readdir with rc %d",
674 /* not much we can do if it fails anyway, ignore rc */
677 write_unlock(&GlobalSMBSeslock);
678 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
680 cFYI(1, "closedir free smb buf in srch struct");
681 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
682 if (pCFileStruct->srch_inf.smallBuf)
683 cifs_small_buf_release(ptmp);
685 cifs_buf_release(ptmp);
687 cifs_put_tlink(pCFileStruct->tlink);
688 kfree(file->private_data);
689 file->private_data = NULL;
691 /* BB can we lock the filestruct while this is going on? */
696 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
697 __u64 offset, __u8 lockType)
699 struct cifsLockInfo *li =
700 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
706 mutex_lock(&fid->lock_mutex);
707 list_add(&li->llist, &fid->llist);
708 mutex_unlock(&fid->lock_mutex);
712 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
718 bool wait_flag = false;
719 struct cifs_sb_info *cifs_sb;
720 struct cifsTconInfo *tcon;
722 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
723 bool posix_locking = 0;
725 length = 1 + pfLock->fl_end - pfLock->fl_start;
729 cFYI(1, "Lock parm: 0x%x flockflags: "
730 "0x%x flocktype: 0x%x start: %lld end: %lld",
731 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
734 if (pfLock->fl_flags & FL_POSIX)
736 if (pfLock->fl_flags & FL_FLOCK)
738 if (pfLock->fl_flags & FL_SLEEP) {
739 cFYI(1, "Blocking lock");
742 if (pfLock->fl_flags & FL_ACCESS)
743 cFYI(1, "Process suspended by mandatory locking - "
744 "not implemented yet");
745 if (pfLock->fl_flags & FL_LEASE)
746 cFYI(1, "Lease on file - not implemented yet");
747 if (pfLock->fl_flags &
748 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
749 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
751 if (pfLock->fl_type == F_WRLCK) {
754 } else if (pfLock->fl_type == F_UNLCK) {
757 /* Check if unlock includes more than
759 } else if (pfLock->fl_type == F_RDLCK) {
761 lockType |= LOCKING_ANDX_SHARED_LOCK;
763 } else if (pfLock->fl_type == F_EXLCK) {
766 } else if (pfLock->fl_type == F_SHLCK) {
768 lockType |= LOCKING_ANDX_SHARED_LOCK;
771 cFYI(1, "Unknown type of lock");
773 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
774 tcon = tlink_tcon(((struct cifsFileInfo *)file->private_data)->tlink);
776 if (file->private_data == NULL) {
781 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
783 if ((tcon->ses->capabilities & CAP_UNIX) &&
784 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
785 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
787 /* BB add code here to normalize offset and length to
788 account for negative length which we can not accept over the
793 if (lockType & LOCKING_ANDX_SHARED_LOCK)
794 posix_lock_type = CIFS_RDLCK;
796 posix_lock_type = CIFS_WRLCK;
797 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
799 posix_lock_type, wait_flag);
804 /* BB we could chain these into one lock request BB */
805 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
806 0, 1, lockType, 0 /* wait flag */ );
808 rc = CIFSSMBLock(xid, tcon, netfid, length,
809 pfLock->fl_start, 1 /* numUnlock */ ,
810 0 /* numLock */ , lockType,
812 pfLock->fl_type = F_UNLCK;
814 cERROR(1, "Error unlocking previously locked "
815 "range %d during test of lock", rc);
819 /* if rc == ERR_SHARING_VIOLATION ? */
822 if (lockType & LOCKING_ANDX_SHARED_LOCK) {
823 pfLock->fl_type = F_WRLCK;
825 rc = CIFSSMBLock(xid, tcon, netfid, length,
826 pfLock->fl_start, 0, 1,
827 lockType | LOCKING_ANDX_SHARED_LOCK,
830 rc = CIFSSMBLock(xid, tcon, netfid,
831 length, pfLock->fl_start, 1, 0,
833 LOCKING_ANDX_SHARED_LOCK,
835 pfLock->fl_type = F_RDLCK;
837 cERROR(1, "Error unlocking "
838 "previously locked range %d "
839 "during test of lock", rc);
842 pfLock->fl_type = F_WRLCK;
852 if (!numLock && !numUnlock) {
853 /* if no lock or unlock then nothing
854 to do since we do not know what it is */
861 if (lockType & LOCKING_ANDX_SHARED_LOCK)
862 posix_lock_type = CIFS_RDLCK;
864 posix_lock_type = CIFS_WRLCK;
867 posix_lock_type = CIFS_UNLCK;
869 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
871 posix_lock_type, wait_flag);
873 struct cifsFileInfo *fid = file->private_data;
876 rc = CIFSSMBLock(xid, tcon, netfid, length,
878 0, numLock, lockType, wait_flag);
881 /* For Windows locks we must store them. */
882 rc = store_file_lock(fid, length,
883 pfLock->fl_start, lockType);
885 } else if (numUnlock) {
886 /* For each stored lock that this unlock overlaps
887 completely, unlock it. */
889 struct cifsLockInfo *li, *tmp;
892 mutex_lock(&fid->lock_mutex);
893 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
894 if (pfLock->fl_start <= li->offset &&
895 (pfLock->fl_start + length) >=
896 (li->offset + li->length)) {
897 stored_rc = CIFSSMBLock(xid, tcon,
899 li->length, li->offset,
900 1, 0, li->type, false);
904 list_del(&li->llist);
909 mutex_unlock(&fid->lock_mutex);
913 if (pfLock->fl_flags & FL_POSIX)
914 posix_lock_file_wait(file, pfLock);
920 * Set the timeout on write requests past EOF. For some servers (Windows)
921 * these calls can be very long.
923 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
924 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
925 * The 10M cutoff is totally arbitrary. A better scheme for this would be
926 * welcome if someone wants to suggest one.
928 * We may be able to do a better job with this if there were some way to
929 * declare that a file should be sparse.
932 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
934 if (offset <= cifsi->server_eof)
936 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
937 return CIFS_VLONG_OP;
942 /* update the file size (if needed) after a write */
944 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
945 unsigned int bytes_written)
947 loff_t end_of_write = offset + bytes_written;
949 if (end_of_write > cifsi->server_eof)
950 cifsi->server_eof = end_of_write;
953 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
954 size_t write_size, loff_t *poffset)
957 unsigned int bytes_written = 0;
958 unsigned int total_written;
959 struct cifs_sb_info *cifs_sb;
960 struct cifsTconInfo *pTcon;
962 struct cifsFileInfo *open_file;
963 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
965 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
967 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
968 *poffset, file->f_path.dentry->d_name.name); */
970 if (file->private_data == NULL)
973 open_file = file->private_data;
974 pTcon = tlink_tcon(open_file->tlink);
976 rc = generic_write_checks(file, poffset, &write_size, 0);
982 long_op = cifs_write_timeout(cifsi, *poffset);
983 for (total_written = 0; write_size > total_written;
984 total_written += bytes_written) {
986 while (rc == -EAGAIN) {
987 if (file->private_data == NULL) {
988 /* file has been closed on us */
990 /* if we have gotten here we have written some data
991 and blocked, and the file has been freed on us while
992 we blocked so return what we managed to write */
993 return total_written;
995 if (open_file->closePend) {
998 return total_written;
1002 if (open_file->invalidHandle) {
1003 /* we could deadlock if we called
1004 filemap_fdatawait from here so tell
1005 reopen_file not to flush data to server
1007 rc = cifs_reopen_file(file, false);
1012 rc = CIFSSMBWrite(xid, pTcon,
1014 min_t(const int, cifs_sb->wsize,
1015 write_size - total_written),
1016 *poffset, &bytes_written,
1017 NULL, write_data + total_written, long_op);
1019 if (rc || (bytes_written == 0)) {
1027 cifs_update_eof(cifsi, *poffset, bytes_written);
1028 *poffset += bytes_written;
1030 long_op = CIFS_STD_OP; /* subsequent writes fast -
1031 15 seconds is plenty */
1034 cifs_stats_bytes_written(pTcon, total_written);
1036 /* since the write may have blocked check these pointers again */
1037 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1038 struct inode *inode = file->f_path.dentry->d_inode;
1039 /* Do not update local mtime - server will set its actual value on write
1040 * inode->i_ctime = inode->i_mtime =
1041 * current_fs_time(inode->i_sb);*/
1042 if (total_written > 0) {
1043 spin_lock(&inode->i_lock);
1044 if (*poffset > file->f_path.dentry->d_inode->i_size)
1045 i_size_write(file->f_path.dentry->d_inode,
1047 spin_unlock(&inode->i_lock);
1049 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1052 return total_written;
1055 static ssize_t cifs_write(struct file *file, const char *write_data,
1056 size_t write_size, loff_t *poffset)
1059 unsigned int bytes_written = 0;
1060 unsigned int total_written;
1061 struct cifs_sb_info *cifs_sb;
1062 struct cifsTconInfo *pTcon;
1064 struct cifsFileInfo *open_file;
1065 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1067 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1069 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1070 *poffset, file->f_path.dentry->d_name.name);
1072 if (file->private_data == NULL)
1074 open_file = file->private_data;
1075 pTcon = tlink_tcon(open_file->tlink);
1079 long_op = cifs_write_timeout(cifsi, *poffset);
1080 for (total_written = 0; write_size > total_written;
1081 total_written += bytes_written) {
1083 while (rc == -EAGAIN) {
1084 if (file->private_data == NULL) {
1085 /* file has been closed on us */
1087 /* if we have gotten here we have written some data
1088 and blocked, and the file has been freed on us
1089 while we blocked so return what we managed to
1091 return total_written;
1093 if (open_file->closePend) {
1096 return total_written;
1100 if (open_file->invalidHandle) {
1101 /* we could deadlock if we called
1102 filemap_fdatawait from here so tell
1103 reopen_file not to flush data to
1105 rc = cifs_reopen_file(file, false);
1109 if (experimEnabled || (pTcon->ses->server &&
1110 ((pTcon->ses->server->secMode &
1111 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1116 len = min((size_t)cifs_sb->wsize,
1117 write_size - total_written);
1118 /* iov[0] is reserved for smb header */
1119 iov[1].iov_base = (char *)write_data +
1121 iov[1].iov_len = len;
1122 rc = CIFSSMBWrite2(xid, pTcon,
1123 open_file->netfid, len,
1124 *poffset, &bytes_written,
1127 rc = CIFSSMBWrite(xid, pTcon,
1129 min_t(const int, cifs_sb->wsize,
1130 write_size - total_written),
1131 *poffset, &bytes_written,
1132 write_data + total_written,
1135 if (rc || (bytes_written == 0)) {
1143 cifs_update_eof(cifsi, *poffset, bytes_written);
1144 *poffset += bytes_written;
1146 long_op = CIFS_STD_OP; /* subsequent writes fast -
1147 15 seconds is plenty */
1150 cifs_stats_bytes_written(pTcon, total_written);
1152 /* since the write may have blocked check these pointers again */
1153 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1154 /*BB We could make this contingent on superblock ATIME flag too */
1155 /* file->f_path.dentry->d_inode->i_ctime =
1156 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1157 if (total_written > 0) {
1158 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1159 if (*poffset > file->f_path.dentry->d_inode->i_size)
1160 i_size_write(file->f_path.dentry->d_inode,
1162 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1164 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1167 return total_written;
1170 #ifdef CONFIG_CIFS_EXPERIMENTAL
1171 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1174 struct cifsFileInfo *open_file = NULL;
1175 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1177 /* only filter by fsuid on multiuser mounts */
1178 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1181 read_lock(&GlobalSMBSeslock);
1182 /* we could simply get the first_list_entry since write-only entries
1183 are always at the end of the list but since the first entry might
1184 have a close pending, we go through the whole list */
1185 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1186 if (open_file->closePend)
1188 if (fsuid_only && open_file->uid != current_fsuid())
1190 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1191 (open_file->pfile->f_flags & O_RDONLY))) {
1192 if (!open_file->invalidHandle) {
1193 /* found a good file */
1194 /* lock it so it will not be closed on us */
1195 cifsFileInfo_get(open_file);
1196 read_unlock(&GlobalSMBSeslock);
1198 } /* else might as well continue, and look for
1199 another, or simply have the caller reopen it
1200 again rather than trying to fix this handle */
1201 } else /* write only file */
1202 break; /* write only files are last so must be done */
1204 read_unlock(&GlobalSMBSeslock);
1209 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1212 struct cifsFileInfo *open_file;
1213 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1214 bool any_available = false;
1217 /* Having a null inode here (because mapping->host was set to zero by
1218 the VFS or MM) should not happen but we had reports of on oops (due to
1219 it being zero) during stress testcases so we need to check for it */
1221 if (cifs_inode == NULL) {
1222 cERROR(1, "Null inode passed to cifs_writeable_file");
1227 /* only filter by fsuid on multiuser mounts */
1228 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1231 read_lock(&GlobalSMBSeslock);
1233 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1234 if (open_file->closePend)
1236 if (!any_available && open_file->pid != current->tgid)
1238 if (fsuid_only && open_file->uid != current_fsuid())
1240 if (open_file->pfile &&
1241 ((open_file->pfile->f_flags & O_RDWR) ||
1242 (open_file->pfile->f_flags & O_WRONLY))) {
1243 cifsFileInfo_get(open_file);
1245 if (!open_file->invalidHandle) {
1246 /* found a good writable file */
1247 read_unlock(&GlobalSMBSeslock);
1251 read_unlock(&GlobalSMBSeslock);
1252 /* Had to unlock since following call can block */
1253 rc = cifs_reopen_file(open_file->pfile, false);
1255 if (!open_file->closePend)
1257 else { /* start over in case this was deleted */
1258 /* since the list could be modified */
1259 read_lock(&GlobalSMBSeslock);
1260 cifsFileInfo_put(open_file);
1261 goto refind_writable;
1265 /* if it fails, try another handle if possible -
1266 (we can not do this if closePending since
1267 loop could be modified - in which case we
1268 have to start at the beginning of the list
1269 again. Note that it would be bad
1270 to hold up writepages here (rather than
1271 in caller) with continuous retries */
1272 cFYI(1, "wp failed on reopen file");
1273 read_lock(&GlobalSMBSeslock);
1274 /* can not use this handle, no write
1275 pending on this one after all */
1276 cifsFileInfo_put(open_file);
1278 if (open_file->closePend) /* list could have changed */
1279 goto refind_writable;
1280 /* else we simply continue to the next entry. Thus
1281 we do not loop on reopen errors. If we
1282 can not reopen the file, for example if we
1283 reconnected to a server with another client
1284 racing to delete or lock the file we would not
1285 make progress if we restarted before the beginning
1286 of the loop here. */
1289 /* couldn't find useable FH with same pid, try any available */
1290 if (!any_available) {
1291 any_available = true;
1292 goto refind_writable;
1294 read_unlock(&GlobalSMBSeslock);
1298 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1300 struct address_space *mapping = page->mapping;
1301 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1304 int bytes_written = 0;
1305 struct cifs_sb_info *cifs_sb;
1306 struct inode *inode;
1307 struct cifsFileInfo *open_file;
1309 if (!mapping || !mapping->host)
1312 inode = page->mapping->host;
1313 cifs_sb = CIFS_SB(inode->i_sb);
1315 offset += (loff_t)from;
1316 write_data = kmap(page);
1319 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1324 /* racing with truncate? */
1325 if (offset > mapping->host->i_size) {
1327 return 0; /* don't care */
1330 /* check to make sure that we are not extending the file */
1331 if (mapping->host->i_size - offset < (loff_t)to)
1332 to = (unsigned)(mapping->host->i_size - offset);
1334 open_file = find_writable_file(CIFS_I(mapping->host), false);
1336 bytes_written = cifs_write(open_file->pfile, write_data,
1338 cifsFileInfo_put(open_file);
1339 /* Does mm or vfs already set times? */
1340 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1341 if ((bytes_written > 0) && (offset))
1343 else if (bytes_written < 0)
1346 cFYI(1, "No writeable filehandles for inode");
1354 static int cifs_writepages(struct address_space *mapping,
1355 struct writeback_control *wbc)
1357 struct backing_dev_info *bdi = mapping->backing_dev_info;
1358 unsigned int bytes_to_write;
1359 unsigned int bytes_written;
1360 struct cifs_sb_info *cifs_sb;
1364 int range_whole = 0;
1371 struct cifsFileInfo *open_file;
1372 struct cifsTconInfo *tcon;
1373 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1375 struct pagevec pvec;
1381 * BB: Is this meaningful for a non-block-device file system?
1382 * If it is, we should test it again after we do I/O
1384 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1385 wbc->encountered_congestion = 1;
1389 cifs_sb = CIFS_SB(mapping->host->i_sb);
1392 * If wsize is smaller that the page cache size, default to writing
1393 * one page at a time via cifs_writepage
1395 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1396 return generic_writepages(mapping, wbc);
1398 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1400 return generic_writepages(mapping, wbc);
1403 * if there's no open file, then this is likely to fail too,
1404 * but it'll at least handle the return. Maybe it should be
1407 open_file = find_writable_file(CIFS_I(mapping->host), false);
1410 return generic_writepages(mapping, wbc);
1413 tcon = tlink_tcon(open_file->tlink);
1414 if (!experimEnabled && tcon->ses->server->secMode &
1415 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1416 cifsFileInfo_put(open_file);
1417 return generic_writepages(mapping, wbc);
1419 cifsFileInfo_put(open_file);
1423 pagevec_init(&pvec, 0);
1424 if (wbc->range_cyclic) {
1425 index = mapping->writeback_index; /* Start from prev offset */
1428 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1429 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1430 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1435 while (!done && (index <= end) &&
1436 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1437 PAGECACHE_TAG_DIRTY,
1438 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1447 for (i = 0; i < nr_pages; i++) {
1448 page = pvec.pages[i];
1450 * At this point we hold neither mapping->tree_lock nor
1451 * lock on the page itself: the page may be truncated or
1452 * invalidated (changing page->mapping to NULL), or even
1453 * swizzled back from swapper_space to tmpfs file
1459 else if (!trylock_page(page))
1462 if (unlikely(page->mapping != mapping)) {
1467 if (!wbc->range_cyclic && page->index > end) {
1473 if (next && (page->index != next)) {
1474 /* Not next consecutive page */
1479 if (wbc->sync_mode != WB_SYNC_NONE)
1480 wait_on_page_writeback(page);
1482 if (PageWriteback(page) ||
1483 !clear_page_dirty_for_io(page)) {
1489 * This actually clears the dirty bit in the radix tree.
1490 * See cifs_writepage() for more commentary.
1492 set_page_writeback(page);
1494 if (page_offset(page) >= mapping->host->i_size) {
1497 end_page_writeback(page);
1502 * BB can we get rid of this? pages are held by pvec
1504 page_cache_get(page);
1506 len = min(mapping->host->i_size - page_offset(page),
1507 (loff_t)PAGE_CACHE_SIZE);
1509 /* reserve iov[0] for the smb header */
1511 iov[n_iov].iov_base = kmap(page);
1512 iov[n_iov].iov_len = len;
1513 bytes_to_write += len;
1517 offset = page_offset(page);
1519 next = page->index + 1;
1520 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1524 open_file = find_writable_file(CIFS_I(mapping->host),
1527 cERROR(1, "No writable handles for inode");
1530 long_op = cifs_write_timeout(cifsi, offset);
1531 rc = CIFSSMBWrite2(xid, tcon, open_file->netfid,
1532 bytes_to_write, offset,
1533 &bytes_written, iov, n_iov,
1535 cifsFileInfo_put(open_file);
1536 cifs_update_eof(cifsi, offset, bytes_written);
1539 if (rc || bytes_written < bytes_to_write) {
1540 cERROR(1, "Write2 ret %d, wrote %d",
1542 /* BB what if continued retry is
1543 requested via mount flags? */
1545 set_bit(AS_ENOSPC, &mapping->flags);
1547 set_bit(AS_EIO, &mapping->flags);
1549 cifs_stats_bytes_written(tcon, bytes_written);
1552 for (i = 0; i < n_iov; i++) {
1553 page = pvec.pages[first + i];
1554 /* Should we also set page error on
1555 success rc but too little data written? */
1556 /* BB investigate retry logic on temporary
1557 server crash cases and how recovery works
1558 when page marked as error */
1563 end_page_writeback(page);
1564 page_cache_release(page);
1566 if ((wbc->nr_to_write -= n_iov) <= 0)
1570 /* Need to re-find the pages we skipped */
1571 index = pvec.pages[0]->index + 1;
1573 pagevec_release(&pvec);
1575 if (!scanned && !done) {
1577 * We hit the last page and there is more work to be done: wrap
1578 * back to the start of the file
1584 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1585 mapping->writeback_index = index;
1592 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1598 /* BB add check for wbc flags */
1599 page_cache_get(page);
1600 if (!PageUptodate(page))
1601 cFYI(1, "ppw - page not up to date");
1604 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1606 * A writepage() implementation always needs to do either this,
1607 * or re-dirty the page with "redirty_page_for_writepage()" in
1608 * the case of a failure.
1610 * Just unlocking the page will cause the radix tree tag-bits
1611 * to fail to update with the state of the page correctly.
1613 set_page_writeback(page);
1614 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1615 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1617 end_page_writeback(page);
1618 page_cache_release(page);
1623 static int cifs_write_end(struct file *file, struct address_space *mapping,
1624 loff_t pos, unsigned len, unsigned copied,
1625 struct page *page, void *fsdata)
1628 struct inode *inode = mapping->host;
1630 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1633 if (PageChecked(page)) {
1635 SetPageUptodate(page);
1636 ClearPageChecked(page);
1637 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1638 SetPageUptodate(page);
1640 if (!PageUptodate(page)) {
1642 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1646 /* this is probably better than directly calling
1647 partialpage_write since in this function the file handle is
1648 known which we might as well leverage */
1649 /* BB check if anything else missing out of ppw
1650 such as updating last write time */
1651 page_data = kmap(page);
1652 rc = cifs_write(file, page_data + offset, copied, &pos);
1653 /* if (rc < 0) should we set writebehind rc? */
1660 set_page_dirty(page);
1664 spin_lock(&inode->i_lock);
1665 if (pos > inode->i_size)
1666 i_size_write(inode, pos);
1667 spin_unlock(&inode->i_lock);
1671 page_cache_release(page);
1676 int cifs_fsync(struct file *file, int datasync)
1680 struct cifsTconInfo *tcon;
1681 struct cifsFileInfo *smbfile = file->private_data;
1682 struct inode *inode = file->f_path.dentry->d_inode;
1686 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1687 file->f_path.dentry->d_name.name, datasync);
1689 rc = filemap_write_and_wait(inode->i_mapping);
1691 rc = CIFS_I(inode)->write_behind_rc;
1692 CIFS_I(inode)->write_behind_rc = 0;
1693 tcon = tlink_tcon(smbfile->tlink);
1694 if (!rc && tcon && smbfile &&
1695 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1696 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1703 /* static void cifs_sync_page(struct page *page)
1705 struct address_space *mapping;
1706 struct inode *inode;
1707 unsigned long index = page->index;
1708 unsigned int rpages = 0;
1711 cFYI(1, "sync page %p", page);
1712 mapping = page->mapping;
1715 inode = mapping->host;
1719 /* fill in rpages then
1720 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1722 /* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1732 * As file closes, flush all cached write data for this inode checking
1733 * for write behind errors.
1735 int cifs_flush(struct file *file, fl_owner_t id)
1737 struct inode *inode = file->f_path.dentry->d_inode;
1740 /* Rather than do the steps manually:
1741 lock the inode for writing
1742 loop through pages looking for write behind data (dirty pages)
1743 coalesce into contiguous 16K (or smaller) chunks to write to server
1744 send to server (prefer in parallel)
1745 deal with writebehind errors
1746 unlock inode for writing
1747 filemapfdatawrite appears easier for the time being */
1749 rc = filemap_fdatawrite(inode->i_mapping);
1750 /* reset wb rc if we were able to write out dirty pages */
1752 rc = CIFS_I(inode)->write_behind_rc;
1753 CIFS_I(inode)->write_behind_rc = 0;
1756 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1761 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1762 size_t read_size, loff_t *poffset)
1765 unsigned int bytes_read = 0;
1766 unsigned int total_read = 0;
1767 unsigned int current_read_size;
1768 struct cifs_sb_info *cifs_sb;
1769 struct cifsTconInfo *pTcon;
1771 struct cifsFileInfo *open_file;
1772 char *smb_read_data;
1773 char __user *current_offset;
1774 struct smb_com_read_rsp *pSMBr;
1777 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1779 if (file->private_data == NULL) {
1784 open_file = file->private_data;
1785 pTcon = tlink_tcon(open_file->tlink);
1787 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1788 cFYI(1, "attempting read on write only file instance");
1790 for (total_read = 0, current_offset = read_data;
1791 read_size > total_read;
1792 total_read += bytes_read, current_offset += bytes_read) {
1793 current_read_size = min_t(const int, read_size - total_read,
1796 smb_read_data = NULL;
1797 while (rc == -EAGAIN) {
1798 int buf_type = CIFS_NO_BUFFER;
1799 if ((open_file->invalidHandle) &&
1800 (!open_file->closePend)) {
1801 rc = cifs_reopen_file(file, true);
1805 rc = CIFSSMBRead(xid, pTcon,
1807 current_read_size, *poffset,
1808 &bytes_read, &smb_read_data,
1810 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1811 if (smb_read_data) {
1812 if (copy_to_user(current_offset,
1814 4 /* RFC1001 length field */ +
1815 le16_to_cpu(pSMBr->DataOffset),
1819 if (buf_type == CIFS_SMALL_BUFFER)
1820 cifs_small_buf_release(smb_read_data);
1821 else if (buf_type == CIFS_LARGE_BUFFER)
1822 cifs_buf_release(smb_read_data);
1823 smb_read_data = NULL;
1826 if (rc || (bytes_read == 0)) {
1834 cifs_stats_bytes_read(pTcon, bytes_read);
1835 *poffset += bytes_read;
1843 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1847 unsigned int bytes_read = 0;
1848 unsigned int total_read;
1849 unsigned int current_read_size;
1850 struct cifs_sb_info *cifs_sb;
1851 struct cifsTconInfo *pTcon;
1853 char *current_offset;
1854 struct cifsFileInfo *open_file;
1855 int buf_type = CIFS_NO_BUFFER;
1858 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1860 if (file->private_data == NULL) {
1865 open_file = file->private_data;
1866 pTcon = tlink_tcon(open_file->tlink);
1868 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1869 cFYI(1, "attempting read on write only file instance");
1871 for (total_read = 0, current_offset = read_data;
1872 read_size > total_read;
1873 total_read += bytes_read, current_offset += bytes_read) {
1874 current_read_size = min_t(const int, read_size - total_read,
1876 /* For windows me and 9x we do not want to request more
1877 than it negotiated since it will refuse the read then */
1879 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1880 current_read_size = min_t(const int, current_read_size,
1881 pTcon->ses->server->maxBuf - 128);
1884 while (rc == -EAGAIN) {
1885 if ((open_file->invalidHandle) &&
1886 (!open_file->closePend)) {
1887 rc = cifs_reopen_file(file, true);
1891 rc = CIFSSMBRead(xid, pTcon,
1893 current_read_size, *poffset,
1894 &bytes_read, ¤t_offset,
1897 if (rc || (bytes_read == 0)) {
1905 cifs_stats_bytes_read(pTcon, total_read);
1906 *poffset += bytes_read;
1913 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1918 rc = cifs_revalidate_file(file);
1920 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1924 rc = generic_file_mmap(file, vma);
1930 static void cifs_copy_cache_pages(struct address_space *mapping,
1931 struct list_head *pages, int bytes_read, char *data)
1936 while (bytes_read > 0) {
1937 if (list_empty(pages))
1940 page = list_entry(pages->prev, struct page, lru);
1941 list_del(&page->lru);
1943 if (add_to_page_cache_lru(page, mapping, page->index,
1945 page_cache_release(page);
1946 cFYI(1, "Add page cache failed");
1947 data += PAGE_CACHE_SIZE;
1948 bytes_read -= PAGE_CACHE_SIZE;
1951 page_cache_release(page);
1953 target = kmap_atomic(page, KM_USER0);
1955 if (PAGE_CACHE_SIZE > bytes_read) {
1956 memcpy(target, data, bytes_read);
1957 /* zero the tail end of this partial page */
1958 memset(target + bytes_read, 0,
1959 PAGE_CACHE_SIZE - bytes_read);
1962 memcpy(target, data, PAGE_CACHE_SIZE);
1963 bytes_read -= PAGE_CACHE_SIZE;
1965 kunmap_atomic(target, KM_USER0);
1967 flush_dcache_page(page);
1968 SetPageUptodate(page);
1970 data += PAGE_CACHE_SIZE;
1972 /* add page to FS-Cache */
1973 cifs_readpage_to_fscache(mapping->host, page);
1978 static int cifs_readpages(struct file *file, struct address_space *mapping,
1979 struct list_head *page_list, unsigned num_pages)
1985 struct cifs_sb_info *cifs_sb;
1986 struct cifsTconInfo *pTcon;
1987 unsigned int bytes_read = 0;
1988 unsigned int read_size, i;
1989 char *smb_read_data = NULL;
1990 struct smb_com_read_rsp *pSMBr;
1991 struct cifsFileInfo *open_file;
1992 int buf_type = CIFS_NO_BUFFER;
1995 if (file->private_data == NULL) {
2000 open_file = file->private_data;
2001 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2002 pTcon = tlink_tcon(open_file->tlink);
2005 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2006 * immediately if the cookie is negative
2008 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2013 cFYI(DBG2, "rpages: num pages %d", num_pages);
2014 for (i = 0; i < num_pages; ) {
2015 unsigned contig_pages;
2016 struct page *tmp_page;
2017 unsigned long expected_index;
2019 if (list_empty(page_list))
2022 page = list_entry(page_list->prev, struct page, lru);
2023 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2025 /* count adjacent pages that we will read into */
2028 list_entry(page_list->prev, struct page, lru)->index;
2029 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2030 if (tmp_page->index == expected_index) {
2036 if (contig_pages + i > num_pages)
2037 contig_pages = num_pages - i;
2039 /* for reads over a certain size could initiate async
2042 read_size = contig_pages * PAGE_CACHE_SIZE;
2043 /* Read size needs to be in multiples of one page */
2044 read_size = min_t(const unsigned int, read_size,
2045 cifs_sb->rsize & PAGE_CACHE_MASK);
2046 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
2047 read_size, contig_pages);
2049 while (rc == -EAGAIN) {
2050 if ((open_file->invalidHandle) &&
2051 (!open_file->closePend)) {
2052 rc = cifs_reopen_file(file, true);
2057 rc = CIFSSMBRead(xid, pTcon,
2060 &bytes_read, &smb_read_data,
2062 /* BB more RC checks ? */
2063 if (rc == -EAGAIN) {
2064 if (smb_read_data) {
2065 if (buf_type == CIFS_SMALL_BUFFER)
2066 cifs_small_buf_release(smb_read_data);
2067 else if (buf_type == CIFS_LARGE_BUFFER)
2068 cifs_buf_release(smb_read_data);
2069 smb_read_data = NULL;
2073 if ((rc < 0) || (smb_read_data == NULL)) {
2074 cFYI(1, "Read error in readpages: %d", rc);
2076 } else if (bytes_read > 0) {
2077 task_io_account_read(bytes_read);
2078 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2079 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2080 smb_read_data + 4 /* RFC1001 hdr */ +
2081 le16_to_cpu(pSMBr->DataOffset));
2083 i += bytes_read >> PAGE_CACHE_SHIFT;
2084 cifs_stats_bytes_read(pTcon, bytes_read);
2085 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2086 i++; /* account for partial page */
2088 /* server copy of file can have smaller size
2090 /* BB do we need to verify this common case ?
2091 this case is ok - if we are at server EOF
2092 we will hit it on next read */
2097 cFYI(1, "No bytes read (%d) at offset %lld . "
2098 "Cleaning remaining pages from readahead list",
2099 bytes_read, offset);
2100 /* BB turn off caching and do new lookup on
2101 file size at server? */
2104 if (smb_read_data) {
2105 if (buf_type == CIFS_SMALL_BUFFER)
2106 cifs_small_buf_release(smb_read_data);
2107 else if (buf_type == CIFS_LARGE_BUFFER)
2108 cifs_buf_release(smb_read_data);
2109 smb_read_data = NULL;
2114 /* need to free smb_read_data buf before exit */
2115 if (smb_read_data) {
2116 if (buf_type == CIFS_SMALL_BUFFER)
2117 cifs_small_buf_release(smb_read_data);
2118 else if (buf_type == CIFS_LARGE_BUFFER)
2119 cifs_buf_release(smb_read_data);
2120 smb_read_data = NULL;
2128 static int cifs_readpage_worker(struct file *file, struct page *page,
2134 /* Is the page cached? */
2135 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2139 page_cache_get(page);
2140 read_data = kmap(page);
2141 /* for reads over a certain size could initiate async read ahead */
2143 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2148 cFYI(1, "Bytes read %d", rc);
2150 file->f_path.dentry->d_inode->i_atime =
2151 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2153 if (PAGE_CACHE_SIZE > rc)
2154 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2156 flush_dcache_page(page);
2157 SetPageUptodate(page);
2159 /* send this page to the cache */
2160 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2166 page_cache_release(page);
2172 static int cifs_readpage(struct file *file, struct page *page)
2174 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2180 if (file->private_data == NULL) {
2186 cFYI(1, "readpage %p at offset %d 0x%x\n",
2187 page, (int)offset, (int)offset);
2189 rc = cifs_readpage_worker(file, page, &offset);
2197 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2199 struct cifsFileInfo *open_file;
2201 read_lock(&GlobalSMBSeslock);
2202 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2203 if (open_file->closePend)
2205 if (open_file->pfile &&
2206 ((open_file->pfile->f_flags & O_RDWR) ||
2207 (open_file->pfile->f_flags & O_WRONLY))) {
2208 read_unlock(&GlobalSMBSeslock);
2212 read_unlock(&GlobalSMBSeslock);
2216 /* We do not want to update the file size from server for inodes
2217 open for write - to avoid races with writepage extending
2218 the file - in the future we could consider allowing
2219 refreshing the inode only on increases in the file size
2220 but this is tricky to do without racing with writebehind
2221 page caching in the current Linux kernel design */
2222 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2227 if (is_inode_writable(cifsInode)) {
2228 /* This inode is open for write at least once */
2229 struct cifs_sb_info *cifs_sb;
2231 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2232 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2233 /* since no page cache to corrupt on directio
2234 we can change size safely */
2238 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2246 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2247 loff_t pos, unsigned len, unsigned flags,
2248 struct page **pagep, void **fsdata)
2250 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2251 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2252 loff_t page_start = pos & PAGE_MASK;
2257 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2259 page = grab_cache_page_write_begin(mapping, index, flags);
2265 if (PageUptodate(page))
2269 * If we write a full page it will be up to date, no need to read from
2270 * the server. If the write is short, we'll end up doing a sync write
2273 if (len == PAGE_CACHE_SIZE)
2277 * optimize away the read when we have an oplock, and we're not
2278 * expecting to use any of the data we'd be reading in. That
2279 * is, when the page lies beyond the EOF, or straddles the EOF
2280 * and the write will cover all of the existing data.
2282 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2283 i_size = i_size_read(mapping->host);
2284 if (page_start >= i_size ||
2285 (offset == 0 && (pos + len) >= i_size)) {
2286 zero_user_segments(page, 0, offset,
2290 * PageChecked means that the parts of the page
2291 * to which we're not writing are considered up
2292 * to date. Once the data is copied to the
2293 * page, it can be set uptodate.
2295 SetPageChecked(page);
2300 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2302 * might as well read a page, it is fast enough. If we get
2303 * an error, we don't need to return it. cifs_write_end will
2304 * do a sync write instead since PG_uptodate isn't set.
2306 cifs_readpage_worker(file, page, &page_start);
2308 /* we could try using another file handle if there is one -
2309 but how would we lock it to prevent close of that handle
2310 racing with this read? In any case
2311 this will be written out by write_end so is fine */
2318 static int cifs_release_page(struct page *page, gfp_t gfp)
2320 if (PagePrivate(page))
2323 return cifs_fscache_release_page(page, gfp);
2326 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2328 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2331 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2334 void cifs_oplock_break(struct work_struct *work)
2336 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2338 struct inode *inode = cfile->pInode;
2339 struct cifsInodeInfo *cinode = CIFS_I(inode);
2342 if (inode && S_ISREG(inode->i_mode)) {
2343 if (cinode->clientCanCacheRead)
2344 break_lease(inode, O_RDONLY);
2346 break_lease(inode, O_WRONLY);
2347 rc = filemap_fdatawrite(inode->i_mapping);
2348 if (cinode->clientCanCacheRead == 0) {
2349 waitrc = filemap_fdatawait(inode->i_mapping);
2350 invalidate_remote_inode(inode);
2355 cinode->write_behind_rc = rc;
2356 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2360 * releasing stale oplock after recent reconnect of smb session using
2361 * a now incorrect file handle is not a data integrity issue but do
2362 * not bother sending an oplock release if session to server still is
2363 * disconnected since oplock already released by the server
2365 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2366 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2367 0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false);
2368 cFYI(1, "Oplock release rc = %d", rc);
2372 * We might have kicked in before is_valid_oplock_break()
2373 * finished grabbing reference for us. Make sure it's done by
2374 * waiting for GlobalSMSSeslock.
2376 write_lock(&GlobalSMBSeslock);
2377 write_unlock(&GlobalSMBSeslock);
2379 cifs_oplock_break_put(cfile);
2382 void cifs_oplock_break_get(struct cifsFileInfo *cfile)
2385 cifsFileInfo_get(cfile);
2388 void cifs_oplock_break_put(struct cifsFileInfo *cfile)
2391 cifsFileInfo_put(cfile);
2394 const struct address_space_operations cifs_addr_ops = {
2395 .readpage = cifs_readpage,
2396 .readpages = cifs_readpages,
2397 .writepage = cifs_writepage,
2398 .writepages = cifs_writepages,
2399 .write_begin = cifs_write_begin,
2400 .write_end = cifs_write_end,
2401 .set_page_dirty = __set_page_dirty_nobuffers,
2402 .releasepage = cifs_release_page,
2403 .invalidatepage = cifs_invalidate_page,
2404 /* .sync_page = cifs_sync_page, */
2409 * cifs_readpages requires the server to support a buffer large enough to
2410 * contain the header plus one complete page of data. Otherwise, we need
2411 * to leave cifs_readpages out of the address space operations.
2413 const struct address_space_operations cifs_addr_ops_smallbuf = {
2414 .readpage = cifs_readpage,
2415 .writepage = cifs_writepage,
2416 .writepages = cifs_writepages,
2417 .write_begin = cifs_write_begin,
2418 .write_end = cifs_write_end,
2419 .set_page_dirty = __set_page_dirty_nobuffers,
2420 .releasepage = cifs_release_page,
2421 .invalidatepage = cifs_invalidate_page,
2422 /* .sync_page = cifs_sync_page, */