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, cifs_sb);
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 cFYI(1, ("cifs_open returned 0x%x ", rc));
264 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
265 if (file->private_data == NULL) {
269 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
270 write_lock(&file->f_owner.lock);
271 write_lock(&GlobalSMBSeslock);
272 list_add(&pCifsFile->tlist, &pTcon->openFileList);
274 pCifsInode = CIFS_I(file->f_dentry->d_inode);
276 rc = cifs_open_inode_helper(inode, file, pCifsInode,
278 &oplock, buf, full_path, xid);
280 write_unlock(&GlobalSMBSeslock);
281 write_unlock(&file->f_owner.lock);
284 if (oplock & CIFS_CREATE_ACTION) {
285 /* time to set mode which we can not set earlier due to
286 problems creating new read-only files */
287 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
288 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
290 (__u64)-1, (__u64)-1, 0 /* dev */,
292 cifs_sb->mnt_cifs_flags &
293 CIFS_MOUNT_MAP_SPECIAL_CHR);
295 /* BB implement via Windows security descriptors eg
296 CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
298 in the meantime could set r/o dos attribute when
299 perms are eg: mode & 0222 == 0 */
310 /* Try to reaquire byte range locks that were released when session */
311 /* to server was lost */
312 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
316 /* BB list all locks open on this file and relock */
321 static int cifs_reopen_file(struct inode *inode, struct file *file,
326 struct cifs_sb_info *cifs_sb;
327 struct cifsTconInfo *pTcon;
328 struct cifsFileInfo *pCifsFile;
329 struct cifsInodeInfo *pCifsInode;
330 char *full_path = NULL;
332 int disposition = FILE_OPEN;
337 if (file->private_data) {
338 pCifsFile = (struct cifsFileInfo *)file->private_data;
343 down(&pCifsFile->fh_sem);
344 if (pCifsFile->invalidHandle == FALSE) {
345 up(&pCifsFile->fh_sem);
350 if (file->f_dentry == NULL) {
351 up(&pCifsFile->fh_sem);
352 cFYI(1, ("failed file reopen, no valid name if dentry freed"));
356 cifs_sb = CIFS_SB(inode->i_sb);
357 pTcon = cifs_sb->tcon;
358 /* can not grab rename sem here because various ops, including
359 those that already have the rename sem can end up causing writepage
360 to get called and if the server was down that means we end up here,
361 and we can never tell if the caller already has the rename_sem */
362 full_path = build_path_from_dentry(file->f_dentry, cifs_sb);
363 if (full_path == NULL) {
364 up(&pCifsFile->fh_sem);
369 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
370 inode, file->f_flags,full_path));
371 desiredAccess = cifs_convert_flags(file->f_flags);
378 /* Can not refresh inode by passing in file_info buf to be returned
379 by SMBOpen and then calling get_inode_info with returned buf
380 since file might have write behind data that needs to be flushed
381 and server version of file size can be stale. If we knew for sure
382 that inode was not dirty locally we could do this */
384 /* buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
386 up(&pCifsFile->fh_sem);
391 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
392 CREATE_NOT_DIR, &netfid, &oplock, NULL,
393 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
394 CIFS_MOUNT_MAP_SPECIAL_CHR);
396 up(&pCifsFile->fh_sem);
397 cFYI(1, ("cifs_open returned 0x%x ", rc));
398 cFYI(1, ("oplock: %d ", oplock));
400 pCifsFile->netfid = netfid;
401 pCifsFile->invalidHandle = FALSE;
402 up(&pCifsFile->fh_sem);
403 pCifsInode = CIFS_I(inode);
406 filemap_fdatawrite(inode->i_mapping);
407 filemap_fdatawait(inode->i_mapping);
408 /* temporarily disable caching while we
409 go to server to get inode info */
410 pCifsInode->clientCanCacheAll = FALSE;
411 pCifsInode->clientCanCacheRead = FALSE;
412 if (pTcon->ses->capabilities & CAP_UNIX)
413 rc = cifs_get_inode_info_unix(&inode,
414 full_path, inode->i_sb, xid);
416 rc = cifs_get_inode_info(&inode,
417 full_path, NULL, inode->i_sb,
419 } /* else we are writing out data to server already
420 and could deadlock if we tried to flush data, and
421 since we do not know if we have data that would
422 invalidate the current end of file on the server
423 we can not go to the server to get the new inod
425 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
426 pCifsInode->clientCanCacheAll = TRUE;
427 pCifsInode->clientCanCacheRead = TRUE;
428 cFYI(1, ("Exclusive Oplock granted on inode %p",
429 file->f_dentry->d_inode));
430 } else if ((oplock & 0xF) == OPLOCK_READ) {
431 pCifsInode->clientCanCacheRead = TRUE;
432 pCifsInode->clientCanCacheAll = FALSE;
434 pCifsInode->clientCanCacheRead = FALSE;
435 pCifsInode->clientCanCacheAll = FALSE;
437 cifs_relock_file(pCifsFile);
446 int cifs_close(struct inode *inode, struct file *file)
450 struct cifs_sb_info *cifs_sb;
451 struct cifsTconInfo *pTcon;
452 struct cifsFileInfo *pSMBFile =
453 (struct cifsFileInfo *)file->private_data;
457 cifs_sb = CIFS_SB(inode->i_sb);
458 pTcon = cifs_sb->tcon;
460 pSMBFile->closePend = TRUE;
461 write_lock(&file->f_owner.lock);
463 /* no sense reconnecting to close a file that is
465 if (pTcon->tidStatus != CifsNeedReconnect) {
466 write_unlock(&file->f_owner.lock);
467 rc = CIFSSMBClose(xid, pTcon,
469 write_lock(&file->f_owner.lock);
472 write_lock(&GlobalSMBSeslock);
473 list_del(&pSMBFile->flist);
474 list_del(&pSMBFile->tlist);
475 write_unlock(&GlobalSMBSeslock);
476 write_unlock(&file->f_owner.lock);
477 kfree(pSMBFile->search_resume_name);
478 kfree(file->private_data);
479 file->private_data = NULL;
483 if (list_empty(&(CIFS_I(inode)->openFileList))) {
484 cFYI(1, ("closing last open instance for inode %p", inode));
485 /* if the file is not open we do not know if we can cache info
486 on this inode, much less write behind and read ahead */
487 CIFS_I(inode)->clientCanCacheRead = FALSE;
488 CIFS_I(inode)->clientCanCacheAll = FALSE;
490 if ((rc ==0) && CIFS_I(inode)->write_behind_rc)
491 rc = CIFS_I(inode)->write_behind_rc;
496 int cifs_closedir(struct inode *inode, struct file *file)
500 struct cifsFileInfo *pCFileStruct =
501 (struct cifsFileInfo *)file->private_data;
504 cFYI(1, ("Closedir inode = 0x%p with ", inode));
509 struct cifsTconInfo *pTcon;
510 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_dentry->d_sb);
512 pTcon = cifs_sb->tcon;
514 cFYI(1, ("Freeing private data in close dir"));
515 if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
516 (pCFileStruct->invalidHandle == FALSE)) {
517 pCFileStruct->invalidHandle = TRUE;
518 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
519 cFYI(1, ("Closing uncompleted readdir with rc %d",
521 /* not much we can do if it fails anyway, ignore rc */
524 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
526 /* BB removeme BB */ cFYI(1, ("freeing smb buf in srch struct in closedir"));
527 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
528 cifs_buf_release(ptmp);
530 ptmp = pCFileStruct->search_resume_name;
532 /* BB removeme BB */ cFYI(1, ("freeing resume name in closedir"));
533 pCFileStruct->search_resume_name = NULL;
536 kfree(file->private_data);
537 file->private_data = NULL;
539 /* BB can we lock the filestruct while this is going on? */
544 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
547 __u32 lockType = LOCKING_ANDX_LARGE_FILES;
551 int wait_flag = FALSE;
552 struct cifs_sb_info *cifs_sb;
553 struct cifsTconInfo *pTcon;
555 length = 1 + pfLock->fl_end - pfLock->fl_start;
559 cFYI(1, ("Lock parm: 0x%x flockflags: "
560 "0x%x flocktype: 0x%x start: %lld end: %lld",
561 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
564 if (pfLock->fl_flags & FL_POSIX)
566 if (pfLock->fl_flags & FL_FLOCK)
568 if (pfLock->fl_flags & FL_SLEEP) {
569 cFYI(1, ("Blocking lock "));
572 if (pfLock->fl_flags & FL_ACCESS)
573 cFYI(1, ("Process suspended by mandatory locking - "
574 "not implemented yet "));
575 if (pfLock->fl_flags & FL_LEASE)
576 cFYI(1, ("Lease on file - not implemented yet"));
577 if (pfLock->fl_flags &
578 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
579 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
581 if (pfLock->fl_type == F_WRLCK) {
582 cFYI(1, ("F_WRLCK "));
584 } else if (pfLock->fl_type == F_UNLCK) {
585 cFYI(1, ("F_UNLCK "));
587 } else if (pfLock->fl_type == F_RDLCK) {
588 cFYI(1, ("F_RDLCK "));
589 lockType |= LOCKING_ANDX_SHARED_LOCK;
591 } else if (pfLock->fl_type == F_EXLCK) {
592 cFYI(1, ("F_EXLCK "));
594 } else if (pfLock->fl_type == F_SHLCK) {
595 cFYI(1, ("F_SHLCK "));
596 lockType |= LOCKING_ANDX_SHARED_LOCK;
599 cFYI(1, ("Unknown type of lock "));
601 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
602 pTcon = cifs_sb->tcon;
604 if (file->private_data == NULL) {
610 rc = CIFSSMBLock(xid, pTcon,
611 ((struct cifsFileInfo *)file->
612 private_data)->netfid,
614 pfLock->fl_start, 0, 1, lockType,
617 rc = CIFSSMBLock(xid, pTcon,
618 ((struct cifsFileInfo *) file->
619 private_data)->netfid,
621 pfLock->fl_start, 1 /* numUnlock */ ,
622 0 /* numLock */ , lockType,
624 pfLock->fl_type = F_UNLCK;
626 cERROR(1, ("Error unlocking previously locked "
627 "range %d during test of lock ",
632 /* if rc == ERR_SHARING_VIOLATION ? */
633 rc = 0; /* do not change lock type to unlock
634 since range in use */
641 rc = CIFSSMBLock(xid, pTcon,
642 ((struct cifsFileInfo *) file->private_data)->
644 pfLock->fl_start, numUnlock, numLock, lockType,
646 if (rc == 0 && (pfLock->fl_flags & FL_POSIX))
647 posix_lock_file_wait(file, pfLock);
652 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
653 size_t write_size, loff_t *poffset)
656 unsigned int bytes_written = 0;
657 unsigned int total_written;
658 struct cifs_sb_info *cifs_sb;
659 struct cifsTconInfo *pTcon;
661 struct cifsFileInfo *open_file;
663 if (file->f_dentry == NULL)
666 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
670 pTcon = cifs_sb->tcon;
673 (" write %d bytes to offset %lld of %s", write_size,
674 *poffset, file->f_dentry->d_name.name)); */
676 if (file->private_data == NULL)
679 open_file = (struct cifsFileInfo *) file->private_data;
682 if (file->f_dentry->d_inode == NULL) {
687 if (*poffset > file->f_dentry->d_inode->i_size)
688 long_op = 2; /* writes past end of file can take a long time */
692 for (total_written = 0; write_size > total_written;
693 total_written += bytes_written) {
695 while (rc == -EAGAIN) {
696 if (file->private_data == NULL) {
697 /* file has been closed on us */
699 /* if we have gotten here we have written some data
700 and blocked, and the file has been freed on us while
701 we blocked so return what we managed to write */
702 return total_written;
704 if (open_file->closePend) {
707 return total_written;
711 if (open_file->invalidHandle) {
712 if ((file->f_dentry == NULL) ||
713 (file->f_dentry->d_inode == NULL)) {
715 return total_written;
717 /* we could deadlock if we called
718 filemap_fdatawait from here so tell
719 reopen_file not to flush data to server
721 rc = cifs_reopen_file(file->f_dentry->d_inode,
727 rc = CIFSSMBWrite(xid, pTcon,
729 min_t(const int, cifs_sb->wsize,
730 write_size - total_written),
731 *poffset, &bytes_written,
732 NULL, write_data + total_written, long_op);
734 if (rc || (bytes_written == 0)) {
742 *poffset += bytes_written;
743 long_op = FALSE; /* subsequent writes fast -
744 15 seconds is plenty */
747 #ifdef CONFIG_CIFS_STATS
748 if (total_written > 0) {
749 atomic_inc(&pTcon->num_writes);
750 spin_lock(&pTcon->stat_lock);
751 pTcon->bytes_written += total_written;
752 spin_unlock(&pTcon->stat_lock);
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 #ifdef CONFIG_CIFS_STATS
883 if (total_written > 0) {
884 atomic_inc(&pTcon->num_writes);
885 spin_lock(&pTcon->stat_lock);
886 pTcon->bytes_written += total_written;
887 spin_unlock(&pTcon->stat_lock);
891 /* since the write may have blocked check these pointers again */
892 if (file->f_dentry) {
893 if (file->f_dentry->d_inode) {
894 file->f_dentry->d_inode->i_ctime =
895 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
896 if (total_written > 0) {
897 if (*poffset > file->f_dentry->d_inode->i_size)
898 i_size_write(file->f_dentry->d_inode,
901 mark_inode_dirty_sync(file->f_dentry->d_inode);
905 return total_written;
908 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
910 struct address_space *mapping = page->mapping;
911 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
914 int bytes_written = 0;
915 struct cifs_sb_info *cifs_sb;
916 struct cifsTconInfo *pTcon;
918 struct cifsInodeInfo *cifsInode;
919 struct cifsFileInfo *open_file = NULL;
920 struct list_head *tmp;
921 struct list_head *tmp1;
923 if (!mapping || !mapping->host)
926 inode = page->mapping->host;
927 cifs_sb = CIFS_SB(inode->i_sb);
928 pTcon = cifs_sb->tcon;
930 offset += (loff_t)from;
931 write_data = kmap(page);
934 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
939 /* racing with truncate? */
940 if (offset > mapping->host->i_size) {
942 return 0; /* don't care */
945 /* check to make sure that we are not extending the file */
946 if (mapping->host->i_size - offset < (loff_t)to)
947 to = (unsigned)(mapping->host->i_size - offset);
949 cifsInode = CIFS_I(mapping->host);
950 read_lock(&GlobalSMBSeslock);
951 /* BB we should start at the end */
952 list_for_each_safe(tmp, tmp1, &cifsInode->openFileList) {
953 open_file = list_entry(tmp, struct cifsFileInfo, flist);
954 if (open_file->closePend)
956 /* We check if file is open for writing first */
957 if ((open_file->pfile) &&
958 ((open_file->pfile->f_flags & O_RDWR) ||
959 (open_file->pfile->f_flags & O_WRONLY))) {
960 read_unlock(&GlobalSMBSeslock);
961 bytes_written = cifs_write(open_file->pfile,
964 read_lock(&GlobalSMBSeslock);
965 /* Does mm or vfs already set times? */
967 inode->i_mtime = current_fs_time(inode->i_sb);
968 if ((bytes_written > 0) && (offset)) {
970 } else if (bytes_written < 0) {
972 /* have seen a case in which kernel seemed to
973 have closed/freed a file even with writes
974 active so we might as well see if there are
975 other file structs to try for the same
976 inode before giving up */
981 break; /* now that we found a valid file handle and
982 tried to write to it we are done, no sense
983 continuing to loop looking for another */
985 if (tmp->next == NULL) {
986 cFYI(1, ("File instance %p removed", tmp));
990 read_unlock(&GlobalSMBSeslock);
991 if (open_file == NULL) {
992 cFYI(1, ("No writeable filehandles for inode"));
1001 static int cifs_writepages(struct address_space *mapping,
1002 struct writeback_control *wbc)
1009 /* Find contiguous pages then iterate through repeating
1010 call 16K write then Setpageuptodate or if LARGE_WRITE_X
1011 support then send larger writes via kevec so as to eliminate
1018 static int cifs_writepage(struct page* page, struct writeback_control *wbc)
1024 /* BB add check for wbc flags */
1025 page_cache_get(page);
1026 if (!PageUptodate(page)) {
1027 cFYI(1, ("ppw - page not up to date"));
1030 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1031 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1033 page_cache_release(page);
1038 static int cifs_commit_write(struct file *file, struct page *page,
1039 unsigned offset, unsigned to)
1043 struct inode *inode = page->mapping->host;
1044 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1048 cFYI(1, ("commit write for page %p up to position %lld for %d",
1049 page, position, to));
1050 if (position > inode->i_size) {
1051 i_size_write(inode, position);
1052 /* if (file->private_data == NULL) {
1055 open_file = (struct cifsFileInfo *)file->private_data;
1056 cifs_sb = CIFS_SB(inode->i_sb);
1058 while (rc == -EAGAIN) {
1059 if ((open_file->invalidHandle) &&
1060 (!open_file->closePend)) {
1061 rc = cifs_reopen_file(
1062 file->f_dentry->d_inode, file);
1066 if (!open_file->closePend) {
1067 rc = CIFSSMBSetFileSize(xid,
1068 cifs_sb->tcon, position,
1070 open_file->pid, FALSE);
1076 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1079 if (!PageUptodate(page)) {
1080 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1081 /* can not rely on (or let) writepage write this data */
1083 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1088 /* this is probably better than directly calling
1089 partialpage_write since in this function the file handle is
1090 known which we might as well leverage */
1091 /* BB check if anything else missing out of ppw
1092 such as updating last write time */
1093 page_data = kmap(page);
1094 rc = cifs_write(file, page_data + offset, to-offset,
1098 /* else if (rc < 0) should we set writebehind rc? */
1101 set_page_dirty(page);
1108 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1112 struct inode *inode = file->f_dentry->d_inode;
1116 cFYI(1, ("Sync file - name: %s datasync: 0x%x ",
1117 dentry->d_name.name, datasync));
1119 rc = filemap_fdatawrite(inode->i_mapping);
1121 CIFS_I(inode)->write_behind_rc = 0;
1126 /* static int cifs_sync_page(struct page *page)
1128 struct address_space *mapping;
1129 struct inode *inode;
1130 unsigned long index = page->index;
1131 unsigned int rpages = 0;
1134 cFYI(1, ("sync page %p",page));
1135 mapping = page->mapping;
1138 inode = mapping->host;
1142 /* fill in rpages then
1143 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1145 /* cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
1153 * As file closes, flush all cached write data for this inode checking
1154 * for write behind errors.
1156 int cifs_flush(struct file *file)
1158 struct inode * inode = file->f_dentry->d_inode;
1161 /* Rather than do the steps manually:
1162 lock the inode for writing
1163 loop through pages looking for write behind data (dirty pages)
1164 coalesce into contiguous 16K (or smaller) chunks to write to server
1165 send to server (prefer in parallel)
1166 deal with writebehind errors
1167 unlock inode for writing
1168 filemapfdatawrite appears easier for the time being */
1170 rc = filemap_fdatawrite(inode->i_mapping);
1171 if (!rc) /* reset wb rc if we were able to write out dirty pages */
1172 CIFS_I(inode)->write_behind_rc = 0;
1174 cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
1179 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1180 size_t read_size, loff_t *poffset)
1183 unsigned int bytes_read = 0;
1184 unsigned int total_read = 0;
1185 unsigned int current_read_size;
1186 struct cifs_sb_info *cifs_sb;
1187 struct cifsTconInfo *pTcon;
1189 struct cifsFileInfo *open_file;
1190 char *smb_read_data;
1191 char __user *current_offset;
1192 struct smb_com_read_rsp *pSMBr;
1195 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1196 pTcon = cifs_sb->tcon;
1198 if (file->private_data == NULL) {
1202 open_file = (struct cifsFileInfo *)file->private_data;
1204 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1205 cFYI(1, ("attempting read on write only file instance"));
1207 for (total_read = 0, current_offset = read_data;
1208 read_size > total_read;
1209 total_read += bytes_read, current_offset += bytes_read) {
1210 current_read_size = min_t(const int, read_size - total_read,
1213 smb_read_data = NULL;
1214 while (rc == -EAGAIN) {
1215 if ((open_file->invalidHandle) &&
1216 (!open_file->closePend)) {
1217 rc = cifs_reopen_file(file->f_dentry->d_inode,
1223 rc = CIFSSMBRead(xid, pTcon,
1225 current_read_size, *poffset,
1226 &bytes_read, &smb_read_data);
1228 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1229 if (copy_to_user(current_offset,
1230 smb_read_data + 4 /* RFC1001 hdr */
1231 + le16_to_cpu(pSMBr->DataOffset),
1237 if (smb_read_data) {
1238 cifs_buf_release(smb_read_data);
1239 smb_read_data = NULL;
1242 if (rc || (bytes_read == 0)) {
1250 #ifdef CONFIG_CIFS_STATS
1251 atomic_inc(&pTcon->num_reads);
1252 spin_lock(&pTcon->stat_lock);
1253 pTcon->bytes_read += total_read;
1254 spin_unlock(&pTcon->stat_lock);
1256 *poffset += bytes_read;
1264 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1268 unsigned int bytes_read = 0;
1269 unsigned int total_read;
1270 unsigned int current_read_size;
1271 struct cifs_sb_info *cifs_sb;
1272 struct cifsTconInfo *pTcon;
1274 char *current_offset;
1275 struct cifsFileInfo *open_file;
1278 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1279 pTcon = cifs_sb->tcon;
1281 if (file->private_data == NULL) {
1285 open_file = (struct cifsFileInfo *)file->private_data;
1287 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1288 cFYI(1, ("attempting read on write only file instance"));
1290 for (total_read = 0, current_offset = read_data;
1291 read_size > total_read;
1292 total_read += bytes_read, current_offset += bytes_read) {
1293 current_read_size = min_t(const int, read_size - total_read,
1296 while (rc == -EAGAIN) {
1297 if ((open_file->invalidHandle) &&
1298 (!open_file->closePend)) {
1299 rc = cifs_reopen_file(file->f_dentry->d_inode,
1305 rc = CIFSSMBRead(xid, pTcon,
1307 current_read_size, *poffset,
1308 &bytes_read, ¤t_offset);
1310 if (rc || (bytes_read == 0)) {
1318 #ifdef CONFIG_CIFS_STATS
1319 atomic_inc(&pTcon->num_reads);
1320 spin_lock(&pTcon->stat_lock);
1321 pTcon->bytes_read += total_read;
1322 spin_unlock(&pTcon->stat_lock);
1324 *poffset += bytes_read;
1331 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1333 struct dentry *dentry = file->f_dentry;
1337 rc = cifs_revalidate(dentry);
1339 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1343 rc = generic_file_mmap(file, vma);
1349 static void cifs_copy_cache_pages(struct address_space *mapping,
1350 struct list_head *pages, int bytes_read, char *data,
1351 struct pagevec *plru_pvec)
1356 while (bytes_read > 0) {
1357 if (list_empty(pages))
1360 page = list_entry(pages->prev, struct page, lru);
1361 list_del(&page->lru);
1363 if (add_to_page_cache(page, mapping, page->index,
1365 page_cache_release(page);
1366 cFYI(1, ("Add page cache failed"));
1367 data += PAGE_CACHE_SIZE;
1368 bytes_read -= PAGE_CACHE_SIZE;
1372 target = kmap_atomic(page,KM_USER0);
1374 if (PAGE_CACHE_SIZE > bytes_read) {
1375 memcpy(target, data, bytes_read);
1376 /* zero the tail end of this partial page */
1377 memset(target + bytes_read, 0,
1378 PAGE_CACHE_SIZE - bytes_read);
1381 memcpy(target, data, PAGE_CACHE_SIZE);
1382 bytes_read -= PAGE_CACHE_SIZE;
1384 kunmap_atomic(target, KM_USER0);
1386 flush_dcache_page(page);
1387 SetPageUptodate(page);
1389 if (!pagevec_add(plru_pvec, page))
1390 __pagevec_lru_add(plru_pvec);
1391 data += PAGE_CACHE_SIZE;
1396 static int cifs_readpages(struct file *file, struct address_space *mapping,
1397 struct list_head *page_list, unsigned num_pages)
1403 struct cifs_sb_info *cifs_sb;
1404 struct cifsTconInfo *pTcon;
1406 unsigned int read_size,i;
1407 char *smb_read_data = NULL;
1408 struct smb_com_read_rsp *pSMBr;
1409 struct pagevec lru_pvec;
1410 struct cifsFileInfo *open_file;
1413 if (file->private_data == NULL) {
1417 open_file = (struct cifsFileInfo *)file->private_data;
1418 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1419 pTcon = cifs_sb->tcon;
1421 pagevec_init(&lru_pvec, 0);
1423 for (i = 0; i < num_pages; ) {
1424 unsigned contig_pages;
1425 struct page *tmp_page;
1426 unsigned long expected_index;
1428 if (list_empty(page_list))
1431 page = list_entry(page_list->prev, struct page, lru);
1432 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1434 /* count adjacent pages that we will read into */
1437 list_entry(page_list->prev, struct page, lru)->index;
1438 list_for_each_entry_reverse(tmp_page,page_list,lru) {
1439 if (tmp_page->index == expected_index) {
1445 if (contig_pages + i > num_pages)
1446 contig_pages = num_pages - i;
1448 /* for reads over a certain size could initiate async
1451 read_size = contig_pages * PAGE_CACHE_SIZE;
1452 /* Read size needs to be in multiples of one page */
1453 read_size = min_t(const unsigned int, read_size,
1454 cifs_sb->rsize & PAGE_CACHE_MASK);
1457 while (rc == -EAGAIN) {
1458 if ((open_file->invalidHandle) &&
1459 (!open_file->closePend)) {
1460 rc = cifs_reopen_file(file->f_dentry->d_inode,
1466 rc = CIFSSMBRead(xid, pTcon,
1469 &bytes_read, &smb_read_data);
1470 /* BB need to check return code here */
1472 if (smb_read_data) {
1473 cifs_buf_release(smb_read_data);
1474 smb_read_data = NULL;
1478 if ((rc < 0) || (smb_read_data == NULL)) {
1479 cFYI(1, ("Read error in readpages: %d", rc));
1480 /* clean up remaing pages off list */
1481 while (!list_empty(page_list) && (i < num_pages)) {
1482 page = list_entry(page_list->prev, struct page,
1484 list_del(&page->lru);
1485 page_cache_release(page);
1488 } else if (bytes_read > 0) {
1489 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1490 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1491 smb_read_data + 4 /* RFC1001 hdr */ +
1492 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1494 i += bytes_read >> PAGE_CACHE_SHIFT;
1495 #ifdef CONFIG_CIFS_STATS
1496 atomic_inc(&pTcon->num_reads);
1497 spin_lock(&pTcon->stat_lock);
1498 pTcon->bytes_read += bytes_read;
1499 spin_unlock(&pTcon->stat_lock);
1501 if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1502 i++; /* account for partial page */
1504 /* server copy of file can have smaller size
1506 /* BB do we need to verify this common case ?
1507 this case is ok - if we are at server EOF
1508 we will hit it on next read */
1510 /* while (!list_empty(page_list) && (i < num_pages)) {
1511 page = list_entry(page_list->prev,
1513 list_del(&page->list);
1514 page_cache_release(page);
1519 cFYI(1, ("No bytes read (%d) at offset %lld . "
1520 "Cleaning remaining pages from readahead list",
1521 bytes_read, offset));
1522 /* BB turn off caching and do new lookup on
1523 file size at server? */
1524 while (!list_empty(page_list) && (i < num_pages)) {
1525 page = list_entry(page_list->prev, struct page,
1527 list_del(&page->lru);
1529 /* BB removeme - replace with zero of page? */
1530 page_cache_release(page);
1534 if (smb_read_data) {
1535 cifs_buf_release(smb_read_data);
1536 smb_read_data = NULL;
1541 pagevec_lru_add(&lru_pvec);
1543 /* need to free smb_read_data buf before exit */
1544 if (smb_read_data) {
1545 cifs_buf_release(smb_read_data);
1546 smb_read_data = NULL;
1553 static int cifs_readpage_worker(struct file *file, struct page *page,
1559 page_cache_get(page);
1560 read_data = kmap(page);
1561 /* for reads over a certain size could initiate async read ahead */
1563 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1568 cFYI(1, ("Bytes read %d ",rc));
1570 file->f_dentry->d_inode->i_atime =
1571 current_fs_time(file->f_dentry->d_inode->i_sb);
1573 if (PAGE_CACHE_SIZE > rc)
1574 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1576 flush_dcache_page(page);
1577 SetPageUptodate(page);
1582 page_cache_release(page);
1586 static int cifs_readpage(struct file *file, struct page *page)
1588 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1594 if (file->private_data == NULL) {
1599 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1600 page, (int)offset, (int)offset));
1602 rc = cifs_readpage_worker(file, page, &offset);
1610 /* We do not want to update the file size from server for inodes
1611 open for write - to avoid races with writepage extending
1612 the file - in the future we could consider allowing
1613 refreshing the inode only on increases in the file size
1614 but this is tricky to do without racing with writebehind
1615 page caching in the current Linux kernel design */
1616 int is_size_safe_to_change(struct cifsInodeInfo *cifsInode)
1618 struct list_head *tmp;
1619 struct list_head *tmp1;
1620 struct cifsFileInfo *open_file = NULL;
1623 if (cifsInode == NULL)
1626 read_lock(&GlobalSMBSeslock);
1627 list_for_each_safe(tmp, tmp1, &cifsInode->openFileList) {
1628 open_file = list_entry(tmp, struct cifsFileInfo, flist);
1629 if (open_file == NULL)
1631 if (open_file->closePend)
1633 /* We check if file is open for writing,
1634 BB we could supplement this with a check to see if file size
1635 changes have been flushed to server - ie inode metadata dirty */
1636 if ((open_file->pfile) &&
1637 ((open_file->pfile->f_flags & O_RDWR) ||
1638 (open_file->pfile->f_flags & O_WRONLY))) {
1642 if (tmp->next == NULL) {
1643 cFYI(1, ("File instance %p removed", tmp));
1647 read_unlock(&GlobalSMBSeslock);
1652 static int cifs_prepare_write(struct file *file, struct page *page,
1653 unsigned from, unsigned to)
1656 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1657 cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
1658 if (!PageUptodate(page)) {
1659 /* if (to - from != PAGE_CACHE_SIZE) {
1660 void *kaddr = kmap_atomic(page, KM_USER0);
1661 memset(kaddr, 0, from);
1662 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
1663 flush_dcache_page(page);
1664 kunmap_atomic(kaddr, KM_USER0);
1666 /* If we are writing a full page it will be up to date,
1667 no need to read from the server */
1668 if ((to == PAGE_CACHE_SIZE) && (from == 0))
1669 SetPageUptodate(page);
1671 /* might as well read a page, it is fast enough */
1672 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
1673 rc = cifs_readpage_worker(file, page, &offset);
1675 /* should we try using another file handle if there is one -
1676 how would we lock it to prevent close of that handle
1677 racing with this read?
1678 In any case this will be written out by commit_write */
1682 /* BB should we pass any errors back?
1683 e.g. if we do not have read access to the file */
1687 struct address_space_operations cifs_addr_ops = {
1688 .readpage = cifs_readpage,
1689 .readpages = cifs_readpages,
1690 .writepage = cifs_writepage,
1691 .prepare_write = cifs_prepare_write,
1692 .commit_write = cifs_commit_write,
1693 .set_page_dirty = __set_page_dirty_nobuffers,
1694 /* .sync_page = cifs_sync_page, */