4 * vfs operations that deal with files
6 * Copyright (C) International Business Machines Corp., 2002,2007
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 <asm/div64.h>
38 #include "cifsproto.h"
39 #include "cifs_unicode.h"
40 #include "cifs_debug.h"
41 #include "cifs_fs_sb.h"
43 static inline int cifs_convert_flags(unsigned int flags)
45 if ((flags & O_ACCMODE) == O_RDONLY)
47 else if ((flags & O_ACCMODE) == O_WRONLY)
49 else if ((flags & O_ACCMODE) == O_RDWR) {
50 /* GENERIC_ALL is too much permission to request
51 can cause unnecessary access denied on create */
52 /* return GENERIC_ALL; */
53 return (GENERIC_READ | GENERIC_WRITE);
56 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
57 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
61 static inline fmode_t cifs_posix_convert_flags(unsigned int flags)
63 fmode_t posix_flags = 0;
65 if ((flags & O_ACCMODE) == O_RDONLY)
66 posix_flags = FMODE_READ;
67 else if ((flags & O_ACCMODE) == O_WRONLY)
68 posix_flags = FMODE_WRITE;
69 else if ((flags & O_ACCMODE) == O_RDWR) {
70 /* GENERIC_ALL is too much permission to request
71 can cause unnecessary access denied on create */
72 /* return GENERIC_ALL; */
73 posix_flags = FMODE_READ | FMODE_WRITE;
75 /* can not map O_CREAT or O_EXCL or O_TRUNC flags when
76 reopening a file. They had their effect on the original open */
78 posix_flags |= (fmode_t)O_APPEND;
80 posix_flags |= (fmode_t)O_DSYNC;
82 posix_flags |= (fmode_t)__O_SYNC;
83 if (flags & O_DIRECTORY)
84 posix_flags |= (fmode_t)O_DIRECTORY;
85 if (flags & O_NOFOLLOW)
86 posix_flags |= (fmode_t)O_NOFOLLOW;
88 posix_flags |= (fmode_t)O_DIRECT;
93 static inline int cifs_get_disposition(unsigned int flags)
95 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
97 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
98 return FILE_OVERWRITE_IF;
99 else if ((flags & O_CREAT) == O_CREAT)
101 else if ((flags & O_TRUNC) == O_TRUNC)
102 return FILE_OVERWRITE;
107 /* all arguments to this function must be checked for validity in caller */
109 cifs_posix_open_inode_helper(struct inode *inode, struct file *file,
110 struct cifsInodeInfo *pCifsInode,
111 struct cifsFileInfo *pCifsFile, __u32 oplock,
115 write_lock(&GlobalSMBSeslock);
117 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
118 if (pCifsInode == NULL) {
119 write_unlock(&GlobalSMBSeslock);
123 if (pCifsInode->clientCanCacheRead) {
124 /* we have the inode open somewhere else
125 no need to discard cache data */
126 goto psx_client_can_cache;
129 /* BB FIXME need to fix this check to move it earlier into posix_open
130 BB fIX following section BB FIXME */
132 /* if not oplocked, invalidate inode pages if mtime or file
134 /* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
135 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
136 (file->f_path.dentry->d_inode->i_size ==
137 (loff_t)le64_to_cpu(buf->EndOfFile))) {
138 cFYI(1, ("inode unchanged on server"));
140 if (file->f_path.dentry->d_inode->i_mapping) {
141 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
143 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
145 cFYI(1, ("invalidating remote inode since open detected it "
147 invalidate_remote_inode(file->f_path.dentry->d_inode);
150 psx_client_can_cache:
151 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
152 pCifsInode->clientCanCacheAll = true;
153 pCifsInode->clientCanCacheRead = true;
154 cFYI(1, ("Exclusive Oplock granted on inode %p",
155 file->f_path.dentry->d_inode));
156 } else if ((oplock & 0xF) == OPLOCK_READ)
157 pCifsInode->clientCanCacheRead = true;
159 /* will have to change the unlock if we reenable the
160 filemap_fdatawrite (which does not seem necessary */
161 write_unlock(&GlobalSMBSeslock);
165 static struct cifsFileInfo *
166 cifs_fill_filedata(struct file *file)
168 struct list_head *tmp;
169 struct cifsFileInfo *pCifsFile = NULL;
170 struct cifsInodeInfo *pCifsInode = NULL;
172 /* search inode for this file and fill in file->private_data */
173 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
174 read_lock(&GlobalSMBSeslock);
175 list_for_each(tmp, &pCifsInode->openFileList) {
176 pCifsFile = list_entry(tmp, struct cifsFileInfo, flist);
177 if ((pCifsFile->pfile == NULL) &&
178 (pCifsFile->pid == current->tgid)) {
179 /* mode set in cifs_create */
181 /* needed for writepage */
182 pCifsFile->pfile = file;
183 file->private_data = pCifsFile;
187 read_unlock(&GlobalSMBSeslock);
189 if (file->private_data != NULL) {
191 } else if ((file->f_flags & O_CREAT) && (file->f_flags & O_EXCL))
192 cERROR(1, ("could not find file instance for "
193 "new file %p", file));
197 /* all arguments to this function must be checked for validity in caller */
198 static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
199 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
200 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
201 char *full_path, int xid)
203 struct timespec temp;
206 if (pCifsInode->clientCanCacheRead) {
207 /* we have the inode open somewhere else
208 no need to discard cache data */
209 goto client_can_cache;
212 /* BB need same check in cifs_create too? */
213 /* if not oplocked, invalidate inode pages if mtime or file
215 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
216 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
217 (file->f_path.dentry->d_inode->i_size ==
218 (loff_t)le64_to_cpu(buf->EndOfFile))) {
219 cFYI(1, ("inode unchanged on server"));
221 if (file->f_path.dentry->d_inode->i_mapping) {
222 /* BB no need to lock inode until after invalidate
223 since namei code should already have it locked? */
224 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
226 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
228 cFYI(1, ("invalidating remote inode since open detected it "
230 invalidate_remote_inode(file->f_path.dentry->d_inode);
235 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
236 full_path, inode->i_sb, xid);
238 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
239 full_path, buf, inode->i_sb, xid, NULL);
241 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
242 pCifsInode->clientCanCacheAll = true;
243 pCifsInode->clientCanCacheRead = true;
244 cFYI(1, ("Exclusive Oplock granted on inode %p",
245 file->f_path.dentry->d_inode));
246 } else if ((*oplock & 0xF) == OPLOCK_READ)
247 pCifsInode->clientCanCacheRead = true;
252 int cifs_open(struct inode *inode, struct file *file)
257 struct cifs_sb_info *cifs_sb;
258 struct cifsTconInfo *tcon;
259 struct cifsFileInfo *pCifsFile;
260 struct cifsInodeInfo *pCifsInode;
261 char *full_path = NULL;
265 FILE_ALL_INFO *buf = NULL;
269 cifs_sb = CIFS_SB(inode->i_sb);
270 tcon = cifs_sb->tcon;
272 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
273 pCifsFile = cifs_fill_filedata(file);
280 full_path = build_path_from_dentry(file->f_path.dentry);
281 if (full_path == NULL) {
287 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
288 inode, file->f_flags, full_path));
295 if (!tcon->broken_posix_open && tcon->unix_ext &&
296 (tcon->ses->capabilities & CAP_UNIX) &&
297 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
298 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
299 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
300 /* can not refresh inode info since size could be stale */
301 rc = cifs_posix_open(full_path, &inode, file->f_path.mnt,
302 cifs_sb->mnt_file_mode /* ignored */,
303 oflags, &oplock, &netfid, xid);
305 cFYI(1, ("posix open succeeded"));
306 /* no need for special case handling of setting mode
307 on read only files needed here */
309 pCifsFile = cifs_fill_filedata(file);
310 cifs_posix_open_inode_helper(inode, file, pCifsInode,
311 pCifsFile, oplock, netfid);
313 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
314 if (tcon->ses->serverNOS)
315 cERROR(1, ("server %s of type %s returned"
316 " unexpected error on SMB posix open"
317 ", disabling posix open support."
318 " Check if server update available.",
319 tcon->ses->serverName,
320 tcon->ses->serverNOS));
321 tcon->broken_posix_open = true;
322 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
323 (rc != -EOPNOTSUPP)) /* path not found or net err */
325 /* else fallthrough to retry open the old way on network i/o
329 desiredAccess = cifs_convert_flags(file->f_flags);
331 /*********************************************************************
332 * open flag mapping table:
334 * POSIX Flag CIFS Disposition
335 * ---------- ----------------
336 * O_CREAT FILE_OPEN_IF
337 * O_CREAT | O_EXCL FILE_CREATE
338 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
339 * O_TRUNC FILE_OVERWRITE
340 * none of the above FILE_OPEN
342 * Note that there is not a direct match between disposition
343 * FILE_SUPERSEDE (ie create whether or not file exists although
344 * O_CREAT | O_TRUNC is similar but truncates the existing
345 * file rather than creating a new file as FILE_SUPERSEDE does
346 * (which uses the attributes / metadata passed in on open call)
348 *? O_SYNC is a reasonable match to CIFS writethrough flag
349 *? and the read write flags match reasonably. O_LARGEFILE
350 *? is irrelevant because largefile support is always used
351 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
352 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
353 *********************************************************************/
355 disposition = cifs_get_disposition(file->f_flags);
357 /* BB pass O_SYNC flag through on file attributes .. BB */
359 /* Also refresh inode by passing in file_info buf returned by SMBOpen
360 and calling get_inode_info with returned buf (at least helps
361 non-Unix server case) */
363 /* BB we can not do this if this is the second open of a file
364 and the first handle has writebehind data, we might be
365 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
366 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
372 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
373 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
374 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
375 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
376 & CIFS_MOUNT_MAP_SPECIAL_CHR);
378 rc = -EIO; /* no NT SMB support fall into legacy open below */
381 /* Old server, try legacy style OpenX */
382 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
383 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
384 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
385 & CIFS_MOUNT_MAP_SPECIAL_CHR);
388 cFYI(1, ("cifs_open returned 0x%x", rc));
392 pCifsFile = cifs_new_fileinfo(inode, netfid, file, file->f_path.mnt,
394 file->private_data = pCifsFile;
395 if (file->private_data == NULL) {
400 rc = cifs_open_inode_helper(inode, file, pCifsInode, pCifsFile, tcon,
401 &oplock, buf, full_path, xid);
403 if (oplock & CIFS_CREATE_ACTION) {
404 /* time to set mode which we can not set earlier due to
405 problems creating new read-only files */
406 if (tcon->unix_ext) {
407 struct cifs_unix_set_info_args args = {
408 .mode = inode->i_mode,
411 .ctime = NO_CHANGE_64,
412 .atime = NO_CHANGE_64,
413 .mtime = NO_CHANGE_64,
416 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
418 cifs_sb->mnt_cifs_flags &
419 CIFS_MOUNT_MAP_SPECIAL_CHR);
430 /* Try to reacquire byte range locks that were released when session */
431 /* to server was lost */
432 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
436 /* BB list all locks open on this file and relock */
441 static int cifs_reopen_file(struct file *file, bool can_flush)
446 struct cifs_sb_info *cifs_sb;
447 struct cifsTconInfo *tcon;
448 struct cifsFileInfo *pCifsFile;
449 struct cifsInodeInfo *pCifsInode;
451 char *full_path = NULL;
453 int disposition = FILE_OPEN;
456 if (file->private_data)
457 pCifsFile = (struct cifsFileInfo *)file->private_data;
462 mutex_lock(&pCifsFile->fh_mutex);
463 if (!pCifsFile->invalidHandle) {
464 mutex_unlock(&pCifsFile->fh_mutex);
470 if (file->f_path.dentry == NULL) {
471 cERROR(1, ("no valid name if dentry freed"));
474 goto reopen_error_exit;
477 inode = file->f_path.dentry->d_inode;
479 cERROR(1, ("inode not valid"));
482 goto reopen_error_exit;
485 cifs_sb = CIFS_SB(inode->i_sb);
486 tcon = cifs_sb->tcon;
488 /* can not grab rename sem here because various ops, including
489 those that already have the rename sem can end up causing writepage
490 to get called and if the server was down that means we end up here,
491 and we can never tell if the caller already has the rename_sem */
492 full_path = build_path_from_dentry(file->f_path.dentry);
493 if (full_path == NULL) {
496 mutex_unlock(&pCifsFile->fh_mutex);
501 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
502 inode, file->f_flags, full_path));
509 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
510 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
511 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
512 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
513 /* can not refresh inode info since size could be stale */
514 rc = cifs_posix_open(full_path, NULL, file->f_path.mnt,
515 cifs_sb->mnt_file_mode /* ignored */,
516 oflags, &oplock, &netfid, xid);
518 cFYI(1, ("posix reopen succeeded"));
521 /* fallthrough to retry open the old way on errors, especially
522 in the reconnect path it is important to retry hard */
525 desiredAccess = cifs_convert_flags(file->f_flags);
527 /* Can not refresh inode by passing in file_info buf to be returned
528 by SMBOpen and then calling get_inode_info with returned buf
529 since file might have write behind data that needs to be flushed
530 and server version of file size can be stale. If we knew for sure
531 that inode was not dirty locally we could do this */
533 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
534 CREATE_NOT_DIR, &netfid, &oplock, NULL,
535 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
536 CIFS_MOUNT_MAP_SPECIAL_CHR);
538 mutex_unlock(&pCifsFile->fh_mutex);
539 cFYI(1, ("cifs_open returned 0x%x", rc));
540 cFYI(1, ("oplock: %d", oplock));
543 pCifsFile->netfid = netfid;
544 pCifsFile->invalidHandle = false;
545 mutex_unlock(&pCifsFile->fh_mutex);
546 pCifsInode = CIFS_I(inode);
549 rc = filemap_write_and_wait(inode->i_mapping);
551 CIFS_I(inode)->write_behind_rc = rc;
552 /* temporarily disable caching while we
553 go to server to get inode info */
554 pCifsInode->clientCanCacheAll = false;
555 pCifsInode->clientCanCacheRead = false;
557 rc = cifs_get_inode_info_unix(&inode,
558 full_path, inode->i_sb, xid);
560 rc = cifs_get_inode_info(&inode,
561 full_path, NULL, inode->i_sb,
563 } /* else we are writing out data to server already
564 and could deadlock if we tried to flush data, and
565 since we do not know if we have data that would
566 invalidate the current end of file on the server
567 we can not go to the server to get the new inod
569 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
570 pCifsInode->clientCanCacheAll = true;
571 pCifsInode->clientCanCacheRead = true;
572 cFYI(1, ("Exclusive Oplock granted on inode %p",
573 file->f_path.dentry->d_inode));
574 } else if ((oplock & 0xF) == OPLOCK_READ) {
575 pCifsInode->clientCanCacheRead = true;
576 pCifsInode->clientCanCacheAll = false;
578 pCifsInode->clientCanCacheRead = false;
579 pCifsInode->clientCanCacheAll = false;
581 cifs_relock_file(pCifsFile);
589 int cifs_close(struct inode *inode, struct file *file)
593 struct cifs_sb_info *cifs_sb;
594 struct cifsTconInfo *pTcon;
595 struct cifsFileInfo *pSMBFile =
596 (struct cifsFileInfo *)file->private_data;
600 cifs_sb = CIFS_SB(inode->i_sb);
601 pTcon = cifs_sb->tcon;
603 struct cifsLockInfo *li, *tmp;
604 write_lock(&GlobalSMBSeslock);
605 pSMBFile->closePend = true;
607 /* no sense reconnecting to close a file that is
609 if (!pTcon->need_reconnect) {
610 write_unlock(&GlobalSMBSeslock);
612 while ((atomic_read(&pSMBFile->count) != 1)
613 && (timeout <= 2048)) {
614 /* Give write a better chance to get to
615 server ahead of the close. We do not
616 want to add a wait_q here as it would
617 increase the memory utilization as
618 the struct would be in each open file,
619 but this should give enough time to
622 ("close delay, write pending"));
626 if (!pTcon->need_reconnect &&
627 !pSMBFile->invalidHandle)
628 rc = CIFSSMBClose(xid, pTcon,
631 write_unlock(&GlobalSMBSeslock);
633 write_unlock(&GlobalSMBSeslock);
635 /* Delete any outstanding lock records.
636 We'll lose them when the file is closed anyway. */
637 mutex_lock(&pSMBFile->lock_mutex);
638 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
639 list_del(&li->llist);
642 mutex_unlock(&pSMBFile->lock_mutex);
644 write_lock(&GlobalSMBSeslock);
645 list_del(&pSMBFile->flist);
646 list_del(&pSMBFile->tlist);
647 write_unlock(&GlobalSMBSeslock);
648 cifsFileInfo_put(file->private_data);
649 file->private_data = NULL;
653 read_lock(&GlobalSMBSeslock);
654 if (list_empty(&(CIFS_I(inode)->openFileList))) {
655 cFYI(1, ("closing last open instance for inode %p", inode));
656 /* if the file is not open we do not know if we can cache info
657 on this inode, much less write behind and read ahead */
658 CIFS_I(inode)->clientCanCacheRead = false;
659 CIFS_I(inode)->clientCanCacheAll = false;
661 read_unlock(&GlobalSMBSeslock);
662 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
663 rc = CIFS_I(inode)->write_behind_rc;
668 int cifs_closedir(struct inode *inode, struct file *file)
672 struct cifsFileInfo *pCFileStruct =
673 (struct cifsFileInfo *)file->private_data;
676 cFYI(1, ("Closedir inode = 0x%p", inode));
681 struct cifsTconInfo *pTcon;
682 struct cifs_sb_info *cifs_sb =
683 CIFS_SB(file->f_path.dentry->d_sb);
685 pTcon = cifs_sb->tcon;
687 cFYI(1, ("Freeing private data in close dir"));
688 write_lock(&GlobalSMBSeslock);
689 if (!pCFileStruct->srch_inf.endOfSearch &&
690 !pCFileStruct->invalidHandle) {
691 pCFileStruct->invalidHandle = true;
692 write_unlock(&GlobalSMBSeslock);
693 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
694 cFYI(1, ("Closing uncompleted readdir with rc %d",
696 /* not much we can do if it fails anyway, ignore rc */
699 write_unlock(&GlobalSMBSeslock);
700 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
702 cFYI(1, ("closedir free smb buf in srch struct"));
703 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
704 if (pCFileStruct->srch_inf.smallBuf)
705 cifs_small_buf_release(ptmp);
707 cifs_buf_release(ptmp);
709 kfree(file->private_data);
710 file->private_data = NULL;
712 /* BB can we lock the filestruct while this is going on? */
717 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
718 __u64 offset, __u8 lockType)
720 struct cifsLockInfo *li =
721 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
727 mutex_lock(&fid->lock_mutex);
728 list_add(&li->llist, &fid->llist);
729 mutex_unlock(&fid->lock_mutex);
733 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
739 bool wait_flag = false;
740 struct cifs_sb_info *cifs_sb;
741 struct cifsTconInfo *tcon;
743 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
744 bool posix_locking = 0;
746 length = 1 + pfLock->fl_end - pfLock->fl_start;
750 cFYI(1, ("Lock parm: 0x%x flockflags: "
751 "0x%x flocktype: 0x%x start: %lld end: %lld",
752 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
755 if (pfLock->fl_flags & FL_POSIX)
757 if (pfLock->fl_flags & FL_FLOCK)
759 if (pfLock->fl_flags & FL_SLEEP) {
760 cFYI(1, ("Blocking lock"));
763 if (pfLock->fl_flags & FL_ACCESS)
764 cFYI(1, ("Process suspended by mandatory locking - "
765 "not implemented yet"));
766 if (pfLock->fl_flags & FL_LEASE)
767 cFYI(1, ("Lease on file - not implemented yet"));
768 if (pfLock->fl_flags &
769 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
770 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
772 if (pfLock->fl_type == F_WRLCK) {
773 cFYI(1, ("F_WRLCK "));
775 } else if (pfLock->fl_type == F_UNLCK) {
776 cFYI(1, ("F_UNLCK"));
778 /* Check if unlock includes more than
780 } else if (pfLock->fl_type == F_RDLCK) {
781 cFYI(1, ("F_RDLCK"));
782 lockType |= LOCKING_ANDX_SHARED_LOCK;
784 } else if (pfLock->fl_type == F_EXLCK) {
785 cFYI(1, ("F_EXLCK"));
787 } else if (pfLock->fl_type == F_SHLCK) {
788 cFYI(1, ("F_SHLCK"));
789 lockType |= LOCKING_ANDX_SHARED_LOCK;
792 cFYI(1, ("Unknown type of lock"));
794 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
795 tcon = cifs_sb->tcon;
797 if (file->private_data == NULL) {
802 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
804 if ((tcon->ses->capabilities & CAP_UNIX) &&
805 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
806 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
808 /* BB add code here to normalize offset and length to
809 account for negative length which we can not accept over the
814 if (lockType & LOCKING_ANDX_SHARED_LOCK)
815 posix_lock_type = CIFS_RDLCK;
817 posix_lock_type = CIFS_WRLCK;
818 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
820 posix_lock_type, wait_flag);
825 /* BB we could chain these into one lock request BB */
826 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
827 0, 1, lockType, 0 /* wait flag */ );
829 rc = CIFSSMBLock(xid, tcon, netfid, length,
830 pfLock->fl_start, 1 /* numUnlock */ ,
831 0 /* numLock */ , lockType,
833 pfLock->fl_type = F_UNLCK;
835 cERROR(1, ("Error unlocking previously locked "
836 "range %d during test of lock", rc));
840 /* if rc == ERR_SHARING_VIOLATION ? */
843 if (lockType & LOCKING_ANDX_SHARED_LOCK) {
844 pfLock->fl_type = F_WRLCK;
846 rc = CIFSSMBLock(xid, tcon, netfid, length,
847 pfLock->fl_start, 0, 1,
848 lockType | LOCKING_ANDX_SHARED_LOCK,
851 rc = CIFSSMBLock(xid, tcon, netfid,
852 length, pfLock->fl_start, 1, 0,
854 LOCKING_ANDX_SHARED_LOCK,
856 pfLock->fl_type = F_RDLCK;
858 cERROR(1, ("Error unlocking "
859 "previously locked range %d "
860 "during test of lock", rc));
863 pfLock->fl_type = F_WRLCK;
873 if (!numLock && !numUnlock) {
874 /* if no lock or unlock then nothing
875 to do since we do not know what it is */
882 if (lockType & LOCKING_ANDX_SHARED_LOCK)
883 posix_lock_type = CIFS_RDLCK;
885 posix_lock_type = CIFS_WRLCK;
888 posix_lock_type = CIFS_UNLCK;
890 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
892 posix_lock_type, wait_flag);
894 struct cifsFileInfo *fid =
895 (struct cifsFileInfo *)file->private_data;
898 rc = CIFSSMBLock(xid, tcon, netfid, length,
900 0, numLock, lockType, wait_flag);
903 /* For Windows locks we must store them. */
904 rc = store_file_lock(fid, length,
905 pfLock->fl_start, lockType);
907 } else if (numUnlock) {
908 /* For each stored lock that this unlock overlaps
909 completely, unlock it. */
911 struct cifsLockInfo *li, *tmp;
914 mutex_lock(&fid->lock_mutex);
915 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
916 if (pfLock->fl_start <= li->offset &&
917 (pfLock->fl_start + length) >=
918 (li->offset + li->length)) {
919 stored_rc = CIFSSMBLock(xid, tcon,
921 li->length, li->offset,
922 1, 0, li->type, false);
926 list_del(&li->llist);
930 mutex_unlock(&fid->lock_mutex);
934 if (pfLock->fl_flags & FL_POSIX)
935 posix_lock_file_wait(file, pfLock);
941 * Set the timeout on write requests past EOF. For some servers (Windows)
942 * these calls can be very long.
944 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
945 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
946 * The 10M cutoff is totally arbitrary. A better scheme for this would be
947 * welcome if someone wants to suggest one.
949 * We may be able to do a better job with this if there were some way to
950 * declare that a file should be sparse.
953 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
955 if (offset <= cifsi->server_eof)
957 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
958 return CIFS_VLONG_OP;
963 /* update the file size (if needed) after a write */
965 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
966 unsigned int bytes_written)
968 loff_t end_of_write = offset + bytes_written;
970 if (end_of_write > cifsi->server_eof)
971 cifsi->server_eof = end_of_write;
974 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
975 size_t write_size, loff_t *poffset)
978 unsigned int bytes_written = 0;
979 unsigned int total_written;
980 struct cifs_sb_info *cifs_sb;
981 struct cifsTconInfo *pTcon;
983 struct cifsFileInfo *open_file;
984 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
986 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
988 pTcon = cifs_sb->tcon;
991 (" write %d bytes to offset %lld of %s", write_size,
992 *poffset, file->f_path.dentry->d_name.name)); */
994 if (file->private_data == NULL)
996 open_file = (struct cifsFileInfo *) file->private_data;
998 rc = generic_write_checks(file, poffset, &write_size, 0);
1004 long_op = cifs_write_timeout(cifsi, *poffset);
1005 for (total_written = 0; write_size > total_written;
1006 total_written += bytes_written) {
1008 while (rc == -EAGAIN) {
1009 if (file->private_data == NULL) {
1010 /* file has been closed on us */
1012 /* if we have gotten here we have written some data
1013 and blocked, and the file has been freed on us while
1014 we blocked so return what we managed to write */
1015 return total_written;
1017 if (open_file->closePend) {
1020 return total_written;
1024 if (open_file->invalidHandle) {
1025 /* we could deadlock if we called
1026 filemap_fdatawait from here so tell
1027 reopen_file not to flush data to server
1029 rc = cifs_reopen_file(file, false);
1034 rc = CIFSSMBWrite(xid, pTcon,
1036 min_t(const int, cifs_sb->wsize,
1037 write_size - total_written),
1038 *poffset, &bytes_written,
1039 NULL, write_data + total_written, long_op);
1041 if (rc || (bytes_written == 0)) {
1049 cifs_update_eof(cifsi, *poffset, bytes_written);
1050 *poffset += bytes_written;
1052 long_op = CIFS_STD_OP; /* subsequent writes fast -
1053 15 seconds is plenty */
1056 cifs_stats_bytes_written(pTcon, total_written);
1058 /* since the write may have blocked check these pointers again */
1059 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1060 struct inode *inode = file->f_path.dentry->d_inode;
1061 /* Do not update local mtime - server will set its actual value on write
1062 * inode->i_ctime = inode->i_mtime =
1063 * current_fs_time(inode->i_sb);*/
1064 if (total_written > 0) {
1065 spin_lock(&inode->i_lock);
1066 if (*poffset > file->f_path.dentry->d_inode->i_size)
1067 i_size_write(file->f_path.dentry->d_inode,
1069 spin_unlock(&inode->i_lock);
1071 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1074 return total_written;
1077 static ssize_t cifs_write(struct file *file, const char *write_data,
1078 size_t write_size, loff_t *poffset)
1081 unsigned int bytes_written = 0;
1082 unsigned int total_written;
1083 struct cifs_sb_info *cifs_sb;
1084 struct cifsTconInfo *pTcon;
1086 struct cifsFileInfo *open_file;
1087 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1089 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1091 pTcon = cifs_sb->tcon;
1093 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
1094 *poffset, file->f_path.dentry->d_name.name));
1096 if (file->private_data == NULL)
1098 open_file = (struct cifsFileInfo *)file->private_data;
1102 long_op = cifs_write_timeout(cifsi, *poffset);
1103 for (total_written = 0; write_size > total_written;
1104 total_written += bytes_written) {
1106 while (rc == -EAGAIN) {
1107 if (file->private_data == NULL) {
1108 /* file has been closed on us */
1110 /* if we have gotten here we have written some data
1111 and blocked, and the file has been freed on us
1112 while we blocked so return what we managed to
1114 return total_written;
1116 if (open_file->closePend) {
1119 return total_written;
1123 if (open_file->invalidHandle) {
1124 /* we could deadlock if we called
1125 filemap_fdatawait from here so tell
1126 reopen_file not to flush data to
1128 rc = cifs_reopen_file(file, false);
1132 if (experimEnabled || (pTcon->ses->server &&
1133 ((pTcon->ses->server->secMode &
1134 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1139 len = min((size_t)cifs_sb->wsize,
1140 write_size - total_written);
1141 /* iov[0] is reserved for smb header */
1142 iov[1].iov_base = (char *)write_data +
1144 iov[1].iov_len = len;
1145 rc = CIFSSMBWrite2(xid, pTcon,
1146 open_file->netfid, len,
1147 *poffset, &bytes_written,
1150 rc = CIFSSMBWrite(xid, pTcon,
1152 min_t(const int, cifs_sb->wsize,
1153 write_size - total_written),
1154 *poffset, &bytes_written,
1155 write_data + total_written,
1158 if (rc || (bytes_written == 0)) {
1166 cifs_update_eof(cifsi, *poffset, bytes_written);
1167 *poffset += bytes_written;
1169 long_op = CIFS_STD_OP; /* subsequent writes fast -
1170 15 seconds is plenty */
1173 cifs_stats_bytes_written(pTcon, total_written);
1175 /* since the write may have blocked check these pointers again */
1176 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1177 /*BB We could make this contingent on superblock ATIME flag too */
1178 /* file->f_path.dentry->d_inode->i_ctime =
1179 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1180 if (total_written > 0) {
1181 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1182 if (*poffset > file->f_path.dentry->d_inode->i_size)
1183 i_size_write(file->f_path.dentry->d_inode,
1185 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1187 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1190 return total_written;
1193 #ifdef CONFIG_CIFS_EXPERIMENTAL
1194 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1196 struct cifsFileInfo *open_file = NULL;
1198 read_lock(&GlobalSMBSeslock);
1199 /* we could simply get the first_list_entry since write-only entries
1200 are always at the end of the list but since the first entry might
1201 have a close pending, we go through the whole list */
1202 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1203 if (open_file->closePend)
1205 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1206 (open_file->pfile->f_flags & O_RDONLY))) {
1207 if (!open_file->invalidHandle) {
1208 /* found a good file */
1209 /* lock it so it will not be closed on us */
1210 cifsFileInfo_get(open_file);
1211 read_unlock(&GlobalSMBSeslock);
1213 } /* else might as well continue, and look for
1214 another, or simply have the caller reopen it
1215 again rather than trying to fix this handle */
1216 } else /* write only file */
1217 break; /* write only files are last so must be done */
1219 read_unlock(&GlobalSMBSeslock);
1224 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1226 struct cifsFileInfo *open_file;
1227 bool any_available = false;
1230 /* Having a null inode here (because mapping->host was set to zero by
1231 the VFS or MM) should not happen but we had reports of on oops (due to
1232 it being zero) during stress testcases so we need to check for it */
1234 if (cifs_inode == NULL) {
1235 cERROR(1, ("Null inode passed to cifs_writeable_file"));
1240 read_lock(&GlobalSMBSeslock);
1242 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1243 if (open_file->closePend ||
1244 (!any_available && open_file->pid != current->tgid))
1247 if (open_file->pfile &&
1248 ((open_file->pfile->f_flags & O_RDWR) ||
1249 (open_file->pfile->f_flags & O_WRONLY))) {
1250 cifsFileInfo_get(open_file);
1252 if (!open_file->invalidHandle) {
1253 /* found a good writable file */
1254 read_unlock(&GlobalSMBSeslock);
1258 read_unlock(&GlobalSMBSeslock);
1259 /* Had to unlock since following call can block */
1260 rc = cifs_reopen_file(open_file->pfile, false);
1262 if (!open_file->closePend)
1264 else { /* start over in case this was deleted */
1265 /* since the list could be modified */
1266 read_lock(&GlobalSMBSeslock);
1267 cifsFileInfo_put(open_file);
1268 goto refind_writable;
1272 /* if it fails, try another handle if possible -
1273 (we can not do this if closePending since
1274 loop could be modified - in which case we
1275 have to start at the beginning of the list
1276 again. Note that it would be bad
1277 to hold up writepages here (rather than
1278 in caller) with continuous retries */
1279 cFYI(1, ("wp failed on reopen file"));
1280 read_lock(&GlobalSMBSeslock);
1281 /* can not use this handle, no write
1282 pending on this one after all */
1283 cifsFileInfo_put(open_file);
1285 if (open_file->closePend) /* list could have changed */
1286 goto refind_writable;
1287 /* else we simply continue to the next entry. Thus
1288 we do not loop on reopen errors. If we
1289 can not reopen the file, for example if we
1290 reconnected to a server with another client
1291 racing to delete or lock the file we would not
1292 make progress if we restarted before the beginning
1293 of the loop here. */
1296 /* couldn't find useable FH with same pid, try any available */
1297 if (!any_available) {
1298 any_available = true;
1299 goto refind_writable;
1301 read_unlock(&GlobalSMBSeslock);
1305 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1307 struct address_space *mapping = page->mapping;
1308 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1311 int bytes_written = 0;
1312 struct cifs_sb_info *cifs_sb;
1313 struct cifsTconInfo *pTcon;
1314 struct inode *inode;
1315 struct cifsFileInfo *open_file;
1317 if (!mapping || !mapping->host)
1320 inode = page->mapping->host;
1321 cifs_sb = CIFS_SB(inode->i_sb);
1322 pTcon = cifs_sb->tcon;
1324 offset += (loff_t)from;
1325 write_data = kmap(page);
1328 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1333 /* racing with truncate? */
1334 if (offset > mapping->host->i_size) {
1336 return 0; /* don't care */
1339 /* check to make sure that we are not extending the file */
1340 if (mapping->host->i_size - offset < (loff_t)to)
1341 to = (unsigned)(mapping->host->i_size - offset);
1343 open_file = find_writable_file(CIFS_I(mapping->host));
1345 bytes_written = cifs_write(open_file->pfile, write_data,
1347 cifsFileInfo_put(open_file);
1348 /* Does mm or vfs already set times? */
1349 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1350 if ((bytes_written > 0) && (offset))
1352 else if (bytes_written < 0)
1355 cFYI(1, ("No writeable filehandles for inode"));
1363 static int cifs_writepages(struct address_space *mapping,
1364 struct writeback_control *wbc)
1366 struct backing_dev_info *bdi = mapping->backing_dev_info;
1367 unsigned int bytes_to_write;
1368 unsigned int bytes_written;
1369 struct cifs_sb_info *cifs_sb;
1373 int range_whole = 0;
1380 struct cifsFileInfo *open_file;
1381 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1383 struct pagevec pvec;
1388 cifs_sb = CIFS_SB(mapping->host->i_sb);
1391 * If wsize is smaller that the page cache size, default to writing
1392 * one page at a time via cifs_writepage
1394 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1395 return generic_writepages(mapping, wbc);
1397 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1398 if (cifs_sb->tcon->ses->server->secMode &
1399 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1400 if (!experimEnabled)
1401 return generic_writepages(mapping, wbc);
1403 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1405 return generic_writepages(mapping, wbc);
1409 * BB: Is this meaningful for a non-block-device file system?
1410 * If it is, we should test it again after we do I/O
1412 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1413 wbc->encountered_congestion = 1;
1420 pagevec_init(&pvec, 0);
1421 if (wbc->range_cyclic) {
1422 index = mapping->writeback_index; /* Start from prev offset */
1425 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1426 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1427 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1432 while (!done && (index <= end) &&
1433 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1434 PAGECACHE_TAG_DIRTY,
1435 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1444 for (i = 0; i < nr_pages; i++) {
1445 page = pvec.pages[i];
1447 * At this point we hold neither mapping->tree_lock nor
1448 * lock on the page itself: the page may be truncated or
1449 * invalidated (changing page->mapping to NULL), or even
1450 * swizzled back from swapper_space to tmpfs file
1456 else if (!trylock_page(page))
1459 if (unlikely(page->mapping != mapping)) {
1464 if (!wbc->range_cyclic && page->index > end) {
1470 if (next && (page->index != next)) {
1471 /* Not next consecutive page */
1476 if (wbc->sync_mode != WB_SYNC_NONE)
1477 wait_on_page_writeback(page);
1479 if (PageWriteback(page) ||
1480 !clear_page_dirty_for_io(page)) {
1486 * This actually clears the dirty bit in the radix tree.
1487 * See cifs_writepage() for more commentary.
1489 set_page_writeback(page);
1491 if (page_offset(page) >= mapping->host->i_size) {
1494 end_page_writeback(page);
1499 * BB can we get rid of this? pages are held by pvec
1501 page_cache_get(page);
1503 len = min(mapping->host->i_size - page_offset(page),
1504 (loff_t)PAGE_CACHE_SIZE);
1506 /* reserve iov[0] for the smb header */
1508 iov[n_iov].iov_base = kmap(page);
1509 iov[n_iov].iov_len = len;
1510 bytes_to_write += len;
1514 offset = page_offset(page);
1516 next = page->index + 1;
1517 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1521 /* Search for a writable handle every time we call
1522 * CIFSSMBWrite2. We can't rely on the last handle
1523 * we used to still be valid
1525 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, cifs_sb->tcon,
1533 bytes_to_write, offset,
1534 &bytes_written, iov, n_iov,
1536 cifsFileInfo_put(open_file);
1537 cifs_update_eof(cifsi, offset, bytes_written);
1539 if (rc || bytes_written < bytes_to_write) {
1540 cERROR(1, ("Write2 ret %d, wrote %d",
1541 rc, bytes_written));
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(cifs_sb->tcon,
1553 for (i = 0; i < n_iov; i++) {
1554 page = pvec.pages[first + i];
1555 /* Should we also set page error on
1556 success rc but too little data written? */
1557 /* BB investigate retry logic on temporary
1558 server crash cases and how recovery works
1559 when page marked as error */
1564 end_page_writeback(page);
1565 page_cache_release(page);
1567 if ((wbc->nr_to_write -= n_iov) <= 0)
1571 /* Need to re-find the pages we skipped */
1572 index = pvec.pages[0]->index + 1;
1574 pagevec_release(&pvec);
1576 if (!scanned && !done) {
1578 * We hit the last page and there is more work to be done: wrap
1579 * back to the start of the file
1585 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1586 mapping->writeback_index = index;
1593 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1599 /* BB add check for wbc flags */
1600 page_cache_get(page);
1601 if (!PageUptodate(page))
1602 cFYI(1, ("ppw - page not up to date"));
1605 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1607 * A writepage() implementation always needs to do either this,
1608 * or re-dirty the page with "redirty_page_for_writepage()" in
1609 * the case of a failure.
1611 * Just unlocking the page will cause the radix tree tag-bits
1612 * to fail to update with the state of the page correctly.
1614 set_page_writeback(page);
1615 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1616 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1618 end_page_writeback(page);
1619 page_cache_release(page);
1624 static int cifs_write_end(struct file *file, struct address_space *mapping,
1625 loff_t pos, unsigned len, unsigned copied,
1626 struct page *page, void *fsdata)
1629 struct inode *inode = mapping->host;
1631 cFYI(1, ("write_end for page %p from pos %lld with %d bytes",
1632 page, pos, copied));
1634 if (PageChecked(page)) {
1636 SetPageUptodate(page);
1637 ClearPageChecked(page);
1638 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1639 SetPageUptodate(page);
1641 if (!PageUptodate(page)) {
1643 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1647 /* this is probably better than directly calling
1648 partialpage_write since in this function the file handle is
1649 known which we might as well leverage */
1650 /* BB check if anything else missing out of ppw
1651 such as updating last write time */
1652 page_data = kmap(page);
1653 rc = cifs_write(file, page_data + offset, copied, &pos);
1654 /* if (rc < 0) should we set writebehind rc? */
1661 set_page_dirty(page);
1665 spin_lock(&inode->i_lock);
1666 if (pos > inode->i_size)
1667 i_size_write(inode, pos);
1668 spin_unlock(&inode->i_lock);
1672 page_cache_release(page);
1677 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1681 struct cifsTconInfo *tcon;
1682 struct cifsFileInfo *smbfile =
1683 (struct cifsFileInfo *)file->private_data;
1684 struct inode *inode = file->f_path.dentry->d_inode;
1688 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
1689 dentry->d_name.name, datasync));
1691 rc = filemap_write_and_wait(inode->i_mapping);
1693 rc = CIFS_I(inode)->write_behind_rc;
1694 CIFS_I(inode)->write_behind_rc = 0;
1695 tcon = CIFS_SB(inode->i_sb)->tcon;
1696 if (!rc && tcon && smbfile &&
1697 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1698 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1705 /* static void cifs_sync_page(struct page *page)
1707 struct address_space *mapping;
1708 struct inode *inode;
1709 unsigned long index = page->index;
1710 unsigned int rpages = 0;
1713 cFYI(1, ("sync page %p",page));
1714 mapping = page->mapping;
1717 inode = mapping->host;
1721 /* fill in rpages then
1722 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1724 /* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
1734 * As file closes, flush all cached write data for this inode checking
1735 * for write behind errors.
1737 int cifs_flush(struct file *file, fl_owner_t id)
1739 struct inode *inode = file->f_path.dentry->d_inode;
1742 /* Rather than do the steps manually:
1743 lock the inode for writing
1744 loop through pages looking for write behind data (dirty pages)
1745 coalesce into contiguous 16K (or smaller) chunks to write to server
1746 send to server (prefer in parallel)
1747 deal with writebehind errors
1748 unlock inode for writing
1749 filemapfdatawrite appears easier for the time being */
1751 rc = filemap_fdatawrite(inode->i_mapping);
1752 /* reset wb rc if we were able to write out dirty pages */
1754 rc = CIFS_I(inode)->write_behind_rc;
1755 CIFS_I(inode)->write_behind_rc = 0;
1758 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
1763 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1764 size_t read_size, loff_t *poffset)
1767 unsigned int bytes_read = 0;
1768 unsigned int total_read = 0;
1769 unsigned int current_read_size;
1770 struct cifs_sb_info *cifs_sb;
1771 struct cifsTconInfo *pTcon;
1773 struct cifsFileInfo *open_file;
1774 char *smb_read_data;
1775 char __user *current_offset;
1776 struct smb_com_read_rsp *pSMBr;
1779 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1780 pTcon = cifs_sb->tcon;
1782 if (file->private_data == NULL) {
1787 open_file = (struct cifsFileInfo *)file->private_data;
1789 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1790 cFYI(1, ("attempting read on write only file instance"));
1792 for (total_read = 0, current_offset = read_data;
1793 read_size > total_read;
1794 total_read += bytes_read, current_offset += bytes_read) {
1795 current_read_size = min_t(const int, read_size - total_read,
1798 smb_read_data = NULL;
1799 while (rc == -EAGAIN) {
1800 int buf_type = CIFS_NO_BUFFER;
1801 if ((open_file->invalidHandle) &&
1802 (!open_file->closePend)) {
1803 rc = cifs_reopen_file(file, true);
1807 rc = CIFSSMBRead(xid, pTcon,
1809 current_read_size, *poffset,
1810 &bytes_read, &smb_read_data,
1812 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1813 if (smb_read_data) {
1814 if (copy_to_user(current_offset,
1816 4 /* RFC1001 length field */ +
1817 le16_to_cpu(pSMBr->DataOffset),
1821 if (buf_type == CIFS_SMALL_BUFFER)
1822 cifs_small_buf_release(smb_read_data);
1823 else if (buf_type == CIFS_LARGE_BUFFER)
1824 cifs_buf_release(smb_read_data);
1825 smb_read_data = NULL;
1828 if (rc || (bytes_read == 0)) {
1836 cifs_stats_bytes_read(pTcon, bytes_read);
1837 *poffset += bytes_read;
1845 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1849 unsigned int bytes_read = 0;
1850 unsigned int total_read;
1851 unsigned int current_read_size;
1852 struct cifs_sb_info *cifs_sb;
1853 struct cifsTconInfo *pTcon;
1855 char *current_offset;
1856 struct cifsFileInfo *open_file;
1857 int buf_type = CIFS_NO_BUFFER;
1860 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1861 pTcon = cifs_sb->tcon;
1863 if (file->private_data == NULL) {
1868 open_file = (struct cifsFileInfo *)file->private_data;
1870 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1871 cFYI(1, ("attempting read on write only file instance"));
1873 for (total_read = 0, current_offset = read_data;
1874 read_size > total_read;
1875 total_read += bytes_read, current_offset += bytes_read) {
1876 current_read_size = min_t(const int, read_size - total_read,
1878 /* For windows me and 9x we do not want to request more
1879 than it negotiated since it will refuse the read then */
1881 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1882 current_read_size = min_t(const int, current_read_size,
1883 pTcon->ses->server->maxBuf - 128);
1886 while (rc == -EAGAIN) {
1887 if ((open_file->invalidHandle) &&
1888 (!open_file->closePend)) {
1889 rc = cifs_reopen_file(file, true);
1893 rc = CIFSSMBRead(xid, pTcon,
1895 current_read_size, *poffset,
1896 &bytes_read, ¤t_offset,
1899 if (rc || (bytes_read == 0)) {
1907 cifs_stats_bytes_read(pTcon, total_read);
1908 *poffset += bytes_read;
1915 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1920 rc = cifs_revalidate_file(file);
1922 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1926 rc = generic_file_mmap(file, vma);
1932 static void cifs_copy_cache_pages(struct address_space *mapping,
1933 struct list_head *pages, int bytes_read, char *data,
1934 struct pagevec *plru_pvec)
1939 while (bytes_read > 0) {
1940 if (list_empty(pages))
1943 page = list_entry(pages->prev, struct page, lru);
1944 list_del(&page->lru);
1946 if (add_to_page_cache(page, mapping, page->index,
1948 page_cache_release(page);
1949 cFYI(1, ("Add page cache failed"));
1950 data += PAGE_CACHE_SIZE;
1951 bytes_read -= PAGE_CACHE_SIZE;
1955 target = kmap_atomic(page, KM_USER0);
1957 if (PAGE_CACHE_SIZE > bytes_read) {
1958 memcpy(target, data, bytes_read);
1959 /* zero the tail end of this partial page */
1960 memset(target + bytes_read, 0,
1961 PAGE_CACHE_SIZE - bytes_read);
1964 memcpy(target, data, PAGE_CACHE_SIZE);
1965 bytes_read -= PAGE_CACHE_SIZE;
1967 kunmap_atomic(target, KM_USER0);
1969 flush_dcache_page(page);
1970 SetPageUptodate(page);
1972 if (!pagevec_add(plru_pvec, page))
1973 __pagevec_lru_add_file(plru_pvec);
1974 data += PAGE_CACHE_SIZE;
1979 static int cifs_readpages(struct file *file, struct address_space *mapping,
1980 struct list_head *page_list, unsigned num_pages)
1986 struct cifs_sb_info *cifs_sb;
1987 struct cifsTconInfo *pTcon;
1988 unsigned int bytes_read = 0;
1989 unsigned int read_size, i;
1990 char *smb_read_data = NULL;
1991 struct smb_com_read_rsp *pSMBr;
1992 struct pagevec lru_pvec;
1993 struct cifsFileInfo *open_file;
1994 int buf_type = CIFS_NO_BUFFER;
1997 if (file->private_data == NULL) {
2002 open_file = (struct cifsFileInfo *)file->private_data;
2003 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2004 pTcon = cifs_sb->tcon;
2006 pagevec_init(&lru_pvec, 0);
2007 cFYI(DBG2, ("rpages: num pages %d", num_pages));
2008 for (i = 0; i < num_pages; ) {
2009 unsigned contig_pages;
2010 struct page *tmp_page;
2011 unsigned long expected_index;
2013 if (list_empty(page_list))
2016 page = list_entry(page_list->prev, struct page, lru);
2017 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2019 /* count adjacent pages that we will read into */
2022 list_entry(page_list->prev, struct page, lru)->index;
2023 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2024 if (tmp_page->index == expected_index) {
2030 if (contig_pages + i > num_pages)
2031 contig_pages = num_pages - i;
2033 /* for reads over a certain size could initiate async
2036 read_size = contig_pages * PAGE_CACHE_SIZE;
2037 /* Read size needs to be in multiples of one page */
2038 read_size = min_t(const unsigned int, read_size,
2039 cifs_sb->rsize & PAGE_CACHE_MASK);
2040 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
2041 read_size, contig_pages));
2043 while (rc == -EAGAIN) {
2044 if ((open_file->invalidHandle) &&
2045 (!open_file->closePend)) {
2046 rc = cifs_reopen_file(file, true);
2051 rc = CIFSSMBRead(xid, pTcon,
2054 &bytes_read, &smb_read_data,
2056 /* BB more RC checks ? */
2057 if (rc == -EAGAIN) {
2058 if (smb_read_data) {
2059 if (buf_type == CIFS_SMALL_BUFFER)
2060 cifs_small_buf_release(smb_read_data);
2061 else if (buf_type == CIFS_LARGE_BUFFER)
2062 cifs_buf_release(smb_read_data);
2063 smb_read_data = NULL;
2067 if ((rc < 0) || (smb_read_data == NULL)) {
2068 cFYI(1, ("Read error in readpages: %d", rc));
2070 } else if (bytes_read > 0) {
2071 task_io_account_read(bytes_read);
2072 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2073 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2074 smb_read_data + 4 /* RFC1001 hdr */ +
2075 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
2077 i += bytes_read >> PAGE_CACHE_SHIFT;
2078 cifs_stats_bytes_read(pTcon, bytes_read);
2079 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2080 i++; /* account for partial page */
2082 /* server copy of file can have smaller size
2084 /* BB do we need to verify this common case ?
2085 this case is ok - if we are at server EOF
2086 we will hit it on next read */
2091 cFYI(1, ("No bytes read (%d) at offset %lld . "
2092 "Cleaning remaining pages from readahead list",
2093 bytes_read, offset));
2094 /* BB turn off caching and do new lookup on
2095 file size at server? */
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;
2108 pagevec_lru_add_file(&lru_pvec);
2110 /* need to free smb_read_data buf before exit */
2111 if (smb_read_data) {
2112 if (buf_type == CIFS_SMALL_BUFFER)
2113 cifs_small_buf_release(smb_read_data);
2114 else if (buf_type == CIFS_LARGE_BUFFER)
2115 cifs_buf_release(smb_read_data);
2116 smb_read_data = NULL;
2123 static int cifs_readpage_worker(struct file *file, struct page *page,
2129 page_cache_get(page);
2130 read_data = kmap(page);
2131 /* for reads over a certain size could initiate async read ahead */
2133 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2138 cFYI(1, ("Bytes read %d", rc));
2140 file->f_path.dentry->d_inode->i_atime =
2141 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2143 if (PAGE_CACHE_SIZE > rc)
2144 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2146 flush_dcache_page(page);
2147 SetPageUptodate(page);
2152 page_cache_release(page);
2156 static int cifs_readpage(struct file *file, struct page *page)
2158 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2164 if (file->private_data == NULL) {
2170 cFYI(1, ("readpage %p at offset %d 0x%x\n",
2171 page, (int)offset, (int)offset));
2173 rc = cifs_readpage_worker(file, page, &offset);
2181 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2183 struct cifsFileInfo *open_file;
2185 read_lock(&GlobalSMBSeslock);
2186 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2187 if (open_file->closePend)
2189 if (open_file->pfile &&
2190 ((open_file->pfile->f_flags & O_RDWR) ||
2191 (open_file->pfile->f_flags & O_WRONLY))) {
2192 read_unlock(&GlobalSMBSeslock);
2196 read_unlock(&GlobalSMBSeslock);
2200 /* We do not want to update the file size from server for inodes
2201 open for write - to avoid races with writepage extending
2202 the file - in the future we could consider allowing
2203 refreshing the inode only on increases in the file size
2204 but this is tricky to do without racing with writebehind
2205 page caching in the current Linux kernel design */
2206 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2211 if (is_inode_writable(cifsInode)) {
2212 /* This inode is open for write at least once */
2213 struct cifs_sb_info *cifs_sb;
2215 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2216 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2217 /* since no page cache to corrupt on directio
2218 we can change size safely */
2222 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2230 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2231 loff_t pos, unsigned len, unsigned flags,
2232 struct page **pagep, void **fsdata)
2234 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2235 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2236 loff_t page_start = pos & PAGE_MASK;
2241 cFYI(1, ("write_begin from %lld len %d", (long long)pos, len));
2243 page = grab_cache_page_write_begin(mapping, index, flags);
2249 if (PageUptodate(page))
2253 * If we write a full page it will be up to date, no need to read from
2254 * the server. If the write is short, we'll end up doing a sync write
2257 if (len == PAGE_CACHE_SIZE)
2261 * optimize away the read when we have an oplock, and we're not
2262 * expecting to use any of the data we'd be reading in. That
2263 * is, when the page lies beyond the EOF, or straddles the EOF
2264 * and the write will cover all of the existing data.
2266 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2267 i_size = i_size_read(mapping->host);
2268 if (page_start >= i_size ||
2269 (offset == 0 && (pos + len) >= i_size)) {
2270 zero_user_segments(page, 0, offset,
2274 * PageChecked means that the parts of the page
2275 * to which we're not writing are considered up
2276 * to date. Once the data is copied to the
2277 * page, it can be set uptodate.
2279 SetPageChecked(page);
2284 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2286 * might as well read a page, it is fast enough. If we get
2287 * an error, we don't need to return it. cifs_write_end will
2288 * do a sync write instead since PG_uptodate isn't set.
2290 cifs_readpage_worker(file, page, &page_start);
2292 /* we could try using another file handle if there is one -
2293 but how would we lock it to prevent close of that handle
2294 racing with this read? In any case
2295 this will be written out by write_end so is fine */
2303 cifs_oplock_break(struct slow_work *work)
2305 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2307 struct inode *inode = cfile->pInode;
2308 struct cifsInodeInfo *cinode = CIFS_I(inode);
2309 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->mnt->mnt_sb);
2312 if (inode && S_ISREG(inode->i_mode)) {
2313 #ifdef CONFIG_CIFS_EXPERIMENTAL
2314 if (cinode->clientCanCacheAll == 0)
2315 break_lease(inode, O_RDONLY);
2316 else if (cinode->clientCanCacheRead == 0)
2317 break_lease(inode, O_WRONLY);
2319 rc = filemap_fdatawrite(inode->i_mapping);
2320 if (cinode->clientCanCacheRead == 0) {
2321 waitrc = filemap_fdatawait(inode->i_mapping);
2322 invalidate_remote_inode(inode);
2327 cinode->write_behind_rc = rc;
2328 cFYI(1, ("Oplock flush inode %p rc %d", inode, rc));
2332 * releasing stale oplock after recent reconnect of smb session using
2333 * a now incorrect file handle is not a data integrity issue but do
2334 * not bother sending an oplock release if session to server still is
2335 * disconnected since oplock already released by the server
2337 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2338 rc = CIFSSMBLock(0, cifs_sb->tcon, cfile->netfid, 0, 0, 0, 0,
2339 LOCKING_ANDX_OPLOCK_RELEASE, false);
2340 cFYI(1, ("Oplock release rc = %d", rc));
2345 cifs_oplock_break_get(struct slow_work *work)
2347 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2350 cifsFileInfo_get(cfile);
2355 cifs_oplock_break_put(struct slow_work *work)
2357 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2360 cifsFileInfo_put(cfile);
2363 const struct slow_work_ops cifs_oplock_break_ops = {
2364 .get_ref = cifs_oplock_break_get,
2365 .put_ref = cifs_oplock_break_put,
2366 .execute = cifs_oplock_break,
2369 const struct address_space_operations cifs_addr_ops = {
2370 .readpage = cifs_readpage,
2371 .readpages = cifs_readpages,
2372 .writepage = cifs_writepage,
2373 .writepages = cifs_writepages,
2374 .write_begin = cifs_write_begin,
2375 .write_end = cifs_write_end,
2376 .set_page_dirty = __set_page_dirty_nobuffers,
2377 /* .sync_page = cifs_sync_page, */
2382 * cifs_readpages requires the server to support a buffer large enough to
2383 * contain the header plus one complete page of data. Otherwise, we need
2384 * to leave cifs_readpages out of the address space operations.
2386 const struct address_space_operations cifs_addr_ops_smallbuf = {
2387 .readpage = cifs_readpage,
2388 .writepage = cifs_writepage,
2389 .writepages = cifs_writepages,
2390 .write_begin = cifs_write_begin,
2391 .write_end = cifs_write_end,
2392 .set_page_dirty = __set_page_dirty_nobuffers,
2393 /* .sync_page = cifs_sync_page, */