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_SYNC
;
81 if (flags
& O_DIRECTORY
)
82 posix_flags
|= (fmode_t
)O_DIRECTORY
;
83 if (flags
& O_NOFOLLOW
)
84 posix_flags
|= (fmode_t
)O_NOFOLLOW
;
86 posix_flags
|= (fmode_t
)O_DIRECT
;
91 static inline int cifs_get_disposition(unsigned int flags
)
93 if ((flags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
95 else if ((flags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
96 return FILE_OVERWRITE_IF
;
97 else if ((flags
& O_CREAT
) == O_CREAT
)
99 else if ((flags
& O_TRUNC
) == O_TRUNC
)
100 return FILE_OVERWRITE
;
105 /* all arguments to this function must be checked for validity in caller */
107 cifs_posix_open_inode_helper(struct inode
*inode
, struct file
*file
,
108 struct cifsInodeInfo
*pCifsInode
,
109 struct cifsFileInfo
*pCifsFile
, __u32 oplock
,
113 write_lock(&GlobalSMBSeslock
);
115 pCifsInode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
116 if (pCifsInode
== NULL
) {
117 write_unlock(&GlobalSMBSeslock
);
121 if (pCifsInode
->clientCanCacheRead
) {
122 /* we have the inode open somewhere else
123 no need to discard cache data */
124 goto psx_client_can_cache
;
127 /* BB FIXME need to fix this check to move it earlier into posix_open
128 BB fIX following section BB FIXME */
130 /* if not oplocked, invalidate inode pages if mtime or file
132 /* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
133 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
134 (file->f_path.dentry->d_inode->i_size ==
135 (loff_t)le64_to_cpu(buf->EndOfFile))) {
136 cFYI(1, ("inode unchanged on server"));
138 if (file->f_path.dentry->d_inode->i_mapping) {
139 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
141 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
143 cFYI(1, ("invalidating remote inode since open detected it "
145 invalidate_remote_inode(file->f_path.dentry->d_inode);
148 psx_client_can_cache
:
149 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
150 pCifsInode
->clientCanCacheAll
= true;
151 pCifsInode
->clientCanCacheRead
= true;
152 cFYI(1, ("Exclusive Oplock granted on inode %p",
153 file
->f_path
.dentry
->d_inode
));
154 } else if ((oplock
& 0xF) == OPLOCK_READ
)
155 pCifsInode
->clientCanCacheRead
= true;
157 /* will have to change the unlock if we reenable the
158 filemap_fdatawrite (which does not seem necessary */
159 write_unlock(&GlobalSMBSeslock
);
163 static struct cifsFileInfo
*
164 cifs_fill_filedata(struct file
*file
)
166 struct list_head
*tmp
;
167 struct cifsFileInfo
*pCifsFile
= NULL
;
168 struct cifsInodeInfo
*pCifsInode
= NULL
;
170 /* search inode for this file and fill in file->private_data */
171 pCifsInode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
172 read_lock(&GlobalSMBSeslock
);
173 list_for_each(tmp
, &pCifsInode
->openFileList
) {
174 pCifsFile
= list_entry(tmp
, struct cifsFileInfo
, flist
);
175 if ((pCifsFile
->pfile
== NULL
) &&
176 (pCifsFile
->pid
== current
->tgid
)) {
177 /* mode set in cifs_create */
179 /* needed for writepage */
180 pCifsFile
->pfile
= file
;
181 file
->private_data
= pCifsFile
;
185 read_unlock(&GlobalSMBSeslock
);
187 if (file
->private_data
!= NULL
) {
189 } else if ((file
->f_flags
& O_CREAT
) && (file
->f_flags
& O_EXCL
))
190 cERROR(1, ("could not find file instance for "
191 "new file %p", file
));
195 /* all arguments to this function must be checked for validity in caller */
196 static inline int cifs_open_inode_helper(struct inode
*inode
, struct file
*file
,
197 struct cifsInodeInfo
*pCifsInode
, struct cifsFileInfo
*pCifsFile
,
198 struct cifsTconInfo
*pTcon
, int *oplock
, FILE_ALL_INFO
*buf
,
199 char *full_path
, int xid
)
201 struct timespec temp
;
204 if (pCifsInode
->clientCanCacheRead
) {
205 /* we have the inode open somewhere else
206 no need to discard cache data */
207 goto client_can_cache
;
210 /* BB need same check in cifs_create too? */
211 /* if not oplocked, invalidate inode pages if mtime or file
213 temp
= cifs_NTtimeToUnix(buf
->LastWriteTime
);
214 if (timespec_equal(&file
->f_path
.dentry
->d_inode
->i_mtime
, &temp
) &&
215 (file
->f_path
.dentry
->d_inode
->i_size
==
216 (loff_t
)le64_to_cpu(buf
->EndOfFile
))) {
217 cFYI(1, ("inode unchanged on server"));
219 if (file
->f_path
.dentry
->d_inode
->i_mapping
) {
220 /* BB no need to lock inode until after invalidate
221 since namei code should already have it locked? */
222 rc
= filemap_write_and_wait(file
->f_path
.dentry
->d_inode
->i_mapping
);
224 CIFS_I(file
->f_path
.dentry
->d_inode
)->write_behind_rc
= rc
;
226 cFYI(1, ("invalidating remote inode since open detected it "
228 invalidate_remote_inode(file
->f_path
.dentry
->d_inode
);
233 rc
= cifs_get_inode_info_unix(&file
->f_path
.dentry
->d_inode
,
234 full_path
, inode
->i_sb
, xid
);
236 rc
= cifs_get_inode_info(&file
->f_path
.dentry
->d_inode
,
237 full_path
, buf
, inode
->i_sb
, xid
, NULL
);
239 if ((*oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
240 pCifsInode
->clientCanCacheAll
= true;
241 pCifsInode
->clientCanCacheRead
= true;
242 cFYI(1, ("Exclusive Oplock granted on inode %p",
243 file
->f_path
.dentry
->d_inode
));
244 } else if ((*oplock
& 0xF) == OPLOCK_READ
)
245 pCifsInode
->clientCanCacheRead
= true;
250 int cifs_open(struct inode
*inode
, struct file
*file
)
255 struct cifs_sb_info
*cifs_sb
;
256 struct cifsTconInfo
*tcon
;
257 struct cifsFileInfo
*pCifsFile
;
258 struct cifsInodeInfo
*pCifsInode
;
259 char *full_path
= NULL
;
263 FILE_ALL_INFO
*buf
= NULL
;
267 cifs_sb
= CIFS_SB(inode
->i_sb
);
268 tcon
= cifs_sb
->tcon
;
270 pCifsInode
= CIFS_I(file
->f_path
.dentry
->d_inode
);
271 pCifsFile
= cifs_fill_filedata(file
);
278 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
279 if (full_path
== NULL
) {
285 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
286 inode
, file
->f_flags
, full_path
));
293 if (!tcon
->broken_posix_open
&& tcon
->unix_ext
&&
294 (tcon
->ses
->capabilities
& CAP_UNIX
) &&
295 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
296 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
297 int oflags
= (int) cifs_posix_convert_flags(file
->f_flags
);
298 oflags
|= SMB_O_CREAT
;
299 /* can not refresh inode info since size could be stale */
300 rc
= cifs_posix_open(full_path
, &inode
, file
->f_path
.mnt
,
302 cifs_sb
->mnt_file_mode
/* ignored */,
303 oflags
, &oplock
, &netfid
, xid
);
305 cFYI(1, ("posix open succeeded"));
306 /* no need for special case handling of setting mode
307 on read only files needed here */
309 pCifsFile
= cifs_fill_filedata(file
);
310 cifs_posix_open_inode_helper(inode
, file
, pCifsInode
,
311 pCifsFile
, oplock
, netfid
);
313 } else if ((rc
== -EINVAL
) || (rc
== -EOPNOTSUPP
)) {
314 if (tcon
->ses
->serverNOS
)
315 cERROR(1, ("server %s of type %s returned"
316 " unexpected error on SMB posix open"
317 ", disabling posix open support."
318 " Check if server update available.",
319 tcon
->ses
->serverName
,
320 tcon
->ses
->serverNOS
));
321 tcon
->broken_posix_open
= true;
322 } else if ((rc
!= -EIO
) && (rc
!= -EREMOTE
) &&
323 (rc
!= -EOPNOTSUPP
)) /* path not found or net err */
325 /* else fallthrough to retry open the old way on network i/o
329 desiredAccess
= cifs_convert_flags(file
->f_flags
);
331 /*********************************************************************
332 * open flag mapping table:
334 * POSIX Flag CIFS Disposition
335 * ---------- ----------------
336 * O_CREAT FILE_OPEN_IF
337 * O_CREAT | O_EXCL FILE_CREATE
338 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
339 * O_TRUNC FILE_OVERWRITE
340 * none of the above FILE_OPEN
342 * Note that there is not a direct match between disposition
343 * FILE_SUPERSEDE (ie create whether or not file exists although
344 * O_CREAT | O_TRUNC is similar but truncates the existing
345 * file rather than creating a new file as FILE_SUPERSEDE does
346 * (which uses the attributes / metadata passed in on open call)
348 *? O_SYNC is a reasonable match to CIFS writethrough flag
349 *? and the read write flags match reasonably. O_LARGEFILE
350 *? is irrelevant because largefile support is always used
351 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
352 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
353 *********************************************************************/
355 disposition
= cifs_get_disposition(file
->f_flags
);
357 /* BB pass O_SYNC flag through on file attributes .. BB */
359 /* Also refresh inode by passing in file_info buf returned by SMBOpen
360 and calling get_inode_info with returned buf (at least helps
361 non-Unix server case) */
363 /* BB we can not do this if this is the second open of a file
364 and the first handle has writebehind data, we might be
365 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
366 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
372 if (cifs_sb
->tcon
->ses
->capabilities
& CAP_NT_SMBS
)
373 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
,
374 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
375 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
376 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
378 rc
= -EIO
; /* no NT SMB support fall into legacy open below */
381 /* Old server, try legacy style OpenX */
382 rc
= SMBLegacyOpen(xid
, tcon
, full_path
, disposition
,
383 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
384 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
385 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
388 cFYI(1, ("cifs_open returned 0x%x", rc
));
392 pCifsFile
= cifs_new_fileinfo(inode
, netfid
, file
, file
->f_path
.mnt
,
394 file
->private_data
= pCifsFile
;
395 if (file
->private_data
== NULL
) {
400 rc
= cifs_open_inode_helper(inode
, file
, pCifsInode
, pCifsFile
, tcon
,
401 &oplock
, buf
, full_path
, xid
);
403 if (oplock
& CIFS_CREATE_ACTION
) {
404 /* time to set mode which we can not set earlier due to
405 problems creating new read-only files */
406 if (tcon
->unix_ext
) {
407 struct cifs_unix_set_info_args args
= {
408 .mode
= inode
->i_mode
,
411 .ctime
= NO_CHANGE_64
,
412 .atime
= NO_CHANGE_64
,
413 .mtime
= NO_CHANGE_64
,
416 CIFSSMBUnixSetPathInfo(xid
, tcon
, full_path
, &args
,
418 cifs_sb
->mnt_cifs_flags
&
419 CIFS_MOUNT_MAP_SPECIAL_CHR
);
430 /* Try to reacquire byte range locks that were released when session */
431 /* to server was lost */
432 static int cifs_relock_file(struct cifsFileInfo
*cifsFile
)
436 /* BB list all locks open on this file and relock */
441 static int cifs_reopen_file(struct file
*file
, bool can_flush
)
446 struct cifs_sb_info
*cifs_sb
;
447 struct cifsTconInfo
*tcon
;
448 struct cifsFileInfo
*pCifsFile
;
449 struct cifsInodeInfo
*pCifsInode
;
451 char *full_path
= NULL
;
453 int disposition
= FILE_OPEN
;
456 if (file
->private_data
)
457 pCifsFile
= (struct cifsFileInfo
*)file
->private_data
;
462 mutex_lock(&pCifsFile
->fh_mutex
);
463 if (!pCifsFile
->invalidHandle
) {
464 mutex_unlock(&pCifsFile
->fh_mutex
);
470 if (file
->f_path
.dentry
== NULL
) {
471 cERROR(1, ("no valid name if dentry freed"));
474 goto reopen_error_exit
;
477 inode
= file
->f_path
.dentry
->d_inode
;
479 cERROR(1, ("inode not valid"));
482 goto reopen_error_exit
;
485 cifs_sb
= CIFS_SB(inode
->i_sb
);
486 tcon
= cifs_sb
->tcon
;
488 /* can not grab rename sem here because various ops, including
489 those that already have the rename sem can end up causing writepage
490 to get called and if the server was down that means we end up here,
491 and we can never tell if the caller already has the rename_sem */
492 full_path
= build_path_from_dentry(file
->f_path
.dentry
);
493 if (full_path
== NULL
) {
496 mutex_unlock(&pCifsFile
->fh_mutex
);
501 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
502 inode
, file
->f_flags
, full_path
));
509 if (tcon
->unix_ext
&& (tcon
->ses
->capabilities
& CAP_UNIX
) &&
510 (CIFS_UNIX_POSIX_PATH_OPS_CAP
&
511 le64_to_cpu(tcon
->fsUnixInfo
.Capability
))) {
512 int oflags
= (int) cifs_posix_convert_flags(file
->f_flags
);
513 /* can not refresh inode info since size could be stale */
514 rc
= cifs_posix_open(full_path
, NULL
, file
->f_path
.mnt
,
516 cifs_sb
->mnt_file_mode
/* ignored */,
517 oflags
, &oplock
, &netfid
, xid
);
519 cFYI(1, ("posix reopen succeeded"));
522 /* fallthrough to retry open the old way on errors, especially
523 in the reconnect path it is important to retry hard */
526 desiredAccess
= cifs_convert_flags(file
->f_flags
);
528 /* Can not refresh inode by passing in file_info buf to be returned
529 by SMBOpen and then calling get_inode_info with returned buf
530 since file might have write behind data that needs to be flushed
531 and server version of file size can be stale. If we knew for sure
532 that inode was not dirty locally we could do this */
534 rc
= CIFSSMBOpen(xid
, tcon
, full_path
, disposition
, desiredAccess
,
535 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
536 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
537 CIFS_MOUNT_MAP_SPECIAL_CHR
);
539 mutex_unlock(&pCifsFile
->fh_mutex
);
540 cFYI(1, ("cifs_open returned 0x%x", rc
));
541 cFYI(1, ("oplock: %d", oplock
));
544 pCifsFile
->netfid
= netfid
;
545 pCifsFile
->invalidHandle
= false;
546 mutex_unlock(&pCifsFile
->fh_mutex
);
547 pCifsInode
= CIFS_I(inode
);
550 rc
= filemap_write_and_wait(inode
->i_mapping
);
552 CIFS_I(inode
)->write_behind_rc
= rc
;
553 /* temporarily disable caching while we
554 go to server to get inode info */
555 pCifsInode
->clientCanCacheAll
= false;
556 pCifsInode
->clientCanCacheRead
= false;
558 rc
= cifs_get_inode_info_unix(&inode
,
559 full_path
, inode
->i_sb
, xid
);
561 rc
= cifs_get_inode_info(&inode
,
562 full_path
, NULL
, inode
->i_sb
,
564 } /* else we are writing out data to server already
565 and could deadlock if we tried to flush data, and
566 since we do not know if we have data that would
567 invalidate the current end of file on the server
568 we can not go to the server to get the new inod
570 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
571 pCifsInode
->clientCanCacheAll
= true;
572 pCifsInode
->clientCanCacheRead
= true;
573 cFYI(1, ("Exclusive Oplock granted on inode %p",
574 file
->f_path
.dentry
->d_inode
));
575 } else if ((oplock
& 0xF) == OPLOCK_READ
) {
576 pCifsInode
->clientCanCacheRead
= true;
577 pCifsInode
->clientCanCacheAll
= false;
579 pCifsInode
->clientCanCacheRead
= false;
580 pCifsInode
->clientCanCacheAll
= false;
582 cifs_relock_file(pCifsFile
);
590 int cifs_close(struct inode
*inode
, struct file
*file
)
594 struct cifs_sb_info
*cifs_sb
;
595 struct cifsTconInfo
*pTcon
;
596 struct cifsFileInfo
*pSMBFile
=
597 (struct cifsFileInfo
*)file
->private_data
;
601 cifs_sb
= CIFS_SB(inode
->i_sb
);
602 pTcon
= cifs_sb
->tcon
;
604 struct cifsLockInfo
*li
, *tmp
;
605 write_lock(&GlobalSMBSeslock
);
606 pSMBFile
->closePend
= true;
608 /* no sense reconnecting to close a file that is
610 if (!pTcon
->need_reconnect
) {
611 write_unlock(&GlobalSMBSeslock
);
613 while ((atomic_read(&pSMBFile
->count
) != 1)
614 && (timeout
<= 2048)) {
615 /* Give write a better chance to get to
616 server ahead of the close. We do not
617 want to add a wait_q here as it would
618 increase the memory utilization as
619 the struct would be in each open file,
620 but this should give enough time to
623 ("close delay, write pending"));
627 if (!pTcon
->need_reconnect
&&
628 !pSMBFile
->invalidHandle
)
629 rc
= CIFSSMBClose(xid
, pTcon
,
632 write_unlock(&GlobalSMBSeslock
);
634 write_unlock(&GlobalSMBSeslock
);
636 /* Delete any outstanding lock records.
637 We'll lose them when the file is closed anyway. */
638 mutex_lock(&pSMBFile
->lock_mutex
);
639 list_for_each_entry_safe(li
, tmp
, &pSMBFile
->llist
, llist
) {
640 list_del(&li
->llist
);
643 mutex_unlock(&pSMBFile
->lock_mutex
);
645 write_lock(&GlobalSMBSeslock
);
646 list_del(&pSMBFile
->flist
);
647 list_del(&pSMBFile
->tlist
);
648 write_unlock(&GlobalSMBSeslock
);
649 cifsFileInfo_put(file
->private_data
);
650 file
->private_data
= NULL
;
654 read_lock(&GlobalSMBSeslock
);
655 if (list_empty(&(CIFS_I(inode
)->openFileList
))) {
656 cFYI(1, ("closing last open instance for inode %p", inode
));
657 /* if the file is not open we do not know if we can cache info
658 on this inode, much less write behind and read ahead */
659 CIFS_I(inode
)->clientCanCacheRead
= false;
660 CIFS_I(inode
)->clientCanCacheAll
= false;
662 read_unlock(&GlobalSMBSeslock
);
663 if ((rc
== 0) && CIFS_I(inode
)->write_behind_rc
)
664 rc
= CIFS_I(inode
)->write_behind_rc
;
669 int cifs_closedir(struct inode
*inode
, struct file
*file
)
673 struct cifsFileInfo
*pCFileStruct
=
674 (struct cifsFileInfo
*)file
->private_data
;
677 cFYI(1, ("Closedir inode = 0x%p", inode
));
682 struct cifsTconInfo
*pTcon
;
683 struct cifs_sb_info
*cifs_sb
=
684 CIFS_SB(file
->f_path
.dentry
->d_sb
);
686 pTcon
= cifs_sb
->tcon
;
688 cFYI(1, ("Freeing private data in close dir"));
689 write_lock(&GlobalSMBSeslock
);
690 if (!pCFileStruct
->srch_inf
.endOfSearch
&&
691 !pCFileStruct
->invalidHandle
) {
692 pCFileStruct
->invalidHandle
= true;
693 write_unlock(&GlobalSMBSeslock
);
694 rc
= CIFSFindClose(xid
, pTcon
, pCFileStruct
->netfid
);
695 cFYI(1, ("Closing uncompleted readdir with rc %d",
697 /* not much we can do if it fails anyway, ignore rc */
700 write_unlock(&GlobalSMBSeslock
);
701 ptmp
= pCFileStruct
->srch_inf
.ntwrk_buf_start
;
703 cFYI(1, ("closedir free smb buf in srch struct"));
704 pCFileStruct
->srch_inf
.ntwrk_buf_start
= NULL
;
705 if (pCFileStruct
->srch_inf
.smallBuf
)
706 cifs_small_buf_release(ptmp
);
708 cifs_buf_release(ptmp
);
710 kfree(file
->private_data
);
711 file
->private_data
= NULL
;
713 /* BB can we lock the filestruct while this is going on? */
718 static int store_file_lock(struct cifsFileInfo
*fid
, __u64 len
,
719 __u64 offset
, __u8 lockType
)
721 struct cifsLockInfo
*li
=
722 kmalloc(sizeof(struct cifsLockInfo
), GFP_KERNEL
);
728 mutex_lock(&fid
->lock_mutex
);
729 list_add(&li
->llist
, &fid
->llist
);
730 mutex_unlock(&fid
->lock_mutex
);
734 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*pfLock
)
740 bool wait_flag
= false;
741 struct cifs_sb_info
*cifs_sb
;
742 struct cifsTconInfo
*tcon
;
744 __u8 lockType
= LOCKING_ANDX_LARGE_FILES
;
745 bool posix_locking
= 0;
747 length
= 1 + pfLock
->fl_end
- pfLock
->fl_start
;
751 cFYI(1, ("Lock parm: 0x%x flockflags: "
752 "0x%x flocktype: 0x%x start: %lld end: %lld",
753 cmd
, pfLock
->fl_flags
, pfLock
->fl_type
, pfLock
->fl_start
,
756 if (pfLock
->fl_flags
& FL_POSIX
)
758 if (pfLock
->fl_flags
& FL_FLOCK
)
760 if (pfLock
->fl_flags
& FL_SLEEP
) {
761 cFYI(1, ("Blocking lock"));
764 if (pfLock
->fl_flags
& FL_ACCESS
)
765 cFYI(1, ("Process suspended by mandatory locking - "
766 "not implemented yet"));
767 if (pfLock
->fl_flags
& FL_LEASE
)
768 cFYI(1, ("Lease on file - not implemented yet"));
769 if (pfLock
->fl_flags
&
770 (~(FL_POSIX
| FL_FLOCK
| FL_SLEEP
| FL_ACCESS
| FL_LEASE
)))
771 cFYI(1, ("Unknown lock flags 0x%x", pfLock
->fl_flags
));
773 if (pfLock
->fl_type
== F_WRLCK
) {
774 cFYI(1, ("F_WRLCK "));
776 } else if (pfLock
->fl_type
== F_UNLCK
) {
777 cFYI(1, ("F_UNLCK"));
779 /* Check if unlock includes more than
781 } else if (pfLock
->fl_type
== F_RDLCK
) {
782 cFYI(1, ("F_RDLCK"));
783 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
785 } else if (pfLock
->fl_type
== F_EXLCK
) {
786 cFYI(1, ("F_EXLCK"));
788 } else if (pfLock
->fl_type
== F_SHLCK
) {
789 cFYI(1, ("F_SHLCK"));
790 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
793 cFYI(1, ("Unknown type of lock"));
795 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
796 tcon
= cifs_sb
->tcon
;
798 if (file
->private_data
== NULL
) {
803 netfid
= ((struct cifsFileInfo
*)file
->private_data
)->netfid
;
805 if ((tcon
->ses
->capabilities
& CAP_UNIX
) &&
806 (CIFS_UNIX_FCNTL_CAP
& le64_to_cpu(tcon
->fsUnixInfo
.Capability
)) &&
807 ((cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_NOPOSIXBRL
) == 0))
809 /* BB add code here to normalize offset and length to
810 account for negative length which we can not accept over the
815 if (lockType
& LOCKING_ANDX_SHARED_LOCK
)
816 posix_lock_type
= CIFS_RDLCK
;
818 posix_lock_type
= CIFS_WRLCK
;
819 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, 1 /* get */,
821 posix_lock_type
, wait_flag
);
826 /* BB we could chain these into one lock request BB */
827 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
, pfLock
->fl_start
,
828 0, 1, lockType
, 0 /* wait flag */, 0);
830 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
831 pfLock
->fl_start
, 1 /* numUnlock */ ,
832 0 /* numLock */ , lockType
,
833 0 /* wait flag */, 0);
834 pfLock
->fl_type
= F_UNLCK
;
836 cERROR(1, ("Error unlocking previously locked "
837 "range %d during test of lock", rc
));
841 /* if rc == ERR_SHARING_VIOLATION ? */
842 rc
= 0; /* do not change lock type to unlock
843 since range in use */
850 if (!numLock
&& !numUnlock
) {
851 /* if no lock or unlock then nothing
852 to do since we do not know what it is */
859 if (lockType
& LOCKING_ANDX_SHARED_LOCK
)
860 posix_lock_type
= CIFS_RDLCK
;
862 posix_lock_type
= CIFS_WRLCK
;
865 posix_lock_type
= CIFS_UNLCK
;
867 rc
= CIFSSMBPosixLock(xid
, tcon
, netfid
, 0 /* set */,
869 posix_lock_type
, wait_flag
);
871 struct cifsFileInfo
*fid
=
872 (struct cifsFileInfo
*)file
->private_data
;
875 rc
= CIFSSMBLock(xid
, tcon
, netfid
, length
,
876 pfLock
->fl_start
, 0, numLock
, lockType
,
880 /* For Windows locks we must store them. */
881 rc
= store_file_lock(fid
, length
,
882 pfLock
->fl_start
, lockType
);
884 } else if (numUnlock
) {
885 /* For each stored lock that this unlock overlaps
886 completely, unlock it. */
888 struct cifsLockInfo
*li
, *tmp
;
891 mutex_lock(&fid
->lock_mutex
);
892 list_for_each_entry_safe(li
, tmp
, &fid
->llist
, llist
) {
893 if (pfLock
->fl_start
<= li
->offset
&&
894 (pfLock
->fl_start
+ length
) >=
895 (li
->offset
+ li
->length
)) {
896 stored_rc
= CIFSSMBLock(xid
, tcon
,
903 list_del(&li
->llist
);
907 mutex_unlock(&fid
->lock_mutex
);
911 if (pfLock
->fl_flags
& FL_POSIX
)
912 posix_lock_file_wait(file
, pfLock
);
918 * Set the timeout on write requests past EOF. For some servers (Windows)
919 * these calls can be very long.
921 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
922 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
923 * The 10M cutoff is totally arbitrary. A better scheme for this would be
924 * welcome if someone wants to suggest one.
926 * We may be able to do a better job with this if there were some way to
927 * declare that a file should be sparse.
930 cifs_write_timeout(struct cifsInodeInfo
*cifsi
, loff_t offset
)
932 if (offset
<= cifsi
->server_eof
)
934 else if (offset
> (cifsi
->server_eof
+ (10 * 1024 * 1024)))
935 return CIFS_VLONG_OP
;
940 /* update the file size (if needed) after a write */
942 cifs_update_eof(struct cifsInodeInfo
*cifsi
, loff_t offset
,
943 unsigned int bytes_written
)
945 loff_t end_of_write
= offset
+ bytes_written
;
947 if (end_of_write
> cifsi
->server_eof
)
948 cifsi
->server_eof
= end_of_write
;
951 ssize_t
cifs_user_write(struct file
*file
, const char __user
*write_data
,
952 size_t write_size
, loff_t
*poffset
)
955 unsigned int bytes_written
= 0;
956 unsigned int total_written
;
957 struct cifs_sb_info
*cifs_sb
;
958 struct cifsTconInfo
*pTcon
;
960 struct cifsFileInfo
*open_file
;
961 struct cifsInodeInfo
*cifsi
= CIFS_I(file
->f_path
.dentry
->d_inode
);
963 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
965 pTcon
= cifs_sb
->tcon
;
968 (" write %d bytes to offset %lld of %s", write_size,
969 *poffset, file->f_path.dentry->d_name.name)); */
971 if (file
->private_data
== NULL
)
973 open_file
= (struct cifsFileInfo
*) file
->private_data
;
975 rc
= generic_write_checks(file
, poffset
, &write_size
, 0);
981 long_op
= cifs_write_timeout(cifsi
, *poffset
);
982 for (total_written
= 0; write_size
> total_written
;
983 total_written
+= bytes_written
) {
985 while (rc
== -EAGAIN
) {
986 if (file
->private_data
== NULL
) {
987 /* file has been closed on us */
989 /* if we have gotten here we have written some data
990 and blocked, and the file has been freed on us while
991 we blocked so return what we managed to write */
992 return total_written
;
994 if (open_file
->closePend
) {
997 return total_written
;
1001 if (open_file
->invalidHandle
) {
1002 /* we could deadlock if we called
1003 filemap_fdatawait from here so tell
1004 reopen_file not to flush data to server
1006 rc
= cifs_reopen_file(file
, false);
1011 rc
= CIFSSMBWrite(xid
, pTcon
,
1013 min_t(const int, cifs_sb
->wsize
,
1014 write_size
- total_written
),
1015 *poffset
, &bytes_written
,
1016 NULL
, write_data
+ total_written
, long_op
);
1018 if (rc
|| (bytes_written
== 0)) {
1026 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1027 *poffset
+= bytes_written
;
1029 long_op
= CIFS_STD_OP
; /* subsequent writes fast -
1030 15 seconds is plenty */
1033 cifs_stats_bytes_written(pTcon
, total_written
);
1035 /* since the write may have blocked check these pointers again */
1036 if ((file
->f_path
.dentry
) && (file
->f_path
.dentry
->d_inode
)) {
1037 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1038 /* Do not update local mtime - server will set its actual value on write
1039 * inode->i_ctime = inode->i_mtime =
1040 * current_fs_time(inode->i_sb);*/
1041 if (total_written
> 0) {
1042 spin_lock(&inode
->i_lock
);
1043 if (*poffset
> file
->f_path
.dentry
->d_inode
->i_size
)
1044 i_size_write(file
->f_path
.dentry
->d_inode
,
1046 spin_unlock(&inode
->i_lock
);
1048 mark_inode_dirty_sync(file
->f_path
.dentry
->d_inode
);
1051 return total_written
;
1054 static ssize_t
cifs_write(struct file
*file
, const char *write_data
,
1055 size_t write_size
, loff_t
*poffset
)
1058 unsigned int bytes_written
= 0;
1059 unsigned int total_written
;
1060 struct cifs_sb_info
*cifs_sb
;
1061 struct cifsTconInfo
*pTcon
;
1063 struct cifsFileInfo
*open_file
;
1064 struct cifsInodeInfo
*cifsi
= CIFS_I(file
->f_path
.dentry
->d_inode
);
1066 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1068 pTcon
= cifs_sb
->tcon
;
1070 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size
,
1071 *poffset
, file
->f_path
.dentry
->d_name
.name
));
1073 if (file
->private_data
== NULL
)
1075 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1079 long_op
= cifs_write_timeout(cifsi
, *poffset
);
1080 for (total_written
= 0; write_size
> total_written
;
1081 total_written
+= bytes_written
) {
1083 while (rc
== -EAGAIN
) {
1084 if (file
->private_data
== NULL
) {
1085 /* file has been closed on us */
1087 /* if we have gotten here we have written some data
1088 and blocked, and the file has been freed on us
1089 while we blocked so return what we managed to
1091 return total_written
;
1093 if (open_file
->closePend
) {
1096 return total_written
;
1100 if (open_file
->invalidHandle
) {
1101 /* we could deadlock if we called
1102 filemap_fdatawait from here so tell
1103 reopen_file not to flush data to
1105 rc
= cifs_reopen_file(file
, false);
1109 if (experimEnabled
|| (pTcon
->ses
->server
&&
1110 ((pTcon
->ses
->server
->secMode
&
1111 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
1116 len
= min((size_t)cifs_sb
->wsize
,
1117 write_size
- total_written
);
1118 /* iov[0] is reserved for smb header */
1119 iov
[1].iov_base
= (char *)write_data
+
1121 iov
[1].iov_len
= len
;
1122 rc
= CIFSSMBWrite2(xid
, pTcon
,
1123 open_file
->netfid
, len
,
1124 *poffset
, &bytes_written
,
1127 rc
= CIFSSMBWrite(xid
, pTcon
,
1129 min_t(const int, cifs_sb
->wsize
,
1130 write_size
- total_written
),
1131 *poffset
, &bytes_written
,
1132 write_data
+ total_written
,
1135 if (rc
|| (bytes_written
== 0)) {
1143 cifs_update_eof(cifsi
, *poffset
, bytes_written
);
1144 *poffset
+= bytes_written
;
1146 long_op
= CIFS_STD_OP
; /* subsequent writes fast -
1147 15 seconds is plenty */
1150 cifs_stats_bytes_written(pTcon
, total_written
);
1152 /* since the write may have blocked check these pointers again */
1153 if ((file
->f_path
.dentry
) && (file
->f_path
.dentry
->d_inode
)) {
1154 /*BB We could make this contingent on superblock ATIME flag too */
1155 /* file->f_path.dentry->d_inode->i_ctime =
1156 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1157 if (total_written
> 0) {
1158 spin_lock(&file
->f_path
.dentry
->d_inode
->i_lock
);
1159 if (*poffset
> file
->f_path
.dentry
->d_inode
->i_size
)
1160 i_size_write(file
->f_path
.dentry
->d_inode
,
1162 spin_unlock(&file
->f_path
.dentry
->d_inode
->i_lock
);
1164 mark_inode_dirty_sync(file
->f_path
.dentry
->d_inode
);
1167 return total_written
;
1170 #ifdef CONFIG_CIFS_EXPERIMENTAL
1171 struct cifsFileInfo
*find_readable_file(struct cifsInodeInfo
*cifs_inode
)
1173 struct cifsFileInfo
*open_file
= NULL
;
1175 read_lock(&GlobalSMBSeslock
);
1176 /* we could simply get the first_list_entry since write-only entries
1177 are always at the end of the list but since the first entry might
1178 have a close pending, we go through the whole list */
1179 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1180 if (open_file
->closePend
)
1182 if (open_file
->pfile
&& ((open_file
->pfile
->f_flags
& O_RDWR
) ||
1183 (open_file
->pfile
->f_flags
& O_RDONLY
))) {
1184 if (!open_file
->invalidHandle
) {
1185 /* found a good file */
1186 /* lock it so it will not be closed on us */
1187 cifsFileInfo_get(open_file
);
1188 read_unlock(&GlobalSMBSeslock
);
1190 } /* else might as well continue, and look for
1191 another, or simply have the caller reopen it
1192 again rather than trying to fix this handle */
1193 } else /* write only file */
1194 break; /* write only files are last so must be done */
1196 read_unlock(&GlobalSMBSeslock
);
1201 struct cifsFileInfo
*find_writable_file(struct cifsInodeInfo
*cifs_inode
)
1203 struct cifsFileInfo
*open_file
;
1204 bool any_available
= false;
1207 /* Having a null inode here (because mapping->host was set to zero by
1208 the VFS or MM) should not happen but we had reports of on oops (due to
1209 it being zero) during stress testcases so we need to check for it */
1211 if (cifs_inode
== NULL
) {
1212 cERROR(1, ("Null inode passed to cifs_writeable_file"));
1217 read_lock(&GlobalSMBSeslock
);
1219 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
1220 if (open_file
->closePend
||
1221 (!any_available
&& open_file
->pid
!= current
->tgid
))
1224 if (open_file
->pfile
&&
1225 ((open_file
->pfile
->f_flags
& O_RDWR
) ||
1226 (open_file
->pfile
->f_flags
& O_WRONLY
))) {
1227 cifsFileInfo_get(open_file
);
1229 if (!open_file
->invalidHandle
) {
1230 /* found a good writable file */
1231 read_unlock(&GlobalSMBSeslock
);
1235 read_unlock(&GlobalSMBSeslock
);
1236 /* Had to unlock since following call can block */
1237 rc
= cifs_reopen_file(open_file
->pfile
, false);
1239 if (!open_file
->closePend
)
1241 else { /* start over in case this was deleted */
1242 /* since the list could be modified */
1243 read_lock(&GlobalSMBSeslock
);
1244 cifsFileInfo_put(open_file
);
1245 goto refind_writable
;
1249 /* if it fails, try another handle if possible -
1250 (we can not do this if closePending since
1251 loop could be modified - in which case we
1252 have to start at the beginning of the list
1253 again. Note that it would be bad
1254 to hold up writepages here (rather than
1255 in caller) with continuous retries */
1256 cFYI(1, ("wp failed on reopen file"));
1257 read_lock(&GlobalSMBSeslock
);
1258 /* can not use this handle, no write
1259 pending on this one after all */
1260 cifsFileInfo_put(open_file
);
1262 if (open_file
->closePend
) /* list could have changed */
1263 goto refind_writable
;
1264 /* else we simply continue to the next entry. Thus
1265 we do not loop on reopen errors. If we
1266 can not reopen the file, for example if we
1267 reconnected to a server with another client
1268 racing to delete or lock the file we would not
1269 make progress if we restarted before the beginning
1270 of the loop here. */
1273 /* couldn't find useable FH with same pid, try any available */
1274 if (!any_available
) {
1275 any_available
= true;
1276 goto refind_writable
;
1278 read_unlock(&GlobalSMBSeslock
);
1282 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
1284 struct address_space
*mapping
= page
->mapping
;
1285 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1288 int bytes_written
= 0;
1289 struct cifs_sb_info
*cifs_sb
;
1290 struct cifsTconInfo
*pTcon
;
1291 struct inode
*inode
;
1292 struct cifsFileInfo
*open_file
;
1294 if (!mapping
|| !mapping
->host
)
1297 inode
= page
->mapping
->host
;
1298 cifs_sb
= CIFS_SB(inode
->i_sb
);
1299 pTcon
= cifs_sb
->tcon
;
1301 offset
+= (loff_t
)from
;
1302 write_data
= kmap(page
);
1305 if ((to
> PAGE_CACHE_SIZE
) || (from
> to
)) {
1310 /* racing with truncate? */
1311 if (offset
> mapping
->host
->i_size
) {
1313 return 0; /* don't care */
1316 /* check to make sure that we are not extending the file */
1317 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
1318 to
= (unsigned)(mapping
->host
->i_size
- offset
);
1320 open_file
= find_writable_file(CIFS_I(mapping
->host
));
1322 bytes_written
= cifs_write(open_file
->pfile
, write_data
,
1324 cifsFileInfo_put(open_file
);
1325 /* Does mm or vfs already set times? */
1326 inode
->i_atime
= inode
->i_mtime
= current_fs_time(inode
->i_sb
);
1327 if ((bytes_written
> 0) && (offset
))
1329 else if (bytes_written
< 0)
1332 cFYI(1, ("No writeable filehandles for inode"));
1340 static int cifs_writepages(struct address_space
*mapping
,
1341 struct writeback_control
*wbc
)
1343 struct backing_dev_info
*bdi
= mapping
->backing_dev_info
;
1344 unsigned int bytes_to_write
;
1345 unsigned int bytes_written
;
1346 struct cifs_sb_info
*cifs_sb
;
1350 int range_whole
= 0;
1357 struct cifsFileInfo
*open_file
;
1358 struct cifsInodeInfo
*cifsi
= CIFS_I(mapping
->host
);
1360 struct pagevec pvec
;
1365 cifs_sb
= CIFS_SB(mapping
->host
->i_sb
);
1368 * If wsize is smaller that the page cache size, default to writing
1369 * one page at a time via cifs_writepage
1371 if (cifs_sb
->wsize
< PAGE_CACHE_SIZE
)
1372 return generic_writepages(mapping
, wbc
);
1374 if ((cifs_sb
->tcon
->ses
) && (cifs_sb
->tcon
->ses
->server
))
1375 if (cifs_sb
->tcon
->ses
->server
->secMode
&
1376 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
))
1377 if (!experimEnabled
)
1378 return generic_writepages(mapping
, wbc
);
1380 iov
= kmalloc(32 * sizeof(struct kvec
), GFP_KERNEL
);
1382 return generic_writepages(mapping
, wbc
);
1386 * BB: Is this meaningful for a non-block-device file system?
1387 * If it is, we should test it again after we do I/O
1389 if (wbc
->nonblocking
&& bdi_write_congested(bdi
)) {
1390 wbc
->encountered_congestion
= 1;
1397 pagevec_init(&pvec
, 0);
1398 if (wbc
->range_cyclic
) {
1399 index
= mapping
->writeback_index
; /* Start from prev offset */
1402 index
= wbc
->range_start
>> PAGE_CACHE_SHIFT
;
1403 end
= wbc
->range_end
>> PAGE_CACHE_SHIFT
;
1404 if (wbc
->range_start
== 0 && wbc
->range_end
== LLONG_MAX
)
1409 while (!done
&& (index
<= end
) &&
1410 (nr_pages
= pagevec_lookup_tag(&pvec
, mapping
, &index
,
1411 PAGECACHE_TAG_DIRTY
,
1412 min(end
- index
, (pgoff_t
)PAGEVEC_SIZE
- 1) + 1))) {
1421 for (i
= 0; i
< nr_pages
; i
++) {
1422 page
= pvec
.pages
[i
];
1424 * At this point we hold neither mapping->tree_lock nor
1425 * lock on the page itself: the page may be truncated or
1426 * invalidated (changing page->mapping to NULL), or even
1427 * swizzled back from swapper_space to tmpfs file
1433 else if (!trylock_page(page
))
1436 if (unlikely(page
->mapping
!= mapping
)) {
1441 if (!wbc
->range_cyclic
&& page
->index
> end
) {
1447 if (next
&& (page
->index
!= next
)) {
1448 /* Not next consecutive page */
1453 if (wbc
->sync_mode
!= WB_SYNC_NONE
)
1454 wait_on_page_writeback(page
);
1456 if (PageWriteback(page
) ||
1457 !clear_page_dirty_for_io(page
)) {
1463 * This actually clears the dirty bit in the radix tree.
1464 * See cifs_writepage() for more commentary.
1466 set_page_writeback(page
);
1468 if (page_offset(page
) >= mapping
->host
->i_size
) {
1471 end_page_writeback(page
);
1476 * BB can we get rid of this? pages are held by pvec
1478 page_cache_get(page
);
1480 len
= min(mapping
->host
->i_size
- page_offset(page
),
1481 (loff_t
)PAGE_CACHE_SIZE
);
1483 /* reserve iov[0] for the smb header */
1485 iov
[n_iov
].iov_base
= kmap(page
);
1486 iov
[n_iov
].iov_len
= len
;
1487 bytes_to_write
+= len
;
1491 offset
= page_offset(page
);
1493 next
= page
->index
+ 1;
1494 if (bytes_to_write
+ PAGE_CACHE_SIZE
> cifs_sb
->wsize
)
1498 /* Search for a writable handle every time we call
1499 * CIFSSMBWrite2. We can't rely on the last handle
1500 * we used to still be valid
1502 open_file
= find_writable_file(CIFS_I(mapping
->host
));
1504 cERROR(1, ("No writable handles for inode"));
1507 long_op
= cifs_write_timeout(cifsi
, offset
);
1508 rc
= CIFSSMBWrite2(xid
, cifs_sb
->tcon
,
1510 bytes_to_write
, offset
,
1511 &bytes_written
, iov
, n_iov
,
1513 cifsFileInfo_put(open_file
);
1514 cifs_update_eof(cifsi
, offset
, bytes_written
);
1516 if (rc
|| bytes_written
< bytes_to_write
) {
1517 cERROR(1, ("Write2 ret %d, wrote %d",
1518 rc
, bytes_written
));
1519 /* BB what if continued retry is
1520 requested via mount flags? */
1522 set_bit(AS_ENOSPC
, &mapping
->flags
);
1524 set_bit(AS_EIO
, &mapping
->flags
);
1526 cifs_stats_bytes_written(cifs_sb
->tcon
,
1530 for (i
= 0; i
< n_iov
; i
++) {
1531 page
= pvec
.pages
[first
+ i
];
1532 /* Should we also set page error on
1533 success rc but too little data written? */
1534 /* BB investigate retry logic on temporary
1535 server crash cases and how recovery works
1536 when page marked as error */
1541 end_page_writeback(page
);
1542 page_cache_release(page
);
1544 if ((wbc
->nr_to_write
-= n_iov
) <= 0)
1548 /* Need to re-find the pages we skipped */
1549 index
= pvec
.pages
[0]->index
+ 1;
1551 pagevec_release(&pvec
);
1553 if (!scanned
&& !done
) {
1555 * We hit the last page and there is more work to be done: wrap
1556 * back to the start of the file
1562 if (wbc
->range_cyclic
|| (range_whole
&& wbc
->nr_to_write
> 0))
1563 mapping
->writeback_index
= index
;
1570 static int cifs_writepage(struct page
*page
, struct writeback_control
*wbc
)
1576 /* BB add check for wbc flags */
1577 page_cache_get(page
);
1578 if (!PageUptodate(page
))
1579 cFYI(1, ("ppw - page not up to date"));
1582 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1584 * A writepage() implementation always needs to do either this,
1585 * or re-dirty the page with "redirty_page_for_writepage()" in
1586 * the case of a failure.
1588 * Just unlocking the page will cause the radix tree tag-bits
1589 * to fail to update with the state of the page correctly.
1591 set_page_writeback(page
);
1592 rc
= cifs_partialpagewrite(page
, 0, PAGE_CACHE_SIZE
);
1593 SetPageUptodate(page
); /* BB add check for error and Clearuptodate? */
1595 end_page_writeback(page
);
1596 page_cache_release(page
);
1601 static int cifs_write_end(struct file
*file
, struct address_space
*mapping
,
1602 loff_t pos
, unsigned len
, unsigned copied
,
1603 struct page
*page
, void *fsdata
)
1606 struct inode
*inode
= mapping
->host
;
1608 cFYI(1, ("write_end for page %p from pos %lld with %d bytes",
1609 page
, pos
, copied
));
1611 if (PageChecked(page
)) {
1613 SetPageUptodate(page
);
1614 ClearPageChecked(page
);
1615 } else if (!PageUptodate(page
) && copied
== PAGE_CACHE_SIZE
)
1616 SetPageUptodate(page
);
1618 if (!PageUptodate(page
)) {
1620 unsigned offset
= pos
& (PAGE_CACHE_SIZE
- 1);
1624 /* this is probably better than directly calling
1625 partialpage_write since in this function the file handle is
1626 known which we might as well leverage */
1627 /* BB check if anything else missing out of ppw
1628 such as updating last write time */
1629 page_data
= kmap(page
);
1630 rc
= cifs_write(file
, page_data
+ offset
, copied
, &pos
);
1631 /* if (rc < 0) should we set writebehind rc? */
1638 set_page_dirty(page
);
1642 spin_lock(&inode
->i_lock
);
1643 if (pos
> inode
->i_size
)
1644 i_size_write(inode
, pos
);
1645 spin_unlock(&inode
->i_lock
);
1649 page_cache_release(page
);
1654 int cifs_fsync(struct file
*file
, struct dentry
*dentry
, int datasync
)
1658 struct cifsTconInfo
*tcon
;
1659 struct cifsFileInfo
*smbfile
=
1660 (struct cifsFileInfo
*)file
->private_data
;
1661 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1665 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
1666 dentry
->d_name
.name
, datasync
));
1668 rc
= filemap_write_and_wait(inode
->i_mapping
);
1670 rc
= CIFS_I(inode
)->write_behind_rc
;
1671 CIFS_I(inode
)->write_behind_rc
= 0;
1672 tcon
= CIFS_SB(inode
->i_sb
)->tcon
;
1673 if (!rc
&& tcon
&& smbfile
&&
1674 !(CIFS_SB(inode
->i_sb
)->mnt_cifs_flags
& CIFS_MOUNT_NOSSYNC
))
1675 rc
= CIFSSMBFlush(xid
, tcon
, smbfile
->netfid
);
1682 /* static void cifs_sync_page(struct page *page)
1684 struct address_space *mapping;
1685 struct inode *inode;
1686 unsigned long index = page->index;
1687 unsigned int rpages = 0;
1690 cFYI(1, ("sync page %p",page));
1691 mapping = page->mapping;
1694 inode = mapping->host;
1698 /* fill in rpages then
1699 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1701 /* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
1711 * As file closes, flush all cached write data for this inode checking
1712 * for write behind errors.
1714 int cifs_flush(struct file
*file
, fl_owner_t id
)
1716 struct inode
*inode
= file
->f_path
.dentry
->d_inode
;
1719 /* Rather than do the steps manually:
1720 lock the inode for writing
1721 loop through pages looking for write behind data (dirty pages)
1722 coalesce into contiguous 16K (or smaller) chunks to write to server
1723 send to server (prefer in parallel)
1724 deal with writebehind errors
1725 unlock inode for writing
1726 filemapfdatawrite appears easier for the time being */
1728 rc
= filemap_fdatawrite(inode
->i_mapping
);
1729 /* reset wb rc if we were able to write out dirty pages */
1731 rc
= CIFS_I(inode
)->write_behind_rc
;
1732 CIFS_I(inode
)->write_behind_rc
= 0;
1735 cFYI(1, ("Flush inode %p file %p rc %d", inode
, file
, rc
));
1740 ssize_t
cifs_user_read(struct file
*file
, char __user
*read_data
,
1741 size_t read_size
, loff_t
*poffset
)
1744 unsigned int bytes_read
= 0;
1745 unsigned int total_read
= 0;
1746 unsigned int current_read_size
;
1747 struct cifs_sb_info
*cifs_sb
;
1748 struct cifsTconInfo
*pTcon
;
1750 struct cifsFileInfo
*open_file
;
1751 char *smb_read_data
;
1752 char __user
*current_offset
;
1753 struct smb_com_read_rsp
*pSMBr
;
1756 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1757 pTcon
= cifs_sb
->tcon
;
1759 if (file
->private_data
== NULL
) {
1764 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1766 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1767 cFYI(1, ("attempting read on write only file instance"));
1769 for (total_read
= 0, current_offset
= read_data
;
1770 read_size
> total_read
;
1771 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1772 current_read_size
= min_t(const int, read_size
- total_read
,
1775 smb_read_data
= NULL
;
1776 while (rc
== -EAGAIN
) {
1777 int buf_type
= CIFS_NO_BUFFER
;
1778 if ((open_file
->invalidHandle
) &&
1779 (!open_file
->closePend
)) {
1780 rc
= cifs_reopen_file(file
, true);
1784 rc
= CIFSSMBRead(xid
, pTcon
,
1786 current_read_size
, *poffset
,
1787 &bytes_read
, &smb_read_data
,
1789 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
1790 if (smb_read_data
) {
1791 if (copy_to_user(current_offset
,
1793 4 /* RFC1001 length field */ +
1794 le16_to_cpu(pSMBr
->DataOffset
),
1798 if (buf_type
== CIFS_SMALL_BUFFER
)
1799 cifs_small_buf_release(smb_read_data
);
1800 else if (buf_type
== CIFS_LARGE_BUFFER
)
1801 cifs_buf_release(smb_read_data
);
1802 smb_read_data
= NULL
;
1805 if (rc
|| (bytes_read
== 0)) {
1813 cifs_stats_bytes_read(pTcon
, bytes_read
);
1814 *poffset
+= bytes_read
;
1822 static ssize_t
cifs_read(struct file
*file
, char *read_data
, size_t read_size
,
1826 unsigned int bytes_read
= 0;
1827 unsigned int total_read
;
1828 unsigned int current_read_size
;
1829 struct cifs_sb_info
*cifs_sb
;
1830 struct cifsTconInfo
*pTcon
;
1832 char *current_offset
;
1833 struct cifsFileInfo
*open_file
;
1834 int buf_type
= CIFS_NO_BUFFER
;
1837 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1838 pTcon
= cifs_sb
->tcon
;
1840 if (file
->private_data
== NULL
) {
1845 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1847 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1848 cFYI(1, ("attempting read on write only file instance"));
1850 for (total_read
= 0, current_offset
= read_data
;
1851 read_size
> total_read
;
1852 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1853 current_read_size
= min_t(const int, read_size
- total_read
,
1855 /* For windows me and 9x we do not want to request more
1856 than it negotiated since it will refuse the read then */
1858 !(pTcon
->ses
->capabilities
& CAP_LARGE_FILES
)) {
1859 current_read_size
= min_t(const int, current_read_size
,
1860 pTcon
->ses
->server
->maxBuf
- 128);
1863 while (rc
== -EAGAIN
) {
1864 if ((open_file
->invalidHandle
) &&
1865 (!open_file
->closePend
)) {
1866 rc
= cifs_reopen_file(file
, true);
1870 rc
= CIFSSMBRead(xid
, pTcon
,
1872 current_read_size
, *poffset
,
1873 &bytes_read
, ¤t_offset
,
1876 if (rc
|| (bytes_read
== 0)) {
1884 cifs_stats_bytes_read(pTcon
, total_read
);
1885 *poffset
+= bytes_read
;
1892 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1894 struct dentry
*dentry
= file
->f_path
.dentry
;
1898 rc
= cifs_revalidate(dentry
);
1900 cFYI(1, ("Validation prior to mmap failed, error=%d", rc
));
1904 rc
= generic_file_mmap(file
, vma
);
1910 static void cifs_copy_cache_pages(struct address_space
*mapping
,
1911 struct list_head
*pages
, int bytes_read
, char *data
,
1912 struct pagevec
*plru_pvec
)
1917 while (bytes_read
> 0) {
1918 if (list_empty(pages
))
1921 page
= list_entry(pages
->prev
, struct page
, lru
);
1922 list_del(&page
->lru
);
1924 if (add_to_page_cache(page
, mapping
, page
->index
,
1926 page_cache_release(page
);
1927 cFYI(1, ("Add page cache failed"));
1928 data
+= PAGE_CACHE_SIZE
;
1929 bytes_read
-= PAGE_CACHE_SIZE
;
1933 target
= kmap_atomic(page
, KM_USER0
);
1935 if (PAGE_CACHE_SIZE
> bytes_read
) {
1936 memcpy(target
, data
, bytes_read
);
1937 /* zero the tail end of this partial page */
1938 memset(target
+ bytes_read
, 0,
1939 PAGE_CACHE_SIZE
- bytes_read
);
1942 memcpy(target
, data
, PAGE_CACHE_SIZE
);
1943 bytes_read
-= PAGE_CACHE_SIZE
;
1945 kunmap_atomic(target
, KM_USER0
);
1947 flush_dcache_page(page
);
1948 SetPageUptodate(page
);
1950 if (!pagevec_add(plru_pvec
, page
))
1951 __pagevec_lru_add_file(plru_pvec
);
1952 data
+= PAGE_CACHE_SIZE
;
1957 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
1958 struct list_head
*page_list
, unsigned num_pages
)
1964 struct cifs_sb_info
*cifs_sb
;
1965 struct cifsTconInfo
*pTcon
;
1966 unsigned int bytes_read
= 0;
1967 unsigned int read_size
, i
;
1968 char *smb_read_data
= NULL
;
1969 struct smb_com_read_rsp
*pSMBr
;
1970 struct pagevec lru_pvec
;
1971 struct cifsFileInfo
*open_file
;
1972 int buf_type
= CIFS_NO_BUFFER
;
1975 if (file
->private_data
== NULL
) {
1980 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1981 cifs_sb
= CIFS_SB(file
->f_path
.dentry
->d_sb
);
1982 pTcon
= cifs_sb
->tcon
;
1984 pagevec_init(&lru_pvec
, 0);
1985 cFYI(DBG2
, ("rpages: num pages %d", num_pages
));
1986 for (i
= 0; i
< num_pages
; ) {
1987 unsigned contig_pages
;
1988 struct page
*tmp_page
;
1989 unsigned long expected_index
;
1991 if (list_empty(page_list
))
1994 page
= list_entry(page_list
->prev
, struct page
, lru
);
1995 offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1997 /* count adjacent pages that we will read into */
2000 list_entry(page_list
->prev
, struct page
, lru
)->index
;
2001 list_for_each_entry_reverse(tmp_page
, page_list
, lru
) {
2002 if (tmp_page
->index
== expected_index
) {
2008 if (contig_pages
+ i
> num_pages
)
2009 contig_pages
= num_pages
- i
;
2011 /* for reads over a certain size could initiate async
2014 read_size
= contig_pages
* PAGE_CACHE_SIZE
;
2015 /* Read size needs to be in multiples of one page */
2016 read_size
= min_t(const unsigned int, read_size
,
2017 cifs_sb
->rsize
& PAGE_CACHE_MASK
);
2018 cFYI(DBG2
, ("rpages: read size 0x%x contiguous pages %d",
2019 read_size
, contig_pages
));
2021 while (rc
== -EAGAIN
) {
2022 if ((open_file
->invalidHandle
) &&
2023 (!open_file
->closePend
)) {
2024 rc
= cifs_reopen_file(file
, true);
2029 rc
= CIFSSMBRead(xid
, pTcon
,
2032 &bytes_read
, &smb_read_data
,
2034 /* BB more RC checks ? */
2035 if (rc
== -EAGAIN
) {
2036 if (smb_read_data
) {
2037 if (buf_type
== CIFS_SMALL_BUFFER
)
2038 cifs_small_buf_release(smb_read_data
);
2039 else if (buf_type
== CIFS_LARGE_BUFFER
)
2040 cifs_buf_release(smb_read_data
);
2041 smb_read_data
= NULL
;
2045 if ((rc
< 0) || (smb_read_data
== NULL
)) {
2046 cFYI(1, ("Read error in readpages: %d", rc
));
2048 } else if (bytes_read
> 0) {
2049 task_io_account_read(bytes_read
);
2050 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
2051 cifs_copy_cache_pages(mapping
, page_list
, bytes_read
,
2052 smb_read_data
+ 4 /* RFC1001 hdr */ +
2053 le16_to_cpu(pSMBr
->DataOffset
), &lru_pvec
);
2055 i
+= bytes_read
>> PAGE_CACHE_SHIFT
;
2056 cifs_stats_bytes_read(pTcon
, bytes_read
);
2057 if ((bytes_read
& PAGE_CACHE_MASK
) != bytes_read
) {
2058 i
++; /* account for partial page */
2060 /* server copy of file can have smaller size
2062 /* BB do we need to verify this common case ?
2063 this case is ok - if we are at server EOF
2064 we will hit it on next read */
2069 cFYI(1, ("No bytes read (%d) at offset %lld . "
2070 "Cleaning remaining pages from readahead list",
2071 bytes_read
, offset
));
2072 /* BB turn off caching and do new lookup on
2073 file size at server? */
2076 if (smb_read_data
) {
2077 if (buf_type
== CIFS_SMALL_BUFFER
)
2078 cifs_small_buf_release(smb_read_data
);
2079 else if (buf_type
== CIFS_LARGE_BUFFER
)
2080 cifs_buf_release(smb_read_data
);
2081 smb_read_data
= NULL
;
2086 pagevec_lru_add_file(&lru_pvec
);
2088 /* need to free smb_read_data buf before exit */
2089 if (smb_read_data
) {
2090 if (buf_type
== CIFS_SMALL_BUFFER
)
2091 cifs_small_buf_release(smb_read_data
);
2092 else if (buf_type
== CIFS_LARGE_BUFFER
)
2093 cifs_buf_release(smb_read_data
);
2094 smb_read_data
= NULL
;
2101 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
2107 page_cache_get(page
);
2108 read_data
= kmap(page
);
2109 /* for reads over a certain size could initiate async read ahead */
2111 rc
= cifs_read(file
, read_data
, PAGE_CACHE_SIZE
, poffset
);
2116 cFYI(1, ("Bytes read %d", rc
));
2118 file
->f_path
.dentry
->d_inode
->i_atime
=
2119 current_fs_time(file
->f_path
.dentry
->d_inode
->i_sb
);
2121 if (PAGE_CACHE_SIZE
> rc
)
2122 memset(read_data
+ rc
, 0, PAGE_CACHE_SIZE
- rc
);
2124 flush_dcache_page(page
);
2125 SetPageUptodate(page
);
2130 page_cache_release(page
);
2134 static int cifs_readpage(struct file
*file
, struct page
*page
)
2136 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
2142 if (file
->private_data
== NULL
) {
2148 cFYI(1, ("readpage %p at offset %d 0x%x\n",
2149 page
, (int)offset
, (int)offset
));
2151 rc
= cifs_readpage_worker(file
, page
, &offset
);
2159 static int is_inode_writable(struct cifsInodeInfo
*cifs_inode
)
2161 struct cifsFileInfo
*open_file
;
2163 read_lock(&GlobalSMBSeslock
);
2164 list_for_each_entry(open_file
, &cifs_inode
->openFileList
, flist
) {
2165 if (open_file
->closePend
)
2167 if (open_file
->pfile
&&
2168 ((open_file
->pfile
->f_flags
& O_RDWR
) ||
2169 (open_file
->pfile
->f_flags
& O_WRONLY
))) {
2170 read_unlock(&GlobalSMBSeslock
);
2174 read_unlock(&GlobalSMBSeslock
);
2178 /* We do not want to update the file size from server for inodes
2179 open for write - to avoid races with writepage extending
2180 the file - in the future we could consider allowing
2181 refreshing the inode only on increases in the file size
2182 but this is tricky to do without racing with writebehind
2183 page caching in the current Linux kernel design */
2184 bool is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
, __u64 end_of_file
)
2189 if (is_inode_writable(cifsInode
)) {
2190 /* This inode is open for write at least once */
2191 struct cifs_sb_info
*cifs_sb
;
2193 cifs_sb
= CIFS_SB(cifsInode
->vfs_inode
.i_sb
);
2194 if (cifs_sb
->mnt_cifs_flags
& CIFS_MOUNT_DIRECT_IO
) {
2195 /* since no page cache to corrupt on directio
2196 we can change size safely */
2200 if (i_size_read(&cifsInode
->vfs_inode
) < end_of_file
)
2208 static int cifs_write_begin(struct file
*file
, struct address_space
*mapping
,
2209 loff_t pos
, unsigned len
, unsigned flags
,
2210 struct page
**pagep
, void **fsdata
)
2212 pgoff_t index
= pos
>> PAGE_CACHE_SHIFT
;
2213 loff_t offset
= pos
& (PAGE_CACHE_SIZE
- 1);
2214 loff_t page_start
= pos
& PAGE_MASK
;
2219 cFYI(1, ("write_begin from %lld len %d", (long long)pos
, len
));
2221 page
= grab_cache_page_write_begin(mapping
, index
, flags
);
2227 if (PageUptodate(page
))
2231 * If we write a full page it will be up to date, no need to read from
2232 * the server. If the write is short, we'll end up doing a sync write
2235 if (len
== PAGE_CACHE_SIZE
)
2239 * optimize away the read when we have an oplock, and we're not
2240 * expecting to use any of the data we'd be reading in. That
2241 * is, when the page lies beyond the EOF, or straddles the EOF
2242 * and the write will cover all of the existing data.
2244 if (CIFS_I(mapping
->host
)->clientCanCacheRead
) {
2245 i_size
= i_size_read(mapping
->host
);
2246 if (page_start
>= i_size
||
2247 (offset
== 0 && (pos
+ len
) >= i_size
)) {
2248 zero_user_segments(page
, 0, offset
,
2252 * PageChecked means that the parts of the page
2253 * to which we're not writing are considered up
2254 * to date. Once the data is copied to the
2255 * page, it can be set uptodate.
2257 SetPageChecked(page
);
2262 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
) {
2264 * might as well read a page, it is fast enough. If we get
2265 * an error, we don't need to return it. cifs_write_end will
2266 * do a sync write instead since PG_uptodate isn't set.
2268 cifs_readpage_worker(file
, page
, &page_start
);
2270 /* we could try using another file handle if there is one -
2271 but how would we lock it to prevent close of that handle
2272 racing with this read? In any case
2273 this will be written out by write_end so is fine */
2281 cifs_oplock_break(struct slow_work
*work
)
2283 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2285 struct inode
*inode
= cfile
->pInode
;
2286 struct cifsInodeInfo
*cinode
= CIFS_I(inode
);
2287 struct cifs_sb_info
*cifs_sb
= CIFS_SB(cfile
->mnt
->mnt_sb
);
2290 if (inode
&& S_ISREG(inode
->i_mode
)) {
2291 #ifdef CONFIG_CIFS_EXPERIMENTAL
2292 if (cinode
->clientCanCacheAll
== 0)
2293 break_lease(inode
, FMODE_READ
);
2294 else if (cinode
->clientCanCacheRead
== 0)
2295 break_lease(inode
, FMODE_WRITE
);
2297 rc
= filemap_fdatawrite(inode
->i_mapping
);
2298 if (cinode
->clientCanCacheRead
== 0) {
2299 waitrc
= filemap_fdatawait(inode
->i_mapping
);
2300 invalidate_remote_inode(inode
);
2305 cinode
->write_behind_rc
= rc
;
2306 cFYI(1, ("Oplock flush inode %p rc %d", inode
, rc
));
2310 * releasing stale oplock after recent reconnect of smb session using
2311 * a now incorrect file handle is not a data integrity issue but do
2312 * not bother sending an oplock release if session to server still is
2313 * disconnected since oplock already released by the server
2315 if (!cfile
->closePend
&& !cfile
->oplock_break_cancelled
) {
2316 rc
= CIFSSMBLock(0, cifs_sb
->tcon
, cfile
->netfid
, 0, 0, 0, 0,
2317 LOCKING_ANDX_OPLOCK_RELEASE
, false,
2318 cinode
->clientCanCacheRead
? 1 : 0);
2319 cFYI(1, ("Oplock release rc = %d", rc
));
2324 cifs_oplock_break_get(struct slow_work
*work
)
2326 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2329 cifsFileInfo_get(cfile
);
2334 cifs_oplock_break_put(struct slow_work
*work
)
2336 struct cifsFileInfo
*cfile
= container_of(work
, struct cifsFileInfo
,
2339 cifsFileInfo_put(cfile
);
2342 const struct slow_work_ops cifs_oplock_break_ops
= {
2343 .get_ref
= cifs_oplock_break_get
,
2344 .put_ref
= cifs_oplock_break_put
,
2345 .execute
= cifs_oplock_break
,
2348 const struct address_space_operations cifs_addr_ops
= {
2349 .readpage
= cifs_readpage
,
2350 .readpages
= cifs_readpages
,
2351 .writepage
= cifs_writepage
,
2352 .writepages
= cifs_writepages
,
2353 .write_begin
= cifs_write_begin
,
2354 .write_end
= cifs_write_end
,
2355 .set_page_dirty
= __set_page_dirty_nobuffers
,
2356 /* .sync_page = cifs_sync_page, */
2361 * cifs_readpages requires the server to support a buffer large enough to
2362 * contain the header plus one complete page of data. Otherwise, we need
2363 * to leave cifs_readpages out of the address space operations.
2365 const struct address_space_operations cifs_addr_ops_smallbuf
= {
2366 .readpage
= cifs_readpage
,
2367 .writepage
= cifs_writepage
,
2368 .writepages
= cifs_writepages
,
2369 .write_begin
= cifs_write_begin
,
2370 .write_end
= cifs_write_end
,
2371 .set_page_dirty
= __set_page_dirty_nobuffers
,
2372 /* .sync_page = cifs_sync_page, */