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 <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"
44 static inline int cifs_convert_flags(unsigned int flags)
46 if ((flags & O_ACCMODE) == O_RDONLY)
48 else if ((flags & O_ACCMODE) == O_WRONLY)
50 else if ((flags & O_ACCMODE) == O_RDWR) {
51 /* GENERIC_ALL is too much permission to request
52 can cause unnecessary access denied on create */
53 /* return GENERIC_ALL; */
54 return (GENERIC_READ | GENERIC_WRITE);
57 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
58 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
62 static inline fmode_t cifs_posix_convert_flags(unsigned int flags)
64 fmode_t posix_flags = 0;
66 if ((flags & O_ACCMODE) == O_RDONLY)
67 posix_flags = FMODE_READ;
68 else if ((flags & O_ACCMODE) == O_WRONLY)
69 posix_flags = FMODE_WRITE;
70 else if ((flags & O_ACCMODE) == O_RDWR) {
71 /* GENERIC_ALL is too much permission to request
72 can cause unnecessary access denied on create */
73 /* return GENERIC_ALL; */
74 posix_flags = FMODE_READ | FMODE_WRITE;
76 /* can not map O_CREAT or O_EXCL or O_TRUNC flags when
77 reopening a file. They had their effect on the original open */
79 posix_flags |= (fmode_t)O_APPEND;
81 posix_flags |= (fmode_t)O_DSYNC;
83 posix_flags |= (fmode_t)__O_SYNC;
84 if (flags & O_DIRECTORY)
85 posix_flags |= (fmode_t)O_DIRECTORY;
86 if (flags & O_NOFOLLOW)
87 posix_flags |= (fmode_t)O_NOFOLLOW;
89 posix_flags |= (fmode_t)O_DIRECT;
94 static inline int cifs_get_disposition(unsigned int flags)
96 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
98 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
99 return FILE_OVERWRITE_IF;
100 else if ((flags & O_CREAT) == O_CREAT)
102 else if ((flags & O_TRUNC) == O_TRUNC)
103 return FILE_OVERWRITE;
108 /* all arguments to this function must be checked for validity in caller */
110 cifs_posix_open_inode_helper(struct inode *inode, struct file *file,
111 struct cifsInodeInfo *pCifsInode,
112 struct cifsFileInfo *pCifsFile, __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 static struct cifsFileInfo *
167 cifs_fill_filedata(struct file *file)
169 struct list_head *tmp;
170 struct cifsFileInfo *pCifsFile = NULL;
171 struct cifsInodeInfo *pCifsInode = NULL;
173 /* search inode for this file and fill in file->private_data */
174 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
175 read_lock(&GlobalSMBSeslock);
176 list_for_each(tmp, &pCifsInode->openFileList) {
177 pCifsFile = list_entry(tmp, struct cifsFileInfo, flist);
178 if ((pCifsFile->pfile == NULL) &&
179 (pCifsFile->pid == current->tgid)) {
180 /* mode set in cifs_create */
182 /* needed for writepage */
183 pCifsFile->pfile = file;
184 file->private_data = pCifsFile;
188 read_unlock(&GlobalSMBSeslock);
190 if (file->private_data != NULL) {
192 } else if ((file->f_flags & O_CREAT) && (file->f_flags & O_EXCL))
193 cERROR(1, "could not find file instance for "
194 "new file %p", file);
198 /* all arguments to this function must be checked for validity in caller */
199 static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
200 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
201 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
202 char *full_path, int xid)
204 struct timespec temp;
207 if (pCifsInode->clientCanCacheRead) {
208 /* we have the inode open somewhere else
209 no need to discard cache data */
210 goto client_can_cache;
213 /* BB need same check in cifs_create too? */
214 /* if not oplocked, invalidate inode pages if mtime or file
216 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
217 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
218 (file->f_path.dentry->d_inode->i_size ==
219 (loff_t)le64_to_cpu(buf->EndOfFile))) {
220 cFYI(1, "inode unchanged on server");
222 if (file->f_path.dentry->d_inode->i_mapping) {
223 /* BB no need to lock inode until after invalidate
224 since namei code should already have it locked? */
225 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
227 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
229 cFYI(1, "invalidating remote inode since open detected it "
231 invalidate_remote_inode(file->f_path.dentry->d_inode);
236 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
237 full_path, inode->i_sb, xid);
239 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
240 full_path, buf, inode->i_sb, xid, NULL);
242 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
243 pCifsInode->clientCanCacheAll = true;
244 pCifsInode->clientCanCacheRead = true;
245 cFYI(1, "Exclusive Oplock granted on inode %p",
246 file->f_path.dentry->d_inode);
247 } else if ((*oplock & 0xF) == OPLOCK_READ)
248 pCifsInode->clientCanCacheRead = true;
253 int cifs_open(struct inode *inode, struct file *file)
258 struct cifs_sb_info *cifs_sb;
259 struct cifsTconInfo *tcon;
260 struct cifsFileInfo *pCifsFile;
261 struct cifsInodeInfo *pCifsInode;
262 char *full_path = NULL;
266 FILE_ALL_INFO *buf = NULL;
270 cifs_sb = CIFS_SB(inode->i_sb);
271 tcon = cifs_sb->tcon;
273 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
274 pCifsFile = cifs_fill_filedata(file);
281 full_path = build_path_from_dentry(file->f_path.dentry);
282 if (full_path == NULL) {
288 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
289 inode, file->f_flags, full_path);
296 if (!tcon->broken_posix_open && tcon->unix_ext &&
297 (tcon->ses->capabilities & CAP_UNIX) &&
298 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
299 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
300 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
301 /* can not refresh inode info since size could be stale */
302 rc = cifs_posix_open(full_path, &inode, file->f_path.mnt,
303 cifs_sb->mnt_file_mode /* ignored */,
304 oflags, &oplock, &netfid, xid);
306 cFYI(1, "posix open succeeded");
307 /* no need for special case handling of setting mode
308 on read only files needed here */
310 pCifsFile = cifs_fill_filedata(file);
311 cifs_posix_open_inode_helper(inode, file, pCifsInode,
312 pCifsFile, oplock, netfid);
314 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
315 if (tcon->ses->serverNOS)
316 cERROR(1, "server %s of type %s returned"
317 " unexpected error on SMB posix open"
318 ", disabling posix open support."
319 " Check if server update available.",
320 tcon->ses->serverName,
321 tcon->ses->serverNOS);
322 tcon->broken_posix_open = true;
323 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
324 (rc != -EOPNOTSUPP)) /* path not found or net err */
326 /* else fallthrough to retry open the old way on network i/o
330 desiredAccess = cifs_convert_flags(file->f_flags);
332 /*********************************************************************
333 * open flag mapping table:
335 * POSIX Flag CIFS Disposition
336 * ---------- ----------------
337 * O_CREAT FILE_OPEN_IF
338 * O_CREAT | O_EXCL FILE_CREATE
339 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
340 * O_TRUNC FILE_OVERWRITE
341 * none of the above FILE_OPEN
343 * Note that there is not a direct match between disposition
344 * FILE_SUPERSEDE (ie create whether or not file exists although
345 * O_CREAT | O_TRUNC is similar but truncates the existing
346 * file rather than creating a new file as FILE_SUPERSEDE does
347 * (which uses the attributes / metadata passed in on open call)
349 *? O_SYNC is a reasonable match to CIFS writethrough flag
350 *? and the read write flags match reasonably. O_LARGEFILE
351 *? is irrelevant because largefile support is always used
352 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
353 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
354 *********************************************************************/
356 disposition = cifs_get_disposition(file->f_flags);
358 /* BB pass O_SYNC flag through on file attributes .. BB */
360 /* Also refresh inode by passing in file_info buf returned by SMBOpen
361 and calling get_inode_info with returned buf (at least helps
362 non-Unix server case) */
364 /* BB we can not do this if this is the second open of a file
365 and the first handle has writebehind data, we might be
366 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
367 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
373 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
374 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
375 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
376 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
377 & CIFS_MOUNT_MAP_SPECIAL_CHR);
379 rc = -EIO; /* no NT SMB support fall into legacy open below */
382 /* Old server, try legacy style OpenX */
383 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
384 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
385 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
386 & CIFS_MOUNT_MAP_SPECIAL_CHR);
389 cFYI(1, "cifs_open returned 0x%x", rc);
393 pCifsFile = cifs_new_fileinfo(inode, netfid, file, file->f_path.mnt,
395 file->private_data = pCifsFile;
396 if (file->private_data == NULL) {
401 rc = cifs_open_inode_helper(inode, file, pCifsInode, pCifsFile, tcon,
402 &oplock, buf, full_path, xid);
404 if (oplock & CIFS_CREATE_ACTION) {
405 /* time to set mode which we can not set earlier due to
406 problems creating new read-only files */
407 if (tcon->unix_ext) {
408 struct cifs_unix_set_info_args args = {
409 .mode = inode->i_mode,
412 .ctime = NO_CHANGE_64,
413 .atime = NO_CHANGE_64,
414 .mtime = NO_CHANGE_64,
417 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
419 cifs_sb->mnt_cifs_flags &
420 CIFS_MOUNT_MAP_SPECIAL_CHR);
431 /* Try to reacquire byte range locks that were released when session */
432 /* to server was lost */
433 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
437 /* BB list all locks open on this file and relock */
442 static int cifs_reopen_file(struct file *file, bool can_flush)
447 struct cifs_sb_info *cifs_sb;
448 struct cifsTconInfo *tcon;
449 struct cifsFileInfo *pCifsFile;
450 struct cifsInodeInfo *pCifsInode;
452 char *full_path = NULL;
454 int disposition = FILE_OPEN;
457 if (file->private_data)
458 pCifsFile = (struct cifsFileInfo *)file->private_data;
463 mutex_lock(&pCifsFile->fh_mutex);
464 if (!pCifsFile->invalidHandle) {
465 mutex_unlock(&pCifsFile->fh_mutex);
471 if (file->f_path.dentry == NULL) {
472 cERROR(1, "no valid name if dentry freed");
475 goto reopen_error_exit;
478 inode = file->f_path.dentry->d_inode;
480 cERROR(1, "inode not valid");
483 goto reopen_error_exit;
486 cifs_sb = CIFS_SB(inode->i_sb);
487 tcon = cifs_sb->tcon;
489 /* can not grab rename sem here because various ops, including
490 those that already have the rename sem can end up causing writepage
491 to get called and if the server was down that means we end up here,
492 and we can never tell if the caller already has the rename_sem */
493 full_path = build_path_from_dentry(file->f_path.dentry);
494 if (full_path == NULL) {
497 mutex_unlock(&pCifsFile->fh_mutex);
502 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
503 inode, file->f_flags, full_path);
510 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
511 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
512 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
513 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
514 /* can not refresh inode info since size could be stale */
515 rc = cifs_posix_open(full_path, NULL, file->f_path.mnt,
516 cifs_sb->mnt_file_mode /* ignored */,
517 oflags, &oplock, &netfid, xid);
519 cFYI(1, "posix reopen succeeded");
522 /* fallthrough to retry open the old way on errors, especially
523 in the reconnect path it is important to retry hard */
526 desiredAccess = cifs_convert_flags(file->f_flags);
528 /* Can not refresh inode by passing in file_info buf to be returned
529 by SMBOpen and then calling get_inode_info with returned buf
530 since file might have write behind data that needs to be flushed
531 and server version of file size can be stale. If we knew for sure
532 that inode was not dirty locally we could do this */
534 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
535 CREATE_NOT_DIR, &netfid, &oplock, NULL,
536 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
537 CIFS_MOUNT_MAP_SPECIAL_CHR);
539 mutex_unlock(&pCifsFile->fh_mutex);
540 cFYI(1, "cifs_open returned 0x%x", rc);
541 cFYI(1, "oplock: %d", oplock);
544 pCifsFile->netfid = netfid;
545 pCifsFile->invalidHandle = false;
546 mutex_unlock(&pCifsFile->fh_mutex);
547 pCifsInode = CIFS_I(inode);
550 rc = filemap_write_and_wait(inode->i_mapping);
552 CIFS_I(inode)->write_behind_rc = rc;
553 /* temporarily disable caching while we
554 go to server to get inode info */
555 pCifsInode->clientCanCacheAll = false;
556 pCifsInode->clientCanCacheRead = false;
558 rc = cifs_get_inode_info_unix(&inode,
559 full_path, inode->i_sb, xid);
561 rc = cifs_get_inode_info(&inode,
562 full_path, NULL, inode->i_sb,
564 } /* else we are writing out data to server already
565 and could deadlock if we tried to flush data, and
566 since we do not know if we have data that would
567 invalidate the current end of file on the server
568 we can not go to the server to get the new inod
570 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
571 pCifsInode->clientCanCacheAll = true;
572 pCifsInode->clientCanCacheRead = true;
573 cFYI(1, "Exclusive Oplock granted on inode %p",
574 file->f_path.dentry->d_inode);
575 } else if ((oplock & 0xF) == OPLOCK_READ) {
576 pCifsInode->clientCanCacheRead = true;
577 pCifsInode->clientCanCacheAll = false;
579 pCifsInode->clientCanCacheRead = false;
580 pCifsInode->clientCanCacheAll = false;
582 cifs_relock_file(pCifsFile);
590 int cifs_close(struct inode *inode, struct file *file)
594 struct cifs_sb_info *cifs_sb;
595 struct cifsTconInfo *pTcon;
596 struct cifsFileInfo *pSMBFile =
597 (struct cifsFileInfo *)file->private_data;
601 cifs_sb = CIFS_SB(inode->i_sb);
602 pTcon = cifs_sb->tcon;
604 struct cifsLockInfo *li, *tmp;
605 write_lock(&GlobalSMBSeslock);
606 pSMBFile->closePend = true;
608 /* no sense reconnecting to close a file that is
610 if (!pTcon->need_reconnect) {
611 write_unlock(&GlobalSMBSeslock);
613 while ((atomic_read(&pSMBFile->count) != 1)
614 && (timeout <= 2048)) {
615 /* Give write a better chance to get to
616 server ahead of the close. We do not
617 want to add a wait_q here as it would
618 increase the memory utilization as
619 the struct would be in each open file,
620 but this should give enough time to
622 cFYI(DBG2, "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) {
775 } else if (pfLock->fl_type == F_UNLCK) {
778 /* Check if unlock includes more than
780 } else if (pfLock->fl_type == F_RDLCK) {
782 lockType |= LOCKING_ANDX_SHARED_LOCK;
784 } else if (pfLock->fl_type == F_EXLCK) {
787 } else if (pfLock->fl_type == 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;
990 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
991 *poffset, file->f_path.dentry->d_name.name); */
993 if (file->private_data == NULL)
995 open_file = (struct cifsFileInfo *) file->private_data;
997 rc = generic_write_checks(file, poffset, &write_size, 0);
1003 long_op = cifs_write_timeout(cifsi, *poffset);
1004 for (total_written = 0; write_size > total_written;
1005 total_written += bytes_written) {
1007 while (rc == -EAGAIN) {
1008 if (file->private_data == NULL) {
1009 /* file has been closed on us */
1011 /* if we have gotten here we have written some data
1012 and blocked, and the file has been freed on us while
1013 we blocked so return what we managed to write */
1014 return total_written;
1016 if (open_file->closePend) {
1019 return total_written;
1023 if (open_file->invalidHandle) {
1024 /* we could deadlock if we called
1025 filemap_fdatawait from here so tell
1026 reopen_file not to flush data to server
1028 rc = cifs_reopen_file(file, false);
1033 rc = CIFSSMBWrite(xid, pTcon,
1035 min_t(const int, cifs_sb->wsize,
1036 write_size - total_written),
1037 *poffset, &bytes_written,
1038 NULL, write_data + total_written, long_op);
1040 if (rc || (bytes_written == 0)) {
1048 cifs_update_eof(cifsi, *poffset, bytes_written);
1049 *poffset += bytes_written;
1051 long_op = CIFS_STD_OP; /* subsequent writes fast -
1052 15 seconds is plenty */
1055 cifs_stats_bytes_written(pTcon, total_written);
1057 /* since the write may have blocked check these pointers again */
1058 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1059 struct inode *inode = file->f_path.dentry->d_inode;
1060 /* Do not update local mtime - server will set its actual value on write
1061 * inode->i_ctime = inode->i_mtime =
1062 * current_fs_time(inode->i_sb);*/
1063 if (total_written > 0) {
1064 spin_lock(&inode->i_lock);
1065 if (*poffset > file->f_path.dentry->d_inode->i_size)
1066 i_size_write(file->f_path.dentry->d_inode,
1068 spin_unlock(&inode->i_lock);
1070 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1073 return total_written;
1076 static ssize_t cifs_write(struct file *file, const char *write_data,
1077 size_t write_size, loff_t *poffset)
1080 unsigned int bytes_written = 0;
1081 unsigned int total_written;
1082 struct cifs_sb_info *cifs_sb;
1083 struct cifsTconInfo *pTcon;
1085 struct cifsFileInfo *open_file;
1086 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1088 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1090 pTcon = cifs_sb->tcon;
1092 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1093 *poffset, file->f_path.dentry->d_name.name);
1095 if (file->private_data == NULL)
1097 open_file = (struct cifsFileInfo *)file->private_data;
1101 long_op = cifs_write_timeout(cifsi, *poffset);
1102 for (total_written = 0; write_size > total_written;
1103 total_written += bytes_written) {
1105 while (rc == -EAGAIN) {
1106 if (file->private_data == NULL) {
1107 /* file has been closed on us */
1109 /* if we have gotten here we have written some data
1110 and blocked, and the file has been freed on us
1111 while we blocked so return what we managed to
1113 return total_written;
1115 if (open_file->closePend) {
1118 return total_written;
1122 if (open_file->invalidHandle) {
1123 /* we could deadlock if we called
1124 filemap_fdatawait from here so tell
1125 reopen_file not to flush data to
1127 rc = cifs_reopen_file(file, false);
1131 if (experimEnabled || (pTcon->ses->server &&
1132 ((pTcon->ses->server->secMode &
1133 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1138 len = min((size_t)cifs_sb->wsize,
1139 write_size - total_written);
1140 /* iov[0] is reserved for smb header */
1141 iov[1].iov_base = (char *)write_data +
1143 iov[1].iov_len = len;
1144 rc = CIFSSMBWrite2(xid, pTcon,
1145 open_file->netfid, len,
1146 *poffset, &bytes_written,
1149 rc = CIFSSMBWrite(xid, pTcon,
1151 min_t(const int, cifs_sb->wsize,
1152 write_size - total_written),
1153 *poffset, &bytes_written,
1154 write_data + total_written,
1157 if (rc || (bytes_written == 0)) {
1165 cifs_update_eof(cifsi, *poffset, bytes_written);
1166 *poffset += bytes_written;
1168 long_op = CIFS_STD_OP; /* subsequent writes fast -
1169 15 seconds is plenty */
1172 cifs_stats_bytes_written(pTcon, total_written);
1174 /* since the write may have blocked check these pointers again */
1175 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1176 /*BB We could make this contingent on superblock ATIME flag too */
1177 /* file->f_path.dentry->d_inode->i_ctime =
1178 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1179 if (total_written > 0) {
1180 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1181 if (*poffset > file->f_path.dentry->d_inode->i_size)
1182 i_size_write(file->f_path.dentry->d_inode,
1184 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1186 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1189 return total_written;
1192 #ifdef CONFIG_CIFS_EXPERIMENTAL
1193 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1195 struct cifsFileInfo *open_file = NULL;
1197 read_lock(&GlobalSMBSeslock);
1198 /* we could simply get the first_list_entry since write-only entries
1199 are always at the end of the list but since the first entry might
1200 have a close pending, we go through the whole list */
1201 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1202 if (open_file->closePend)
1204 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1205 (open_file->pfile->f_flags & O_RDONLY))) {
1206 if (!open_file->invalidHandle) {
1207 /* found a good file */
1208 /* lock it so it will not be closed on us */
1209 cifsFileInfo_get(open_file);
1210 read_unlock(&GlobalSMBSeslock);
1212 } /* else might as well continue, and look for
1213 another, or simply have the caller reopen it
1214 again rather than trying to fix this handle */
1215 } else /* write only file */
1216 break; /* write only files are last so must be done */
1218 read_unlock(&GlobalSMBSeslock);
1223 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1225 struct cifsFileInfo *open_file;
1226 bool any_available = false;
1229 /* Having a null inode here (because mapping->host was set to zero by
1230 the VFS or MM) should not happen but we had reports of on oops (due to
1231 it being zero) during stress testcases so we need to check for it */
1233 if (cifs_inode == NULL) {
1234 cERROR(1, "Null inode passed to cifs_writeable_file");
1239 read_lock(&GlobalSMBSeslock);
1241 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1242 if (open_file->closePend ||
1243 (!any_available && open_file->pid != current->tgid))
1246 if (open_file->pfile &&
1247 ((open_file->pfile->f_flags & O_RDWR) ||
1248 (open_file->pfile->f_flags & O_WRONLY))) {
1249 cifsFileInfo_get(open_file);
1251 if (!open_file->invalidHandle) {
1252 /* found a good writable file */
1253 read_unlock(&GlobalSMBSeslock);
1257 read_unlock(&GlobalSMBSeslock);
1258 /* Had to unlock since following call can block */
1259 rc = cifs_reopen_file(open_file->pfile, false);
1261 if (!open_file->closePend)
1263 else { /* start over in case this was deleted */
1264 /* since the list could be modified */
1265 read_lock(&GlobalSMBSeslock);
1266 cifsFileInfo_put(open_file);
1267 goto refind_writable;
1271 /* if it fails, try another handle if possible -
1272 (we can not do this if closePending since
1273 loop could be modified - in which case we
1274 have to start at the beginning of the list
1275 again. Note that it would be bad
1276 to hold up writepages here (rather than
1277 in caller) with continuous retries */
1278 cFYI(1, "wp failed on reopen file");
1279 read_lock(&GlobalSMBSeslock);
1280 /* can not use this handle, no write
1281 pending on this one after all */
1282 cifsFileInfo_put(open_file);
1284 if (open_file->closePend) /* list could have changed */
1285 goto refind_writable;
1286 /* else we simply continue to the next entry. Thus
1287 we do not loop on reopen errors. If we
1288 can not reopen the file, for example if we
1289 reconnected to a server with another client
1290 racing to delete or lock the file we would not
1291 make progress if we restarted before the beginning
1292 of the loop here. */
1295 /* couldn't find useable FH with same pid, try any available */
1296 if (!any_available) {
1297 any_available = true;
1298 goto refind_writable;
1300 read_unlock(&GlobalSMBSeslock);
1304 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1306 struct address_space *mapping = page->mapping;
1307 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1310 int bytes_written = 0;
1311 struct cifs_sb_info *cifs_sb;
1312 struct cifsTconInfo *pTcon;
1313 struct inode *inode;
1314 struct cifsFileInfo *open_file;
1316 if (!mapping || !mapping->host)
1319 inode = page->mapping->host;
1320 cifs_sb = CIFS_SB(inode->i_sb);
1321 pTcon = cifs_sb->tcon;
1323 offset += (loff_t)from;
1324 write_data = kmap(page);
1327 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1332 /* racing with truncate? */
1333 if (offset > mapping->host->i_size) {
1335 return 0; /* don't care */
1338 /* check to make sure that we are not extending the file */
1339 if (mapping->host->i_size - offset < (loff_t)to)
1340 to = (unsigned)(mapping->host->i_size - offset);
1342 open_file = find_writable_file(CIFS_I(mapping->host));
1344 bytes_written = cifs_write(open_file->pfile, write_data,
1346 cifsFileInfo_put(open_file);
1347 /* Does mm or vfs already set times? */
1348 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1349 if ((bytes_written > 0) && (offset))
1351 else if (bytes_written < 0)
1354 cFYI(1, "No writeable filehandles for inode");
1362 static int cifs_writepages(struct address_space *mapping,
1363 struct writeback_control *wbc)
1365 struct backing_dev_info *bdi = mapping->backing_dev_info;
1366 unsigned int bytes_to_write;
1367 unsigned int bytes_written;
1368 struct cifs_sb_info *cifs_sb;
1372 int range_whole = 0;
1379 struct cifsFileInfo *open_file;
1380 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1382 struct pagevec pvec;
1387 cifs_sb = CIFS_SB(mapping->host->i_sb);
1390 * If wsize is smaller that the page cache size, default to writing
1391 * one page at a time via cifs_writepage
1393 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1394 return generic_writepages(mapping, wbc);
1396 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1397 if (cifs_sb->tcon->ses->server->secMode &
1398 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1399 if (!experimEnabled)
1400 return generic_writepages(mapping, wbc);
1402 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1404 return generic_writepages(mapping, wbc);
1408 * BB: Is this meaningful for a non-block-device file system?
1409 * If it is, we should test it again after we do I/O
1411 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1412 wbc->encountered_congestion = 1;
1419 pagevec_init(&pvec, 0);
1420 if (wbc->range_cyclic) {
1421 index = mapping->writeback_index; /* Start from prev offset */
1424 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1425 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1426 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1431 while (!done && (index <= end) &&
1432 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1433 PAGECACHE_TAG_DIRTY,
1434 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1443 for (i = 0; i < nr_pages; i++) {
1444 page = pvec.pages[i];
1446 * At this point we hold neither mapping->tree_lock nor
1447 * lock on the page itself: the page may be truncated or
1448 * invalidated (changing page->mapping to NULL), or even
1449 * swizzled back from swapper_space to tmpfs file
1455 else if (!trylock_page(page))
1458 if (unlikely(page->mapping != mapping)) {
1463 if (!wbc->range_cyclic && page->index > end) {
1469 if (next && (page->index != next)) {
1470 /* Not next consecutive page */
1475 if (wbc->sync_mode != WB_SYNC_NONE)
1476 wait_on_page_writeback(page);
1478 if (PageWriteback(page) ||
1479 !clear_page_dirty_for_io(page)) {
1485 * This actually clears the dirty bit in the radix tree.
1486 * See cifs_writepage() for more commentary.
1488 set_page_writeback(page);
1490 if (page_offset(page) >= mapping->host->i_size) {
1493 end_page_writeback(page);
1498 * BB can we get rid of this? pages are held by pvec
1500 page_cache_get(page);
1502 len = min(mapping->host->i_size - page_offset(page),
1503 (loff_t)PAGE_CACHE_SIZE);
1505 /* reserve iov[0] for the smb header */
1507 iov[n_iov].iov_base = kmap(page);
1508 iov[n_iov].iov_len = len;
1509 bytes_to_write += len;
1513 offset = page_offset(page);
1515 next = page->index + 1;
1516 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1520 /* Search for a writable handle every time we call
1521 * CIFSSMBWrite2. We can't rely on the last handle
1522 * we used to still be valid
1524 open_file = find_writable_file(CIFS_I(mapping->host));
1526 cERROR(1, "No writable handles for inode");
1529 long_op = cifs_write_timeout(cifsi, offset);
1530 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1532 bytes_to_write, offset,
1533 &bytes_written, iov, n_iov,
1535 cifsFileInfo_put(open_file);
1536 cifs_update_eof(cifsi, offset, bytes_written);
1538 if (rc || bytes_written < bytes_to_write) {
1539 cERROR(1, "Write2 ret %d, wrote %d",
1541 /* BB what if continued retry is
1542 requested via mount flags? */
1544 set_bit(AS_ENOSPC, &mapping->flags);
1546 set_bit(AS_EIO, &mapping->flags);
1548 cifs_stats_bytes_written(cifs_sb->tcon,
1552 for (i = 0; i < n_iov; i++) {
1553 page = pvec.pages[first + i];
1554 /* Should we also set page error on
1555 success rc but too little data written? */
1556 /* BB investigate retry logic on temporary
1557 server crash cases and how recovery works
1558 when page marked as error */
1563 end_page_writeback(page);
1564 page_cache_release(page);
1566 if ((wbc->nr_to_write -= n_iov) <= 0)
1570 /* Need to re-find the pages we skipped */
1571 index = pvec.pages[0]->index + 1;
1573 pagevec_release(&pvec);
1575 if (!scanned && !done) {
1577 * We hit the last page and there is more work to be done: wrap
1578 * back to the start of the file
1584 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1585 mapping->writeback_index = index;
1592 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1598 /* BB add check for wbc flags */
1599 page_cache_get(page);
1600 if (!PageUptodate(page))
1601 cFYI(1, "ppw - page not up to date");
1604 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1606 * A writepage() implementation always needs to do either this,
1607 * or re-dirty the page with "redirty_page_for_writepage()" in
1608 * the case of a failure.
1610 * Just unlocking the page will cause the radix tree tag-bits
1611 * to fail to update with the state of the page correctly.
1613 set_page_writeback(page);
1614 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1615 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1617 end_page_writeback(page);
1618 page_cache_release(page);
1623 static int cifs_write_end(struct file *file, struct address_space *mapping,
1624 loff_t pos, unsigned len, unsigned copied,
1625 struct page *page, void *fsdata)
1628 struct inode *inode = mapping->host;
1630 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1633 if (PageChecked(page)) {
1635 SetPageUptodate(page);
1636 ClearPageChecked(page);
1637 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1638 SetPageUptodate(page);
1640 if (!PageUptodate(page)) {
1642 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1646 /* this is probably better than directly calling
1647 partialpage_write since in this function the file handle is
1648 known which we might as well leverage */
1649 /* BB check if anything else missing out of ppw
1650 such as updating last write time */
1651 page_data = kmap(page);
1652 rc = cifs_write(file, page_data + offset, copied, &pos);
1653 /* if (rc < 0) should we set writebehind rc? */
1660 set_page_dirty(page);
1664 spin_lock(&inode->i_lock);
1665 if (pos > inode->i_size)
1666 i_size_write(inode, pos);
1667 spin_unlock(&inode->i_lock);
1671 page_cache_release(page);
1676 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1680 struct cifsTconInfo *tcon;
1681 struct cifsFileInfo *smbfile =
1682 (struct cifsFileInfo *)file->private_data;
1683 struct inode *inode = file->f_path.dentry->d_inode;
1687 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1688 dentry->d_name.name, datasync);
1690 rc = filemap_write_and_wait(inode->i_mapping);
1692 rc = CIFS_I(inode)->write_behind_rc;
1693 CIFS_I(inode)->write_behind_rc = 0;
1694 tcon = CIFS_SB(inode->i_sb)->tcon;
1695 if (!rc && tcon && smbfile &&
1696 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1697 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1704 /* static void cifs_sync_page(struct page *page)
1706 struct address_space *mapping;
1707 struct inode *inode;
1708 unsigned long index = page->index;
1709 unsigned int rpages = 0;
1712 cFYI(1, "sync page %p",page);
1713 mapping = page->mapping;
1716 inode = mapping->host;
1720 /* fill in rpages then
1721 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1723 /* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1733 * As file closes, flush all cached write data for this inode checking
1734 * for write behind errors.
1736 int cifs_flush(struct file *file, fl_owner_t id)
1738 struct inode *inode = file->f_path.dentry->d_inode;
1741 /* Rather than do the steps manually:
1742 lock the inode for writing
1743 loop through pages looking for write behind data (dirty pages)
1744 coalesce into contiguous 16K (or smaller) chunks to write to server
1745 send to server (prefer in parallel)
1746 deal with writebehind errors
1747 unlock inode for writing
1748 filemapfdatawrite appears easier for the time being */
1750 rc = filemap_fdatawrite(inode->i_mapping);
1751 /* reset wb rc if we were able to write out dirty pages */
1753 rc = CIFS_I(inode)->write_behind_rc;
1754 CIFS_I(inode)->write_behind_rc = 0;
1757 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1762 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1763 size_t read_size, loff_t *poffset)
1766 unsigned int bytes_read = 0;
1767 unsigned int total_read = 0;
1768 unsigned int current_read_size;
1769 struct cifs_sb_info *cifs_sb;
1770 struct cifsTconInfo *pTcon;
1772 struct cifsFileInfo *open_file;
1773 char *smb_read_data;
1774 char __user *current_offset;
1775 struct smb_com_read_rsp *pSMBr;
1778 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1779 pTcon = cifs_sb->tcon;
1781 if (file->private_data == NULL) {
1786 open_file = (struct cifsFileInfo *)file->private_data;
1788 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1789 cFYI(1, "attempting read on write only file instance");
1791 for (total_read = 0, current_offset = read_data;
1792 read_size > total_read;
1793 total_read += bytes_read, current_offset += bytes_read) {
1794 current_read_size = min_t(const int, read_size - total_read,
1797 smb_read_data = NULL;
1798 while (rc == -EAGAIN) {
1799 int buf_type = CIFS_NO_BUFFER;
1800 if ((open_file->invalidHandle) &&
1801 (!open_file->closePend)) {
1802 rc = cifs_reopen_file(file, true);
1806 rc = CIFSSMBRead(xid, pTcon,
1808 current_read_size, *poffset,
1809 &bytes_read, &smb_read_data,
1811 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1812 if (smb_read_data) {
1813 if (copy_to_user(current_offset,
1815 4 /* RFC1001 length field */ +
1816 le16_to_cpu(pSMBr->DataOffset),
1820 if (buf_type == CIFS_SMALL_BUFFER)
1821 cifs_small_buf_release(smb_read_data);
1822 else if (buf_type == CIFS_LARGE_BUFFER)
1823 cifs_buf_release(smb_read_data);
1824 smb_read_data = NULL;
1827 if (rc || (bytes_read == 0)) {
1835 cifs_stats_bytes_read(pTcon, bytes_read);
1836 *poffset += bytes_read;
1844 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1848 unsigned int bytes_read = 0;
1849 unsigned int total_read;
1850 unsigned int current_read_size;
1851 struct cifs_sb_info *cifs_sb;
1852 struct cifsTconInfo *pTcon;
1854 char *current_offset;
1855 struct cifsFileInfo *open_file;
1856 int buf_type = CIFS_NO_BUFFER;
1859 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1860 pTcon = cifs_sb->tcon;
1862 if (file->private_data == NULL) {
1867 open_file = (struct cifsFileInfo *)file->private_data;
1869 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1870 cFYI(1, "attempting read on write only file instance");
1872 for (total_read = 0, current_offset = read_data;
1873 read_size > total_read;
1874 total_read += bytes_read, current_offset += bytes_read) {
1875 current_read_size = min_t(const int, read_size - total_read,
1877 /* For windows me and 9x we do not want to request more
1878 than it negotiated since it will refuse the read then */
1880 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1881 current_read_size = min_t(const int, current_read_size,
1882 pTcon->ses->server->maxBuf - 128);
1885 while (rc == -EAGAIN) {
1886 if ((open_file->invalidHandle) &&
1887 (!open_file->closePend)) {
1888 rc = cifs_reopen_file(file, true);
1892 rc = CIFSSMBRead(xid, pTcon,
1894 current_read_size, *poffset,
1895 &bytes_read, ¤t_offset,
1898 if (rc || (bytes_read == 0)) {
1906 cifs_stats_bytes_read(pTcon, total_read);
1907 *poffset += bytes_read;
1914 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1919 rc = cifs_revalidate_file(file);
1921 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1925 rc = generic_file_mmap(file, vma);
1931 static void cifs_copy_cache_pages(struct address_space *mapping,
1932 struct list_head *pages, int bytes_read, char *data)
1937 while (bytes_read > 0) {
1938 if (list_empty(pages))
1941 page = list_entry(pages->prev, struct page, lru);
1942 list_del(&page->lru);
1944 if (add_to_page_cache_lru(page, mapping, page->index,
1946 page_cache_release(page);
1947 cFYI(1, "Add page cache failed");
1948 data += PAGE_CACHE_SIZE;
1949 bytes_read -= PAGE_CACHE_SIZE;
1953 target = kmap_atomic(page, KM_USER0);
1955 if (PAGE_CACHE_SIZE > bytes_read) {
1956 memcpy(target, data, bytes_read);
1957 /* zero the tail end of this partial page */
1958 memset(target + bytes_read, 0,
1959 PAGE_CACHE_SIZE - bytes_read);
1962 memcpy(target, data, PAGE_CACHE_SIZE);
1963 bytes_read -= PAGE_CACHE_SIZE;
1965 kunmap_atomic(target, KM_USER0);
1967 flush_dcache_page(page);
1968 SetPageUptodate(page);
1970 data += PAGE_CACHE_SIZE;
1975 static int cifs_readpages(struct file *file, struct address_space *mapping,
1976 struct list_head *page_list, unsigned num_pages)
1982 struct cifs_sb_info *cifs_sb;
1983 struct cifsTconInfo *pTcon;
1984 unsigned int bytes_read = 0;
1985 unsigned int read_size, i;
1986 char *smb_read_data = NULL;
1987 struct smb_com_read_rsp *pSMBr;
1988 struct cifsFileInfo *open_file;
1989 int buf_type = CIFS_NO_BUFFER;
1992 if (file->private_data == NULL) {
1997 open_file = (struct cifsFileInfo *)file->private_data;
1998 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1999 pTcon = cifs_sb->tcon;
2001 cFYI(DBG2, ("rpages: num pages %d", num_pages));
2002 for (i = 0; i < num_pages; ) {
2003 unsigned contig_pages;
2004 struct page *tmp_page;
2005 unsigned long expected_index;
2007 if (list_empty(page_list))
2010 page = list_entry(page_list->prev, struct page, lru);
2011 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2013 /* count adjacent pages that we will read into */
2016 list_entry(page_list->prev, struct page, lru)->index;
2017 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2018 if (tmp_page->index == expected_index) {
2024 if (contig_pages + i > num_pages)
2025 contig_pages = num_pages - i;
2027 /* for reads over a certain size could initiate async
2030 read_size = contig_pages * PAGE_CACHE_SIZE;
2031 /* Read size needs to be in multiples of one page */
2032 read_size = min_t(const unsigned int, read_size,
2033 cifs_sb->rsize & PAGE_CACHE_MASK);
2034 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
2035 read_size, contig_pages);
2037 while (rc == -EAGAIN) {
2038 if ((open_file->invalidHandle) &&
2039 (!open_file->closePend)) {
2040 rc = cifs_reopen_file(file, true);
2045 rc = CIFSSMBRead(xid, pTcon,
2048 &bytes_read, &smb_read_data,
2050 /* BB more RC checks ? */
2051 if (rc == -EAGAIN) {
2052 if (smb_read_data) {
2053 if (buf_type == CIFS_SMALL_BUFFER)
2054 cifs_small_buf_release(smb_read_data);
2055 else if (buf_type == CIFS_LARGE_BUFFER)
2056 cifs_buf_release(smb_read_data);
2057 smb_read_data = NULL;
2061 if ((rc < 0) || (smb_read_data == NULL)) {
2062 cFYI(1, "Read error in readpages: %d", rc);
2064 } else if (bytes_read > 0) {
2065 task_io_account_read(bytes_read);
2066 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2067 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2068 smb_read_data + 4 /* RFC1001 hdr */ +
2069 le16_to_cpu(pSMBr->DataOffset));
2071 i += bytes_read >> PAGE_CACHE_SHIFT;
2072 cifs_stats_bytes_read(pTcon, bytes_read);
2073 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2074 i++; /* account for partial page */
2076 /* server copy of file can have smaller size
2078 /* BB do we need to verify this common case ?
2079 this case is ok - if we are at server EOF
2080 we will hit it on next read */
2085 cFYI(1, "No bytes read (%d) at offset %lld . "
2086 "Cleaning remaining pages from readahead list",
2087 bytes_read, offset);
2088 /* BB turn off caching and do new lookup on
2089 file size at server? */
2092 if (smb_read_data) {
2093 if (buf_type == CIFS_SMALL_BUFFER)
2094 cifs_small_buf_release(smb_read_data);
2095 else if (buf_type == CIFS_LARGE_BUFFER)
2096 cifs_buf_release(smb_read_data);
2097 smb_read_data = NULL;
2102 /* need to free smb_read_data buf before exit */
2103 if (smb_read_data) {
2104 if (buf_type == CIFS_SMALL_BUFFER)
2105 cifs_small_buf_release(smb_read_data);
2106 else if (buf_type == CIFS_LARGE_BUFFER)
2107 cifs_buf_release(smb_read_data);
2108 smb_read_data = NULL;
2115 static int cifs_readpage_worker(struct file *file, struct page *page,
2121 page_cache_get(page);
2122 read_data = kmap(page);
2123 /* for reads over a certain size could initiate async read ahead */
2125 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2130 cFYI(1, "Bytes read %d", rc);
2132 file->f_path.dentry->d_inode->i_atime =
2133 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2135 if (PAGE_CACHE_SIZE > rc)
2136 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2138 flush_dcache_page(page);
2139 SetPageUptodate(page);
2144 page_cache_release(page);
2148 static int cifs_readpage(struct file *file, struct page *page)
2150 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2156 if (file->private_data == NULL) {
2162 cFYI(1, "readpage %p at offset %d 0x%x\n",
2163 page, (int)offset, (int)offset);
2165 rc = cifs_readpage_worker(file, page, &offset);
2173 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2175 struct cifsFileInfo *open_file;
2177 read_lock(&GlobalSMBSeslock);
2178 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2179 if (open_file->closePend)
2181 if (open_file->pfile &&
2182 ((open_file->pfile->f_flags & O_RDWR) ||
2183 (open_file->pfile->f_flags & O_WRONLY))) {
2184 read_unlock(&GlobalSMBSeslock);
2188 read_unlock(&GlobalSMBSeslock);
2192 /* We do not want to update the file size from server for inodes
2193 open for write - to avoid races with writepage extending
2194 the file - in the future we could consider allowing
2195 refreshing the inode only on increases in the file size
2196 but this is tricky to do without racing with writebehind
2197 page caching in the current Linux kernel design */
2198 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2203 if (is_inode_writable(cifsInode)) {
2204 /* This inode is open for write at least once */
2205 struct cifs_sb_info *cifs_sb;
2207 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2208 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2209 /* since no page cache to corrupt on directio
2210 we can change size safely */
2214 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2222 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2223 loff_t pos, unsigned len, unsigned flags,
2224 struct page **pagep, void **fsdata)
2226 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2227 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2228 loff_t page_start = pos & PAGE_MASK;
2233 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2235 page = grab_cache_page_write_begin(mapping, index, flags);
2241 if (PageUptodate(page))
2245 * If we write a full page it will be up to date, no need to read from
2246 * the server. If the write is short, we'll end up doing a sync write
2249 if (len == PAGE_CACHE_SIZE)
2253 * optimize away the read when we have an oplock, and we're not
2254 * expecting to use any of the data we'd be reading in. That
2255 * is, when the page lies beyond the EOF, or straddles the EOF
2256 * and the write will cover all of the existing data.
2258 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2259 i_size = i_size_read(mapping->host);
2260 if (page_start >= i_size ||
2261 (offset == 0 && (pos + len) >= i_size)) {
2262 zero_user_segments(page, 0, offset,
2266 * PageChecked means that the parts of the page
2267 * to which we're not writing are considered up
2268 * to date. Once the data is copied to the
2269 * page, it can be set uptodate.
2271 SetPageChecked(page);
2276 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2278 * might as well read a page, it is fast enough. If we get
2279 * an error, we don't need to return it. cifs_write_end will
2280 * do a sync write instead since PG_uptodate isn't set.
2282 cifs_readpage_worker(file, page, &page_start);
2284 /* we could try using another file handle if there is one -
2285 but how would we lock it to prevent close of that handle
2286 racing with this read? In any case
2287 this will be written out by write_end so is fine */
2295 cifs_oplock_break(struct slow_work *work)
2297 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2299 struct inode *inode = cfile->pInode;
2300 struct cifsInodeInfo *cinode = CIFS_I(inode);
2301 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->mnt->mnt_sb);
2304 if (inode && S_ISREG(inode->i_mode)) {
2305 #ifdef CONFIG_CIFS_EXPERIMENTAL
2306 if (cinode->clientCanCacheAll == 0)
2307 break_lease(inode, O_RDONLY);
2308 else if (cinode->clientCanCacheRead == 0)
2309 break_lease(inode, O_WRONLY);
2311 rc = filemap_fdatawrite(inode->i_mapping);
2312 if (cinode->clientCanCacheRead == 0) {
2313 waitrc = filemap_fdatawait(inode->i_mapping);
2314 invalidate_remote_inode(inode);
2319 cinode->write_behind_rc = rc;
2320 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2324 * releasing stale oplock after recent reconnect of smb session using
2325 * a now incorrect file handle is not a data integrity issue but do
2326 * not bother sending an oplock release if session to server still is
2327 * disconnected since oplock already released by the server
2329 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2330 rc = CIFSSMBLock(0, cifs_sb->tcon, cfile->netfid, 0, 0, 0, 0,
2331 LOCKING_ANDX_OPLOCK_RELEASE, false);
2332 cFYI(1, "Oplock release rc = %d", rc);
2337 cifs_oplock_break_get(struct slow_work *work)
2339 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2342 cifsFileInfo_get(cfile);
2347 cifs_oplock_break_put(struct slow_work *work)
2349 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2352 cifsFileInfo_put(cfile);
2355 const struct slow_work_ops cifs_oplock_break_ops = {
2356 .get_ref = cifs_oplock_break_get,
2357 .put_ref = cifs_oplock_break_put,
2358 .execute = cifs_oplock_break,
2361 const struct address_space_operations cifs_addr_ops = {
2362 .readpage = cifs_readpage,
2363 .readpages = cifs_readpages,
2364 .writepage = cifs_writepage,
2365 .writepages = cifs_writepages,
2366 .write_begin = cifs_write_begin,
2367 .write_end = cifs_write_end,
2368 .set_page_dirty = __set_page_dirty_nobuffers,
2369 /* .sync_page = cifs_sync_page, */
2374 * cifs_readpages requires the server to support a buffer large enough to
2375 * contain the header plus one complete page of data. Otherwise, we need
2376 * to leave cifs_readpages out of the address space operations.
2378 const struct address_space_operations cifs_addr_ops_smallbuf = {
2379 .readpage = cifs_readpage,
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 /* .sync_page = cifs_sync_page, */