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 <linux/swap.h>
36 #include <asm/div64.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
46 static inline int cifs_convert_flags(unsigned int flags
)
48 if ((flags
& O_ACCMODE
) == O_RDONLY
)
50 else if ((flags
& O_ACCMODE
) == O_WRONLY
)
52 else if ((flags
& O_ACCMODE
) == O_RDWR
) {
53 /* GENERIC_ALL is too much permission to request
54 can cause unnecessary access denied on create */
55 /* return GENERIC_ALL; */
56 return (GENERIC_READ
| GENERIC_WRITE
);
59 return (READ_CONTROL
| FILE_WRITE_ATTRIBUTES
| FILE_READ_ATTRIBUTES
|
60 FILE_WRITE_EA
| FILE_APPEND_DATA
| FILE_WRITE_DATA
|
64 static u32
cifs_posix_convert_flags(unsigned int flags
)
68 if ((flags
& O_ACCMODE
) == O_RDONLY
)
69 posix_flags
= SMB_O_RDONLY
;
70 else if ((flags
& O_ACCMODE
) == O_WRONLY
)
71 posix_flags
= SMB_O_WRONLY
;
72 else if ((flags
& O_ACCMODE
) == O_RDWR
)
73 posix_flags
= SMB_O_RDWR
;
76 posix_flags
|= SMB_O_CREAT
;
78 posix_flags
|= SMB_O_EXCL
;
80 posix_flags
|= SMB_O_TRUNC
;
81 /* be safe and imply O_SYNC for O_DSYNC */
83 posix_flags
|= SMB_O_SYNC
;
84 if (flags
& O_DIRECTORY
)
85 posix_flags
|= SMB_O_DIRECTORY
;
86 if (flags
& O_NOFOLLOW
)
87 posix_flags
|= SMB_O_NOFOLLOW
;
89 posix_flags
|= SMB_O_DIRECT
;
94 static inline int cifs_get_disposition(unsigned int flags
)
96 if ((flags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
98 else if ((flags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
99 return FILE_OVERWRITE_IF
;
100 else if ((flags
& O_CREAT
) == O_CREAT
)
102 else if ((flags
& O_TRUNC
) == O_TRUNC
)
103 return FILE_OVERWRITE
;
108 int cifs_posix_open(char *full_path
, struct inode
**pinode
,
109 struct super_block
*sb
, int mode
, unsigned int f_flags
,
110 __u32
*poplock
, __u16
*pnetfid
, unsigned int xid
)
113 FILE_UNIX_BASIC_INFO
*presp_data
;
114 __u32 posix_flags
= 0;
115 struct cifs_sb_info
*cifs_sb
= CIFS_SB(sb
);
116 struct cifs_fattr fattr
;
117 struct tcon_link
*tlink
;
118 struct cifs_tcon
*tcon
;
120 cFYI(1, "posix open %s", full_path
);
122 presp_data
= kzalloc(sizeof(FILE_UNIX_BASIC_INFO
), GFP_KERNEL
);
123 if (presp_data
== NULL
)
126 tlink
= cifs_sb_tlink(cifs_sb
);
132 tcon
= tlink_tcon(tlink
);
133 mode
&= ~current_umask();
135 posix_flags
= cifs_posix_convert_flags(f_flags
);
136 rc
= CIFSPOSIXCreate(xid
, tcon
, posix_flags
, mode
, pnetfid
, presp_data
,
137 poplock
, full_path
, cifs_sb
->local_nls
,
138 cifs_sb
->mnt_cifs_flags
&
139 CIFS_MOUNT_MAP_SPECIAL_CHR
);
140 cifs_put_tlink(tlink
);
145 if (presp_data
->Type
== cpu_to_le32(-1))
146 goto posix_open_ret
; /* open ok, caller does qpathinfo */
149 goto posix_open_ret
; /* caller does not need info */
151 cifs_unix_basic_to_fattr(&fattr
, presp_data
, cifs_sb
);
153 /* get new inode and set it up */
154 if (*pinode
== NULL
) {
155 cifs_fill_uniqueid(sb
, &fattr
);
156 *pinode
= cifs_iget(sb
, &fattr
);
162 cifs_fattr_to_inode(*pinode
, &fattr
);
171 cifs_nt_open(char *full_path
, struct inode
*inode
, struct cifs_sb_info
*cifs_sb
,
172 struct cifs_tcon
*tcon
, unsigned int f_flags
, __u32
*poplock
,
173 __u16
*pnetfid
, unsigned int xid
)
178 int create_options
= CREATE_NOT_DIR
;
181 desiredAccess
= cifs_convert_flags(f_flags
);
183 /*********************************************************************
184 * open flag mapping table:
186 * POSIX Flag CIFS Disposition
187 * ---------- ----------------
188 * O_CREAT FILE_OPEN_IF
189 * O_CREAT | O_EXCL FILE_CREATE
190 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
191 * O_TRUNC FILE_OVERWRITE
192 * none of the above FILE_OPEN
194 * Note that there is not a direct match between disposition
195 * FILE_SUPERSEDE (ie create whether or not file exists although
196 * O_CREAT | O_TRUNC is similar but truncates the existing
197 * file rather than creating a new file as FILE_SUPERSEDE does
198 * (which uses the attributes / metadata passed in on open call)
200 *? O_SYNC is a reasonable match to CIFS writethrough flag
201 *? and the read write flags match reasonably. O_LARGEFILE
202 *? is irrelevant because largefile support is always used
203 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
204 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
205 *********************************************************************/
207 disposition
= cifs_get_disposition(f_flags
);
209 /* BB pass O_SYNC flag through on file attributes .. BB */
211 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
215 if (backup_cred(cifs_sb
))
216 create_options
|= CREATE_OPEN_BACKUP_INTENT
;
218 if (tcon
->ses
->capabilities
& CAP_NT_SMBS
)
219 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
220 desiredAccess
, create_options
, pnetfid
, poplock
, buf
,
221 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
222 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
224 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
225 desiredAccess
, CREATE_NOT_DIR
, pnetfid
, poplock
, buf
,
226 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
227 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
233 rc
= cifs_get_inode_info_unix(&inode
, full_path
, inode
->i_sb
,
236 rc
= cifs_get_inode_info(&inode
, full_path
, buf
, inode
->i_sb
,
244 struct cifsFileInfo
*
245 cifs_new_fileinfo(__u16 fileHandle
, struct file
*file
,
246 struct tcon_link
*tlink
, __u32 oplock
)
248 struct dentry
*dentry
= file
->f_path
.dentry
;
249 struct inode
*inode
= dentry
->d_inode
;
250 struct cifsInodeInfo
*pCifsInode
= CIFS_I(inode
);
251 struct cifsFileInfo
*pCifsFile
;
253 pCifsFile
= kzalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
254 if (pCifsFile
== NULL
)
257 pCifsFile
->count
= 1;
258 pCifsFile
->netfid
= fileHandle
;
259 pCifsFile
->pid
= current
->tgid
;
260 pCifsFile
->uid
= current_fsuid();
261 pCifsFile
->dentry
= dget(dentry
);
262 pCifsFile
->f_flags
= file
->f_flags
;
263 pCifsFile
->invalidHandle
= false;
264 pCifsFile
->tlink
= cifs_get_tlink(tlink
);
265 mutex_init(&pCifsFile
->fh_mutex
);
266 INIT_WORK(&pCifsFile
->oplock_break
, cifs_oplock_break
);
267 INIT_LIST_HEAD(&pCifsFile
->llist
);
269 spin_lock(&cifs_file_list_lock
);
270 list_add(&pCifsFile
->tlist
, &(tlink_tcon(tlink
)->openFileList
));
271 /* if readable file instance put first in list*/
272 if (file
->f_mode
& FMODE_READ
)
273 list_add(&pCifsFile
->flist
, &pCifsInode
->openFileList
);
275 list_add_tail(&pCifsFile
->flist
, &pCifsInode
->openFileList
);
276 spin_unlock(&cifs_file_list_lock
);
278 cifs_set_oplock_level(pCifsInode
, oplock
);
279 pCifsInode
->can_cache_brlcks
= pCifsInode
->clientCanCacheAll
;
281 file
->private_data
= pCifsFile
;
285 static void cifs_del_lock_waiters(struct cifsLockInfo
*lock
);
288 * Release a reference on the file private data. This may involve closing
289 * the filehandle out on the server. Must be called without holding
290 * cifs_file_list_lock.
292 void cifsFileInfo_put(struct cifsFileInfo
*cifs_file
)
294 struct inode
*inode
= cifs_file
->dentry
->d_inode
;
295 struct cifs_tcon
*tcon
= tlink_tcon(cifs_file
->tlink
);
296 struct cifsInodeInfo
*cifsi
= CIFS_I(inode
);
297 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
298 struct cifsLockInfo
*li
, *tmp
;
300 spin_lock(&cifs_file_list_lock
);
301 if (--cifs_file
->count
> 0) {
302 spin_unlock(&cifs_file_list_lock
);
306 /* remove it from the lists */
307 list_del(&cifs_file
->flist
);
308 list_del(&cifs_file
->tlist
);
310 if (list_empty(&cifsi
->openFileList
)) {
311 cFYI(1, "closing last open instance for inode %p",
312 cifs_file
->dentry
->d_inode
);
314 /* in strict cache mode we need invalidate mapping on the last
315 close because it may cause a error when we open this file
316 again and get at least level II oplock */
317 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_STRICT_IO
)
318 CIFS_I(inode
)->invalid_mapping
= true;
320 cifs_set_oplock_level(cifsi
, 0);
322 spin_unlock(&cifs_file_list_lock
);
324 cancel_work_sync(&cifs_file
->oplock_break
);
326 if (!tcon
->need_reconnect
&& !cifs_file
->invalidHandle
) {
330 rc
= CIFSSMBClose(xid
, tcon
, cifs_file
->netfid
);
334 /* Delete any outstanding lock records. We'll lose them when the file
337 mutex_lock(&cifsi
->lock_mutex
);
338 list_for_each_entry_safe(li
, tmp
, &cifs_file
->llist
, llist
) {
339 list_del(&li
->llist
);
340 cifs_del_lock_waiters(li
);
343 mutex_unlock(&cifsi
->lock_mutex
);
345 cifs_put_tlink(cifs_file
->tlink
);
346 dput(cifs_file
->dentry
);
350 int cifs_open(struct inode
*inode
, struct file
*file
)
355 struct cifs_sb_info
*cifs_sb
;
356 struct cifs_tcon
*tcon
;
357 struct tcon_link
*tlink
;
358 struct cifsFileInfo
*pCifsFile
= NULL
;
359 char *full_path
= NULL
;
360 bool posix_open_ok
= false;
365 cifs_sb
= CIFS_SB(inode
->i_sb
);
366 tlink
= cifs_sb_tlink(cifs_sb
);
369 return PTR_ERR(tlink
);
371 tcon
= tlink_tcon(tlink
);
373 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
374 if (full_path
== NULL
) {
379 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
380 inode
, file
->f_flags
, full_path
);
382 if (tcon
->ses
->server
->oplocks
)
387 if (!tcon
->broken_posix_open
&& tcon
->unix_ext
&&
388 (tcon
->ses
->capabilities
& CAP_UNIX
) &&
389 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
390 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
391 /* can not refresh inode info since size could be stale */
392 rc
= cifs_posix_open(full_path
, &inode
, inode
->i_sb
,
393 cifs_sb
->mnt_file_mode
/* ignored */,
394 file
->f_flags
, &oplock
, &netfid
, xid
);
396 cFYI(1, "posix open succeeded");
397 posix_open_ok
= true;
398 } else if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
399 if (tcon
->ses
->serverNOS
)
400 cERROR(1, "server %s of type %s returned"
401 " unexpected error on SMB posix open"
402 ", disabling posix open support."
403 " Check if server update available.",
404 tcon
->ses
->serverName
,
405 tcon
->ses
->serverNOS
);
406 tcon
->broken_posix_open
= true;
407 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
408 (rc
!= -EOPNOTSUPP
)) /* path not found or net err */
410 /* else fallthrough to retry open the old way on network i/o
414 if (!posix_open_ok
) {
415 rc
= cifs_nt_open(full_path
, inode
, cifs_sb
, tcon
,
416 file
->f_flags
, &oplock
, &netfid
, xid
);
421 pCifsFile
= cifs_new_fileinfo(netfid
, file
, tlink
, oplock
);
422 if (pCifsFile
== NULL
) {
423 CIFSSMBClose(xid
, tcon
, netfid
);
428 cifs_fscache_set_inode_cookie(inode
, file
);
430 if ((oplock
& CIFS_CREATE_ACTION
) && !posix_open_ok
&& tcon
->unix_ext
) {
431 /* time to set mode which we can not set earlier due to
432 problems creating new read-only files */
433 struct cifs_unix_set_info_args args
= {
434 .mode
= inode
->i_mode
,
437 .ctime
= NO_CHANGE_64
,
438 .atime
= NO_CHANGE_64
,
439 .mtime
= NO_CHANGE_64
,
442 CIFSSMBUnixSetFileInfo(xid
, tcon
, &args
, netfid
,
449 cifs_put_tlink(tlink
);
453 /* Try to reacquire byte range locks that were released when session */
454 /* to server was lost */
455 static int cifs_relock_file(struct cifsFileInfo
*cifsFile
)
459 /* BB list all locks open on this file and relock */
464 static int cifs_reopen_file(struct cifsFileInfo
*pCifsFile
, bool can_flush
)
469 struct cifs_sb_info
*cifs_sb
;
470 struct cifs_tcon
*tcon
;
471 struct cifsInodeInfo
*pCifsInode
;
473 char *full_path
= NULL
;
475 int disposition
= FILE_OPEN
;
476 int create_options
= CREATE_NOT_DIR
;
480 mutex_lock(&pCifsFile
->fh_mutex
);
481 if (!pCifsFile
->invalidHandle
) {
482 mutex_unlock(&pCifsFile
->fh_mutex
);
488 inode
= pCifsFile
->dentry
->d_inode
;
489 cifs_sb
= CIFS_SB(inode
->i_sb
);
490 tcon
= tlink_tcon(pCifsFile
->tlink
);
492 /* can not grab rename sem here because various ops, including
493 those that already have the rename sem can end up causing writepage
494 to get called and if the server was down that means we end up here,
495 and we can never tell if the caller already has the rename_sem */
496 full_path
= build_path_from_dentry(pCifsFile
->dentry
);
497 if (full_path
== NULL
) {
499 mutex_unlock(&pCifsFile
->fh_mutex
);
504 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
505 inode
, pCifsFile
->f_flags
, full_path
);
507 if (tcon
->ses
->server
->oplocks
)
512 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
513 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
514 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
517 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
518 * original open. Must mask them off for a reopen.
520 unsigned int oflags
= pCifsFile
->f_flags
&
521 ~(O_CREAT
| O_EXCL
| O_TRUNC
);
523 rc
= cifs_posix_open(full_path
, NULL
, inode
->i_sb
,
524 cifs_sb
->mnt_file_mode
/* ignored */,
525 oflags
, &oplock
, &netfid
, xid
);
527 cFYI(1, "posix reopen succeeded");
530 /* fallthrough to retry open the old way on errors, especially
531 in the reconnect path it is important to retry hard */
534 desiredAccess
= cifs_convert_flags(pCifsFile
->f_flags
);
536 if (backup_cred(cifs_sb
))
537 create_options
|= CREATE_OPEN_BACKUP_INTENT
;
539 /* Can not refresh inode by passing in file_info buf to be returned
540 by SMBOpen and then calling get_inode_info with returned buf
541 since file might have write behind data that needs to be flushed
542 and server version of file size can be stale. If we knew for sure
543 that inode was not dirty locally we could do this */
545 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
, desiredAccess
,
546 create_options
, &netfid
, &oplock
, NULL
,
547 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
548 CIFS_MOUNT_MAP_SPECIAL_CHR
);
550 mutex_unlock(&pCifsFile
->fh_mutex
);
551 cFYI(1, "cifs_open returned 0x%x", rc
);
552 cFYI(1, "oplock: %d", oplock
);
553 goto reopen_error_exit
;
557 pCifsFile
->netfid
= netfid
;
558 pCifsFile
->invalidHandle
= false;
559 mutex_unlock(&pCifsFile
->fh_mutex
);
560 pCifsInode
= CIFS_I(inode
);
563 rc
= filemap_write_and_wait(inode
->i_mapping
);
564 mapping_set_error(inode
->i_mapping
, rc
);
567 rc
= cifs_get_inode_info_unix(&inode
,
568 full_path
, inode
->i_sb
, xid
);
570 rc
= cifs_get_inode_info(&inode
,
571 full_path
, NULL
, inode
->i_sb
,
573 } /* else we are writing out data to server already
574 and could deadlock if we tried to flush data, and
575 since we do not know if we have data that would
576 invalidate the current end of file on the server
577 we can not go to the server to get the new inod
580 cifs_set_oplock_level(pCifsInode
, oplock
);
582 cifs_relock_file(pCifsFile
);
590 int cifs_close(struct inode
*inode
, struct file
*file
)
592 if (file
->private_data
!= NULL
) {
593 cifsFileInfo_put(file
->private_data
);
594 file
->private_data
= NULL
;
597 /* return code from the ->release op is always ignored */
601 int cifs_closedir(struct inode
*inode
, struct file
*file
)
605 struct cifsFileInfo
*pCFileStruct
= file
->private_data
;
608 cFYI(1, "Closedir inode = 0x%p", inode
);
613 struct cifs_tcon
*pTcon
= tlink_tcon(pCFileStruct
->tlink
);
615 cFYI(1, "Freeing private data in close dir");
616 spin_lock(&cifs_file_list_lock
);
617 if (!pCFileStruct
->srch_inf
.endOfSearch
&&
618 !pCFileStruct
->invalidHandle
) {
619 pCFileStruct
->invalidHandle
= true;
620 spin_unlock(&cifs_file_list_lock
);
621 rc
= CIFSFindClose(xid
, pTcon
, pCFileStruct
->netfid
);
622 cFYI(1, "Closing uncompleted readdir with rc %d",
624 /* not much we can do if it fails anyway, ignore rc */
627 spin_unlock(&cifs_file_list_lock
);
628 ptmp
= pCFileStruct
->srch_inf
.ntwrk_buf_start
;
630 cFYI(1, "closedir free smb buf in srch struct");
631 pCFileStruct
->srch_inf
.ntwrk_buf_start
= NULL
;
632 if (pCFileStruct
->srch_inf
.smallBuf
)
633 cifs_small_buf_release(ptmp
);
635 cifs_buf_release(ptmp
);
637 cifs_put_tlink(pCFileStruct
->tlink
);
638 kfree(file
->private_data
);
639 file
->private_data
= NULL
;
641 /* BB can we lock the filestruct while this is going on? */
646 static struct cifsLockInfo
*
647 cifs_lock_init(__u64 offset
, __u64 length
, __u8 type
)
649 struct cifsLockInfo
*lock
=
650 kmalloc(sizeof(struct cifsLockInfo
), GFP_KERNEL
);
653 lock
->offset
= offset
;
654 lock
->length
= length
;
656 lock
->pid
= current
->tgid
;
657 INIT_LIST_HEAD(&lock
->blist
);
658 init_waitqueue_head(&lock
->block_q
);
663 cifs_del_lock_waiters(struct cifsLockInfo
*lock
)
665 struct cifsLockInfo
*li
, *tmp
;
666 list_for_each_entry_safe(li
, tmp
, &lock
->blist
, blist
) {
667 list_del_init(&li
->blist
);
668 wake_up(&li
->block_q
);
673 cifs_find_fid_lock_conflict(struct cifsFileInfo
*cfile
, __u64 offset
,
674 __u64 length
, __u8 type
, struct cifsFileInfo
*cur
,
675 struct cifsLockInfo
**conf_lock
)
677 struct cifsLockInfo
*li
;
678 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
680 list_for_each_entry(li
, &cfile
->llist
, llist
) {
681 if (offset
+ length
<= li
->offset
||
682 offset
>= li
->offset
+ li
->length
)
684 else if ((type
& server
->vals
->shared_lock_type
) &&
685 ((server
->ops
->compare_fids(cur
, cfile
) &&
686 current
->tgid
== li
->pid
) || type
== li
->type
))
697 cifs_find_lock_conflict(struct cifsFileInfo
*cfile
, __u64 offset
, __u64 length
,
698 __u8 type
, struct cifsLockInfo
**conf_lock
)
701 struct cifsFileInfo
*fid
, *tmp
;
702 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
704 spin_lock(&cifs_file_list_lock
);
705 list_for_each_entry_safe(fid
, tmp
, &cinode
->openFileList
, flist
) {
706 rc
= cifs_find_fid_lock_conflict(fid
, offset
, length
, type
,
711 spin_unlock(&cifs_file_list_lock
);
717 * Check if there is another lock that prevents us to set the lock (mandatory
718 * style). If such a lock exists, update the flock structure with its
719 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
720 * or leave it the same if we can't. Returns 0 if we don't need to request to
721 * the server or 1 otherwise.
724 cifs_lock_test(struct cifsFileInfo
*cfile
, __u64 offset
, __u64 length
,
725 __u8 type
, struct file_lock
*flock
)
728 struct cifsLockInfo
*conf_lock
;
729 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
730 struct TCP_Server_Info
*server
= tlink_tcon(cfile
->tlink
)->ses
->server
;
733 mutex_lock(&cinode
->lock_mutex
);
735 exist
= cifs_find_lock_conflict(cfile
, offset
, length
, type
,
738 flock
->fl_start
= conf_lock
->offset
;
739 flock
->fl_end
= conf_lock
->offset
+ conf_lock
->length
- 1;
740 flock
->fl_pid
= conf_lock
->pid
;
741 if (conf_lock
->type
& server
->vals
->shared_lock_type
)
742 flock
->fl_type
= F_RDLCK
;
744 flock
->fl_type
= F_WRLCK
;
745 } else if (!cinode
->can_cache_brlcks
)
748 flock
->fl_type
= F_UNLCK
;
750 mutex_unlock(&cinode
->lock_mutex
);
755 cifs_lock_add(struct cifsFileInfo
*cfile
, struct cifsLockInfo
*lock
)
757 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
758 mutex_lock(&cinode
->lock_mutex
);
759 list_add_tail(&lock
->llist
, &cfile
->llist
);
760 mutex_unlock(&cinode
->lock_mutex
);
764 * Set the byte-range lock (mandatory style). Returns:
765 * 1) 0, if we set the lock and don't need to request to the server;
766 * 2) 1, if no locks prevent us but we need to request to the server;
767 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
770 cifs_lock_add_if(struct cifsFileInfo
*cfile
, struct cifsLockInfo
*lock
,
773 struct cifsLockInfo
*conf_lock
;
774 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
780 mutex_lock(&cinode
->lock_mutex
);
782 exist
= cifs_find_lock_conflict(cfile
, lock
->offset
, lock
->length
,
783 lock
->type
, &conf_lock
);
784 if (!exist
&& cinode
->can_cache_brlcks
) {
785 list_add_tail(&lock
->llist
, &cfile
->llist
);
786 mutex_unlock(&cinode
->lock_mutex
);
795 list_add_tail(&lock
->blist
, &conf_lock
->blist
);
796 mutex_unlock(&cinode
->lock_mutex
);
797 rc
= wait_event_interruptible(lock
->block_q
,
798 (lock
->blist
.prev
== &lock
->blist
) &&
799 (lock
->blist
.next
== &lock
->blist
));
802 mutex_lock(&cinode
->lock_mutex
);
803 list_del_init(&lock
->blist
);
806 mutex_unlock(&cinode
->lock_mutex
);
811 * Check if there is another lock that prevents us to set the lock (posix
812 * style). If such a lock exists, update the flock structure with its
813 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
814 * or leave it the same if we can't. Returns 0 if we don't need to request to
815 * the server or 1 otherwise.
818 cifs_posix_lock_test(struct file
*file
, struct file_lock
*flock
)
821 struct cifsInodeInfo
*cinode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
822 unsigned char saved_type
= flock
->fl_type
;
824 if ((flock
->fl_flags
& FL_POSIX
) == 0)
827 mutex_lock(&cinode
->lock_mutex
);
828 posix_test_lock(file
, flock
);
830 if (flock
->fl_type
== F_UNLCK
&& !cinode
->can_cache_brlcks
) {
831 flock
->fl_type
= saved_type
;
835 mutex_unlock(&cinode
->lock_mutex
);
840 * Set the byte-range lock (posix style). Returns:
841 * 1) 0, if we set the lock and don't need to request to the server;
842 * 2) 1, if we need to request to the server;
843 * 3) <0, if the error occurs while setting the lock.
846 cifs_posix_lock_set(struct file
*file
, struct file_lock
*flock
)
848 struct cifsInodeInfo
*cinode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
851 if ((flock
->fl_flags
& FL_POSIX
) == 0)
855 mutex_lock(&cinode
->lock_mutex
);
856 if (!cinode
->can_cache_brlcks
) {
857 mutex_unlock(&cinode
->lock_mutex
);
861 rc
= posix_lock_file(file
, flock
, NULL
);
862 mutex_unlock(&cinode
->lock_mutex
);
863 if (rc
== FILE_LOCK_DEFERRED
) {
864 rc
= wait_event_interruptible(flock
->fl_wait
, !flock
->fl_next
);
867 locks_delete_block(flock
);
873 cifs_push_mandatory_locks(struct cifsFileInfo
*cfile
)
876 int rc
= 0, stored_rc
;
877 struct cifsLockInfo
*li
, *tmp
;
878 struct cifs_tcon
*tcon
;
879 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
880 unsigned int num
, max_num
, max_buf
;
881 LOCKING_ANDX_RANGE
*buf
, *cur
;
882 int types
[] = {LOCKING_ANDX_LARGE_FILES
,
883 LOCKING_ANDX_SHARED_LOCK
| LOCKING_ANDX_LARGE_FILES
};
887 tcon
= tlink_tcon(cfile
->tlink
);
889 mutex_lock(&cinode
->lock_mutex
);
890 if (!cinode
->can_cache_brlcks
) {
891 mutex_unlock(&cinode
->lock_mutex
);
897 * Accessing maxBuf is racy with cifs_reconnect - need to store value
898 * and check it for zero before using.
900 max_buf
= tcon
->ses
->server
->maxBuf
;
902 mutex_unlock(&cinode
->lock_mutex
);
907 max_num
= (max_buf
- sizeof(struct smb_hdr
)) /
908 sizeof(LOCKING_ANDX_RANGE
);
909 buf
= kzalloc(max_num
* sizeof(LOCKING_ANDX_RANGE
), GFP_KERNEL
);
911 mutex_unlock(&cinode
->lock_mutex
);
916 for (i
= 0; i
< 2; i
++) {
919 list_for_each_entry_safe(li
, tmp
, &cfile
->llist
, llist
) {
920 if (li
->type
!= types
[i
])
922 cur
->Pid
= cpu_to_le16(li
->pid
);
923 cur
->LengthLow
= cpu_to_le32((u32
)li
->length
);
924 cur
->LengthHigh
= cpu_to_le32((u32
)(li
->length
>>32));
925 cur
->OffsetLow
= cpu_to_le32((u32
)li
->offset
);
926 cur
->OffsetHigh
= cpu_to_le32((u32
)(li
->offset
>>32));
927 if (++num
== max_num
) {
928 stored_rc
= cifs_lockv(xid
, tcon
, cfile
->netfid
,
929 (__u8
)li
->type
, 0, num
,
940 stored_rc
= cifs_lockv(xid
, tcon
, cfile
->netfid
,
941 (__u8
)types
[i
], 0, num
, buf
);
947 cinode
->can_cache_brlcks
= false;
948 mutex_unlock(&cinode
->lock_mutex
);
955 /* copied from fs/locks.c with a name change */
956 #define cifs_for_each_lock(inode, lockp) \
957 for (lockp = &inode->i_flock; *lockp != NULL; \
958 lockp = &(*lockp)->fl_next)
960 struct lock_to_push
{
961 struct list_head llist
;
970 cifs_push_posix_locks(struct cifsFileInfo
*cfile
)
972 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
973 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
974 struct file_lock
*flock
, **before
;
975 unsigned int count
= 0, i
= 0;
976 int rc
= 0, xid
, type
;
977 struct list_head locks_to_send
, *el
;
978 struct lock_to_push
*lck
, *tmp
;
983 mutex_lock(&cinode
->lock_mutex
);
984 if (!cinode
->can_cache_brlcks
) {
985 mutex_unlock(&cinode
->lock_mutex
);
991 cifs_for_each_lock(cfile
->dentry
->d_inode
, before
) {
992 if ((*before
)->fl_flags
& FL_POSIX
)
997 INIT_LIST_HEAD(&locks_to_send
);
1000 * Allocating count locks is enough because no FL_POSIX locks can be
1001 * added to the list while we are holding cinode->lock_mutex that
1002 * protects locking operations of this inode.
1004 for (; i
< count
; i
++) {
1005 lck
= kmalloc(sizeof(struct lock_to_push
), GFP_KERNEL
);
1010 list_add_tail(&lck
->llist
, &locks_to_send
);
1013 el
= locks_to_send
.next
;
1015 cifs_for_each_lock(cfile
->dentry
->d_inode
, before
) {
1017 if ((flock
->fl_flags
& FL_POSIX
) == 0)
1019 if (el
== &locks_to_send
) {
1021 * The list ended. We don't have enough allocated
1022 * structures - something is really wrong.
1024 cERROR(1, "Can't push all brlocks!");
1027 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1028 if (flock
->fl_type
== F_RDLCK
|| flock
->fl_type
== F_SHLCK
)
1032 lck
= list_entry(el
, struct lock_to_push
, llist
);
1033 lck
->pid
= flock
->fl_pid
;
1034 lck
->netfid
= cfile
->netfid
;
1035 lck
->length
= length
;
1037 lck
->offset
= flock
->fl_start
;
1042 list_for_each_entry_safe(lck
, tmp
, &locks_to_send
, llist
) {
1045 stored_rc
= CIFSSMBPosixLock(xid
, tcon
, lck
->netfid
, lck
->pid
,
1046 lck
->offset
, lck
->length
, NULL
,
1050 list_del(&lck
->llist
);
1055 cinode
->can_cache_brlcks
= false;
1056 mutex_unlock(&cinode
->lock_mutex
);
1061 list_for_each_entry_safe(lck
, tmp
, &locks_to_send
, llist
) {
1062 list_del(&lck
->llist
);
1069 cifs_push_locks(struct cifsFileInfo
*cfile
)
1071 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
1072 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1074 if ((tcon
->ses
->capabilities
& CAP_UNIX
) &&
1075 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
1076 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
1077 return cifs_push_posix_locks(cfile
);
1079 return cifs_push_mandatory_locks(cfile
);
1083 cifs_read_flock(struct file_lock
*flock
, __u32
*type
, int *lock
, int *unlock
,
1084 bool *wait_flag
, struct TCP_Server_Info
*server
)
1086 if (flock
->fl_flags
& FL_POSIX
)
1088 if (flock
->fl_flags
& FL_FLOCK
)
1090 if (flock
->fl_flags
& FL_SLEEP
) {
1091 cFYI(1, "Blocking lock");
1094 if (flock
->fl_flags
& FL_ACCESS
)
1095 cFYI(1, "Process suspended by mandatory locking - "
1096 "not implemented yet");
1097 if (flock
->fl_flags
& FL_LEASE
)
1098 cFYI(1, "Lease on file - not implemented yet");
1099 if (flock
->fl_flags
&
1100 (~(FL_POSIX
| FL_FLOCK
| FL_SLEEP
| FL_ACCESS
| FL_LEASE
)))
1101 cFYI(1, "Unknown lock flags 0x%x", flock
->fl_flags
);
1103 *type
= server
->vals
->large_lock_type
;
1104 if (flock
->fl_type
== F_WRLCK
) {
1105 cFYI(1, "F_WRLCK ");
1106 *type
|= server
->vals
->exclusive_lock_type
;
1108 } else if (flock
->fl_type
== F_UNLCK
) {
1110 *type
|= server
->vals
->unlock_lock_type
;
1112 /* Check if unlock includes more than one lock range */
1113 } else if (flock
->fl_type
== F_RDLCK
) {
1115 *type
|= server
->vals
->shared_lock_type
;
1117 } else if (flock
->fl_type
== F_EXLCK
) {
1119 *type
|= server
->vals
->exclusive_lock_type
;
1121 } else if (flock
->fl_type
== F_SHLCK
) {
1123 *type
|= server
->vals
->shared_lock_type
;
1126 cFYI(1, "Unknown type of lock");
1130 cifs_mandatory_lock(unsigned int xid
, struct cifsFileInfo
*cfile
, __u64 offset
,
1131 __u64 length
, __u32 type
, int lock
, int unlock
, bool wait
)
1133 return CIFSSMBLock(xid
, tlink_tcon(cfile
->tlink
), cfile
->netfid
,
1134 current
->tgid
, length
, offset
, unlock
, lock
,
1135 (__u8
)type
, wait
, 0);
1139 cifs_getlk(struct file
*file
, struct file_lock
*flock
, __u32 type
,
1140 bool wait_flag
, bool posix_lck
, unsigned int xid
)
1143 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1144 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
1145 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1146 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1147 __u16 netfid
= cfile
->netfid
;
1150 int posix_lock_type
;
1152 rc
= cifs_posix_lock_test(file
, flock
);
1156 if (type
& server
->vals
->shared_lock_type
)
1157 posix_lock_type
= CIFS_RDLCK
;
1159 posix_lock_type
= CIFS_WRLCK
;
1160 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, current
->tgid
,
1161 flock
->fl_start
, length
, flock
,
1162 posix_lock_type
, wait_flag
);
1166 rc
= cifs_lock_test(cfile
, flock
->fl_start
, length
, type
, flock
);
1170 /* BB we could chain these into one lock request BB */
1171 rc
= cifs_mandatory_lock(xid
, cfile
, flock
->fl_start
, length
, type
,
1174 rc
= cifs_mandatory_lock(xid
, cfile
, flock
->fl_start
, length
,
1176 flock
->fl_type
= F_UNLCK
;
1178 cERROR(1, "Error unlocking previously locked "
1179 "range %d during test of lock", rc
);
1183 if (type
& server
->vals
->shared_lock_type
) {
1184 flock
->fl_type
= F_WRLCK
;
1188 rc
= cifs_mandatory_lock(xid
, cfile
, flock
->fl_start
, length
,
1189 type
| server
->vals
->shared_lock_type
, 1, 0,
1192 rc
= cifs_mandatory_lock(xid
, cfile
, flock
->fl_start
, length
,
1193 type
| server
->vals
->shared_lock_type
,
1195 flock
->fl_type
= F_RDLCK
;
1197 cERROR(1, "Error unlocking previously locked "
1198 "range %d during test of lock", rc
);
1200 flock
->fl_type
= F_WRLCK
;
1206 cifs_move_llist(struct list_head
*source
, struct list_head
*dest
)
1208 struct list_head
*li
, *tmp
;
1209 list_for_each_safe(li
, tmp
, source
)
1210 list_move(li
, dest
);
1214 cifs_free_llist(struct list_head
*llist
)
1216 struct cifsLockInfo
*li
, *tmp
;
1217 list_for_each_entry_safe(li
, tmp
, llist
, llist
) {
1218 cifs_del_lock_waiters(li
);
1219 list_del(&li
->llist
);
1225 cifs_unlock_range(struct cifsFileInfo
*cfile
, struct file_lock
*flock
,
1228 int rc
= 0, stored_rc
;
1229 int types
[] = {LOCKING_ANDX_LARGE_FILES
,
1230 LOCKING_ANDX_SHARED_LOCK
| LOCKING_ANDX_LARGE_FILES
};
1232 unsigned int max_num
, num
, max_buf
;
1233 LOCKING_ANDX_RANGE
*buf
, *cur
;
1234 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1235 struct cifsInodeInfo
*cinode
= CIFS_I(cfile
->dentry
->d_inode
);
1236 struct cifsLockInfo
*li
, *tmp
;
1237 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1238 struct list_head tmp_llist
;
1240 INIT_LIST_HEAD(&tmp_llist
);
1243 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1244 * and check it for zero before using.
1246 max_buf
= tcon
->ses
->server
->maxBuf
;
1250 max_num
= (max_buf
- sizeof(struct smb_hdr
)) /
1251 sizeof(LOCKING_ANDX_RANGE
);
1252 buf
= kzalloc(max_num
* sizeof(LOCKING_ANDX_RANGE
), GFP_KERNEL
);
1256 mutex_lock(&cinode
->lock_mutex
);
1257 for (i
= 0; i
< 2; i
++) {
1260 list_for_each_entry_safe(li
, tmp
, &cfile
->llist
, llist
) {
1261 if (flock
->fl_start
> li
->offset
||
1262 (flock
->fl_start
+ length
) <
1263 (li
->offset
+ li
->length
))
1265 if (current
->tgid
!= li
->pid
)
1267 if (types
[i
] != li
->type
)
1269 if (cinode
->can_cache_brlcks
) {
1271 * We can cache brlock requests - simply remove
1272 * a lock from the file's list.
1274 list_del(&li
->llist
);
1275 cifs_del_lock_waiters(li
);
1279 cur
->Pid
= cpu_to_le16(li
->pid
);
1280 cur
->LengthLow
= cpu_to_le32((u32
)li
->length
);
1281 cur
->LengthHigh
= cpu_to_le32((u32
)(li
->length
>>32));
1282 cur
->OffsetLow
= cpu_to_le32((u32
)li
->offset
);
1283 cur
->OffsetHigh
= cpu_to_le32((u32
)(li
->offset
>>32));
1285 * We need to save a lock here to let us add it again to
1286 * the file's list if the unlock range request fails on
1289 list_move(&li
->llist
, &tmp_llist
);
1290 if (++num
== max_num
) {
1291 stored_rc
= cifs_lockv(xid
, tcon
, cfile
->netfid
,
1292 li
->type
, num
, 0, buf
);
1295 * We failed on the unlock range
1296 * request - add all locks from the tmp
1297 * list to the head of the file's list.
1299 cifs_move_llist(&tmp_llist
,
1304 * The unlock range request succeed -
1305 * free the tmp list.
1307 cifs_free_llist(&tmp_llist
);
1314 stored_rc
= cifs_lockv(xid
, tcon
, cfile
->netfid
,
1315 types
[i
], num
, 0, buf
);
1317 cifs_move_llist(&tmp_llist
, &cfile
->llist
);
1320 cifs_free_llist(&tmp_llist
);
1324 mutex_unlock(&cinode
->lock_mutex
);
1330 cifs_setlk(struct file
*file
, struct file_lock
*flock
, __u32 type
,
1331 bool wait_flag
, bool posix_lck
, int lock
, int unlock
,
1335 __u64 length
= 1 + flock
->fl_end
- flock
->fl_start
;
1336 struct cifsFileInfo
*cfile
= (struct cifsFileInfo
*)file
->private_data
;
1337 struct cifs_tcon
*tcon
= tlink_tcon(cfile
->tlink
);
1338 struct TCP_Server_Info
*server
= tcon
->ses
->server
;
1339 __u16 netfid
= cfile
->netfid
;
1342 int posix_lock_type
;
1344 rc
= cifs_posix_lock_set(file
, flock
);
1348 if (type
& server
->vals
->shared_lock_type
)
1349 posix_lock_type
= CIFS_RDLCK
;
1351 posix_lock_type
= CIFS_WRLCK
;
1354 posix_lock_type
= CIFS_UNLCK
;
1356 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, current
->tgid
,
1357 flock
->fl_start
, length
, NULL
,
1358 posix_lock_type
, wait_flag
);
1363 struct cifsLockInfo
*lock
;
1365 lock
= cifs_lock_init(flock
->fl_start
, length
, type
);
1369 rc
= cifs_lock_add_if(cfile
, lock
, wait_flag
);
1375 rc
= cifs_mandatory_lock(xid
, cfile
, flock
->fl_start
, length
,
1376 type
, 1, 0, wait_flag
);
1382 cifs_lock_add(cfile
, lock
);
1384 rc
= cifs_unlock_range(cfile
, flock
, xid
);
1387 if (flock
->fl_flags
& FL_POSIX
)
1388 posix_lock_file_wait(file
, flock
);
1392 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*flock
)
1395 int lock
= 0, unlock
= 0;
1396 bool wait_flag
= false;
1397 bool posix_lck
= false;
1398 struct cifs_sb_info
*cifs_sb
;
1399 struct cifs_tcon
*tcon
;
1400 struct cifsInodeInfo
*cinode
;
1401 struct cifsFileInfo
*cfile
;
1408 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1409 "end: %lld", cmd
, flock
->fl_flags
, flock
->fl_type
,
1410 flock
->fl_start
, flock
->fl_end
);
1412 cfile
= (struct cifsFileInfo
*)file
->private_data
;
1413 tcon
= tlink_tcon(cfile
->tlink
);
1415 cifs_read_flock(flock
, &type
, &lock
, &unlock
, &wait_flag
,
1418 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1419 netfid
= cfile
->netfid
;
1420 cinode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
1422 if ((tcon
->ses
->capabilities
& CAP_UNIX
) &&
1423 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
1424 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
1427 * BB add code here to normalize offset and length to account for
1428 * negative length which we can not accept over the wire.
1430 if (IS_GETLK(cmd
)) {
1431 rc
= cifs_getlk(file
, flock
, type
, wait_flag
, posix_lck
, xid
);
1436 if (!lock
&& !unlock
) {
1438 * if no lock or unlock then nothing to do since we do not
1445 rc
= cifs_setlk(file
, flock
, type
, wait_flag
, posix_lck
, lock
, unlock
,
1452 * update the file size (if needed) after a write. Should be called with
1453 * the inode->i_lock held
1456 cifs_update_eof(struct cifsInodeInfo
*cifsi
, loff_t offset
,
1457 unsigned int bytes_written
)
1459 loff_t end_of_write
= offset
+ bytes_written
;
1461 if (end_of_write
> cifsi
->server_eof
)
1462 cifsi
->server_eof
= end_of_write
;
1465 static ssize_t
cifs_write(struct cifsFileInfo
*open_file
, __u32 pid
,
1466 const char *write_data
, size_t write_size
,
1470 unsigned int bytes_written
= 0;
1471 unsigned int total_written
;
1472 struct cifs_sb_info
*cifs_sb
;
1473 struct cifs_tcon
*pTcon
;
1475 struct dentry
*dentry
= open_file
->dentry
;
1476 struct cifsInodeInfo
*cifsi
= CIFS_I(dentry
->d_inode
);
1477 struct cifs_io_parms io_parms
;
1479 cifs_sb
= CIFS_SB(dentry
->d_sb
);
1481 cFYI(1, "write %zd bytes to offset %lld of %s", write_size
,
1482 *poffset
, dentry
->d_name
.name
);
1484 pTcon
= tlink_tcon(open_file
->tlink
);
1488 for (total_written
= 0; write_size
> total_written
;
1489 total_written
+= bytes_written
) {
1491 while (rc
== -EAGAIN
) {
1495 if (open_file
->invalidHandle
) {
1496 /* we could deadlock if we called
1497 filemap_fdatawait from here so tell
1498 reopen_file not to flush data to
1500 rc
= cifs_reopen_file(open_file
, false);
1505 len
= min((size_t)cifs_sb
->wsize
,
1506 write_size
- total_written
);
1507 /* iov[0] is reserved for smb header */
1508 iov
[1].iov_base
= (char *)write_data
+ total_written
;
1509 iov
[1].iov_len
= len
;
1510 io_parms
.netfid
= open_file
->netfid
;
1512 io_parms
.tcon
= pTcon
;
1513 io_parms
.offset
= *poffset
;
1514 io_parms
.length
= len
;
1515 rc
= CIFSSMBWrite2(xid
, &io_parms
, &bytes_written
, iov
,
1518 if (rc
|| (bytes_written
== 0)) {
1526 spin_lock(&dentry
->d_inode
->i_lock
);
1527 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1528 spin_unlock(&dentry
->d_inode
->i_lock
);
1529 *poffset
+= bytes_written
;
1533 cifs_stats_bytes_written(pTcon
, total_written
);
1535 if (total_written
> 0) {
1536 spin_lock(&dentry
->d_inode
->i_lock
);
1537 if (*poffset
> dentry
->d_inode
->i_size
)
1538 i_size_write(dentry
->d_inode
, *poffset
);
1539 spin_unlock(&dentry
->d_inode
->i_lock
);
1541 mark_inode_dirty_sync(dentry
->d_inode
);
1543 return total_written
;
1546 struct cifsFileInfo
*find_readable_file(struct cifsInodeInfo
*cifs_inode
,
1549 struct cifsFileInfo
*open_file
= NULL
;
1550 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1552 /* only filter by fsuid on multiuser mounts */
1553 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1556 spin_lock(&cifs_file_list_lock
);
1557 /* we could simply get the first_list_entry since write-only entries
1558 are always at the end of the list but since the first entry might
1559 have a close pending, we go through the whole list */
1560 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1561 if (fsuid_only
&& open_file
->uid
!= current_fsuid())
1563 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_READ
) {
1564 if (!open_file
->invalidHandle
) {
1565 /* found a good file */
1566 /* lock it so it will not be closed on us */
1567 cifsFileInfo_get(open_file
);
1568 spin_unlock(&cifs_file_list_lock
);
1570 } /* else might as well continue, and look for
1571 another, or simply have the caller reopen it
1572 again rather than trying to fix this handle */
1573 } else /* write only file */
1574 break; /* write only files are last so must be done */
1576 spin_unlock(&cifs_file_list_lock
);
1580 struct cifsFileInfo
*find_writable_file(struct cifsInodeInfo
*cifs_inode
,
1583 struct cifsFileInfo
*open_file
, *inv_file
= NULL
;
1584 struct cifs_sb_info
*cifs_sb
;
1585 bool any_available
= false;
1587 unsigned int refind
= 0;
1589 /* Having a null inode here (because mapping->host was set to zero by
1590 the VFS or MM) should not happen but we had reports of on oops (due to
1591 it being zero) during stress testcases so we need to check for it */
1593 if (cifs_inode
== NULL
) {
1594 cERROR(1, "Null inode passed to cifs_writeable_file");
1599 cifs_sb
= CIFS_SB(cifs_inode
->vfs_inode
.i_sb
);
1601 /* only filter by fsuid on multiuser mounts */
1602 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_MULTIUSER
))
1605 spin_lock(&cifs_file_list_lock
);
1607 if (refind
> MAX_REOPEN_ATT
) {
1608 spin_unlock(&cifs_file_list_lock
);
1611 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1612 if (!any_available
&& open_file
->pid
!= current
->tgid
)
1614 if (fsuid_only
&& open_file
->uid
!= current_fsuid())
1616 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
1617 if (!open_file
->invalidHandle
) {
1618 /* found a good writable file */
1619 cifsFileInfo_get(open_file
);
1620 spin_unlock(&cifs_file_list_lock
);
1624 inv_file
= open_file
;
1628 /* couldn't find useable FH with same pid, try any available */
1629 if (!any_available
) {
1630 any_available
= true;
1631 goto refind_writable
;
1635 any_available
= false;
1636 cifsFileInfo_get(inv_file
);
1639 spin_unlock(&cifs_file_list_lock
);
1642 rc
= cifs_reopen_file(inv_file
, false);
1646 spin_lock(&cifs_file_list_lock
);
1647 list_move_tail(&inv_file
->flist
,
1648 &cifs_inode
->openFileList
);
1649 spin_unlock(&cifs_file_list_lock
);
1650 cifsFileInfo_put(inv_file
);
1651 spin_lock(&cifs_file_list_lock
);
1653 goto refind_writable
;
1660 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
1662 struct address_space
*mapping
= page
->mapping
;
1663 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1666 int bytes_written
= 0;
1667 struct inode
*inode
;
1668 struct cifsFileInfo
*open_file
;
1670 if (!mapping
|| !mapping
->host
)
1673 inode
= page
->mapping
->host
;
1675 offset
+= (loff_t
)from
;
1676 write_data
= kmap(page
);
1679 if ((to
> PAGE_CACHE_SIZE
) || (from
> to
)) {
1684 /* racing with truncate? */
1685 if (offset
> mapping
->host
->i_size
) {
1687 return 0; /* don't care */
1690 /* check to make sure that we are not extending the file */
1691 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
1692 to
= (unsigned)(mapping
->host
->i_size
- offset
);
1694 open_file
= find_writable_file(CIFS_I(mapping
->host
), false);
1696 bytes_written
= cifs_write(open_file
, open_file
->pid
,
1697 write_data
, to
- from
, &offset
);
1698 cifsFileInfo_put(open_file
);
1699 /* Does mm or vfs already set times? */
1700 inode
->i_atime
= inode
->i_mtime
= current_fs_time(inode
->i_sb
);
1701 if ((bytes_written
> 0) && (offset
))
1703 else if (bytes_written
< 0)
1706 cFYI(1, "No writeable filehandles for inode");
1715 * Marshal up the iov array, reserving the first one for the header. Also,
1719 cifs_writepages_marshal_iov(struct kvec
*iov
, struct cifs_writedata
*wdata
)
1722 struct inode
*inode
= wdata
->cfile
->dentry
->d_inode
;
1723 loff_t size
= i_size_read(inode
);
1725 /* marshal up the pages into iov array */
1727 for (i
= 0; i
< wdata
->nr_pages
; i
++) {
1728 iov
[i
+ 1].iov_len
= min(size
- page_offset(wdata
->pages
[i
]),
1729 (loff_t
)PAGE_CACHE_SIZE
);
1730 iov
[i
+ 1].iov_base
= kmap(wdata
->pages
[i
]);
1731 wdata
->bytes
+= iov
[i
+ 1].iov_len
;
1735 static int cifs_writepages(struct address_space
*mapping
,
1736 struct writeback_control
*wbc
)
1738 struct cifs_sb_info
*cifs_sb
= CIFS_SB(mapping
->host
->i_sb
);
1739 bool done
= false, scanned
= false, range_whole
= false;
1741 struct cifs_writedata
*wdata
;
1746 * If wsize is smaller than the page cache size, default to writing
1747 * one page at a time via cifs_writepage
1749 if (cifs_sb
->wsize
< PAGE_CACHE_SIZE
)
1750 return generic_writepages(mapping
, wbc
);
1752 if (wbc
->range_cyclic
) {
1753 index
= mapping
->writeback_index
; /* Start from prev offset */
1756 index
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
1757 end
= wbc
->range_end
>> PAGE_CACHE_SHIFT
;
1758 if (wbc
->range_start
== 0 && wbc
->range_end
== LLONG_MAX
)
1763 while (!done
&& index
<= end
) {
1764 unsigned int i
, nr_pages
, found_pages
;
1765 pgoff_t next
= 0, tofind
;
1766 struct page
**pages
;
1768 tofind
= min((cifs_sb
->wsize
/ PAGE_CACHE_SIZE
) - 1,
1771 wdata
= cifs_writedata_alloc((unsigned int)tofind
,
1772 cifs_writev_complete
);
1779 * find_get_pages_tag seems to return a max of 256 on each
1780 * iteration, so we must call it several times in order to
1781 * fill the array or the wsize is effectively limited to
1782 * 256 * PAGE_CACHE_SIZE.
1785 pages
= wdata
->pages
;
1787 nr_pages
= find_get_pages_tag(mapping
, &index
,
1788 PAGECACHE_TAG_DIRTY
,
1790 found_pages
+= nr_pages
;
1793 } while (nr_pages
&& tofind
&& index
<= end
);
1795 if (found_pages
== 0) {
1796 kref_put(&wdata
->refcount
, cifs_writedata_release
);
1801 for (i
= 0; i
< found_pages
; i
++) {
1802 page
= wdata
->pages
[i
];
1804 * At this point we hold neither mapping->tree_lock nor
1805 * lock on the page itself: the page may be truncated or
1806 * invalidated (changing page->mapping to NULL), or even
1807 * swizzled back from swapper_space to tmpfs file
1813 else if (!trylock_page(page
))
1816 if (unlikely(page
->mapping
!= mapping
)) {
1821 if (!wbc
->range_cyclic
&& page
->index
> end
) {
1827 if (next
&& (page
->index
!= next
)) {
1828 /* Not next consecutive page */
1833 if (wbc
->sync_mode
!= WB_SYNC_NONE
)
1834 wait_on_page_writeback(page
);
1836 if (PageWriteback(page
) ||
1837 !clear_page_dirty_for_io(page
)) {
1843 * This actually clears the dirty bit in the radix tree.
1844 * See cifs_writepage() for more commentary.
1846 set_page_writeback(page
);
1848 if (page_offset(page
) >= mapping
->host
->i_size
) {
1851 end_page_writeback(page
);
1855 wdata
->pages
[i
] = page
;
1856 next
= page
->index
+ 1;
1860 /* reset index to refind any pages skipped */
1862 index
= wdata
->pages
[0]->index
+ 1;
1864 /* put any pages we aren't going to use */
1865 for (i
= nr_pages
; i
< found_pages
; i
++) {
1866 page_cache_release(wdata
->pages
[i
]);
1867 wdata
->pages
[i
] = NULL
;
1870 /* nothing to write? */
1871 if (nr_pages
== 0) {
1872 kref_put(&wdata
->refcount
, cifs_writedata_release
);
1876 wdata
->sync_mode
= wbc
->sync_mode
;
1877 wdata
->nr_pages
= nr_pages
;
1878 wdata
->offset
= page_offset(wdata
->pages
[0]);
1879 wdata
->marshal_iov
= cifs_writepages_marshal_iov
;
1882 if (wdata
->cfile
!= NULL
)
1883 cifsFileInfo_put(wdata
->cfile
);
1884 wdata
->cfile
= find_writable_file(CIFS_I(mapping
->host
),
1886 if (!wdata
->cfile
) {
1887 cERROR(1, "No writable handles for inode");
1891 wdata
->pid
= wdata
->cfile
->pid
;
1892 rc
= cifs_async_writev(wdata
);
1893 } while (wbc
->sync_mode
== WB_SYNC_ALL
&& rc
== -EAGAIN
);
1895 for (i
= 0; i
< nr_pages
; ++i
)
1896 unlock_page(wdata
->pages
[i
]);
1898 /* send failure -- clean up the mess */
1900 for (i
= 0; i
< nr_pages
; ++i
) {
1902 redirty_page_for_writepage(wbc
,
1905 SetPageError(wdata
->pages
[i
]);
1906 end_page_writeback(wdata
->pages
[i
]);
1907 page_cache_release(wdata
->pages
[i
]);
1910 mapping_set_error(mapping
, rc
);
1912 kref_put(&wdata
->refcount
, cifs_writedata_release
);
1914 wbc
->nr_to_write
-= nr_pages
;
1915 if (wbc
->nr_to_write
<= 0)
1921 if (!scanned
&& !done
) {
1923 * We hit the last page and there is more work to be done: wrap
1924 * back to the start of the file
1931 if (wbc
->range_cyclic
|| (range_whole
&& wbc
->nr_to_write
> 0))
1932 mapping
->writeback_index
= index
;
1938 cifs_writepage_locked(struct page
*page
, struct writeback_control
*wbc
)
1944 /* BB add check for wbc flags */
1945 page_cache_get(page
);
1946 if (!PageUptodate(page
))
1947 cFYI(1, "ppw - page not up to date");
1950 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1952 * A writepage() implementation always needs to do either this,
1953 * or re-dirty the page with "redirty_page_for_writepage()" in
1954 * the case of a failure.
1956 * Just unlocking the page will cause the radix tree tag-bits
1957 * to fail to update with the state of the page correctly.
1959 set_page_writeback(page
);
1961 rc
= cifs_partialpagewrite(page
, 0, PAGE_CACHE_SIZE
);
1962 if (rc
== -EAGAIN
&& wbc
->sync_mode
== WB_SYNC_ALL
)
1964 else if (rc
== -EAGAIN
)
1965 redirty_page_for_writepage(wbc
, page
);
1969 SetPageUptodate(page
);
1970 end_page_writeback(page
);
1971 page_cache_release(page
);
1976 static int cifs_writepage(struct page
*page
, struct writeback_control
*wbc
)
1978 int rc
= cifs_writepage_locked(page
, wbc
);
1983 static int cifs_write_end(struct file
*file
, struct address_space
*mapping
,
1984 loff_t pos
, unsigned len
, unsigned copied
,
1985 struct page
*page
, void *fsdata
)
1988 struct inode
*inode
= mapping
->host
;
1989 struct cifsFileInfo
*cfile
= file
->private_data
;
1990 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->dentry
->d_sb
);
1993 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
1996 pid
= current
->tgid
;
1998 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
2001 if (PageChecked(page
)) {
2003 SetPageUptodate(page
);
2004 ClearPageChecked(page
);
2005 } else if (!PageUptodate(page
) && copied
== PAGE_CACHE_SIZE
)
2006 SetPageUptodate(page
);
2008 if (!PageUptodate(page
)) {
2010 unsigned offset
= pos
& (PAGE_CACHE_SIZE
- 1);
2014 /* this is probably better than directly calling
2015 partialpage_write since in this function the file handle is
2016 known which we might as well leverage */
2017 /* BB check if anything else missing out of ppw
2018 such as updating last write time */
2019 page_data
= kmap(page
);
2020 rc
= cifs_write(cfile
, pid
, page_data
+ offset
, copied
, &pos
);
2021 /* if (rc < 0) should we set writebehind rc? */
2028 set_page_dirty(page
);
2032 spin_lock(&inode
->i_lock
);
2033 if (pos
> inode
->i_size
)
2034 i_size_write(inode
, pos
);
2035 spin_unlock(&inode
->i_lock
);
2039 page_cache_release(page
);
2044 int cifs_strict_fsync(struct file
*file
, loff_t start
, loff_t end
,
2049 struct cifs_tcon
*tcon
;
2050 struct cifsFileInfo
*smbfile
= file
->private_data
;
2051 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
2052 struct cifs_sb_info
*cifs_sb
= CIFS_SB(inode
->i_sb
);
2054 rc
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
2057 mutex_lock(&inode
->i_mutex
);
2061 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2062 file
->f_path
.dentry
->d_name
.name
, datasync
);
2064 if (!CIFS_I(inode
)->clientCanCacheRead
) {
2065 rc
= cifs_invalidate_mapping(inode
);
2067 cFYI(1, "rc: %d during invalidate phase", rc
);
2068 rc
= 0; /* don't care about it in fsync */
2072 tcon
= tlink_tcon(smbfile
->tlink
);
2073 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
))
2074 rc
= CIFSSMBFlush(xid
, tcon
, smbfile
->netfid
);
2077 mutex_unlock(&inode
->i_mutex
);
2081 int cifs_fsync(struct file
*file
, loff_t start
, loff_t end
, int datasync
)
2085 struct cifs_tcon
*tcon
;
2086 struct cifsFileInfo
*smbfile
= file
->private_data
;
2087 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2088 struct inode
*inode
= file
->f_mapping
->host
;
2090 rc
= filemap_write_and_wait_range(inode
->i_mapping
, start
, end
);
2093 mutex_lock(&inode
->i_mutex
);
2097 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2098 file
->f_path
.dentry
->d_name
.name
, datasync
);
2100 tcon
= tlink_tcon(smbfile
->tlink
);
2101 if (!(cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
))
2102 rc
= CIFSSMBFlush(xid
, tcon
, smbfile
->netfid
);
2105 mutex_unlock(&inode
->i_mutex
);
2110 * As file closes, flush all cached write data for this inode checking
2111 * for write behind errors.
2113 int cifs_flush(struct file
*file
, fl_owner_t id
)
2115 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
2118 if (file
->f_mode
& FMODE_WRITE
)
2119 rc
= filemap_write_and_wait(inode
->i_mapping
);
2121 cFYI(1, "Flush inode %p file %p rc %d", inode
, file
, rc
);
2127 cifs_write_allocate_pages(struct page
**pages
, unsigned long num_pages
)
2132 for (i
= 0; i
< num_pages
; i
++) {
2133 pages
[i
] = alloc_page(GFP_KERNEL
|__GFP_HIGHMEM
);
2136 * save number of pages we have already allocated and
2137 * return with ENOMEM error
2146 for (i
= 0; i
< num_pages
; i
++)
2153 size_t get_numpages(const size_t wsize
, const size_t len
, size_t *cur_len
)
2158 clen
= min_t(const size_t, len
, wsize
);
2159 num_pages
= DIV_ROUND_UP(clen
, PAGE_SIZE
);
2168 cifs_uncached_marshal_iov(struct kvec
*iov
, struct cifs_writedata
*wdata
)
2171 size_t bytes
= wdata
->bytes
;
2173 /* marshal up the pages into iov array */
2174 for (i
= 0; i
< wdata
->nr_pages
; i
++) {
2175 iov
[i
+ 1].iov_len
= min_t(size_t, bytes
, PAGE_SIZE
);
2176 iov
[i
+ 1].iov_base
= kmap(wdata
->pages
[i
]);
2177 bytes
-= iov
[i
+ 1].iov_len
;
2182 cifs_uncached_writev_complete(struct work_struct
*work
)
2185 struct cifs_writedata
*wdata
= container_of(work
,
2186 struct cifs_writedata
, work
);
2187 struct inode
*inode
= wdata
->cfile
->dentry
->d_inode
;
2188 struct cifsInodeInfo
*cifsi
= CIFS_I(inode
);
2190 spin_lock(&inode
->i_lock
);
2191 cifs_update_eof(cifsi
, wdata
->offset
, wdata
->bytes
);
2192 if (cifsi
->server_eof
> inode
->i_size
)
2193 i_size_write(inode
, cifsi
->server_eof
);
2194 spin_unlock(&inode
->i_lock
);
2196 complete(&wdata
->done
);
2198 if (wdata
->result
!= -EAGAIN
) {
2199 for (i
= 0; i
< wdata
->nr_pages
; i
++)
2200 put_page(wdata
->pages
[i
]);
2203 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2206 /* attempt to send write to server, retry on any -EAGAIN errors */
2208 cifs_uncached_retry_writev(struct cifs_writedata
*wdata
)
2213 if (wdata
->cfile
->invalidHandle
) {
2214 rc
= cifs_reopen_file(wdata
->cfile
, false);
2218 rc
= cifs_async_writev(wdata
);
2219 } while (rc
== -EAGAIN
);
2225 cifs_iovec_write(struct file
*file
, const struct iovec
*iov
,
2226 unsigned long nr_segs
, loff_t
*poffset
)
2228 unsigned long nr_pages
, i
;
2229 size_t copied
, len
, cur_len
;
2230 ssize_t total_written
= 0;
2233 struct cifsFileInfo
*open_file
;
2234 struct cifs_tcon
*tcon
;
2235 struct cifs_sb_info
*cifs_sb
;
2236 struct cifs_writedata
*wdata
, *tmp
;
2237 struct list_head wdata_list
;
2241 len
= iov_length(iov
, nr_segs
);
2245 rc
= generic_write_checks(file
, poffset
, &len
, 0);
2249 INIT_LIST_HEAD(&wdata_list
);
2250 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2251 open_file
= file
->private_data
;
2252 tcon
= tlink_tcon(open_file
->tlink
);
2255 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2256 pid
= open_file
->pid
;
2258 pid
= current
->tgid
;
2260 iov_iter_init(&it
, iov
, nr_segs
, len
, 0);
2264 nr_pages
= get_numpages(cifs_sb
->wsize
, len
, &cur_len
);
2265 wdata
= cifs_writedata_alloc(nr_pages
,
2266 cifs_uncached_writev_complete
);
2272 rc
= cifs_write_allocate_pages(wdata
->pages
, nr_pages
);
2279 for (i
= 0; i
< nr_pages
; i
++) {
2280 copied
= min_t(const size_t, cur_len
, PAGE_SIZE
);
2281 copied
= iov_iter_copy_from_user(wdata
->pages
[i
], &it
,
2284 iov_iter_advance(&it
, copied
);
2286 cur_len
= save_len
- cur_len
;
2288 wdata
->sync_mode
= WB_SYNC_ALL
;
2289 wdata
->nr_pages
= nr_pages
;
2290 wdata
->offset
= (__u64
)offset
;
2291 wdata
->cfile
= cifsFileInfo_get(open_file
);
2293 wdata
->bytes
= cur_len
;
2294 wdata
->marshal_iov
= cifs_uncached_marshal_iov
;
2295 rc
= cifs_uncached_retry_writev(wdata
);
2297 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2301 list_add_tail(&wdata
->list
, &wdata_list
);
2307 * If at least one write was successfully sent, then discard any rc
2308 * value from the later writes. If the other write succeeds, then
2309 * we'll end up returning whatever was written. If it fails, then
2310 * we'll get a new rc value from that.
2312 if (!list_empty(&wdata_list
))
2316 * Wait for and collect replies for any successful sends in order of
2317 * increasing offset. Once an error is hit or we get a fatal signal
2318 * while waiting, then return without waiting for any more replies.
2321 list_for_each_entry_safe(wdata
, tmp
, &wdata_list
, list
) {
2323 /* FIXME: freezable too? */
2324 rc
= wait_for_completion_killable(&wdata
->done
);
2327 else if (wdata
->result
)
2330 total_written
+= wdata
->bytes
;
2332 /* resend call if it's a retryable error */
2333 if (rc
== -EAGAIN
) {
2334 rc
= cifs_uncached_retry_writev(wdata
);
2338 list_del_init(&wdata
->list
);
2339 kref_put(&wdata
->refcount
, cifs_writedata_release
);
2342 if (total_written
> 0)
2343 *poffset
+= total_written
;
2345 cifs_stats_bytes_written(tcon
, total_written
);
2346 return total_written
? total_written
: (ssize_t
)rc
;
2349 ssize_t
cifs_user_writev(struct kiocb
*iocb
, const struct iovec
*iov
,
2350 unsigned long nr_segs
, loff_t pos
)
2353 struct inode
*inode
;
2355 inode
= iocb
->ki_filp
->f_path
.dentry
->d_inode
;
2358 * BB - optimize the way when signing is disabled. We can drop this
2359 * extra memory-to-memory copying and use iovec buffers for constructing
2363 written
= cifs_iovec_write(iocb
->ki_filp
, iov
, nr_segs
, &pos
);
2365 CIFS_I(inode
)->invalid_mapping
= true;
2372 ssize_t
cifs_strict_writev(struct kiocb
*iocb
, const struct iovec
*iov
,
2373 unsigned long nr_segs
, loff_t pos
)
2375 struct inode
*inode
;
2377 inode
= iocb
->ki_filp
->f_path
.dentry
->d_inode
;
2379 if (CIFS_I(inode
)->clientCanCacheAll
)
2380 return generic_file_aio_write(iocb
, iov
, nr_segs
, pos
);
2383 * In strict cache mode we need to write the data to the server exactly
2384 * from the pos to pos+len-1 rather than flush all affected pages
2385 * because it may cause a error with mandatory locks on these pages but
2386 * not on the region from pos to ppos+len-1.
2389 return cifs_user_writev(iocb
, iov
, nr_segs
, pos
);
2392 static struct cifs_readdata
*
2393 cifs_readdata_alloc(unsigned int nr_vecs
, work_func_t complete
)
2395 struct cifs_readdata
*rdata
;
2397 rdata
= kzalloc(sizeof(*rdata
) +
2398 sizeof(struct kvec
) * nr_vecs
, GFP_KERNEL
);
2399 if (rdata
!= NULL
) {
2400 kref_init(&rdata
->refcount
);
2401 INIT_LIST_HEAD(&rdata
->list
);
2402 init_completion(&rdata
->done
);
2403 INIT_WORK(&rdata
->work
, complete
);
2404 INIT_LIST_HEAD(&rdata
->pages
);
2410 cifs_readdata_release(struct kref
*refcount
)
2412 struct cifs_readdata
*rdata
= container_of(refcount
,
2413 struct cifs_readdata
, refcount
);
2416 cifsFileInfo_put(rdata
->cfile
);
2422 cifs_read_allocate_pages(struct list_head
*list
, unsigned int npages
)
2425 struct page
*page
, *tpage
;
2428 for (i
= 0; i
< npages
; i
++) {
2429 page
= alloc_page(GFP_KERNEL
|__GFP_HIGHMEM
);
2434 list_add(&page
->lru
, list
);
2438 list_for_each_entry_safe(page
, tpage
, list
, lru
) {
2439 list_del(&page
->lru
);
2447 cifs_uncached_readdata_release(struct kref
*refcount
)
2449 struct page
*page
, *tpage
;
2450 struct cifs_readdata
*rdata
= container_of(refcount
,
2451 struct cifs_readdata
, refcount
);
2453 list_for_each_entry_safe(page
, tpage
, &rdata
->pages
, lru
) {
2454 list_del(&page
->lru
);
2457 cifs_readdata_release(refcount
);
2461 cifs_retry_async_readv(struct cifs_readdata
*rdata
)
2466 if (rdata
->cfile
->invalidHandle
) {
2467 rc
= cifs_reopen_file(rdata
->cfile
, true);
2471 rc
= cifs_async_readv(rdata
);
2472 } while (rc
== -EAGAIN
);
2478 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2479 * @rdata: the readdata response with list of pages holding data
2480 * @iov: vector in which we should copy the data
2481 * @nr_segs: number of segments in vector
2482 * @offset: offset into file of the first iovec
2483 * @copied: used to return the amount of data copied to the iov
2485 * This function copies data from a list of pages in a readdata response into
2486 * an array of iovecs. It will first calculate where the data should go
2487 * based on the info in the readdata and then copy the data into that spot.
2490 cifs_readdata_to_iov(struct cifs_readdata
*rdata
, const struct iovec
*iov
,
2491 unsigned long nr_segs
, loff_t offset
, ssize_t
*copied
)
2495 size_t pos
= rdata
->offset
- offset
;
2496 struct page
*page
, *tpage
;
2497 ssize_t remaining
= rdata
->bytes
;
2498 unsigned char *pdata
;
2500 /* set up iov_iter and advance to the correct offset */
2501 iov_iter_init(&ii
, iov
, nr_segs
, iov_length(iov
, nr_segs
), 0);
2502 iov_iter_advance(&ii
, pos
);
2505 list_for_each_entry_safe(page
, tpage
, &rdata
->pages
, lru
) {
2508 /* copy a whole page or whatever's left */
2509 copy
= min_t(ssize_t
, remaining
, PAGE_SIZE
);
2511 /* ...but limit it to whatever space is left in the iov */
2512 copy
= min_t(ssize_t
, copy
, iov_iter_count(&ii
));
2514 /* go while there's data to be copied and no errors */
2517 rc
= memcpy_toiovecend(ii
.iov
, pdata
, ii
.iov_offset
,
2523 iov_iter_advance(&ii
, copy
);
2527 list_del(&page
->lru
);
2535 cifs_uncached_readv_complete(struct work_struct
*work
)
2537 struct cifs_readdata
*rdata
= container_of(work
,
2538 struct cifs_readdata
, work
);
2540 /* if the result is non-zero then the pages weren't kmapped */
2541 if (rdata
->result
== 0) {
2544 list_for_each_entry(page
, &rdata
->pages
, lru
)
2548 complete(&rdata
->done
);
2549 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
2553 cifs_uncached_read_marshal_iov(struct cifs_readdata
*rdata
,
2554 unsigned int remaining
)
2557 struct page
*page
, *tpage
;
2560 list_for_each_entry_safe(page
, tpage
, &rdata
->pages
, lru
) {
2561 if (remaining
>= PAGE_SIZE
) {
2562 /* enough data to fill the page */
2563 rdata
->iov
[rdata
->nr_iov
].iov_base
= kmap(page
);
2564 rdata
->iov
[rdata
->nr_iov
].iov_len
= PAGE_SIZE
;
2565 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2566 rdata
->nr_iov
, page
->index
,
2567 rdata
->iov
[rdata
->nr_iov
].iov_base
,
2568 rdata
->iov
[rdata
->nr_iov
].iov_len
);
2571 remaining
-= PAGE_SIZE
;
2572 } else if (remaining
> 0) {
2573 /* enough for partial page, fill and zero the rest */
2574 rdata
->iov
[rdata
->nr_iov
].iov_base
= kmap(page
);
2575 rdata
->iov
[rdata
->nr_iov
].iov_len
= remaining
;
2576 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2577 rdata
->nr_iov
, page
->index
,
2578 rdata
->iov
[rdata
->nr_iov
].iov_base
,
2579 rdata
->iov
[rdata
->nr_iov
].iov_len
);
2580 memset(rdata
->iov
[rdata
->nr_iov
].iov_base
+ remaining
,
2581 '\0', PAGE_SIZE
- remaining
);
2586 /* no need to hold page hostage */
2587 list_del(&page
->lru
);
2596 cifs_iovec_read(struct file
*file
, const struct iovec
*iov
,
2597 unsigned long nr_segs
, loff_t
*poffset
)
2600 size_t len
, cur_len
;
2601 ssize_t total_read
= 0;
2602 loff_t offset
= *poffset
;
2603 unsigned int npages
;
2604 struct cifs_sb_info
*cifs_sb
;
2605 struct cifs_tcon
*tcon
;
2606 struct cifsFileInfo
*open_file
;
2607 struct cifs_readdata
*rdata
, *tmp
;
2608 struct list_head rdata_list
;
2614 len
= iov_length(iov
, nr_segs
);
2618 INIT_LIST_HEAD(&rdata_list
);
2619 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2620 open_file
= file
->private_data
;
2621 tcon
= tlink_tcon(open_file
->tlink
);
2623 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2624 pid
= open_file
->pid
;
2626 pid
= current
->tgid
;
2628 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
2629 cFYI(1, "attempting read on write only file instance");
2632 cur_len
= min_t(const size_t, len
- total_read
, cifs_sb
->rsize
);
2633 npages
= DIV_ROUND_UP(cur_len
, PAGE_SIZE
);
2635 /* allocate a readdata struct */
2636 rdata
= cifs_readdata_alloc(npages
,
2637 cifs_uncached_readv_complete
);
2643 rc
= cifs_read_allocate_pages(&rdata
->pages
, npages
);
2647 rdata
->cfile
= cifsFileInfo_get(open_file
);
2648 rdata
->offset
= offset
;
2649 rdata
->bytes
= cur_len
;
2651 rdata
->marshal_iov
= cifs_uncached_read_marshal_iov
;
2653 rc
= cifs_retry_async_readv(rdata
);
2656 kref_put(&rdata
->refcount
,
2657 cifs_uncached_readdata_release
);
2661 list_add_tail(&rdata
->list
, &rdata_list
);
2666 /* if at least one read request send succeeded, then reset rc */
2667 if (!list_empty(&rdata_list
))
2670 /* the loop below should proceed in the order of increasing offsets */
2672 list_for_each_entry_safe(rdata
, tmp
, &rdata_list
, list
) {
2676 /* FIXME: freezable sleep too? */
2677 rc
= wait_for_completion_killable(&rdata
->done
);
2680 else if (rdata
->result
)
2683 rc
= cifs_readdata_to_iov(rdata
, iov
,
2686 total_read
+= copied
;
2689 /* resend call if it's a retryable error */
2690 if (rc
== -EAGAIN
) {
2691 rc
= cifs_retry_async_readv(rdata
);
2695 list_del_init(&rdata
->list
);
2696 kref_put(&rdata
->refcount
, cifs_uncached_readdata_release
);
2699 cifs_stats_bytes_read(tcon
, total_read
);
2700 *poffset
+= total_read
;
2702 return total_read
? total_read
: rc
;
2705 ssize_t
cifs_user_readv(struct kiocb
*iocb
, const struct iovec
*iov
,
2706 unsigned long nr_segs
, loff_t pos
)
2710 read
= cifs_iovec_read(iocb
->ki_filp
, iov
, nr_segs
, &pos
);
2717 ssize_t
cifs_strict_readv(struct kiocb
*iocb
, const struct iovec
*iov
,
2718 unsigned long nr_segs
, loff_t pos
)
2720 struct inode
*inode
;
2722 inode
= iocb
->ki_filp
->f_path
.dentry
->d_inode
;
2724 if (CIFS_I(inode
)->clientCanCacheRead
)
2725 return generic_file_aio_read(iocb
, iov
, nr_segs
, pos
);
2728 * In strict cache mode we need to read from the server all the time
2729 * if we don't have level II oplock because the server can delay mtime
2730 * change - so we can't make a decision about inode invalidating.
2731 * And we can also fail with pagereading if there are mandatory locks
2732 * on pages affected by this read but not on the region from pos to
2736 return cifs_user_readv(iocb
, iov
, nr_segs
, pos
);
2739 static ssize_t
cifs_read(struct file
*file
, char *read_data
, size_t read_size
,
2743 unsigned int bytes_read
= 0;
2744 unsigned int total_read
;
2745 unsigned int current_read_size
;
2747 struct cifs_sb_info
*cifs_sb
;
2748 struct cifs_tcon
*pTcon
;
2750 char *current_offset
;
2751 struct cifsFileInfo
*open_file
;
2752 struct cifs_io_parms io_parms
;
2753 int buf_type
= CIFS_NO_BUFFER
;
2757 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2759 /* FIXME: set up handlers for larger reads and/or convert to async */
2760 rsize
= min_t(unsigned int, cifs_sb
->rsize
, CIFSMaxBufSize
);
2762 if (file
->private_data
== NULL
) {
2767 open_file
= file
->private_data
;
2768 pTcon
= tlink_tcon(open_file
->tlink
);
2770 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
2771 pid
= open_file
->pid
;
2773 pid
= current
->tgid
;
2775 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
2776 cFYI(1, "attempting read on write only file instance");
2778 for (total_read
= 0, current_offset
= read_data
;
2779 read_size
> total_read
;
2780 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
2781 current_read_size
= min_t(uint
, read_size
- total_read
, rsize
);
2783 /* For windows me and 9x we do not want to request more
2784 than it negotiated since it will refuse the read then */
2786 !(pTcon
->ses
->capabilities
& CAP_LARGE_FILES
)) {
2787 current_read_size
= min_t(uint
, current_read_size
,
2791 while (rc
== -EAGAIN
) {
2792 if (open_file
->invalidHandle
) {
2793 rc
= cifs_reopen_file(open_file
, true);
2797 io_parms
.netfid
= open_file
->netfid
;
2799 io_parms
.tcon
= pTcon
;
2800 io_parms
.offset
= *poffset
;
2801 io_parms
.length
= current_read_size
;
2802 rc
= CIFSSMBRead(xid
, &io_parms
, &bytes_read
,
2803 ¤t_offset
, &buf_type
);
2805 if (rc
|| (bytes_read
== 0)) {
2813 cifs_stats_bytes_read(pTcon
, total_read
);
2814 *poffset
+= bytes_read
;
2822 * If the page is mmap'ed into a process' page tables, then we need to make
2823 * sure that it doesn't change while being written back.
2826 cifs_page_mkwrite(struct vm_area_struct
*vma
, struct vm_fault
*vmf
)
2828 struct page
*page
= vmf
->page
;
2831 return VM_FAULT_LOCKED
;
2834 static struct vm_operations_struct cifs_file_vm_ops
= {
2835 .fault
= filemap_fault
,
2836 .page_mkwrite
= cifs_page_mkwrite
,
2839 int cifs_file_strict_mmap(struct file
*file
, struct vm_area_struct
*vma
)
2842 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
2846 if (!CIFS_I(inode
)->clientCanCacheRead
) {
2847 rc
= cifs_invalidate_mapping(inode
);
2852 rc
= generic_file_mmap(file
, vma
);
2854 vma
->vm_ops
= &cifs_file_vm_ops
;
2859 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
2864 rc
= cifs_revalidate_file(file
);
2866 cFYI(1, "Validation prior to mmap failed, error=%d", rc
);
2870 rc
= generic_file_mmap(file
, vma
);
2872 vma
->vm_ops
= &cifs_file_vm_ops
;
2878 cifs_readv_complete(struct work_struct
*work
)
2880 struct cifs_readdata
*rdata
= container_of(work
,
2881 struct cifs_readdata
, work
);
2882 struct page
*page
, *tpage
;
2884 list_for_each_entry_safe(page
, tpage
, &rdata
->pages
, lru
) {
2885 list_del(&page
->lru
);
2886 lru_cache_add_file(page
);
2888 if (rdata
->result
== 0) {
2890 flush_dcache_page(page
);
2891 SetPageUptodate(page
);
2896 if (rdata
->result
== 0)
2897 cifs_readpage_to_fscache(rdata
->mapping
->host
, page
);
2899 page_cache_release(page
);
2901 kref_put(&rdata
->refcount
, cifs_readdata_release
);
2905 cifs_readpages_marshal_iov(struct cifs_readdata
*rdata
, unsigned int remaining
)
2908 struct page
*page
, *tpage
;
2912 /* determine the eof that the server (probably) has */
2913 eof
= CIFS_I(rdata
->mapping
->host
)->server_eof
;
2914 eof_index
= eof
? (eof
- 1) >> PAGE_CACHE_SHIFT
: 0;
2915 cFYI(1, "eof=%llu eof_index=%lu", eof
, eof_index
);
2918 list_for_each_entry_safe(page
, tpage
, &rdata
->pages
, lru
) {
2919 if (remaining
>= PAGE_CACHE_SIZE
) {
2920 /* enough data to fill the page */
2921 rdata
->iov
[rdata
->nr_iov
].iov_base
= kmap(page
);
2922 rdata
->iov
[rdata
->nr_iov
].iov_len
= PAGE_CACHE_SIZE
;
2923 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2924 rdata
->nr_iov
, page
->index
,
2925 rdata
->iov
[rdata
->nr_iov
].iov_base
,
2926 rdata
->iov
[rdata
->nr_iov
].iov_len
);
2928 len
+= PAGE_CACHE_SIZE
;
2929 remaining
-= PAGE_CACHE_SIZE
;
2930 } else if (remaining
> 0) {
2931 /* enough for partial page, fill and zero the rest */
2932 rdata
->iov
[rdata
->nr_iov
].iov_base
= kmap(page
);
2933 rdata
->iov
[rdata
->nr_iov
].iov_len
= remaining
;
2934 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2935 rdata
->nr_iov
, page
->index
,
2936 rdata
->iov
[rdata
->nr_iov
].iov_base
,
2937 rdata
->iov
[rdata
->nr_iov
].iov_len
);
2938 memset(rdata
->iov
[rdata
->nr_iov
].iov_base
+ remaining
,
2939 '\0', PAGE_CACHE_SIZE
- remaining
);
2943 } else if (page
->index
> eof_index
) {
2945 * The VFS will not try to do readahead past the
2946 * i_size, but it's possible that we have outstanding
2947 * writes with gaps in the middle and the i_size hasn't
2948 * caught up yet. Populate those with zeroed out pages
2949 * to prevent the VFS from repeatedly attempting to
2950 * fill them until the writes are flushed.
2952 zero_user(page
, 0, PAGE_CACHE_SIZE
);
2953 list_del(&page
->lru
);
2954 lru_cache_add_file(page
);
2955 flush_dcache_page(page
);
2956 SetPageUptodate(page
);
2958 page_cache_release(page
);
2960 /* no need to hold page hostage */
2961 list_del(&page
->lru
);
2962 lru_cache_add_file(page
);
2964 page_cache_release(page
);
2971 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
2972 struct list_head
*page_list
, unsigned num_pages
)
2975 struct list_head tmplist
;
2976 struct cifsFileInfo
*open_file
= file
->private_data
;
2977 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
2978 unsigned int rsize
= cifs_sb
->rsize
;
2982 * Give up immediately if rsize is too small to read an entire page.
2983 * The VFS will fall back to readpage. We should never reach this
2984 * point however since we set ra_pages to 0 when the rsize is smaller
2985 * than a cache page.
2987 if (unlikely(rsize
< PAGE_CACHE_SIZE
))
2991 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2992 * immediately if the cookie is negative
2994 rc
= cifs_readpages_from_fscache(mapping
->host
, mapping
, page_list
,
2999 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_RWPIDFORWARD
)
3000 pid
= open_file
->pid
;
3002 pid
= current
->tgid
;
3005 INIT_LIST_HEAD(&tmplist
);
3007 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__
, file
,
3008 mapping
, num_pages
);
3011 * Start with the page at end of list and move it to private
3012 * list. Do the same with any following pages until we hit
3013 * the rsize limit, hit an index discontinuity, or run out of
3014 * pages. Issue the async read and then start the loop again
3015 * until the list is empty.
3017 * Note that list order is important. The page_list is in
3018 * the order of declining indexes. When we put the pages in
3019 * the rdata->pages, then we want them in increasing order.
3021 while (!list_empty(page_list
)) {
3022 unsigned int bytes
= PAGE_CACHE_SIZE
;
3023 unsigned int expected_index
;
3024 unsigned int nr_pages
= 1;
3026 struct page
*page
, *tpage
;
3027 struct cifs_readdata
*rdata
;
3029 page
= list_entry(page_list
->prev
, struct page
, lru
);
3032 * Lock the page and put it in the cache. Since no one else
3033 * should have access to this page, we're safe to simply set
3034 * PG_locked without checking it first.
3036 __set_page_locked(page
);
3037 rc
= add_to_page_cache_locked(page
, mapping
,
3038 page
->index
, GFP_KERNEL
);
3040 /* give up if we can't stick it in the cache */
3042 __clear_page_locked(page
);
3046 /* move first page to the tmplist */
3047 offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
3048 list_move_tail(&page
->lru
, &tmplist
);
3050 /* now try and add more pages onto the request */
3051 expected_index
= page
->index
+ 1;
3052 list_for_each_entry_safe_reverse(page
, tpage
, page_list
, lru
) {
3053 /* discontinuity ? */
3054 if (page
->index
!= expected_index
)
3057 /* would this page push the read over the rsize? */
3058 if (bytes
+ PAGE_CACHE_SIZE
> rsize
)
3061 __set_page_locked(page
);
3062 if (add_to_page_cache_locked(page
, mapping
,
3063 page
->index
, GFP_KERNEL
)) {
3064 __clear_page_locked(page
);
3067 list_move_tail(&page
->lru
, &tmplist
);
3068 bytes
+= PAGE_CACHE_SIZE
;
3073 rdata
= cifs_readdata_alloc(nr_pages
, cifs_readv_complete
);
3075 /* best to give up if we're out of mem */
3076 list_for_each_entry_safe(page
, tpage
, &tmplist
, lru
) {
3077 list_del(&page
->lru
);
3078 lru_cache_add_file(page
);
3080 page_cache_release(page
);
3086 spin_lock(&cifs_file_list_lock
);
3087 spin_unlock(&cifs_file_list_lock
);
3088 rdata
->cfile
= cifsFileInfo_get(open_file
);
3089 rdata
->mapping
= mapping
;
3090 rdata
->offset
= offset
;
3091 rdata
->bytes
= bytes
;
3093 rdata
->marshal_iov
= cifs_readpages_marshal_iov
;
3094 list_splice_init(&tmplist
, &rdata
->pages
);
3096 rc
= cifs_retry_async_readv(rdata
);
3098 list_for_each_entry_safe(page
, tpage
, &rdata
->pages
,
3100 list_del(&page
->lru
);
3101 lru_cache_add_file(page
);
3103 page_cache_release(page
);
3105 kref_put(&rdata
->refcount
, cifs_readdata_release
);
3109 kref_put(&rdata
->refcount
, cifs_readdata_release
);
3115 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
3121 /* Is the page cached? */
3122 rc
= cifs_readpage_from_fscache(file
->f_path
.dentry
->d_inode
, page
);
3126 page_cache_get(page
);
3127 read_data
= kmap(page
);
3128 /* for reads over a certain size could initiate async read ahead */
3130 rc
= cifs_read(file
, read_data
, PAGE_CACHE_SIZE
, poffset
);
3135 cFYI(1, "Bytes read %d", rc
);
3137 file
->f_path
.dentry
->d_inode
->i_atime
=
3138 current_fs_time(file
->f_path
.dentry
->d_inode
->i_sb
);
3140 if (PAGE_CACHE_SIZE
> rc
)
3141 memset(read_data
+ rc
, 0, PAGE_CACHE_SIZE
- rc
);
3143 flush_dcache_page(page
);
3144 SetPageUptodate(page
);
3146 /* send this page to the cache */
3147 cifs_readpage_to_fscache(file
->f_path
.dentry
->d_inode
, page
);
3153 page_cache_release(page
);
3159 static int cifs_readpage(struct file
*file
, struct page
*page
)
3161 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
3167 if (file
->private_data
== NULL
) {
3173 cFYI(1, "readpage %p at offset %d 0x%x",
3174 page
, (int)offset
, (int)offset
);
3176 rc
= cifs_readpage_worker(file
, page
, &offset
);
3184 static int is_inode_writable(struct cifsInodeInfo
*cifs_inode
)
3186 struct cifsFileInfo
*open_file
;
3188 spin_lock(&cifs_file_list_lock
);
3189 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
3190 if (OPEN_FMODE(open_file
->f_flags
) & FMODE_WRITE
) {
3191 spin_unlock(&cifs_file_list_lock
);
3195 spin_unlock(&cifs_file_list_lock
);
3199 /* We do not want to update the file size from server for inodes
3200 open for write - to avoid races with writepage extending
3201 the file - in the future we could consider allowing
3202 refreshing the inode only on increases in the file size
3203 but this is tricky to do without racing with writebehind
3204 page caching in the current Linux kernel design */
3205 bool is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
, __u64 end_of_file
)
3210 if (is_inode_writable(cifsInode
)) {
3211 /* This inode is open for write at least once */
3212 struct cifs_sb_info
*cifs_sb
;
3214 cifs_sb
= CIFS_SB(cifsInode
->vfs_inode
.i_sb
);
3215 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
3216 /* since no page cache to corrupt on directio
3217 we can change size safely */
3221 if (i_size_read(&cifsInode
->vfs_inode
) < end_of_file
)
3229 static int cifs_write_begin(struct file
*file
, struct address_space
*mapping
,
3230 loff_t pos
, unsigned len
, unsigned flags
,
3231 struct page
**pagep
, void **fsdata
)
3233 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
3234 loff_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
3235 loff_t page_start
= pos
& PAGE_MASK
;
3240 cFYI(1, "write_begin from %lld len %d", (long long)pos
, len
);
3242 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
3248 if (PageUptodate(page
))
3252 * If we write a full page it will be up to date, no need to read from
3253 * the server. If the write is short, we'll end up doing a sync write
3256 if (len
== PAGE_CACHE_SIZE
)
3260 * optimize away the read when we have an oplock, and we're not
3261 * expecting to use any of the data we'd be reading in. That
3262 * is, when the page lies beyond the EOF, or straddles the EOF
3263 * and the write will cover all of the existing data.
3265 if (CIFS_I(mapping
->host
)->clientCanCacheRead
) {
3266 i_size
= i_size_read(mapping
->host
);
3267 if (page_start
>= i_size
||
3268 (offset
== 0 && (pos
+ len
) >= i_size
)) {
3269 zero_user_segments(page
, 0, offset
,
3273 * PageChecked means that the parts of the page
3274 * to which we're not writing are considered up
3275 * to date. Once the data is copied to the
3276 * page, it can be set uptodate.
3278 SetPageChecked(page
);
3283 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
) {
3285 * might as well read a page, it is fast enough. If we get
3286 * an error, we don't need to return it. cifs_write_end will
3287 * do a sync write instead since PG_uptodate isn't set.
3289 cifs_readpage_worker(file
, page
, &page_start
);
3291 /* we could try using another file handle if there is one -
3292 but how would we lock it to prevent close of that handle
3293 racing with this read? In any case
3294 this will be written out by write_end so is fine */
3301 static int cifs_release_page(struct page
*page
, gfp_t gfp
)
3303 if (PagePrivate(page
))
3306 return cifs_fscache_release_page(page
, gfp
);
3309 static void cifs_invalidate_page(struct page
*page
, unsigned long offset
)
3311 struct cifsInodeInfo
*cifsi
= CIFS_I(page
->mapping
->host
);
3314 cifs_fscache_invalidate_page(page
, &cifsi
->vfs_inode
);
3317 static int cifs_launder_page(struct page
*page
)
3320 loff_t range_start
= page_offset(page
);
3321 loff_t range_end
= range_start
+ (loff_t
)(PAGE_CACHE_SIZE
- 1);
3322 struct writeback_control wbc
= {
3323 .sync_mode
= WB_SYNC_ALL
,
3325 .range_start
= range_start
,
3326 .range_end
= range_end
,
3329 cFYI(1, "Launder page: %p", page
);
3331 if (clear_page_dirty_for_io(page
))
3332 rc
= cifs_writepage_locked(page
, &wbc
);
3334 cifs_fscache_invalidate_page(page
, page
->mapping
->host
);
3338 void cifs_oplock_break(struct work_struct
*work
)
3340 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
3342 struct inode
*inode
= cfile
->dentry
->d_inode
;
3343 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
3346 if (inode
&& S_ISREG(inode
->i_mode
)) {
3347 if (cinode
->clientCanCacheRead
)
3348 break_lease(inode
, O_RDONLY
);
3350 break_lease(inode
, O_WRONLY
);
3351 rc
= filemap_fdatawrite(inode
->i_mapping
);
3352 if (cinode
->clientCanCacheRead
== 0) {
3353 rc
= filemap_fdatawait(inode
->i_mapping
);
3354 mapping_set_error(inode
->i_mapping
, rc
);
3355 invalidate_remote_inode(inode
);
3357 cFYI(1, "Oplock flush inode %p rc %d", inode
, rc
);
3360 rc
= cifs_push_locks(cfile
);
3362 cERROR(1, "Push locks rc = %d", rc
);
3365 * releasing stale oplock after recent reconnect of smb session using
3366 * a now incorrect file handle is not a data integrity issue but do
3367 * not bother sending an oplock release if session to server still is
3368 * disconnected since oplock already released by the server
3370 if (!cfile
->oplock_break_cancelled
) {
3371 rc
= CIFSSMBLock(0, tlink_tcon(cfile
->tlink
), cfile
->netfid
,
3372 current
->tgid
, 0, 0, 0, 0,
3373 LOCKING_ANDX_OPLOCK_RELEASE
, false,
3374 cinode
->clientCanCacheRead
? 1 : 0);
3375 cFYI(1, "Oplock release rc = %d", rc
);
3379 const struct address_space_operations cifs_addr_ops
= {
3380 .readpage
= cifs_readpage
,
3381 .readpages
= cifs_readpages
,
3382 .writepage
= cifs_writepage
,
3383 .writepages
= cifs_writepages
,
3384 .write_begin
= cifs_write_begin
,
3385 .write_end
= cifs_write_end
,
3386 .set_page_dirty
= __set_page_dirty_nobuffers
,
3387 .releasepage
= cifs_release_page
,
3388 .invalidatepage
= cifs_invalidate_page
,
3389 .launder_page
= cifs_launder_page
,
3393 * cifs_readpages requires the server to support a buffer large enough to
3394 * contain the header plus one complete page of data. Otherwise, we need
3395 * to leave cifs_readpages out of the address space operations.
3397 const struct address_space_operations cifs_addr_ops_smallbuf
= {
3398 .readpage
= cifs_readpage
,
3399 .writepage
= cifs_writepage
,
3400 .writepages
= cifs_writepages
,
3401 .write_begin
= cifs_write_begin
,
3402 .write_end
= cifs_write_end
,
3403 .set_page_dirty
= __set_page_dirty_nobuffers
,
3404 .releasepage
= cifs_release_page
,
3405 .invalidatepage
= cifs_invalidate_page
,
3406 .launder_page
= cifs_launder_page
,