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"
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
, __u32 oplock
,
115 write_lock(&GlobalSMBSeslock
);
117 pCifsInode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
118 if (pCifsInode
== NULL
) {
119 write_unlock(&GlobalSMBSeslock
);
123 if (pCifsInode
->clientCanCacheRead
) {
124 /* we have the inode open somewhere else
125 no need to discard cache data */
126 goto psx_client_can_cache
;
129 /* BB FIXME need to fix this check to move it earlier into posix_open
130 BB fIX following section BB FIXME */
132 /* if not oplocked, invalidate inode pages if mtime or file
134 /* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
135 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
136 (file->f_path.dentry->d_inode->i_size ==
137 (loff_t)le64_to_cpu(buf->EndOfFile))) {
138 cFYI(1, "inode unchanged on server");
140 if (file->f_path.dentry->d_inode->i_mapping) {
141 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
143 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
145 cFYI(1, "invalidating remote inode since open detected it "
147 invalidate_remote_inode(file->f_path.dentry->d_inode);
150 psx_client_can_cache
:
151 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
152 pCifsInode
->clientCanCacheAll
= true;
153 pCifsInode
->clientCanCacheRead
= true;
154 cFYI(1, "Exclusive Oplock granted on inode %p",
155 file
->f_path
.dentry
->d_inode
);
156 } else if ((oplock
& 0xF) == OPLOCK_READ
)
157 pCifsInode
->clientCanCacheRead
= true;
159 /* will have to change the unlock if we reenable the
160 filemap_fdatawrite (which does not seem necessary */
161 write_unlock(&GlobalSMBSeslock
);
165 /* all arguments to this function must be checked for validity in caller */
166 static inline int cifs_open_inode_helper(struct inode
*inode
,
167 struct cifsTconInfo
*pTcon
, int *oplock
, FILE_ALL_INFO
*buf
,
168 char *full_path
, int xid
)
170 struct cifsInodeInfo
*pCifsInode
= CIFS_I(inode
);
171 struct timespec temp
;
174 if (pCifsInode
->clientCanCacheRead
) {
175 /* we have the inode open somewhere else
176 no need to discard cache data */
177 goto client_can_cache
;
180 /* BB need same check in cifs_create too? */
181 /* if not oplocked, invalidate inode pages if mtime or file
183 temp
= cifs_NTtimeToUnix(buf
->LastWriteTime
);
184 if (timespec_equal(&inode
->i_mtime
, &temp
) &&
186 (loff_t
)le64_to_cpu(buf
->EndOfFile
))) {
187 cFYI(1, "inode unchanged on server");
189 if (inode
->i_mapping
) {
190 /* BB no need to lock inode until after invalidate
191 since namei code should already have it locked? */
192 rc
= filemap_write_and_wait(inode
->i_mapping
);
194 pCifsInode
->write_behind_rc
= rc
;
196 cFYI(1, "invalidating remote inode since open detected it "
198 invalidate_remote_inode(inode
);
203 rc
= cifs_get_inode_info_unix(&inode
, full_path
, inode
->i_sb
,
206 rc
= cifs_get_inode_info(&inode
, full_path
, buf
, inode
->i_sb
,
209 if ((*oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
210 pCifsInode
->clientCanCacheAll
= true;
211 pCifsInode
->clientCanCacheRead
= true;
212 cFYI(1, "Exclusive Oplock granted on inode %p", inode
);
213 } else if ((*oplock
& 0xF) == OPLOCK_READ
)
214 pCifsInode
->clientCanCacheRead
= true;
219 int cifs_open(struct inode
*inode
, struct file
*file
)
224 struct cifs_sb_info
*cifs_sb
;
225 struct cifsTconInfo
*tcon
;
226 struct cifsFileInfo
*pCifsFile
= NULL
;
227 struct cifsInodeInfo
*pCifsInode
;
228 char *full_path
= NULL
;
232 FILE_ALL_INFO
*buf
= NULL
;
236 cifs_sb
= CIFS_SB(inode
->i_sb
);
237 tcon
= cifs_sb
->tcon
;
239 pCifsInode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
241 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
242 if (full_path
== NULL
) {
248 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
249 inode
, file
->f_flags
, full_path
);
256 if (!tcon
->broken_posix_open
&& tcon
->unix_ext
&&
257 (tcon
->ses
->capabilities
& CAP_UNIX
) &&
258 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
259 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
260 int oflags
= (int) cifs_posix_convert_flags(file
->f_flags
);
261 oflags
|= SMB_O_CREAT
;
262 /* can not refresh inode info since size could be stale */
263 rc
= cifs_posix_open(full_path
, &inode
, inode
->i_sb
,
264 cifs_sb
->mnt_file_mode
/* ignored */,
265 oflags
, &oplock
, &netfid
, xid
);
267 cFYI(1, "posix open succeeded");
268 /* no need for special case handling of setting mode
269 on read only files needed here */
271 rc
= cifs_posix_open_inode_helper(inode
, file
,
272 pCifsInode
, oplock
, netfid
);
274 CIFSSMBClose(xid
, tcon
, netfid
);
278 pCifsFile
= cifs_new_fileinfo(inode
, netfid
, file
,
281 if (pCifsFile
== NULL
) {
282 CIFSSMBClose(xid
, tcon
, netfid
);
286 } else if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
287 if (tcon
->ses
->serverNOS
)
288 cERROR(1, "server %s of type %s returned"
289 " unexpected error on SMB posix open"
290 ", disabling posix open support."
291 " Check if server update available.",
292 tcon
->ses
->serverName
,
293 tcon
->ses
->serverNOS
);
294 tcon
->broken_posix_open
= true;
295 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
296 (rc
!= -EOPNOTSUPP
)) /* path not found or net err */
298 /* else fallthrough to retry open the old way on network i/o
302 desiredAccess
= cifs_convert_flags(file
->f_flags
);
304 /*********************************************************************
305 * open flag mapping table:
307 * POSIX Flag CIFS Disposition
308 * ---------- ----------------
309 * O_CREAT FILE_OPEN_IF
310 * O_CREAT | O_EXCL FILE_CREATE
311 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
312 * O_TRUNC FILE_OVERWRITE
313 * none of the above FILE_OPEN
315 * Note that there is not a direct match between disposition
316 * FILE_SUPERSEDE (ie create whether or not file exists although
317 * O_CREAT | O_TRUNC is similar but truncates the existing
318 * file rather than creating a new file as FILE_SUPERSEDE does
319 * (which uses the attributes / metadata passed in on open call)
321 *? O_SYNC is a reasonable match to CIFS writethrough flag
322 *? and the read write flags match reasonably. O_LARGEFILE
323 *? is irrelevant because largefile support is always used
324 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
325 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
326 *********************************************************************/
328 disposition
= cifs_get_disposition(file
->f_flags
);
330 /* BB pass O_SYNC flag through on file attributes .. BB */
332 /* Also refresh inode by passing in file_info buf returned by SMBOpen
333 and calling get_inode_info with returned buf (at least helps
334 non-Unix server case) */
336 /* BB we can not do this if this is the second open of a file
337 and the first handle has writebehind data, we might be
338 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
339 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
345 if (cifs_sb
->tcon
->ses
->capabilities
& CAP_NT_SMBS
)
346 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
347 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
348 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
349 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
351 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
354 /* Old server, try legacy style OpenX */
355 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
356 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
357 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
358 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
361 cFYI(1, "cifs_open returned 0x%x", rc
);
365 rc
= cifs_open_inode_helper(inode
, tcon
, &oplock
, buf
, full_path
, xid
);
369 pCifsFile
= cifs_new_fileinfo(inode
, netfid
, file
, file
->f_path
.mnt
,
371 if (pCifsFile
== NULL
) {
376 if (oplock
& CIFS_CREATE_ACTION
) {
377 /* time to set mode which we can not set earlier due to
378 problems creating new read-only files */
379 if (tcon
->unix_ext
) {
380 struct cifs_unix_set_info_args args
= {
381 .mode
= inode
->i_mode
,
384 .ctime
= NO_CHANGE_64
,
385 .atime
= NO_CHANGE_64
,
386 .mtime
= NO_CHANGE_64
,
389 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
391 cifs_sb
->mnt_cifs_flags
&
392 CIFS_MOUNT_MAP_SPECIAL_CHR
);
403 /* Try to reacquire byte range locks that were released when session */
404 /* to server was lost */
405 static int cifs_relock_file(struct cifsFileInfo
*cifsFile
)
409 /* BB list all locks open on this file and relock */
414 static int cifs_reopen_file(struct file
*file
, bool can_flush
)
419 struct cifs_sb_info
*cifs_sb
;
420 struct cifsTconInfo
*tcon
;
421 struct cifsFileInfo
*pCifsFile
;
422 struct cifsInodeInfo
*pCifsInode
;
424 char *full_path
= NULL
;
426 int disposition
= FILE_OPEN
;
429 if (file
->private_data
)
430 pCifsFile
= (struct cifsFileInfo
*)file
->private_data
;
435 mutex_lock(&pCifsFile
->fh_mutex
);
436 if (!pCifsFile
->invalidHandle
) {
437 mutex_unlock(&pCifsFile
->fh_mutex
);
443 if (file
->f_path
.dentry
== NULL
) {
444 cERROR(1, "no valid name if dentry freed");
447 goto reopen_error_exit
;
450 inode
= file
->f_path
.dentry
->d_inode
;
452 cERROR(1, "inode not valid");
455 goto reopen_error_exit
;
458 cifs_sb
= CIFS_SB(inode
->i_sb
);
459 tcon
= cifs_sb
->tcon
;
461 /* can not grab rename sem here because various ops, including
462 those that already have the rename sem can end up causing writepage
463 to get called and if the server was down that means we end up here,
464 and we can never tell if the caller already has the rename_sem */
465 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
466 if (full_path
== NULL
) {
469 mutex_unlock(&pCifsFile
->fh_mutex
);
474 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
475 inode
, file
->f_flags
, full_path
);
482 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
483 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
484 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
485 int oflags
= (int) cifs_posix_convert_flags(file
->f_flags
);
486 /* can not refresh inode info since size could be stale */
487 rc
= cifs_posix_open(full_path
, NULL
, inode
->i_sb
,
488 cifs_sb
->mnt_file_mode
/* ignored */,
489 oflags
, &oplock
, &netfid
, xid
);
491 cFYI(1, "posix reopen succeeded");
494 /* fallthrough to retry open the old way on errors, especially
495 in the reconnect path it is important to retry hard */
498 desiredAccess
= cifs_convert_flags(file
->f_flags
);
500 /* Can not refresh inode by passing in file_info buf to be returned
501 by SMBOpen and then calling get_inode_info with returned buf
502 since file might have write behind data that needs to be flushed
503 and server version of file size can be stale. If we knew for sure
504 that inode was not dirty locally we could do this */
506 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
, desiredAccess
,
507 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
508 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
509 CIFS_MOUNT_MAP_SPECIAL_CHR
);
511 mutex_unlock(&pCifsFile
->fh_mutex
);
512 cFYI(1, "cifs_open returned 0x%x", rc
);
513 cFYI(1, "oplock: %d", oplock
);
516 pCifsFile
->netfid
= netfid
;
517 pCifsFile
->invalidHandle
= false;
518 mutex_unlock(&pCifsFile
->fh_mutex
);
519 pCifsInode
= CIFS_I(inode
);
522 rc
= filemap_write_and_wait(inode
->i_mapping
);
524 CIFS_I(inode
)->write_behind_rc
= rc
;
525 /* temporarily disable caching while we
526 go to server to get inode info */
527 pCifsInode
->clientCanCacheAll
= false;
528 pCifsInode
->clientCanCacheRead
= false;
530 rc
= cifs_get_inode_info_unix(&inode
,
531 full_path
, inode
->i_sb
, xid
);
533 rc
= cifs_get_inode_info(&inode
,
534 full_path
, NULL
, inode
->i_sb
,
536 } /* else we are writing out data to server already
537 and could deadlock if we tried to flush data, and
538 since we do not know if we have data that would
539 invalidate the current end of file on the server
540 we can not go to the server to get the new inod
542 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
543 pCifsInode
->clientCanCacheAll
= true;
544 pCifsInode
->clientCanCacheRead
= true;
545 cFYI(1, "Exclusive Oplock granted on inode %p",
546 file
->f_path
.dentry
->d_inode
);
547 } else if ((oplock
& 0xF) == OPLOCK_READ
) {
548 pCifsInode
->clientCanCacheRead
= true;
549 pCifsInode
->clientCanCacheAll
= false;
551 pCifsInode
->clientCanCacheRead
= false;
552 pCifsInode
->clientCanCacheAll
= false;
554 cifs_relock_file(pCifsFile
);
562 int cifs_close(struct inode
*inode
, struct file
*file
)
566 struct cifs_sb_info
*cifs_sb
;
567 struct cifsTconInfo
*pTcon
;
568 struct cifsFileInfo
*pSMBFile
=
569 (struct cifsFileInfo
*)file
->private_data
;
573 cifs_sb
= CIFS_SB(inode
->i_sb
);
574 pTcon
= cifs_sb
->tcon
;
576 struct cifsLockInfo
*li
, *tmp
;
577 write_lock(&GlobalSMBSeslock
);
578 pSMBFile
->closePend
= true;
580 /* no sense reconnecting to close a file that is
582 if (!pTcon
->need_reconnect
) {
583 write_unlock(&GlobalSMBSeslock
);
585 while ((atomic_read(&pSMBFile
->count
) != 1)
586 && (timeout
<= 2048)) {
587 /* Give write a better chance to get to
588 server ahead of the close. We do not
589 want to add a wait_q here as it would
590 increase the memory utilization as
591 the struct would be in each open file,
592 but this should give enough time to
594 cFYI(DBG2
, "close delay, write pending");
598 if (!pTcon
->need_reconnect
&&
599 !pSMBFile
->invalidHandle
)
600 rc
= CIFSSMBClose(xid
, pTcon
,
603 write_unlock(&GlobalSMBSeslock
);
605 write_unlock(&GlobalSMBSeslock
);
607 /* Delete any outstanding lock records.
608 We'll lose them when the file is closed anyway. */
609 mutex_lock(&pSMBFile
->lock_mutex
);
610 list_for_each_entry_safe(li
, tmp
, &pSMBFile
->llist
, llist
) {
611 list_del(&li
->llist
);
614 mutex_unlock(&pSMBFile
->lock_mutex
);
616 write_lock(&GlobalSMBSeslock
);
617 list_del(&pSMBFile
->flist
);
618 list_del(&pSMBFile
->tlist
);
619 write_unlock(&GlobalSMBSeslock
);
620 cifsFileInfo_put(file
->private_data
);
621 file
->private_data
= NULL
;
625 read_lock(&GlobalSMBSeslock
);
626 if (list_empty(&(CIFS_I(inode
)->openFileList
))) {
627 cFYI(1, "closing last open instance for inode %p", inode
);
628 /* if the file is not open we do not know if we can cache info
629 on this inode, much less write behind and read ahead */
630 CIFS_I(inode
)->clientCanCacheRead
= false;
631 CIFS_I(inode
)->clientCanCacheAll
= false;
633 read_unlock(&GlobalSMBSeslock
);
634 if ((rc
== 0) && CIFS_I(inode
)->write_behind_rc
)
635 rc
= CIFS_I(inode
)->write_behind_rc
;
640 int cifs_closedir(struct inode
*inode
, struct file
*file
)
644 struct cifsFileInfo
*pCFileStruct
=
645 (struct cifsFileInfo
*)file
->private_data
;
648 cFYI(1, "Closedir inode = 0x%p", inode
);
653 struct cifsTconInfo
*pTcon
;
654 struct cifs_sb_info
*cifs_sb
=
655 CIFS_SB(file
->f_path
.dentry
->d_sb
);
657 pTcon
= cifs_sb
->tcon
;
659 cFYI(1, "Freeing private data in close dir");
660 write_lock(&GlobalSMBSeslock
);
661 if (!pCFileStruct
->srch_inf
.endOfSearch
&&
662 !pCFileStruct
->invalidHandle
) {
663 pCFileStruct
->invalidHandle
= true;
664 write_unlock(&GlobalSMBSeslock
);
665 rc
= CIFSFindClose(xid
, pTcon
, pCFileStruct
->netfid
);
666 cFYI(1, "Closing uncompleted readdir with rc %d",
668 /* not much we can do if it fails anyway, ignore rc */
671 write_unlock(&GlobalSMBSeslock
);
672 ptmp
= pCFileStruct
->srch_inf
.ntwrk_buf_start
;
674 cFYI(1, "closedir free smb buf in srch struct");
675 pCFileStruct
->srch_inf
.ntwrk_buf_start
= NULL
;
676 if (pCFileStruct
->srch_inf
.smallBuf
)
677 cifs_small_buf_release(ptmp
);
679 cifs_buf_release(ptmp
);
681 kfree(file
->private_data
);
682 file
->private_data
= NULL
;
684 /* BB can we lock the filestruct while this is going on? */
689 static int store_file_lock(struct cifsFileInfo
*fid
, __u64 len
,
690 __u64 offset
, __u8 lockType
)
692 struct cifsLockInfo
*li
=
693 kmalloc(sizeof(struct cifsLockInfo
), GFP_KERNEL
);
699 mutex_lock(&fid
->lock_mutex
);
700 list_add(&li
->llist
, &fid
->llist
);
701 mutex_unlock(&fid
->lock_mutex
);
705 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*pfLock
)
711 bool wait_flag
= false;
712 struct cifs_sb_info
*cifs_sb
;
713 struct cifsTconInfo
*tcon
;
715 __u8 lockType
= LOCKING_ANDX_LARGE_FILES
;
716 bool posix_locking
= 0;
718 length
= 1 + pfLock
->fl_end
- pfLock
->fl_start
;
722 cFYI(1, "Lock parm: 0x%x flockflags: "
723 "0x%x flocktype: 0x%x start: %lld end: %lld",
724 cmd
, pfLock
->fl_flags
, pfLock
->fl_type
, pfLock
->fl_start
,
727 if (pfLock
->fl_flags
& FL_POSIX
)
729 if (pfLock
->fl_flags
& FL_FLOCK
)
731 if (pfLock
->fl_flags
& FL_SLEEP
) {
732 cFYI(1, "Blocking lock");
735 if (pfLock
->fl_flags
& FL_ACCESS
)
736 cFYI(1, "Process suspended by mandatory locking - "
737 "not implemented yet");
738 if (pfLock
->fl_flags
& FL_LEASE
)
739 cFYI(1, "Lease on file - not implemented yet");
740 if (pfLock
->fl_flags
&
741 (~(FL_POSIX
| FL_FLOCK
| FL_SLEEP
| FL_ACCESS
| FL_LEASE
)))
742 cFYI(1, "Unknown lock flags 0x%x", pfLock
->fl_flags
);
744 if (pfLock
->fl_type
== F_WRLCK
) {
747 } else if (pfLock
->fl_type
== F_UNLCK
) {
750 /* Check if unlock includes more than
752 } else if (pfLock
->fl_type
== F_RDLCK
) {
754 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
756 } else if (pfLock
->fl_type
== F_EXLCK
) {
759 } else if (pfLock
->fl_type
== F_SHLCK
) {
761 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
764 cFYI(1, "Unknown type of lock");
766 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
767 tcon
= cifs_sb
->tcon
;
769 if (file
->private_data
== NULL
) {
774 netfid
= ((struct cifsFileInfo
*)file
->private_data
)->netfid
;
776 if ((tcon
->ses
->capabilities
& CAP_UNIX
) &&
777 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
778 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
780 /* BB add code here to normalize offset and length to
781 account for negative length which we can not accept over the
786 if (lockType
& LOCKING_ANDX_SHARED_LOCK
)
787 posix_lock_type
= CIFS_RDLCK
;
789 posix_lock_type
= CIFS_WRLCK
;
790 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, 1 /* get */,
792 posix_lock_type
, wait_flag
);
797 /* BB we could chain these into one lock request BB */
798 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
, pfLock
->fl_start
,
799 0, 1, lockType
, 0 /* wait flag */ );
801 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
802 pfLock
->fl_start
, 1 /* numUnlock */ ,
803 0 /* numLock */ , lockType
,
805 pfLock
->fl_type
= F_UNLCK
;
807 cERROR(1, "Error unlocking previously locked "
808 "range %d during test of lock", rc
);
812 /* if rc == ERR_SHARING_VIOLATION ? */
815 if (lockType
& LOCKING_ANDX_SHARED_LOCK
) {
816 pfLock
->fl_type
= F_WRLCK
;
818 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
819 pfLock
->fl_start
, 0, 1,
820 lockType
| LOCKING_ANDX_SHARED_LOCK
,
823 rc
= CIFSSMBLock(xid
, tcon
, netfid
,
824 length
, pfLock
->fl_start
, 1, 0,
826 LOCKING_ANDX_SHARED_LOCK
,
828 pfLock
->fl_type
= F_RDLCK
;
830 cERROR(1, "Error unlocking "
831 "previously locked range %d "
832 "during test of lock", rc
);
835 pfLock
->fl_type
= F_WRLCK
;
845 if (!numLock
&& !numUnlock
) {
846 /* if no lock or unlock then nothing
847 to do since we do not know what it is */
854 if (lockType
& LOCKING_ANDX_SHARED_LOCK
)
855 posix_lock_type
= CIFS_RDLCK
;
857 posix_lock_type
= CIFS_WRLCK
;
860 posix_lock_type
= CIFS_UNLCK
;
862 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, 0 /* set */,
864 posix_lock_type
, wait_flag
);
866 struct cifsFileInfo
*fid
=
867 (struct cifsFileInfo
*)file
->private_data
;
870 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
872 0, numLock
, lockType
, wait_flag
);
875 /* For Windows locks we must store them. */
876 rc
= store_file_lock(fid
, length
,
877 pfLock
->fl_start
, lockType
);
879 } else if (numUnlock
) {
880 /* For each stored lock that this unlock overlaps
881 completely, unlock it. */
883 struct cifsLockInfo
*li
, *tmp
;
886 mutex_lock(&fid
->lock_mutex
);
887 list_for_each_entry_safe(li
, tmp
, &fid
->llist
, llist
) {
888 if (pfLock
->fl_start
<= li
->offset
&&
889 (pfLock
->fl_start
+ length
) >=
890 (li
->offset
+ li
->length
)) {
891 stored_rc
= CIFSSMBLock(xid
, tcon
,
893 li
->length
, li
->offset
,
894 1, 0, li
->type
, false);
898 list_del(&li
->llist
);
903 mutex_unlock(&fid
->lock_mutex
);
907 if (pfLock
->fl_flags
& FL_POSIX
)
908 posix_lock_file_wait(file
, pfLock
);
914 * Set the timeout on write requests past EOF. For some servers (Windows)
915 * these calls can be very long.
917 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
918 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
919 * The 10M cutoff is totally arbitrary. A better scheme for this would be
920 * welcome if someone wants to suggest one.
922 * We may be able to do a better job with this if there were some way to
923 * declare that a file should be sparse.
926 cifs_write_timeout(struct cifsInodeInfo
*cifsi
, loff_t offset
)
928 if (offset
<= cifsi
->server_eof
)
930 else if (offset
> (cifsi
->server_eof
+ (10 * 1024 * 1024)))
931 return CIFS_VLONG_OP
;
936 /* update the file size (if needed) after a write */
938 cifs_update_eof(struct cifsInodeInfo
*cifsi
, loff_t offset
,
939 unsigned int bytes_written
)
941 loff_t end_of_write
= offset
+ bytes_written
;
943 if (end_of_write
> cifsi
->server_eof
)
944 cifsi
->server_eof
= end_of_write
;
947 ssize_t
cifs_user_write(struct file
*file
, const char __user
*write_data
,
948 size_t write_size
, loff_t
*poffset
)
951 unsigned int bytes_written
= 0;
952 unsigned int total_written
;
953 struct cifs_sb_info
*cifs_sb
;
954 struct cifsTconInfo
*pTcon
;
956 struct cifsFileInfo
*open_file
;
957 struct cifsInodeInfo
*cifsi
= CIFS_I(file
->f_path
.dentry
->d_inode
);
959 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
961 pTcon
= cifs_sb
->tcon
;
963 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
964 *poffset, file->f_path.dentry->d_name.name); */
966 if (file
->private_data
== NULL
)
968 open_file
= (struct cifsFileInfo
*) file
->private_data
;
970 rc
= generic_write_checks(file
, poffset
, &write_size
, 0);
976 long_op
= cifs_write_timeout(cifsi
, *poffset
);
977 for (total_written
= 0; write_size
> total_written
;
978 total_written
+= bytes_written
) {
980 while (rc
== -EAGAIN
) {
981 if (file
->private_data
== NULL
) {
982 /* file has been closed on us */
984 /* if we have gotten here we have written some data
985 and blocked, and the file has been freed on us while
986 we blocked so return what we managed to write */
987 return total_written
;
989 if (open_file
->closePend
) {
992 return total_written
;
996 if (open_file
->invalidHandle
) {
997 /* we could deadlock if we called
998 filemap_fdatawait from here so tell
999 reopen_file not to flush data to server
1001 rc
= cifs_reopen_file(file
, false);
1006 rc
= CIFSSMBWrite(xid
, pTcon
,
1008 min_t(const int, cifs_sb
->wsize
,
1009 write_size
- total_written
),
1010 *poffset
, &bytes_written
,
1011 NULL
, write_data
+ total_written
, long_op
);
1013 if (rc
|| (bytes_written
== 0)) {
1021 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1022 *poffset
+= bytes_written
;
1024 long_op
= CIFS_STD_OP
; /* subsequent writes fast -
1025 15 seconds is plenty */
1028 cifs_stats_bytes_written(pTcon
, total_written
);
1030 /* since the write may have blocked check these pointers again */
1031 if ((file
->f_path
.dentry
) && (file
->f_path
.dentry
->d_inode
)) {
1032 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1033 /* Do not update local mtime - server will set its actual value on write
1034 * inode->i_ctime = inode->i_mtime =
1035 * current_fs_time(inode->i_sb);*/
1036 if (total_written
> 0) {
1037 spin_lock(&inode
->i_lock
);
1038 if (*poffset
> file
->f_path
.dentry
->d_inode
->i_size
)
1039 i_size_write(file
->f_path
.dentry
->d_inode
,
1041 spin_unlock(&inode
->i_lock
);
1043 mark_inode_dirty_sync(file
->f_path
.dentry
->d_inode
);
1046 return total_written
;
1049 static ssize_t
cifs_write(struct file
*file
, const char *write_data
,
1050 size_t write_size
, loff_t
*poffset
)
1053 unsigned int bytes_written
= 0;
1054 unsigned int total_written
;
1055 struct cifs_sb_info
*cifs_sb
;
1056 struct cifsTconInfo
*pTcon
;
1058 struct cifsFileInfo
*open_file
;
1059 struct cifsInodeInfo
*cifsi
= CIFS_I(file
->f_path
.dentry
->d_inode
);
1061 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1063 pTcon
= cifs_sb
->tcon
;
1065 cFYI(1, "write %zd bytes to offset %lld of %s", write_size
,
1066 *poffset
, file
->f_path
.dentry
->d_name
.name
);
1068 if (file
->private_data
== NULL
)
1070 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1074 long_op
= cifs_write_timeout(cifsi
, *poffset
);
1075 for (total_written
= 0; write_size
> total_written
;
1076 total_written
+= bytes_written
) {
1078 while (rc
== -EAGAIN
) {
1079 if (file
->private_data
== NULL
) {
1080 /* file has been closed on us */
1082 /* if we have gotten here we have written some data
1083 and blocked, and the file has been freed on us
1084 while we blocked so return what we managed to
1086 return total_written
;
1088 if (open_file
->closePend
) {
1091 return total_written
;
1095 if (open_file
->invalidHandle
) {
1096 /* we could deadlock if we called
1097 filemap_fdatawait from here so tell
1098 reopen_file not to flush data to
1100 rc
= cifs_reopen_file(file
, false);
1104 if (experimEnabled
|| (pTcon
->ses
->server
&&
1105 ((pTcon
->ses
->server
->secMode
&
1106 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
1111 len
= min((size_t)cifs_sb
->wsize
,
1112 write_size
- total_written
);
1113 /* iov[0] is reserved for smb header */
1114 iov
[1].iov_base
= (char *)write_data
+
1116 iov
[1].iov_len
= len
;
1117 rc
= CIFSSMBWrite2(xid
, pTcon
,
1118 open_file
->netfid
, len
,
1119 *poffset
, &bytes_written
,
1122 rc
= CIFSSMBWrite(xid
, pTcon
,
1124 min_t(const int, cifs_sb
->wsize
,
1125 write_size
- total_written
),
1126 *poffset
, &bytes_written
,
1127 write_data
+ total_written
,
1130 if (rc
|| (bytes_written
== 0)) {
1138 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1139 *poffset
+= bytes_written
;
1141 long_op
= CIFS_STD_OP
; /* subsequent writes fast -
1142 15 seconds is plenty */
1145 cifs_stats_bytes_written(pTcon
, total_written
);
1147 /* since the write may have blocked check these pointers again */
1148 if ((file
->f_path
.dentry
) && (file
->f_path
.dentry
->d_inode
)) {
1149 /*BB We could make this contingent on superblock ATIME flag too */
1150 /* file->f_path.dentry->d_inode->i_ctime =
1151 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1152 if (total_written
> 0) {
1153 spin_lock(&file
->f_path
.dentry
->d_inode
->i_lock
);
1154 if (*poffset
> file
->f_path
.dentry
->d_inode
->i_size
)
1155 i_size_write(file
->f_path
.dentry
->d_inode
,
1157 spin_unlock(&file
->f_path
.dentry
->d_inode
->i_lock
);
1159 mark_inode_dirty_sync(file
->f_path
.dentry
->d_inode
);
1162 return total_written
;
1165 #ifdef CONFIG_CIFS_EXPERIMENTAL
1166 struct cifsFileInfo
*find_readable_file(struct cifsInodeInfo
*cifs_inode
)
1168 struct cifsFileInfo
*open_file
= NULL
;
1170 read_lock(&GlobalSMBSeslock
);
1171 /* we could simply get the first_list_entry since write-only entries
1172 are always at the end of the list but since the first entry might
1173 have a close pending, we go through the whole list */
1174 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1175 if (open_file
->closePend
)
1177 if (open_file
->pfile
&& ((open_file
->pfile
->f_flags
& O_RDWR
) ||
1178 (open_file
->pfile
->f_flags
& O_RDONLY
))) {
1179 if (!open_file
->invalidHandle
) {
1180 /* found a good file */
1181 /* lock it so it will not be closed on us */
1182 cifsFileInfo_get(open_file
);
1183 read_unlock(&GlobalSMBSeslock
);
1185 } /* else might as well continue, and look for
1186 another, or simply have the caller reopen it
1187 again rather than trying to fix this handle */
1188 } else /* write only file */
1189 break; /* write only files are last so must be done */
1191 read_unlock(&GlobalSMBSeslock
);
1196 struct cifsFileInfo
*find_writable_file(struct cifsInodeInfo
*cifs_inode
)
1198 struct cifsFileInfo
*open_file
;
1199 bool any_available
= false;
1202 /* Having a null inode here (because mapping->host was set to zero by
1203 the VFS or MM) should not happen but we had reports of on oops (due to
1204 it being zero) during stress testcases so we need to check for it */
1206 if (cifs_inode
== NULL
) {
1207 cERROR(1, "Null inode passed to cifs_writeable_file");
1212 read_lock(&GlobalSMBSeslock
);
1214 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1215 if (open_file
->closePend
||
1216 (!any_available
&& open_file
->pid
!= current
->tgid
))
1219 if (open_file
->pfile
&&
1220 ((open_file
->pfile
->f_flags
& O_RDWR
) ||
1221 (open_file
->pfile
->f_flags
& O_WRONLY
))) {
1222 cifsFileInfo_get(open_file
);
1224 if (!open_file
->invalidHandle
) {
1225 /* found a good writable file */
1226 read_unlock(&GlobalSMBSeslock
);
1230 read_unlock(&GlobalSMBSeslock
);
1231 /* Had to unlock since following call can block */
1232 rc
= cifs_reopen_file(open_file
->pfile
, false);
1234 if (!open_file
->closePend
)
1236 else { /* start over in case this was deleted */
1237 /* since the list could be modified */
1238 read_lock(&GlobalSMBSeslock
);
1239 cifsFileInfo_put(open_file
);
1240 goto refind_writable
;
1244 /* if it fails, try another handle if possible -
1245 (we can not do this if closePending since
1246 loop could be modified - in which case we
1247 have to start at the beginning of the list
1248 again. Note that it would be bad
1249 to hold up writepages here (rather than
1250 in caller) with continuous retries */
1251 cFYI(1, "wp failed on reopen file");
1252 read_lock(&GlobalSMBSeslock
);
1253 /* can not use this handle, no write
1254 pending on this one after all */
1255 cifsFileInfo_put(open_file
);
1257 if (open_file
->closePend
) /* list could have changed */
1258 goto refind_writable
;
1259 /* else we simply continue to the next entry. Thus
1260 we do not loop on reopen errors. If we
1261 can not reopen the file, for example if we
1262 reconnected to a server with another client
1263 racing to delete or lock the file we would not
1264 make progress if we restarted before the beginning
1265 of the loop here. */
1268 /* couldn't find useable FH with same pid, try any available */
1269 if (!any_available
) {
1270 any_available
= true;
1271 goto refind_writable
;
1273 read_unlock(&GlobalSMBSeslock
);
1277 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
1279 struct address_space
*mapping
= page
->mapping
;
1280 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1283 int bytes_written
= 0;
1284 struct cifs_sb_info
*cifs_sb
;
1285 struct cifsTconInfo
*pTcon
;
1286 struct inode
*inode
;
1287 struct cifsFileInfo
*open_file
;
1289 if (!mapping
|| !mapping
->host
)
1292 inode
= page
->mapping
->host
;
1293 cifs_sb
= CIFS_SB(inode
->i_sb
);
1294 pTcon
= cifs_sb
->tcon
;
1296 offset
+= (loff_t
)from
;
1297 write_data
= kmap(page
);
1300 if ((to
> PAGE_CACHE_SIZE
) || (from
> to
)) {
1305 /* racing with truncate? */
1306 if (offset
> mapping
->host
->i_size
) {
1308 return 0; /* don't care */
1311 /* check to make sure that we are not extending the file */
1312 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
1313 to
= (unsigned)(mapping
->host
->i_size
- offset
);
1315 open_file
= find_writable_file(CIFS_I(mapping
->host
));
1317 bytes_written
= cifs_write(open_file
->pfile
, write_data
,
1319 cifsFileInfo_put(open_file
);
1320 /* Does mm or vfs already set times? */
1321 inode
->i_atime
= inode
->i_mtime
= current_fs_time(inode
->i_sb
);
1322 if ((bytes_written
> 0) && (offset
))
1324 else if (bytes_written
< 0)
1327 cFYI(1, "No writeable filehandles for inode");
1335 static int cifs_writepages(struct address_space
*mapping
,
1336 struct writeback_control
*wbc
)
1338 struct backing_dev_info
*bdi
= mapping
->backing_dev_info
;
1339 unsigned int bytes_to_write
;
1340 unsigned int bytes_written
;
1341 struct cifs_sb_info
*cifs_sb
;
1345 int range_whole
= 0;
1352 struct cifsFileInfo
*open_file
;
1353 struct cifsInodeInfo
*cifsi
= CIFS_I(mapping
->host
);
1355 struct pagevec pvec
;
1360 cifs_sb
= CIFS_SB(mapping
->host
->i_sb
);
1363 * If wsize is smaller that the page cache size, default to writing
1364 * one page at a time via cifs_writepage
1366 if (cifs_sb
->wsize
< PAGE_CACHE_SIZE
)
1367 return generic_writepages(mapping
, wbc
);
1369 if ((cifs_sb
->tcon
->ses
) && (cifs_sb
->tcon
->ses
->server
))
1370 if (cifs_sb
->tcon
->ses
->server
->secMode
&
1371 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
1372 if (!experimEnabled
)
1373 return generic_writepages(mapping
, wbc
);
1375 iov
= kmalloc(32 * sizeof(struct kvec
), GFP_KERNEL
);
1377 return generic_writepages(mapping
, wbc
);
1381 * BB: Is this meaningful for a non-block-device file system?
1382 * If it is, we should test it again after we do I/O
1384 if (wbc
->nonblocking
&& bdi_write_congested(bdi
)) {
1385 wbc
->encountered_congestion
= 1;
1392 pagevec_init(&pvec
, 0);
1393 if (wbc
->range_cyclic
) {
1394 index
= mapping
->writeback_index
; /* Start from prev offset */
1397 index
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
1398 end
= wbc
->range_end
>> PAGE_CACHE_SHIFT
;
1399 if (wbc
->range_start
== 0 && wbc
->range_end
== LLONG_MAX
)
1404 while (!done
&& (index
<= end
) &&
1405 (nr_pages
= pagevec_lookup_tag(&pvec
, mapping
, &index
,
1406 PAGECACHE_TAG_DIRTY
,
1407 min(end
- index
, (pgoff_t
)PAGEVEC_SIZE
- 1) + 1))) {
1416 for (i
= 0; i
< nr_pages
; i
++) {
1417 page
= pvec
.pages
[i
];
1419 * At this point we hold neither mapping->tree_lock nor
1420 * lock on the page itself: the page may be truncated or
1421 * invalidated (changing page->mapping to NULL), or even
1422 * swizzled back from swapper_space to tmpfs file
1428 else if (!trylock_page(page
))
1431 if (unlikely(page
->mapping
!= mapping
)) {
1436 if (!wbc
->range_cyclic
&& page
->index
> end
) {
1442 if (next
&& (page
->index
!= next
)) {
1443 /* Not next consecutive page */
1448 if (wbc
->sync_mode
!= WB_SYNC_NONE
)
1449 wait_on_page_writeback(page
);
1451 if (PageWriteback(page
) ||
1452 !clear_page_dirty_for_io(page
)) {
1458 * This actually clears the dirty bit in the radix tree.
1459 * See cifs_writepage() for more commentary.
1461 set_page_writeback(page
);
1463 if (page_offset(page
) >= mapping
->host
->i_size
) {
1466 end_page_writeback(page
);
1471 * BB can we get rid of this? pages are held by pvec
1473 page_cache_get(page
);
1475 len
= min(mapping
->host
->i_size
- page_offset(page
),
1476 (loff_t
)PAGE_CACHE_SIZE
);
1478 /* reserve iov[0] for the smb header */
1480 iov
[n_iov
].iov_base
= kmap(page
);
1481 iov
[n_iov
].iov_len
= len
;
1482 bytes_to_write
+= len
;
1486 offset
= page_offset(page
);
1488 next
= page
->index
+ 1;
1489 if (bytes_to_write
+ PAGE_CACHE_SIZE
> cifs_sb
->wsize
)
1493 /* Search for a writable handle every time we call
1494 * CIFSSMBWrite2. We can't rely on the last handle
1495 * we used to still be valid
1497 open_file
= find_writable_file(CIFS_I(mapping
->host
));
1499 cERROR(1, "No writable handles for inode");
1502 long_op
= cifs_write_timeout(cifsi
, offset
);
1503 rc
= CIFSSMBWrite2(xid
, cifs_sb
->tcon
,
1505 bytes_to_write
, offset
,
1506 &bytes_written
, iov
, n_iov
,
1508 cifsFileInfo_put(open_file
);
1509 cifs_update_eof(cifsi
, offset
, bytes_written
);
1511 if (rc
|| bytes_written
< bytes_to_write
) {
1512 cERROR(1, "Write2 ret %d, wrote %d",
1514 /* BB what if continued retry is
1515 requested via mount flags? */
1517 set_bit(AS_ENOSPC
, &mapping
->flags
);
1519 set_bit(AS_EIO
, &mapping
->flags
);
1521 cifs_stats_bytes_written(cifs_sb
->tcon
,
1525 for (i
= 0; i
< n_iov
; i
++) {
1526 page
= pvec
.pages
[first
+ i
];
1527 /* Should we also set page error on
1528 success rc but too little data written? */
1529 /* BB investigate retry logic on temporary
1530 server crash cases and how recovery works
1531 when page marked as error */
1536 end_page_writeback(page
);
1537 page_cache_release(page
);
1539 if ((wbc
->nr_to_write
-= n_iov
) <= 0)
1543 /* Need to re-find the pages we skipped */
1544 index
= pvec
.pages
[0]->index
+ 1;
1546 pagevec_release(&pvec
);
1548 if (!scanned
&& !done
) {
1550 * We hit the last page and there is more work to be done: wrap
1551 * back to the start of the file
1557 if (wbc
->range_cyclic
|| (range_whole
&& wbc
->nr_to_write
> 0))
1558 mapping
->writeback_index
= index
;
1565 static int cifs_writepage(struct page
*page
, struct writeback_control
*wbc
)
1571 /* BB add check for wbc flags */
1572 page_cache_get(page
);
1573 if (!PageUptodate(page
))
1574 cFYI(1, "ppw - page not up to date");
1577 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1579 * A writepage() implementation always needs to do either this,
1580 * or re-dirty the page with "redirty_page_for_writepage()" in
1581 * the case of a failure.
1583 * Just unlocking the page will cause the radix tree tag-bits
1584 * to fail to update with the state of the page correctly.
1586 set_page_writeback(page
);
1587 rc
= cifs_partialpagewrite(page
, 0, PAGE_CACHE_SIZE
);
1588 SetPageUptodate(page
); /* BB add check for error and Clearuptodate? */
1590 end_page_writeback(page
);
1591 page_cache_release(page
);
1596 static int cifs_write_end(struct file
*file
, struct address_space
*mapping
,
1597 loff_t pos
, unsigned len
, unsigned copied
,
1598 struct page
*page
, void *fsdata
)
1601 struct inode
*inode
= mapping
->host
;
1603 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1606 if (PageChecked(page
)) {
1608 SetPageUptodate(page
);
1609 ClearPageChecked(page
);
1610 } else if (!PageUptodate(page
) && copied
== PAGE_CACHE_SIZE
)
1611 SetPageUptodate(page
);
1613 if (!PageUptodate(page
)) {
1615 unsigned offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1619 /* this is probably better than directly calling
1620 partialpage_write since in this function the file handle is
1621 known which we might as well leverage */
1622 /* BB check if anything else missing out of ppw
1623 such as updating last write time */
1624 page_data
= kmap(page
);
1625 rc
= cifs_write(file
, page_data
+ offset
, copied
, &pos
);
1626 /* if (rc < 0) should we set writebehind rc? */
1633 set_page_dirty(page
);
1637 spin_lock(&inode
->i_lock
);
1638 if (pos
> inode
->i_size
)
1639 i_size_write(inode
, pos
);
1640 spin_unlock(&inode
->i_lock
);
1644 page_cache_release(page
);
1649 int cifs_fsync(struct file
*file
, int datasync
)
1653 struct cifsTconInfo
*tcon
;
1654 struct cifsFileInfo
*smbfile
=
1655 (struct cifsFileInfo
*)file
->private_data
;
1656 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1660 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1661 file
->f_path
.dentry
->d_name
.name
, datasync
);
1663 rc
= filemap_write_and_wait(inode
->i_mapping
);
1665 rc
= CIFS_I(inode
)->write_behind_rc
;
1666 CIFS_I(inode
)->write_behind_rc
= 0;
1667 tcon
= CIFS_SB(inode
->i_sb
)->tcon
;
1668 if (!rc
&& tcon
&& smbfile
&&
1669 !(CIFS_SB(inode
->i_sb
)->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
))
1670 rc
= CIFSSMBFlush(xid
, tcon
, smbfile
->netfid
);
1677 /* static void cifs_sync_page(struct page *page)
1679 struct address_space *mapping;
1680 struct inode *inode;
1681 unsigned long index = page->index;
1682 unsigned int rpages = 0;
1685 cFYI(1, "sync page %p", page);
1686 mapping = page->mapping;
1689 inode = mapping->host;
1693 /* fill in rpages then
1694 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1696 /* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1706 * As file closes, flush all cached write data for this inode checking
1707 * for write behind errors.
1709 int cifs_flush(struct file
*file
, fl_owner_t id
)
1711 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1714 /* Rather than do the steps manually:
1715 lock the inode for writing
1716 loop through pages looking for write behind data (dirty pages)
1717 coalesce into contiguous 16K (or smaller) chunks to write to server
1718 send to server (prefer in parallel)
1719 deal with writebehind errors
1720 unlock inode for writing
1721 filemapfdatawrite appears easier for the time being */
1723 rc
= filemap_fdatawrite(inode
->i_mapping
);
1724 /* reset wb rc if we were able to write out dirty pages */
1726 rc
= CIFS_I(inode
)->write_behind_rc
;
1727 CIFS_I(inode
)->write_behind_rc
= 0;
1730 cFYI(1, "Flush inode %p file %p rc %d", inode
, file
, rc
);
1735 ssize_t
cifs_user_read(struct file
*file
, char __user
*read_data
,
1736 size_t read_size
, loff_t
*poffset
)
1739 unsigned int bytes_read
= 0;
1740 unsigned int total_read
= 0;
1741 unsigned int current_read_size
;
1742 struct cifs_sb_info
*cifs_sb
;
1743 struct cifsTconInfo
*pTcon
;
1745 struct cifsFileInfo
*open_file
;
1746 char *smb_read_data
;
1747 char __user
*current_offset
;
1748 struct smb_com_read_rsp
*pSMBr
;
1751 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1752 pTcon
= cifs_sb
->tcon
;
1754 if (file
->private_data
== NULL
) {
1759 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1761 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1762 cFYI(1, "attempting read on write only file instance");
1764 for (total_read
= 0, current_offset
= read_data
;
1765 read_size
> total_read
;
1766 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1767 current_read_size
= min_t(const int, read_size
- total_read
,
1770 smb_read_data
= NULL
;
1771 while (rc
== -EAGAIN
) {
1772 int buf_type
= CIFS_NO_BUFFER
;
1773 if ((open_file
->invalidHandle
) &&
1774 (!open_file
->closePend
)) {
1775 rc
= cifs_reopen_file(file
, true);
1779 rc
= CIFSSMBRead(xid
, pTcon
,
1781 current_read_size
, *poffset
,
1782 &bytes_read
, &smb_read_data
,
1784 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
1785 if (smb_read_data
) {
1786 if (copy_to_user(current_offset
,
1788 4 /* RFC1001 length field */ +
1789 le16_to_cpu(pSMBr
->DataOffset
),
1793 if (buf_type
== CIFS_SMALL_BUFFER
)
1794 cifs_small_buf_release(smb_read_data
);
1795 else if (buf_type
== CIFS_LARGE_BUFFER
)
1796 cifs_buf_release(smb_read_data
);
1797 smb_read_data
= NULL
;
1800 if (rc
|| (bytes_read
== 0)) {
1808 cifs_stats_bytes_read(pTcon
, bytes_read
);
1809 *poffset
+= bytes_read
;
1817 static ssize_t
cifs_read(struct file
*file
, char *read_data
, size_t read_size
,
1821 unsigned int bytes_read
= 0;
1822 unsigned int total_read
;
1823 unsigned int current_read_size
;
1824 struct cifs_sb_info
*cifs_sb
;
1825 struct cifsTconInfo
*pTcon
;
1827 char *current_offset
;
1828 struct cifsFileInfo
*open_file
;
1829 int buf_type
= CIFS_NO_BUFFER
;
1832 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1833 pTcon
= cifs_sb
->tcon
;
1835 if (file
->private_data
== NULL
) {
1840 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1842 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1843 cFYI(1, "attempting read on write only file instance");
1845 for (total_read
= 0, current_offset
= read_data
;
1846 read_size
> total_read
;
1847 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1848 current_read_size
= min_t(const int, read_size
- total_read
,
1850 /* For windows me and 9x we do not want to request more
1851 than it negotiated since it will refuse the read then */
1853 !(pTcon
->ses
->capabilities
& CAP_LARGE_FILES
)) {
1854 current_read_size
= min_t(const int, current_read_size
,
1855 pTcon
->ses
->server
->maxBuf
- 128);
1858 while (rc
== -EAGAIN
) {
1859 if ((open_file
->invalidHandle
) &&
1860 (!open_file
->closePend
)) {
1861 rc
= cifs_reopen_file(file
, true);
1865 rc
= CIFSSMBRead(xid
, pTcon
,
1867 current_read_size
, *poffset
,
1868 &bytes_read
, ¤t_offset
,
1871 if (rc
|| (bytes_read
== 0)) {
1879 cifs_stats_bytes_read(pTcon
, total_read
);
1880 *poffset
+= bytes_read
;
1887 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1892 rc
= cifs_revalidate_file(file
);
1894 cFYI(1, "Validation prior to mmap failed, error=%d", rc
);
1898 rc
= generic_file_mmap(file
, vma
);
1904 static void cifs_copy_cache_pages(struct address_space
*mapping
,
1905 struct list_head
*pages
, int bytes_read
, char *data
)
1910 while (bytes_read
> 0) {
1911 if (list_empty(pages
))
1914 page
= list_entry(pages
->prev
, struct page
, lru
);
1915 list_del(&page
->lru
);
1917 if (add_to_page_cache_lru(page
, mapping
, page
->index
,
1919 page_cache_release(page
);
1920 cFYI(1, "Add page cache failed");
1921 data
+= PAGE_CACHE_SIZE
;
1922 bytes_read
-= PAGE_CACHE_SIZE
;
1925 page_cache_release(page
);
1927 target
= kmap_atomic(page
, KM_USER0
);
1929 if (PAGE_CACHE_SIZE
> bytes_read
) {
1930 memcpy(target
, data
, bytes_read
);
1931 /* zero the tail end of this partial page */
1932 memset(target
+ bytes_read
, 0,
1933 PAGE_CACHE_SIZE
- bytes_read
);
1936 memcpy(target
, data
, PAGE_CACHE_SIZE
);
1937 bytes_read
-= PAGE_CACHE_SIZE
;
1939 kunmap_atomic(target
, KM_USER0
);
1941 flush_dcache_page(page
);
1942 SetPageUptodate(page
);
1944 data
+= PAGE_CACHE_SIZE
;
1949 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
1950 struct list_head
*page_list
, unsigned num_pages
)
1956 struct cifs_sb_info
*cifs_sb
;
1957 struct cifsTconInfo
*pTcon
;
1958 unsigned int bytes_read
= 0;
1959 unsigned int read_size
, i
;
1960 char *smb_read_data
= NULL
;
1961 struct smb_com_read_rsp
*pSMBr
;
1962 struct cifsFileInfo
*open_file
;
1963 int buf_type
= CIFS_NO_BUFFER
;
1966 if (file
->private_data
== NULL
) {
1971 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1972 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1973 pTcon
= cifs_sb
->tcon
;
1975 cFYI(DBG2
, "rpages: num pages %d", num_pages
);
1976 for (i
= 0; i
< num_pages
; ) {
1977 unsigned contig_pages
;
1978 struct page
*tmp_page
;
1979 unsigned long expected_index
;
1981 if (list_empty(page_list
))
1984 page
= list_entry(page_list
->prev
, struct page
, lru
);
1985 offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1987 /* count adjacent pages that we will read into */
1990 list_entry(page_list
->prev
, struct page
, lru
)->index
;
1991 list_for_each_entry_reverse(tmp_page
, page_list
, lru
) {
1992 if (tmp_page
->index
== expected_index
) {
1998 if (contig_pages
+ i
> num_pages
)
1999 contig_pages
= num_pages
- i
;
2001 /* for reads over a certain size could initiate async
2004 read_size
= contig_pages
* PAGE_CACHE_SIZE
;
2005 /* Read size needs to be in multiples of one page */
2006 read_size
= min_t(const unsigned int, read_size
,
2007 cifs_sb
->rsize
& PAGE_CACHE_MASK
);
2008 cFYI(DBG2
, "rpages: read size 0x%x contiguous pages %d",
2009 read_size
, contig_pages
);
2011 while (rc
== -EAGAIN
) {
2012 if ((open_file
->invalidHandle
) &&
2013 (!open_file
->closePend
)) {
2014 rc
= cifs_reopen_file(file
, true);
2019 rc
= CIFSSMBRead(xid
, pTcon
,
2022 &bytes_read
, &smb_read_data
,
2024 /* BB more RC checks ? */
2025 if (rc
== -EAGAIN
) {
2026 if (smb_read_data
) {
2027 if (buf_type
== CIFS_SMALL_BUFFER
)
2028 cifs_small_buf_release(smb_read_data
);
2029 else if (buf_type
== CIFS_LARGE_BUFFER
)
2030 cifs_buf_release(smb_read_data
);
2031 smb_read_data
= NULL
;
2035 if ((rc
< 0) || (smb_read_data
== NULL
)) {
2036 cFYI(1, "Read error in readpages: %d", rc
);
2038 } else if (bytes_read
> 0) {
2039 task_io_account_read(bytes_read
);
2040 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
2041 cifs_copy_cache_pages(mapping
, page_list
, bytes_read
,
2042 smb_read_data
+ 4 /* RFC1001 hdr */ +
2043 le16_to_cpu(pSMBr
->DataOffset
));
2045 i
+= bytes_read
>> PAGE_CACHE_SHIFT
;
2046 cifs_stats_bytes_read(pTcon
, bytes_read
);
2047 if ((bytes_read
& PAGE_CACHE_MASK
) != bytes_read
) {
2048 i
++; /* account for partial page */
2050 /* server copy of file can have smaller size
2052 /* BB do we need to verify this common case ?
2053 this case is ok - if we are at server EOF
2054 we will hit it on next read */
2059 cFYI(1, "No bytes read (%d) at offset %lld . "
2060 "Cleaning remaining pages from readahead list",
2061 bytes_read
, offset
);
2062 /* BB turn off caching and do new lookup on
2063 file size at server? */
2066 if (smb_read_data
) {
2067 if (buf_type
== CIFS_SMALL_BUFFER
)
2068 cifs_small_buf_release(smb_read_data
);
2069 else if (buf_type
== CIFS_LARGE_BUFFER
)
2070 cifs_buf_release(smb_read_data
);
2071 smb_read_data
= NULL
;
2076 /* need to free smb_read_data buf before exit */
2077 if (smb_read_data
) {
2078 if (buf_type
== CIFS_SMALL_BUFFER
)
2079 cifs_small_buf_release(smb_read_data
);
2080 else if (buf_type
== CIFS_LARGE_BUFFER
)
2081 cifs_buf_release(smb_read_data
);
2082 smb_read_data
= NULL
;
2089 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
2095 page_cache_get(page
);
2096 read_data
= kmap(page
);
2097 /* for reads over a certain size could initiate async read ahead */
2099 rc
= cifs_read(file
, read_data
, PAGE_CACHE_SIZE
, poffset
);
2104 cFYI(1, "Bytes read %d", rc
);
2106 file
->f_path
.dentry
->d_inode
->i_atime
=
2107 current_fs_time(file
->f_path
.dentry
->d_inode
->i_sb
);
2109 if (PAGE_CACHE_SIZE
> rc
)
2110 memset(read_data
+ rc
, 0, PAGE_CACHE_SIZE
- rc
);
2112 flush_dcache_page(page
);
2113 SetPageUptodate(page
);
2118 page_cache_release(page
);
2122 static int cifs_readpage(struct file
*file
, struct page
*page
)
2124 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
2130 if (file
->private_data
== NULL
) {
2136 cFYI(1, "readpage %p at offset %d 0x%x\n",
2137 page
, (int)offset
, (int)offset
);
2139 rc
= cifs_readpage_worker(file
, page
, &offset
);
2147 static int is_inode_writable(struct cifsInodeInfo
*cifs_inode
)
2149 struct cifsFileInfo
*open_file
;
2151 read_lock(&GlobalSMBSeslock
);
2152 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
2153 if (open_file
->closePend
)
2155 if (open_file
->pfile
&&
2156 ((open_file
->pfile
->f_flags
& O_RDWR
) ||
2157 (open_file
->pfile
->f_flags
& O_WRONLY
))) {
2158 read_unlock(&GlobalSMBSeslock
);
2162 read_unlock(&GlobalSMBSeslock
);
2166 /* We do not want to update the file size from server for inodes
2167 open for write - to avoid races with writepage extending
2168 the file - in the future we could consider allowing
2169 refreshing the inode only on increases in the file size
2170 but this is tricky to do without racing with writebehind
2171 page caching in the current Linux kernel design */
2172 bool is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
, __u64 end_of_file
)
2177 if (is_inode_writable(cifsInode
)) {
2178 /* This inode is open for write at least once */
2179 struct cifs_sb_info
*cifs_sb
;
2181 cifs_sb
= CIFS_SB(cifsInode
->vfs_inode
.i_sb
);
2182 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
2183 /* since no page cache to corrupt on directio
2184 we can change size safely */
2188 if (i_size_read(&cifsInode
->vfs_inode
) < end_of_file
)
2196 static int cifs_write_begin(struct file
*file
, struct address_space
*mapping
,
2197 loff_t pos
, unsigned len
, unsigned flags
,
2198 struct page
**pagep
, void **fsdata
)
2200 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
2201 loff_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
2202 loff_t page_start
= pos
& PAGE_MASK
;
2207 cFYI(1, "write_begin from %lld len %d", (long long)pos
, len
);
2209 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
2215 if (PageUptodate(page
))
2219 * If we write a full page it will be up to date, no need to read from
2220 * the server. If the write is short, we'll end up doing a sync write
2223 if (len
== PAGE_CACHE_SIZE
)
2227 * optimize away the read when we have an oplock, and we're not
2228 * expecting to use any of the data we'd be reading in. That
2229 * is, when the page lies beyond the EOF, or straddles the EOF
2230 * and the write will cover all of the existing data.
2232 if (CIFS_I(mapping
->host
)->clientCanCacheRead
) {
2233 i_size
= i_size_read(mapping
->host
);
2234 if (page_start
>= i_size
||
2235 (offset
== 0 && (pos
+ len
) >= i_size
)) {
2236 zero_user_segments(page
, 0, offset
,
2240 * PageChecked means that the parts of the page
2241 * to which we're not writing are considered up
2242 * to date. Once the data is copied to the
2243 * page, it can be set uptodate.
2245 SetPageChecked(page
);
2250 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
) {
2252 * might as well read a page, it is fast enough. If we get
2253 * an error, we don't need to return it. cifs_write_end will
2254 * do a sync write instead since PG_uptodate isn't set.
2256 cifs_readpage_worker(file
, page
, &page_start
);
2258 /* we could try using another file handle if there is one -
2259 but how would we lock it to prevent close of that handle
2260 racing with this read? In any case
2261 this will be written out by write_end so is fine */
2269 cifs_oplock_break(struct slow_work
*work
)
2271 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2273 struct inode
*inode
= cfile
->pInode
;
2274 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2275 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->mnt
->mnt_sb
);
2278 if (inode
&& S_ISREG(inode
->i_mode
)) {
2279 if (cinode
->clientCanCacheRead
)
2280 break_lease(inode
, O_RDONLY
);
2282 break_lease(inode
, O_WRONLY
);
2283 rc
= filemap_fdatawrite(inode
->i_mapping
);
2284 if (cinode
->clientCanCacheRead
== 0) {
2285 waitrc
= filemap_fdatawait(inode
->i_mapping
);
2286 invalidate_remote_inode(inode
);
2291 cinode
->write_behind_rc
= rc
;
2292 cFYI(1, "Oplock flush inode %p rc %d", inode
, rc
);
2296 * releasing stale oplock after recent reconnect of smb session using
2297 * a now incorrect file handle is not a data integrity issue but do
2298 * not bother sending an oplock release if session to server still is
2299 * disconnected since oplock already released by the server
2301 if (!cfile
->closePend
&& !cfile
->oplock_break_cancelled
) {
2302 rc
= CIFSSMBLock(0, cifs_sb
->tcon
, cfile
->netfid
, 0, 0, 0, 0,
2303 LOCKING_ANDX_OPLOCK_RELEASE
, false);
2304 cFYI(1, "Oplock release rc = %d", rc
);
2309 cifs_oplock_break_get(struct slow_work
*work
)
2311 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2314 cifsFileInfo_get(cfile
);
2319 cifs_oplock_break_put(struct slow_work
*work
)
2321 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2324 cifsFileInfo_put(cfile
);
2327 const struct slow_work_ops cifs_oplock_break_ops
= {
2328 .get_ref
= cifs_oplock_break_get
,
2329 .put_ref
= cifs_oplock_break_put
,
2330 .execute
= cifs_oplock_break
,
2333 const struct address_space_operations cifs_addr_ops
= {
2334 .readpage
= cifs_readpage
,
2335 .readpages
= cifs_readpages
,
2336 .writepage
= cifs_writepage
,
2337 .writepages
= cifs_writepages
,
2338 .write_begin
= cifs_write_begin
,
2339 .write_end
= cifs_write_end
,
2340 .set_page_dirty
= __set_page_dirty_nobuffers
,
2341 /* .sync_page = cifs_sync_page, */
2346 * cifs_readpages requires the server to support a buffer large enough to
2347 * contain the header plus one complete page of data. Otherwise, we need
2348 * to leave cifs_readpages out of the address space operations.
2350 const struct address_space_operations cifs_addr_ops_smallbuf
= {
2351 .readpage
= cifs_readpage
,
2352 .writepage
= cifs_writepage
,
2353 .writepages
= cifs_writepages
,
2354 .write_begin
= cifs_write_begin
,
2355 .write_end
= cifs_write_end
,
2356 .set_page_dirty
= __set_page_dirty_nobuffers
,
2357 /* .sync_page = cifs_sync_page, */