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
623 ("close delay, write pending"));
627 if (!pTcon->need_reconnect &&
628 !pSMBFile->invalidHandle)
629 rc = CIFSSMBClose(xid, pTcon,
632 write_unlock(&GlobalSMBSeslock);
634 write_unlock(&GlobalSMBSeslock);
636 /* Delete any outstanding lock records.
637 We'll lose them when the file is closed anyway. */
638 mutex_lock(&pSMBFile->lock_mutex);
639 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
640 list_del(&li->llist);
643 mutex_unlock(&pSMBFile->lock_mutex);
645 write_lock(&GlobalSMBSeslock);
646 list_del(&pSMBFile->flist);
647 list_del(&pSMBFile->tlist);
648 write_unlock(&GlobalSMBSeslock);
649 cifsFileInfo_put(file->private_data);
650 file->private_data = NULL;
654 read_lock(&GlobalSMBSeslock);
655 if (list_empty(&(CIFS_I(inode)->openFileList))) {
656 cFYI(1, ("closing last open instance for inode %p", inode));
657 /* if the file is not open we do not know if we can cache info
658 on this inode, much less write behind and read ahead */
659 CIFS_I(inode)->clientCanCacheRead = false;
660 CIFS_I(inode)->clientCanCacheAll = false;
662 read_unlock(&GlobalSMBSeslock);
663 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
664 rc = CIFS_I(inode)->write_behind_rc;
669 int cifs_closedir(struct inode *inode, struct file *file)
673 struct cifsFileInfo *pCFileStruct =
674 (struct cifsFileInfo *)file->private_data;
677 cFYI(1, ("Closedir inode = 0x%p", inode));
682 struct cifsTconInfo *pTcon;
683 struct cifs_sb_info *cifs_sb =
684 CIFS_SB(file->f_path.dentry->d_sb);
686 pTcon = cifs_sb->tcon;
688 cFYI(1, ("Freeing private data in close dir"));
689 write_lock(&GlobalSMBSeslock);
690 if (!pCFileStruct->srch_inf.endOfSearch &&
691 !pCFileStruct->invalidHandle) {
692 pCFileStruct->invalidHandle = true;
693 write_unlock(&GlobalSMBSeslock);
694 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
695 cFYI(1, ("Closing uncompleted readdir with rc %d",
697 /* not much we can do if it fails anyway, ignore rc */
700 write_unlock(&GlobalSMBSeslock);
701 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
703 cFYI(1, ("closedir free smb buf in srch struct"));
704 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
705 if (pCFileStruct->srch_inf.smallBuf)
706 cifs_small_buf_release(ptmp);
708 cifs_buf_release(ptmp);
710 kfree(file->private_data);
711 file->private_data = NULL;
713 /* BB can we lock the filestruct while this is going on? */
718 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
719 __u64 offset, __u8 lockType)
721 struct cifsLockInfo *li =
722 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
728 mutex_lock(&fid->lock_mutex);
729 list_add(&li->llist, &fid->llist);
730 mutex_unlock(&fid->lock_mutex);
734 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
740 bool wait_flag = false;
741 struct cifs_sb_info *cifs_sb;
742 struct cifsTconInfo *tcon;
744 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
745 bool posix_locking = 0;
747 length = 1 + pfLock->fl_end - pfLock->fl_start;
751 cFYI(1, ("Lock parm: 0x%x flockflags: "
752 "0x%x flocktype: 0x%x start: %lld end: %lld",
753 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
756 if (pfLock->fl_flags & FL_POSIX)
758 if (pfLock->fl_flags & FL_FLOCK)
760 if (pfLock->fl_flags & FL_SLEEP) {
761 cFYI(1, ("Blocking lock"));
764 if (pfLock->fl_flags & FL_ACCESS)
765 cFYI(1, ("Process suspended by mandatory locking - "
766 "not implemented yet"));
767 if (pfLock->fl_flags & FL_LEASE)
768 cFYI(1, ("Lease on file - not implemented yet"));
769 if (pfLock->fl_flags &
770 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
771 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
773 if (pfLock->fl_type == F_WRLCK) {
774 cFYI(1, ("F_WRLCK "));
776 } else if (pfLock->fl_type == F_UNLCK) {
777 cFYI(1, ("F_UNLCK"));
779 /* Check if unlock includes more than
781 } else if (pfLock->fl_type == F_RDLCK) {
782 cFYI(1, ("F_RDLCK"));
783 lockType |= LOCKING_ANDX_SHARED_LOCK;
785 } else if (pfLock->fl_type == F_EXLCK) {
786 cFYI(1, ("F_EXLCK"));
788 } else if (pfLock->fl_type == F_SHLCK) {
789 cFYI(1, ("F_SHLCK"));
790 lockType |= LOCKING_ANDX_SHARED_LOCK;
793 cFYI(1, ("Unknown type of lock"));
795 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
796 tcon = cifs_sb->tcon;
798 if (file->private_data == NULL) {
803 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
805 if ((tcon->ses->capabilities & CAP_UNIX) &&
806 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
807 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
809 /* BB add code here to normalize offset and length to
810 account for negative length which we can not accept over the
815 if (lockType & LOCKING_ANDX_SHARED_LOCK)
816 posix_lock_type = CIFS_RDLCK;
818 posix_lock_type = CIFS_WRLCK;
819 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
821 posix_lock_type, wait_flag);
826 /* BB we could chain these into one lock request BB */
827 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
828 0, 1, lockType, 0 /* wait flag */ );
830 rc = CIFSSMBLock(xid, tcon, netfid, length,
831 pfLock->fl_start, 1 /* numUnlock */ ,
832 0 /* numLock */ , lockType,
834 pfLock->fl_type = F_UNLCK;
836 cERROR(1, ("Error unlocking previously locked "
837 "range %d during test of lock", rc));
841 /* if rc == ERR_SHARING_VIOLATION ? */
842 rc = 0; /* do not change lock type to unlock
843 since range in use */
850 if (!numLock && !numUnlock) {
851 /* if no lock or unlock then nothing
852 to do since we do not know what it is */
859 if (lockType & LOCKING_ANDX_SHARED_LOCK)
860 posix_lock_type = CIFS_RDLCK;
862 posix_lock_type = CIFS_WRLCK;
865 posix_lock_type = CIFS_UNLCK;
867 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
869 posix_lock_type, wait_flag);
871 struct cifsFileInfo *fid =
872 (struct cifsFileInfo *)file->private_data;
875 rc = CIFSSMBLock(xid, tcon, netfid, length,
877 0, numLock, lockType, wait_flag);
880 /* For Windows locks we must store them. */
881 rc = store_file_lock(fid, length,
882 pfLock->fl_start, lockType);
884 } else if (numUnlock) {
885 /* For each stored lock that this unlock overlaps
886 completely, unlock it. */
888 struct cifsLockInfo *li, *tmp;
891 mutex_lock(&fid->lock_mutex);
892 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
893 if (pfLock->fl_start <= li->offset &&
894 (pfLock->fl_start + length) >=
895 (li->offset + li->length)) {
896 stored_rc = CIFSSMBLock(xid, tcon,
898 li->length, li->offset,
899 1, 0, li->type, false);
903 list_del(&li->llist);
907 mutex_unlock(&fid->lock_mutex);
911 if (pfLock->fl_flags & FL_POSIX)
912 posix_lock_file_wait(file, pfLock);
918 * Set the timeout on write requests past EOF. For some servers (Windows)
919 * these calls can be very long.
921 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
922 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
923 * The 10M cutoff is totally arbitrary. A better scheme for this would be
924 * welcome if someone wants to suggest one.
926 * We may be able to do a better job with this if there were some way to
927 * declare that a file should be sparse.
930 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
932 if (offset <= cifsi->server_eof)
934 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
935 return CIFS_VLONG_OP;
940 /* update the file size (if needed) after a write */
942 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
943 unsigned int bytes_written)
945 loff_t end_of_write = offset + bytes_written;
947 if (end_of_write > cifsi->server_eof)
948 cifsi->server_eof = end_of_write;
951 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
952 size_t write_size, loff_t *poffset)
955 unsigned int bytes_written = 0;
956 unsigned int total_written;
957 struct cifs_sb_info *cifs_sb;
958 struct cifsTconInfo *pTcon;
960 struct cifsFileInfo *open_file;
961 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
963 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
965 pTcon = cifs_sb->tcon;
968 (" write %d bytes to offset %lld of %s", write_size,
969 *poffset, file->f_path.dentry->d_name.name)); */
971 if (file->private_data == NULL)
973 open_file = (struct cifsFileInfo *) file->private_data;
975 rc = generic_write_checks(file, poffset, &write_size, 0);
981 long_op = cifs_write_timeout(cifsi, *poffset);
982 for (total_written = 0; write_size > total_written;
983 total_written += bytes_written) {
985 while (rc == -EAGAIN) {
986 if (file->private_data == NULL) {
987 /* file has been closed on us */
989 /* if we have gotten here we have written some data
990 and blocked, and the file has been freed on us while
991 we blocked so return what we managed to write */
992 return total_written;
994 if (open_file->closePend) {
997 return total_written;
1001 if (open_file->invalidHandle) {
1002 /* we could deadlock if we called
1003 filemap_fdatawait from here so tell
1004 reopen_file not to flush data to server
1006 rc = cifs_reopen_file(file, false);
1011 rc = CIFSSMBWrite(xid, pTcon,
1013 min_t(const int, cifs_sb->wsize,
1014 write_size - total_written),
1015 *poffset, &bytes_written,
1016 NULL, write_data + total_written, long_op);
1018 if (rc || (bytes_written == 0)) {
1026 cifs_update_eof(cifsi, *poffset, bytes_written);
1027 *poffset += bytes_written;
1029 long_op = CIFS_STD_OP; /* subsequent writes fast -
1030 15 seconds is plenty */
1033 cifs_stats_bytes_written(pTcon, total_written);
1035 /* since the write may have blocked check these pointers again */
1036 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1037 struct inode *inode = file->f_path.dentry->d_inode;
1038 /* Do not update local mtime - server will set its actual value on write
1039 * inode->i_ctime = inode->i_mtime =
1040 * current_fs_time(inode->i_sb);*/
1041 if (total_written > 0) {
1042 spin_lock(&inode->i_lock);
1043 if (*poffset > file->f_path.dentry->d_inode->i_size)
1044 i_size_write(file->f_path.dentry->d_inode,
1046 spin_unlock(&inode->i_lock);
1048 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1051 return total_written;
1054 static ssize_t cifs_write(struct file *file, const char *write_data,
1055 size_t write_size, loff_t *poffset)
1058 unsigned int bytes_written = 0;
1059 unsigned int total_written;
1060 struct cifs_sb_info *cifs_sb;
1061 struct cifsTconInfo *pTcon;
1063 struct cifsFileInfo *open_file;
1064 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1066 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1068 pTcon = cifs_sb->tcon;
1070 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
1071 *poffset, file->f_path.dentry->d_name.name));
1073 if (file->private_data == NULL)
1075 open_file = (struct cifsFileInfo *)file->private_data;
1079 long_op = cifs_write_timeout(cifsi, *poffset);
1080 for (total_written = 0; write_size > total_written;
1081 total_written += bytes_written) {
1083 while (rc == -EAGAIN) {
1084 if (file->private_data == NULL) {
1085 /* file has been closed on us */
1087 /* if we have gotten here we have written some data
1088 and blocked, and the file has been freed on us
1089 while we blocked so return what we managed to
1091 return total_written;
1093 if (open_file->closePend) {
1096 return total_written;
1100 if (open_file->invalidHandle) {
1101 /* we could deadlock if we called
1102 filemap_fdatawait from here so tell
1103 reopen_file not to flush data to
1105 rc = cifs_reopen_file(file, false);
1109 if (experimEnabled || (pTcon->ses->server &&
1110 ((pTcon->ses->server->secMode &
1111 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1116 len = min((size_t)cifs_sb->wsize,
1117 write_size - total_written);
1118 /* iov[0] is reserved for smb header */
1119 iov[1].iov_base = (char *)write_data +
1121 iov[1].iov_len = len;
1122 rc = CIFSSMBWrite2(xid, pTcon,
1123 open_file->netfid, len,
1124 *poffset, &bytes_written,
1127 rc = CIFSSMBWrite(xid, pTcon,
1129 min_t(const int, cifs_sb->wsize,
1130 write_size - total_written),
1131 *poffset, &bytes_written,
1132 write_data + total_written,
1135 if (rc || (bytes_written == 0)) {
1143 cifs_update_eof(cifsi, *poffset, bytes_written);
1144 *poffset += bytes_written;
1146 long_op = CIFS_STD_OP; /* subsequent writes fast -
1147 15 seconds is plenty */
1150 cifs_stats_bytes_written(pTcon, total_written);
1152 /* since the write may have blocked check these pointers again */
1153 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1154 /*BB We could make this contingent on superblock ATIME flag too */
1155 /* file->f_path.dentry->d_inode->i_ctime =
1156 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1157 if (total_written > 0) {
1158 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1159 if (*poffset > file->f_path.dentry->d_inode->i_size)
1160 i_size_write(file->f_path.dentry->d_inode,
1162 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1164 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1167 return total_written;
1170 #ifdef CONFIG_CIFS_EXPERIMENTAL
1171 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1173 struct cifsFileInfo *open_file = NULL;
1175 read_lock(&GlobalSMBSeslock);
1176 /* we could simply get the first_list_entry since write-only entries
1177 are always at the end of the list but since the first entry might
1178 have a close pending, we go through the whole list */
1179 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1180 if (open_file->closePend)
1182 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1183 (open_file->pfile->f_flags & O_RDONLY))) {
1184 if (!open_file->invalidHandle) {
1185 /* found a good file */
1186 /* lock it so it will not be closed on us */
1187 cifsFileInfo_get(open_file);
1188 read_unlock(&GlobalSMBSeslock);
1190 } /* else might as well continue, and look for
1191 another, or simply have the caller reopen it
1192 again rather than trying to fix this handle */
1193 } else /* write only file */
1194 break; /* write only files are last so must be done */
1196 read_unlock(&GlobalSMBSeslock);
1201 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1203 struct cifsFileInfo *open_file;
1204 bool any_available = false;
1207 /* Having a null inode here (because mapping->host was set to zero by
1208 the VFS or MM) should not happen but we had reports of on oops (due to
1209 it being zero) during stress testcases so we need to check for it */
1211 if (cifs_inode == NULL) {
1212 cERROR(1, ("Null inode passed to cifs_writeable_file"));
1217 read_lock(&GlobalSMBSeslock);
1219 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1220 if (open_file->closePend ||
1221 (!any_available && open_file->pid != current->tgid))
1224 if (open_file->pfile &&
1225 ((open_file->pfile->f_flags & O_RDWR) ||
1226 (open_file->pfile->f_flags & O_WRONLY))) {
1227 cifsFileInfo_get(open_file);
1229 if (!open_file->invalidHandle) {
1230 /* found a good writable file */
1231 read_unlock(&GlobalSMBSeslock);
1235 read_unlock(&GlobalSMBSeslock);
1236 /* Had to unlock since following call can block */
1237 rc = cifs_reopen_file(open_file->pfile, false);
1239 if (!open_file->closePend)
1241 else { /* start over in case this was deleted */
1242 /* since the list could be modified */
1243 read_lock(&GlobalSMBSeslock);
1244 cifsFileInfo_put(open_file);
1245 goto refind_writable;
1249 /* if it fails, try another handle if possible -
1250 (we can not do this if closePending since
1251 loop could be modified - in which case we
1252 have to start at the beginning of the list
1253 again. Note that it would be bad
1254 to hold up writepages here (rather than
1255 in caller) with continuous retries */
1256 cFYI(1, ("wp failed on reopen file"));
1257 read_lock(&GlobalSMBSeslock);
1258 /* can not use this handle, no write
1259 pending on this one after all */
1260 cifsFileInfo_put(open_file);
1262 if (open_file->closePend) /* list could have changed */
1263 goto refind_writable;
1264 /* else we simply continue to the next entry. Thus
1265 we do not loop on reopen errors. If we
1266 can not reopen the file, for example if we
1267 reconnected to a server with another client
1268 racing to delete or lock the file we would not
1269 make progress if we restarted before the beginning
1270 of the loop here. */
1273 /* couldn't find useable FH with same pid, try any available */
1274 if (!any_available) {
1275 any_available = true;
1276 goto refind_writable;
1278 read_unlock(&GlobalSMBSeslock);
1282 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1284 struct address_space *mapping = page->mapping;
1285 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1288 int bytes_written = 0;
1289 struct cifs_sb_info *cifs_sb;
1290 struct cifsTconInfo *pTcon;
1291 struct inode *inode;
1292 struct cifsFileInfo *open_file;
1294 if (!mapping || !mapping->host)
1297 inode = page->mapping->host;
1298 cifs_sb = CIFS_SB(inode->i_sb);
1299 pTcon = cifs_sb->tcon;
1301 offset += (loff_t)from;
1302 write_data = kmap(page);
1305 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1310 /* racing with truncate? */
1311 if (offset > mapping->host->i_size) {
1313 return 0; /* don't care */
1316 /* check to make sure that we are not extending the file */
1317 if (mapping->host->i_size - offset < (loff_t)to)
1318 to = (unsigned)(mapping->host->i_size - offset);
1320 open_file = find_writable_file(CIFS_I(mapping->host));
1322 bytes_written = cifs_write(open_file->pfile, write_data,
1324 cifsFileInfo_put(open_file);
1325 /* Does mm or vfs already set times? */
1326 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1327 if ((bytes_written > 0) && (offset))
1329 else if (bytes_written < 0)
1332 cFYI(1, ("No writeable filehandles for inode"));
1340 static int cifs_writepages(struct address_space *mapping,
1341 struct writeback_control *wbc)
1343 struct backing_dev_info *bdi = mapping->backing_dev_info;
1344 unsigned int bytes_to_write;
1345 unsigned int bytes_written;
1346 struct cifs_sb_info *cifs_sb;
1350 int range_whole = 0;
1357 struct cifsFileInfo *open_file;
1358 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1360 struct pagevec pvec;
1365 cifs_sb = CIFS_SB(mapping->host->i_sb);
1368 * If wsize is smaller that the page cache size, default to writing
1369 * one page at a time via cifs_writepage
1371 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1372 return generic_writepages(mapping, wbc);
1374 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1375 if (cifs_sb->tcon->ses->server->secMode &
1376 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1377 if (!experimEnabled)
1378 return generic_writepages(mapping, wbc);
1380 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1382 return generic_writepages(mapping, wbc);
1386 * BB: Is this meaningful for a non-block-device file system?
1387 * If it is, we should test it again after we do I/O
1389 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1390 wbc->encountered_congestion = 1;
1397 pagevec_init(&pvec, 0);
1398 if (wbc->range_cyclic) {
1399 index = mapping->writeback_index; /* Start from prev offset */
1402 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1403 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1404 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1409 while (!done && (index <= end) &&
1410 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1411 PAGECACHE_TAG_DIRTY,
1412 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1421 for (i = 0; i < nr_pages; i++) {
1422 page = pvec.pages[i];
1424 * At this point we hold neither mapping->tree_lock nor
1425 * lock on the page itself: the page may be truncated or
1426 * invalidated (changing page->mapping to NULL), or even
1427 * swizzled back from swapper_space to tmpfs file
1433 else if (!trylock_page(page))
1436 if (unlikely(page->mapping != mapping)) {
1441 if (!wbc->range_cyclic && page->index > end) {
1447 if (next && (page->index != next)) {
1448 /* Not next consecutive page */
1453 if (wbc->sync_mode != WB_SYNC_NONE)
1454 wait_on_page_writeback(page);
1456 if (PageWriteback(page) ||
1457 !clear_page_dirty_for_io(page)) {
1463 * This actually clears the dirty bit in the radix tree.
1464 * See cifs_writepage() for more commentary.
1466 set_page_writeback(page);
1468 if (page_offset(page) >= mapping->host->i_size) {
1471 end_page_writeback(page);
1476 * BB can we get rid of this? pages are held by pvec
1478 page_cache_get(page);
1480 len = min(mapping->host->i_size - page_offset(page),
1481 (loff_t)PAGE_CACHE_SIZE);
1483 /* reserve iov[0] for the smb header */
1485 iov[n_iov].iov_base = kmap(page);
1486 iov[n_iov].iov_len = len;
1487 bytes_to_write += len;
1491 offset = page_offset(page);
1493 next = page->index + 1;
1494 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1498 /* Search for a writable handle every time we call
1499 * CIFSSMBWrite2. We can't rely on the last handle
1500 * we used to still be valid
1502 open_file = find_writable_file(CIFS_I(mapping->host));
1504 cERROR(1, ("No writable handles for inode"));
1507 long_op = cifs_write_timeout(cifsi, offset);
1508 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1510 bytes_to_write, offset,
1511 &bytes_written, iov, n_iov,
1513 cifsFileInfo_put(open_file);
1514 cifs_update_eof(cifsi, offset, bytes_written);
1516 if (rc || bytes_written < bytes_to_write) {
1517 cERROR(1, ("Write2 ret %d, wrote %d",
1518 rc, bytes_written));
1519 /* BB what if continued retry is
1520 requested via mount flags? */
1522 set_bit(AS_ENOSPC, &mapping->flags);
1524 set_bit(AS_EIO, &mapping->flags);
1526 cifs_stats_bytes_written(cifs_sb->tcon,
1530 for (i = 0; i < n_iov; i++) {
1531 page = pvec.pages[first + i];
1532 /* Should we also set page error on
1533 success rc but too little data written? */
1534 /* BB investigate retry logic on temporary
1535 server crash cases and how recovery works
1536 when page marked as error */
1541 end_page_writeback(page);
1542 page_cache_release(page);
1544 if ((wbc->nr_to_write -= n_iov) <= 0)
1548 /* Need to re-find the pages we skipped */
1549 index = pvec.pages[0]->index + 1;
1551 pagevec_release(&pvec);
1553 if (!scanned && !done) {
1555 * We hit the last page and there is more work to be done: wrap
1556 * back to the start of the file
1562 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1563 mapping->writeback_index = index;
1570 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1576 /* BB add check for wbc flags */
1577 page_cache_get(page);
1578 if (!PageUptodate(page))
1579 cFYI(1, ("ppw - page not up to date"));
1582 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1584 * A writepage() implementation always needs to do either this,
1585 * or re-dirty the page with "redirty_page_for_writepage()" in
1586 * the case of a failure.
1588 * Just unlocking the page will cause the radix tree tag-bits
1589 * to fail to update with the state of the page correctly.
1591 set_page_writeback(page);
1592 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1593 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1595 end_page_writeback(page);
1596 page_cache_release(page);
1601 static int cifs_write_end(struct file *file, struct address_space *mapping,
1602 loff_t pos, unsigned len, unsigned copied,
1603 struct page *page, void *fsdata)
1606 struct inode *inode = mapping->host;
1608 cFYI(1, ("write_end for page %p from pos %lld with %d bytes",
1609 page, pos, copied));
1611 if (PageChecked(page)) {
1613 SetPageUptodate(page);
1614 ClearPageChecked(page);
1615 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1616 SetPageUptodate(page);
1618 if (!PageUptodate(page)) {
1620 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1624 /* this is probably better than directly calling
1625 partialpage_write since in this function the file handle is
1626 known which we might as well leverage */
1627 /* BB check if anything else missing out of ppw
1628 such as updating last write time */
1629 page_data = kmap(page);
1630 rc = cifs_write(file, page_data + offset, copied, &pos);
1631 /* if (rc < 0) should we set writebehind rc? */
1638 set_page_dirty(page);
1642 spin_lock(&inode->i_lock);
1643 if (pos > inode->i_size)
1644 i_size_write(inode, pos);
1645 spin_unlock(&inode->i_lock);
1649 page_cache_release(page);
1654 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1658 struct cifsTconInfo *tcon;
1659 struct cifsFileInfo *smbfile =
1660 (struct cifsFileInfo *)file->private_data;
1661 struct inode *inode = file->f_path.dentry->d_inode;
1665 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
1666 dentry->d_name.name, datasync));
1668 rc = filemap_write_and_wait(inode->i_mapping);
1670 rc = CIFS_I(inode)->write_behind_rc;
1671 CIFS_I(inode)->write_behind_rc = 0;
1672 tcon = CIFS_SB(inode->i_sb)->tcon;
1673 if (!rc && tcon && smbfile &&
1674 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1675 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1682 /* static void cifs_sync_page(struct page *page)
1684 struct address_space *mapping;
1685 struct inode *inode;
1686 unsigned long index = page->index;
1687 unsigned int rpages = 0;
1690 cFYI(1, ("sync page %p",page));
1691 mapping = page->mapping;
1694 inode = mapping->host;
1698 /* fill in rpages then
1699 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1701 /* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
1711 * As file closes, flush all cached write data for this inode checking
1712 * for write behind errors.
1714 int cifs_flush(struct file *file, fl_owner_t id)
1716 struct inode *inode = file->f_path.dentry->d_inode;
1719 /* Rather than do the steps manually:
1720 lock the inode for writing
1721 loop through pages looking for write behind data (dirty pages)
1722 coalesce into contiguous 16K (or smaller) chunks to write to server
1723 send to server (prefer in parallel)
1724 deal with writebehind errors
1725 unlock inode for writing
1726 filemapfdatawrite appears easier for the time being */
1728 rc = filemap_fdatawrite(inode->i_mapping);
1729 /* reset wb rc if we were able to write out dirty pages */
1731 rc = CIFS_I(inode)->write_behind_rc;
1732 CIFS_I(inode)->write_behind_rc = 0;
1735 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
1740 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1741 size_t read_size, loff_t *poffset)
1744 unsigned int bytes_read = 0;
1745 unsigned int total_read = 0;
1746 unsigned int current_read_size;
1747 struct cifs_sb_info *cifs_sb;
1748 struct cifsTconInfo *pTcon;
1750 struct cifsFileInfo *open_file;
1751 char *smb_read_data;
1752 char __user *current_offset;
1753 struct smb_com_read_rsp *pSMBr;
1756 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1757 pTcon = cifs_sb->tcon;
1759 if (file->private_data == NULL) {
1764 open_file = (struct cifsFileInfo *)file->private_data;
1766 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1767 cFYI(1, ("attempting read on write only file instance"));
1769 for (total_read = 0, current_offset = read_data;
1770 read_size > total_read;
1771 total_read += bytes_read, current_offset += bytes_read) {
1772 current_read_size = min_t(const int, read_size - total_read,
1775 smb_read_data = NULL;
1776 while (rc == -EAGAIN) {
1777 int buf_type = CIFS_NO_BUFFER;
1778 if ((open_file->invalidHandle) &&
1779 (!open_file->closePend)) {
1780 rc = cifs_reopen_file(file, true);
1784 rc = CIFSSMBRead(xid, pTcon,
1786 current_read_size, *poffset,
1787 &bytes_read, &smb_read_data,
1789 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1790 if (smb_read_data) {
1791 if (copy_to_user(current_offset,
1793 4 /* RFC1001 length field */ +
1794 le16_to_cpu(pSMBr->DataOffset),
1798 if (buf_type == CIFS_SMALL_BUFFER)
1799 cifs_small_buf_release(smb_read_data);
1800 else if (buf_type == CIFS_LARGE_BUFFER)
1801 cifs_buf_release(smb_read_data);
1802 smb_read_data = NULL;
1805 if (rc || (bytes_read == 0)) {
1813 cifs_stats_bytes_read(pTcon, bytes_read);
1814 *poffset += bytes_read;
1822 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1826 unsigned int bytes_read = 0;
1827 unsigned int total_read;
1828 unsigned int current_read_size;
1829 struct cifs_sb_info *cifs_sb;
1830 struct cifsTconInfo *pTcon;
1832 char *current_offset;
1833 struct cifsFileInfo *open_file;
1834 int buf_type = CIFS_NO_BUFFER;
1837 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1838 pTcon = cifs_sb->tcon;
1840 if (file->private_data == NULL) {
1845 open_file = (struct cifsFileInfo *)file->private_data;
1847 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1848 cFYI(1, ("attempting read on write only file instance"));
1850 for (total_read = 0, current_offset = read_data;
1851 read_size > total_read;
1852 total_read += bytes_read, current_offset += bytes_read) {
1853 current_read_size = min_t(const int, read_size - total_read,
1855 /* For windows me and 9x we do not want to request more
1856 than it negotiated since it will refuse the read then */
1858 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1859 current_read_size = min_t(const int, current_read_size,
1860 pTcon->ses->server->maxBuf - 128);
1863 while (rc == -EAGAIN) {
1864 if ((open_file->invalidHandle) &&
1865 (!open_file->closePend)) {
1866 rc = cifs_reopen_file(file, true);
1870 rc = CIFSSMBRead(xid, pTcon,
1872 current_read_size, *poffset,
1873 &bytes_read, ¤t_offset,
1876 if (rc || (bytes_read == 0)) {
1884 cifs_stats_bytes_read(pTcon, total_read);
1885 *poffset += bytes_read;
1892 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1897 rc = cifs_revalidate_file(file);
1899 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1903 rc = generic_file_mmap(file, vma);
1909 static void cifs_copy_cache_pages(struct address_space *mapping,
1910 struct list_head *pages, int bytes_read, char *data,
1911 struct pagevec *plru_pvec)
1916 while (bytes_read > 0) {
1917 if (list_empty(pages))
1920 page = list_entry(pages->prev, struct page, lru);
1921 list_del(&page->lru);
1923 if (add_to_page_cache(page, mapping, page->index,
1925 page_cache_release(page);
1926 cFYI(1, ("Add page cache failed"));
1927 data += PAGE_CACHE_SIZE;
1928 bytes_read -= PAGE_CACHE_SIZE;
1932 target = kmap_atomic(page, KM_USER0);
1934 if (PAGE_CACHE_SIZE > bytes_read) {
1935 memcpy(target, data, bytes_read);
1936 /* zero the tail end of this partial page */
1937 memset(target + bytes_read, 0,
1938 PAGE_CACHE_SIZE - bytes_read);
1941 memcpy(target, data, PAGE_CACHE_SIZE);
1942 bytes_read -= PAGE_CACHE_SIZE;
1944 kunmap_atomic(target, KM_USER0);
1946 flush_dcache_page(page);
1947 SetPageUptodate(page);
1949 if (!pagevec_add(plru_pvec, page))
1950 __pagevec_lru_add_file(plru_pvec);
1951 data += PAGE_CACHE_SIZE;
1956 static int cifs_readpages(struct file *file, struct address_space *mapping,
1957 struct list_head *page_list, unsigned num_pages)
1963 struct cifs_sb_info *cifs_sb;
1964 struct cifsTconInfo *pTcon;
1965 unsigned int bytes_read = 0;
1966 unsigned int read_size, i;
1967 char *smb_read_data = NULL;
1968 struct smb_com_read_rsp *pSMBr;
1969 struct pagevec lru_pvec;
1970 struct cifsFileInfo *open_file;
1971 int buf_type = CIFS_NO_BUFFER;
1974 if (file->private_data == NULL) {
1979 open_file = (struct cifsFileInfo *)file->private_data;
1980 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1981 pTcon = cifs_sb->tcon;
1983 pagevec_init(&lru_pvec, 0);
1984 cFYI(DBG2, ("rpages: num pages %d", num_pages));
1985 for (i = 0; i < num_pages; ) {
1986 unsigned contig_pages;
1987 struct page *tmp_page;
1988 unsigned long expected_index;
1990 if (list_empty(page_list))
1993 page = list_entry(page_list->prev, struct page, lru);
1994 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1996 /* count adjacent pages that we will read into */
1999 list_entry(page_list->prev, struct page, lru)->index;
2000 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2001 if (tmp_page->index == expected_index) {
2007 if (contig_pages + i > num_pages)
2008 contig_pages = num_pages - i;
2010 /* for reads over a certain size could initiate async
2013 read_size = contig_pages * PAGE_CACHE_SIZE;
2014 /* Read size needs to be in multiples of one page */
2015 read_size = min_t(const unsigned int, read_size,
2016 cifs_sb->rsize & PAGE_CACHE_MASK);
2017 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
2018 read_size, contig_pages));
2020 while (rc == -EAGAIN) {
2021 if ((open_file->invalidHandle) &&
2022 (!open_file->closePend)) {
2023 rc = cifs_reopen_file(file, true);
2028 rc = CIFSSMBRead(xid, pTcon,
2031 &bytes_read, &smb_read_data,
2033 /* BB more RC checks ? */
2034 if (rc == -EAGAIN) {
2035 if (smb_read_data) {
2036 if (buf_type == CIFS_SMALL_BUFFER)
2037 cifs_small_buf_release(smb_read_data);
2038 else if (buf_type == CIFS_LARGE_BUFFER)
2039 cifs_buf_release(smb_read_data);
2040 smb_read_data = NULL;
2044 if ((rc < 0) || (smb_read_data == NULL)) {
2045 cFYI(1, ("Read error in readpages: %d", rc));
2047 } else if (bytes_read > 0) {
2048 task_io_account_read(bytes_read);
2049 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2050 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2051 smb_read_data + 4 /* RFC1001 hdr */ +
2052 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
2054 i += bytes_read >> PAGE_CACHE_SHIFT;
2055 cifs_stats_bytes_read(pTcon, bytes_read);
2056 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2057 i++; /* account for partial page */
2059 /* server copy of file can have smaller size
2061 /* BB do we need to verify this common case ?
2062 this case is ok - if we are at server EOF
2063 we will hit it on next read */
2068 cFYI(1, ("No bytes read (%d) at offset %lld . "
2069 "Cleaning remaining pages from readahead list",
2070 bytes_read, offset));
2071 /* BB turn off caching and do new lookup on
2072 file size at server? */
2075 if (smb_read_data) {
2076 if (buf_type == CIFS_SMALL_BUFFER)
2077 cifs_small_buf_release(smb_read_data);
2078 else if (buf_type == CIFS_LARGE_BUFFER)
2079 cifs_buf_release(smb_read_data);
2080 smb_read_data = NULL;
2085 pagevec_lru_add_file(&lru_pvec);
2087 /* need to free smb_read_data buf before exit */
2088 if (smb_read_data) {
2089 if (buf_type == CIFS_SMALL_BUFFER)
2090 cifs_small_buf_release(smb_read_data);
2091 else if (buf_type == CIFS_LARGE_BUFFER)
2092 cifs_buf_release(smb_read_data);
2093 smb_read_data = NULL;
2100 static int cifs_readpage_worker(struct file *file, struct page *page,
2106 page_cache_get(page);
2107 read_data = kmap(page);
2108 /* for reads over a certain size could initiate async read ahead */
2110 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2115 cFYI(1, ("Bytes read %d", rc));
2117 file->f_path.dentry->d_inode->i_atime =
2118 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2120 if (PAGE_CACHE_SIZE > rc)
2121 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2123 flush_dcache_page(page);
2124 SetPageUptodate(page);
2129 page_cache_release(page);
2133 static int cifs_readpage(struct file *file, struct page *page)
2135 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2141 if (file->private_data == NULL) {
2147 cFYI(1, ("readpage %p at offset %d 0x%x\n",
2148 page, (int)offset, (int)offset));
2150 rc = cifs_readpage_worker(file, page, &offset);
2158 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2160 struct cifsFileInfo *open_file;
2162 read_lock(&GlobalSMBSeslock);
2163 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2164 if (open_file->closePend)
2166 if (open_file->pfile &&
2167 ((open_file->pfile->f_flags & O_RDWR) ||
2168 (open_file->pfile->f_flags & O_WRONLY))) {
2169 read_unlock(&GlobalSMBSeslock);
2173 read_unlock(&GlobalSMBSeslock);
2177 /* We do not want to update the file size from server for inodes
2178 open for write - to avoid races with writepage extending
2179 the file - in the future we could consider allowing
2180 refreshing the inode only on increases in the file size
2181 but this is tricky to do without racing with writebehind
2182 page caching in the current Linux kernel design */
2183 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2188 if (is_inode_writable(cifsInode)) {
2189 /* This inode is open for write at least once */
2190 struct cifs_sb_info *cifs_sb;
2192 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2193 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2194 /* since no page cache to corrupt on directio
2195 we can change size safely */
2199 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2207 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2208 loff_t pos, unsigned len, unsigned flags,
2209 struct page **pagep, void **fsdata)
2211 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2212 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2213 loff_t page_start = pos & PAGE_MASK;
2218 cFYI(1, ("write_begin from %lld len %d", (long long)pos, len));
2220 page = grab_cache_page_write_begin(mapping, index, flags);
2226 if (PageUptodate(page))
2230 * If we write a full page it will be up to date, no need to read from
2231 * the server. If the write is short, we'll end up doing a sync write
2234 if (len == PAGE_CACHE_SIZE)
2238 * optimize away the read when we have an oplock, and we're not
2239 * expecting to use any of the data we'd be reading in. That
2240 * is, when the page lies beyond the EOF, or straddles the EOF
2241 * and the write will cover all of the existing data.
2243 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2244 i_size = i_size_read(mapping->host);
2245 if (page_start >= i_size ||
2246 (offset == 0 && (pos + len) >= i_size)) {
2247 zero_user_segments(page, 0, offset,
2251 * PageChecked means that the parts of the page
2252 * to which we're not writing are considered up
2253 * to date. Once the data is copied to the
2254 * page, it can be set uptodate.
2256 SetPageChecked(page);
2261 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2263 * might as well read a page, it is fast enough. If we get
2264 * an error, we don't need to return it. cifs_write_end will
2265 * do a sync write instead since PG_uptodate isn't set.
2267 cifs_readpage_worker(file, page, &page_start);
2269 /* we could try using another file handle if there is one -
2270 but how would we lock it to prevent close of that handle
2271 racing with this read? In any case
2272 this will be written out by write_end so is fine */
2280 cifs_oplock_break(struct slow_work *work)
2282 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2284 struct inode *inode = cfile->pInode;
2285 struct cifsInodeInfo *cinode = CIFS_I(inode);
2286 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->mnt->mnt_sb);
2289 if (inode && S_ISREG(inode->i_mode)) {
2290 #ifdef CONFIG_CIFS_EXPERIMENTAL
2291 if (cinode->clientCanCacheAll == 0)
2292 break_lease(inode, O_RDONLY);
2293 else if (cinode->clientCanCacheRead == 0)
2294 break_lease(inode, O_WRONLY);
2296 rc = filemap_fdatawrite(inode->i_mapping);
2297 if (cinode->clientCanCacheRead == 0) {
2298 waitrc = filemap_fdatawait(inode->i_mapping);
2299 invalidate_remote_inode(inode);
2304 cinode->write_behind_rc = rc;
2305 cFYI(1, ("Oplock flush inode %p rc %d", inode, rc));
2309 * releasing stale oplock after recent reconnect of smb session using
2310 * a now incorrect file handle is not a data integrity issue but do
2311 * not bother sending an oplock release if session to server still is
2312 * disconnected since oplock already released by the server
2314 if (!cfile->closePend && !cfile->oplock_break_cancelled) {
2315 rc = CIFSSMBLock(0, cifs_sb->tcon, cfile->netfid, 0, 0, 0, 0,
2316 LOCKING_ANDX_OPLOCK_RELEASE, false);
2317 cFYI(1, ("Oplock release rc = %d", rc));
2322 cifs_oplock_break_get(struct slow_work *work)
2324 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2327 cifsFileInfo_get(cfile);
2332 cifs_oplock_break_put(struct slow_work *work)
2334 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2337 cifsFileInfo_put(cfile);
2340 const struct slow_work_ops cifs_oplock_break_ops = {
2341 .get_ref = cifs_oplock_break_get,
2342 .put_ref = cifs_oplock_break_put,
2343 .execute = cifs_oplock_break,
2346 const struct address_space_operations cifs_addr_ops = {
2347 .readpage = cifs_readpage,
2348 .readpages = cifs_readpages,
2349 .writepage = cifs_writepage,
2350 .writepages = cifs_writepages,
2351 .write_begin = cifs_write_begin,
2352 .write_end = cifs_write_end,
2353 .set_page_dirty = __set_page_dirty_nobuffers,
2354 /* .sync_page = cifs_sync_page, */
2359 * cifs_readpages requires the server to support a buffer large enough to
2360 * contain the header plus one complete page of data. Otherwise, we need
2361 * to leave cifs_readpages out of the address space operations.
2363 const struct address_space_operations cifs_addr_ops_smallbuf = {
2364 .readpage = cifs_readpage,
2365 .writepage = cifs_writepage,
2366 .writepages = cifs_writepages,
2367 .write_begin = cifs_write_begin,
2368 .write_end = cifs_write_end,
2369 .set_page_dirty = __set_page_dirty_nobuffers,
2370 /* .sync_page = cifs_sync_page, */