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)
1173 struct cifsFileInfo *open_file = NULL;
1175 read_lock(&GlobalSMBSeslock);
1176 /* we could simply get the first_list_entry since write-only entries
1177 are always at the end of the list but since the first entry might
1178 have a close pending, we go through the whole list */
1179 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1180 if (open_file->closePend)
1182 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1183 (open_file->pfile->f_flags & O_RDONLY))) {
1184 if (!open_file->invalidHandle) {
1185 /* found a good file */
1186 /* lock it so it will not be closed on us */
1187 cifsFileInfo_get(open_file);
1188 read_unlock(&GlobalSMBSeslock);
1190 } /* else might as well continue, and look for
1191 another, or simply have the caller reopen it
1192 again rather than trying to fix this handle */
1193 } else /* write only file */
1194 break; /* write only files are last so must be done */
1196 read_unlock(&GlobalSMBSeslock);
1201 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1203 struct cifsFileInfo *open_file;
1204 bool any_available = false;
1207 /* Having a null inode here (because mapping->host was set to zero by
1208 the VFS or MM) should not happen but we had reports of on oops (due to
1209 it being zero) during stress testcases so we need to check for it */
1211 if (cifs_inode == NULL) {
1212 cERROR(1, "Null inode passed to cifs_writeable_file");
1217 read_lock(&GlobalSMBSeslock);
1219 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1220 if (open_file->closePend ||
1221 (!any_available && open_file->pid != current->tgid))
1224 if (open_file->pfile &&
1225 ((open_file->pfile->f_flags & O_RDWR) ||
1226 (open_file->pfile->f_flags & O_WRONLY))) {
1227 cifsFileInfo_get(open_file);
1229 if (!open_file->invalidHandle) {
1230 /* found a good writable file */
1231 read_unlock(&GlobalSMBSeslock);
1235 read_unlock(&GlobalSMBSeslock);
1236 /* Had to unlock since following call can block */
1237 rc = cifs_reopen_file(open_file->pfile, false);
1239 if (!open_file->closePend)
1241 else { /* start over in case this was deleted */
1242 /* since the list could be modified */
1243 read_lock(&GlobalSMBSeslock);
1244 cifsFileInfo_put(open_file);
1245 goto refind_writable;
1249 /* if it fails, try another handle if possible -
1250 (we can not do this if closePending since
1251 loop could be modified - in which case we
1252 have to start at the beginning of the list
1253 again. Note that it would be bad
1254 to hold up writepages here (rather than
1255 in caller) with continuous retries */
1256 cFYI(1, "wp failed on reopen file");
1257 read_lock(&GlobalSMBSeslock);
1258 /* can not use this handle, no write
1259 pending on this one after all */
1260 cifsFileInfo_put(open_file);
1262 if (open_file->closePend) /* list could have changed */
1263 goto refind_writable;
1264 /* else we simply continue to the next entry. Thus
1265 we do not loop on reopen errors. If we
1266 can not reopen the file, for example if we
1267 reconnected to a server with another client
1268 racing to delete or lock the file we would not
1269 make progress if we restarted before the beginning
1270 of the loop here. */
1273 /* couldn't find useable FH with same pid, try any available */
1274 if (!any_available) {
1275 any_available = true;
1276 goto refind_writable;
1278 read_unlock(&GlobalSMBSeslock);
1282 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1284 struct address_space *mapping = page->mapping;
1285 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1288 int bytes_written = 0;
1289 struct cifs_sb_info *cifs_sb;
1290 struct inode *inode;
1291 struct cifsFileInfo *open_file;
1293 if (!mapping || !mapping->host)
1296 inode = page->mapping->host;
1297 cifs_sb = CIFS_SB(inode->i_sb);
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 cifsTconInfo *tcon;
1357 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1359 struct pagevec pvec;
1365 * BB: Is this meaningful for a non-block-device file system?
1366 * If it is, we should test it again after we do I/O
1368 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1369 wbc->encountered_congestion = 1;
1373 cifs_sb = CIFS_SB(mapping->host->i_sb);
1376 * If wsize is smaller that the page cache size, default to writing
1377 * one page at a time via cifs_writepage
1379 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1380 return generic_writepages(mapping, wbc);
1382 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1384 return generic_writepages(mapping, wbc);
1387 * if there's no open file, then this is likely to fail too,
1388 * but it'll at least handle the return. Maybe it should be
1391 open_file = find_writable_file(CIFS_I(mapping->host));
1394 return generic_writepages(mapping, wbc);
1397 tcon = tlink_tcon(open_file->tlink);
1398 if (!experimEnabled && tcon->ses->server->secMode &
1399 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1400 cifsFileInfo_put(open_file);
1401 return generic_writepages(mapping, wbc);
1403 cifsFileInfo_put(open_file);
1407 pagevec_init(&pvec, 0);
1408 if (wbc->range_cyclic) {
1409 index = mapping->writeback_index; /* Start from prev offset */
1412 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1413 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1414 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1419 while (!done && (index <= end) &&
1420 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1421 PAGECACHE_TAG_DIRTY,
1422 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1431 for (i = 0; i < nr_pages; i++) {
1432 page = pvec.pages[i];
1434 * At this point we hold neither mapping->tree_lock nor
1435 * lock on the page itself: the page may be truncated or
1436 * invalidated (changing page->mapping to NULL), or even
1437 * swizzled back from swapper_space to tmpfs file
1443 else if (!trylock_page(page))
1446 if (unlikely(page->mapping != mapping)) {
1451 if (!wbc->range_cyclic && page->index > end) {
1457 if (next && (page->index != next)) {
1458 /* Not next consecutive page */
1463 if (wbc->sync_mode != WB_SYNC_NONE)
1464 wait_on_page_writeback(page);
1466 if (PageWriteback(page) ||
1467 !clear_page_dirty_for_io(page)) {
1473 * This actually clears the dirty bit in the radix tree.
1474 * See cifs_writepage() for more commentary.
1476 set_page_writeback(page);
1478 if (page_offset(page) >= mapping->host->i_size) {
1481 end_page_writeback(page);
1486 * BB can we get rid of this? pages are held by pvec
1488 page_cache_get(page);
1490 len = min(mapping->host->i_size - page_offset(page),
1491 (loff_t)PAGE_CACHE_SIZE);
1493 /* reserve iov[0] for the smb header */
1495 iov[n_iov].iov_base = kmap(page);
1496 iov[n_iov].iov_len = len;
1497 bytes_to_write += len;
1501 offset = page_offset(page);
1503 next = page->index + 1;
1504 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1508 open_file = find_writable_file(CIFS_I(mapping->host));
1510 cERROR(1, "No writable handles for inode");
1513 long_op = cifs_write_timeout(cifsi, offset);
1514 rc = CIFSSMBWrite2(xid, tcon, open_file->netfid,
1515 bytes_to_write, offset,
1516 &bytes_written, iov, n_iov,
1518 cifsFileInfo_put(open_file);
1519 cifs_update_eof(cifsi, offset, bytes_written);
1522 if (rc || bytes_written < bytes_to_write) {
1523 cERROR(1, "Write2 ret %d, wrote %d",
1525 /* BB what if continued retry is
1526 requested via mount flags? */
1528 set_bit(AS_ENOSPC, &mapping->flags);
1530 set_bit(AS_EIO, &mapping->flags);
1532 cifs_stats_bytes_written(tcon, bytes_written);
1535 for (i = 0; i < n_iov; i++) {
1536 page = pvec.pages[first + i];
1537 /* Should we also set page error on
1538 success rc but too little data written? */
1539 /* BB investigate retry logic on temporary
1540 server crash cases and how recovery works
1541 when page marked as error */
1546 end_page_writeback(page);
1547 page_cache_release(page);
1549 if ((wbc->nr_to_write -= n_iov) <= 0)
1553 /* Need to re-find the pages we skipped */
1554 index = pvec.pages[0]->index + 1;
1556 pagevec_release(&pvec);
1558 if (!scanned && !done) {
1560 * We hit the last page and there is more work to be done: wrap
1561 * back to the start of the file
1567 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1568 mapping->writeback_index = index;
1575 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1581 /* BB add check for wbc flags */
1582 page_cache_get(page);
1583 if (!PageUptodate(page))
1584 cFYI(1, "ppw - page not up to date");
1587 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1589 * A writepage() implementation always needs to do either this,
1590 * or re-dirty the page with "redirty_page_for_writepage()" in
1591 * the case of a failure.
1593 * Just unlocking the page will cause the radix tree tag-bits
1594 * to fail to update with the state of the page correctly.
1596 set_page_writeback(page);
1597 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1598 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1600 end_page_writeback(page);
1601 page_cache_release(page);
1606 static int cifs_write_end(struct file *file, struct address_space *mapping,
1607 loff_t pos, unsigned len, unsigned copied,
1608 struct page *page, void *fsdata)
1611 struct inode *inode = mapping->host;
1613 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1616 if (PageChecked(page)) {
1618 SetPageUptodate(page);
1619 ClearPageChecked(page);
1620 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1621 SetPageUptodate(page);
1623 if (!PageUptodate(page)) {
1625 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1629 /* this is probably better than directly calling
1630 partialpage_write since in this function the file handle is
1631 known which we might as well leverage */
1632 /* BB check if anything else missing out of ppw
1633 such as updating last write time */
1634 page_data = kmap(page);
1635 rc = cifs_write(file, page_data + offset, copied, &pos);
1636 /* if (rc < 0) should we set writebehind rc? */
1643 set_page_dirty(page);
1647 spin_lock(&inode->i_lock);
1648 if (pos > inode->i_size)
1649 i_size_write(inode, pos);
1650 spin_unlock(&inode->i_lock);
1654 page_cache_release(page);
1659 int cifs_fsync(struct file *file, int datasync)
1663 struct cifsTconInfo *tcon;
1664 struct cifsFileInfo *smbfile = file->private_data;
1665 struct inode *inode = file->f_path.dentry->d_inode;
1669 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1670 file->f_path.dentry->d_name.name, datasync);
1672 rc = filemap_write_and_wait(inode->i_mapping);
1674 rc = CIFS_I(inode)->write_behind_rc;
1675 CIFS_I(inode)->write_behind_rc = 0;
1676 tcon = tlink_tcon(smbfile->tlink);
1677 if (!rc && tcon && smbfile &&
1678 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1679 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1686 /* static void cifs_sync_page(struct page *page)
1688 struct address_space *mapping;
1689 struct inode *inode;
1690 unsigned long index = page->index;
1691 unsigned int rpages = 0;
1694 cFYI(1, "sync page %p", page);
1695 mapping = page->mapping;
1698 inode = mapping->host;
1702 /* fill in rpages then
1703 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1705 /* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1715 * As file closes, flush all cached write data for this inode checking
1716 * for write behind errors.
1718 int cifs_flush(struct file *file, fl_owner_t id)
1720 struct inode *inode = file->f_path.dentry->d_inode;
1723 /* Rather than do the steps manually:
1724 lock the inode for writing
1725 loop through pages looking for write behind data (dirty pages)
1726 coalesce into contiguous 16K (or smaller) chunks to write to server
1727 send to server (prefer in parallel)
1728 deal with writebehind errors
1729 unlock inode for writing
1730 filemapfdatawrite appears easier for the time being */
1732 rc = filemap_fdatawrite(inode->i_mapping);
1733 /* reset wb rc if we were able to write out dirty pages */
1735 rc = CIFS_I(inode)->write_behind_rc;
1736 CIFS_I(inode)->write_behind_rc = 0;
1739 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1744 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1745 size_t read_size, loff_t *poffset)
1748 unsigned int bytes_read = 0;
1749 unsigned int total_read = 0;
1750 unsigned int current_read_size;
1751 struct cifs_sb_info *cifs_sb;
1752 struct cifsTconInfo *pTcon;
1754 struct cifsFileInfo *open_file;
1755 char *smb_read_data;
1756 char __user *current_offset;
1757 struct smb_com_read_rsp *pSMBr;
1760 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1762 if (file->private_data == NULL) {
1767 open_file = file->private_data;
1768 pTcon = tlink_tcon(open_file->tlink);
1770 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1771 cFYI(1, "attempting read on write only file instance");
1773 for (total_read = 0, current_offset = read_data;
1774 read_size > total_read;
1775 total_read += bytes_read, current_offset += bytes_read) {
1776 current_read_size = min_t(const int, read_size - total_read,
1779 smb_read_data = NULL;
1780 while (rc == -EAGAIN) {
1781 int buf_type = CIFS_NO_BUFFER;
1782 if ((open_file->invalidHandle) &&
1783 (!open_file->closePend)) {
1784 rc = cifs_reopen_file(file, true);
1788 rc = CIFSSMBRead(xid, pTcon,
1790 current_read_size, *poffset,
1791 &bytes_read, &smb_read_data,
1793 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1794 if (smb_read_data) {
1795 if (copy_to_user(current_offset,
1797 4 /* RFC1001 length field */ +
1798 le16_to_cpu(pSMBr->DataOffset),
1802 if (buf_type == CIFS_SMALL_BUFFER)
1803 cifs_small_buf_release(smb_read_data);
1804 else if (buf_type == CIFS_LARGE_BUFFER)
1805 cifs_buf_release(smb_read_data);
1806 smb_read_data = NULL;
1809 if (rc || (bytes_read == 0)) {
1817 cifs_stats_bytes_read(pTcon, bytes_read);
1818 *poffset += bytes_read;
1826 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1830 unsigned int bytes_read = 0;
1831 unsigned int total_read;
1832 unsigned int current_read_size;
1833 struct cifs_sb_info *cifs_sb;
1834 struct cifsTconInfo *pTcon;
1836 char *current_offset;
1837 struct cifsFileInfo *open_file;
1838 int buf_type = CIFS_NO_BUFFER;
1841 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1843 if (file->private_data == NULL) {
1848 open_file = file->private_data;
1849 pTcon = tlink_tcon(open_file->tlink);
1851 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1852 cFYI(1, "attempting read on write only file instance");
1854 for (total_read = 0, current_offset = read_data;
1855 read_size > total_read;
1856 total_read += bytes_read, current_offset += bytes_read) {
1857 current_read_size = min_t(const int, read_size - total_read,
1859 /* For windows me and 9x we do not want to request more
1860 than it negotiated since it will refuse the read then */
1862 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1863 current_read_size = min_t(const int, current_read_size,
1864 pTcon->ses->server->maxBuf - 128);
1867 while (rc == -EAGAIN) {
1868 if ((open_file->invalidHandle) &&
1869 (!open_file->closePend)) {
1870 rc = cifs_reopen_file(file, true);
1874 rc = CIFSSMBRead(xid, pTcon,
1876 current_read_size, *poffset,
1877 &bytes_read, ¤t_offset,
1880 if (rc || (bytes_read == 0)) {
1888 cifs_stats_bytes_read(pTcon, total_read);
1889 *poffset += bytes_read;
1896 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1901 rc = cifs_revalidate_file(file);
1903 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1907 rc = generic_file_mmap(file, vma);
1913 static void cifs_copy_cache_pages(struct address_space *mapping,
1914 struct list_head *pages, int bytes_read, char *data)
1919 while (bytes_read > 0) {
1920 if (list_empty(pages))
1923 page = list_entry(pages->prev, struct page, lru);
1924 list_del(&page->lru);
1926 if (add_to_page_cache_lru(page, mapping, page->index,
1928 page_cache_release(page);
1929 cFYI(1, "Add page cache failed");
1930 data += PAGE_CACHE_SIZE;
1931 bytes_read -= PAGE_CACHE_SIZE;
1934 page_cache_release(page);
1936 target = kmap_atomic(page, KM_USER0);
1938 if (PAGE_CACHE_SIZE > bytes_read) {
1939 memcpy(target, data, bytes_read);
1940 /* zero the tail end of this partial page */
1941 memset(target + bytes_read, 0,
1942 PAGE_CACHE_SIZE - bytes_read);
1945 memcpy(target, data, PAGE_CACHE_SIZE);
1946 bytes_read -= PAGE_CACHE_SIZE;
1948 kunmap_atomic(target, KM_USER0);
1950 flush_dcache_page(page);
1951 SetPageUptodate(page);
1953 data += PAGE_CACHE_SIZE;
1955 /* add page to FS-Cache */
1956 cifs_readpage_to_fscache(mapping->host, page);
1961 static int cifs_readpages(struct file *file, struct address_space *mapping,
1962 struct list_head *page_list, unsigned num_pages)
1968 struct cifs_sb_info *cifs_sb;
1969 struct cifsTconInfo *pTcon;
1970 unsigned int bytes_read = 0;
1971 unsigned int read_size, i;
1972 char *smb_read_data = NULL;
1973 struct smb_com_read_rsp *pSMBr;
1974 struct cifsFileInfo *open_file;
1975 int buf_type = CIFS_NO_BUFFER;
1978 if (file->private_data == NULL) {
1983 open_file = file->private_data;
1984 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1985 pTcon = tlink_tcon(open_file->tlink);
1988 * Reads as many pages as possible from fscache. Returns -ENOBUFS
1989 * immediately if the cookie is negative
1991 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
1996 cFYI(DBG2, "rpages: num pages %d", num_pages);
1997 for (i = 0; i < num_pages; ) {
1998 unsigned contig_pages;
1999 struct page *tmp_page;
2000 unsigned long expected_index;
2002 if (list_empty(page_list))
2005 page = list_entry(page_list->prev, struct page, lru);
2006 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2008 /* count adjacent pages that we will read into */
2011 list_entry(page_list->prev, struct page, lru)->index;
2012 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2013 if (tmp_page->index == expected_index) {
2019 if (contig_pages + i > num_pages)
2020 contig_pages = num_pages - i;
2022 /* for reads over a certain size could initiate async
2025 read_size = contig_pages * PAGE_CACHE_SIZE;
2026 /* Read size needs to be in multiples of one page */
2027 read_size = min_t(const unsigned int, read_size,
2028 cifs_sb->rsize & PAGE_CACHE_MASK);
2029 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
2030 read_size, contig_pages);
2032 while (rc == -EAGAIN) {
2033 if ((open_file->invalidHandle) &&
2034 (!open_file->closePend)) {
2035 rc = cifs_reopen_file(file, true);
2040 rc = CIFSSMBRead(xid, pTcon,
2043 &bytes_read, &smb_read_data,
2045 /* BB more RC checks ? */
2046 if (rc == -EAGAIN) {
2047 if (smb_read_data) {
2048 if (buf_type == CIFS_SMALL_BUFFER)
2049 cifs_small_buf_release(smb_read_data);
2050 else if (buf_type == CIFS_LARGE_BUFFER)
2051 cifs_buf_release(smb_read_data);
2052 smb_read_data = NULL;
2056 if ((rc < 0) || (smb_read_data == NULL)) {
2057 cFYI(1, "Read error in readpages: %d", rc);
2059 } else if (bytes_read > 0) {
2060 task_io_account_read(bytes_read);
2061 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2062 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2063 smb_read_data + 4 /* RFC1001 hdr */ +
2064 le16_to_cpu(pSMBr->DataOffset));
2066 i += bytes_read >> PAGE_CACHE_SHIFT;
2067 cifs_stats_bytes_read(pTcon, bytes_read);
2068 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2069 i++; /* account for partial page */
2071 /* server copy of file can have smaller size
2073 /* BB do we need to verify this common case ?
2074 this case is ok - if we are at server EOF
2075 we will hit it on next read */
2080 cFYI(1, "No bytes read (%d) at offset %lld . "
2081 "Cleaning remaining pages from readahead list",
2082 bytes_read, offset);
2083 /* BB turn off caching and do new lookup on
2084 file size at server? */
2087 if (smb_read_data) {
2088 if (buf_type == CIFS_SMALL_BUFFER)
2089 cifs_small_buf_release(smb_read_data);
2090 else if (buf_type == CIFS_LARGE_BUFFER)
2091 cifs_buf_release(smb_read_data);
2092 smb_read_data = NULL;
2097 /* need to free smb_read_data buf before exit */
2098 if (smb_read_data) {
2099 if (buf_type == CIFS_SMALL_BUFFER)
2100 cifs_small_buf_release(smb_read_data);
2101 else if (buf_type == CIFS_LARGE_BUFFER)
2102 cifs_buf_release(smb_read_data);
2103 smb_read_data = NULL;
2111 static int cifs_readpage_worker(struct file *file, struct page *page,
2117 /* Is the page cached? */
2118 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2122 page_cache_get(page);
2123 read_data = kmap(page);
2124 /* for reads over a certain size could initiate async read ahead */
2126 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2131 cFYI(1, "Bytes read %d", rc);
2133 file->f_path.dentry->d_inode->i_atime =
2134 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2136 if (PAGE_CACHE_SIZE > rc)
2137 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2139 flush_dcache_page(page);
2140 SetPageUptodate(page);
2142 /* send this page to the cache */
2143 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2149 page_cache_release(page);
2155 static int cifs_readpage(struct file *file, struct page *page)
2157 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2163 if (file->private_data == NULL) {
2169 cFYI(1, "readpage %p at offset %d 0x%x\n",
2170 page, (int)offset, (int)offset);
2172 rc = cifs_readpage_worker(file, page, &offset);
2180 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2182 struct cifsFileInfo *open_file;
2184 read_lock(&GlobalSMBSeslock);
2185 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2186 if (open_file->closePend)
2188 if (open_file->pfile &&
2189 ((open_file->pfile->f_flags & O_RDWR) ||
2190 (open_file->pfile->f_flags & O_WRONLY))) {
2191 read_unlock(&GlobalSMBSeslock);
2195 read_unlock(&GlobalSMBSeslock);
2199 /* We do not want to update the file size from server for inodes
2200 open for write - to avoid races with writepage extending
2201 the file - in the future we could consider allowing
2202 refreshing the inode only on increases in the file size
2203 but this is tricky to do without racing with writebehind
2204 page caching in the current Linux kernel design */
2205 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2210 if (is_inode_writable(cifsInode)) {
2211 /* This inode is open for write at least once */
2212 struct cifs_sb_info *cifs_sb;
2214 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2215 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2216 /* since no page cache to corrupt on directio
2217 we can change size safely */
2221 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2229 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2230 loff_t pos, unsigned len, unsigned flags,
2231 struct page **pagep, void **fsdata)
2233 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2234 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2235 loff_t page_start = pos & PAGE_MASK;
2240 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2242 page = grab_cache_page_write_begin(mapping, index, flags);
2248 if (PageUptodate(page))
2252 * If we write a full page it will be up to date, no need to read from
2253 * the server. If the write is short, we'll end up doing a sync write
2256 if (len == PAGE_CACHE_SIZE)
2260 * optimize away the read when we have an oplock, and we're not
2261 * expecting to use any of the data we'd be reading in. That
2262 * is, when the page lies beyond the EOF, or straddles the EOF
2263 * and the write will cover all of the existing data.
2265 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2266 i_size = i_size_read(mapping->host);
2267 if (page_start >= i_size ||
2268 (offset == 0 && (pos + len) >= i_size)) {
2269 zero_user_segments(page, 0, offset,
2273 * PageChecked means that the parts of the page
2274 * to which we're not writing are considered up
2275 * to date. Once the data is copied to the
2276 * page, it can be set uptodate.
2278 SetPageChecked(page);
2283 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2285 * might as well read a page, it is fast enough. If we get
2286 * an error, we don't need to return it. cifs_write_end will
2287 * do a sync write instead since PG_uptodate isn't set.
2289 cifs_readpage_worker(file, page, &page_start);
2291 /* we could try using another file handle if there is one -
2292 but how would we lock it to prevent close of that handle
2293 racing with this read? In any case
2294 this will be written out by write_end so is fine */
2301 static int cifs_release_page(struct page *page, gfp_t gfp)
2303 if (PagePrivate(page))
2306 return cifs_fscache_release_page(page, gfp);
2309 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2311 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2314 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2317 void cifs_oplock_break(struct work_struct *work)
2319 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2321 struct inode *inode = cfile->pInode;
2322 struct cifsInodeInfo *cinode = CIFS_I(inode);
2325 if (inode && S_ISREG(inode->i_mode)) {
2326 if (cinode->clientCanCacheRead)
2327 break_lease(inode, O_RDONLY);
2329 break_lease(inode, O_WRONLY);
2330 rc = filemap_fdatawrite(inode->i_mapping);
2331 if (cinode->clientCanCacheRead == 0) {
2332 waitrc = filemap_fdatawait(inode->i_mapping);
2333 invalidate_remote_inode(inode);
2338 cinode->write_behind_rc = rc;
2339 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2343 * releasing stale oplock after recent reconnect of smb session using
2344 * a now incorrect file handle is not a data integrity issue but do
2345 * not bother sending an oplock release if session to server still is
2346 * disconnected since oplock already released by the server
2348 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2349 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2350 0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false);
2351 cFYI(1, "Oplock release rc = %d", rc);
2355 * We might have kicked in before is_valid_oplock_break()
2356 * finished grabbing reference for us. Make sure it's done by
2357 * waiting for GlobalSMSSeslock.
2359 write_lock(&GlobalSMBSeslock);
2360 write_unlock(&GlobalSMBSeslock);
2362 cifs_oplock_break_put(cfile);
2365 void cifs_oplock_break_get(struct cifsFileInfo *cfile)
2368 cifsFileInfo_get(cfile);
2371 void cifs_oplock_break_put(struct cifsFileInfo *cfile)
2374 cifsFileInfo_put(cfile);
2377 const struct address_space_operations cifs_addr_ops = {
2378 .readpage = cifs_readpage,
2379 .readpages = cifs_readpages,
2380 .writepage = cifs_writepage,
2381 .writepages = cifs_writepages,
2382 .write_begin = cifs_write_begin,
2383 .write_end = cifs_write_end,
2384 .set_page_dirty = __set_page_dirty_nobuffers,
2385 .releasepage = cifs_release_page,
2386 .invalidatepage = cifs_invalidate_page,
2387 /* .sync_page = cifs_sync_page, */
2392 * cifs_readpages requires the server to support a buffer large enough to
2393 * contain the header plus one complete page of data. Otherwise, we need
2394 * to leave cifs_readpages out of the address space operations.
2396 const struct address_space_operations cifs_addr_ops_smallbuf = {
2397 .readpage = cifs_readpage,
2398 .writepage = cifs_writepage,
2399 .writepages = cifs_writepages,
2400 .write_begin = cifs_write_begin,
2401 .write_end = cifs_write_end,
2402 .set_page_dirty = __set_page_dirty_nobuffers,
2403 .releasepage = cifs_release_page,
2404 .invalidatepage = cifs_invalidate_page,
2405 /* .sync_page = cifs_sync_page, */