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
);
135 pCifsInode
->write_behind_rc
= rc
;
137 cFYI(1, "invalidating remote inode since open detected it "
139 invalidate_remote_inode(inode
);
144 rc
= cifs_get_inode_info_unix(&inode
, full_path
, inode
->i_sb
,
147 rc
= cifs_get_inode_info(&inode
, full_path
, buf
, inode
->i_sb
,
150 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
151 pCifsInode
->clientCanCacheAll
= true;
152 pCifsInode
->clientCanCacheRead
= true;
153 cFYI(1, "Exclusive Oplock granted on inode %p", inode
);
154 } else if ((oplock
& 0xF) == OPLOCK_READ
)
155 pCifsInode
->clientCanCacheRead
= true;
160 int cifs_posix_open(char *full_path
, struct inode
**pinode
,
161 struct super_block
*sb
, int mode
, unsigned int f_flags
,
162 __u32
*poplock
, __u16
*pnetfid
, int xid
)
165 FILE_UNIX_BASIC_INFO
*presp_data
;
166 __u32 posix_flags
= 0;
167 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
168 struct cifs_fattr fattr
;
169 struct tcon_link
*tlink
;
170 struct cifsTconInfo
*tcon
;
172 cFYI(1, "posix open %s", full_path
);
174 presp_data
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
175 if (presp_data
== NULL
)
178 tlink
= cifs_sb_tlink(cifs_sb
);
184 tcon
= tlink_tcon(tlink
);
185 mode
&= ~current_umask();
187 posix_flags
= cifs_posix_convert_flags(f_flags
);
188 rc
= CIFSPOSIXCreate(xid
, tcon
, posix_flags
, mode
, pnetfid
, presp_data
,
189 poplock
, full_path
, cifs_sb
->local_nls
,
190 cifs_sb
->mnt_cifs_flags
&
191 CIFS_MOUNT_MAP_SPECIAL_CHR
);
192 cifs_put_tlink(tlink
);
197 if (presp_data
->Type
== cpu_to_le32(-1))
198 goto posix_open_ret
; /* open ok, caller does qpathinfo */
201 goto posix_open_ret
; /* caller does not need info */
203 cifs_unix_basic_to_fattr(&fattr
, presp_data
, cifs_sb
);
205 /* get new inode and set it up */
206 if (*pinode
== NULL
) {
207 cifs_fill_uniqueid(sb
, &fattr
);
208 *pinode
= cifs_iget(sb
, &fattr
);
214 cifs_fattr_to_inode(*pinode
, &fattr
);
222 int cifs_open(struct inode
*inode
, struct file
*file
)
227 struct cifs_sb_info
*cifs_sb
;
228 struct cifsTconInfo
*tcon
;
229 struct tcon_link
*tlink
;
230 struct cifsFileInfo
*pCifsFile
= NULL
;
231 struct cifsInodeInfo
*pCifsInode
;
232 char *full_path
= NULL
;
236 FILE_ALL_INFO
*buf
= NULL
;
240 cifs_sb
= CIFS_SB(inode
->i_sb
);
241 tlink
= cifs_sb_tlink(cifs_sb
);
244 return PTR_ERR(tlink
);
246 tcon
= tlink_tcon(tlink
);
248 pCifsInode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
250 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
251 if (full_path
== NULL
) {
256 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
257 inode
, file
->f_flags
, full_path
);
264 if (!tcon
->broken_posix_open
&& tcon
->unix_ext
&&
265 (tcon
->ses
->capabilities
& CAP_UNIX
) &&
266 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
267 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
268 /* can not refresh inode info since size could be stale */
269 rc
= cifs_posix_open(full_path
, &inode
, inode
->i_sb
,
270 cifs_sb
->mnt_file_mode
/* ignored */,
271 file
->f_flags
, &oplock
, &netfid
, xid
);
273 cFYI(1, "posix open succeeded");
275 pCifsFile
= cifs_new_fileinfo(netfid
, file
, tlink
,
277 if (pCifsFile
== NULL
) {
278 CIFSSMBClose(xid
, tcon
, netfid
);
282 cifs_fscache_set_inode_cookie(inode
, file
);
285 } else if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
286 if (tcon
->ses
->serverNOS
)
287 cERROR(1, "server %s of type %s returned"
288 " unexpected error on SMB posix open"
289 ", disabling posix open support."
290 " Check if server update available.",
291 tcon
->ses
->serverName
,
292 tcon
->ses
->serverNOS
);
293 tcon
->broken_posix_open
= true;
294 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
295 (rc
!= -EOPNOTSUPP
)) /* path not found or net err */
297 /* else fallthrough to retry open the old way on network i/o
301 desiredAccess
= cifs_convert_flags(file
->f_flags
);
303 /*********************************************************************
304 * open flag mapping table:
306 * POSIX Flag CIFS Disposition
307 * ---------- ----------------
308 * O_CREAT FILE_OPEN_IF
309 * O_CREAT | O_EXCL FILE_CREATE
310 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
311 * O_TRUNC FILE_OVERWRITE
312 * none of the above FILE_OPEN
314 * Note that there is not a direct match between disposition
315 * FILE_SUPERSEDE (ie create whether or not file exists although
316 * O_CREAT | O_TRUNC is similar but truncates the existing
317 * file rather than creating a new file as FILE_SUPERSEDE does
318 * (which uses the attributes / metadata passed in on open call)
320 *? O_SYNC is a reasonable match to CIFS writethrough flag
321 *? and the read write flags match reasonably. O_LARGEFILE
322 *? is irrelevant because largefile support is always used
323 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
324 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
325 *********************************************************************/
327 disposition
= cifs_get_disposition(file
->f_flags
);
329 /* BB pass O_SYNC flag through on file attributes .. BB */
331 /* Also refresh inode by passing in file_info buf returned by SMBOpen
332 and calling get_inode_info with returned buf (at least helps
333 non-Unix server case) */
335 /* BB we can not do this if this is the second open of a file
336 and the first handle has writebehind data, we might be
337 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
338 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
344 if (tcon
->ses
->capabilities
& CAP_NT_SMBS
)
345 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
346 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
347 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
348 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
350 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
353 /* Old server, try legacy style OpenX */
354 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
355 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
356 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
357 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
360 cFYI(1, "cifs_open returned 0x%x", rc
);
364 rc
= cifs_open_inode_helper(inode
, tcon
, oplock
, buf
, full_path
, xid
);
368 pCifsFile
= cifs_new_fileinfo(netfid
, file
, tlink
, oplock
);
369 if (pCifsFile
== NULL
) {
374 cifs_fscache_set_inode_cookie(inode
, file
);
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
);
400 cifs_put_tlink(tlink
);
404 /* Try to reacquire byte range locks that were released when session */
405 /* to server was lost */
406 static int cifs_relock_file(struct cifsFileInfo
*cifsFile
)
410 /* BB list all locks open on this file and relock */
415 static int cifs_reopen_file(struct cifsFileInfo
*pCifsFile
, bool can_flush
)
420 struct cifs_sb_info
*cifs_sb
;
421 struct cifsTconInfo
*tcon
;
422 struct cifsInodeInfo
*pCifsInode
;
424 char *full_path
= NULL
;
426 int disposition
= FILE_OPEN
;
430 mutex_lock(&pCifsFile
->fh_mutex
);
431 if (!pCifsFile
->invalidHandle
) {
432 mutex_unlock(&pCifsFile
->fh_mutex
);
438 inode
= pCifsFile
->dentry
->d_inode
;
439 cifs_sb
= CIFS_SB(inode
->i_sb
);
440 tcon
= tlink_tcon(pCifsFile
->tlink
);
442 /* can not grab rename sem here because various ops, including
443 those that already have the rename sem can end up causing writepage
444 to get called and if the server was down that means we end up here,
445 and we can never tell if the caller already has the rename_sem */
446 full_path
= build_path_from_dentry(pCifsFile
->dentry
);
447 if (full_path
== NULL
) {
449 mutex_unlock(&pCifsFile
->fh_mutex
);
454 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
455 inode
, pCifsFile
->f_flags
, full_path
);
462 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
463 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
464 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
467 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
468 * original open. Must mask them off for a reopen.
470 unsigned int oflags
= pCifsFile
->f_flags
&
471 ~(O_CREAT
| O_EXCL
| O_TRUNC
);
473 rc
= cifs_posix_open(full_path
, NULL
, inode
->i_sb
,
474 cifs_sb
->mnt_file_mode
/* ignored */,
475 oflags
, &oplock
, &netfid
, xid
);
477 cFYI(1, "posix reopen succeeded");
480 /* fallthrough to retry open the old way on errors, especially
481 in the reconnect path it is important to retry hard */
484 desiredAccess
= cifs_convert_flags(pCifsFile
->f_flags
);
486 /* Can not refresh inode by passing in file_info buf to be returned
487 by SMBOpen and then calling get_inode_info with returned buf
488 since file might have write behind data that needs to be flushed
489 and server version of file size can be stale. If we knew for sure
490 that inode was not dirty locally we could do this */
492 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
, desiredAccess
,
493 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
494 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
495 CIFS_MOUNT_MAP_SPECIAL_CHR
);
497 mutex_unlock(&pCifsFile
->fh_mutex
);
498 cFYI(1, "cifs_open returned 0x%x", rc
);
499 cFYI(1, "oplock: %d", oplock
);
500 goto reopen_error_exit
;
504 pCifsFile
->netfid
= netfid
;
505 pCifsFile
->invalidHandle
= false;
506 mutex_unlock(&pCifsFile
->fh_mutex
);
507 pCifsInode
= CIFS_I(inode
);
510 rc
= filemap_write_and_wait(inode
->i_mapping
);
512 CIFS_I(inode
)->write_behind_rc
= rc
;
514 pCifsInode
->clientCanCacheAll
= false;
515 pCifsInode
->clientCanCacheRead
= false;
517 rc
= cifs_get_inode_info_unix(&inode
,
518 full_path
, inode
->i_sb
, xid
);
520 rc
= cifs_get_inode_info(&inode
,
521 full_path
, NULL
, inode
->i_sb
,
523 } /* else we are writing out data to server already
524 and could deadlock if we tried to flush data, and
525 since we do not know if we have data that would
526 invalidate the current end of file on the server
527 we can not go to the server to get the new inod
529 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
530 pCifsInode
->clientCanCacheAll
= true;
531 pCifsInode
->clientCanCacheRead
= true;
532 cFYI(1, "Exclusive Oplock granted on inode %p",
533 pCifsFile
->dentry
->d_inode
);
534 } else if ((oplock
& 0xF) == OPLOCK_READ
) {
535 pCifsInode
->clientCanCacheRead
= true;
536 pCifsInode
->clientCanCacheAll
= false;
538 pCifsInode
->clientCanCacheRead
= false;
539 pCifsInode
->clientCanCacheAll
= false;
541 cifs_relock_file(pCifsFile
);
549 int cifs_close(struct inode
*inode
, struct file
*file
)
553 struct cifs_sb_info
*cifs_sb
;
554 struct cifsTconInfo
*pTcon
;
555 struct cifsFileInfo
*pSMBFile
= file
->private_data
;
559 cifs_sb
= CIFS_SB(inode
->i_sb
);
560 pTcon
= tlink_tcon(pSMBFile
->tlink
);
562 struct cifsLockInfo
*li
, *tmp
;
563 write_lock(&GlobalSMBSeslock
);
564 pSMBFile
->closePend
= true;
566 /* no sense reconnecting to close a file that is
568 if (!pTcon
->need_reconnect
) {
569 write_unlock(&GlobalSMBSeslock
);
571 while ((atomic_read(&pSMBFile
->count
) != 1)
572 && (timeout
<= 2048)) {
573 /* Give write a better chance to get to
574 server ahead of the close. We do not
575 want to add a wait_q here as it would
576 increase the memory utilization as
577 the struct would be in each open file,
578 but this should give enough time to
580 cFYI(DBG2
, "close delay, write pending");
584 if (!pTcon
->need_reconnect
&&
585 !pSMBFile
->invalidHandle
)
586 rc
= CIFSSMBClose(xid
, pTcon
,
589 write_unlock(&GlobalSMBSeslock
);
591 write_unlock(&GlobalSMBSeslock
);
593 /* Delete any outstanding lock records.
594 We'll lose them when the file is closed anyway. */
595 mutex_lock(&pSMBFile
->lock_mutex
);
596 list_for_each_entry_safe(li
, tmp
, &pSMBFile
->llist
, llist
) {
597 list_del(&li
->llist
);
600 mutex_unlock(&pSMBFile
->lock_mutex
);
602 write_lock(&GlobalSMBSeslock
);
603 list_del(&pSMBFile
->flist
);
604 list_del(&pSMBFile
->tlist
);
605 write_unlock(&GlobalSMBSeslock
);
606 cifsFileInfo_put(file
->private_data
);
607 file
->private_data
= NULL
;
611 read_lock(&GlobalSMBSeslock
);
612 if (list_empty(&(CIFS_I(inode
)->openFileList
))) {
613 cFYI(1, "closing last open instance for inode %p", inode
);
614 /* if the file is not open we do not know if we can cache info
615 on this inode, much less write behind and read ahead */
616 CIFS_I(inode
)->clientCanCacheRead
= false;
617 CIFS_I(inode
)->clientCanCacheAll
= false;
619 read_unlock(&GlobalSMBSeslock
);
620 if ((rc
== 0) && CIFS_I(inode
)->write_behind_rc
)
621 rc
= CIFS_I(inode
)->write_behind_rc
;
626 int cifs_closedir(struct inode
*inode
, struct file
*file
)
630 struct cifsFileInfo
*pCFileStruct
= file
->private_data
;
633 cFYI(1, "Closedir inode = 0x%p", inode
);
638 struct cifsTconInfo
*pTcon
= tlink_tcon(pCFileStruct
->tlink
);
640 cFYI(1, "Freeing private data in close dir");
641 write_lock(&GlobalSMBSeslock
);
642 if (!pCFileStruct
->srch_inf
.endOfSearch
&&
643 !pCFileStruct
->invalidHandle
) {
644 pCFileStruct
->invalidHandle
= true;
645 write_unlock(&GlobalSMBSeslock
);
646 rc
= CIFSFindClose(xid
, pTcon
, pCFileStruct
->netfid
);
647 cFYI(1, "Closing uncompleted readdir with rc %d",
649 /* not much we can do if it fails anyway, ignore rc */
652 write_unlock(&GlobalSMBSeslock
);
653 ptmp
= pCFileStruct
->srch_inf
.ntwrk_buf_start
;
655 cFYI(1, "closedir free smb buf in srch struct");
656 pCFileStruct
->srch_inf
.ntwrk_buf_start
= NULL
;
657 if (pCFileStruct
->srch_inf
.smallBuf
)
658 cifs_small_buf_release(ptmp
);
660 cifs_buf_release(ptmp
);
662 cifs_put_tlink(pCFileStruct
->tlink
);
663 kfree(file
->private_data
);
664 file
->private_data
= NULL
;
666 /* BB can we lock the filestruct while this is going on? */
671 static int store_file_lock(struct cifsFileInfo
*fid
, __u64 len
,
672 __u64 offset
, __u8 lockType
)
674 struct cifsLockInfo
*li
=
675 kmalloc(sizeof(struct cifsLockInfo
), GFP_KERNEL
);
681 mutex_lock(&fid
->lock_mutex
);
682 list_add(&li
->llist
, &fid
->llist
);
683 mutex_unlock(&fid
->lock_mutex
);
687 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*pfLock
)
693 bool wait_flag
= false;
694 struct cifs_sb_info
*cifs_sb
;
695 struct cifsTconInfo
*tcon
;
697 __u8 lockType
= LOCKING_ANDX_LARGE_FILES
;
698 bool posix_locking
= 0;
700 length
= 1 + pfLock
->fl_end
- pfLock
->fl_start
;
704 cFYI(1, "Lock parm: 0x%x flockflags: "
705 "0x%x flocktype: 0x%x start: %lld end: %lld",
706 cmd
, pfLock
->fl_flags
, pfLock
->fl_type
, pfLock
->fl_start
,
709 if (pfLock
->fl_flags
& FL_POSIX
)
711 if (pfLock
->fl_flags
& FL_FLOCK
)
713 if (pfLock
->fl_flags
& FL_SLEEP
) {
714 cFYI(1, "Blocking lock");
717 if (pfLock
->fl_flags
& FL_ACCESS
)
718 cFYI(1, "Process suspended by mandatory locking - "
719 "not implemented yet");
720 if (pfLock
->fl_flags
& FL_LEASE
)
721 cFYI(1, "Lease on file - not implemented yet");
722 if (pfLock
->fl_flags
&
723 (~(FL_POSIX
| FL_FLOCK
| FL_SLEEP
| FL_ACCESS
| FL_LEASE
)))
724 cFYI(1, "Unknown lock flags 0x%x", pfLock
->fl_flags
);
726 if (pfLock
->fl_type
== F_WRLCK
) {
729 } else if (pfLock
->fl_type
== F_UNLCK
) {
732 /* Check if unlock includes more than
734 } else if (pfLock
->fl_type
== F_RDLCK
) {
736 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
738 } else if (pfLock
->fl_type
== F_EXLCK
) {
741 } else if (pfLock
->fl_type
== F_SHLCK
) {
743 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
746 cFYI(1, "Unknown type of lock");
748 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
749 tcon
= tlink_tcon(((struct cifsFileInfo
*)file
->private_data
)->tlink
);
751 if (file
->private_data
== NULL
) {
756 netfid
= ((struct cifsFileInfo
*)file
->private_data
)->netfid
;
758 if ((tcon
->ses
->capabilities
& CAP_UNIX
) &&
759 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
760 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
762 /* BB add code here to normalize offset and length to
763 account for negative length which we can not accept over the
768 if (lockType
& LOCKING_ANDX_SHARED_LOCK
)
769 posix_lock_type
= CIFS_RDLCK
;
771 posix_lock_type
= CIFS_WRLCK
;
772 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, 1 /* get */,
774 posix_lock_type
, wait_flag
);
779 /* BB we could chain these into one lock request BB */
780 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
, pfLock
->fl_start
,
781 0, 1, lockType
, 0 /* wait flag */ );
783 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
784 pfLock
->fl_start
, 1 /* numUnlock */ ,
785 0 /* numLock */ , lockType
,
787 pfLock
->fl_type
= F_UNLCK
;
789 cERROR(1, "Error unlocking previously locked "
790 "range %d during test of lock", rc
);
794 /* if rc == ERR_SHARING_VIOLATION ? */
797 if (lockType
& LOCKING_ANDX_SHARED_LOCK
) {
798 pfLock
->fl_type
= F_WRLCK
;
800 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
801 pfLock
->fl_start
, 0, 1,
802 lockType
| LOCKING_ANDX_SHARED_LOCK
,
805 rc
= CIFSSMBLock(xid
, tcon
, netfid
,
806 length
, pfLock
->fl_start
, 1, 0,
808 LOCKING_ANDX_SHARED_LOCK
,
810 pfLock
->fl_type
= F_RDLCK
;
812 cERROR(1, "Error unlocking "
813 "previously locked range %d "
814 "during test of lock", rc
);
817 pfLock
->fl_type
= F_WRLCK
;
827 if (!numLock
&& !numUnlock
) {
828 /* if no lock or unlock then nothing
829 to do since we do not know what it is */
836 if (lockType
& LOCKING_ANDX_SHARED_LOCK
)
837 posix_lock_type
= CIFS_RDLCK
;
839 posix_lock_type
= CIFS_WRLCK
;
842 posix_lock_type
= CIFS_UNLCK
;
844 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, 0 /* set */,
846 posix_lock_type
, wait_flag
);
848 struct cifsFileInfo
*fid
= file
->private_data
;
851 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
853 0, numLock
, lockType
, wait_flag
);
856 /* For Windows locks we must store them. */
857 rc
= store_file_lock(fid
, length
,
858 pfLock
->fl_start
, lockType
);
860 } else if (numUnlock
) {
861 /* For each stored lock that this unlock overlaps
862 completely, unlock it. */
864 struct cifsLockInfo
*li
, *tmp
;
867 mutex_lock(&fid
->lock_mutex
);
868 list_for_each_entry_safe(li
, tmp
, &fid
->llist
, llist
) {
869 if (pfLock
->fl_start
<= li
->offset
&&
870 (pfLock
->fl_start
+ length
) >=
871 (li
->offset
+ li
->length
)) {
872 stored_rc
= CIFSSMBLock(xid
, tcon
,
874 li
->length
, li
->offset
,
875 1, 0, li
->type
, false);
879 list_del(&li
->llist
);
884 mutex_unlock(&fid
->lock_mutex
);
888 if (pfLock
->fl_flags
& FL_POSIX
)
889 posix_lock_file_wait(file
, pfLock
);
895 * Set the timeout on write requests past EOF. For some servers (Windows)
896 * these calls can be very long.
898 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
899 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
900 * The 10M cutoff is totally arbitrary. A better scheme for this would be
901 * welcome if someone wants to suggest one.
903 * We may be able to do a better job with this if there were some way to
904 * declare that a file should be sparse.
907 cifs_write_timeout(struct cifsInodeInfo
*cifsi
, loff_t offset
)
909 if (offset
<= cifsi
->server_eof
)
911 else if (offset
> (cifsi
->server_eof
+ (10 * 1024 * 1024)))
912 return CIFS_VLONG_OP
;
917 /* update the file size (if needed) after a write */
919 cifs_update_eof(struct cifsInodeInfo
*cifsi
, loff_t offset
,
920 unsigned int bytes_written
)
922 loff_t end_of_write
= offset
+ bytes_written
;
924 if (end_of_write
> cifsi
->server_eof
)
925 cifsi
->server_eof
= end_of_write
;
928 ssize_t
cifs_user_write(struct file
*file
, const char __user
*write_data
,
929 size_t write_size
, loff_t
*poffset
)
932 unsigned int bytes_written
= 0;
933 unsigned int total_written
;
934 struct cifs_sb_info
*cifs_sb
;
935 struct cifsTconInfo
*pTcon
;
937 struct cifsFileInfo
*open_file
;
938 struct cifsInodeInfo
*cifsi
= CIFS_I(file
->f_path
.dentry
->d_inode
);
940 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
942 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
943 *poffset, file->f_path.dentry->d_name.name); */
945 if (file
->private_data
== NULL
)
948 open_file
= file
->private_data
;
949 pTcon
= tlink_tcon(open_file
->tlink
);
951 rc
= generic_write_checks(file
, poffset
, &write_size
, 0);
957 long_op
= cifs_write_timeout(cifsi
, *poffset
);
958 for (total_written
= 0; write_size
> total_written
;
959 total_written
+= bytes_written
) {
961 while (rc
== -EAGAIN
) {
962 if (file
->private_data
== NULL
) {
963 /* file has been closed on us */
965 /* if we have gotten here we have written some data
966 and blocked, and the file has been freed on us while
967 we blocked so return what we managed to write */
968 return total_written
;
970 if (open_file
->closePend
) {
973 return total_written
;
977 if (open_file
->invalidHandle
) {
978 /* we could deadlock if we called
979 filemap_fdatawait from here so tell
980 reopen_file not to flush data to server
982 rc
= cifs_reopen_file(open_file
, false);
987 rc
= CIFSSMBWrite(xid
, pTcon
,
989 min_t(const int, cifs_sb
->wsize
,
990 write_size
- total_written
),
991 *poffset
, &bytes_written
,
992 NULL
, write_data
+ total_written
, long_op
);
994 if (rc
|| (bytes_written
== 0)) {
1002 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1003 *poffset
+= bytes_written
;
1005 long_op
= CIFS_STD_OP
; /* subsequent writes fast -
1006 15 seconds is plenty */
1009 cifs_stats_bytes_written(pTcon
, total_written
);
1011 /* since the write may have blocked check these pointers again */
1012 if ((file
->f_path
.dentry
) && (file
->f_path
.dentry
->d_inode
)) {
1013 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1014 /* Do not update local mtime - server will set its actual value on write
1015 * inode->i_ctime = inode->i_mtime =
1016 * current_fs_time(inode->i_sb);*/
1017 if (total_written
> 0) {
1018 spin_lock(&inode
->i_lock
);
1019 if (*poffset
> file
->f_path
.dentry
->d_inode
->i_size
)
1020 i_size_write(file
->f_path
.dentry
->d_inode
,
1022 spin_unlock(&inode
->i_lock
);
1024 mark_inode_dirty_sync(file
->f_path
.dentry
->d_inode
);
1027 return total_written
;
1030 static ssize_t
cifs_write(struct cifsFileInfo
*open_file
,
1031 const char *write_data
, size_t write_size
,
1035 unsigned int bytes_written
= 0;
1036 unsigned int total_written
;
1037 struct cifs_sb_info
*cifs_sb
;
1038 struct cifsTconInfo
*pTcon
;
1040 struct dentry
*dentry
= open_file
->dentry
;
1041 struct cifsInodeInfo
*cifsi
= CIFS_I(dentry
->d_inode
);
1043 cifs_sb
= CIFS_SB(dentry
->d_sb
);
1045 cFYI(1, "write %zd bytes to offset %lld of %s", write_size
,
1046 *poffset
, dentry
->d_name
.name
);
1048 pTcon
= tlink_tcon(open_file
->tlink
);
1052 long_op
= cifs_write_timeout(cifsi
, *poffset
);
1053 for (total_written
= 0; write_size
> total_written
;
1054 total_written
+= bytes_written
) {
1056 while (rc
== -EAGAIN
) {
1057 if (open_file
->closePend
) {
1060 return total_written
;
1064 if (open_file
->invalidHandle
) {
1065 /* we could deadlock if we called
1066 filemap_fdatawait from here so tell
1067 reopen_file not to flush data to
1069 rc
= cifs_reopen_file(open_file
, false);
1073 if (experimEnabled
|| (pTcon
->ses
->server
&&
1074 ((pTcon
->ses
->server
->secMode
&
1075 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
1080 len
= min((size_t)cifs_sb
->wsize
,
1081 write_size
- total_written
);
1082 /* iov[0] is reserved for smb header */
1083 iov
[1].iov_base
= (char *)write_data
+
1085 iov
[1].iov_len
= len
;
1086 rc
= CIFSSMBWrite2(xid
, pTcon
,
1087 open_file
->netfid
, len
,
1088 *poffset
, &bytes_written
,
1091 rc
= CIFSSMBWrite(xid
, pTcon
,
1093 min_t(const int, cifs_sb
->wsize
,
1094 write_size
- total_written
),
1095 *poffset
, &bytes_written
,
1096 write_data
+ total_written
,
1099 if (rc
|| (bytes_written
== 0)) {
1107 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1108 *poffset
+= bytes_written
;
1110 long_op
= CIFS_STD_OP
; /* subsequent writes fast -
1111 15 seconds is plenty */
1114 cifs_stats_bytes_written(pTcon
, total_written
);
1116 if (total_written
> 0) {
1117 spin_lock(&dentry
->d_inode
->i_lock
);
1118 if (*poffset
> dentry
->d_inode
->i_size
)
1119 i_size_write(dentry
->d_inode
, *poffset
);
1120 spin_unlock(&dentry
->d_inode
->i_lock
);
1122 mark_inode_dirty_sync(dentry
->d_inode
);
1124 return total_written
;
1127 #ifdef CONFIG_CIFS_EXPERIMENTAL
1128 struct cifsFileInfo
*find_readable_file(struct cifsInodeInfo
*cifs_inode
,
1131 struct cifsFileInfo
*open_file
= NULL
;
1132 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1134 /* only filter by fsuid on multiuser mounts */
1135 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1138 read_lock(&GlobalSMBSeslock
);
1139 /* we could simply get the first_list_entry since write-only entries
1140 are always at the end of the list but since the first entry might
1141 have a close pending, we go through the whole list */
1142 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1143 if (open_file
->closePend
)
1145 if (fsuid_only
&& open_file
->uid
!= current_fsuid())
1147 if (open_file
->pfile
&& ((open_file
->pfile
->f_flags
& O_RDWR
) ||
1148 (open_file
->pfile
->f_flags
& O_RDONLY
))) {
1149 if (!open_file
->invalidHandle
) {
1150 /* found a good file */
1151 /* lock it so it will not be closed on us */
1152 cifsFileInfo_get(open_file
);
1153 read_unlock(&GlobalSMBSeslock
);
1155 } /* else might as well continue, and look for
1156 another, or simply have the caller reopen it
1157 again rather than trying to fix this handle */
1158 } else /* write only file */
1159 break; /* write only files are last so must be done */
1161 read_unlock(&GlobalSMBSeslock
);
1166 struct cifsFileInfo
*find_writable_file(struct cifsInodeInfo
*cifs_inode
,
1169 struct cifsFileInfo
*open_file
;
1170 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1171 bool any_available
= false;
1174 /* Having a null inode here (because mapping->host was set to zero by
1175 the VFS or MM) should not happen but we had reports of on oops (due to
1176 it being zero) during stress testcases so we need to check for it */
1178 if (cifs_inode
== NULL
) {
1179 cERROR(1, "Null inode passed to cifs_writeable_file");
1184 /* only filter by fsuid on multiuser mounts */
1185 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1188 read_lock(&GlobalSMBSeslock
);
1190 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1191 if (open_file
->closePend
)
1193 if (!any_available
&& open_file
->pid
!= current
->tgid
)
1195 if (fsuid_only
&& open_file
->uid
!= current_fsuid())
1197 if (open_file
->pfile
&&
1198 ((open_file
->pfile
->f_flags
& O_RDWR
) ||
1199 (open_file
->pfile
->f_flags
& O_WRONLY
))) {
1200 cifsFileInfo_get(open_file
);
1202 if (!open_file
->invalidHandle
) {
1203 /* found a good writable file */
1204 read_unlock(&GlobalSMBSeslock
);
1208 read_unlock(&GlobalSMBSeslock
);
1209 /* Had to unlock since following call can block */
1210 rc
= cifs_reopen_file(open_file
, false);
1212 if (!open_file
->closePend
)
1214 else { /* start over in case this was deleted */
1215 /* since the list could be modified */
1216 read_lock(&GlobalSMBSeslock
);
1217 cifsFileInfo_put(open_file
);
1218 goto refind_writable
;
1222 /* if it fails, try another handle if possible -
1223 (we can not do this if closePending since
1224 loop could be modified - in which case we
1225 have to start at the beginning of the list
1226 again. Note that it would be bad
1227 to hold up writepages here (rather than
1228 in caller) with continuous retries */
1229 cFYI(1, "wp failed on reopen file");
1230 read_lock(&GlobalSMBSeslock
);
1231 /* can not use this handle, no write
1232 pending on this one after all */
1233 cifsFileInfo_put(open_file
);
1235 if (open_file
->closePend
) /* list could have changed */
1236 goto refind_writable
;
1237 /* else we simply continue to the next entry. Thus
1238 we do not loop on reopen errors. If we
1239 can not reopen the file, for example if we
1240 reconnected to a server with another client
1241 racing to delete or lock the file we would not
1242 make progress if we restarted before the beginning
1243 of the loop here. */
1246 /* couldn't find useable FH with same pid, try any available */
1247 if (!any_available
) {
1248 any_available
= true;
1249 goto refind_writable
;
1251 read_unlock(&GlobalSMBSeslock
);
1255 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
1257 struct address_space
*mapping
= page
->mapping
;
1258 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1261 int bytes_written
= 0;
1262 struct cifs_sb_info
*cifs_sb
;
1263 struct inode
*inode
;
1264 struct cifsFileInfo
*open_file
;
1266 if (!mapping
|| !mapping
->host
)
1269 inode
= page
->mapping
->host
;
1270 cifs_sb
= CIFS_SB(inode
->i_sb
);
1272 offset
+= (loff_t
)from
;
1273 write_data
= kmap(page
);
1276 if ((to
> PAGE_CACHE_SIZE
) || (from
> to
)) {
1281 /* racing with truncate? */
1282 if (offset
> mapping
->host
->i_size
) {
1284 return 0; /* don't care */
1287 /* check to make sure that we are not extending the file */
1288 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
1289 to
= (unsigned)(mapping
->host
->i_size
- offset
);
1291 open_file
= find_writable_file(CIFS_I(mapping
->host
), false);
1293 bytes_written
= cifs_write(open_file
, write_data
,
1294 to
- from
, &offset
);
1295 cifsFileInfo_put(open_file
);
1296 /* Does mm or vfs already set times? */
1297 inode
->i_atime
= inode
->i_mtime
= current_fs_time(inode
->i_sb
);
1298 if ((bytes_written
> 0) && (offset
))
1300 else if (bytes_written
< 0)
1303 cFYI(1, "No writeable filehandles for inode");
1311 static int cifs_writepages(struct address_space
*mapping
,
1312 struct writeback_control
*wbc
)
1314 struct backing_dev_info
*bdi
= mapping
->backing_dev_info
;
1315 unsigned int bytes_to_write
;
1316 unsigned int bytes_written
;
1317 struct cifs_sb_info
*cifs_sb
;
1321 int range_whole
= 0;
1328 struct cifsFileInfo
*open_file
;
1329 struct cifsTconInfo
*tcon
;
1330 struct cifsInodeInfo
*cifsi
= CIFS_I(mapping
->host
);
1332 struct pagevec pvec
;
1338 * BB: Is this meaningful for a non-block-device file system?
1339 * If it is, we should test it again after we do I/O
1341 if (wbc
->nonblocking
&& bdi_write_congested(bdi
)) {
1342 wbc
->encountered_congestion
= 1;
1346 cifs_sb
= CIFS_SB(mapping
->host
->i_sb
);
1349 * If wsize is smaller that the page cache size, default to writing
1350 * one page at a time via cifs_writepage
1352 if (cifs_sb
->wsize
< PAGE_CACHE_SIZE
)
1353 return generic_writepages(mapping
, wbc
);
1355 iov
= kmalloc(32 * sizeof(struct kvec
), GFP_KERNEL
);
1357 return generic_writepages(mapping
, wbc
);
1360 * if there's no open file, then this is likely to fail too,
1361 * but it'll at least handle the return. Maybe it should be
1364 open_file
= find_writable_file(CIFS_I(mapping
->host
), false);
1367 return generic_writepages(mapping
, wbc
);
1370 tcon
= tlink_tcon(open_file
->tlink
);
1371 if (!experimEnabled
&& tcon
->ses
->server
->secMode
&
1372 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
)) {
1373 cifsFileInfo_put(open_file
);
1374 return generic_writepages(mapping
, wbc
);
1376 cifsFileInfo_put(open_file
);
1380 pagevec_init(&pvec
, 0);
1381 if (wbc
->range_cyclic
) {
1382 index
= mapping
->writeback_index
; /* Start from prev offset */
1385 index
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
1386 end
= wbc
->range_end
>> PAGE_CACHE_SHIFT
;
1387 if (wbc
->range_start
== 0 && wbc
->range_end
== LLONG_MAX
)
1392 while (!done
&& (index
<= end
) &&
1393 (nr_pages
= pagevec_lookup_tag(&pvec
, mapping
, &index
,
1394 PAGECACHE_TAG_DIRTY
,
1395 min(end
- index
, (pgoff_t
)PAGEVEC_SIZE
- 1) + 1))) {
1404 for (i
= 0; i
< nr_pages
; i
++) {
1405 page
= pvec
.pages
[i
];
1407 * At this point we hold neither mapping->tree_lock nor
1408 * lock on the page itself: the page may be truncated or
1409 * invalidated (changing page->mapping to NULL), or even
1410 * swizzled back from swapper_space to tmpfs file
1416 else if (!trylock_page(page
))
1419 if (unlikely(page
->mapping
!= mapping
)) {
1424 if (!wbc
->range_cyclic
&& page
->index
> end
) {
1430 if (next
&& (page
->index
!= next
)) {
1431 /* Not next consecutive page */
1436 if (wbc
->sync_mode
!= WB_SYNC_NONE
)
1437 wait_on_page_writeback(page
);
1439 if (PageWriteback(page
) ||
1440 !clear_page_dirty_for_io(page
)) {
1446 * This actually clears the dirty bit in the radix tree.
1447 * See cifs_writepage() for more commentary.
1449 set_page_writeback(page
);
1451 if (page_offset(page
) >= mapping
->host
->i_size
) {
1454 end_page_writeback(page
);
1459 * BB can we get rid of this? pages are held by pvec
1461 page_cache_get(page
);
1463 len
= min(mapping
->host
->i_size
- page_offset(page
),
1464 (loff_t
)PAGE_CACHE_SIZE
);
1466 /* reserve iov[0] for the smb header */
1468 iov
[n_iov
].iov_base
= kmap(page
);
1469 iov
[n_iov
].iov_len
= len
;
1470 bytes_to_write
+= len
;
1474 offset
= page_offset(page
);
1476 next
= page
->index
+ 1;
1477 if (bytes_to_write
+ PAGE_CACHE_SIZE
> cifs_sb
->wsize
)
1481 open_file
= find_writable_file(CIFS_I(mapping
->host
),
1484 cERROR(1, "No writable handles for inode");
1487 long_op
= cifs_write_timeout(cifsi
, offset
);
1488 rc
= CIFSSMBWrite2(xid
, tcon
, open_file
->netfid
,
1489 bytes_to_write
, offset
,
1490 &bytes_written
, iov
, n_iov
,
1492 cifsFileInfo_put(open_file
);
1493 cifs_update_eof(cifsi
, offset
, bytes_written
);
1496 if (rc
|| bytes_written
< bytes_to_write
) {
1497 cERROR(1, "Write2 ret %d, wrote %d",
1499 /* BB what if continued retry is
1500 requested via mount flags? */
1502 set_bit(AS_ENOSPC
, &mapping
->flags
);
1504 set_bit(AS_EIO
, &mapping
->flags
);
1506 cifs_stats_bytes_written(tcon
, bytes_written
);
1509 for (i
= 0; i
< n_iov
; i
++) {
1510 page
= pvec
.pages
[first
+ i
];
1511 /* Should we also set page error on
1512 success rc but too little data written? */
1513 /* BB investigate retry logic on temporary
1514 server crash cases and how recovery works
1515 when page marked as error */
1520 end_page_writeback(page
);
1521 page_cache_release(page
);
1523 if ((wbc
->nr_to_write
-= n_iov
) <= 0)
1527 /* Need to re-find the pages we skipped */
1528 index
= pvec
.pages
[0]->index
+ 1;
1530 pagevec_release(&pvec
);
1532 if (!scanned
&& !done
) {
1534 * We hit the last page and there is more work to be done: wrap
1535 * back to the start of the file
1541 if (wbc
->range_cyclic
|| (range_whole
&& wbc
->nr_to_write
> 0))
1542 mapping
->writeback_index
= index
;
1549 static int cifs_writepage(struct page
*page
, struct writeback_control
*wbc
)
1555 /* BB add check for wbc flags */
1556 page_cache_get(page
);
1557 if (!PageUptodate(page
))
1558 cFYI(1, "ppw - page not up to date");
1561 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1563 * A writepage() implementation always needs to do either this,
1564 * or re-dirty the page with "redirty_page_for_writepage()" in
1565 * the case of a failure.
1567 * Just unlocking the page will cause the radix tree tag-bits
1568 * to fail to update with the state of the page correctly.
1570 set_page_writeback(page
);
1571 rc
= cifs_partialpagewrite(page
, 0, PAGE_CACHE_SIZE
);
1572 SetPageUptodate(page
); /* BB add check for error and Clearuptodate? */
1574 end_page_writeback(page
);
1575 page_cache_release(page
);
1580 static int cifs_write_end(struct file
*file
, struct address_space
*mapping
,
1581 loff_t pos
, unsigned len
, unsigned copied
,
1582 struct page
*page
, void *fsdata
)
1585 struct inode
*inode
= mapping
->host
;
1587 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1590 if (PageChecked(page
)) {
1592 SetPageUptodate(page
);
1593 ClearPageChecked(page
);
1594 } else if (!PageUptodate(page
) && copied
== PAGE_CACHE_SIZE
)
1595 SetPageUptodate(page
);
1597 if (!PageUptodate(page
)) {
1599 unsigned offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1603 /* this is probably better than directly calling
1604 partialpage_write since in this function the file handle is
1605 known which we might as well leverage */
1606 /* BB check if anything else missing out of ppw
1607 such as updating last write time */
1608 page_data
= kmap(page
);
1609 rc
= cifs_write(file
->private_data
, page_data
+ offset
,
1611 /* if (rc < 0) should we set writebehind rc? */
1618 set_page_dirty(page
);
1622 spin_lock(&inode
->i_lock
);
1623 if (pos
> inode
->i_size
)
1624 i_size_write(inode
, pos
);
1625 spin_unlock(&inode
->i_lock
);
1629 page_cache_release(page
);
1634 int cifs_fsync(struct file
*file
, int datasync
)
1638 struct cifsTconInfo
*tcon
;
1639 struct cifsFileInfo
*smbfile
= file
->private_data
;
1640 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1644 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1645 file
->f_path
.dentry
->d_name
.name
, datasync
);
1647 rc
= filemap_write_and_wait(inode
->i_mapping
);
1649 rc
= CIFS_I(inode
)->write_behind_rc
;
1650 CIFS_I(inode
)->write_behind_rc
= 0;
1651 tcon
= tlink_tcon(smbfile
->tlink
);
1652 if (!rc
&& tcon
&& smbfile
&&
1653 !(CIFS_SB(inode
->i_sb
)->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
))
1654 rc
= CIFSSMBFlush(xid
, tcon
, smbfile
->netfid
);
1661 /* static void cifs_sync_page(struct page *page)
1663 struct address_space *mapping;
1664 struct inode *inode;
1665 unsigned long index = page->index;
1666 unsigned int rpages = 0;
1669 cFYI(1, "sync page %p", page);
1670 mapping = page->mapping;
1673 inode = mapping->host;
1677 /* fill in rpages then
1678 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1680 /* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1690 * As file closes, flush all cached write data for this inode checking
1691 * for write behind errors.
1693 int cifs_flush(struct file
*file
, fl_owner_t id
)
1695 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1698 /* Rather than do the steps manually:
1699 lock the inode for writing
1700 loop through pages looking for write behind data (dirty pages)
1701 coalesce into contiguous 16K (or smaller) chunks to write to server
1702 send to server (prefer in parallel)
1703 deal with writebehind errors
1704 unlock inode for writing
1705 filemapfdatawrite appears easier for the time being */
1707 rc
= filemap_fdatawrite(inode
->i_mapping
);
1708 /* reset wb rc if we were able to write out dirty pages */
1710 rc
= CIFS_I(inode
)->write_behind_rc
;
1711 CIFS_I(inode
)->write_behind_rc
= 0;
1714 cFYI(1, "Flush inode %p file %p rc %d", inode
, file
, rc
);
1719 ssize_t
cifs_user_read(struct file
*file
, char __user
*read_data
,
1720 size_t read_size
, loff_t
*poffset
)
1723 unsigned int bytes_read
= 0;
1724 unsigned int total_read
= 0;
1725 unsigned int current_read_size
;
1726 struct cifs_sb_info
*cifs_sb
;
1727 struct cifsTconInfo
*pTcon
;
1729 struct cifsFileInfo
*open_file
;
1730 char *smb_read_data
;
1731 char __user
*current_offset
;
1732 struct smb_com_read_rsp
*pSMBr
;
1735 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1737 if (file
->private_data
== NULL
) {
1742 open_file
= file
->private_data
;
1743 pTcon
= tlink_tcon(open_file
->tlink
);
1745 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1746 cFYI(1, "attempting read on write only file instance");
1748 for (total_read
= 0, current_offset
= read_data
;
1749 read_size
> total_read
;
1750 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1751 current_read_size
= min_t(const int, read_size
- total_read
,
1754 smb_read_data
= NULL
;
1755 while (rc
== -EAGAIN
) {
1756 int buf_type
= CIFS_NO_BUFFER
;
1757 if ((open_file
->invalidHandle
) &&
1758 (!open_file
->closePend
)) {
1759 rc
= cifs_reopen_file(open_file
, true);
1763 rc
= CIFSSMBRead(xid
, pTcon
,
1765 current_read_size
, *poffset
,
1766 &bytes_read
, &smb_read_data
,
1768 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
1769 if (smb_read_data
) {
1770 if (copy_to_user(current_offset
,
1772 4 /* RFC1001 length field */ +
1773 le16_to_cpu(pSMBr
->DataOffset
),
1777 if (buf_type
== CIFS_SMALL_BUFFER
)
1778 cifs_small_buf_release(smb_read_data
);
1779 else if (buf_type
== CIFS_LARGE_BUFFER
)
1780 cifs_buf_release(smb_read_data
);
1781 smb_read_data
= NULL
;
1784 if (rc
|| (bytes_read
== 0)) {
1792 cifs_stats_bytes_read(pTcon
, bytes_read
);
1793 *poffset
+= bytes_read
;
1801 static ssize_t
cifs_read(struct file
*file
, char *read_data
, size_t read_size
,
1805 unsigned int bytes_read
= 0;
1806 unsigned int total_read
;
1807 unsigned int current_read_size
;
1808 struct cifs_sb_info
*cifs_sb
;
1809 struct cifsTconInfo
*pTcon
;
1811 char *current_offset
;
1812 struct cifsFileInfo
*open_file
;
1813 int buf_type
= CIFS_NO_BUFFER
;
1816 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1818 if (file
->private_data
== NULL
) {
1823 open_file
= file
->private_data
;
1824 pTcon
= tlink_tcon(open_file
->tlink
);
1826 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1827 cFYI(1, "attempting read on write only file instance");
1829 for (total_read
= 0, current_offset
= read_data
;
1830 read_size
> total_read
;
1831 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1832 current_read_size
= min_t(const int, read_size
- total_read
,
1834 /* For windows me and 9x we do not want to request more
1835 than it negotiated since it will refuse the read then */
1837 !(pTcon
->ses
->capabilities
& CAP_LARGE_FILES
)) {
1838 current_read_size
= min_t(const int, current_read_size
,
1839 pTcon
->ses
->server
->maxBuf
- 128);
1842 while (rc
== -EAGAIN
) {
1843 if ((open_file
->invalidHandle
) &&
1844 (!open_file
->closePend
)) {
1845 rc
= cifs_reopen_file(open_file
, true);
1849 rc
= CIFSSMBRead(xid
, pTcon
,
1851 current_read_size
, *poffset
,
1852 &bytes_read
, ¤t_offset
,
1855 if (rc
|| (bytes_read
== 0)) {
1863 cifs_stats_bytes_read(pTcon
, total_read
);
1864 *poffset
+= bytes_read
;
1871 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1876 rc
= cifs_revalidate_file(file
);
1878 cFYI(1, "Validation prior to mmap failed, error=%d", rc
);
1882 rc
= generic_file_mmap(file
, vma
);
1888 static void cifs_copy_cache_pages(struct address_space
*mapping
,
1889 struct list_head
*pages
, int bytes_read
, char *data
)
1894 while (bytes_read
> 0) {
1895 if (list_empty(pages
))
1898 page
= list_entry(pages
->prev
, struct page
, lru
);
1899 list_del(&page
->lru
);
1901 if (add_to_page_cache_lru(page
, mapping
, page
->index
,
1903 page_cache_release(page
);
1904 cFYI(1, "Add page cache failed");
1905 data
+= PAGE_CACHE_SIZE
;
1906 bytes_read
-= PAGE_CACHE_SIZE
;
1909 page_cache_release(page
);
1911 target
= kmap_atomic(page
, KM_USER0
);
1913 if (PAGE_CACHE_SIZE
> bytes_read
) {
1914 memcpy(target
, data
, bytes_read
);
1915 /* zero the tail end of this partial page */
1916 memset(target
+ bytes_read
, 0,
1917 PAGE_CACHE_SIZE
- bytes_read
);
1920 memcpy(target
, data
, PAGE_CACHE_SIZE
);
1921 bytes_read
-= PAGE_CACHE_SIZE
;
1923 kunmap_atomic(target
, KM_USER0
);
1925 flush_dcache_page(page
);
1926 SetPageUptodate(page
);
1928 data
+= PAGE_CACHE_SIZE
;
1930 /* add page to FS-Cache */
1931 cifs_readpage_to_fscache(mapping
->host
, page
);
1936 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
1937 struct list_head
*page_list
, unsigned num_pages
)
1943 struct cifs_sb_info
*cifs_sb
;
1944 struct cifsTconInfo
*pTcon
;
1945 unsigned int bytes_read
= 0;
1946 unsigned int read_size
, i
;
1947 char *smb_read_data
= NULL
;
1948 struct smb_com_read_rsp
*pSMBr
;
1949 struct cifsFileInfo
*open_file
;
1950 int buf_type
= CIFS_NO_BUFFER
;
1953 if (file
->private_data
== NULL
) {
1958 open_file
= file
->private_data
;
1959 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1960 pTcon
= tlink_tcon(open_file
->tlink
);
1963 * Reads as many pages as possible from fscache. Returns -ENOBUFS
1964 * immediately if the cookie is negative
1966 rc
= cifs_readpages_from_fscache(mapping
->host
, mapping
, page_list
,
1971 cFYI(DBG2
, "rpages: num pages %d", num_pages
);
1972 for (i
= 0; i
< num_pages
; ) {
1973 unsigned contig_pages
;
1974 struct page
*tmp_page
;
1975 unsigned long expected_index
;
1977 if (list_empty(page_list
))
1980 page
= list_entry(page_list
->prev
, struct page
, lru
);
1981 offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1983 /* count adjacent pages that we will read into */
1986 list_entry(page_list
->prev
, struct page
, lru
)->index
;
1987 list_for_each_entry_reverse(tmp_page
, page_list
, lru
) {
1988 if (tmp_page
->index
== expected_index
) {
1994 if (contig_pages
+ i
> num_pages
)
1995 contig_pages
= num_pages
- i
;
1997 /* for reads over a certain size could initiate async
2000 read_size
= contig_pages
* PAGE_CACHE_SIZE
;
2001 /* Read size needs to be in multiples of one page */
2002 read_size
= min_t(const unsigned int, read_size
,
2003 cifs_sb
->rsize
& PAGE_CACHE_MASK
);
2004 cFYI(DBG2
, "rpages: read size 0x%x contiguous pages %d",
2005 read_size
, contig_pages
);
2007 while (rc
== -EAGAIN
) {
2008 if ((open_file
->invalidHandle
) &&
2009 (!open_file
->closePend
)) {
2010 rc
= cifs_reopen_file(open_file
, true);
2015 rc
= CIFSSMBRead(xid
, pTcon
,
2018 &bytes_read
, &smb_read_data
,
2020 /* BB more RC checks ? */
2021 if (rc
== -EAGAIN
) {
2022 if (smb_read_data
) {
2023 if (buf_type
== CIFS_SMALL_BUFFER
)
2024 cifs_small_buf_release(smb_read_data
);
2025 else if (buf_type
== CIFS_LARGE_BUFFER
)
2026 cifs_buf_release(smb_read_data
);
2027 smb_read_data
= NULL
;
2031 if ((rc
< 0) || (smb_read_data
== NULL
)) {
2032 cFYI(1, "Read error in readpages: %d", rc
);
2034 } else if (bytes_read
> 0) {
2035 task_io_account_read(bytes_read
);
2036 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
2037 cifs_copy_cache_pages(mapping
, page_list
, bytes_read
,
2038 smb_read_data
+ 4 /* RFC1001 hdr */ +
2039 le16_to_cpu(pSMBr
->DataOffset
));
2041 i
+= bytes_read
>> PAGE_CACHE_SHIFT
;
2042 cifs_stats_bytes_read(pTcon
, bytes_read
);
2043 if ((bytes_read
& PAGE_CACHE_MASK
) != bytes_read
) {
2044 i
++; /* account for partial page */
2046 /* server copy of file can have smaller size
2048 /* BB do we need to verify this common case ?
2049 this case is ok - if we are at server EOF
2050 we will hit it on next read */
2055 cFYI(1, "No bytes read (%d) at offset %lld . "
2056 "Cleaning remaining pages from readahead list",
2057 bytes_read
, offset
);
2058 /* BB turn off caching and do new lookup on
2059 file size at server? */
2062 if (smb_read_data
) {
2063 if (buf_type
== CIFS_SMALL_BUFFER
)
2064 cifs_small_buf_release(smb_read_data
);
2065 else if (buf_type
== CIFS_LARGE_BUFFER
)
2066 cifs_buf_release(smb_read_data
);
2067 smb_read_data
= NULL
;
2072 /* need to free smb_read_data buf before exit */
2073 if (smb_read_data
) {
2074 if (buf_type
== CIFS_SMALL_BUFFER
)
2075 cifs_small_buf_release(smb_read_data
);
2076 else if (buf_type
== CIFS_LARGE_BUFFER
)
2077 cifs_buf_release(smb_read_data
);
2078 smb_read_data
= NULL
;
2086 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
2092 /* Is the page cached? */
2093 rc
= cifs_readpage_from_fscache(file
->f_path
.dentry
->d_inode
, page
);
2097 page_cache_get(page
);
2098 read_data
= kmap(page
);
2099 /* for reads over a certain size could initiate async read ahead */
2101 rc
= cifs_read(file
, read_data
, PAGE_CACHE_SIZE
, poffset
);
2106 cFYI(1, "Bytes read %d", rc
);
2108 file
->f_path
.dentry
->d_inode
->i_atime
=
2109 current_fs_time(file
->f_path
.dentry
->d_inode
->i_sb
);
2111 if (PAGE_CACHE_SIZE
> rc
)
2112 memset(read_data
+ rc
, 0, PAGE_CACHE_SIZE
- rc
);
2114 flush_dcache_page(page
);
2115 SetPageUptodate(page
);
2117 /* send this page to the cache */
2118 cifs_readpage_to_fscache(file
->f_path
.dentry
->d_inode
, page
);
2124 page_cache_release(page
);
2130 static int cifs_readpage(struct file
*file
, struct page
*page
)
2132 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
2138 if (file
->private_data
== NULL
) {
2144 cFYI(1, "readpage %p at offset %d 0x%x\n",
2145 page
, (int)offset
, (int)offset
);
2147 rc
= cifs_readpage_worker(file
, page
, &offset
);
2155 static int is_inode_writable(struct cifsInodeInfo
*cifs_inode
)
2157 struct cifsFileInfo
*open_file
;
2159 read_lock(&GlobalSMBSeslock
);
2160 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
2161 if (open_file
->closePend
)
2163 if (open_file
->pfile
&&
2164 ((open_file
->pfile
->f_flags
& O_RDWR
) ||
2165 (open_file
->pfile
->f_flags
& O_WRONLY
))) {
2166 read_unlock(&GlobalSMBSeslock
);
2170 read_unlock(&GlobalSMBSeslock
);
2174 /* We do not want to update the file size from server for inodes
2175 open for write - to avoid races with writepage extending
2176 the file - in the future we could consider allowing
2177 refreshing the inode only on increases in the file size
2178 but this is tricky to do without racing with writebehind
2179 page caching in the current Linux kernel design */
2180 bool is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
, __u64 end_of_file
)
2185 if (is_inode_writable(cifsInode
)) {
2186 /* This inode is open for write at least once */
2187 struct cifs_sb_info
*cifs_sb
;
2189 cifs_sb
= CIFS_SB(cifsInode
->vfs_inode
.i_sb
);
2190 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
2191 /* since no page cache to corrupt on directio
2192 we can change size safely */
2196 if (i_size_read(&cifsInode
->vfs_inode
) < end_of_file
)
2204 static int cifs_write_begin(struct file
*file
, struct address_space
*mapping
,
2205 loff_t pos
, unsigned len
, unsigned flags
,
2206 struct page
**pagep
, void **fsdata
)
2208 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
2209 loff_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
2210 loff_t page_start
= pos
& PAGE_MASK
;
2215 cFYI(1, "write_begin from %lld len %d", (long long)pos
, len
);
2217 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
2223 if (PageUptodate(page
))
2227 * If we write a full page it will be up to date, no need to read from
2228 * the server. If the write is short, we'll end up doing a sync write
2231 if (len
== PAGE_CACHE_SIZE
)
2235 * optimize away the read when we have an oplock, and we're not
2236 * expecting to use any of the data we'd be reading in. That
2237 * is, when the page lies beyond the EOF, or straddles the EOF
2238 * and the write will cover all of the existing data.
2240 if (CIFS_I(mapping
->host
)->clientCanCacheRead
) {
2241 i_size
= i_size_read(mapping
->host
);
2242 if (page_start
>= i_size
||
2243 (offset
== 0 && (pos
+ len
) >= i_size
)) {
2244 zero_user_segments(page
, 0, offset
,
2248 * PageChecked means that the parts of the page
2249 * to which we're not writing are considered up
2250 * to date. Once the data is copied to the
2251 * page, it can be set uptodate.
2253 SetPageChecked(page
);
2258 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
) {
2260 * might as well read a page, it is fast enough. If we get
2261 * an error, we don't need to return it. cifs_write_end will
2262 * do a sync write instead since PG_uptodate isn't set.
2264 cifs_readpage_worker(file
, page
, &page_start
);
2266 /* we could try using another file handle if there is one -
2267 but how would we lock it to prevent close of that handle
2268 racing with this read? In any case
2269 this will be written out by write_end so is fine */
2276 static int cifs_release_page(struct page
*page
, gfp_t gfp
)
2278 if (PagePrivate(page
))
2281 return cifs_fscache_release_page(page
, gfp
);
2284 static void cifs_invalidate_page(struct page
*page
, unsigned long offset
)
2286 struct cifsInodeInfo
*cifsi
= CIFS_I(page
->mapping
->host
);
2289 cifs_fscache_invalidate_page(page
, &cifsi
->vfs_inode
);
2292 void cifs_oplock_break(struct work_struct
*work
)
2294 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2296 struct inode
*inode
= cfile
->dentry
->d_inode
;
2297 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2300 if (inode
&& S_ISREG(inode
->i_mode
)) {
2301 if (cinode
->clientCanCacheRead
)
2302 break_lease(inode
, O_RDONLY
);
2304 break_lease(inode
, O_WRONLY
);
2305 rc
= filemap_fdatawrite(inode
->i_mapping
);
2306 if (cinode
->clientCanCacheRead
== 0) {
2307 waitrc
= filemap_fdatawait(inode
->i_mapping
);
2308 invalidate_remote_inode(inode
);
2313 cinode
->write_behind_rc
= rc
;
2314 cFYI(1, "Oplock flush inode %p rc %d", inode
, rc
);
2318 * releasing stale oplock after recent reconnect of smb session using
2319 * a now incorrect file handle is not a data integrity issue but do
2320 * not bother sending an oplock release if session to server still is
2321 * disconnected since oplock already released by the server
2323 if (!cfile
->closePend
&& !cfile
->oplock_break_cancelled
) {
2324 rc
= CIFSSMBLock(0, tlink_tcon(cfile
->tlink
), cfile
->netfid
, 0,
2325 0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE
, false);
2326 cFYI(1, "Oplock release rc = %d", rc
);
2330 * We might have kicked in before is_valid_oplock_break()
2331 * finished grabbing reference for us. Make sure it's done by
2332 * waiting for GlobalSMSSeslock.
2334 write_lock(&GlobalSMBSeslock
);
2335 write_unlock(&GlobalSMBSeslock
);
2337 cifs_oplock_break_put(cfile
);
2340 void cifs_oplock_break_get(struct cifsFileInfo
*cfile
)
2342 cifs_sb_active(cfile
->dentry
->d_sb
);
2343 cifsFileInfo_get(cfile
);
2346 void cifs_oplock_break_put(struct cifsFileInfo
*cfile
)
2348 cifsFileInfo_put(cfile
);
2349 cifs_sb_deactive(cfile
->dentry
->d_sb
);
2352 const struct address_space_operations cifs_addr_ops
= {
2353 .readpage
= cifs_readpage
,
2354 .readpages
= cifs_readpages
,
2355 .writepage
= cifs_writepage
,
2356 .writepages
= cifs_writepages
,
2357 .write_begin
= cifs_write_begin
,
2358 .write_end
= cifs_write_end
,
2359 .set_page_dirty
= __set_page_dirty_nobuffers
,
2360 .releasepage
= cifs_release_page
,
2361 .invalidatepage
= cifs_invalidate_page
,
2362 /* .sync_page = cifs_sync_page, */
2367 * cifs_readpages requires the server to support a buffer large enough to
2368 * contain the header plus one complete page of data. Otherwise, we need
2369 * to leave cifs_readpages out of the address space operations.
2371 const struct address_space_operations cifs_addr_ops_smallbuf
= {
2372 .readpage
= cifs_readpage
,
2373 .writepage
= cifs_writepage
,
2374 .writepages
= cifs_writepages
,
2375 .write_begin
= cifs_write_begin
,
2376 .write_end
= cifs_write_end
,
2377 .set_page_dirty
= __set_page_dirty_nobuffers
,
2378 .releasepage
= cifs_release_page
,
2379 .invalidatepage
= cifs_invalidate_page
,
2380 /* .sync_page = cifs_sync_page, */