4 * vfs operations that deal with files
6 * Copyright (C) International Business Machines Corp., 2002,2007
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 <asm/div64.h>
38 #include "cifsproto.h"
39 #include "cifs_unicode.h"
40 #include "cifs_debug.h"
41 #include "cifs_fs_sb.h"
43 static inline int cifs_convert_flags(unsigned int flags
)
45 if ((flags
& O_ACCMODE
) == O_RDONLY
)
47 else if ((flags
& O_ACCMODE
) == O_WRONLY
)
49 else if ((flags
& O_ACCMODE
) == O_RDWR
) {
50 /* GENERIC_ALL is too much permission to request
51 can cause unnecessary access denied on create */
52 /* return GENERIC_ALL; */
53 return (GENERIC_READ
| GENERIC_WRITE
);
56 return (READ_CONTROL
| FILE_WRITE_ATTRIBUTES
| FILE_READ_ATTRIBUTES
|
57 FILE_WRITE_EA
| FILE_APPEND_DATA
| FILE_WRITE_DATA
|
61 static inline fmode_t
cifs_posix_convert_flags(unsigned int flags
)
63 fmode_t posix_flags
= 0;
65 if ((flags
& O_ACCMODE
) == O_RDONLY
)
66 posix_flags
= FMODE_READ
;
67 else if ((flags
& O_ACCMODE
) == O_WRONLY
)
68 posix_flags
= FMODE_WRITE
;
69 else if ((flags
& O_ACCMODE
) == O_RDWR
) {
70 /* GENERIC_ALL is too much permission to request
71 can cause unnecessary access denied on create */
72 /* return GENERIC_ALL; */
73 posix_flags
= FMODE_READ
| FMODE_WRITE
;
75 /* can not map O_CREAT or O_EXCL or O_TRUNC flags when
76 reopening a file. They had their effect on the original open */
78 posix_flags
|= (fmode_t
)O_APPEND
;
80 posix_flags
|= (fmode_t
)O_DSYNC
;
82 posix_flags
|= (fmode_t
)__O_SYNC
;
83 if (flags
& O_DIRECTORY
)
84 posix_flags
|= (fmode_t
)O_DIRECTORY
;
85 if (flags
& O_NOFOLLOW
)
86 posix_flags
|= (fmode_t
)O_NOFOLLOW
;
88 posix_flags
|= (fmode_t
)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 /* all arguments to this function must be checked for validity in caller */
109 cifs_posix_open_inode_helper(struct inode
*inode
, struct file
*file
,
110 struct cifsInodeInfo
*pCifsInode
,
111 struct cifsFileInfo
*pCifsFile
, __u32 oplock
,
115 write_lock(&GlobalSMBSeslock
);
117 pCifsInode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
118 if (pCifsInode
== NULL
) {
119 write_unlock(&GlobalSMBSeslock
);
123 if (pCifsInode
->clientCanCacheRead
) {
124 /* we have the inode open somewhere else
125 no need to discard cache data */
126 goto psx_client_can_cache
;
129 /* BB FIXME need to fix this check to move it earlier into posix_open
130 BB fIX following section BB FIXME */
132 /* if not oplocked, invalidate inode pages if mtime or file
134 /* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
135 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
136 (file->f_path.dentry->d_inode->i_size ==
137 (loff_t)le64_to_cpu(buf->EndOfFile))) {
138 cFYI(1, ("inode unchanged on server"));
140 if (file->f_path.dentry->d_inode->i_mapping) {
141 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
143 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
145 cFYI(1, ("invalidating remote inode since open detected it "
147 invalidate_remote_inode(file->f_path.dentry->d_inode);
150 psx_client_can_cache
:
151 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
152 pCifsInode
->clientCanCacheAll
= true;
153 pCifsInode
->clientCanCacheRead
= true;
154 cFYI(1, ("Exclusive Oplock granted on inode %p",
155 file
->f_path
.dentry
->d_inode
));
156 } else if ((oplock
& 0xF) == OPLOCK_READ
)
157 pCifsInode
->clientCanCacheRead
= true;
159 /* will have to change the unlock if we reenable the
160 filemap_fdatawrite (which does not seem necessary */
161 write_unlock(&GlobalSMBSeslock
);
165 static struct cifsFileInfo
*
166 cifs_fill_filedata(struct file
*file
)
168 struct list_head
*tmp
;
169 struct cifsFileInfo
*pCifsFile
= NULL
;
170 struct cifsInodeInfo
*pCifsInode
= NULL
;
172 /* search inode for this file and fill in file->private_data */
173 pCifsInode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
174 read_lock(&GlobalSMBSeslock
);
175 list_for_each(tmp
, &pCifsInode
->openFileList
) {
176 pCifsFile
= list_entry(tmp
, struct cifsFileInfo
, flist
);
177 if ((pCifsFile
->pfile
== NULL
) &&
178 (pCifsFile
->pid
== current
->tgid
)) {
179 /* mode set in cifs_create */
181 /* needed for writepage */
182 pCifsFile
->pfile
= file
;
183 file
->private_data
= pCifsFile
;
187 read_unlock(&GlobalSMBSeslock
);
189 if (file
->private_data
!= NULL
) {
191 } else if ((file
->f_flags
& O_CREAT
) && (file
->f_flags
& O_EXCL
))
192 cERROR(1, ("could not find file instance for "
193 "new file %p", file
));
197 /* all arguments to this function must be checked for validity in caller */
198 static inline int cifs_open_inode_helper(struct inode
*inode
, struct file
*file
,
199 struct cifsInodeInfo
*pCifsInode
, struct cifsFileInfo
*pCifsFile
,
200 struct cifsTconInfo
*pTcon
, int *oplock
, FILE_ALL_INFO
*buf
,
201 char *full_path
, int xid
)
203 struct timespec temp
;
206 if (pCifsInode
->clientCanCacheRead
) {
207 /* we have the inode open somewhere else
208 no need to discard cache data */
209 goto client_can_cache
;
212 /* BB need same check in cifs_create too? */
213 /* if not oplocked, invalidate inode pages if mtime or file
215 temp
= cifs_NTtimeToUnix(buf
->LastWriteTime
);
216 if (timespec_equal(&file
->f_path
.dentry
->d_inode
->i_mtime
, &temp
) &&
217 (file
->f_path
.dentry
->d_inode
->i_size
==
218 (loff_t
)le64_to_cpu(buf
->EndOfFile
))) {
219 cFYI(1, ("inode unchanged on server"));
221 if (file
->f_path
.dentry
->d_inode
->i_mapping
) {
222 /* BB no need to lock inode until after invalidate
223 since namei code should already have it locked? */
224 rc
= filemap_write_and_wait(file
->f_path
.dentry
->d_inode
->i_mapping
);
226 CIFS_I(file
->f_path
.dentry
->d_inode
)->write_behind_rc
= rc
;
228 cFYI(1, ("invalidating remote inode since open detected it "
230 invalidate_remote_inode(file
->f_path
.dentry
->d_inode
);
235 rc
= cifs_get_inode_info_unix(&file
->f_path
.dentry
->d_inode
,
236 full_path
, inode
->i_sb
, xid
);
238 rc
= cifs_get_inode_info(&file
->f_path
.dentry
->d_inode
,
239 full_path
, buf
, inode
->i_sb
, xid
, NULL
);
241 if ((*oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
242 pCifsInode
->clientCanCacheAll
= true;
243 pCifsInode
->clientCanCacheRead
= true;
244 cFYI(1, ("Exclusive Oplock granted on inode %p",
245 file
->f_path
.dentry
->d_inode
));
246 } else if ((*oplock
& 0xF) == OPLOCK_READ
)
247 pCifsInode
->clientCanCacheRead
= true;
252 int cifs_open(struct inode
*inode
, struct file
*file
)
257 struct cifs_sb_info
*cifs_sb
;
258 struct cifsTconInfo
*tcon
;
259 struct cifsFileInfo
*pCifsFile
;
260 struct cifsInodeInfo
*pCifsInode
;
261 char *full_path
= NULL
;
265 FILE_ALL_INFO
*buf
= NULL
;
269 cifs_sb
= CIFS_SB(inode
->i_sb
);
270 tcon
= cifs_sb
->tcon
;
272 pCifsInode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
273 pCifsFile
= cifs_fill_filedata(file
);
280 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
281 if (full_path
== NULL
) {
287 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
288 inode
, file
->f_flags
, full_path
));
295 if (!tcon
->broken_posix_open
&& tcon
->unix_ext
&&
296 (tcon
->ses
->capabilities
& CAP_UNIX
) &&
297 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
298 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
299 int oflags
= (int) cifs_posix_convert_flags(file
->f_flags
);
300 oflags
|= SMB_O_CREAT
;
301 /* can not refresh inode info since size could be stale */
302 rc
= cifs_posix_open(full_path
, &inode
, file
->f_path
.mnt
,
304 cifs_sb
->mnt_file_mode
/* ignored */,
305 oflags
, &oplock
, &netfid
, xid
);
307 cFYI(1, ("posix open succeeded"));
308 /* no need for special case handling of setting mode
309 on read only files needed here */
311 pCifsFile
= cifs_fill_filedata(file
);
312 cifs_posix_open_inode_helper(inode
, file
, pCifsInode
,
313 pCifsFile
, oplock
, netfid
);
315 } else if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
316 if (tcon
->ses
->serverNOS
)
317 cERROR(1, ("server %s of type %s returned"
318 " unexpected error on SMB posix open"
319 ", disabling posix open support."
320 " Check if server update available.",
321 tcon
->ses
->serverName
,
322 tcon
->ses
->serverNOS
));
323 tcon
->broken_posix_open
= true;
324 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
325 (rc
!= -EOPNOTSUPP
)) /* path not found or net err */
327 /* else fallthrough to retry open the old way on network i/o
331 desiredAccess
= cifs_convert_flags(file
->f_flags
);
333 /*********************************************************************
334 * open flag mapping table:
336 * POSIX Flag CIFS Disposition
337 * ---------- ----------------
338 * O_CREAT FILE_OPEN_IF
339 * O_CREAT | O_EXCL FILE_CREATE
340 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
341 * O_TRUNC FILE_OVERWRITE
342 * none of the above FILE_OPEN
344 * Note that there is not a direct match between disposition
345 * FILE_SUPERSEDE (ie create whether or not file exists although
346 * O_CREAT | O_TRUNC is similar but truncates the existing
347 * file rather than creating a new file as FILE_SUPERSEDE does
348 * (which uses the attributes / metadata passed in on open call)
350 *? O_SYNC is a reasonable match to CIFS writethrough flag
351 *? and the read write flags match reasonably. O_LARGEFILE
352 *? is irrelevant because largefile support is always used
353 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
354 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
355 *********************************************************************/
357 disposition
= cifs_get_disposition(file
->f_flags
);
359 /* BB pass O_SYNC flag through on file attributes .. BB */
361 /* Also refresh inode by passing in file_info buf returned by SMBOpen
362 and calling get_inode_info with returned buf (at least helps
363 non-Unix server case) */
365 /* BB we can not do this if this is the second open of a file
366 and the first handle has writebehind data, we might be
367 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
368 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
374 if (cifs_sb
->tcon
->ses
->capabilities
& CAP_NT_SMBS
)
375 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
376 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
377 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
378 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
380 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
383 /* Old server, try legacy style OpenX */
384 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
385 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
386 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
387 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
390 cFYI(1, ("cifs_open returned 0x%x", rc
));
394 pCifsFile
= cifs_new_fileinfo(inode
, netfid
, file
, file
->f_path
.mnt
,
396 file
->private_data
= pCifsFile
;
397 if (file
->private_data
== NULL
) {
402 rc
= cifs_open_inode_helper(inode
, file
, pCifsInode
, pCifsFile
, tcon
,
403 &oplock
, buf
, full_path
, xid
);
405 if (oplock
& CIFS_CREATE_ACTION
) {
406 /* time to set mode which we can not set earlier due to
407 problems creating new read-only files */
408 if (tcon
->unix_ext
) {
409 struct cifs_unix_set_info_args args
= {
410 .mode
= inode
->i_mode
,
413 .ctime
= NO_CHANGE_64
,
414 .atime
= NO_CHANGE_64
,
415 .mtime
= NO_CHANGE_64
,
418 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
420 cifs_sb
->mnt_cifs_flags
&
421 CIFS_MOUNT_MAP_SPECIAL_CHR
);
432 /* Try to reacquire byte range locks that were released when session */
433 /* to server was lost */
434 static int cifs_relock_file(struct cifsFileInfo
*cifsFile
)
438 /* BB list all locks open on this file and relock */
443 static int cifs_reopen_file(struct file
*file
, bool can_flush
)
448 struct cifs_sb_info
*cifs_sb
;
449 struct cifsTconInfo
*tcon
;
450 struct cifsFileInfo
*pCifsFile
;
451 struct cifsInodeInfo
*pCifsInode
;
453 char *full_path
= NULL
;
455 int disposition
= FILE_OPEN
;
458 if (file
->private_data
)
459 pCifsFile
= (struct cifsFileInfo
*)file
->private_data
;
464 mutex_lock(&pCifsFile
->fh_mutex
);
465 if (!pCifsFile
->invalidHandle
) {
466 mutex_unlock(&pCifsFile
->fh_mutex
);
472 if (file
->f_path
.dentry
== NULL
) {
473 cERROR(1, ("no valid name if dentry freed"));
476 goto reopen_error_exit
;
479 inode
= file
->f_path
.dentry
->d_inode
;
481 cERROR(1, ("inode not valid"));
484 goto reopen_error_exit
;
487 cifs_sb
= CIFS_SB(inode
->i_sb
);
488 tcon
= cifs_sb
->tcon
;
490 /* can not grab rename sem here because various ops, including
491 those that already have the rename sem can end up causing writepage
492 to get called and if the server was down that means we end up here,
493 and we can never tell if the caller already has the rename_sem */
494 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
495 if (full_path
== NULL
) {
498 mutex_unlock(&pCifsFile
->fh_mutex
);
503 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
504 inode
, file
->f_flags
, full_path
));
511 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
512 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
513 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
514 int oflags
= (int) cifs_posix_convert_flags(file
->f_flags
);
515 /* can not refresh inode info since size could be stale */
516 rc
= cifs_posix_open(full_path
, NULL
, file
->f_path
.mnt
,
518 cifs_sb
->mnt_file_mode
/* ignored */,
519 oflags
, &oplock
, &netfid
, xid
);
521 cFYI(1, ("posix reopen succeeded"));
524 /* fallthrough to retry open the old way on errors, especially
525 in the reconnect path it is important to retry hard */
528 desiredAccess
= cifs_convert_flags(file
->f_flags
);
530 /* Can not refresh inode by passing in file_info buf to be returned
531 by SMBOpen and then calling get_inode_info with returned buf
532 since file might have write behind data that needs to be flushed
533 and server version of file size can be stale. If we knew for sure
534 that inode was not dirty locally we could do this */
536 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
, desiredAccess
,
537 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
538 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
539 CIFS_MOUNT_MAP_SPECIAL_CHR
);
541 mutex_unlock(&pCifsFile
->fh_mutex
);
542 cFYI(1, ("cifs_open returned 0x%x", rc
));
543 cFYI(1, ("oplock: %d", oplock
));
546 pCifsFile
->netfid
= netfid
;
547 pCifsFile
->invalidHandle
= false;
548 mutex_unlock(&pCifsFile
->fh_mutex
);
549 pCifsInode
= CIFS_I(inode
);
552 rc
= filemap_write_and_wait(inode
->i_mapping
);
554 CIFS_I(inode
)->write_behind_rc
= rc
;
555 /* temporarily disable caching while we
556 go to server to get inode info */
557 pCifsInode
->clientCanCacheAll
= false;
558 pCifsInode
->clientCanCacheRead
= false;
560 rc
= cifs_get_inode_info_unix(&inode
,
561 full_path
, inode
->i_sb
, xid
);
563 rc
= cifs_get_inode_info(&inode
,
564 full_path
, NULL
, inode
->i_sb
,
566 } /* else we are writing out data to server already
567 and could deadlock if we tried to flush data, and
568 since we do not know if we have data that would
569 invalidate the current end of file on the server
570 we can not go to the server to get the new inod
572 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
573 pCifsInode
->clientCanCacheAll
= true;
574 pCifsInode
->clientCanCacheRead
= true;
575 cFYI(1, ("Exclusive Oplock granted on inode %p",
576 file
->f_path
.dentry
->d_inode
));
577 } else if ((oplock
& 0xF) == OPLOCK_READ
) {
578 pCifsInode
->clientCanCacheRead
= true;
579 pCifsInode
->clientCanCacheAll
= false;
581 pCifsInode
->clientCanCacheRead
= false;
582 pCifsInode
->clientCanCacheAll
= false;
584 cifs_relock_file(pCifsFile
);
592 int cifs_close(struct inode
*inode
, struct file
*file
)
596 struct cifs_sb_info
*cifs_sb
;
597 struct cifsTconInfo
*pTcon
;
598 struct cifsFileInfo
*pSMBFile
=
599 (struct cifsFileInfo
*)file
->private_data
;
603 cifs_sb
= CIFS_SB(inode
->i_sb
);
604 pTcon
= cifs_sb
->tcon
;
606 struct cifsLockInfo
*li
, *tmp
;
607 write_lock(&GlobalSMBSeslock
);
608 pSMBFile
->closePend
= true;
610 /* no sense reconnecting to close a file that is
612 if (!pTcon
->need_reconnect
) {
613 write_unlock(&GlobalSMBSeslock
);
615 while ((atomic_read(&pSMBFile
->count
) != 1)
616 && (timeout
<= 2048)) {
617 /* Give write a better chance to get to
618 server ahead of the close. We do not
619 want to add a wait_q here as it would
620 increase the memory utilization as
621 the struct would be in each open file,
622 but this should give enough time to
625 ("close delay, write pending"));
629 if (!pTcon
->need_reconnect
&&
630 !pSMBFile
->invalidHandle
)
631 rc
= CIFSSMBClose(xid
, pTcon
,
634 write_unlock(&GlobalSMBSeslock
);
636 write_unlock(&GlobalSMBSeslock
);
638 /* Delete any outstanding lock records.
639 We'll lose them when the file is closed anyway. */
640 mutex_lock(&pSMBFile
->lock_mutex
);
641 list_for_each_entry_safe(li
, tmp
, &pSMBFile
->llist
, llist
) {
642 list_del(&li
->llist
);
645 mutex_unlock(&pSMBFile
->lock_mutex
);
647 write_lock(&GlobalSMBSeslock
);
648 list_del(&pSMBFile
->flist
);
649 list_del(&pSMBFile
->tlist
);
650 write_unlock(&GlobalSMBSeslock
);
651 cifsFileInfo_put(file
->private_data
);
652 file
->private_data
= NULL
;
656 read_lock(&GlobalSMBSeslock
);
657 if (list_empty(&(CIFS_I(inode
)->openFileList
))) {
658 cFYI(1, ("closing last open instance for inode %p", inode
));
659 /* if the file is not open we do not know if we can cache info
660 on this inode, much less write behind and read ahead */
661 CIFS_I(inode
)->clientCanCacheRead
= false;
662 CIFS_I(inode
)->clientCanCacheAll
= false;
664 read_unlock(&GlobalSMBSeslock
);
665 if ((rc
== 0) && CIFS_I(inode
)->write_behind_rc
)
666 rc
= CIFS_I(inode
)->write_behind_rc
;
671 int cifs_closedir(struct inode
*inode
, struct file
*file
)
675 struct cifsFileInfo
*pCFileStruct
=
676 (struct cifsFileInfo
*)file
->private_data
;
679 cFYI(1, ("Closedir inode = 0x%p", inode
));
684 struct cifsTconInfo
*pTcon
;
685 struct cifs_sb_info
*cifs_sb
=
686 CIFS_SB(file
->f_path
.dentry
->d_sb
);
688 pTcon
= cifs_sb
->tcon
;
690 cFYI(1, ("Freeing private data in close dir"));
691 write_lock(&GlobalSMBSeslock
);
692 if (!pCFileStruct
->srch_inf
.endOfSearch
&&
693 !pCFileStruct
->invalidHandle
) {
694 pCFileStruct
->invalidHandle
= true;
695 write_unlock(&GlobalSMBSeslock
);
696 rc
= CIFSFindClose(xid
, pTcon
, pCFileStruct
->netfid
);
697 cFYI(1, ("Closing uncompleted readdir with rc %d",
699 /* not much we can do if it fails anyway, ignore rc */
702 write_unlock(&GlobalSMBSeslock
);
703 ptmp
= pCFileStruct
->srch_inf
.ntwrk_buf_start
;
705 cFYI(1, ("closedir free smb buf in srch struct"));
706 pCFileStruct
->srch_inf
.ntwrk_buf_start
= NULL
;
707 if (pCFileStruct
->srch_inf
.smallBuf
)
708 cifs_small_buf_release(ptmp
);
710 cifs_buf_release(ptmp
);
712 kfree(file
->private_data
);
713 file
->private_data
= NULL
;
715 /* BB can we lock the filestruct while this is going on? */
720 static int store_file_lock(struct cifsFileInfo
*fid
, __u64 len
,
721 __u64 offset
, __u8 lockType
)
723 struct cifsLockInfo
*li
=
724 kmalloc(sizeof(struct cifsLockInfo
), GFP_KERNEL
);
730 mutex_lock(&fid
->lock_mutex
);
731 list_add(&li
->llist
, &fid
->llist
);
732 mutex_unlock(&fid
->lock_mutex
);
736 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*pfLock
)
742 bool wait_flag
= false;
743 struct cifs_sb_info
*cifs_sb
;
744 struct cifsTconInfo
*tcon
;
746 __u8 lockType
= LOCKING_ANDX_LARGE_FILES
;
747 bool posix_locking
= 0;
749 length
= 1 + pfLock
->fl_end
- pfLock
->fl_start
;
753 cFYI(1, ("Lock parm: 0x%x flockflags: "
754 "0x%x flocktype: 0x%x start: %lld end: %lld",
755 cmd
, pfLock
->fl_flags
, pfLock
->fl_type
, pfLock
->fl_start
,
758 if (pfLock
->fl_flags
& FL_POSIX
)
760 if (pfLock
->fl_flags
& FL_FLOCK
)
762 if (pfLock
->fl_flags
& FL_SLEEP
) {
763 cFYI(1, ("Blocking lock"));
766 if (pfLock
->fl_flags
& FL_ACCESS
)
767 cFYI(1, ("Process suspended by mandatory locking - "
768 "not implemented yet"));
769 if (pfLock
->fl_flags
& FL_LEASE
)
770 cFYI(1, ("Lease on file - not implemented yet"));
771 if (pfLock
->fl_flags
&
772 (~(FL_POSIX
| FL_FLOCK
| FL_SLEEP
| FL_ACCESS
| FL_LEASE
)))
773 cFYI(1, ("Unknown lock flags 0x%x", pfLock
->fl_flags
));
775 if (pfLock
->fl_type
== F_WRLCK
) {
776 cFYI(1, ("F_WRLCK "));
778 } else if (pfLock
->fl_type
== F_UNLCK
) {
779 cFYI(1, ("F_UNLCK"));
781 /* Check if unlock includes more than
783 } else if (pfLock
->fl_type
== F_RDLCK
) {
784 cFYI(1, ("F_RDLCK"));
785 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
787 } else if (pfLock
->fl_type
== F_EXLCK
) {
788 cFYI(1, ("F_EXLCK"));
790 } else if (pfLock
->fl_type
== F_SHLCK
) {
791 cFYI(1, ("F_SHLCK"));
792 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
795 cFYI(1, ("Unknown type of lock"));
797 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
798 tcon
= cifs_sb
->tcon
;
800 if (file
->private_data
== NULL
) {
805 netfid
= ((struct cifsFileInfo
*)file
->private_data
)->netfid
;
807 if ((tcon
->ses
->capabilities
& CAP_UNIX
) &&
808 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
809 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
811 /* BB add code here to normalize offset and length to
812 account for negative length which we can not accept over the
817 if (lockType
& LOCKING_ANDX_SHARED_LOCK
)
818 posix_lock_type
= CIFS_RDLCK
;
820 posix_lock_type
= CIFS_WRLCK
;
821 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, 1 /* get */,
823 posix_lock_type
, wait_flag
);
828 /* BB we could chain these into one lock request BB */
829 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
, pfLock
->fl_start
,
830 0, 1, lockType
, 0 /* wait flag */, 0);
832 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
833 pfLock
->fl_start
, 1 /* numUnlock */ ,
834 0 /* numLock */ , lockType
,
835 0 /* wait flag */, 0);
836 pfLock
->fl_type
= F_UNLCK
;
838 cERROR(1, ("Error unlocking previously locked "
839 "range %d during test of lock", rc
));
843 /* if rc == ERR_SHARING_VIOLATION ? */
844 rc
= 0; /* do not change lock type to unlock
845 since range in use */
852 if (!numLock
&& !numUnlock
) {
853 /* if no lock or unlock then nothing
854 to do since we do not know what it is */
861 if (lockType
& LOCKING_ANDX_SHARED_LOCK
)
862 posix_lock_type
= CIFS_RDLCK
;
864 posix_lock_type
= CIFS_WRLCK
;
867 posix_lock_type
= CIFS_UNLCK
;
869 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, 0 /* set */,
871 posix_lock_type
, wait_flag
);
873 struct cifsFileInfo
*fid
=
874 (struct cifsFileInfo
*)file
->private_data
;
877 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
878 pfLock
->fl_start
, 0, numLock
, lockType
,
882 /* For Windows locks we must store them. */
883 rc
= store_file_lock(fid
, length
,
884 pfLock
->fl_start
, lockType
);
886 } else if (numUnlock
) {
887 /* For each stored lock that this unlock overlaps
888 completely, unlock it. */
890 struct cifsLockInfo
*li
, *tmp
;
893 mutex_lock(&fid
->lock_mutex
);
894 list_for_each_entry_safe(li
, tmp
, &fid
->llist
, llist
) {
895 if (pfLock
->fl_start
<= li
->offset
&&
896 (pfLock
->fl_start
+ length
) >=
897 (li
->offset
+ li
->length
)) {
898 stored_rc
= CIFSSMBLock(xid
, tcon
,
905 list_del(&li
->llist
);
909 mutex_unlock(&fid
->lock_mutex
);
913 if (pfLock
->fl_flags
& FL_POSIX
)
914 posix_lock_file_wait(file
, pfLock
);
920 * Set the timeout on write requests past EOF. For some servers (Windows)
921 * these calls can be very long.
923 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
924 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
925 * The 10M cutoff is totally arbitrary. A better scheme for this would be
926 * welcome if someone wants to suggest one.
928 * We may be able to do a better job with this if there were some way to
929 * declare that a file should be sparse.
932 cifs_write_timeout(struct cifsInodeInfo
*cifsi
, loff_t offset
)
934 if (offset
<= cifsi
->server_eof
)
936 else if (offset
> (cifsi
->server_eof
+ (10 * 1024 * 1024)))
937 return CIFS_VLONG_OP
;
942 /* update the file size (if needed) after a write */
944 cifs_update_eof(struct cifsInodeInfo
*cifsi
, loff_t offset
,
945 unsigned int bytes_written
)
947 loff_t end_of_write
= offset
+ bytes_written
;
949 if (end_of_write
> cifsi
->server_eof
)
950 cifsi
->server_eof
= end_of_write
;
953 ssize_t
cifs_user_write(struct file
*file
, const char __user
*write_data
,
954 size_t write_size
, loff_t
*poffset
)
957 unsigned int bytes_written
= 0;
958 unsigned int total_written
;
959 struct cifs_sb_info
*cifs_sb
;
960 struct cifsTconInfo
*pTcon
;
962 struct cifsFileInfo
*open_file
;
963 struct cifsInodeInfo
*cifsi
= CIFS_I(file
->f_path
.dentry
->d_inode
);
965 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
967 pTcon
= cifs_sb
->tcon
;
970 (" write %d bytes to offset %lld of %s", write_size,
971 *poffset, file->f_path.dentry->d_name.name)); */
973 if (file
->private_data
== NULL
)
975 open_file
= (struct cifsFileInfo
*) file
->private_data
;
977 rc
= generic_write_checks(file
, poffset
, &write_size
, 0);
983 long_op
= cifs_write_timeout(cifsi
, *poffset
);
984 for (total_written
= 0; write_size
> total_written
;
985 total_written
+= bytes_written
) {
987 while (rc
== -EAGAIN
) {
988 if (file
->private_data
== NULL
) {
989 /* file has been closed on us */
991 /* if we have gotten here we have written some data
992 and blocked, and the file has been freed on us while
993 we blocked so return what we managed to write */
994 return total_written
;
996 if (open_file
->closePend
) {
999 return total_written
;
1003 if (open_file
->invalidHandle
) {
1004 /* we could deadlock if we called
1005 filemap_fdatawait from here so tell
1006 reopen_file not to flush data to server
1008 rc
= cifs_reopen_file(file
, false);
1013 rc
= CIFSSMBWrite(xid
, pTcon
,
1015 min_t(const int, cifs_sb
->wsize
,
1016 write_size
- total_written
),
1017 *poffset
, &bytes_written
,
1018 NULL
, write_data
+ total_written
, long_op
);
1020 if (rc
|| (bytes_written
== 0)) {
1028 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1029 *poffset
+= bytes_written
;
1031 long_op
= CIFS_STD_OP
; /* subsequent writes fast -
1032 15 seconds is plenty */
1035 cifs_stats_bytes_written(pTcon
, total_written
);
1037 /* since the write may have blocked check these pointers again */
1038 if ((file
->f_path
.dentry
) && (file
->f_path
.dentry
->d_inode
)) {
1039 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1040 /* Do not update local mtime - server will set its actual value on write
1041 * inode->i_ctime = inode->i_mtime =
1042 * current_fs_time(inode->i_sb);*/
1043 if (total_written
> 0) {
1044 spin_lock(&inode
->i_lock
);
1045 if (*poffset
> file
->f_path
.dentry
->d_inode
->i_size
)
1046 i_size_write(file
->f_path
.dentry
->d_inode
,
1048 spin_unlock(&inode
->i_lock
);
1050 mark_inode_dirty_sync(file
->f_path
.dentry
->d_inode
);
1053 return total_written
;
1056 static ssize_t
cifs_write(struct file
*file
, const char *write_data
,
1057 size_t write_size
, loff_t
*poffset
)
1060 unsigned int bytes_written
= 0;
1061 unsigned int total_written
;
1062 struct cifs_sb_info
*cifs_sb
;
1063 struct cifsTconInfo
*pTcon
;
1065 struct cifsFileInfo
*open_file
;
1066 struct cifsInodeInfo
*cifsi
= CIFS_I(file
->f_path
.dentry
->d_inode
);
1068 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1070 pTcon
= cifs_sb
->tcon
;
1072 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size
,
1073 *poffset
, file
->f_path
.dentry
->d_name
.name
));
1075 if (file
->private_data
== NULL
)
1077 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1081 long_op
= cifs_write_timeout(cifsi
, *poffset
);
1082 for (total_written
= 0; write_size
> total_written
;
1083 total_written
+= bytes_written
) {
1085 while (rc
== -EAGAIN
) {
1086 if (file
->private_data
== NULL
) {
1087 /* file has been closed on us */
1089 /* if we have gotten here we have written some data
1090 and blocked, and the file has been freed on us
1091 while we blocked so return what we managed to
1093 return total_written
;
1095 if (open_file
->closePend
) {
1098 return total_written
;
1102 if (open_file
->invalidHandle
) {
1103 /* we could deadlock if we called
1104 filemap_fdatawait from here so tell
1105 reopen_file not to flush data to
1107 rc
= cifs_reopen_file(file
, false);
1111 if (experimEnabled
|| (pTcon
->ses
->server
&&
1112 ((pTcon
->ses
->server
->secMode
&
1113 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
1118 len
= min((size_t)cifs_sb
->wsize
,
1119 write_size
- total_written
);
1120 /* iov[0] is reserved for smb header */
1121 iov
[1].iov_base
= (char *)write_data
+
1123 iov
[1].iov_len
= len
;
1124 rc
= CIFSSMBWrite2(xid
, pTcon
,
1125 open_file
->netfid
, len
,
1126 *poffset
, &bytes_written
,
1129 rc
= CIFSSMBWrite(xid
, pTcon
,
1131 min_t(const int, cifs_sb
->wsize
,
1132 write_size
- total_written
),
1133 *poffset
, &bytes_written
,
1134 write_data
+ total_written
,
1137 if (rc
|| (bytes_written
== 0)) {
1145 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1146 *poffset
+= bytes_written
;
1148 long_op
= CIFS_STD_OP
; /* subsequent writes fast -
1149 15 seconds is plenty */
1152 cifs_stats_bytes_written(pTcon
, total_written
);
1154 /* since the write may have blocked check these pointers again */
1155 if ((file
->f_path
.dentry
) && (file
->f_path
.dentry
->d_inode
)) {
1156 /*BB We could make this contingent on superblock ATIME flag too */
1157 /* file->f_path.dentry->d_inode->i_ctime =
1158 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1159 if (total_written
> 0) {
1160 spin_lock(&file
->f_path
.dentry
->d_inode
->i_lock
);
1161 if (*poffset
> file
->f_path
.dentry
->d_inode
->i_size
)
1162 i_size_write(file
->f_path
.dentry
->d_inode
,
1164 spin_unlock(&file
->f_path
.dentry
->d_inode
->i_lock
);
1166 mark_inode_dirty_sync(file
->f_path
.dentry
->d_inode
);
1169 return total_written
;
1172 #ifdef CONFIG_CIFS_EXPERIMENTAL
1173 struct cifsFileInfo
*find_readable_file(struct cifsInodeInfo
*cifs_inode
)
1175 struct cifsFileInfo
*open_file
= NULL
;
1177 read_lock(&GlobalSMBSeslock
);
1178 /* we could simply get the first_list_entry since write-only entries
1179 are always at the end of the list but since the first entry might
1180 have a close pending, we go through the whole list */
1181 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1182 if (open_file
->closePend
)
1184 if (open_file
->pfile
&& ((open_file
->pfile
->f_flags
& O_RDWR
) ||
1185 (open_file
->pfile
->f_flags
& O_RDONLY
))) {
1186 if (!open_file
->invalidHandle
) {
1187 /* found a good file */
1188 /* lock it so it will not be closed on us */
1189 cifsFileInfo_get(open_file
);
1190 read_unlock(&GlobalSMBSeslock
);
1192 } /* else might as well continue, and look for
1193 another, or simply have the caller reopen it
1194 again rather than trying to fix this handle */
1195 } else /* write only file */
1196 break; /* write only files are last so must be done */
1198 read_unlock(&GlobalSMBSeslock
);
1203 struct cifsFileInfo
*find_writable_file(struct cifsInodeInfo
*cifs_inode
)
1205 struct cifsFileInfo
*open_file
;
1206 bool any_available
= false;
1209 /* Having a null inode here (because mapping->host was set to zero by
1210 the VFS or MM) should not happen but we had reports of on oops (due to
1211 it being zero) during stress testcases so we need to check for it */
1213 if (cifs_inode
== NULL
) {
1214 cERROR(1, ("Null inode passed to cifs_writeable_file"));
1219 read_lock(&GlobalSMBSeslock
);
1221 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1222 if (open_file
->closePend
||
1223 (!any_available
&& open_file
->pid
!= current
->tgid
))
1226 if (open_file
->pfile
&&
1227 ((open_file
->pfile
->f_flags
& O_RDWR
) ||
1228 (open_file
->pfile
->f_flags
& O_WRONLY
))) {
1229 cifsFileInfo_get(open_file
);
1231 if (!open_file
->invalidHandle
) {
1232 /* found a good writable file */
1233 read_unlock(&GlobalSMBSeslock
);
1237 read_unlock(&GlobalSMBSeslock
);
1238 /* Had to unlock since following call can block */
1239 rc
= cifs_reopen_file(open_file
->pfile
, false);
1241 if (!open_file
->closePend
)
1243 else { /* start over in case this was deleted */
1244 /* since the list could be modified */
1245 read_lock(&GlobalSMBSeslock
);
1246 cifsFileInfo_put(open_file
);
1247 goto refind_writable
;
1251 /* if it fails, try another handle if possible -
1252 (we can not do this if closePending since
1253 loop could be modified - in which case we
1254 have to start at the beginning of the list
1255 again. Note that it would be bad
1256 to hold up writepages here (rather than
1257 in caller) with continuous retries */
1258 cFYI(1, ("wp failed on reopen file"));
1259 read_lock(&GlobalSMBSeslock
);
1260 /* can not use this handle, no write
1261 pending on this one after all */
1262 cifsFileInfo_put(open_file
);
1264 if (open_file
->closePend
) /* list could have changed */
1265 goto refind_writable
;
1266 /* else we simply continue to the next entry. Thus
1267 we do not loop on reopen errors. If we
1268 can not reopen the file, for example if we
1269 reconnected to a server with another client
1270 racing to delete or lock the file we would not
1271 make progress if we restarted before the beginning
1272 of the loop here. */
1275 /* couldn't find useable FH with same pid, try any available */
1276 if (!any_available
) {
1277 any_available
= true;
1278 goto refind_writable
;
1280 read_unlock(&GlobalSMBSeslock
);
1284 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
1286 struct address_space
*mapping
= page
->mapping
;
1287 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1290 int bytes_written
= 0;
1291 struct cifs_sb_info
*cifs_sb
;
1292 struct cifsTconInfo
*pTcon
;
1293 struct inode
*inode
;
1294 struct cifsFileInfo
*open_file
;
1296 if (!mapping
|| !mapping
->host
)
1299 inode
= page
->mapping
->host
;
1300 cifs_sb
= CIFS_SB(inode
->i_sb
);
1301 pTcon
= cifs_sb
->tcon
;
1303 offset
+= (loff_t
)from
;
1304 write_data
= kmap(page
);
1307 if ((to
> PAGE_CACHE_SIZE
) || (from
> to
)) {
1312 /* racing with truncate? */
1313 if (offset
> mapping
->host
->i_size
) {
1315 return 0; /* don't care */
1318 /* check to make sure that we are not extending the file */
1319 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
1320 to
= (unsigned)(mapping
->host
->i_size
- offset
);
1322 open_file
= find_writable_file(CIFS_I(mapping
->host
));
1324 bytes_written
= cifs_write(open_file
->pfile
, write_data
,
1326 cifsFileInfo_put(open_file
);
1327 /* Does mm or vfs already set times? */
1328 inode
->i_atime
= inode
->i_mtime
= current_fs_time(inode
->i_sb
);
1329 if ((bytes_written
> 0) && (offset
))
1331 else if (bytes_written
< 0)
1334 cFYI(1, ("No writeable filehandles for inode"));
1342 static int cifs_writepages(struct address_space
*mapping
,
1343 struct writeback_control
*wbc
)
1345 struct backing_dev_info
*bdi
= mapping
->backing_dev_info
;
1346 unsigned int bytes_to_write
;
1347 unsigned int bytes_written
;
1348 struct cifs_sb_info
*cifs_sb
;
1352 int range_whole
= 0;
1359 struct cifsFileInfo
*open_file
;
1360 struct cifsInodeInfo
*cifsi
= CIFS_I(mapping
->host
);
1362 struct pagevec pvec
;
1367 cifs_sb
= CIFS_SB(mapping
->host
->i_sb
);
1370 * If wsize is smaller that the page cache size, default to writing
1371 * one page at a time via cifs_writepage
1373 if (cifs_sb
->wsize
< PAGE_CACHE_SIZE
)
1374 return generic_writepages(mapping
, wbc
);
1376 if ((cifs_sb
->tcon
->ses
) && (cifs_sb
->tcon
->ses
->server
))
1377 if (cifs_sb
->tcon
->ses
->server
->secMode
&
1378 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
1379 if (!experimEnabled
)
1380 return generic_writepages(mapping
, wbc
);
1382 iov
= kmalloc(32 * sizeof(struct kvec
), GFP_KERNEL
);
1384 return generic_writepages(mapping
, wbc
);
1388 * BB: Is this meaningful for a non-block-device file system?
1389 * If it is, we should test it again after we do I/O
1391 if (wbc
->nonblocking
&& bdi_write_congested(bdi
)) {
1392 wbc
->encountered_congestion
= 1;
1399 pagevec_init(&pvec
, 0);
1400 if (wbc
->range_cyclic
) {
1401 index
= mapping
->writeback_index
; /* Start from prev offset */
1404 index
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
1405 end
= wbc
->range_end
>> PAGE_CACHE_SHIFT
;
1406 if (wbc
->range_start
== 0 && wbc
->range_end
== LLONG_MAX
)
1411 while (!done
&& (index
<= end
) &&
1412 (nr_pages
= pagevec_lookup_tag(&pvec
, mapping
, &index
,
1413 PAGECACHE_TAG_DIRTY
,
1414 min(end
- index
, (pgoff_t
)PAGEVEC_SIZE
- 1) + 1))) {
1423 for (i
= 0; i
< nr_pages
; i
++) {
1424 page
= pvec
.pages
[i
];
1426 * At this point we hold neither mapping->tree_lock nor
1427 * lock on the page itself: the page may be truncated or
1428 * invalidated (changing page->mapping to NULL), or even
1429 * swizzled back from swapper_space to tmpfs file
1435 else if (!trylock_page(page
))
1438 if (unlikely(page
->mapping
!= mapping
)) {
1443 if (!wbc
->range_cyclic
&& page
->index
> end
) {
1449 if (next
&& (page
->index
!= next
)) {
1450 /* Not next consecutive page */
1455 if (wbc
->sync_mode
!= WB_SYNC_NONE
)
1456 wait_on_page_writeback(page
);
1458 if (PageWriteback(page
) ||
1459 !clear_page_dirty_for_io(page
)) {
1465 * This actually clears the dirty bit in the radix tree.
1466 * See cifs_writepage() for more commentary.
1468 set_page_writeback(page
);
1470 if (page_offset(page
) >= mapping
->host
->i_size
) {
1473 end_page_writeback(page
);
1478 * BB can we get rid of this? pages are held by pvec
1480 page_cache_get(page
);
1482 len
= min(mapping
->host
->i_size
- page_offset(page
),
1483 (loff_t
)PAGE_CACHE_SIZE
);
1485 /* reserve iov[0] for the smb header */
1487 iov
[n_iov
].iov_base
= kmap(page
);
1488 iov
[n_iov
].iov_len
= len
;
1489 bytes_to_write
+= len
;
1493 offset
= page_offset(page
);
1495 next
= page
->index
+ 1;
1496 if (bytes_to_write
+ PAGE_CACHE_SIZE
> cifs_sb
->wsize
)
1500 /* Search for a writable handle every time we call
1501 * CIFSSMBWrite2. We can't rely on the last handle
1502 * we used to still be valid
1504 open_file
= find_writable_file(CIFS_I(mapping
->host
));
1506 cERROR(1, ("No writable handles for inode"));
1509 long_op
= cifs_write_timeout(cifsi
, offset
);
1510 rc
= CIFSSMBWrite2(xid
, cifs_sb
->tcon
,
1512 bytes_to_write
, offset
,
1513 &bytes_written
, iov
, n_iov
,
1515 cifsFileInfo_put(open_file
);
1516 cifs_update_eof(cifsi
, offset
, bytes_written
);
1518 if (rc
|| bytes_written
< bytes_to_write
) {
1519 cERROR(1, ("Write2 ret %d, wrote %d",
1520 rc
, bytes_written
));
1521 /* BB what if continued retry is
1522 requested via mount flags? */
1524 set_bit(AS_ENOSPC
, &mapping
->flags
);
1526 set_bit(AS_EIO
, &mapping
->flags
);
1528 cifs_stats_bytes_written(cifs_sb
->tcon
,
1532 for (i
= 0; i
< n_iov
; i
++) {
1533 page
= pvec
.pages
[first
+ i
];
1534 /* Should we also set page error on
1535 success rc but too little data written? */
1536 /* BB investigate retry logic on temporary
1537 server crash cases and how recovery works
1538 when page marked as error */
1543 end_page_writeback(page
);
1544 page_cache_release(page
);
1546 if ((wbc
->nr_to_write
-= n_iov
) <= 0)
1550 /* Need to re-find the pages we skipped */
1551 index
= pvec
.pages
[0]->index
+ 1;
1553 pagevec_release(&pvec
);
1555 if (!scanned
&& !done
) {
1557 * We hit the last page and there is more work to be done: wrap
1558 * back to the start of the file
1564 if (wbc
->range_cyclic
|| (range_whole
&& wbc
->nr_to_write
> 0))
1565 mapping
->writeback_index
= index
;
1572 static int cifs_writepage(struct page
*page
, struct writeback_control
*wbc
)
1578 /* BB add check for wbc flags */
1579 page_cache_get(page
);
1580 if (!PageUptodate(page
))
1581 cFYI(1, ("ppw - page not up to date"));
1584 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1586 * A writepage() implementation always needs to do either this,
1587 * or re-dirty the page with "redirty_page_for_writepage()" in
1588 * the case of a failure.
1590 * Just unlocking the page will cause the radix tree tag-bits
1591 * to fail to update with the state of the page correctly.
1593 set_page_writeback(page
);
1594 rc
= cifs_partialpagewrite(page
, 0, PAGE_CACHE_SIZE
);
1595 SetPageUptodate(page
); /* BB add check for error and Clearuptodate? */
1597 end_page_writeback(page
);
1598 page_cache_release(page
);
1603 static int cifs_write_end(struct file
*file
, struct address_space
*mapping
,
1604 loff_t pos
, unsigned len
, unsigned copied
,
1605 struct page
*page
, void *fsdata
)
1608 struct inode
*inode
= mapping
->host
;
1610 cFYI(1, ("write_end for page %p from pos %lld with %d bytes",
1611 page
, pos
, copied
));
1613 if (PageChecked(page
)) {
1615 SetPageUptodate(page
);
1616 ClearPageChecked(page
);
1617 } else if (!PageUptodate(page
) && copied
== PAGE_CACHE_SIZE
)
1618 SetPageUptodate(page
);
1620 if (!PageUptodate(page
)) {
1622 unsigned offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1626 /* this is probably better than directly calling
1627 partialpage_write since in this function the file handle is
1628 known which we might as well leverage */
1629 /* BB check if anything else missing out of ppw
1630 such as updating last write time */
1631 page_data
= kmap(page
);
1632 rc
= cifs_write(file
, page_data
+ offset
, copied
, &pos
);
1633 /* if (rc < 0) should we set writebehind rc? */
1640 set_page_dirty(page
);
1644 spin_lock(&inode
->i_lock
);
1645 if (pos
> inode
->i_size
)
1646 i_size_write(inode
, pos
);
1647 spin_unlock(&inode
->i_lock
);
1651 page_cache_release(page
);
1656 int cifs_fsync(struct file
*file
, struct dentry
*dentry
, int datasync
)
1660 struct cifsTconInfo
*tcon
;
1661 struct cifsFileInfo
*smbfile
=
1662 (struct cifsFileInfo
*)file
->private_data
;
1663 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1667 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
1668 dentry
->d_name
.name
, datasync
));
1670 rc
= filemap_write_and_wait(inode
->i_mapping
);
1672 rc
= CIFS_I(inode
)->write_behind_rc
;
1673 CIFS_I(inode
)->write_behind_rc
= 0;
1674 tcon
= CIFS_SB(inode
->i_sb
)->tcon
;
1675 if (!rc
&& tcon
&& smbfile
&&
1676 !(CIFS_SB(inode
->i_sb
)->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
))
1677 rc
= CIFSSMBFlush(xid
, tcon
, smbfile
->netfid
);
1684 /* static void cifs_sync_page(struct page *page)
1686 struct address_space *mapping;
1687 struct inode *inode;
1688 unsigned long index = page->index;
1689 unsigned int rpages = 0;
1692 cFYI(1, ("sync page %p",page));
1693 mapping = page->mapping;
1696 inode = mapping->host;
1700 /* fill in rpages then
1701 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1703 /* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
1713 * As file closes, flush all cached write data for this inode checking
1714 * for write behind errors.
1716 int cifs_flush(struct file
*file
, fl_owner_t id
)
1718 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1721 /* Rather than do the steps manually:
1722 lock the inode for writing
1723 loop through pages looking for write behind data (dirty pages)
1724 coalesce into contiguous 16K (or smaller) chunks to write to server
1725 send to server (prefer in parallel)
1726 deal with writebehind errors
1727 unlock inode for writing
1728 filemapfdatawrite appears easier for the time being */
1730 rc
= filemap_fdatawrite(inode
->i_mapping
);
1731 /* reset wb rc if we were able to write out dirty pages */
1733 rc
= CIFS_I(inode
)->write_behind_rc
;
1734 CIFS_I(inode
)->write_behind_rc
= 0;
1737 cFYI(1, ("Flush inode %p file %p rc %d", inode
, file
, rc
));
1742 ssize_t
cifs_user_read(struct file
*file
, char __user
*read_data
,
1743 size_t read_size
, loff_t
*poffset
)
1746 unsigned int bytes_read
= 0;
1747 unsigned int total_read
= 0;
1748 unsigned int current_read_size
;
1749 struct cifs_sb_info
*cifs_sb
;
1750 struct cifsTconInfo
*pTcon
;
1752 struct cifsFileInfo
*open_file
;
1753 char *smb_read_data
;
1754 char __user
*current_offset
;
1755 struct smb_com_read_rsp
*pSMBr
;
1758 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1759 pTcon
= cifs_sb
->tcon
;
1761 if (file
->private_data
== NULL
) {
1766 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1768 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1769 cFYI(1, ("attempting read on write only file instance"));
1771 for (total_read
= 0, current_offset
= read_data
;
1772 read_size
> total_read
;
1773 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1774 current_read_size
= min_t(const int, read_size
- total_read
,
1777 smb_read_data
= NULL
;
1778 while (rc
== -EAGAIN
) {
1779 int buf_type
= CIFS_NO_BUFFER
;
1780 if ((open_file
->invalidHandle
) &&
1781 (!open_file
->closePend
)) {
1782 rc
= cifs_reopen_file(file
, true);
1786 rc
= CIFSSMBRead(xid
, pTcon
,
1788 current_read_size
, *poffset
,
1789 &bytes_read
, &smb_read_data
,
1791 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
1792 if (smb_read_data
) {
1793 if (copy_to_user(current_offset
,
1795 4 /* RFC1001 length field */ +
1796 le16_to_cpu(pSMBr
->DataOffset
),
1800 if (buf_type
== CIFS_SMALL_BUFFER
)
1801 cifs_small_buf_release(smb_read_data
);
1802 else if (buf_type
== CIFS_LARGE_BUFFER
)
1803 cifs_buf_release(smb_read_data
);
1804 smb_read_data
= NULL
;
1807 if (rc
|| (bytes_read
== 0)) {
1815 cifs_stats_bytes_read(pTcon
, bytes_read
);
1816 *poffset
+= bytes_read
;
1824 static ssize_t
cifs_read(struct file
*file
, char *read_data
, size_t read_size
,
1828 unsigned int bytes_read
= 0;
1829 unsigned int total_read
;
1830 unsigned int current_read_size
;
1831 struct cifs_sb_info
*cifs_sb
;
1832 struct cifsTconInfo
*pTcon
;
1834 char *current_offset
;
1835 struct cifsFileInfo
*open_file
;
1836 int buf_type
= CIFS_NO_BUFFER
;
1839 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1840 pTcon
= cifs_sb
->tcon
;
1842 if (file
->private_data
== NULL
) {
1847 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1849 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1850 cFYI(1, ("attempting read on write only file instance"));
1852 for (total_read
= 0, current_offset
= read_data
;
1853 read_size
> total_read
;
1854 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1855 current_read_size
= min_t(const int, read_size
- total_read
,
1857 /* For windows me and 9x we do not want to request more
1858 than it negotiated since it will refuse the read then */
1860 !(pTcon
->ses
->capabilities
& CAP_LARGE_FILES
)) {
1861 current_read_size
= min_t(const int, current_read_size
,
1862 pTcon
->ses
->server
->maxBuf
- 128);
1865 while (rc
== -EAGAIN
) {
1866 if ((open_file
->invalidHandle
) &&
1867 (!open_file
->closePend
)) {
1868 rc
= cifs_reopen_file(file
, true);
1872 rc
= CIFSSMBRead(xid
, pTcon
,
1874 current_read_size
, *poffset
,
1875 &bytes_read
, ¤t_offset
,
1878 if (rc
|| (bytes_read
== 0)) {
1886 cifs_stats_bytes_read(pTcon
, total_read
);
1887 *poffset
+= bytes_read
;
1894 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1896 struct dentry
*dentry
= file
->f_path
.dentry
;
1900 rc
= cifs_revalidate(dentry
);
1902 cFYI(1, ("Validation prior to mmap failed, error=%d", rc
));
1906 rc
= generic_file_mmap(file
, vma
);
1912 static void cifs_copy_cache_pages(struct address_space
*mapping
,
1913 struct list_head
*pages
, int bytes_read
, char *data
,
1914 struct pagevec
*plru_pvec
)
1919 while (bytes_read
> 0) {
1920 if (list_empty(pages
))
1923 page
= list_entry(pages
->prev
, struct page
, lru
);
1924 list_del(&page
->lru
);
1926 if (add_to_page_cache(page
, mapping
, page
->index
,
1928 page_cache_release(page
);
1929 cFYI(1, ("Add page cache failed"));
1930 data
+= PAGE_CACHE_SIZE
;
1931 bytes_read
-= PAGE_CACHE_SIZE
;
1935 target
= kmap_atomic(page
, KM_USER0
);
1937 if (PAGE_CACHE_SIZE
> bytes_read
) {
1938 memcpy(target
, data
, bytes_read
);
1939 /* zero the tail end of this partial page */
1940 memset(target
+ bytes_read
, 0,
1941 PAGE_CACHE_SIZE
- bytes_read
);
1944 memcpy(target
, data
, PAGE_CACHE_SIZE
);
1945 bytes_read
-= PAGE_CACHE_SIZE
;
1947 kunmap_atomic(target
, KM_USER0
);
1949 flush_dcache_page(page
);
1950 SetPageUptodate(page
);
1952 if (!pagevec_add(plru_pvec
, page
))
1953 __pagevec_lru_add_file(plru_pvec
);
1954 data
+= PAGE_CACHE_SIZE
;
1959 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
1960 struct list_head
*page_list
, unsigned num_pages
)
1966 struct cifs_sb_info
*cifs_sb
;
1967 struct cifsTconInfo
*pTcon
;
1968 unsigned int bytes_read
= 0;
1969 unsigned int read_size
, i
;
1970 char *smb_read_data
= NULL
;
1971 struct smb_com_read_rsp
*pSMBr
;
1972 struct pagevec lru_pvec
;
1973 struct cifsFileInfo
*open_file
;
1974 int buf_type
= CIFS_NO_BUFFER
;
1977 if (file
->private_data
== NULL
) {
1982 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1983 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1984 pTcon
= cifs_sb
->tcon
;
1986 pagevec_init(&lru_pvec
, 0);
1987 cFYI(DBG2
, ("rpages: num pages %d", num_pages
));
1988 for (i
= 0; i
< num_pages
; ) {
1989 unsigned contig_pages
;
1990 struct page
*tmp_page
;
1991 unsigned long expected_index
;
1993 if (list_empty(page_list
))
1996 page
= list_entry(page_list
->prev
, struct page
, lru
);
1997 offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1999 /* count adjacent pages that we will read into */
2002 list_entry(page_list
->prev
, struct page
, lru
)->index
;
2003 list_for_each_entry_reverse(tmp_page
, page_list
, lru
) {
2004 if (tmp_page
->index
== expected_index
) {
2010 if (contig_pages
+ i
> num_pages
)
2011 contig_pages
= num_pages
- i
;
2013 /* for reads over a certain size could initiate async
2016 read_size
= contig_pages
* PAGE_CACHE_SIZE
;
2017 /* Read size needs to be in multiples of one page */
2018 read_size
= min_t(const unsigned int, read_size
,
2019 cifs_sb
->rsize
& PAGE_CACHE_MASK
);
2020 cFYI(DBG2
, ("rpages: read size 0x%x contiguous pages %d",
2021 read_size
, contig_pages
));
2023 while (rc
== -EAGAIN
) {
2024 if ((open_file
->invalidHandle
) &&
2025 (!open_file
->closePend
)) {
2026 rc
= cifs_reopen_file(file
, true);
2031 rc
= CIFSSMBRead(xid
, pTcon
,
2034 &bytes_read
, &smb_read_data
,
2036 /* BB more RC checks ? */
2037 if (rc
== -EAGAIN
) {
2038 if (smb_read_data
) {
2039 if (buf_type
== CIFS_SMALL_BUFFER
)
2040 cifs_small_buf_release(smb_read_data
);
2041 else if (buf_type
== CIFS_LARGE_BUFFER
)
2042 cifs_buf_release(smb_read_data
);
2043 smb_read_data
= NULL
;
2047 if ((rc
< 0) || (smb_read_data
== NULL
)) {
2048 cFYI(1, ("Read error in readpages: %d", rc
));
2050 } else if (bytes_read
> 0) {
2051 task_io_account_read(bytes_read
);
2052 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
2053 cifs_copy_cache_pages(mapping
, page_list
, bytes_read
,
2054 smb_read_data
+ 4 /* RFC1001 hdr */ +
2055 le16_to_cpu(pSMBr
->DataOffset
), &lru_pvec
);
2057 i
+= bytes_read
>> PAGE_CACHE_SHIFT
;
2058 cifs_stats_bytes_read(pTcon
, bytes_read
);
2059 if ((bytes_read
& PAGE_CACHE_MASK
) != bytes_read
) {
2060 i
++; /* account for partial page */
2062 /* server copy of file can have smaller size
2064 /* BB do we need to verify this common case ?
2065 this case is ok - if we are at server EOF
2066 we will hit it on next read */
2071 cFYI(1, ("No bytes read (%d) at offset %lld . "
2072 "Cleaning remaining pages from readahead list",
2073 bytes_read
, offset
));
2074 /* BB turn off caching and do new lookup on
2075 file size at server? */
2078 if (smb_read_data
) {
2079 if (buf_type
== CIFS_SMALL_BUFFER
)
2080 cifs_small_buf_release(smb_read_data
);
2081 else if (buf_type
== CIFS_LARGE_BUFFER
)
2082 cifs_buf_release(smb_read_data
);
2083 smb_read_data
= NULL
;
2088 pagevec_lru_add_file(&lru_pvec
);
2090 /* need to free smb_read_data buf before exit */
2091 if (smb_read_data
) {
2092 if (buf_type
== CIFS_SMALL_BUFFER
)
2093 cifs_small_buf_release(smb_read_data
);
2094 else if (buf_type
== CIFS_LARGE_BUFFER
)
2095 cifs_buf_release(smb_read_data
);
2096 smb_read_data
= NULL
;
2103 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
2109 page_cache_get(page
);
2110 read_data
= kmap(page
);
2111 /* for reads over a certain size could initiate async read ahead */
2113 rc
= cifs_read(file
, read_data
, PAGE_CACHE_SIZE
, poffset
);
2118 cFYI(1, ("Bytes read %d", rc
));
2120 file
->f_path
.dentry
->d_inode
->i_atime
=
2121 current_fs_time(file
->f_path
.dentry
->d_inode
->i_sb
);
2123 if (PAGE_CACHE_SIZE
> rc
)
2124 memset(read_data
+ rc
, 0, PAGE_CACHE_SIZE
- rc
);
2126 flush_dcache_page(page
);
2127 SetPageUptodate(page
);
2132 page_cache_release(page
);
2136 static int cifs_readpage(struct file
*file
, struct page
*page
)
2138 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
2144 if (file
->private_data
== NULL
) {
2150 cFYI(1, ("readpage %p at offset %d 0x%x\n",
2151 page
, (int)offset
, (int)offset
));
2153 rc
= cifs_readpage_worker(file
, page
, &offset
);
2161 static int is_inode_writable(struct cifsInodeInfo
*cifs_inode
)
2163 struct cifsFileInfo
*open_file
;
2165 read_lock(&GlobalSMBSeslock
);
2166 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
2167 if (open_file
->closePend
)
2169 if (open_file
->pfile
&&
2170 ((open_file
->pfile
->f_flags
& O_RDWR
) ||
2171 (open_file
->pfile
->f_flags
& O_WRONLY
))) {
2172 read_unlock(&GlobalSMBSeslock
);
2176 read_unlock(&GlobalSMBSeslock
);
2180 /* We do not want to update the file size from server for inodes
2181 open for write - to avoid races with writepage extending
2182 the file - in the future we could consider allowing
2183 refreshing the inode only on increases in the file size
2184 but this is tricky to do without racing with writebehind
2185 page caching in the current Linux kernel design */
2186 bool is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
, __u64 end_of_file
)
2191 if (is_inode_writable(cifsInode
)) {
2192 /* This inode is open for write at least once */
2193 struct cifs_sb_info
*cifs_sb
;
2195 cifs_sb
= CIFS_SB(cifsInode
->vfs_inode
.i_sb
);
2196 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
2197 /* since no page cache to corrupt on directio
2198 we can change size safely */
2202 if (i_size_read(&cifsInode
->vfs_inode
) < end_of_file
)
2210 static int cifs_write_begin(struct file
*file
, struct address_space
*mapping
,
2211 loff_t pos
, unsigned len
, unsigned flags
,
2212 struct page
**pagep
, void **fsdata
)
2214 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
2215 loff_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
2216 loff_t page_start
= pos
& PAGE_MASK
;
2221 cFYI(1, ("write_begin from %lld len %d", (long long)pos
, len
));
2223 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
2229 if (PageUptodate(page
))
2233 * If we write a full page it will be up to date, no need to read from
2234 * the server. If the write is short, we'll end up doing a sync write
2237 if (len
== PAGE_CACHE_SIZE
)
2241 * optimize away the read when we have an oplock, and we're not
2242 * expecting to use any of the data we'd be reading in. That
2243 * is, when the page lies beyond the EOF, or straddles the EOF
2244 * and the write will cover all of the existing data.
2246 if (CIFS_I(mapping
->host
)->clientCanCacheRead
) {
2247 i_size
= i_size_read(mapping
->host
);
2248 if (page_start
>= i_size
||
2249 (offset
== 0 && (pos
+ len
) >= i_size
)) {
2250 zero_user_segments(page
, 0, offset
,
2254 * PageChecked means that the parts of the page
2255 * to which we're not writing are considered up
2256 * to date. Once the data is copied to the
2257 * page, it can be set uptodate.
2259 SetPageChecked(page
);
2264 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
) {
2266 * might as well read a page, it is fast enough. If we get
2267 * an error, we don't need to return it. cifs_write_end will
2268 * do a sync write instead since PG_uptodate isn't set.
2270 cifs_readpage_worker(file
, page
, &page_start
);
2272 /* we could try using another file handle if there is one -
2273 but how would we lock it to prevent close of that handle
2274 racing with this read? In any case
2275 this will be written out by write_end so is fine */
2283 cifs_oplock_break(struct slow_work
*work
)
2285 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2287 struct inode
*inode
= cfile
->pInode
;
2288 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2289 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->mnt
->mnt_sb
);
2292 if (inode
&& S_ISREG(inode
->i_mode
)) {
2293 #ifdef CONFIG_CIFS_EXPERIMENTAL
2294 if (cinode
->clientCanCacheAll
== 0)
2295 break_lease(inode
, FMODE_READ
);
2296 else if (cinode
->clientCanCacheRead
== 0)
2297 break_lease(inode
, FMODE_WRITE
);
2299 rc
= filemap_fdatawrite(inode
->i_mapping
);
2300 if (cinode
->clientCanCacheRead
== 0) {
2301 waitrc
= filemap_fdatawait(inode
->i_mapping
);
2302 invalidate_remote_inode(inode
);
2307 cinode
->write_behind_rc
= rc
;
2308 cFYI(1, ("Oplock flush inode %p rc %d", inode
, rc
));
2312 * releasing stale oplock after recent reconnect of smb session using
2313 * a now incorrect file handle is not a data integrity issue but do
2314 * not bother sending an oplock release if session to server still is
2315 * disconnected since oplock already released by the server
2317 if (!cfile
->closePend
&& !cfile
->oplock_break_cancelled
) {
2318 rc
= CIFSSMBLock(0, cifs_sb
->tcon
, cfile
->netfid
, 0, 0, 0, 0,
2319 LOCKING_ANDX_OPLOCK_RELEASE
, false,
2320 cinode
->clientCanCacheRead
? 1 : 0);
2321 cFYI(1, ("Oplock release rc = %d", rc
));
2326 cifs_oplock_break_get(struct slow_work
*work
)
2328 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2331 cifsFileInfo_get(cfile
);
2336 cifs_oplock_break_put(struct slow_work
*work
)
2338 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2341 cifsFileInfo_put(cfile
);
2344 const struct slow_work_ops cifs_oplock_break_ops
= {
2345 .get_ref
= cifs_oplock_break_get
,
2346 .put_ref
= cifs_oplock_break_put
,
2347 .execute
= cifs_oplock_break
,
2350 const struct address_space_operations cifs_addr_ops
= {
2351 .readpage
= cifs_readpage
,
2352 .readpages
= cifs_readpages
,
2353 .writepage
= cifs_writepage
,
2354 .writepages
= cifs_writepages
,
2355 .write_begin
= cifs_write_begin
,
2356 .write_end
= cifs_write_end
,
2357 .set_page_dirty
= __set_page_dirty_nobuffers
,
2358 /* .sync_page = cifs_sync_page, */
2363 * cifs_readpages requires the server to support a buffer large enough to
2364 * contain the header plus one complete page of data. Otherwise, we need
2365 * to leave cifs_readpages out of the address space operations.
2367 const struct address_space_operations cifs_addr_ops_smallbuf
= {
2368 .readpage
= cifs_readpage
,
2369 .writepage
= cifs_writepage
,
2370 .writepages
= cifs_writepages
,
2371 .write_begin
= cifs_write_begin
,
2372 .write_end
= cifs_write_end
,
2373 .set_page_dirty
= __set_page_dirty_nobuffers
,
2374 /* .sync_page = cifs_sync_page, */