4 * vfs operations that deal with files
6 * Copyright (C) International Business Machines Corp., 2002,2003
7 * Author(s): Steve French (sfrench@us.ibm.com)
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 #include <linux/stat.h>
25 #include <linux/fcntl.h>
26 #include <linux/pagemap.h>
27 #include <linux/pagevec.h>
28 #include <linux/smp_lock.h>
29 #include <asm/div64.h>
33 #include "cifsproto.h"
34 #include "cifs_unicode.h"
35 #include "cifs_debug.h"
36 #include "cifs_fs_sb.h"
38 static inline struct cifsFileInfo
*cifs_init_private(
39 struct cifsFileInfo
*private_data
, struct inode
*inode
,
40 struct file
*file
, __u16 netfid
)
42 memset(private_data
, 0, sizeof(struct cifsFileInfo
));
43 private_data
->netfid
= netfid
;
44 private_data
->pid
= current
->tgid
;
45 init_MUTEX(&private_data
->fh_sem
);
46 private_data
->pfile
= file
; /* needed for writepage */
47 private_data
->pInode
= inode
;
48 private_data
->invalidHandle
= FALSE
;
49 private_data
->closePend
= FALSE
;
54 static inline int cifs_convert_flags(unsigned int flags
)
56 if ((flags
& O_ACCMODE
) == O_RDONLY
)
58 else if ((flags
& O_ACCMODE
) == O_WRONLY
)
60 else if ((flags
& O_ACCMODE
) == O_RDWR
) {
61 /* GENERIC_ALL is too much permission to request
62 can cause unnecessary access denied on create */
63 /* return GENERIC_ALL; */
64 return (GENERIC_READ
| GENERIC_WRITE
);
70 static inline int cifs_get_disposition(unsigned int flags
)
72 if ((flags
& (O_CREAT
| O_EXCL
)) == (O_CREAT
| O_EXCL
))
74 else if ((flags
& (O_CREAT
| O_TRUNC
)) == (O_CREAT
| O_TRUNC
))
75 return FILE_OVERWRITE_IF
;
76 else if ((flags
& O_CREAT
) == O_CREAT
)
82 /* all arguments to this function must be checked for validity in caller */
83 static inline int cifs_open_inode_helper(struct inode
*inode
, struct file
*file
,
84 struct cifsInodeInfo
*pCifsInode
, struct cifsFileInfo
*pCifsFile
,
85 struct cifsTconInfo
*pTcon
, int *oplock
, FILE_ALL_INFO
*buf
,
86 char *full_path
, int xid
)
91 /* want handles we can use to read with first
92 in the list so we do not have to walk the
93 list to search for one in prepare_write */
94 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
) {
95 list_add_tail(&pCifsFile
->flist
,
96 &pCifsInode
->openFileList
);
98 list_add(&pCifsFile
->flist
,
99 &pCifsInode
->openFileList
);
101 write_unlock(&GlobalSMBSeslock
);
102 write_unlock(&file
->f_owner
.lock
);
103 if (pCifsInode
->clientCanCacheRead
) {
104 /* we have the inode open somewhere else
105 no need to discard cache data */
106 goto client_can_cache
;
109 /* BB need same check in cifs_create too? */
110 /* if not oplocked, invalidate inode pages if mtime or file
112 temp
= cifs_NTtimeToUnix(le64_to_cpu(buf
->LastWriteTime
));
113 if (timespec_equal(&file
->f_dentry
->d_inode
->i_mtime
, &temp
) &&
114 (file
->f_dentry
->d_inode
->i_size
==
115 (loff_t
)le64_to_cpu(buf
->EndOfFile
))) {
116 cFYI(1, ("inode unchanged on server"));
118 if (file
->f_dentry
->d_inode
->i_mapping
) {
119 /* BB no need to lock inode until after invalidate
120 since namei code should already have it locked? */
121 filemap_fdatawrite(file
->f_dentry
->d_inode
->i_mapping
);
122 filemap_fdatawait(file
->f_dentry
->d_inode
->i_mapping
);
124 cFYI(1, ("invalidating remote inode since open detected it "
126 invalidate_remote_inode(file
->f_dentry
->d_inode
);
130 if (pTcon
->ses
->capabilities
& CAP_UNIX
)
131 rc
= cifs_get_inode_info_unix(&file
->f_dentry
->d_inode
,
132 full_path
, inode
->i_sb
, xid
);
134 rc
= cifs_get_inode_info(&file
->f_dentry
->d_inode
,
135 full_path
, buf
, inode
->i_sb
, xid
);
137 if ((*oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
138 pCifsInode
->clientCanCacheAll
= TRUE
;
139 pCifsInode
->clientCanCacheRead
= TRUE
;
140 cFYI(1, ("Exclusive Oplock granted on inode %p",
141 file
->f_dentry
->d_inode
));
142 } else if ((*oplock
& 0xF) == OPLOCK_READ
)
143 pCifsInode
->clientCanCacheRead
= TRUE
;
148 int cifs_open(struct inode
*inode
, struct file
*file
)
152 struct cifs_sb_info
*cifs_sb
;
153 struct cifsTconInfo
*pTcon
;
154 struct cifsFileInfo
*pCifsFile
;
155 struct cifsInodeInfo
*pCifsInode
;
156 struct list_head
*tmp
;
157 char *full_path
= NULL
;
161 FILE_ALL_INFO
*buf
= NULL
;
165 cifs_sb
= CIFS_SB(inode
->i_sb
);
166 pTcon
= cifs_sb
->tcon
;
168 if (file
->f_flags
& O_CREAT
) {
169 /* search inode for this file and fill in file->private_data */
170 pCifsInode
= CIFS_I(file
->f_dentry
->d_inode
);
171 read_lock(&GlobalSMBSeslock
);
172 list_for_each(tmp
, &pCifsInode
->openFileList
) {
173 pCifsFile
= list_entry(tmp
, struct cifsFileInfo
,
175 if ((pCifsFile
->pfile
== NULL
) &&
176 (pCifsFile
->pid
== current
->tgid
)) {
177 /* mode set in cifs_create */
179 /* needed for writepage */
180 pCifsFile
->pfile
= file
;
182 file
->private_data
= pCifsFile
;
186 read_unlock(&GlobalSMBSeslock
);
187 if (file
->private_data
!= NULL
) {
192 if (file
->f_flags
& O_EXCL
)
193 cERROR(1, ("could not find file instance for "
194 "new file %p ", file
));
198 down(&inode
->i_sb
->s_vfs_rename_sem
);
199 full_path
= build_path_from_dentry(file
->f_dentry
);
200 up(&inode
->i_sb
->s_vfs_rename_sem
);
201 if (full_path
== NULL
) {
206 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
207 inode
, file
->f_flags
, full_path
));
208 desiredAccess
= cifs_convert_flags(file
->f_flags
);
210 /*********************************************************************
211 * open flag mapping table:
213 * POSIX Flag CIFS Disposition
214 * ---------- ----------------
215 * O_CREAT FILE_OPEN_IF
216 * O_CREAT | O_EXCL FILE_CREATE
217 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
218 * O_TRUNC FILE_OVERWRITE
219 * none of the above FILE_OPEN
221 * Note that there is not a direct match between disposition
222 * FILE_SUPERSEDE (ie create whether or not file exists although
223 * O_CREAT | O_TRUNC is similar but truncates the existing
224 * file rather than creating a new file as FILE_SUPERSEDE does
225 * (which uses the attributes / metadata passed in on open call)
227 *? O_SYNC is a reasonable match to CIFS writethrough flag
228 *? and the read write flags match reasonably. O_LARGEFILE
229 *? is irrelevant because largefile support is always used
230 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
231 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
232 *********************************************************************/
234 disposition
= cifs_get_disposition(file
->f_flags
);
241 /* BB pass O_SYNC flag through on file attributes .. BB */
243 /* Also refresh inode by passing in file_info buf returned by SMBOpen
244 and calling get_inode_info with returned buf (at least helps
245 non-Unix server case) */
247 /* BB we can not do this if this is the second open of a file
248 and the first handle has writebehind data, we might be
249 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
250 buf
= kmalloc(sizeof(FILE_ALL_INFO
), GFP_KERNEL
);
255 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
, disposition
, desiredAccess
,
256 CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
257 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
258 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
260 /* Old server, try legacy style OpenX */
261 rc
= SMBLegacyOpen(xid
, pTcon
, full_path
, disposition
,
262 desiredAccess
, CREATE_NOT_DIR
, &netfid
, &oplock
, buf
,
263 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
264 & CIFS_MOUNT_MAP_SPECIAL_CHR
);
267 cFYI(1, ("cifs_open returned 0x%x ", rc
));
271 kmalloc(sizeof(struct cifsFileInfo
), GFP_KERNEL
);
272 if (file
->private_data
== NULL
) {
276 pCifsFile
= cifs_init_private(file
->private_data
, inode
, file
, netfid
);
277 write_lock(&file
->f_owner
.lock
);
278 write_lock(&GlobalSMBSeslock
);
279 list_add(&pCifsFile
->tlist
, &pTcon
->openFileList
);
281 pCifsInode
= CIFS_I(file
->f_dentry
->d_inode
);
283 rc
= cifs_open_inode_helper(inode
, file
, pCifsInode
,
285 &oplock
, buf
, full_path
, xid
);
287 write_unlock(&GlobalSMBSeslock
);
288 write_unlock(&file
->f_owner
.lock
);
291 if (oplock
& CIFS_CREATE_ACTION
) {
292 /* time to set mode which we can not set earlier due to
293 problems creating new read-only files */
294 if (cifs_sb
->tcon
->ses
->capabilities
& CAP_UNIX
) {
295 CIFSSMBUnixSetPerms(xid
, pTcon
, full_path
,
297 (__u64
)-1, (__u64
)-1, 0 /* dev */,
299 cifs_sb
->mnt_cifs_flags
&
300 CIFS_MOUNT_MAP_SPECIAL_CHR
);
302 /* BB implement via Windows security descriptors eg
303 CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
305 in the meantime could set r/o dos attribute when
306 perms are eg: mode & 0222 == 0 */
317 /* Try to reaquire byte range locks that were released when session */
318 /* to server was lost */
319 static int cifs_relock_file(struct cifsFileInfo
*cifsFile
)
323 /* BB list all locks open on this file and relock */
328 static int cifs_reopen_file(struct inode
*inode
, struct file
*file
,
333 struct cifs_sb_info
*cifs_sb
;
334 struct cifsTconInfo
*pTcon
;
335 struct cifsFileInfo
*pCifsFile
;
336 struct cifsInodeInfo
*pCifsInode
;
337 char *full_path
= NULL
;
339 int disposition
= FILE_OPEN
;
344 if (file
->private_data
) {
345 pCifsFile
= (struct cifsFileInfo
*)file
->private_data
;
350 down(&pCifsFile
->fh_sem
);
351 if (pCifsFile
->invalidHandle
== FALSE
) {
352 up(&pCifsFile
->fh_sem
);
357 if (file
->f_dentry
== NULL
) {
358 up(&pCifsFile
->fh_sem
);
359 cFYI(1, ("failed file reopen, no valid name if dentry freed"));
363 cifs_sb
= CIFS_SB(inode
->i_sb
);
364 pTcon
= cifs_sb
->tcon
;
365 /* can not grab rename sem here because various ops, including
366 those that already have the rename sem can end up causing writepage
367 to get called and if the server was down that means we end up here,
368 and we can never tell if the caller already has the rename_sem */
369 full_path
= build_path_from_dentry(file
->f_dentry
);
370 if (full_path
== NULL
) {
371 up(&pCifsFile
->fh_sem
);
376 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
377 inode
, file
->f_flags
,full_path
));
378 desiredAccess
= cifs_convert_flags(file
->f_flags
);
385 /* Can not refresh inode by passing in file_info buf to be returned
386 by SMBOpen and then calling get_inode_info with returned buf
387 since file might have write behind data that needs to be flushed
388 and server version of file size can be stale. If we knew for sure
389 that inode was not dirty locally we could do this */
391 /* buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
393 up(&pCifsFile->fh_sem);
398 rc
= CIFSSMBOpen(xid
, pTcon
, full_path
, disposition
, desiredAccess
,
399 CREATE_NOT_DIR
, &netfid
, &oplock
, NULL
,
400 cifs_sb
->local_nls
, cifs_sb
->mnt_cifs_flags
&
401 CIFS_MOUNT_MAP_SPECIAL_CHR
);
403 up(&pCifsFile
->fh_sem
);
404 cFYI(1, ("cifs_open returned 0x%x ", rc
));
405 cFYI(1, ("oplock: %d ", oplock
));
407 pCifsFile
->netfid
= netfid
;
408 pCifsFile
->invalidHandle
= FALSE
;
409 up(&pCifsFile
->fh_sem
);
410 pCifsInode
= CIFS_I(inode
);
413 filemap_fdatawrite(inode
->i_mapping
);
414 filemap_fdatawait(inode
->i_mapping
);
415 /* temporarily disable caching while we
416 go to server to get inode info */
417 pCifsInode
->clientCanCacheAll
= FALSE
;
418 pCifsInode
->clientCanCacheRead
= FALSE
;
419 if (pTcon
->ses
->capabilities
& CAP_UNIX
)
420 rc
= cifs_get_inode_info_unix(&inode
,
421 full_path
, inode
->i_sb
, xid
);
423 rc
= cifs_get_inode_info(&inode
,
424 full_path
, NULL
, inode
->i_sb
,
426 } /* else we are writing out data to server already
427 and could deadlock if we tried to flush data, and
428 since we do not know if we have data that would
429 invalidate the current end of file on the server
430 we can not go to the server to get the new inod
432 if ((oplock
& 0xF) == OPLOCK_EXCLUSIVE
) {
433 pCifsInode
->clientCanCacheAll
= TRUE
;
434 pCifsInode
->clientCanCacheRead
= TRUE
;
435 cFYI(1, ("Exclusive Oplock granted on inode %p",
436 file
->f_dentry
->d_inode
));
437 } else if ((oplock
& 0xF) == OPLOCK_READ
) {
438 pCifsInode
->clientCanCacheRead
= TRUE
;
439 pCifsInode
->clientCanCacheAll
= FALSE
;
441 pCifsInode
->clientCanCacheRead
= FALSE
;
442 pCifsInode
->clientCanCacheAll
= FALSE
;
444 cifs_relock_file(pCifsFile
);
453 int cifs_close(struct inode
*inode
, struct file
*file
)
457 struct cifs_sb_info
*cifs_sb
;
458 struct cifsTconInfo
*pTcon
;
459 struct cifsFileInfo
*pSMBFile
=
460 (struct cifsFileInfo
*)file
->private_data
;
464 cifs_sb
= CIFS_SB(inode
->i_sb
);
465 pTcon
= cifs_sb
->tcon
;
467 pSMBFile
->closePend
= TRUE
;
468 write_lock(&file
->f_owner
.lock
);
470 /* no sense reconnecting to close a file that is
472 if (pTcon
->tidStatus
!= CifsNeedReconnect
) {
473 write_unlock(&file
->f_owner
.lock
);
474 rc
= CIFSSMBClose(xid
, pTcon
,
476 write_lock(&file
->f_owner
.lock
);
479 write_lock(&GlobalSMBSeslock
);
480 list_del(&pSMBFile
->flist
);
481 list_del(&pSMBFile
->tlist
);
482 write_unlock(&GlobalSMBSeslock
);
483 write_unlock(&file
->f_owner
.lock
);
484 kfree(pSMBFile
->search_resume_name
);
485 kfree(file
->private_data
);
486 file
->private_data
= NULL
;
490 if (list_empty(&(CIFS_I(inode
)->openFileList
))) {
491 cFYI(1, ("closing last open instance for inode %p", inode
));
492 /* if the file is not open we do not know if we can cache info
493 on this inode, much less write behind and read ahead */
494 CIFS_I(inode
)->clientCanCacheRead
= FALSE
;
495 CIFS_I(inode
)->clientCanCacheAll
= FALSE
;
497 if ((rc
==0) && CIFS_I(inode
)->write_behind_rc
)
498 rc
= CIFS_I(inode
)->write_behind_rc
;
503 int cifs_closedir(struct inode
*inode
, struct file
*file
)
507 struct cifsFileInfo
*pCFileStruct
=
508 (struct cifsFileInfo
*)file
->private_data
;
511 cFYI(1, ("Closedir inode = 0x%p with ", inode
));
516 struct cifsTconInfo
*pTcon
;
517 struct cifs_sb_info
*cifs_sb
= CIFS_SB(file
->f_dentry
->d_sb
);
519 pTcon
= cifs_sb
->tcon
;
521 cFYI(1, ("Freeing private data in close dir"));
522 if ((pCFileStruct
->srch_inf
.endOfSearch
== FALSE
) &&
523 (pCFileStruct
->invalidHandle
== FALSE
)) {
524 pCFileStruct
->invalidHandle
= TRUE
;
525 rc
= CIFSFindClose(xid
, pTcon
, pCFileStruct
->netfid
);
526 cFYI(1, ("Closing uncompleted readdir with rc %d",
528 /* not much we can do if it fails anyway, ignore rc */
531 ptmp
= pCFileStruct
->srch_inf
.ntwrk_buf_start
;
533 /* BB removeme BB */ cFYI(1, ("freeing smb buf in srch struct in closedir"));
534 pCFileStruct
->srch_inf
.ntwrk_buf_start
= NULL
;
535 cifs_buf_release(ptmp
);
537 ptmp
= pCFileStruct
->search_resume_name
;
539 /* BB removeme BB */ cFYI(1, ("freeing resume name in closedir"));
540 pCFileStruct
->search_resume_name
= NULL
;
543 kfree(file
->private_data
);
544 file
->private_data
= NULL
;
546 /* BB can we lock the filestruct while this is going on? */
551 int cifs_lock(struct file
*file
, int cmd
, struct file_lock
*pfLock
)
554 __u32 lockType
= LOCKING_ANDX_LARGE_FILES
;
558 int wait_flag
= FALSE
;
559 struct cifs_sb_info
*cifs_sb
;
560 struct cifsTconInfo
*pTcon
;
562 length
= 1 + pfLock
->fl_end
- pfLock
->fl_start
;
566 cFYI(1, ("Lock parm: 0x%x flockflags: "
567 "0x%x flocktype: 0x%x start: %lld end: %lld",
568 cmd
, pfLock
->fl_flags
, pfLock
->fl_type
, pfLock
->fl_start
,
571 if (pfLock
->fl_flags
& FL_POSIX
)
573 if (pfLock
->fl_flags
& FL_FLOCK
)
575 if (pfLock
->fl_flags
& FL_SLEEP
) {
576 cFYI(1, ("Blocking lock "));
579 if (pfLock
->fl_flags
& FL_ACCESS
)
580 cFYI(1, ("Process suspended by mandatory locking - "
581 "not implemented yet "));
582 if (pfLock
->fl_flags
& FL_LEASE
)
583 cFYI(1, ("Lease on file - not implemented yet"));
584 if (pfLock
->fl_flags
&
585 (~(FL_POSIX
| FL_FLOCK
| FL_SLEEP
| FL_ACCESS
| FL_LEASE
)))
586 cFYI(1, ("Unknown lock flags 0x%x", pfLock
->fl_flags
));
588 if (pfLock
->fl_type
== F_WRLCK
) {
589 cFYI(1, ("F_WRLCK "));
591 } else if (pfLock
->fl_type
== F_UNLCK
) {
592 cFYI(1, ("F_UNLCK "));
594 } else if (pfLock
->fl_type
== F_RDLCK
) {
595 cFYI(1, ("F_RDLCK "));
596 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
598 } else if (pfLock
->fl_type
== F_EXLCK
) {
599 cFYI(1, ("F_EXLCK "));
601 } else if (pfLock
->fl_type
== F_SHLCK
) {
602 cFYI(1, ("F_SHLCK "));
603 lockType
|= LOCKING_ANDX_SHARED_LOCK
;
606 cFYI(1, ("Unknown type of lock "));
608 cifs_sb
= CIFS_SB(file
->f_dentry
->d_sb
);
609 pTcon
= cifs_sb
->tcon
;
611 if (file
->private_data
== NULL
) {
617 rc
= CIFSSMBLock(xid
, pTcon
,
618 ((struct cifsFileInfo
*)file
->
619 private_data
)->netfid
,
621 pfLock
->fl_start
, 0, 1, lockType
,
624 rc
= CIFSSMBLock(xid
, pTcon
,
625 ((struct cifsFileInfo
*) file
->
626 private_data
)->netfid
,
628 pfLock
->fl_start
, 1 /* numUnlock */ ,
629 0 /* numLock */ , lockType
,
631 pfLock
->fl_type
= F_UNLCK
;
633 cERROR(1, ("Error unlocking previously locked "
634 "range %d during test of lock ",
639 /* if rc == ERR_SHARING_VIOLATION ? */
640 rc
= 0; /* do not change lock type to unlock
641 since range in use */
648 rc
= CIFSSMBLock(xid
, pTcon
,
649 ((struct cifsFileInfo
*) file
->private_data
)->
651 pfLock
->fl_start
, numUnlock
, numLock
, lockType
,
653 if (pfLock
->fl_flags
& FL_POSIX
)
654 posix_lock_file_wait(file
, pfLock
);
659 ssize_t
cifs_user_write(struct file
*file
, const char __user
*write_data
,
660 size_t write_size
, loff_t
*poffset
)
663 unsigned int bytes_written
= 0;
664 unsigned int total_written
;
665 struct cifs_sb_info
*cifs_sb
;
666 struct cifsTconInfo
*pTcon
;
668 struct cifsFileInfo
*open_file
;
670 if (file
->f_dentry
== NULL
)
673 cifs_sb
= CIFS_SB(file
->f_dentry
->d_sb
);
677 pTcon
= cifs_sb
->tcon
;
680 (" write %d bytes to offset %lld of %s", write_size,
681 *poffset, file->f_dentry->d_name.name)); */
683 if (file
->private_data
== NULL
)
686 open_file
= (struct cifsFileInfo
*) file
->private_data
;
689 if (file
->f_dentry
->d_inode
== NULL
) {
694 if (*poffset
> file
->f_dentry
->d_inode
->i_size
)
695 long_op
= 2; /* writes past end of file can take a long time */
699 for (total_written
= 0; write_size
> total_written
;
700 total_written
+= bytes_written
) {
702 while (rc
== -EAGAIN
) {
703 if (file
->private_data
== NULL
) {
704 /* file has been closed on us */
706 /* if we have gotten here we have written some data
707 and blocked, and the file has been freed on us while
708 we blocked so return what we managed to write */
709 return total_written
;
711 if (open_file
->closePend
) {
714 return total_written
;
718 if (open_file
->invalidHandle
) {
719 if ((file
->f_dentry
== NULL
) ||
720 (file
->f_dentry
->d_inode
== NULL
)) {
722 return total_written
;
724 /* we could deadlock if we called
725 filemap_fdatawait from here so tell
726 reopen_file not to flush data to server
728 rc
= cifs_reopen_file(file
->f_dentry
->d_inode
,
734 rc
= CIFSSMBWrite(xid
, pTcon
,
736 min_t(const int, cifs_sb
->wsize
,
737 write_size
- total_written
),
738 *poffset
, &bytes_written
,
739 NULL
, write_data
+ total_written
, long_op
);
741 if (rc
|| (bytes_written
== 0)) {
749 *poffset
+= bytes_written
;
750 long_op
= FALSE
; /* subsequent writes fast -
751 15 seconds is plenty */
754 cifs_stats_bytes_written(pTcon
, total_written
);
756 /* since the write may have blocked check these pointers again */
757 if (file
->f_dentry
) {
758 if (file
->f_dentry
->d_inode
) {
759 struct inode
*inode
= file
->f_dentry
->d_inode
;
760 inode
->i_ctime
= inode
->i_mtime
=
761 current_fs_time(inode
->i_sb
);
762 if (total_written
> 0) {
763 if (*poffset
> file
->f_dentry
->d_inode
->i_size
)
764 i_size_write(file
->f_dentry
->d_inode
,
767 mark_inode_dirty_sync(file
->f_dentry
->d_inode
);
771 return total_written
;
774 static ssize_t
cifs_write(struct file
*file
, const char *write_data
,
775 size_t write_size
, loff_t
*poffset
)
778 unsigned int bytes_written
= 0;
779 unsigned int total_written
;
780 struct cifs_sb_info
*cifs_sb
;
781 struct cifsTconInfo
*pTcon
;
783 struct cifsFileInfo
*open_file
;
785 if (file
->f_dentry
== NULL
)
788 cifs_sb
= CIFS_SB(file
->f_dentry
->d_sb
);
792 pTcon
= cifs_sb
->tcon
;
794 cFYI(1,(" write %d bytes to offset %lld of %s", write_size
,
795 *poffset
, file
->f_dentry
->d_name
.name
)); /* BB removeme BB */
797 if (file
->private_data
== NULL
)
800 open_file
= (struct cifsFileInfo
*)file
->private_data
;
803 if (file
->f_dentry
->d_inode
== NULL
) {
808 if (*poffset
> file
->f_dentry
->d_inode
->i_size
)
809 long_op
= 2; /* writes past end of file can take a long time */
813 for (total_written
= 0; write_size
> total_written
;
814 total_written
+= bytes_written
) {
816 while (rc
== -EAGAIN
) {
817 if (file
->private_data
== NULL
) {
818 /* file has been closed on us */
820 /* if we have gotten here we have written some data
821 and blocked, and the file has been freed on us
822 while we blocked so return what we managed to
824 return total_written
;
826 if (open_file
->closePend
) {
829 return total_written
;
833 if (open_file
->invalidHandle
) {
834 if ((file
->f_dentry
== NULL
) ||
835 (file
->f_dentry
->d_inode
== NULL
)) {
837 return total_written
;
839 /* we could deadlock if we called
840 filemap_fdatawait from here so tell
841 reopen_file not to flush data to
843 rc
= cifs_reopen_file(file
->f_dentry
->d_inode
,
848 #ifdef CONFIG_CIFS_EXPERIMENTAL
849 /* BB FIXME We can not sign across two buffers yet */
850 if((experimEnabled
) && ((pTcon
->ses
->server
->secMode
&
851 (SECMODE_SIGN_REQUIRED
| SECMODE_SIGN_ENABLED
)) == 0)) {
852 rc
= CIFSSMBWrite2(xid
, pTcon
,
854 min_t(const int, cifs_sb
->wsize
,
855 write_size
- total_written
),
856 *poffset
, &bytes_written
,
857 write_data
+ total_written
,
860 /* BB FIXME fixup indentation of line below */
862 rc
= CIFSSMBWrite(xid
, pTcon
,
864 min_t(const int, cifs_sb
->wsize
,
865 write_size
- total_written
),
866 *poffset
, &bytes_written
,
867 write_data
+ total_written
, NULL
, long_op
);
869 if (rc
|| (bytes_written
== 0)) {
877 *poffset
+= bytes_written
;
878 long_op
= FALSE
; /* subsequent writes fast -
879 15 seconds is plenty */
882 cifs_stats_bytes_written(pTcon
, total_written
);
884 /* since the write may have blocked check these pointers again */
885 if (file
->f_dentry
) {
886 if (file
->f_dentry
->d_inode
) {
887 file
->f_dentry
->d_inode
->i_ctime
=
888 file
->f_dentry
->d_inode
->i_mtime
= CURRENT_TIME
;
889 if (total_written
> 0) {
890 if (*poffset
> file
->f_dentry
->d_inode
->i_size
)
891 i_size_write(file
->f_dentry
->d_inode
,
894 mark_inode_dirty_sync(file
->f_dentry
->d_inode
);
898 return total_written
;
901 static int cifs_partialpagewrite(struct page
*page
, unsigned from
, unsigned to
)
903 struct address_space
*mapping
= page
->mapping
;
904 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
907 int bytes_written
= 0;
908 struct cifs_sb_info
*cifs_sb
;
909 struct cifsTconInfo
*pTcon
;
911 struct cifsInodeInfo
*cifsInode
;
912 struct cifsFileInfo
*open_file
= NULL
;
913 struct list_head
*tmp
;
914 struct list_head
*tmp1
;
916 if (!mapping
|| !mapping
->host
)
919 inode
= page
->mapping
->host
;
920 cifs_sb
= CIFS_SB(inode
->i_sb
);
921 pTcon
= cifs_sb
->tcon
;
923 offset
+= (loff_t
)from
;
924 write_data
= kmap(page
);
927 if ((to
> PAGE_CACHE_SIZE
) || (from
> to
)) {
932 /* racing with truncate? */
933 if (offset
> mapping
->host
->i_size
) {
935 return 0; /* don't care */
938 /* check to make sure that we are not extending the file */
939 if (mapping
->host
->i_size
- offset
< (loff_t
)to
)
940 to
= (unsigned)(mapping
->host
->i_size
- offset
);
942 cifsInode
= CIFS_I(mapping
->host
);
943 read_lock(&GlobalSMBSeslock
);
944 /* BB we should start at the end */
945 list_for_each_safe(tmp
, tmp1
, &cifsInode
->openFileList
) {
946 open_file
= list_entry(tmp
, struct cifsFileInfo
, flist
);
947 if (open_file
->closePend
)
949 /* We check if file is open for writing first */
950 if ((open_file
->pfile
) &&
951 ((open_file
->pfile
->f_flags
& O_RDWR
) ||
952 (open_file
->pfile
->f_flags
& O_WRONLY
))) {
953 read_unlock(&GlobalSMBSeslock
);
954 bytes_written
= cifs_write(open_file
->pfile
,
957 read_lock(&GlobalSMBSeslock
);
958 /* Does mm or vfs already set times? */
960 inode
->i_mtime
= current_fs_time(inode
->i_sb
);
961 if ((bytes_written
> 0) && (offset
)) {
963 } else if (bytes_written
< 0) {
965 /* have seen a case in which kernel seemed to
966 have closed/freed a file even with writes
967 active so we might as well see if there are
968 other file structs to try for the same
969 inode before giving up */
974 break; /* now that we found a valid file handle and
975 tried to write to it we are done, no sense
976 continuing to loop looking for another */
978 if (tmp
->next
== NULL
) {
979 cFYI(1, ("File instance %p removed", tmp
));
983 read_unlock(&GlobalSMBSeslock
);
984 if (open_file
== NULL
) {
985 cFYI(1, ("No writeable filehandles for inode"));
994 static int cifs_writepages(struct address_space
*mapping
,
995 struct writeback_control
*wbc
)
1002 /* Find contiguous pages then iterate through repeating
1003 call 16K write then Setpageuptodate or if LARGE_WRITE_X
1004 support then send larger writes via kevec so as to eliminate
1011 static int cifs_writepage(struct page
* page
, struct writeback_control
*wbc
)
1017 /* BB add check for wbc flags */
1018 page_cache_get(page
);
1019 if (!PageUptodate(page
)) {
1020 cFYI(1, ("ppw - page not up to date"));
1023 rc
= cifs_partialpagewrite(page
, 0, PAGE_CACHE_SIZE
);
1024 SetPageUptodate(page
); /* BB add check for error and Clearuptodate? */
1026 page_cache_release(page
);
1031 static int cifs_commit_write(struct file
*file
, struct page
*page
,
1032 unsigned offset
, unsigned to
)
1036 struct inode
*inode
= page
->mapping
->host
;
1037 loff_t position
= ((loff_t
)page
->index
<< PAGE_CACHE_SHIFT
) + to
;
1041 cFYI(1, ("commit write for page %p up to position %lld for %d",
1042 page
, position
, to
));
1043 if (position
> inode
->i_size
) {
1044 i_size_write(inode
, position
);
1045 /* if (file->private_data == NULL) {
1048 open_file = (struct cifsFileInfo *)file->private_data;
1049 cifs_sb = CIFS_SB(inode->i_sb);
1051 while (rc == -EAGAIN) {
1052 if ((open_file->invalidHandle) &&
1053 (!open_file->closePend)) {
1054 rc = cifs_reopen_file(
1055 file->f_dentry->d_inode, file);
1059 if (!open_file->closePend) {
1060 rc = CIFSSMBSetFileSize(xid,
1061 cifs_sb->tcon, position,
1063 open_file->pid, FALSE);
1069 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1072 if (!PageUptodate(page
)) {
1073 position
= ((loff_t
)page
->index
<< PAGE_CACHE_SHIFT
) + offset
;
1074 /* can not rely on (or let) writepage write this data */
1076 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1081 /* this is probably better than directly calling
1082 partialpage_write since in this function the file handle is
1083 known which we might as well leverage */
1084 /* BB check if anything else missing out of ppw
1085 such as updating last write time */
1086 page_data
= kmap(page
);
1087 rc
= cifs_write(file
, page_data
+ offset
, to
-offset
,
1091 /* else if (rc < 0) should we set writebehind rc? */
1094 set_page_dirty(page
);
1101 int cifs_fsync(struct file
*file
, struct dentry
*dentry
, int datasync
)
1105 struct inode
*inode
= file
->f_dentry
->d_inode
;
1109 cFYI(1, ("Sync file - name: %s datasync: 0x%x ",
1110 dentry
->d_name
.name
, datasync
));
1112 rc
= filemap_fdatawrite(inode
->i_mapping
);
1114 CIFS_I(inode
)->write_behind_rc
= 0;
1119 /* static int cifs_sync_page(struct page *page)
1121 struct address_space *mapping;
1122 struct inode *inode;
1123 unsigned long index = page->index;
1124 unsigned int rpages = 0;
1127 cFYI(1, ("sync page %p",page));
1128 mapping = page->mapping;
1131 inode = mapping->host;
1135 /* fill in rpages then
1136 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1138 /* cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
1146 * As file closes, flush all cached write data for this inode checking
1147 * for write behind errors.
1149 int cifs_flush(struct file
*file
)
1151 struct inode
* inode
= file
->f_dentry
->d_inode
;
1154 /* Rather than do the steps manually:
1155 lock the inode for writing
1156 loop through pages looking for write behind data (dirty pages)
1157 coalesce into contiguous 16K (or smaller) chunks to write to server
1158 send to server (prefer in parallel)
1159 deal with writebehind errors
1160 unlock inode for writing
1161 filemapfdatawrite appears easier for the time being */
1163 rc
= filemap_fdatawrite(inode
->i_mapping
);
1164 if (!rc
) /* reset wb rc if we were able to write out dirty pages */
1165 CIFS_I(inode
)->write_behind_rc
= 0;
1167 cFYI(1, ("Flush inode %p file %p rc %d",inode
,file
,rc
));
1172 ssize_t
cifs_user_read(struct file
*file
, char __user
*read_data
,
1173 size_t read_size
, loff_t
*poffset
)
1176 unsigned int bytes_read
= 0;
1177 unsigned int total_read
= 0;
1178 unsigned int current_read_size
;
1179 struct cifs_sb_info
*cifs_sb
;
1180 struct cifsTconInfo
*pTcon
;
1182 struct cifsFileInfo
*open_file
;
1183 char *smb_read_data
;
1184 char __user
*current_offset
;
1185 struct smb_com_read_rsp
*pSMBr
;
1186 int use_old_read
= FALSE
;
1189 cifs_sb
= CIFS_SB(file
->f_dentry
->d_sb
);
1190 pTcon
= cifs_sb
->tcon
;
1193 if((pTcon
->ses
->capabilities
& CAP_LARGE_FILES
) == 0)
1194 use_old_read
= TRUE
;
1196 if (file
->private_data
== NULL
) {
1200 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1202 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
) {
1203 cFYI(1, ("attempting read on write only file instance"));
1205 for (total_read
= 0, current_offset
= read_data
;
1206 read_size
> total_read
;
1207 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1208 current_read_size
= min_t(const int, read_size
- total_read
,
1211 smb_read_data
= NULL
;
1212 while (rc
== -EAGAIN
) {
1213 if ((open_file
->invalidHandle
) &&
1214 (!open_file
->closePend
)) {
1215 rc
= cifs_reopen_file(file
->f_dentry
->d_inode
,
1221 rc
= SMBLegacyRead(xid
, pTcon
,
1223 current_read_size
, *poffset
,
1224 &bytes_read
, &smb_read_data
);
1226 rc
= CIFSSMBRead(xid
, pTcon
,
1228 current_read_size
, *poffset
,
1229 &bytes_read
, &smb_read_data
);
1231 use_old_read
= TRUE
;
1236 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
1237 if (copy_to_user(current_offset
,
1238 smb_read_data
+ 4 /* RFC1001 hdr */
1239 + le16_to_cpu(pSMBr
->DataOffset
),
1245 if (smb_read_data
) {
1246 cifs_buf_release(smb_read_data
);
1247 smb_read_data
= NULL
;
1250 if (rc
|| (bytes_read
== 0)) {
1258 cifs_stats_bytes_read(pTcon
, bytes_read
);
1259 *poffset
+= bytes_read
;
1267 static ssize_t
cifs_read(struct file
*file
, char *read_data
, size_t read_size
,
1271 unsigned int bytes_read
= 0;
1272 unsigned int total_read
;
1273 unsigned int current_read_size
;
1274 struct cifs_sb_info
*cifs_sb
;
1275 struct cifsTconInfo
*pTcon
;
1277 char *current_offset
;
1278 struct cifsFileInfo
*open_file
;
1279 int use_old_read
= FALSE
;
1282 cifs_sb
= CIFS_SB(file
->f_dentry
->d_sb
);
1283 pTcon
= cifs_sb
->tcon
;
1285 if (file
->private_data
== NULL
) {
1289 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1291 if((pTcon
->ses
->capabilities
& CAP_LARGE_FILES
) == 0)
1292 use_old_read
= TRUE
;
1294 if ((file
->f_flags
& O_ACCMODE
) == O_WRONLY
)
1295 cFYI(1, ("attempting read on write only file instance"));
1297 for (total_read
= 0, current_offset
= read_data
;
1298 read_size
> total_read
;
1299 total_read
+= bytes_read
, current_offset
+= bytes_read
) {
1300 current_read_size
= min_t(const int, read_size
- total_read
,
1303 while (rc
== -EAGAIN
) {
1304 if ((open_file
->invalidHandle
) &&
1305 (!open_file
->closePend
)) {
1306 rc
= cifs_reopen_file(file
->f_dentry
->d_inode
,
1312 rc
= SMBLegacyRead(xid
, pTcon
,
1314 current_read_size
, *poffset
,
1315 &bytes_read
, ¤t_offset
);
1317 rc
= CIFSSMBRead(xid
, pTcon
,
1319 current_read_size
, *poffset
,
1320 &bytes_read
, ¤t_offset
);
1321 /* check if server disavows support for
1325 use_old_read
= TRUE
;
1330 if (rc
|| (bytes_read
== 0)) {
1338 cifs_stats_bytes_read(pTcon
, total_read
);
1339 *poffset
+= bytes_read
;
1346 int cifs_file_mmap(struct file
*file
, struct vm_area_struct
*vma
)
1348 struct dentry
*dentry
= file
->f_dentry
;
1352 rc
= cifs_revalidate(dentry
);
1354 cFYI(1, ("Validation prior to mmap failed, error=%d", rc
));
1358 rc
= generic_file_mmap(file
, vma
);
1364 static void cifs_copy_cache_pages(struct address_space
*mapping
,
1365 struct list_head
*pages
, int bytes_read
, char *data
,
1366 struct pagevec
*plru_pvec
)
1371 while (bytes_read
> 0) {
1372 if (list_empty(pages
))
1375 page
= list_entry(pages
->prev
, struct page
, lru
);
1376 list_del(&page
->lru
);
1378 if (add_to_page_cache(page
, mapping
, page
->index
,
1380 page_cache_release(page
);
1381 cFYI(1, ("Add page cache failed"));
1382 data
+= PAGE_CACHE_SIZE
;
1383 bytes_read
-= PAGE_CACHE_SIZE
;
1387 target
= kmap_atomic(page
,KM_USER0
);
1389 if (PAGE_CACHE_SIZE
> bytes_read
) {
1390 memcpy(target
, data
, bytes_read
);
1391 /* zero the tail end of this partial page */
1392 memset(target
+ bytes_read
, 0,
1393 PAGE_CACHE_SIZE
- bytes_read
);
1396 memcpy(target
, data
, PAGE_CACHE_SIZE
);
1397 bytes_read
-= PAGE_CACHE_SIZE
;
1399 kunmap_atomic(target
, KM_USER0
);
1401 flush_dcache_page(page
);
1402 SetPageUptodate(page
);
1404 if (!pagevec_add(plru_pvec
, page
))
1405 __pagevec_lru_add(plru_pvec
);
1406 data
+= PAGE_CACHE_SIZE
;
1411 static int cifs_readpages(struct file
*file
, struct address_space
*mapping
,
1412 struct list_head
*page_list
, unsigned num_pages
)
1418 struct cifs_sb_info
*cifs_sb
;
1419 struct cifsTconInfo
*pTcon
;
1421 unsigned int read_size
,i
;
1422 char *smb_read_data
= NULL
;
1423 struct smb_com_read_rsp
*pSMBr
;
1424 struct pagevec lru_pvec
;
1425 struct cifsFileInfo
*open_file
;
1426 int use_old_read
= FALSE
;
1429 if (file
->private_data
== NULL
) {
1433 open_file
= (struct cifsFileInfo
*)file
->private_data
;
1434 cifs_sb
= CIFS_SB(file
->f_dentry
->d_sb
);
1435 pTcon
= cifs_sb
->tcon
;
1437 if((pTcon
->ses
->capabilities
& CAP_LARGE_FILES
) == 0)
1438 use_old_read
= TRUE
;
1439 pagevec_init(&lru_pvec
, 0);
1441 for (i
= 0; i
< num_pages
; ) {
1442 unsigned contig_pages
;
1443 struct page
*tmp_page
;
1444 unsigned long expected_index
;
1446 if (list_empty(page_list
))
1449 page
= list_entry(page_list
->prev
, struct page
, lru
);
1450 offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1452 /* count adjacent pages that we will read into */
1455 list_entry(page_list
->prev
, struct page
, lru
)->index
;
1456 list_for_each_entry_reverse(tmp_page
,page_list
,lru
) {
1457 if (tmp_page
->index
== expected_index
) {
1463 if (contig_pages
+ i
> num_pages
)
1464 contig_pages
= num_pages
- i
;
1466 /* for reads over a certain size could initiate async
1469 read_size
= contig_pages
* PAGE_CACHE_SIZE
;
1470 /* Read size needs to be in multiples of one page */
1471 read_size
= min_t(const unsigned int, read_size
,
1472 cifs_sb
->rsize
& PAGE_CACHE_MASK
);
1475 while (rc
== -EAGAIN
) {
1476 if ((open_file
->invalidHandle
) &&
1477 (!open_file
->closePend
)) {
1478 rc
= cifs_reopen_file(file
->f_dentry
->d_inode
,
1485 rc
= SMBLegacyRead(xid
, pTcon
,
1488 &bytes_read
, &smb_read_data
);
1490 rc
= CIFSSMBRead(xid
, pTcon
,
1493 &bytes_read
, &smb_read_data
);
1495 use_old_read
= TRUE
;
1501 /* BB more RC checks ? */
1503 if (smb_read_data
) {
1504 cifs_buf_release(smb_read_data
);
1505 smb_read_data
= NULL
;
1509 if ((rc
< 0) || (smb_read_data
== NULL
)) {
1510 cFYI(1, ("Read error in readpages: %d", rc
));
1511 /* clean up remaing pages off list */
1512 while (!list_empty(page_list
) && (i
< num_pages
)) {
1513 page
= list_entry(page_list
->prev
, struct page
,
1515 list_del(&page
->lru
);
1516 page_cache_release(page
);
1519 } else if (bytes_read
> 0) {
1520 pSMBr
= (struct smb_com_read_rsp
*)smb_read_data
;
1521 cifs_copy_cache_pages(mapping
, page_list
, bytes_read
,
1522 smb_read_data
+ 4 /* RFC1001 hdr */ +
1523 le16_to_cpu(pSMBr
->DataOffset
), &lru_pvec
);
1525 i
+= bytes_read
>> PAGE_CACHE_SHIFT
;
1526 cifs_stats_bytes_read(pTcon
, bytes_read
);
1527 if ((int)(bytes_read
& PAGE_CACHE_MASK
) != bytes_read
) {
1528 i
++; /* account for partial page */
1530 /* server copy of file can have smaller size
1532 /* BB do we need to verify this common case ?
1533 this case is ok - if we are at server EOF
1534 we will hit it on next read */
1536 /* while (!list_empty(page_list) && (i < num_pages)) {
1537 page = list_entry(page_list->prev,
1539 list_del(&page->list);
1540 page_cache_release(page);
1545 cFYI(1, ("No bytes read (%d) at offset %lld . "
1546 "Cleaning remaining pages from readahead list",
1547 bytes_read
, offset
));
1548 /* BB turn off caching and do new lookup on
1549 file size at server? */
1550 while (!list_empty(page_list
) && (i
< num_pages
)) {
1551 page
= list_entry(page_list
->prev
, struct page
,
1553 list_del(&page
->lru
);
1555 /* BB removeme - replace with zero of page? */
1556 page_cache_release(page
);
1560 if (smb_read_data
) {
1561 cifs_buf_release(smb_read_data
);
1562 smb_read_data
= NULL
;
1567 pagevec_lru_add(&lru_pvec
);
1569 /* need to free smb_read_data buf before exit */
1570 if (smb_read_data
) {
1571 cifs_buf_release(smb_read_data
);
1572 smb_read_data
= NULL
;
1579 static int cifs_readpage_worker(struct file
*file
, struct page
*page
,
1585 page_cache_get(page
);
1586 read_data
= kmap(page
);
1587 /* for reads over a certain size could initiate async read ahead */
1589 rc
= cifs_read(file
, read_data
, PAGE_CACHE_SIZE
, poffset
);
1594 cFYI(1, ("Bytes read %d ",rc
));
1596 file
->f_dentry
->d_inode
->i_atime
=
1597 current_fs_time(file
->f_dentry
->d_inode
->i_sb
);
1599 if (PAGE_CACHE_SIZE
> rc
)
1600 memset(read_data
+ rc
, 0, PAGE_CACHE_SIZE
- rc
);
1602 flush_dcache_page(page
);
1603 SetPageUptodate(page
);
1608 page_cache_release(page
);
1612 static int cifs_readpage(struct file
*file
, struct page
*page
)
1614 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1620 if (file
->private_data
== NULL
) {
1625 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1626 page
, (int)offset
, (int)offset
));
1628 rc
= cifs_readpage_worker(file
, page
, &offset
);
1636 /* We do not want to update the file size from server for inodes
1637 open for write - to avoid races with writepage extending
1638 the file - in the future we could consider allowing
1639 refreshing the inode only on increases in the file size
1640 but this is tricky to do without racing with writebehind
1641 page caching in the current Linux kernel design */
1642 int is_size_safe_to_change(struct cifsInodeInfo
*cifsInode
)
1644 struct list_head
*tmp
;
1645 struct list_head
*tmp1
;
1646 struct cifsFileInfo
*open_file
= NULL
;
1649 if (cifsInode
== NULL
)
1652 read_lock(&GlobalSMBSeslock
);
1653 list_for_each_safe(tmp
, tmp1
, &cifsInode
->openFileList
) {
1654 open_file
= list_entry(tmp
, struct cifsFileInfo
, flist
);
1655 if (open_file
== NULL
)
1657 if (open_file
->closePend
)
1659 /* We check if file is open for writing,
1660 BB we could supplement this with a check to see if file size
1661 changes have been flushed to server - ie inode metadata dirty */
1662 if ((open_file
->pfile
) &&
1663 ((open_file
->pfile
->f_flags
& O_RDWR
) ||
1664 (open_file
->pfile
->f_flags
& O_WRONLY
))) {
1668 if (tmp
->next
== NULL
) {
1669 cFYI(1, ("File instance %p removed", tmp
));
1673 read_unlock(&GlobalSMBSeslock
);
1678 static int cifs_prepare_write(struct file
*file
, struct page
*page
,
1679 unsigned from
, unsigned to
)
1682 loff_t offset
= (loff_t
)page
->index
<< PAGE_CACHE_SHIFT
;
1683 cFYI(1, ("prepare write for page %p from %d to %d",page
,from
,to
));
1684 if (!PageUptodate(page
)) {
1685 /* if (to - from != PAGE_CACHE_SIZE) {
1686 void *kaddr = kmap_atomic(page, KM_USER0);
1687 memset(kaddr, 0, from);
1688 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
1689 flush_dcache_page(page);
1690 kunmap_atomic(kaddr, KM_USER0);
1692 /* If we are writing a full page it will be up to date,
1693 no need to read from the server */
1694 if ((to
== PAGE_CACHE_SIZE
) && (from
== 0))
1695 SetPageUptodate(page
);
1697 /* might as well read a page, it is fast enough */
1698 if ((file
->f_flags
& O_ACCMODE
) != O_WRONLY
) {
1699 rc
= cifs_readpage_worker(file
, page
, &offset
);
1701 /* should we try using another file handle if there is one -
1702 how would we lock it to prevent close of that handle
1703 racing with this read?
1704 In any case this will be written out by commit_write */
1708 /* BB should we pass any errors back?
1709 e.g. if we do not have read access to the file */
1713 struct address_space_operations cifs_addr_ops
= {
1714 .readpage
= cifs_readpage
,
1715 .readpages
= cifs_readpages
,
1716 .writepage
= cifs_writepage
,
1717 .prepare_write
= cifs_prepare_write
,
1718 .commit_write
= cifs_commit_write
,
1719 .set_page_dirty
= __set_page_dirty_nobuffers
,
1720 /* .sync_page = cifs_sync_page, */