4 * vfs operations that deal with files
6 * Copyright (C) International Business Machines Corp., 2002,2010
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 * Jeremy Allison (jra@samba.org)
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/writeback.h>
31 #include <linux/task_io_accounting_ops.h>
32 #include <linux/delay.h>
33 #include <linux/mount.h>
34 #include <linux/slab.h>
35 #include <asm/div64.h>
39 #include "cifsproto.h"
40 #include "cifs_unicode.h"
41 #include "cifs_debug.h"
42 #include "cifs_fs_sb.h"
45 static inline int cifs_convert_flags(unsigned int flags)
47 if ((flags & O_ACCMODE) == O_RDONLY)
49 else if ((flags & O_ACCMODE) == O_WRONLY)
51 else if ((flags & O_ACCMODE) == O_RDWR) {
52 /* GENERIC_ALL is too much permission to request
53 can cause unnecessary access denied on create */
54 /* return GENERIC_ALL; */
55 return (GENERIC_READ | GENERIC_WRITE);
58 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
59 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
63 static u32 cifs_posix_convert_flags(unsigned int flags)
67 if ((flags & O_ACCMODE) == O_RDONLY)
68 posix_flags = SMB_O_RDONLY;
69 else if ((flags & O_ACCMODE) == O_WRONLY)
70 posix_flags = SMB_O_WRONLY;
71 else if ((flags & O_ACCMODE) == O_RDWR)
72 posix_flags = SMB_O_RDWR;
75 posix_flags |= SMB_O_CREAT;
77 posix_flags |= SMB_O_EXCL;
79 posix_flags |= SMB_O_TRUNC;
80 /* be safe and imply O_SYNC for O_DSYNC */
82 posix_flags |= SMB_O_SYNC;
83 if (flags & O_DIRECTORY)
84 posix_flags |= SMB_O_DIRECTORY;
85 if (flags & O_NOFOLLOW)
86 posix_flags |= SMB_O_NOFOLLOW;
88 posix_flags |= SMB_O_DIRECT;
93 static inline int cifs_get_disposition(unsigned int flags)
95 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
97 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
98 return FILE_OVERWRITE_IF;
99 else if ((flags & O_CREAT) == O_CREAT)
101 else if ((flags & O_TRUNC) == O_TRUNC)
102 return FILE_OVERWRITE;
107 static inline int cifs_open_inode_helper(struct inode *inode,
108 struct cifsTconInfo *pTcon, __u32 oplock, FILE_ALL_INFO *buf,
109 char *full_path, int xid)
111 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
112 struct timespec temp;
115 if (pCifsInode->clientCanCacheRead) {
116 /* we have the inode open somewhere else
117 no need to discard cache data */
118 goto client_can_cache;
121 /* BB need same check in cifs_create too? */
122 /* if not oplocked, invalidate inode pages if mtime or file
124 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
125 if (timespec_equal(&inode->i_mtime, &temp) &&
127 (loff_t)le64_to_cpu(buf->EndOfFile))) {
128 cFYI(1, "inode unchanged on server");
130 if (inode->i_mapping) {
131 /* BB no need to lock inode until after invalidate
132 since namei code should already have it locked? */
133 rc = filemap_write_and_wait(inode->i_mapping);
134 mapping_set_error(inode->i_mapping, rc);
136 cFYI(1, "invalidating remote inode since open detected it "
138 invalidate_remote_inode(inode);
143 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
146 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
149 cifs_set_oplock_level(pCifsInode, oplock);
154 int cifs_posix_open(char *full_path, struct inode **pinode,
155 struct super_block *sb, int mode, unsigned int f_flags,
156 __u32 *poplock, __u16 *pnetfid, int xid)
159 FILE_UNIX_BASIC_INFO *presp_data;
160 __u32 posix_flags = 0;
161 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
162 struct cifs_fattr fattr;
163 struct tcon_link *tlink;
164 struct cifsTconInfo *tcon;
166 cFYI(1, "posix open %s", full_path);
168 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
169 if (presp_data == NULL)
172 tlink = cifs_sb_tlink(cifs_sb);
178 tcon = tlink_tcon(tlink);
179 mode &= ~current_umask();
181 posix_flags = cifs_posix_convert_flags(f_flags);
182 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
183 poplock, full_path, cifs_sb->local_nls,
184 cifs_sb->mnt_cifs_flags &
185 CIFS_MOUNT_MAP_SPECIAL_CHR);
186 cifs_put_tlink(tlink);
191 if (presp_data->Type == cpu_to_le32(-1))
192 goto posix_open_ret; /* open ok, caller does qpathinfo */
195 goto posix_open_ret; /* caller does not need info */
197 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
199 /* get new inode and set it up */
200 if (*pinode == NULL) {
201 cifs_fill_uniqueid(sb, &fattr);
202 *pinode = cifs_iget(sb, &fattr);
208 cifs_fattr_to_inode(*pinode, &fattr);
216 struct cifsFileInfo *
217 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
218 struct tcon_link *tlink, __u32 oplock)
220 struct dentry *dentry = file->f_path.dentry;
221 struct inode *inode = dentry->d_inode;
222 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
223 struct cifsFileInfo *pCifsFile;
225 pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
226 if (pCifsFile == NULL)
229 pCifsFile->count = 1;
230 pCifsFile->netfid = fileHandle;
231 pCifsFile->pid = current->tgid;
232 pCifsFile->uid = current_fsuid();
233 pCifsFile->dentry = dget(dentry);
234 pCifsFile->f_flags = file->f_flags;
235 pCifsFile->invalidHandle = false;
236 pCifsFile->tlink = cifs_get_tlink(tlink);
237 mutex_init(&pCifsFile->fh_mutex);
238 mutex_init(&pCifsFile->lock_mutex);
239 INIT_LIST_HEAD(&pCifsFile->llist);
240 INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
242 spin_lock(&cifs_file_list_lock);
243 list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
244 /* if readable file instance put first in list*/
245 if (file->f_mode & FMODE_READ)
246 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
248 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
249 spin_unlock(&cifs_file_list_lock);
251 cifs_set_oplock_level(pCifsInode, oplock);
253 file->private_data = pCifsFile;
258 * Release a reference on the file private data. This may involve closing
259 * the filehandle out on the server. Must be called without holding
260 * cifs_file_list_lock.
262 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
264 struct inode *inode = cifs_file->dentry->d_inode;
265 struct cifsTconInfo *tcon = tlink_tcon(cifs_file->tlink);
266 struct cifsInodeInfo *cifsi = CIFS_I(inode);
267 struct cifsLockInfo *li, *tmp;
269 spin_lock(&cifs_file_list_lock);
270 if (--cifs_file->count > 0) {
271 spin_unlock(&cifs_file_list_lock);
275 /* remove it from the lists */
276 list_del(&cifs_file->flist);
277 list_del(&cifs_file->tlist);
279 if (list_empty(&cifsi->openFileList)) {
280 cFYI(1, "closing last open instance for inode %p",
281 cifs_file->dentry->d_inode);
282 cifs_set_oplock_level(cifsi, 0);
284 spin_unlock(&cifs_file_list_lock);
286 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
290 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
294 /* Delete any outstanding lock records. We'll lose them when the file
297 mutex_lock(&cifs_file->lock_mutex);
298 list_for_each_entry_safe(li, tmp, &cifs_file->llist, llist) {
299 list_del(&li->llist);
302 mutex_unlock(&cifs_file->lock_mutex);
304 cifs_put_tlink(cifs_file->tlink);
305 dput(cifs_file->dentry);
309 int cifs_open(struct inode *inode, struct file *file)
314 struct cifs_sb_info *cifs_sb;
315 struct cifsTconInfo *tcon;
316 struct tcon_link *tlink;
317 struct cifsFileInfo *pCifsFile = NULL;
318 struct cifsInodeInfo *pCifsInode;
319 char *full_path = NULL;
323 FILE_ALL_INFO *buf = NULL;
327 cifs_sb = CIFS_SB(inode->i_sb);
328 tlink = cifs_sb_tlink(cifs_sb);
331 return PTR_ERR(tlink);
333 tcon = tlink_tcon(tlink);
335 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
337 full_path = build_path_from_dentry(file->f_path.dentry);
338 if (full_path == NULL) {
343 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
344 inode, file->f_flags, full_path);
351 if (!tcon->broken_posix_open && tcon->unix_ext &&
352 (tcon->ses->capabilities & CAP_UNIX) &&
353 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
354 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
355 /* can not refresh inode info since size could be stale */
356 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
357 cifs_sb->mnt_file_mode /* ignored */,
358 file->f_flags, &oplock, &netfid, xid);
360 cFYI(1, "posix open succeeded");
362 pCifsFile = cifs_new_fileinfo(netfid, file, tlink,
364 if (pCifsFile == NULL) {
365 CIFSSMBClose(xid, tcon, netfid);
369 cifs_fscache_set_inode_cookie(inode, file);
372 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
373 if (tcon->ses->serverNOS)
374 cERROR(1, "server %s of type %s returned"
375 " unexpected error on SMB posix open"
376 ", disabling posix open support."
377 " Check if server update available.",
378 tcon->ses->serverName,
379 tcon->ses->serverNOS);
380 tcon->broken_posix_open = true;
381 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
382 (rc != -EOPNOTSUPP)) /* path not found or net err */
384 /* else fallthrough to retry open the old way on network i/o
388 desiredAccess = cifs_convert_flags(file->f_flags);
390 /*********************************************************************
391 * open flag mapping table:
393 * POSIX Flag CIFS Disposition
394 * ---------- ----------------
395 * O_CREAT FILE_OPEN_IF
396 * O_CREAT | O_EXCL FILE_CREATE
397 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
398 * O_TRUNC FILE_OVERWRITE
399 * none of the above FILE_OPEN
401 * Note that there is not a direct match between disposition
402 * FILE_SUPERSEDE (ie create whether or not file exists although
403 * O_CREAT | O_TRUNC is similar but truncates the existing
404 * file rather than creating a new file as FILE_SUPERSEDE does
405 * (which uses the attributes / metadata passed in on open call)
407 *? O_SYNC is a reasonable match to CIFS writethrough flag
408 *? and the read write flags match reasonably. O_LARGEFILE
409 *? is irrelevant because largefile support is always used
410 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
411 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
412 *********************************************************************/
414 disposition = cifs_get_disposition(file->f_flags);
416 /* BB pass O_SYNC flag through on file attributes .. BB */
418 /* Also refresh inode by passing in file_info buf returned by SMBOpen
419 and calling get_inode_info with returned buf (at least helps
420 non-Unix server case) */
422 /* BB we can not do this if this is the second open of a file
423 and the first handle has writebehind data, we might be
424 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
425 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
431 if (tcon->ses->capabilities & CAP_NT_SMBS)
432 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
433 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
434 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
435 & CIFS_MOUNT_MAP_SPECIAL_CHR);
437 rc = -EIO; /* no NT SMB support fall into legacy open below */
440 /* Old server, try legacy style OpenX */
441 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
442 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
443 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
444 & CIFS_MOUNT_MAP_SPECIAL_CHR);
447 cFYI(1, "cifs_open returned 0x%x", rc);
451 rc = cifs_open_inode_helper(inode, tcon, oplock, buf, full_path, xid);
455 pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
456 if (pCifsFile == NULL) {
461 cifs_fscache_set_inode_cookie(inode, file);
463 if (oplock & CIFS_CREATE_ACTION) {
464 /* time to set mode which we can not set earlier due to
465 problems creating new read-only files */
466 if (tcon->unix_ext) {
467 struct cifs_unix_set_info_args args = {
468 .mode = inode->i_mode,
471 .ctime = NO_CHANGE_64,
472 .atime = NO_CHANGE_64,
473 .mtime = NO_CHANGE_64,
476 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
478 cifs_sb->mnt_cifs_flags &
479 CIFS_MOUNT_MAP_SPECIAL_CHR);
487 cifs_put_tlink(tlink);
491 /* Try to reacquire byte range locks that were released when session */
492 /* to server was lost */
493 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
497 /* BB list all locks open on this file and relock */
502 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
507 struct cifs_sb_info *cifs_sb;
508 struct cifsTconInfo *tcon;
509 struct cifsInodeInfo *pCifsInode;
511 char *full_path = NULL;
513 int disposition = FILE_OPEN;
517 mutex_lock(&pCifsFile->fh_mutex);
518 if (!pCifsFile->invalidHandle) {
519 mutex_unlock(&pCifsFile->fh_mutex);
525 inode = pCifsFile->dentry->d_inode;
526 cifs_sb = CIFS_SB(inode->i_sb);
527 tcon = tlink_tcon(pCifsFile->tlink);
529 /* can not grab rename sem here because various ops, including
530 those that already have the rename sem can end up causing writepage
531 to get called and if the server was down that means we end up here,
532 and we can never tell if the caller already has the rename_sem */
533 full_path = build_path_from_dentry(pCifsFile->dentry);
534 if (full_path == NULL) {
536 mutex_unlock(&pCifsFile->fh_mutex);
541 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
542 inode, pCifsFile->f_flags, full_path);
549 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
550 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
551 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
554 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
555 * original open. Must mask them off for a reopen.
557 unsigned int oflags = pCifsFile->f_flags &
558 ~(O_CREAT | O_EXCL | O_TRUNC);
560 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
561 cifs_sb->mnt_file_mode /* ignored */,
562 oflags, &oplock, &netfid, xid);
564 cFYI(1, "posix reopen succeeded");
567 /* fallthrough to retry open the old way on errors, especially
568 in the reconnect path it is important to retry hard */
571 desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
573 /* Can not refresh inode by passing in file_info buf to be returned
574 by SMBOpen and then calling get_inode_info with returned buf
575 since file might have write behind data that needs to be flushed
576 and server version of file size can be stale. If we knew for sure
577 that inode was not dirty locally we could do this */
579 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
580 CREATE_NOT_DIR, &netfid, &oplock, NULL,
581 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
582 CIFS_MOUNT_MAP_SPECIAL_CHR);
584 mutex_unlock(&pCifsFile->fh_mutex);
585 cFYI(1, "cifs_open returned 0x%x", rc);
586 cFYI(1, "oplock: %d", oplock);
587 goto reopen_error_exit;
591 pCifsFile->netfid = netfid;
592 pCifsFile->invalidHandle = false;
593 mutex_unlock(&pCifsFile->fh_mutex);
594 pCifsInode = CIFS_I(inode);
597 rc = filemap_write_and_wait(inode->i_mapping);
598 mapping_set_error(inode->i_mapping, rc);
601 rc = cifs_get_inode_info_unix(&inode,
602 full_path, inode->i_sb, xid);
604 rc = cifs_get_inode_info(&inode,
605 full_path, NULL, inode->i_sb,
607 } /* else we are writing out data to server already
608 and could deadlock if we tried to flush data, and
609 since we do not know if we have data that would
610 invalidate the current end of file on the server
611 we can not go to the server to get the new inod
614 cifs_set_oplock_level(pCifsInode, oplock);
616 cifs_relock_file(pCifsFile);
624 int cifs_close(struct inode *inode, struct file *file)
626 cifsFileInfo_put(file->private_data);
627 file->private_data = NULL;
629 /* return code from the ->release op is always ignored */
633 int cifs_closedir(struct inode *inode, struct file *file)
637 struct cifsFileInfo *pCFileStruct = file->private_data;
640 cFYI(1, "Closedir inode = 0x%p", inode);
645 struct cifsTconInfo *pTcon = tlink_tcon(pCFileStruct->tlink);
647 cFYI(1, "Freeing private data in close dir");
648 spin_lock(&cifs_file_list_lock);
649 if (!pCFileStruct->srch_inf.endOfSearch &&
650 !pCFileStruct->invalidHandle) {
651 pCFileStruct->invalidHandle = true;
652 spin_unlock(&cifs_file_list_lock);
653 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
654 cFYI(1, "Closing uncompleted readdir with rc %d",
656 /* not much we can do if it fails anyway, ignore rc */
659 spin_unlock(&cifs_file_list_lock);
660 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
662 cFYI(1, "closedir free smb buf in srch struct");
663 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
664 if (pCFileStruct->srch_inf.smallBuf)
665 cifs_small_buf_release(ptmp);
667 cifs_buf_release(ptmp);
669 cifs_put_tlink(pCFileStruct->tlink);
670 kfree(file->private_data);
671 file->private_data = NULL;
673 /* BB can we lock the filestruct while this is going on? */
678 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
679 __u64 offset, __u8 lockType)
681 struct cifsLockInfo *li =
682 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
688 mutex_lock(&fid->lock_mutex);
689 list_add(&li->llist, &fid->llist);
690 mutex_unlock(&fid->lock_mutex);
694 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
700 bool wait_flag = false;
701 struct cifs_sb_info *cifs_sb;
702 struct cifsTconInfo *tcon;
704 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
705 bool posix_locking = 0;
707 length = 1 + pfLock->fl_end - pfLock->fl_start;
711 cFYI(1, "Lock parm: 0x%x flockflags: "
712 "0x%x flocktype: 0x%x start: %lld end: %lld",
713 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
716 if (pfLock->fl_flags & FL_POSIX)
718 if (pfLock->fl_flags & FL_FLOCK)
720 if (pfLock->fl_flags & FL_SLEEP) {
721 cFYI(1, "Blocking lock");
724 if (pfLock->fl_flags & FL_ACCESS)
725 cFYI(1, "Process suspended by mandatory locking - "
726 "not implemented yet");
727 if (pfLock->fl_flags & FL_LEASE)
728 cFYI(1, "Lease on file - not implemented yet");
729 if (pfLock->fl_flags &
730 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
731 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
733 if (pfLock->fl_type == F_WRLCK) {
736 } else if (pfLock->fl_type == F_UNLCK) {
739 /* Check if unlock includes more than
741 } else if (pfLock->fl_type == F_RDLCK) {
743 lockType |= LOCKING_ANDX_SHARED_LOCK;
745 } else if (pfLock->fl_type == F_EXLCK) {
748 } else if (pfLock->fl_type == F_SHLCK) {
750 lockType |= LOCKING_ANDX_SHARED_LOCK;
753 cFYI(1, "Unknown type of lock");
755 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
756 tcon = tlink_tcon(((struct cifsFileInfo *)file->private_data)->tlink);
757 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
759 if ((tcon->ses->capabilities & CAP_UNIX) &&
760 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
761 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
763 /* BB add code here to normalize offset and length to
764 account for negative length which we can not accept over the
769 if (lockType & LOCKING_ANDX_SHARED_LOCK)
770 posix_lock_type = CIFS_RDLCK;
772 posix_lock_type = CIFS_WRLCK;
773 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
775 posix_lock_type, wait_flag);
780 /* BB we could chain these into one lock request BB */
781 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
782 0, 1, lockType, 0 /* wait flag */ );
784 rc = CIFSSMBLock(xid, tcon, netfid, length,
785 pfLock->fl_start, 1 /* numUnlock */ ,
786 0 /* numLock */ , lockType,
788 pfLock->fl_type = F_UNLCK;
790 cERROR(1, "Error unlocking previously locked "
791 "range %d during test of lock", rc);
795 /* if rc == ERR_SHARING_VIOLATION ? */
798 if (lockType & LOCKING_ANDX_SHARED_LOCK) {
799 pfLock->fl_type = F_WRLCK;
801 rc = CIFSSMBLock(xid, tcon, netfid, length,
802 pfLock->fl_start, 0, 1,
803 lockType | LOCKING_ANDX_SHARED_LOCK,
806 rc = CIFSSMBLock(xid, tcon, netfid,
807 length, pfLock->fl_start, 1, 0,
809 LOCKING_ANDX_SHARED_LOCK,
811 pfLock->fl_type = F_RDLCK;
813 cERROR(1, "Error unlocking "
814 "previously locked range %d "
815 "during test of lock", rc);
818 pfLock->fl_type = F_WRLCK;
828 if (!numLock && !numUnlock) {
829 /* if no lock or unlock then nothing
830 to do since we do not know what it is */
837 if (lockType & LOCKING_ANDX_SHARED_LOCK)
838 posix_lock_type = CIFS_RDLCK;
840 posix_lock_type = CIFS_WRLCK;
843 posix_lock_type = CIFS_UNLCK;
845 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
847 posix_lock_type, wait_flag);
849 struct cifsFileInfo *fid = file->private_data;
852 rc = CIFSSMBLock(xid, tcon, netfid, length,
854 0, numLock, lockType, wait_flag);
857 /* For Windows locks we must store them. */
858 rc = store_file_lock(fid, length,
859 pfLock->fl_start, lockType);
861 } else if (numUnlock) {
862 /* For each stored lock that this unlock overlaps
863 completely, unlock it. */
865 struct cifsLockInfo *li, *tmp;
868 mutex_lock(&fid->lock_mutex);
869 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
870 if (pfLock->fl_start <= li->offset &&
871 (pfLock->fl_start + length) >=
872 (li->offset + li->length)) {
873 stored_rc = CIFSSMBLock(xid, tcon,
875 li->length, li->offset,
876 1, 0, li->type, false);
880 list_del(&li->llist);
885 mutex_unlock(&fid->lock_mutex);
889 if (pfLock->fl_flags & FL_POSIX)
890 posix_lock_file_wait(file, pfLock);
896 * Set the timeout on write requests past EOF. For some servers (Windows)
897 * these calls can be very long.
899 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
900 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
901 * The 10M cutoff is totally arbitrary. A better scheme for this would be
902 * welcome if someone wants to suggest one.
904 * We may be able to do a better job with this if there were some way to
905 * declare that a file should be sparse.
908 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
910 if (offset <= cifsi->server_eof)
912 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
913 return CIFS_VLONG_OP;
918 /* update the file size (if needed) after a write */
920 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
921 unsigned int bytes_written)
923 loff_t end_of_write = offset + bytes_written;
925 if (end_of_write > cifsi->server_eof)
926 cifsi->server_eof = end_of_write;
929 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
930 size_t write_size, loff_t *poffset)
932 struct inode *inode = file->f_path.dentry->d_inode;
934 unsigned int bytes_written = 0;
935 unsigned int total_written;
936 struct cifs_sb_info *cifs_sb;
937 struct cifsTconInfo *pTcon;
939 struct cifsFileInfo *open_file;
940 struct cifsInodeInfo *cifsi = CIFS_I(inode);
942 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
944 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
945 *poffset, file->f_path.dentry->d_name.name); */
947 if (file->private_data == NULL)
950 open_file = file->private_data;
951 pTcon = tlink_tcon(open_file->tlink);
953 rc = generic_write_checks(file, poffset, &write_size, 0);
959 long_op = cifs_write_timeout(cifsi, *poffset);
960 for (total_written = 0; write_size > total_written;
961 total_written += bytes_written) {
963 while (rc == -EAGAIN) {
964 if (file->private_data == NULL) {
965 /* file has been closed on us */
967 /* if we have gotten here we have written some data
968 and blocked, and the file has been freed on us while
969 we blocked so return what we managed to write */
970 return total_written;
972 if (open_file->invalidHandle) {
973 /* we could deadlock if we called
974 filemap_fdatawait from here so tell
975 reopen_file not to flush data to server
977 rc = cifs_reopen_file(open_file, false);
982 rc = CIFSSMBWrite(xid, pTcon,
984 min_t(const int, cifs_sb->wsize,
985 write_size - total_written),
986 *poffset, &bytes_written,
987 NULL, write_data + total_written, long_op);
989 if (rc || (bytes_written == 0)) {
997 cifs_update_eof(cifsi, *poffset, bytes_written);
998 *poffset += bytes_written;
1000 long_op = CIFS_STD_OP; /* subsequent writes fast -
1001 15 seconds is plenty */
1004 cifs_stats_bytes_written(pTcon, total_written);
1006 /* Do not update local mtime - server will set its actual value on write
1007 * inode->i_ctime = inode->i_mtime =
1008 * current_fs_time(inode->i_sb);*/
1009 if (total_written > 0) {
1010 spin_lock(&inode->i_lock);
1011 if (*poffset > inode->i_size)
1012 i_size_write(inode, *poffset);
1013 spin_unlock(&inode->i_lock);
1015 mark_inode_dirty_sync(inode);
1018 return total_written;
1021 static ssize_t cifs_write(struct cifsFileInfo *open_file,
1022 const char *write_data, size_t write_size,
1026 unsigned int bytes_written = 0;
1027 unsigned int total_written;
1028 struct cifs_sb_info *cifs_sb;
1029 struct cifsTconInfo *pTcon;
1031 struct dentry *dentry = open_file->dentry;
1032 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1034 cifs_sb = CIFS_SB(dentry->d_sb);
1036 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1037 *poffset, dentry->d_name.name);
1039 pTcon = tlink_tcon(open_file->tlink);
1043 long_op = cifs_write_timeout(cifsi, *poffset);
1044 for (total_written = 0; write_size > total_written;
1045 total_written += bytes_written) {
1047 while (rc == -EAGAIN) {
1048 if (open_file->invalidHandle) {
1049 /* we could deadlock if we called
1050 filemap_fdatawait from here so tell
1051 reopen_file not to flush data to
1053 rc = cifs_reopen_file(open_file, false);
1057 if (experimEnabled || (pTcon->ses->server &&
1058 ((pTcon->ses->server->secMode &
1059 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1064 len = min((size_t)cifs_sb->wsize,
1065 write_size - total_written);
1066 /* iov[0] is reserved for smb header */
1067 iov[1].iov_base = (char *)write_data +
1069 iov[1].iov_len = len;
1070 rc = CIFSSMBWrite2(xid, pTcon,
1071 open_file->netfid, len,
1072 *poffset, &bytes_written,
1075 rc = CIFSSMBWrite(xid, pTcon,
1077 min_t(const int, cifs_sb->wsize,
1078 write_size - total_written),
1079 *poffset, &bytes_written,
1080 write_data + total_written,
1083 if (rc || (bytes_written == 0)) {
1091 cifs_update_eof(cifsi, *poffset, bytes_written);
1092 *poffset += bytes_written;
1094 long_op = CIFS_STD_OP; /* subsequent writes fast -
1095 15 seconds is plenty */
1098 cifs_stats_bytes_written(pTcon, total_written);
1100 if (total_written > 0) {
1101 spin_lock(&dentry->d_inode->i_lock);
1102 if (*poffset > dentry->d_inode->i_size)
1103 i_size_write(dentry->d_inode, *poffset);
1104 spin_unlock(&dentry->d_inode->i_lock);
1106 mark_inode_dirty_sync(dentry->d_inode);
1108 return total_written;
1111 #ifdef CONFIG_CIFS_EXPERIMENTAL
1112 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1115 struct cifsFileInfo *open_file = NULL;
1116 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1118 /* only filter by fsuid on multiuser mounts */
1119 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1122 spin_lock(&cifs_file_list_lock);
1123 /* we could simply get the first_list_entry since write-only entries
1124 are always at the end of the list but since the first entry might
1125 have a close pending, we go through the whole list */
1126 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1127 if (fsuid_only && open_file->uid != current_fsuid())
1129 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1130 if (!open_file->invalidHandle) {
1131 /* found a good file */
1132 /* lock it so it will not be closed on us */
1133 cifsFileInfo_get(open_file);
1134 spin_unlock(&cifs_file_list_lock);
1136 } /* else might as well continue, and look for
1137 another, or simply have the caller reopen it
1138 again rather than trying to fix this handle */
1139 } else /* write only file */
1140 break; /* write only files are last so must be done */
1142 spin_unlock(&cifs_file_list_lock);
1147 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1150 struct cifsFileInfo *open_file;
1151 struct cifs_sb_info *cifs_sb;
1152 bool any_available = false;
1155 /* Having a null inode here (because mapping->host was set to zero by
1156 the VFS or MM) should not happen but we had reports of on oops (due to
1157 it being zero) during stress testcases so we need to check for it */
1159 if (cifs_inode == NULL) {
1160 cERROR(1, "Null inode passed to cifs_writeable_file");
1165 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1167 /* only filter by fsuid on multiuser mounts */
1168 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1171 spin_lock(&cifs_file_list_lock);
1173 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1174 if (!any_available && open_file->pid != current->tgid)
1176 if (fsuid_only && open_file->uid != current_fsuid())
1178 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1179 cifsFileInfo_get(open_file);
1181 if (!open_file->invalidHandle) {
1182 /* found a good writable file */
1183 spin_unlock(&cifs_file_list_lock);
1187 spin_unlock(&cifs_file_list_lock);
1189 /* Had to unlock since following call can block */
1190 rc = cifs_reopen_file(open_file, false);
1194 /* if it fails, try another handle if possible */
1195 cFYI(1, "wp failed on reopen file");
1196 cifsFileInfo_put(open_file);
1198 spin_lock(&cifs_file_list_lock);
1200 /* else we simply continue to the next entry. Thus
1201 we do not loop on reopen errors. If we
1202 can not reopen the file, for example if we
1203 reconnected to a server with another client
1204 racing to delete or lock the file we would not
1205 make progress if we restarted before the beginning
1206 of the loop here. */
1209 /* couldn't find useable FH with same pid, try any available */
1210 if (!any_available) {
1211 any_available = true;
1212 goto refind_writable;
1214 spin_unlock(&cifs_file_list_lock);
1218 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1220 struct address_space *mapping = page->mapping;
1221 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1224 int bytes_written = 0;
1225 struct cifs_sb_info *cifs_sb;
1226 struct inode *inode;
1227 struct cifsFileInfo *open_file;
1229 if (!mapping || !mapping->host)
1232 inode = page->mapping->host;
1233 cifs_sb = CIFS_SB(inode->i_sb);
1235 offset += (loff_t)from;
1236 write_data = kmap(page);
1239 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1244 /* racing with truncate? */
1245 if (offset > mapping->host->i_size) {
1247 return 0; /* don't care */
1250 /* check to make sure that we are not extending the file */
1251 if (mapping->host->i_size - offset < (loff_t)to)
1252 to = (unsigned)(mapping->host->i_size - offset);
1254 open_file = find_writable_file(CIFS_I(mapping->host), false);
1256 bytes_written = cifs_write(open_file, write_data,
1257 to - from, &offset);
1258 cifsFileInfo_put(open_file);
1259 /* Does mm or vfs already set times? */
1260 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1261 if ((bytes_written > 0) && (offset))
1263 else if (bytes_written < 0)
1266 cFYI(1, "No writeable filehandles for inode");
1274 static int cifs_writepages(struct address_space *mapping,
1275 struct writeback_control *wbc)
1277 unsigned int bytes_to_write;
1278 unsigned int bytes_written;
1279 struct cifs_sb_info *cifs_sb;
1283 int range_whole = 0;
1290 struct cifsFileInfo *open_file;
1291 struct cifsTconInfo *tcon;
1292 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1294 struct pagevec pvec;
1299 cifs_sb = CIFS_SB(mapping->host->i_sb);
1302 * If wsize is smaller that the page cache size, default to writing
1303 * one page at a time via cifs_writepage
1305 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1306 return generic_writepages(mapping, wbc);
1308 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1310 return generic_writepages(mapping, wbc);
1313 * if there's no open file, then this is likely to fail too,
1314 * but it'll at least handle the return. Maybe it should be
1317 open_file = find_writable_file(CIFS_I(mapping->host), false);
1320 return generic_writepages(mapping, wbc);
1323 tcon = tlink_tcon(open_file->tlink);
1324 if (!experimEnabled && tcon->ses->server->secMode &
1325 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1326 cifsFileInfo_put(open_file);
1328 return generic_writepages(mapping, wbc);
1330 cifsFileInfo_put(open_file);
1334 pagevec_init(&pvec, 0);
1335 if (wbc->range_cyclic) {
1336 index = mapping->writeback_index; /* Start from prev offset */
1339 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1340 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1341 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1346 while (!done && (index <= end) &&
1347 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1348 PAGECACHE_TAG_DIRTY,
1349 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1358 for (i = 0; i < nr_pages; i++) {
1359 page = pvec.pages[i];
1361 * At this point we hold neither mapping->tree_lock nor
1362 * lock on the page itself: the page may be truncated or
1363 * invalidated (changing page->mapping to NULL), or even
1364 * swizzled back from swapper_space to tmpfs file
1370 else if (!trylock_page(page))
1373 if (unlikely(page->mapping != mapping)) {
1378 if (!wbc->range_cyclic && page->index > end) {
1384 if (next && (page->index != next)) {
1385 /* Not next consecutive page */
1390 if (wbc->sync_mode != WB_SYNC_NONE)
1391 wait_on_page_writeback(page);
1393 if (PageWriteback(page) ||
1394 !clear_page_dirty_for_io(page)) {
1400 * This actually clears the dirty bit in the radix tree.
1401 * See cifs_writepage() for more commentary.
1403 set_page_writeback(page);
1405 if (page_offset(page) >= mapping->host->i_size) {
1408 end_page_writeback(page);
1413 * BB can we get rid of this? pages are held by pvec
1415 page_cache_get(page);
1417 len = min(mapping->host->i_size - page_offset(page),
1418 (loff_t)PAGE_CACHE_SIZE);
1420 /* reserve iov[0] for the smb header */
1422 iov[n_iov].iov_base = kmap(page);
1423 iov[n_iov].iov_len = len;
1424 bytes_to_write += len;
1428 offset = page_offset(page);
1430 next = page->index + 1;
1431 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1435 open_file = find_writable_file(CIFS_I(mapping->host),
1438 cERROR(1, "No writable handles for inode");
1441 long_op = cifs_write_timeout(cifsi, offset);
1442 rc = CIFSSMBWrite2(xid, tcon, open_file->netfid,
1443 bytes_to_write, offset,
1444 &bytes_written, iov, n_iov,
1446 cifsFileInfo_put(open_file);
1447 cifs_update_eof(cifsi, offset, bytes_written);
1450 if (rc || bytes_written < bytes_to_write) {
1451 cERROR(1, "Write2 ret %d, wrote %d",
1453 mapping_set_error(mapping, rc);
1455 cifs_stats_bytes_written(tcon, bytes_written);
1458 for (i = 0; i < n_iov; i++) {
1459 page = pvec.pages[first + i];
1460 /* Should we also set page error on
1461 success rc but too little data written? */
1462 /* BB investigate retry logic on temporary
1463 server crash cases and how recovery works
1464 when page marked as error */
1469 end_page_writeback(page);
1470 page_cache_release(page);
1472 if ((wbc->nr_to_write -= n_iov) <= 0)
1476 /* Need to re-find the pages we skipped */
1477 index = pvec.pages[0]->index + 1;
1479 pagevec_release(&pvec);
1481 if (!scanned && !done) {
1483 * We hit the last page and there is more work to be done: wrap
1484 * back to the start of the file
1490 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1491 mapping->writeback_index = index;
1498 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1504 /* BB add check for wbc flags */
1505 page_cache_get(page);
1506 if (!PageUptodate(page))
1507 cFYI(1, "ppw - page not up to date");
1510 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1512 * A writepage() implementation always needs to do either this,
1513 * or re-dirty the page with "redirty_page_for_writepage()" in
1514 * the case of a failure.
1516 * Just unlocking the page will cause the radix tree tag-bits
1517 * to fail to update with the state of the page correctly.
1519 set_page_writeback(page);
1520 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1521 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1523 end_page_writeback(page);
1524 page_cache_release(page);
1529 static int cifs_write_end(struct file *file, struct address_space *mapping,
1530 loff_t pos, unsigned len, unsigned copied,
1531 struct page *page, void *fsdata)
1534 struct inode *inode = mapping->host;
1536 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1539 if (PageChecked(page)) {
1541 SetPageUptodate(page);
1542 ClearPageChecked(page);
1543 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1544 SetPageUptodate(page);
1546 if (!PageUptodate(page)) {
1548 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1552 /* this is probably better than directly calling
1553 partialpage_write since in this function the file handle is
1554 known which we might as well leverage */
1555 /* BB check if anything else missing out of ppw
1556 such as updating last write time */
1557 page_data = kmap(page);
1558 rc = cifs_write(file->private_data, page_data + offset,
1560 /* if (rc < 0) should we set writebehind rc? */
1567 set_page_dirty(page);
1571 spin_lock(&inode->i_lock);
1572 if (pos > inode->i_size)
1573 i_size_write(inode, pos);
1574 spin_unlock(&inode->i_lock);
1578 page_cache_release(page);
1583 int cifs_fsync(struct file *file, int datasync)
1587 struct cifsTconInfo *tcon;
1588 struct cifsFileInfo *smbfile = file->private_data;
1589 struct inode *inode = file->f_path.dentry->d_inode;
1593 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1594 file->f_path.dentry->d_name.name, datasync);
1596 rc = filemap_write_and_wait(inode->i_mapping);
1598 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1600 tcon = tlink_tcon(smbfile->tlink);
1601 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1602 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1609 /* static void cifs_sync_page(struct page *page)
1611 struct address_space *mapping;
1612 struct inode *inode;
1613 unsigned long index = page->index;
1614 unsigned int rpages = 0;
1617 cFYI(1, "sync page %p", page);
1618 mapping = page->mapping;
1621 inode = mapping->host;
1625 /* fill in rpages then
1626 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1628 /* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1638 * As file closes, flush all cached write data for this inode checking
1639 * for write behind errors.
1641 int cifs_flush(struct file *file, fl_owner_t id)
1643 struct inode *inode = file->f_path.dentry->d_inode;
1646 if (file->f_mode & FMODE_WRITE)
1647 rc = filemap_write_and_wait(inode->i_mapping);
1649 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
1654 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1655 size_t read_size, loff_t *poffset)
1658 unsigned int bytes_read = 0;
1659 unsigned int total_read = 0;
1660 unsigned int current_read_size;
1661 struct cifs_sb_info *cifs_sb;
1662 struct cifsTconInfo *pTcon;
1664 struct cifsFileInfo *open_file;
1665 char *smb_read_data;
1666 char __user *current_offset;
1667 struct smb_com_read_rsp *pSMBr;
1670 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1672 if (file->private_data == NULL) {
1677 open_file = file->private_data;
1678 pTcon = tlink_tcon(open_file->tlink);
1680 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1681 cFYI(1, "attempting read on write only file instance");
1683 for (total_read = 0, current_offset = read_data;
1684 read_size > total_read;
1685 total_read += bytes_read, current_offset += bytes_read) {
1686 current_read_size = min_t(const int, read_size - total_read,
1689 smb_read_data = NULL;
1690 while (rc == -EAGAIN) {
1691 int buf_type = CIFS_NO_BUFFER;
1692 if (open_file->invalidHandle) {
1693 rc = cifs_reopen_file(open_file, true);
1697 rc = CIFSSMBRead(xid, pTcon,
1699 current_read_size, *poffset,
1700 &bytes_read, &smb_read_data,
1702 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1703 if (smb_read_data) {
1704 if (copy_to_user(current_offset,
1706 4 /* RFC1001 length field */ +
1707 le16_to_cpu(pSMBr->DataOffset),
1711 if (buf_type == CIFS_SMALL_BUFFER)
1712 cifs_small_buf_release(smb_read_data);
1713 else if (buf_type == CIFS_LARGE_BUFFER)
1714 cifs_buf_release(smb_read_data);
1715 smb_read_data = NULL;
1718 if (rc || (bytes_read == 0)) {
1726 cifs_stats_bytes_read(pTcon, bytes_read);
1727 *poffset += bytes_read;
1735 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1739 unsigned int bytes_read = 0;
1740 unsigned int total_read;
1741 unsigned int current_read_size;
1742 struct cifs_sb_info *cifs_sb;
1743 struct cifsTconInfo *pTcon;
1745 char *current_offset;
1746 struct cifsFileInfo *open_file;
1747 int buf_type = CIFS_NO_BUFFER;
1750 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1752 if (file->private_data == NULL) {
1757 open_file = file->private_data;
1758 pTcon = tlink_tcon(open_file->tlink);
1760 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1761 cFYI(1, "attempting read on write only file instance");
1763 for (total_read = 0, current_offset = read_data;
1764 read_size > total_read;
1765 total_read += bytes_read, current_offset += bytes_read) {
1766 current_read_size = min_t(const int, read_size - total_read,
1768 /* For windows me and 9x we do not want to request more
1769 than it negotiated since it will refuse the read then */
1771 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1772 current_read_size = min_t(const int, current_read_size,
1773 pTcon->ses->server->maxBuf - 128);
1776 while (rc == -EAGAIN) {
1777 if (open_file->invalidHandle) {
1778 rc = cifs_reopen_file(open_file, true);
1782 rc = CIFSSMBRead(xid, pTcon,
1784 current_read_size, *poffset,
1785 &bytes_read, ¤t_offset,
1788 if (rc || (bytes_read == 0)) {
1796 cifs_stats_bytes_read(pTcon, total_read);
1797 *poffset += bytes_read;
1804 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1809 rc = cifs_revalidate_file(file);
1811 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
1815 rc = generic_file_mmap(file, vma);
1821 static void cifs_copy_cache_pages(struct address_space *mapping,
1822 struct list_head *pages, int bytes_read, char *data)
1827 while (bytes_read > 0) {
1828 if (list_empty(pages))
1831 page = list_entry(pages->prev, struct page, lru);
1832 list_del(&page->lru);
1834 if (add_to_page_cache_lru(page, mapping, page->index,
1836 page_cache_release(page);
1837 cFYI(1, "Add page cache failed");
1838 data += PAGE_CACHE_SIZE;
1839 bytes_read -= PAGE_CACHE_SIZE;
1842 page_cache_release(page);
1844 target = kmap_atomic(page, KM_USER0);
1846 if (PAGE_CACHE_SIZE > bytes_read) {
1847 memcpy(target, data, bytes_read);
1848 /* zero the tail end of this partial page */
1849 memset(target + bytes_read, 0,
1850 PAGE_CACHE_SIZE - bytes_read);
1853 memcpy(target, data, PAGE_CACHE_SIZE);
1854 bytes_read -= PAGE_CACHE_SIZE;
1856 kunmap_atomic(target, KM_USER0);
1858 flush_dcache_page(page);
1859 SetPageUptodate(page);
1861 data += PAGE_CACHE_SIZE;
1863 /* add page to FS-Cache */
1864 cifs_readpage_to_fscache(mapping->host, page);
1869 static int cifs_readpages(struct file *file, struct address_space *mapping,
1870 struct list_head *page_list, unsigned num_pages)
1876 struct cifs_sb_info *cifs_sb;
1877 struct cifsTconInfo *pTcon;
1878 unsigned int bytes_read = 0;
1879 unsigned int read_size, i;
1880 char *smb_read_data = NULL;
1881 struct smb_com_read_rsp *pSMBr;
1882 struct cifsFileInfo *open_file;
1883 int buf_type = CIFS_NO_BUFFER;
1886 if (file->private_data == NULL) {
1891 open_file = file->private_data;
1892 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1893 pTcon = tlink_tcon(open_file->tlink);
1896 * Reads as many pages as possible from fscache. Returns -ENOBUFS
1897 * immediately if the cookie is negative
1899 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
1904 cFYI(DBG2, "rpages: num pages %d", num_pages);
1905 for (i = 0; i < num_pages; ) {
1906 unsigned contig_pages;
1907 struct page *tmp_page;
1908 unsigned long expected_index;
1910 if (list_empty(page_list))
1913 page = list_entry(page_list->prev, struct page, lru);
1914 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1916 /* count adjacent pages that we will read into */
1919 list_entry(page_list->prev, struct page, lru)->index;
1920 list_for_each_entry_reverse(tmp_page, page_list, lru) {
1921 if (tmp_page->index == expected_index) {
1927 if (contig_pages + i > num_pages)
1928 contig_pages = num_pages - i;
1930 /* for reads over a certain size could initiate async
1933 read_size = contig_pages * PAGE_CACHE_SIZE;
1934 /* Read size needs to be in multiples of one page */
1935 read_size = min_t(const unsigned int, read_size,
1936 cifs_sb->rsize & PAGE_CACHE_MASK);
1937 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
1938 read_size, contig_pages);
1940 while (rc == -EAGAIN) {
1941 if (open_file->invalidHandle) {
1942 rc = cifs_reopen_file(open_file, true);
1947 rc = CIFSSMBRead(xid, pTcon,
1950 &bytes_read, &smb_read_data,
1952 /* BB more RC checks ? */
1953 if (rc == -EAGAIN) {
1954 if (smb_read_data) {
1955 if (buf_type == CIFS_SMALL_BUFFER)
1956 cifs_small_buf_release(smb_read_data);
1957 else if (buf_type == CIFS_LARGE_BUFFER)
1958 cifs_buf_release(smb_read_data);
1959 smb_read_data = NULL;
1963 if ((rc < 0) || (smb_read_data == NULL)) {
1964 cFYI(1, "Read error in readpages: %d", rc);
1966 } else if (bytes_read > 0) {
1967 task_io_account_read(bytes_read);
1968 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1969 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1970 smb_read_data + 4 /* RFC1001 hdr */ +
1971 le16_to_cpu(pSMBr->DataOffset));
1973 i += bytes_read >> PAGE_CACHE_SHIFT;
1974 cifs_stats_bytes_read(pTcon, bytes_read);
1975 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1976 i++; /* account for partial page */
1978 /* server copy of file can have smaller size
1980 /* BB do we need to verify this common case ?
1981 this case is ok - if we are at server EOF
1982 we will hit it on next read */
1987 cFYI(1, "No bytes read (%d) at offset %lld . "
1988 "Cleaning remaining pages from readahead list",
1989 bytes_read, offset);
1990 /* BB turn off caching and do new lookup on
1991 file size at server? */
1994 if (smb_read_data) {
1995 if (buf_type == CIFS_SMALL_BUFFER)
1996 cifs_small_buf_release(smb_read_data);
1997 else if (buf_type == CIFS_LARGE_BUFFER)
1998 cifs_buf_release(smb_read_data);
1999 smb_read_data = NULL;
2004 /* need to free smb_read_data buf before exit */
2005 if (smb_read_data) {
2006 if (buf_type == CIFS_SMALL_BUFFER)
2007 cifs_small_buf_release(smb_read_data);
2008 else if (buf_type == CIFS_LARGE_BUFFER)
2009 cifs_buf_release(smb_read_data);
2010 smb_read_data = NULL;
2018 static int cifs_readpage_worker(struct file *file, struct page *page,
2024 /* Is the page cached? */
2025 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2029 page_cache_get(page);
2030 read_data = kmap(page);
2031 /* for reads over a certain size could initiate async read ahead */
2033 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2038 cFYI(1, "Bytes read %d", rc);
2040 file->f_path.dentry->d_inode->i_atime =
2041 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2043 if (PAGE_CACHE_SIZE > rc)
2044 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2046 flush_dcache_page(page);
2047 SetPageUptodate(page);
2049 /* send this page to the cache */
2050 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2056 page_cache_release(page);
2062 static int cifs_readpage(struct file *file, struct page *page)
2064 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2070 if (file->private_data == NULL) {
2076 cFYI(1, "readpage %p at offset %d 0x%x\n",
2077 page, (int)offset, (int)offset);
2079 rc = cifs_readpage_worker(file, page, &offset);
2087 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2089 struct cifsFileInfo *open_file;
2091 spin_lock(&cifs_file_list_lock);
2092 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2093 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2094 spin_unlock(&cifs_file_list_lock);
2098 spin_unlock(&cifs_file_list_lock);
2102 /* We do not want to update the file size from server for inodes
2103 open for write - to avoid races with writepage extending
2104 the file - in the future we could consider allowing
2105 refreshing the inode only on increases in the file size
2106 but this is tricky to do without racing with writebehind
2107 page caching in the current Linux kernel design */
2108 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2113 if (is_inode_writable(cifsInode)) {
2114 /* This inode is open for write at least once */
2115 struct cifs_sb_info *cifs_sb;
2117 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2118 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2119 /* since no page cache to corrupt on directio
2120 we can change size safely */
2124 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2132 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2133 loff_t pos, unsigned len, unsigned flags,
2134 struct page **pagep, void **fsdata)
2136 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2137 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2138 loff_t page_start = pos & PAGE_MASK;
2143 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2145 page = grab_cache_page_write_begin(mapping, index, flags);
2151 if (PageUptodate(page))
2155 * If we write a full page it will be up to date, no need to read from
2156 * the server. If the write is short, we'll end up doing a sync write
2159 if (len == PAGE_CACHE_SIZE)
2163 * optimize away the read when we have an oplock, and we're not
2164 * expecting to use any of the data we'd be reading in. That
2165 * is, when the page lies beyond the EOF, or straddles the EOF
2166 * and the write will cover all of the existing data.
2168 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2169 i_size = i_size_read(mapping->host);
2170 if (page_start >= i_size ||
2171 (offset == 0 && (pos + len) >= i_size)) {
2172 zero_user_segments(page, 0, offset,
2176 * PageChecked means that the parts of the page
2177 * to which we're not writing are considered up
2178 * to date. Once the data is copied to the
2179 * page, it can be set uptodate.
2181 SetPageChecked(page);
2186 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2188 * might as well read a page, it is fast enough. If we get
2189 * an error, we don't need to return it. cifs_write_end will
2190 * do a sync write instead since PG_uptodate isn't set.
2192 cifs_readpage_worker(file, page, &page_start);
2194 /* we could try using another file handle if there is one -
2195 but how would we lock it to prevent close of that handle
2196 racing with this read? In any case
2197 this will be written out by write_end so is fine */
2204 static int cifs_release_page(struct page *page, gfp_t gfp)
2206 if (PagePrivate(page))
2209 return cifs_fscache_release_page(page, gfp);
2212 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2214 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2217 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2220 void cifs_oplock_break(struct work_struct *work)
2222 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2224 struct inode *inode = cfile->dentry->d_inode;
2225 struct cifsInodeInfo *cinode = CIFS_I(inode);
2228 if (inode && S_ISREG(inode->i_mode)) {
2229 if (cinode->clientCanCacheRead)
2230 break_lease(inode, O_RDONLY);
2232 break_lease(inode, O_WRONLY);
2233 rc = filemap_fdatawrite(inode->i_mapping);
2234 if (cinode->clientCanCacheRead == 0) {
2235 rc = filemap_fdatawait(inode->i_mapping);
2236 mapping_set_error(inode->i_mapping, rc);
2237 invalidate_remote_inode(inode);
2239 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2243 * releasing stale oplock after recent reconnect of smb session using
2244 * a now incorrect file handle is not a data integrity issue but do
2245 * not bother sending an oplock release if session to server still is
2246 * disconnected since oplock already released by the server
2248 if (!cfile->oplock_break_cancelled) {
2249 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2250 0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false);
2251 cFYI(1, "Oplock release rc = %d", rc);
2255 * We might have kicked in before is_valid_oplock_break()
2256 * finished grabbing reference for us. Make sure it's done by
2257 * waiting for cifs_file_list_lock.
2259 spin_lock(&cifs_file_list_lock);
2260 spin_unlock(&cifs_file_list_lock);
2262 cifs_oplock_break_put(cfile);
2265 /* must be called while holding cifs_file_list_lock */
2266 void cifs_oplock_break_get(struct cifsFileInfo *cfile)
2268 cifs_sb_active(cfile->dentry->d_sb);
2269 cifsFileInfo_get(cfile);
2272 void cifs_oplock_break_put(struct cifsFileInfo *cfile)
2274 struct super_block *sb = cfile->dentry->d_sb;
2276 cifsFileInfo_put(cfile);
2277 cifs_sb_deactive(sb);
2280 const struct address_space_operations cifs_addr_ops = {
2281 .readpage = cifs_readpage,
2282 .readpages = cifs_readpages,
2283 .writepage = cifs_writepage,
2284 .writepages = cifs_writepages,
2285 .write_begin = cifs_write_begin,
2286 .write_end = cifs_write_end,
2287 .set_page_dirty = __set_page_dirty_nobuffers,
2288 .releasepage = cifs_release_page,
2289 .invalidatepage = cifs_invalidate_page,
2290 /* .sync_page = cifs_sync_page, */
2295 * cifs_readpages requires the server to support a buffer large enough to
2296 * contain the header plus one complete page of data. Otherwise, we need
2297 * to leave cifs_readpages out of the address space operations.
2299 const struct address_space_operations cifs_addr_ops_smallbuf = {
2300 .readpage = cifs_readpage,
2301 .writepage = cifs_writepage,
2302 .writepages = cifs_writepages,
2303 .write_begin = cifs_write_begin,
2304 .write_end = cifs_write_end,
2305 .set_page_dirty = __set_page_dirty_nobuffers,
2306 .releasepage = cifs_release_page,
2307 .invalidatepage = cifs_invalidate_page,
2308 /* .sync_page = cifs_sync_page, */