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 struct cifsFileInfo
*
223 cifs_new_fileinfo(__u16 fileHandle
, struct file
*file
,
224 struct tcon_link
*tlink
, __u32 oplock
)
226 struct dentry
*dentry
= file
->f_path
.dentry
;
227 struct inode
*inode
= dentry
->d_inode
;
228 struct cifsInodeInfo
*pCifsInode
= CIFS_I(inode
);
229 struct cifsFileInfo
*pCifsFile
;
231 pCifsFile
= kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
232 if (pCifsFile
== NULL
)
235 pCifsFile
->netfid
= fileHandle
;
236 pCifsFile
->pid
= current
->tgid
;
237 pCifsFile
->uid
= current_fsuid();
238 pCifsFile
->dentry
= dget(dentry
);
239 pCifsFile
->f_flags
= file
->f_flags
;
240 pCifsFile
->invalidHandle
= false;
241 pCifsFile
->tlink
= cifs_get_tlink(tlink
);
242 mutex_init(&pCifsFile
->fh_mutex
);
243 mutex_init(&pCifsFile
->lock_mutex
);
244 INIT_LIST_HEAD(&pCifsFile
->llist
);
245 atomic_set(&pCifsFile
->count
, 1);
246 INIT_WORK(&pCifsFile
->oplock_break
, cifs_oplock_break
);
248 spin_lock(&cifs_file_list_lock
);
249 list_add(&pCifsFile
->tlist
, &(tlink_tcon(tlink
)->openFileList
));
250 /* if readable file instance put first in list*/
251 if (file
->f_mode
& FMODE_READ
)
252 list_add(&pCifsFile
->flist
, &pCifsInode
->openFileList
);
254 list_add_tail(&pCifsFile
->flist
, &pCifsInode
->openFileList
);
255 spin_unlock(&cifs_file_list_lock
);
257 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
258 pCifsInode
->clientCanCacheAll
= true;
259 pCifsInode
->clientCanCacheRead
= true;
260 cFYI(1, "Exclusive Oplock inode %p", inode
);
261 } else if ((oplock
& 0xF) == OPLOCK_READ
)
262 pCifsInode
->clientCanCacheRead
= true;
264 file
->private_data
= pCifsFile
;
269 * Release a reference on the file private data. This may involve closing
270 * the filehandle out on the server.
272 void cifsFileInfo_put(struct cifsFileInfo
*cifs_file
)
274 struct cifsTconInfo
*tcon
= tlink_tcon(cifs_file
->tlink
);
275 struct cifsInodeInfo
*cifsi
= CIFS_I(cifs_file
->dentry
->d_inode
);
276 struct cifsLockInfo
*li
, *tmp
;
278 spin_lock(&cifs_file_list_lock
);
279 if (!atomic_dec_and_test(&cifs_file
->count
)) {
280 spin_unlock(&cifs_file_list_lock
);
284 /* remove it from the lists */
285 list_del(&cifs_file
->flist
);
286 list_del(&cifs_file
->tlist
);
288 if (list_empty(&cifsi
->openFileList
)) {
289 cFYI(1, "closing last open instance for inode %p",
290 cifs_file
->dentry
->d_inode
);
291 cifsi
->clientCanCacheRead
= false;
292 cifsi
->clientCanCacheAll
= false;
294 spin_unlock(&cifs_file_list_lock
);
296 if (!tcon
->need_reconnect
&& !cifs_file
->invalidHandle
) {
300 rc
= CIFSSMBClose(xid
, tcon
, cifs_file
->netfid
);
304 /* Delete any outstanding lock records. We'll lose them when the file
307 mutex_lock(&cifs_file
->lock_mutex
);
308 list_for_each_entry_safe(li
, tmp
, &cifs_file
->llist
, llist
) {
309 list_del(&li
->llist
);
312 mutex_unlock(&cifs_file
->lock_mutex
);
314 cifs_put_tlink(cifs_file
->tlink
);
315 dput(cifs_file
->dentry
);
319 int cifs_open(struct inode
*inode
, struct file
*file
)
324 struct cifs_sb_info
*cifs_sb
;
325 struct cifsTconInfo
*tcon
;
326 struct tcon_link
*tlink
;
327 struct cifsFileInfo
*pCifsFile
= NULL
;
328 struct cifsInodeInfo
*pCifsInode
;
329 char *full_path
= NULL
;
333 FILE_ALL_INFO
*buf
= NULL
;
337 cifs_sb
= CIFS_SB(inode
->i_sb
);
338 tlink
= cifs_sb_tlink(cifs_sb
);
341 return PTR_ERR(tlink
);
343 tcon
= tlink_tcon(tlink
);
345 pCifsInode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
347 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
348 if (full_path
== NULL
) {
353 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
354 inode
, file
->f_flags
, full_path
);
361 if (!tcon
->broken_posix_open
&& tcon
->unix_ext
&&
362 (tcon
->ses
->capabilities
& CAP_UNIX
) &&
363 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
364 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
365 /* can not refresh inode info since size could be stale */
366 rc
= cifs_posix_open(full_path
, &inode
, inode
->i_sb
,
367 cifs_sb
->mnt_file_mode
/* ignored */,
368 file
->f_flags
, &oplock
, &netfid
, xid
);
370 cFYI(1, "posix open succeeded");
372 pCifsFile
= cifs_new_fileinfo(netfid
, file
, tlink
,
374 if (pCifsFile
== NULL
) {
375 CIFSSMBClose(xid
, tcon
, netfid
);
379 cifs_fscache_set_inode_cookie(inode
, file
);
382 } else if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
383 if (tcon
->ses
->serverNOS
)
384 cERROR(1, "server %s of type %s returned"
385 " unexpected error on SMB posix open"
386 ", disabling posix open support."
387 " Check if server update available.",
388 tcon
->ses
->serverName
,
389 tcon
->ses
->serverNOS
);
390 tcon
->broken_posix_open
= true;
391 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
392 (rc
!= -EOPNOTSUPP
)) /* path not found or net err */
394 /* else fallthrough to retry open the old way on network i/o
398 desiredAccess
= cifs_convert_flags(file
->f_flags
);
400 /*********************************************************************
401 * open flag mapping table:
403 * POSIX Flag CIFS Disposition
404 * ---------- ----------------
405 * O_CREAT FILE_OPEN_IF
406 * O_CREAT | O_EXCL FILE_CREATE
407 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
408 * O_TRUNC FILE_OVERWRITE
409 * none of the above FILE_OPEN
411 * Note that there is not a direct match between disposition
412 * FILE_SUPERSEDE (ie create whether or not file exists although
413 * O_CREAT | O_TRUNC is similar but truncates the existing
414 * file rather than creating a new file as FILE_SUPERSEDE does
415 * (which uses the attributes / metadata passed in on open call)
417 *? O_SYNC is a reasonable match to CIFS writethrough flag
418 *? and the read write flags match reasonably. O_LARGEFILE
419 *? is irrelevant because largefile support is always used
420 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
421 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
422 *********************************************************************/
424 disposition
= cifs_get_disposition(file
->f_flags
);
426 /* BB pass O_SYNC flag through on file attributes .. BB */
428 /* Also refresh inode by passing in file_info buf returned by SMBOpen
429 and calling get_inode_info with returned buf (at least helps
430 non-Unix server case) */
432 /* BB we can not do this if this is the second open of a file
433 and the first handle has writebehind data, we might be
434 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
435 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
441 if (tcon
->ses
->capabilities
& CAP_NT_SMBS
)
442 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
443 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
444 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
445 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
447 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
450 /* Old server, try legacy style OpenX */
451 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
452 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
453 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
454 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
457 cFYI(1, "cifs_open returned 0x%x", rc
);
461 rc
= cifs_open_inode_helper(inode
, tcon
, oplock
, buf
, full_path
, xid
);
465 pCifsFile
= cifs_new_fileinfo(netfid
, file
, tlink
, oplock
);
466 if (pCifsFile
== NULL
) {
471 cifs_fscache_set_inode_cookie(inode
, file
);
473 if (oplock
& CIFS_CREATE_ACTION
) {
474 /* time to set mode which we can not set earlier due to
475 problems creating new read-only files */
476 if (tcon
->unix_ext
) {
477 struct cifs_unix_set_info_args args
= {
478 .mode
= inode
->i_mode
,
481 .ctime
= NO_CHANGE_64
,
482 .atime
= NO_CHANGE_64
,
483 .mtime
= NO_CHANGE_64
,
486 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
488 cifs_sb
->mnt_cifs_flags
&
489 CIFS_MOUNT_MAP_SPECIAL_CHR
);
497 cifs_put_tlink(tlink
);
501 /* Try to reacquire byte range locks that were released when session */
502 /* to server was lost */
503 static int cifs_relock_file(struct cifsFileInfo
*cifsFile
)
507 /* BB list all locks open on this file and relock */
512 static int cifs_reopen_file(struct cifsFileInfo
*pCifsFile
, bool can_flush
)
517 struct cifs_sb_info
*cifs_sb
;
518 struct cifsTconInfo
*tcon
;
519 struct cifsInodeInfo
*pCifsInode
;
521 char *full_path
= NULL
;
523 int disposition
= FILE_OPEN
;
527 mutex_lock(&pCifsFile
->fh_mutex
);
528 if (!pCifsFile
->invalidHandle
) {
529 mutex_unlock(&pCifsFile
->fh_mutex
);
535 inode
= pCifsFile
->dentry
->d_inode
;
536 cifs_sb
= CIFS_SB(inode
->i_sb
);
537 tcon
= tlink_tcon(pCifsFile
->tlink
);
539 /* can not grab rename sem here because various ops, including
540 those that already have the rename sem can end up causing writepage
541 to get called and if the server was down that means we end up here,
542 and we can never tell if the caller already has the rename_sem */
543 full_path
= build_path_from_dentry(pCifsFile
->dentry
);
544 if (full_path
== NULL
) {
546 mutex_unlock(&pCifsFile
->fh_mutex
);
551 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
552 inode
, pCifsFile
->f_flags
, full_path
);
559 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
560 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
561 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
564 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
565 * original open. Must mask them off for a reopen.
567 unsigned int oflags
= pCifsFile
->f_flags
&
568 ~(O_CREAT
| O_EXCL
| O_TRUNC
);
570 rc
= cifs_posix_open(full_path
, NULL
, inode
->i_sb
,
571 cifs_sb
->mnt_file_mode
/* ignored */,
572 oflags
, &oplock
, &netfid
, xid
);
574 cFYI(1, "posix reopen succeeded");
577 /* fallthrough to retry open the old way on errors, especially
578 in the reconnect path it is important to retry hard */
581 desiredAccess
= cifs_convert_flags(pCifsFile
->f_flags
);
583 /* Can not refresh inode by passing in file_info buf to be returned
584 by SMBOpen and then calling get_inode_info with returned buf
585 since file might have write behind data that needs to be flushed
586 and server version of file size can be stale. If we knew for sure
587 that inode was not dirty locally we could do this */
589 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
, desiredAccess
,
590 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
591 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
592 CIFS_MOUNT_MAP_SPECIAL_CHR
);
594 mutex_unlock(&pCifsFile
->fh_mutex
);
595 cFYI(1, "cifs_open returned 0x%x", rc
);
596 cFYI(1, "oplock: %d", oplock
);
597 goto reopen_error_exit
;
601 pCifsFile
->netfid
= netfid
;
602 pCifsFile
->invalidHandle
= false;
603 mutex_unlock(&pCifsFile
->fh_mutex
);
604 pCifsInode
= CIFS_I(inode
);
607 rc
= filemap_write_and_wait(inode
->i_mapping
);
609 CIFS_I(inode
)->write_behind_rc
= rc
;
611 pCifsInode
->clientCanCacheAll
= false;
612 pCifsInode
->clientCanCacheRead
= false;
614 rc
= cifs_get_inode_info_unix(&inode
,
615 full_path
, inode
->i_sb
, xid
);
617 rc
= cifs_get_inode_info(&inode
,
618 full_path
, NULL
, inode
->i_sb
,
620 } /* else we are writing out data to server already
621 and could deadlock if we tried to flush data, and
622 since we do not know if we have data that would
623 invalidate the current end of file on the server
624 we can not go to the server to get the new inod
626 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
627 pCifsInode
->clientCanCacheAll
= true;
628 pCifsInode
->clientCanCacheRead
= true;
629 cFYI(1, "Exclusive Oplock granted on inode %p",
630 pCifsFile
->dentry
->d_inode
);
631 } else if ((oplock
& 0xF) == OPLOCK_READ
) {
632 pCifsInode
->clientCanCacheRead
= true;
633 pCifsInode
->clientCanCacheAll
= false;
635 pCifsInode
->clientCanCacheRead
= false;
636 pCifsInode
->clientCanCacheAll
= false;
638 cifs_relock_file(pCifsFile
);
646 int cifs_close(struct inode
*inode
, struct file
*file
)
648 cifsFileInfo_put(file
->private_data
);
649 file
->private_data
= NULL
;
651 /* return code from the ->release op is always ignored */
655 int cifs_closedir(struct inode
*inode
, struct file
*file
)
659 struct cifsFileInfo
*pCFileStruct
= file
->private_data
;
662 cFYI(1, "Closedir inode = 0x%p", inode
);
667 struct cifsTconInfo
*pTcon
= tlink_tcon(pCFileStruct
->tlink
);
669 cFYI(1, "Freeing private data in close dir");
670 spin_lock(&cifs_file_list_lock
);
671 if (!pCFileStruct
->srch_inf
.endOfSearch
&&
672 !pCFileStruct
->invalidHandle
) {
673 pCFileStruct
->invalidHandle
= true;
674 spin_unlock(&cifs_file_list_lock
);
675 rc
= CIFSFindClose(xid
, pTcon
, pCFileStruct
->netfid
);
676 cFYI(1, "Closing uncompleted readdir with rc %d",
678 /* not much we can do if it fails anyway, ignore rc */
681 spin_unlock(&cifs_file_list_lock
);
682 ptmp
= pCFileStruct
->srch_inf
.ntwrk_buf_start
;
684 cFYI(1, "closedir free smb buf in srch struct");
685 pCFileStruct
->srch_inf
.ntwrk_buf_start
= NULL
;
686 if (pCFileStruct
->srch_inf
.smallBuf
)
687 cifs_small_buf_release(ptmp
);
689 cifs_buf_release(ptmp
);
691 cifs_put_tlink(pCFileStruct
->tlink
);
692 kfree(file
->private_data
);
693 file
->private_data
= NULL
;
695 /* BB can we lock the filestruct while this is going on? */
700 static int store_file_lock(struct cifsFileInfo
*fid
, __u64 len
,
701 __u64 offset
, __u8 lockType
)
703 struct cifsLockInfo
*li
=
704 kmalloc(sizeof(struct cifsLockInfo
), GFP_KERNEL
);
710 mutex_lock(&fid
->lock_mutex
);
711 list_add(&li
->llist
, &fid
->llist
);
712 mutex_unlock(&fid
->lock_mutex
);
716 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*pfLock
)
722 bool wait_flag
= false;
723 struct cifs_sb_info
*cifs_sb
;
724 struct cifsTconInfo
*tcon
;
726 __u8 lockType
= LOCKING_ANDX_LARGE_FILES
;
727 bool posix_locking
= 0;
729 length
= 1 + pfLock
->fl_end
- pfLock
->fl_start
;
733 cFYI(1, "Lock parm: 0x%x flockflags: "
734 "0x%x flocktype: 0x%x start: %lld end: %lld",
735 cmd
, pfLock
->fl_flags
, pfLock
->fl_type
, pfLock
->fl_start
,
738 if (pfLock
->fl_flags
& FL_POSIX
)
740 if (pfLock
->fl_flags
& FL_FLOCK
)
742 if (pfLock
->fl_flags
& FL_SLEEP
) {
743 cFYI(1, "Blocking lock");
746 if (pfLock
->fl_flags
& FL_ACCESS
)
747 cFYI(1, "Process suspended by mandatory locking - "
748 "not implemented yet");
749 if (pfLock
->fl_flags
& FL_LEASE
)
750 cFYI(1, "Lease on file - not implemented yet");
751 if (pfLock
->fl_flags
&
752 (~(FL_POSIX
| FL_FLOCK
| FL_SLEEP
| FL_ACCESS
| FL_LEASE
)))
753 cFYI(1, "Unknown lock flags 0x%x", pfLock
->fl_flags
);
755 if (pfLock
->fl_type
== F_WRLCK
) {
758 } else if (pfLock
->fl_type
== F_UNLCK
) {
761 /* Check if unlock includes more than
763 } else if (pfLock
->fl_type
== F_RDLCK
) {
765 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
767 } else if (pfLock
->fl_type
== F_EXLCK
) {
770 } else if (pfLock
->fl_type
== F_SHLCK
) {
772 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
775 cFYI(1, "Unknown type of lock");
777 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
778 tcon
= tlink_tcon(((struct cifsFileInfo
*)file
->private_data
)->tlink
);
780 if (file
->private_data
== NULL
) {
785 netfid
= ((struct cifsFileInfo
*)file
->private_data
)->netfid
;
787 if ((tcon
->ses
->capabilities
& CAP_UNIX
) &&
788 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
789 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
791 /* BB add code here to normalize offset and length to
792 account for negative length which we can not accept over the
797 if (lockType
& LOCKING_ANDX_SHARED_LOCK
)
798 posix_lock_type
= CIFS_RDLCK
;
800 posix_lock_type
= CIFS_WRLCK
;
801 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, 1 /* get */,
803 posix_lock_type
, wait_flag
);
808 /* BB we could chain these into one lock request BB */
809 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
, pfLock
->fl_start
,
810 0, 1, lockType
, 0 /* wait flag */ );
812 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
813 pfLock
->fl_start
, 1 /* numUnlock */ ,
814 0 /* numLock */ , lockType
,
816 pfLock
->fl_type
= F_UNLCK
;
818 cERROR(1, "Error unlocking previously locked "
819 "range %d during test of lock", rc
);
823 /* if rc == ERR_SHARING_VIOLATION ? */
826 if (lockType
& LOCKING_ANDX_SHARED_LOCK
) {
827 pfLock
->fl_type
= F_WRLCK
;
829 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
830 pfLock
->fl_start
, 0, 1,
831 lockType
| LOCKING_ANDX_SHARED_LOCK
,
834 rc
= CIFSSMBLock(xid
, tcon
, netfid
,
835 length
, pfLock
->fl_start
, 1, 0,
837 LOCKING_ANDX_SHARED_LOCK
,
839 pfLock
->fl_type
= F_RDLCK
;
841 cERROR(1, "Error unlocking "
842 "previously locked range %d "
843 "during test of lock", rc
);
846 pfLock
->fl_type
= F_WRLCK
;
856 if (!numLock
&& !numUnlock
) {
857 /* if no lock or unlock then nothing
858 to do since we do not know what it is */
865 if (lockType
& LOCKING_ANDX_SHARED_LOCK
)
866 posix_lock_type
= CIFS_RDLCK
;
868 posix_lock_type
= CIFS_WRLCK
;
871 posix_lock_type
= CIFS_UNLCK
;
873 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, 0 /* set */,
875 posix_lock_type
, wait_flag
);
877 struct cifsFileInfo
*fid
= file
->private_data
;
880 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
882 0, numLock
, lockType
, wait_flag
);
885 /* For Windows locks we must store them. */
886 rc
= store_file_lock(fid
, length
,
887 pfLock
->fl_start
, lockType
);
889 } else if (numUnlock
) {
890 /* For each stored lock that this unlock overlaps
891 completely, unlock it. */
893 struct cifsLockInfo
*li
, *tmp
;
896 mutex_lock(&fid
->lock_mutex
);
897 list_for_each_entry_safe(li
, tmp
, &fid
->llist
, llist
) {
898 if (pfLock
->fl_start
<= li
->offset
&&
899 (pfLock
->fl_start
+ length
) >=
900 (li
->offset
+ li
->length
)) {
901 stored_rc
= CIFSSMBLock(xid
, tcon
,
903 li
->length
, li
->offset
,
904 1, 0, li
->type
, false);
908 list_del(&li
->llist
);
913 mutex_unlock(&fid
->lock_mutex
);
917 if (pfLock
->fl_flags
& FL_POSIX
)
918 posix_lock_file_wait(file
, pfLock
);
924 * Set the timeout on write requests past EOF. For some servers (Windows)
925 * these calls can be very long.
927 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
928 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
929 * The 10M cutoff is totally arbitrary. A better scheme for this would be
930 * welcome if someone wants to suggest one.
932 * We may be able to do a better job with this if there were some way to
933 * declare that a file should be sparse.
936 cifs_write_timeout(struct cifsInodeInfo
*cifsi
, loff_t offset
)
938 if (offset
<= cifsi
->server_eof
)
940 else if (offset
> (cifsi
->server_eof
+ (10 * 1024 * 1024)))
941 return CIFS_VLONG_OP
;
946 /* update the file size (if needed) after a write */
948 cifs_update_eof(struct cifsInodeInfo
*cifsi
, loff_t offset
,
949 unsigned int bytes_written
)
951 loff_t end_of_write
= offset
+ bytes_written
;
953 if (end_of_write
> cifsi
->server_eof
)
954 cifsi
->server_eof
= end_of_write
;
957 ssize_t
cifs_user_write(struct file
*file
, const char __user
*write_data
,
958 size_t write_size
, loff_t
*poffset
)
961 unsigned int bytes_written
= 0;
962 unsigned int total_written
;
963 struct cifs_sb_info
*cifs_sb
;
964 struct cifsTconInfo
*pTcon
;
966 struct cifsFileInfo
*open_file
;
967 struct cifsInodeInfo
*cifsi
= CIFS_I(file
->f_path
.dentry
->d_inode
);
969 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
971 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
972 *poffset, file->f_path.dentry->d_name.name); */
974 if (file
->private_data
== NULL
)
977 open_file
= file
->private_data
;
978 pTcon
= tlink_tcon(open_file
->tlink
);
980 rc
= generic_write_checks(file
, poffset
, &write_size
, 0);
986 long_op
= cifs_write_timeout(cifsi
, *poffset
);
987 for (total_written
= 0; write_size
> total_written
;
988 total_written
+= bytes_written
) {
990 while (rc
== -EAGAIN
) {
991 if (file
->private_data
== NULL
) {
992 /* file has been closed on us */
994 /* if we have gotten here we have written some data
995 and blocked, and the file has been freed on us while
996 we blocked so return what we managed to write */
997 return total_written
;
999 if (open_file
->invalidHandle
) {
1000 /* we could deadlock if we called
1001 filemap_fdatawait from here so tell
1002 reopen_file not to flush data to server
1004 rc
= cifs_reopen_file(open_file
, false);
1009 rc
= CIFSSMBWrite(xid
, pTcon
,
1011 min_t(const int, cifs_sb
->wsize
,
1012 write_size
- total_written
),
1013 *poffset
, &bytes_written
,
1014 NULL
, write_data
+ total_written
, long_op
);
1016 if (rc
|| (bytes_written
== 0)) {
1024 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1025 *poffset
+= bytes_written
;
1027 long_op
= CIFS_STD_OP
; /* subsequent writes fast -
1028 15 seconds is plenty */
1031 cifs_stats_bytes_written(pTcon
, total_written
);
1033 /* since the write may have blocked check these pointers again */
1034 if ((file
->f_path
.dentry
) && (file
->f_path
.dentry
->d_inode
)) {
1035 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1036 /* Do not update local mtime - server will set its actual value on write
1037 * inode->i_ctime = inode->i_mtime =
1038 * current_fs_time(inode->i_sb);*/
1039 if (total_written
> 0) {
1040 spin_lock(&inode
->i_lock
);
1041 if (*poffset
> file
->f_path
.dentry
->d_inode
->i_size
)
1042 i_size_write(file
->f_path
.dentry
->d_inode
,
1044 spin_unlock(&inode
->i_lock
);
1046 mark_inode_dirty_sync(file
->f_path
.dentry
->d_inode
);
1049 return total_written
;
1052 static ssize_t
cifs_write(struct cifsFileInfo
*open_file
,
1053 const char *write_data
, size_t write_size
,
1057 unsigned int bytes_written
= 0;
1058 unsigned int total_written
;
1059 struct cifs_sb_info
*cifs_sb
;
1060 struct cifsTconInfo
*pTcon
;
1062 struct dentry
*dentry
= open_file
->dentry
;
1063 struct cifsInodeInfo
*cifsi
= CIFS_I(dentry
->d_inode
);
1065 cifs_sb
= CIFS_SB(dentry
->d_sb
);
1067 cFYI(1, "write %zd bytes to offset %lld of %s", write_size
,
1068 *poffset
, dentry
->d_name
.name
);
1070 pTcon
= tlink_tcon(open_file
->tlink
);
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 (open_file
->invalidHandle
) {
1080 /* we could deadlock if we called
1081 filemap_fdatawait from here so tell
1082 reopen_file not to flush data to
1084 rc
= cifs_reopen_file(open_file
, false);
1088 if (experimEnabled
|| (pTcon
->ses
->server
&&
1089 ((pTcon
->ses
->server
->secMode
&
1090 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
1095 len
= min((size_t)cifs_sb
->wsize
,
1096 write_size
- total_written
);
1097 /* iov[0] is reserved for smb header */
1098 iov
[1].iov_base
= (char *)write_data
+
1100 iov
[1].iov_len
= len
;
1101 rc
= CIFSSMBWrite2(xid
, pTcon
,
1102 open_file
->netfid
, len
,
1103 *poffset
, &bytes_written
,
1106 rc
= CIFSSMBWrite(xid
, pTcon
,
1108 min_t(const int, cifs_sb
->wsize
,
1109 write_size
- total_written
),
1110 *poffset
, &bytes_written
,
1111 write_data
+ total_written
,
1114 if (rc
|| (bytes_written
== 0)) {
1122 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1123 *poffset
+= bytes_written
;
1125 long_op
= CIFS_STD_OP
; /* subsequent writes fast -
1126 15 seconds is plenty */
1129 cifs_stats_bytes_written(pTcon
, total_written
);
1131 if (total_written
> 0) {
1132 spin_lock(&dentry
->d_inode
->i_lock
);
1133 if (*poffset
> dentry
->d_inode
->i_size
)
1134 i_size_write(dentry
->d_inode
, *poffset
);
1135 spin_unlock(&dentry
->d_inode
->i_lock
);
1137 mark_inode_dirty_sync(dentry
->d_inode
);
1139 return total_written
;
1142 #ifdef CONFIG_CIFS_EXPERIMENTAL
1143 struct cifsFileInfo
*find_readable_file(struct cifsInodeInfo
*cifs_inode
,
1146 struct cifsFileInfo
*open_file
= NULL
;
1147 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1149 /* only filter by fsuid on multiuser mounts */
1150 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1153 spin_lock(&cifs_file_list_lock
);
1154 /* we could simply get the first_list_entry since write-only entries
1155 are always at the end of the list but since the first entry might
1156 have a close pending, we go through the whole list */
1157 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1158 if (fsuid_only
&& open_file
->uid
!= current_fsuid())
1160 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_READ
) {
1161 if (!open_file
->invalidHandle
) {
1162 /* found a good file */
1163 /* lock it so it will not be closed on us */
1164 cifsFileInfo_get(open_file
);
1165 spin_unlock(&cifs_file_list_lock
);
1167 } /* else might as well continue, and look for
1168 another, or simply have the caller reopen it
1169 again rather than trying to fix this handle */
1170 } else /* write only file */
1171 break; /* write only files are last so must be done */
1173 spin_unlock(&cifs_file_list_lock
);
1178 struct cifsFileInfo
*find_writable_file(struct cifsInodeInfo
*cifs_inode
,
1181 struct cifsFileInfo
*open_file
;
1182 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1183 bool any_available
= false;
1186 /* Having a null inode here (because mapping->host was set to zero by
1187 the VFS or MM) should not happen but we had reports of on oops (due to
1188 it being zero) during stress testcases so we need to check for it */
1190 if (cifs_inode
== NULL
) {
1191 cERROR(1, "Null inode passed to cifs_writeable_file");
1196 /* only filter by fsuid on multiuser mounts */
1197 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1200 spin_lock(&cifs_file_list_lock
);
1202 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1203 if (!any_available
&& open_file
->pid
!= current
->tgid
)
1205 if (fsuid_only
&& open_file
->uid
!= current_fsuid())
1207 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
1208 cifsFileInfo_get(open_file
);
1210 if (!open_file
->invalidHandle
) {
1211 /* found a good writable file */
1212 spin_unlock(&cifs_file_list_lock
);
1216 spin_unlock(&cifs_file_list_lock
);
1218 /* Had to unlock since following call can block */
1219 rc
= cifs_reopen_file(open_file
, false);
1223 /* if it fails, try another handle if possible */
1224 cFYI(1, "wp failed on reopen file");
1225 cifsFileInfo_put(open_file
);
1227 spin_lock(&cifs_file_list_lock
);
1229 /* else we simply continue to the next entry. Thus
1230 we do not loop on reopen errors. If we
1231 can not reopen the file, for example if we
1232 reconnected to a server with another client
1233 racing to delete or lock the file we would not
1234 make progress if we restarted before the beginning
1235 of the loop here. */
1238 /* couldn't find useable FH with same pid, try any available */
1239 if (!any_available
) {
1240 any_available
= true;
1241 goto refind_writable
;
1243 spin_unlock(&cifs_file_list_lock
);
1247 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
1249 struct address_space
*mapping
= page
->mapping
;
1250 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1253 int bytes_written
= 0;
1254 struct cifs_sb_info
*cifs_sb
;
1255 struct inode
*inode
;
1256 struct cifsFileInfo
*open_file
;
1258 if (!mapping
|| !mapping
->host
)
1261 inode
= page
->mapping
->host
;
1262 cifs_sb
= CIFS_SB(inode
->i_sb
);
1264 offset
+= (loff_t
)from
;
1265 write_data
= kmap(page
);
1268 if ((to
> PAGE_CACHE_SIZE
) || (from
> to
)) {
1273 /* racing with truncate? */
1274 if (offset
> mapping
->host
->i_size
) {
1276 return 0; /* don't care */
1279 /* check to make sure that we are not extending the file */
1280 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
1281 to
= (unsigned)(mapping
->host
->i_size
- offset
);
1283 open_file
= find_writable_file(CIFS_I(mapping
->host
), false);
1285 bytes_written
= cifs_write(open_file
, write_data
,
1286 to
- from
, &offset
);
1287 cifsFileInfo_put(open_file
);
1288 /* Does mm or vfs already set times? */
1289 inode
->i_atime
= inode
->i_mtime
= current_fs_time(inode
->i_sb
);
1290 if ((bytes_written
> 0) && (offset
))
1292 else if (bytes_written
< 0)
1295 cFYI(1, "No writeable filehandles for inode");
1303 static int cifs_writepages(struct address_space
*mapping
,
1304 struct writeback_control
*wbc
)
1306 struct backing_dev_info
*bdi
= mapping
->backing_dev_info
;
1307 unsigned int bytes_to_write
;
1308 unsigned int bytes_written
;
1309 struct cifs_sb_info
*cifs_sb
;
1313 int range_whole
= 0;
1320 struct cifsFileInfo
*open_file
;
1321 struct cifsTconInfo
*tcon
;
1322 struct cifsInodeInfo
*cifsi
= CIFS_I(mapping
->host
);
1324 struct pagevec pvec
;
1330 * BB: Is this meaningful for a non-block-device file system?
1331 * If it is, we should test it again after we do I/O
1333 if (wbc
->nonblocking
&& bdi_write_congested(bdi
)) {
1334 wbc
->encountered_congestion
= 1;
1338 cifs_sb
= CIFS_SB(mapping
->host
->i_sb
);
1341 * If wsize is smaller that the page cache size, default to writing
1342 * one page at a time via cifs_writepage
1344 if (cifs_sb
->wsize
< PAGE_CACHE_SIZE
)
1345 return generic_writepages(mapping
, wbc
);
1347 iov
= kmalloc(32 * sizeof(struct kvec
), GFP_KERNEL
);
1349 return generic_writepages(mapping
, wbc
);
1352 * if there's no open file, then this is likely to fail too,
1353 * but it'll at least handle the return. Maybe it should be
1356 open_file
= find_writable_file(CIFS_I(mapping
->host
), false);
1359 return generic_writepages(mapping
, wbc
);
1362 tcon
= tlink_tcon(open_file
->tlink
);
1363 if (!experimEnabled
&& tcon
->ses
->server
->secMode
&
1364 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
)) {
1365 cifsFileInfo_put(open_file
);
1366 return generic_writepages(mapping
, wbc
);
1368 cifsFileInfo_put(open_file
);
1372 pagevec_init(&pvec
, 0);
1373 if (wbc
->range_cyclic
) {
1374 index
= mapping
->writeback_index
; /* Start from prev offset */
1377 index
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
1378 end
= wbc
->range_end
>> PAGE_CACHE_SHIFT
;
1379 if (wbc
->range_start
== 0 && wbc
->range_end
== LLONG_MAX
)
1384 while (!done
&& (index
<= end
) &&
1385 (nr_pages
= pagevec_lookup_tag(&pvec
, mapping
, &index
,
1386 PAGECACHE_TAG_DIRTY
,
1387 min(end
- index
, (pgoff_t
)PAGEVEC_SIZE
- 1) + 1))) {
1396 for (i
= 0; i
< nr_pages
; i
++) {
1397 page
= pvec
.pages
[i
];
1399 * At this point we hold neither mapping->tree_lock nor
1400 * lock on the page itself: the page may be truncated or
1401 * invalidated (changing page->mapping to NULL), or even
1402 * swizzled back from swapper_space to tmpfs file
1408 else if (!trylock_page(page
))
1411 if (unlikely(page
->mapping
!= mapping
)) {
1416 if (!wbc
->range_cyclic
&& page
->index
> end
) {
1422 if (next
&& (page
->index
!= next
)) {
1423 /* Not next consecutive page */
1428 if (wbc
->sync_mode
!= WB_SYNC_NONE
)
1429 wait_on_page_writeback(page
);
1431 if (PageWriteback(page
) ||
1432 !clear_page_dirty_for_io(page
)) {
1438 * This actually clears the dirty bit in the radix tree.
1439 * See cifs_writepage() for more commentary.
1441 set_page_writeback(page
);
1443 if (page_offset(page
) >= mapping
->host
->i_size
) {
1446 end_page_writeback(page
);
1451 * BB can we get rid of this? pages are held by pvec
1453 page_cache_get(page
);
1455 len
= min(mapping
->host
->i_size
- page_offset(page
),
1456 (loff_t
)PAGE_CACHE_SIZE
);
1458 /* reserve iov[0] for the smb header */
1460 iov
[n_iov
].iov_base
= kmap(page
);
1461 iov
[n_iov
].iov_len
= len
;
1462 bytes_to_write
+= len
;
1466 offset
= page_offset(page
);
1468 next
= page
->index
+ 1;
1469 if (bytes_to_write
+ PAGE_CACHE_SIZE
> cifs_sb
->wsize
)
1473 open_file
= find_writable_file(CIFS_I(mapping
->host
),
1476 cERROR(1, "No writable handles for inode");
1479 long_op
= cifs_write_timeout(cifsi
, offset
);
1480 rc
= CIFSSMBWrite2(xid
, tcon
, open_file
->netfid
,
1481 bytes_to_write
, offset
,
1482 &bytes_written
, iov
, n_iov
,
1484 cifsFileInfo_put(open_file
);
1485 cifs_update_eof(cifsi
, offset
, bytes_written
);
1488 if (rc
|| bytes_written
< bytes_to_write
) {
1489 cERROR(1, "Write2 ret %d, wrote %d",
1491 /* BB what if continued retry is
1492 requested via mount flags? */
1494 set_bit(AS_ENOSPC
, &mapping
->flags
);
1496 set_bit(AS_EIO
, &mapping
->flags
);
1498 cifs_stats_bytes_written(tcon
, bytes_written
);
1501 for (i
= 0; i
< n_iov
; i
++) {
1502 page
= pvec
.pages
[first
+ i
];
1503 /* Should we also set page error on
1504 success rc but too little data written? */
1505 /* BB investigate retry logic on temporary
1506 server crash cases and how recovery works
1507 when page marked as error */
1512 end_page_writeback(page
);
1513 page_cache_release(page
);
1515 if ((wbc
->nr_to_write
-= n_iov
) <= 0)
1519 /* Need to re-find the pages we skipped */
1520 index
= pvec
.pages
[0]->index
+ 1;
1522 pagevec_release(&pvec
);
1524 if (!scanned
&& !done
) {
1526 * We hit the last page and there is more work to be done: wrap
1527 * back to the start of the file
1533 if (wbc
->range_cyclic
|| (range_whole
&& wbc
->nr_to_write
> 0))
1534 mapping
->writeback_index
= index
;
1541 static int cifs_writepage(struct page
*page
, struct writeback_control
*wbc
)
1547 /* BB add check for wbc flags */
1548 page_cache_get(page
);
1549 if (!PageUptodate(page
))
1550 cFYI(1, "ppw - page not up to date");
1553 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1555 * A writepage() implementation always needs to do either this,
1556 * or re-dirty the page with "redirty_page_for_writepage()" in
1557 * the case of a failure.
1559 * Just unlocking the page will cause the radix tree tag-bits
1560 * to fail to update with the state of the page correctly.
1562 set_page_writeback(page
);
1563 rc
= cifs_partialpagewrite(page
, 0, PAGE_CACHE_SIZE
);
1564 SetPageUptodate(page
); /* BB add check for error and Clearuptodate? */
1566 end_page_writeback(page
);
1567 page_cache_release(page
);
1572 static int cifs_write_end(struct file
*file
, struct address_space
*mapping
,
1573 loff_t pos
, unsigned len
, unsigned copied
,
1574 struct page
*page
, void *fsdata
)
1577 struct inode
*inode
= mapping
->host
;
1579 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1582 if (PageChecked(page
)) {
1584 SetPageUptodate(page
);
1585 ClearPageChecked(page
);
1586 } else if (!PageUptodate(page
) && copied
== PAGE_CACHE_SIZE
)
1587 SetPageUptodate(page
);
1589 if (!PageUptodate(page
)) {
1591 unsigned offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1595 /* this is probably better than directly calling
1596 partialpage_write since in this function the file handle is
1597 known which we might as well leverage */
1598 /* BB check if anything else missing out of ppw
1599 such as updating last write time */
1600 page_data
= kmap(page
);
1601 rc
= cifs_write(file
->private_data
, page_data
+ offset
,
1603 /* if (rc < 0) should we set writebehind rc? */
1610 set_page_dirty(page
);
1614 spin_lock(&inode
->i_lock
);
1615 if (pos
> inode
->i_size
)
1616 i_size_write(inode
, pos
);
1617 spin_unlock(&inode
->i_lock
);
1621 page_cache_release(page
);
1626 int cifs_fsync(struct file
*file
, int datasync
)
1630 struct cifsTconInfo
*tcon
;
1631 struct cifsFileInfo
*smbfile
= file
->private_data
;
1632 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1636 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1637 file
->f_path
.dentry
->d_name
.name
, datasync
);
1639 rc
= filemap_write_and_wait(inode
->i_mapping
);
1641 rc
= CIFS_I(inode
)->write_behind_rc
;
1642 CIFS_I(inode
)->write_behind_rc
= 0;
1643 tcon
= tlink_tcon(smbfile
->tlink
);
1644 if (!rc
&& tcon
&& smbfile
&&
1645 !(CIFS_SB(inode
->i_sb
)->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
))
1646 rc
= CIFSSMBFlush(xid
, tcon
, smbfile
->netfid
);
1653 /* static void cifs_sync_page(struct page *page)
1655 struct address_space *mapping;
1656 struct inode *inode;
1657 unsigned long index = page->index;
1658 unsigned int rpages = 0;
1661 cFYI(1, "sync page %p", page);
1662 mapping = page->mapping;
1665 inode = mapping->host;
1669 /* fill in rpages then
1670 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1672 /* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
1682 * As file closes, flush all cached write data for this inode checking
1683 * for write behind errors.
1685 int cifs_flush(struct file
*file
, fl_owner_t id
)
1687 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1690 /* Rather than do the steps manually:
1691 lock the inode for writing
1692 loop through pages looking for write behind data (dirty pages)
1693 coalesce into contiguous 16K (or smaller) chunks to write to server
1694 send to server (prefer in parallel)
1695 deal with writebehind errors
1696 unlock inode for writing
1697 filemapfdatawrite appears easier for the time being */
1699 rc
= filemap_fdatawrite(inode
->i_mapping
);
1700 /* reset wb rc if we were able to write out dirty pages */
1702 rc
= CIFS_I(inode
)->write_behind_rc
;
1703 CIFS_I(inode
)->write_behind_rc
= 0;
1706 cFYI(1, "Flush inode %p file %p rc %d", inode
, file
, rc
);
1711 ssize_t
cifs_user_read(struct file
*file
, char __user
*read_data
,
1712 size_t read_size
, loff_t
*poffset
)
1715 unsigned int bytes_read
= 0;
1716 unsigned int total_read
= 0;
1717 unsigned int current_read_size
;
1718 struct cifs_sb_info
*cifs_sb
;
1719 struct cifsTconInfo
*pTcon
;
1721 struct cifsFileInfo
*open_file
;
1722 char *smb_read_data
;
1723 char __user
*current_offset
;
1724 struct smb_com_read_rsp
*pSMBr
;
1727 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1729 if (file
->private_data
== NULL
) {
1734 open_file
= file
->private_data
;
1735 pTcon
= tlink_tcon(open_file
->tlink
);
1737 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1738 cFYI(1, "attempting read on write only file instance");
1740 for (total_read
= 0, current_offset
= read_data
;
1741 read_size
> total_read
;
1742 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1743 current_read_size
= min_t(const int, read_size
- total_read
,
1746 smb_read_data
= NULL
;
1747 while (rc
== -EAGAIN
) {
1748 int buf_type
= CIFS_NO_BUFFER
;
1749 if (open_file
->invalidHandle
) {
1750 rc
= cifs_reopen_file(open_file
, true);
1754 rc
= CIFSSMBRead(xid
, pTcon
,
1756 current_read_size
, *poffset
,
1757 &bytes_read
, &smb_read_data
,
1759 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
1760 if (smb_read_data
) {
1761 if (copy_to_user(current_offset
,
1763 4 /* RFC1001 length field */ +
1764 le16_to_cpu(pSMBr
->DataOffset
),
1768 if (buf_type
== CIFS_SMALL_BUFFER
)
1769 cifs_small_buf_release(smb_read_data
);
1770 else if (buf_type
== CIFS_LARGE_BUFFER
)
1771 cifs_buf_release(smb_read_data
);
1772 smb_read_data
= NULL
;
1775 if (rc
|| (bytes_read
== 0)) {
1783 cifs_stats_bytes_read(pTcon
, bytes_read
);
1784 *poffset
+= bytes_read
;
1792 static ssize_t
cifs_read(struct file
*file
, char *read_data
, size_t read_size
,
1796 unsigned int bytes_read
= 0;
1797 unsigned int total_read
;
1798 unsigned int current_read_size
;
1799 struct cifs_sb_info
*cifs_sb
;
1800 struct cifsTconInfo
*pTcon
;
1802 char *current_offset
;
1803 struct cifsFileInfo
*open_file
;
1804 int buf_type
= CIFS_NO_BUFFER
;
1807 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1809 if (file
->private_data
== NULL
) {
1814 open_file
= file
->private_data
;
1815 pTcon
= tlink_tcon(open_file
->tlink
);
1817 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1818 cFYI(1, "attempting read on write only file instance");
1820 for (total_read
= 0, current_offset
= read_data
;
1821 read_size
> total_read
;
1822 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1823 current_read_size
= min_t(const int, read_size
- total_read
,
1825 /* For windows me and 9x we do not want to request more
1826 than it negotiated since it will refuse the read then */
1828 !(pTcon
->ses
->capabilities
& CAP_LARGE_FILES
)) {
1829 current_read_size
= min_t(const int, current_read_size
,
1830 pTcon
->ses
->server
->maxBuf
- 128);
1833 while (rc
== -EAGAIN
) {
1834 if (open_file
->invalidHandle
) {
1835 rc
= cifs_reopen_file(open_file
, true);
1839 rc
= CIFSSMBRead(xid
, pTcon
,
1841 current_read_size
, *poffset
,
1842 &bytes_read
, ¤t_offset
,
1845 if (rc
|| (bytes_read
== 0)) {
1853 cifs_stats_bytes_read(pTcon
, total_read
);
1854 *poffset
+= bytes_read
;
1861 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1866 rc
= cifs_revalidate_file(file
);
1868 cFYI(1, "Validation prior to mmap failed, error=%d", rc
);
1872 rc
= generic_file_mmap(file
, vma
);
1878 static void cifs_copy_cache_pages(struct address_space
*mapping
,
1879 struct list_head
*pages
, int bytes_read
, char *data
)
1884 while (bytes_read
> 0) {
1885 if (list_empty(pages
))
1888 page
= list_entry(pages
->prev
, struct page
, lru
);
1889 list_del(&page
->lru
);
1891 if (add_to_page_cache_lru(page
, mapping
, page
->index
,
1893 page_cache_release(page
);
1894 cFYI(1, "Add page cache failed");
1895 data
+= PAGE_CACHE_SIZE
;
1896 bytes_read
-= PAGE_CACHE_SIZE
;
1899 page_cache_release(page
);
1901 target
= kmap_atomic(page
, KM_USER0
);
1903 if (PAGE_CACHE_SIZE
> bytes_read
) {
1904 memcpy(target
, data
, bytes_read
);
1905 /* zero the tail end of this partial page */
1906 memset(target
+ bytes_read
, 0,
1907 PAGE_CACHE_SIZE
- bytes_read
);
1910 memcpy(target
, data
, PAGE_CACHE_SIZE
);
1911 bytes_read
-= PAGE_CACHE_SIZE
;
1913 kunmap_atomic(target
, KM_USER0
);
1915 flush_dcache_page(page
);
1916 SetPageUptodate(page
);
1918 data
+= PAGE_CACHE_SIZE
;
1920 /* add page to FS-Cache */
1921 cifs_readpage_to_fscache(mapping
->host
, page
);
1926 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
1927 struct list_head
*page_list
, unsigned num_pages
)
1933 struct cifs_sb_info
*cifs_sb
;
1934 struct cifsTconInfo
*pTcon
;
1935 unsigned int bytes_read
= 0;
1936 unsigned int read_size
, i
;
1937 char *smb_read_data
= NULL
;
1938 struct smb_com_read_rsp
*pSMBr
;
1939 struct cifsFileInfo
*open_file
;
1940 int buf_type
= CIFS_NO_BUFFER
;
1943 if (file
->private_data
== NULL
) {
1948 open_file
= file
->private_data
;
1949 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1950 pTcon
= tlink_tcon(open_file
->tlink
);
1953 * Reads as many pages as possible from fscache. Returns -ENOBUFS
1954 * immediately if the cookie is negative
1956 rc
= cifs_readpages_from_fscache(mapping
->host
, mapping
, page_list
,
1961 cFYI(DBG2
, "rpages: num pages %d", num_pages
);
1962 for (i
= 0; i
< num_pages
; ) {
1963 unsigned contig_pages
;
1964 struct page
*tmp_page
;
1965 unsigned long expected_index
;
1967 if (list_empty(page_list
))
1970 page
= list_entry(page_list
->prev
, struct page
, lru
);
1971 offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1973 /* count adjacent pages that we will read into */
1976 list_entry(page_list
->prev
, struct page
, lru
)->index
;
1977 list_for_each_entry_reverse(tmp_page
, page_list
, lru
) {
1978 if (tmp_page
->index
== expected_index
) {
1984 if (contig_pages
+ i
> num_pages
)
1985 contig_pages
= num_pages
- i
;
1987 /* for reads over a certain size could initiate async
1990 read_size
= contig_pages
* PAGE_CACHE_SIZE
;
1991 /* Read size needs to be in multiples of one page */
1992 read_size
= min_t(const unsigned int, read_size
,
1993 cifs_sb
->rsize
& PAGE_CACHE_MASK
);
1994 cFYI(DBG2
, "rpages: read size 0x%x contiguous pages %d",
1995 read_size
, contig_pages
);
1997 while (rc
== -EAGAIN
) {
1998 if (open_file
->invalidHandle
) {
1999 rc
= cifs_reopen_file(open_file
, true);
2004 rc
= CIFSSMBRead(xid
, pTcon
,
2007 &bytes_read
, &smb_read_data
,
2009 /* BB more RC checks ? */
2010 if (rc
== -EAGAIN
) {
2011 if (smb_read_data
) {
2012 if (buf_type
== CIFS_SMALL_BUFFER
)
2013 cifs_small_buf_release(smb_read_data
);
2014 else if (buf_type
== CIFS_LARGE_BUFFER
)
2015 cifs_buf_release(smb_read_data
);
2016 smb_read_data
= NULL
;
2020 if ((rc
< 0) || (smb_read_data
== NULL
)) {
2021 cFYI(1, "Read error in readpages: %d", rc
);
2023 } else if (bytes_read
> 0) {
2024 task_io_account_read(bytes_read
);
2025 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
2026 cifs_copy_cache_pages(mapping
, page_list
, bytes_read
,
2027 smb_read_data
+ 4 /* RFC1001 hdr */ +
2028 le16_to_cpu(pSMBr
->DataOffset
));
2030 i
+= bytes_read
>> PAGE_CACHE_SHIFT
;
2031 cifs_stats_bytes_read(pTcon
, bytes_read
);
2032 if ((bytes_read
& PAGE_CACHE_MASK
) != bytes_read
) {
2033 i
++; /* account for partial page */
2035 /* server copy of file can have smaller size
2037 /* BB do we need to verify this common case ?
2038 this case is ok - if we are at server EOF
2039 we will hit it on next read */
2044 cFYI(1, "No bytes read (%d) at offset %lld . "
2045 "Cleaning remaining pages from readahead list",
2046 bytes_read
, offset
);
2047 /* BB turn off caching and do new lookup on
2048 file size at server? */
2051 if (smb_read_data
) {
2052 if (buf_type
== CIFS_SMALL_BUFFER
)
2053 cifs_small_buf_release(smb_read_data
);
2054 else if (buf_type
== CIFS_LARGE_BUFFER
)
2055 cifs_buf_release(smb_read_data
);
2056 smb_read_data
= NULL
;
2061 /* need to free smb_read_data buf before exit */
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
;
2075 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
2081 /* Is the page cached? */
2082 rc
= cifs_readpage_from_fscache(file
->f_path
.dentry
->d_inode
, page
);
2086 page_cache_get(page
);
2087 read_data
= kmap(page
);
2088 /* for reads over a certain size could initiate async read ahead */
2090 rc
= cifs_read(file
, read_data
, PAGE_CACHE_SIZE
, poffset
);
2095 cFYI(1, "Bytes read %d", rc
);
2097 file
->f_path
.dentry
->d_inode
->i_atime
=
2098 current_fs_time(file
->f_path
.dentry
->d_inode
->i_sb
);
2100 if (PAGE_CACHE_SIZE
> rc
)
2101 memset(read_data
+ rc
, 0, PAGE_CACHE_SIZE
- rc
);
2103 flush_dcache_page(page
);
2104 SetPageUptodate(page
);
2106 /* send this page to the cache */
2107 cifs_readpage_to_fscache(file
->f_path
.dentry
->d_inode
, page
);
2113 page_cache_release(page
);
2119 static int cifs_readpage(struct file
*file
, struct page
*page
)
2121 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
2127 if (file
->private_data
== NULL
) {
2133 cFYI(1, "readpage %p at offset %d 0x%x\n",
2134 page
, (int)offset
, (int)offset
);
2136 rc
= cifs_readpage_worker(file
, page
, &offset
);
2144 static int is_inode_writable(struct cifsInodeInfo
*cifs_inode
)
2146 struct cifsFileInfo
*open_file
;
2148 spin_lock(&cifs_file_list_lock
);
2149 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
2150 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
2151 spin_unlock(&cifs_file_list_lock
);
2155 spin_unlock(&cifs_file_list_lock
);
2159 /* We do not want to update the file size from server for inodes
2160 open for write - to avoid races with writepage extending
2161 the file - in the future we could consider allowing
2162 refreshing the inode only on increases in the file size
2163 but this is tricky to do without racing with writebehind
2164 page caching in the current Linux kernel design */
2165 bool is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
, __u64 end_of_file
)
2170 if (is_inode_writable(cifsInode
)) {
2171 /* This inode is open for write at least once */
2172 struct cifs_sb_info
*cifs_sb
;
2174 cifs_sb
= CIFS_SB(cifsInode
->vfs_inode
.i_sb
);
2175 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
2176 /* since no page cache to corrupt on directio
2177 we can change size safely */
2181 if (i_size_read(&cifsInode
->vfs_inode
) < end_of_file
)
2189 static int cifs_write_begin(struct file
*file
, struct address_space
*mapping
,
2190 loff_t pos
, unsigned len
, unsigned flags
,
2191 struct page
**pagep
, void **fsdata
)
2193 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
2194 loff_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
2195 loff_t page_start
= pos
& PAGE_MASK
;
2200 cFYI(1, "write_begin from %lld len %d", (long long)pos
, len
);
2202 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
2208 if (PageUptodate(page
))
2212 * If we write a full page it will be up to date, no need to read from
2213 * the server. If the write is short, we'll end up doing a sync write
2216 if (len
== PAGE_CACHE_SIZE
)
2220 * optimize away the read when we have an oplock, and we're not
2221 * expecting to use any of the data we'd be reading in. That
2222 * is, when the page lies beyond the EOF, or straddles the EOF
2223 * and the write will cover all of the existing data.
2225 if (CIFS_I(mapping
->host
)->clientCanCacheRead
) {
2226 i_size
= i_size_read(mapping
->host
);
2227 if (page_start
>= i_size
||
2228 (offset
== 0 && (pos
+ len
) >= i_size
)) {
2229 zero_user_segments(page
, 0, offset
,
2233 * PageChecked means that the parts of the page
2234 * to which we're not writing are considered up
2235 * to date. Once the data is copied to the
2236 * page, it can be set uptodate.
2238 SetPageChecked(page
);
2243 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
) {
2245 * might as well read a page, it is fast enough. If we get
2246 * an error, we don't need to return it. cifs_write_end will
2247 * do a sync write instead since PG_uptodate isn't set.
2249 cifs_readpage_worker(file
, page
, &page_start
);
2251 /* we could try using another file handle if there is one -
2252 but how would we lock it to prevent close of that handle
2253 racing with this read? In any case
2254 this will be written out by write_end so is fine */
2261 static int cifs_release_page(struct page
*page
, gfp_t gfp
)
2263 if (PagePrivate(page
))
2266 return cifs_fscache_release_page(page
, gfp
);
2269 static void cifs_invalidate_page(struct page
*page
, unsigned long offset
)
2271 struct cifsInodeInfo
*cifsi
= CIFS_I(page
->mapping
->host
);
2274 cifs_fscache_invalidate_page(page
, &cifsi
->vfs_inode
);
2277 void cifs_oplock_break(struct work_struct
*work
)
2279 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2281 struct inode
*inode
= cfile
->dentry
->d_inode
;
2282 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2285 if (inode
&& S_ISREG(inode
->i_mode
)) {
2286 if (cinode
->clientCanCacheRead
)
2287 break_lease(inode
, O_RDONLY
);
2289 break_lease(inode
, O_WRONLY
);
2290 rc
= filemap_fdatawrite(inode
->i_mapping
);
2291 if (cinode
->clientCanCacheRead
== 0) {
2292 waitrc
= filemap_fdatawait(inode
->i_mapping
);
2293 invalidate_remote_inode(inode
);
2298 cinode
->write_behind_rc
= rc
;
2299 cFYI(1, "Oplock flush inode %p rc %d", inode
, rc
);
2303 * releasing stale oplock after recent reconnect of smb session using
2304 * a now incorrect file handle is not a data integrity issue but do
2305 * not bother sending an oplock release if session to server still is
2306 * disconnected since oplock already released by the server
2308 if (!cfile
->oplock_break_cancelled
) {
2309 rc
= CIFSSMBLock(0, tlink_tcon(cfile
->tlink
), cfile
->netfid
, 0,
2310 0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE
, false);
2311 cFYI(1, "Oplock release rc = %d", rc
);
2315 * We might have kicked in before is_valid_oplock_break()
2316 * finished grabbing reference for us. Make sure it's done by
2317 * waiting for GlobalSMSSeslock.
2319 spin_lock(&cifs_file_list_lock
);
2320 spin_unlock(&cifs_file_list_lock
);
2322 cifs_oplock_break_put(cfile
);
2325 void cifs_oplock_break_get(struct cifsFileInfo
*cfile
)
2327 cifs_sb_active(cfile
->dentry
->d_sb
);
2328 cifsFileInfo_get(cfile
);
2331 void cifs_oplock_break_put(struct cifsFileInfo
*cfile
)
2333 cifsFileInfo_put(cfile
);
2334 cifs_sb_deactive(cfile
->dentry
->d_sb
);
2337 const struct address_space_operations cifs_addr_ops
= {
2338 .readpage
= cifs_readpage
,
2339 .readpages
= cifs_readpages
,
2340 .writepage
= cifs_writepage
,
2341 .writepages
= cifs_writepages
,
2342 .write_begin
= cifs_write_begin
,
2343 .write_end
= cifs_write_end
,
2344 .set_page_dirty
= __set_page_dirty_nobuffers
,
2345 .releasepage
= cifs_release_page
,
2346 .invalidatepage
= cifs_invalidate_page
,
2347 /* .sync_page = cifs_sync_page, */
2352 * cifs_readpages requires the server to support a buffer large enough to
2353 * contain the header plus one complete page of data. Otherwise, we need
2354 * to leave cifs_readpages out of the address space operations.
2356 const struct address_space_operations cifs_addr_ops_smallbuf
= {
2357 .readpage
= cifs_readpage
,
2358 .writepage
= cifs_writepage
,
2359 .writepages
= cifs_writepages
,
2360 .write_begin
= cifs_write_begin
,
2361 .write_end
= cifs_write_end
,
2362 .set_page_dirty
= __set_page_dirty_nobuffers
,
2363 .releasepage
= cifs_release_page
,
2364 .invalidatepage
= cifs_invalidate_page
,
2365 /* .sync_page = cifs_sync_page, */