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 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);
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 = TRUE;
517 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
518 cFYI(1, ("Closing uncompleted readdir with rc %d",
520 /* not much we can do if it fails anyway, ignore rc */
523 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
525 /* BB removeme BB */ cFYI(1, ("freeing smb buf in srch struct in closedir"));
526 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
527 cifs_buf_release(ptmp);
529 ptmp = pCFileStruct->search_resume_name;
531 /* BB removeme BB */ cFYI(1, ("freeing resume name in closedir"));
532 pCFileStruct->search_resume_name = NULL;
535 kfree(file->private_data);
536 file->private_data = NULL;
538 /* BB can we lock the filestruct while this is going on? */
543 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
546 __u32 lockType = LOCKING_ANDX_LARGE_FILES;
550 int wait_flag = FALSE;
551 struct cifs_sb_info *cifs_sb;
552 struct cifsTconInfo *pTcon;
554 length = 1 + pfLock->fl_end - pfLock->fl_start;
558 cFYI(1, ("Lock parm: 0x%x flockflags: "
559 "0x%x flocktype: 0x%x start: %lld end: %lld",
560 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
563 if (pfLock->fl_flags & FL_POSIX)
565 if (pfLock->fl_flags & FL_FLOCK)
567 if (pfLock->fl_flags & FL_SLEEP) {
568 cFYI(1, ("Blocking lock "));
571 if (pfLock->fl_flags & FL_ACCESS)
572 cFYI(1, ("Process suspended by mandatory locking - "
573 "not implemented yet "));
574 if (pfLock->fl_flags & FL_LEASE)
575 cFYI(1, ("Lease on file - not implemented yet"));
576 if (pfLock->fl_flags &
577 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
578 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
580 if (pfLock->fl_type == F_WRLCK) {
581 cFYI(1, ("F_WRLCK "));
583 } else if (pfLock->fl_type == F_UNLCK) {
584 cFYI(1, ("F_UNLCK "));
586 } else if (pfLock->fl_type == F_RDLCK) {
587 cFYI(1, ("F_RDLCK "));
588 lockType |= LOCKING_ANDX_SHARED_LOCK;
590 } else if (pfLock->fl_type == F_EXLCK) {
591 cFYI(1, ("F_EXLCK "));
593 } else if (pfLock->fl_type == F_SHLCK) {
594 cFYI(1, ("F_SHLCK "));
595 lockType |= LOCKING_ANDX_SHARED_LOCK;
598 cFYI(1, ("Unknown type of lock "));
600 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
601 pTcon = cifs_sb->tcon;
603 if (file->private_data == NULL) {
609 rc = CIFSSMBLock(xid, pTcon,
610 ((struct cifsFileInfo *)file->
611 private_data)->netfid,
613 pfLock->fl_start, 0, 1, lockType,
616 rc = CIFSSMBLock(xid, pTcon,
617 ((struct cifsFileInfo *) file->
618 private_data)->netfid,
620 pfLock->fl_start, 1 /* numUnlock */ ,
621 0 /* numLock */ , lockType,
623 pfLock->fl_type = F_UNLCK;
625 cERROR(1, ("Error unlocking previously locked "
626 "range %d during test of lock ",
631 /* if rc == ERR_SHARING_VIOLATION ? */
632 rc = 0; /* do not change lock type to unlock
633 since range in use */
640 rc = CIFSSMBLock(xid, pTcon,
641 ((struct cifsFileInfo *) file->private_data)->
643 pfLock->fl_start, numUnlock, numLock, lockType,
645 if (rc == 0 && (pfLock->fl_flags & FL_POSIX))
646 posix_lock_file_wait(file, pfLock);
651 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
652 size_t write_size, loff_t *poffset)
655 unsigned int bytes_written = 0;
656 unsigned int total_written;
657 struct cifs_sb_info *cifs_sb;
658 struct cifsTconInfo *pTcon;
660 struct cifsFileInfo *open_file;
662 if (file->f_dentry == NULL)
665 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
669 pTcon = cifs_sb->tcon;
672 (" write %d bytes to offset %lld of %s", write_size,
673 *poffset, file->f_dentry->d_name.name)); */
675 if (file->private_data == NULL)
678 open_file = (struct cifsFileInfo *) file->private_data;
681 if (file->f_dentry->d_inode == NULL) {
686 if (*poffset > file->f_dentry->d_inode->i_size)
687 long_op = 2; /* writes past end of file can take a long time */
691 for (total_written = 0; write_size > total_written;
692 total_written += bytes_written) {
694 while (rc == -EAGAIN) {
695 if (file->private_data == NULL) {
696 /* file has been closed on us */
698 /* if we have gotten here we have written some data
699 and blocked, and the file has been freed on us while
700 we blocked so return what we managed to write */
701 return total_written;
703 if (open_file->closePend) {
706 return total_written;
710 if (open_file->invalidHandle) {
711 if ((file->f_dentry == NULL) ||
712 (file->f_dentry->d_inode == NULL)) {
714 return total_written;
716 /* we could deadlock if we called
717 filemap_fdatawait from here so tell
718 reopen_file not to flush data to server
720 rc = cifs_reopen_file(file->f_dentry->d_inode,
726 rc = CIFSSMBWrite(xid, pTcon,
728 min_t(const int, cifs_sb->wsize,
729 write_size - total_written),
730 *poffset, &bytes_written,
731 NULL, write_data + total_written, long_op);
733 if (rc || (bytes_written == 0)) {
741 *poffset += bytes_written;
742 long_op = FALSE; /* subsequent writes fast -
743 15 seconds is plenty */
746 #ifdef CONFIG_CIFS_STATS
747 if (total_written > 0) {
748 atomic_inc(&pTcon->num_writes);
749 spin_lock(&pTcon->stat_lock);
750 pTcon->bytes_written += total_written;
751 spin_unlock(&pTcon->stat_lock);
755 /* since the write may have blocked check these pointers again */
756 if (file->f_dentry) {
757 if (file->f_dentry->d_inode) {
758 struct inode *inode = file->f_dentry->d_inode;
759 inode->i_ctime = inode->i_mtime =
760 current_fs_time(inode->i_sb);
761 if (total_written > 0) {
762 if (*poffset > file->f_dentry->d_inode->i_size)
763 i_size_write(file->f_dentry->d_inode,
766 mark_inode_dirty_sync(file->f_dentry->d_inode);
770 return total_written;
773 static ssize_t cifs_write(struct file *file, const char *write_data,
774 size_t write_size, loff_t *poffset)
777 unsigned int bytes_written = 0;
778 unsigned int total_written;
779 struct cifs_sb_info *cifs_sb;
780 struct cifsTconInfo *pTcon;
782 struct cifsFileInfo *open_file;
784 if (file->f_dentry == NULL)
787 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
791 pTcon = cifs_sb->tcon;
794 (" write %d bytes to offset %lld of %s", write_size,
795 *poffset, file->f_dentry->d_name.name)); */
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,
849 rc = CIFSSMBWrite(xid, pTcon,
851 min_t(const int, cifs_sb->wsize,
852 write_size - total_written),
853 *poffset, &bytes_written,
854 write_data + total_written, NULL, long_op);
856 if (rc || (bytes_written == 0)) {
864 *poffset += bytes_written;
865 long_op = FALSE; /* subsequent writes fast -
866 15 seconds is plenty */
869 #ifdef CONFIG_CIFS_STATS
870 if (total_written > 0) {
871 atomic_inc(&pTcon->num_writes);
872 spin_lock(&pTcon->stat_lock);
873 pTcon->bytes_written += total_written;
874 spin_unlock(&pTcon->stat_lock);
878 /* since the write may have blocked check these pointers again */
879 if (file->f_dentry) {
880 if (file->f_dentry->d_inode) {
881 file->f_dentry->d_inode->i_ctime =
882 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
883 if (total_written > 0) {
884 if (*poffset > file->f_dentry->d_inode->i_size)
885 i_size_write(file->f_dentry->d_inode,
888 mark_inode_dirty_sync(file->f_dentry->d_inode);
892 return total_written;
895 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
897 struct address_space *mapping = page->mapping;
898 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
901 int bytes_written = 0;
902 struct cifs_sb_info *cifs_sb;
903 struct cifsTconInfo *pTcon;
905 struct cifsInodeInfo *cifsInode;
906 struct cifsFileInfo *open_file = NULL;
907 struct list_head *tmp;
908 struct list_head *tmp1;
910 if (!mapping || !mapping->host)
913 inode = page->mapping->host;
914 cifs_sb = CIFS_SB(inode->i_sb);
915 pTcon = cifs_sb->tcon;
917 offset += (loff_t)from;
918 write_data = kmap(page);
921 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
926 /* racing with truncate? */
927 if (offset > mapping->host->i_size) {
929 return 0; /* don't care */
932 /* check to make sure that we are not extending the file */
933 if (mapping->host->i_size - offset < (loff_t)to)
934 to = (unsigned)(mapping->host->i_size - offset);
936 cifsInode = CIFS_I(mapping->host);
937 read_lock(&GlobalSMBSeslock);
938 /* BB we should start at the end */
939 list_for_each_safe(tmp, tmp1, &cifsInode->openFileList) {
940 open_file = list_entry(tmp, struct cifsFileInfo, flist);
941 if (open_file->closePend)
943 /* We check if file is open for writing first */
944 if ((open_file->pfile) &&
945 ((open_file->pfile->f_flags & O_RDWR) ||
946 (open_file->pfile->f_flags & O_WRONLY))) {
947 read_unlock(&GlobalSMBSeslock);
948 bytes_written = cifs_write(open_file->pfile,
951 read_lock(&GlobalSMBSeslock);
952 /* Does mm or vfs already set times? */
954 inode->i_mtime = current_fs_time(inode->i_sb);
955 if ((bytes_written > 0) && (offset)) {
957 } else if (bytes_written < 0) {
959 /* have seen a case in which kernel seemed to
960 have closed/freed a file even with writes
961 active so we might as well see if there are
962 other file structs to try for the same
963 inode before giving up */
968 break; /* now that we found a valid file handle and
969 tried to write to it we are done, no sense
970 continuing to loop looking for another */
972 if (tmp->next == NULL) {
973 cFYI(1, ("File instance %p removed", tmp));
977 read_unlock(&GlobalSMBSeslock);
978 if (open_file == NULL) {
979 cFYI(1, ("No writeable filehandles for inode"));
988 static int cifs_writepages(struct address_space *mapping,
989 struct writeback_control *wbc)
996 /* Find contiguous pages then iterate through repeating
997 call 16K write then Setpageuptodate or if LARGE_WRITE_X
998 support then send larger writes via kevec so as to eliminate
1005 static int cifs_writepage(struct page* page, struct writeback_control *wbc)
1011 /* BB add check for wbc flags */
1012 page_cache_get(page);
1013 if (!PageUptodate(page)) {
1014 cFYI(1, ("ppw - page not up to date"));
1017 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1018 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1020 page_cache_release(page);
1025 static int cifs_commit_write(struct file *file, struct page *page,
1026 unsigned offset, unsigned to)
1030 struct inode *inode = page->mapping->host;
1031 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1035 cFYI(1, ("commit write for page %p up to position %lld for %d",
1036 page, position, to));
1037 if (position > inode->i_size) {
1038 i_size_write(inode, position);
1039 /* if (file->private_data == NULL) {
1042 open_file = (struct cifsFileInfo *)file->private_data;
1043 cifs_sb = CIFS_SB(inode->i_sb);
1045 while (rc == -EAGAIN) {
1046 if ((open_file->invalidHandle) &&
1047 (!open_file->closePend)) {
1048 rc = cifs_reopen_file(
1049 file->f_dentry->d_inode, file);
1053 if (!open_file->closePend) {
1054 rc = CIFSSMBSetFileSize(xid,
1055 cifs_sb->tcon, position,
1057 open_file->pid, FALSE);
1063 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1066 if (!PageUptodate(page)) {
1067 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1068 /* can not rely on (or let) writepage write this data */
1070 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1075 /* this is probably better than directly calling
1076 partialpage_write since in this function the file handle is
1077 known which we might as well leverage */
1078 /* BB check if anything else missing out of ppw
1079 such as updating last write time */
1080 page_data = kmap(page);
1081 rc = cifs_write(file, page_data + offset, to-offset,
1085 /* else if (rc < 0) should we set writebehind rc? */
1088 set_page_dirty(page);
1095 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1099 struct inode *inode = file->f_dentry->d_inode;
1103 cFYI(1, ("Sync file - name: %s datasync: 0x%x ",
1104 dentry->d_name.name, datasync));
1106 rc = filemap_fdatawrite(inode->i_mapping);
1108 CIFS_I(inode)->write_behind_rc = 0;
1113 /* static int cifs_sync_page(struct page *page)
1115 struct address_space *mapping;
1116 struct inode *inode;
1117 unsigned long index = page->index;
1118 unsigned int rpages = 0;
1121 cFYI(1, ("sync page %p",page));
1122 mapping = page->mapping;
1125 inode = mapping->host;
1129 /* fill in rpages then
1130 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1132 /* cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
1140 * As file closes, flush all cached write data for this inode checking
1141 * for write behind errors.
1143 int cifs_flush(struct file *file)
1145 struct inode * inode = file->f_dentry->d_inode;
1148 /* Rather than do the steps manually:
1149 lock the inode for writing
1150 loop through pages looking for write behind data (dirty pages)
1151 coalesce into contiguous 16K (or smaller) chunks to write to server
1152 send to server (prefer in parallel)
1153 deal with writebehind errors
1154 unlock inode for writing
1155 filemapfdatawrite appears easier for the time being */
1157 rc = filemap_fdatawrite(inode->i_mapping);
1158 if (!rc) /* reset wb rc if we were able to write out dirty pages */
1159 CIFS_I(inode)->write_behind_rc = 0;
1161 cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
1166 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1167 size_t read_size, loff_t *poffset)
1170 unsigned int bytes_read = 0;
1171 unsigned int total_read = 0;
1172 unsigned int current_read_size;
1173 struct cifs_sb_info *cifs_sb;
1174 struct cifsTconInfo *pTcon;
1176 struct cifsFileInfo *open_file;
1177 char *smb_read_data;
1178 char __user *current_offset;
1179 struct smb_com_read_rsp *pSMBr;
1182 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1183 pTcon = cifs_sb->tcon;
1185 if (file->private_data == NULL) {
1189 open_file = (struct cifsFileInfo *)file->private_data;
1191 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1192 cFYI(1, ("attempting read on write only file instance"));
1194 for (total_read = 0, current_offset = read_data;
1195 read_size > total_read;
1196 total_read += bytes_read, current_offset += bytes_read) {
1197 current_read_size = min_t(const int, read_size - total_read,
1200 smb_read_data = NULL;
1201 while (rc == -EAGAIN) {
1202 if ((open_file->invalidHandle) &&
1203 (!open_file->closePend)) {
1204 rc = cifs_reopen_file(file->f_dentry->d_inode,
1210 rc = CIFSSMBRead(xid, pTcon,
1212 current_read_size, *poffset,
1213 &bytes_read, &smb_read_data);
1215 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1216 if (copy_to_user(current_offset,
1217 smb_read_data + 4 /* RFC1001 hdr */
1218 + le16_to_cpu(pSMBr->DataOffset),
1224 if (smb_read_data) {
1225 cifs_buf_release(smb_read_data);
1226 smb_read_data = NULL;
1229 if (rc || (bytes_read == 0)) {
1237 #ifdef CONFIG_CIFS_STATS
1238 atomic_inc(&pTcon->num_reads);
1239 spin_lock(&pTcon->stat_lock);
1240 pTcon->bytes_read += total_read;
1241 spin_unlock(&pTcon->stat_lock);
1243 *poffset += bytes_read;
1251 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1255 unsigned int bytes_read = 0;
1256 unsigned int total_read;
1257 unsigned int current_read_size;
1258 struct cifs_sb_info *cifs_sb;
1259 struct cifsTconInfo *pTcon;
1261 char *current_offset;
1262 struct cifsFileInfo *open_file;
1265 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1266 pTcon = cifs_sb->tcon;
1268 if (file->private_data == NULL) {
1272 open_file = (struct cifsFileInfo *)file->private_data;
1274 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1275 cFYI(1, ("attempting read on write only file instance"));
1277 for (total_read = 0, current_offset = read_data;
1278 read_size > total_read;
1279 total_read += bytes_read, current_offset += bytes_read) {
1280 current_read_size = min_t(const int, read_size - total_read,
1283 while (rc == -EAGAIN) {
1284 if ((open_file->invalidHandle) &&
1285 (!open_file->closePend)) {
1286 rc = cifs_reopen_file(file->f_dentry->d_inode,
1292 rc = CIFSSMBRead(xid, pTcon,
1294 current_read_size, *poffset,
1295 &bytes_read, ¤t_offset);
1297 if (rc || (bytes_read == 0)) {
1305 #ifdef CONFIG_CIFS_STATS
1306 atomic_inc(&pTcon->num_reads);
1307 spin_lock(&pTcon->stat_lock);
1308 pTcon->bytes_read += total_read;
1309 spin_unlock(&pTcon->stat_lock);
1311 *poffset += bytes_read;
1318 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1320 struct dentry *dentry = file->f_dentry;
1324 rc = cifs_revalidate(dentry);
1326 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1330 rc = generic_file_mmap(file, vma);
1336 static void cifs_copy_cache_pages(struct address_space *mapping,
1337 struct list_head *pages, int bytes_read, char *data,
1338 struct pagevec *plru_pvec)
1343 while (bytes_read > 0) {
1344 if (list_empty(pages))
1347 page = list_entry(pages->prev, struct page, lru);
1348 list_del(&page->lru);
1350 if (add_to_page_cache(page, mapping, page->index,
1352 page_cache_release(page);
1353 cFYI(1, ("Add page cache failed"));
1357 target = kmap_atomic(page,KM_USER0);
1359 if (PAGE_CACHE_SIZE > bytes_read) {
1360 memcpy(target, data, bytes_read);
1361 /* zero the tail end of this partial page */
1362 memset(target + bytes_read, 0,
1363 PAGE_CACHE_SIZE - bytes_read);
1366 memcpy(target, data, PAGE_CACHE_SIZE);
1367 bytes_read -= PAGE_CACHE_SIZE;
1369 kunmap_atomic(target, KM_USER0);
1371 flush_dcache_page(page);
1372 SetPageUptodate(page);
1374 if (!pagevec_add(plru_pvec, page))
1375 __pagevec_lru_add(plru_pvec);
1376 data += PAGE_CACHE_SIZE;
1381 static int cifs_readpages(struct file *file, struct address_space *mapping,
1382 struct list_head *page_list, unsigned num_pages)
1388 struct cifs_sb_info *cifs_sb;
1389 struct cifsTconInfo *pTcon;
1391 unsigned int read_size,i;
1392 char *smb_read_data = NULL;
1393 struct smb_com_read_rsp *pSMBr;
1394 struct pagevec lru_pvec;
1395 struct cifsFileInfo *open_file;
1398 if (file->private_data == NULL) {
1402 open_file = (struct cifsFileInfo *)file->private_data;
1403 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1404 pTcon = cifs_sb->tcon;
1406 pagevec_init(&lru_pvec, 0);
1408 for (i = 0; i < num_pages; ) {
1409 unsigned contig_pages;
1410 struct page *tmp_page;
1411 unsigned long expected_index;
1413 if (list_empty(page_list))
1416 page = list_entry(page_list->prev, struct page, lru);
1417 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1419 /* count adjacent pages that we will read into */
1422 list_entry(page_list->prev, struct page, lru)->index;
1423 list_for_each_entry_reverse(tmp_page,page_list,lru) {
1424 if (tmp_page->index == expected_index) {
1430 if (contig_pages + i > num_pages)
1431 contig_pages = num_pages - i;
1433 /* for reads over a certain size could initiate async
1436 read_size = contig_pages * PAGE_CACHE_SIZE;
1437 /* Read size needs to be in multiples of one page */
1438 read_size = min_t(const unsigned int, read_size,
1439 cifs_sb->rsize & PAGE_CACHE_MASK);
1442 while (rc == -EAGAIN) {
1443 if ((open_file->invalidHandle) &&
1444 (!open_file->closePend)) {
1445 rc = cifs_reopen_file(file->f_dentry->d_inode,
1451 rc = CIFSSMBRead(xid, pTcon,
1454 &bytes_read, &smb_read_data);
1455 /* BB need to check return code here */
1457 if (smb_read_data) {
1458 cifs_buf_release(smb_read_data);
1459 smb_read_data = NULL;
1463 if ((rc < 0) || (smb_read_data == NULL)) {
1464 cFYI(1, ("Read error in readpages: %d", rc));
1465 /* clean up remaing pages off list */
1466 while (!list_empty(page_list) && (i < num_pages)) {
1467 page = list_entry(page_list->prev, struct page,
1469 list_del(&page->lru);
1470 page_cache_release(page);
1473 } else if (bytes_read > 0) {
1474 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1475 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1476 smb_read_data + 4 /* RFC1001 hdr */ +
1477 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1479 i += bytes_read >> PAGE_CACHE_SHIFT;
1480 #ifdef CONFIG_CIFS_STATS
1481 atomic_inc(&pTcon->num_reads);
1482 spin_lock(&pTcon->stat_lock);
1483 pTcon->bytes_read += bytes_read;
1484 spin_unlock(&pTcon->stat_lock);
1486 if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1487 i++; /* account for partial page */
1489 /* server copy of file can have smaller size
1491 /* BB do we need to verify this common case ?
1492 this case is ok - if we are at server EOF
1493 we will hit it on next read */
1495 /* while (!list_empty(page_list) && (i < num_pages)) {
1496 page = list_entry(page_list->prev,
1498 list_del(&page->list);
1499 page_cache_release(page);
1504 cFYI(1, ("No bytes read (%d) at offset %lld . "
1505 "Cleaning remaining pages from readahead list",
1506 bytes_read, offset));
1507 /* BB turn off caching and do new lookup on
1508 file size at server? */
1509 while (!list_empty(page_list) && (i < num_pages)) {
1510 page = list_entry(page_list->prev, struct page,
1512 list_del(&page->lru);
1514 /* BB removeme - replace with zero of page? */
1515 page_cache_release(page);
1519 if (smb_read_data) {
1520 cifs_buf_release(smb_read_data);
1521 smb_read_data = NULL;
1526 pagevec_lru_add(&lru_pvec);
1528 /* need to free smb_read_data buf before exit */
1529 if (smb_read_data) {
1530 cifs_buf_release(smb_read_data);
1531 smb_read_data = NULL;
1538 static int cifs_readpage_worker(struct file *file, struct page *page,
1544 page_cache_get(page);
1545 read_data = kmap(page);
1546 /* for reads over a certain size could initiate async read ahead */
1548 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1553 cFYI(1, ("Bytes read %d ",rc));
1555 file->f_dentry->d_inode->i_atime =
1556 current_fs_time(file->f_dentry->d_inode->i_sb);
1558 if (PAGE_CACHE_SIZE > rc)
1559 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1561 flush_dcache_page(page);
1562 SetPageUptodate(page);
1567 page_cache_release(page);
1571 static int cifs_readpage(struct file *file, struct page *page)
1573 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1579 if (file->private_data == NULL) {
1584 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1585 page, (int)offset, (int)offset));
1587 rc = cifs_readpage_worker(file, page, &offset);
1595 /* We do not want to update the file size from server for inodes
1596 open for write - to avoid races with writepage extending
1597 the file - in the future we could consider allowing
1598 refreshing the inode only on increases in the file size
1599 but this is tricky to do without racing with writebehind
1600 page caching in the current Linux kernel design */
1601 int is_size_safe_to_change(struct cifsInodeInfo *cifsInode)
1603 struct list_head *tmp;
1604 struct list_head *tmp1;
1605 struct cifsFileInfo *open_file = NULL;
1608 if (cifsInode == NULL)
1611 read_lock(&GlobalSMBSeslock);
1612 list_for_each_safe(tmp, tmp1, &cifsInode->openFileList) {
1613 open_file = list_entry(tmp, struct cifsFileInfo, flist);
1614 if (open_file == NULL)
1616 if (open_file->closePend)
1618 /* We check if file is open for writing,
1619 BB we could supplement this with a check to see if file size
1620 changes have been flushed to server - ie inode metadata dirty */
1621 if ((open_file->pfile) &&
1622 ((open_file->pfile->f_flags & O_RDWR) ||
1623 (open_file->pfile->f_flags & O_WRONLY))) {
1627 if (tmp->next == NULL) {
1628 cFYI(1, ("File instance %p removed", tmp));
1632 read_unlock(&GlobalSMBSeslock);
1637 static int cifs_prepare_write(struct file *file, struct page *page,
1638 unsigned from, unsigned to)
1641 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1642 cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
1643 if (!PageUptodate(page)) {
1644 /* if (to - from != PAGE_CACHE_SIZE) {
1645 void *kaddr = kmap_atomic(page, KM_USER0);
1646 memset(kaddr, 0, from);
1647 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
1648 flush_dcache_page(page);
1649 kunmap_atomic(kaddr, KM_USER0);
1651 /* If we are writing a full page it will be up to date,
1652 no need to read from the server */
1653 if ((to == PAGE_CACHE_SIZE) && (from == 0))
1654 SetPageUptodate(page);
1656 /* might as well read a page, it is fast enough */
1657 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
1658 rc = cifs_readpage_worker(file, page, &offset);
1660 /* should we try using another file handle if there is one -
1661 how would we lock it to prevent close of that handle
1662 racing with this read?
1663 In any case this will be written out by commit_write */
1667 /* BB should we pass any errors back?
1668 e.g. if we do not have read access to the file */
1672 struct address_space_operations cifs_addr_ops = {
1673 .readpage = cifs_readpage,
1674 .readpages = cifs_readpages,
1675 .writepage = cifs_writepage,
1676 .prepare_write = cifs_prepare_write,
1677 .commit_write = cifs_commit_write,
1678 .set_page_dirty = __set_page_dirty_nobuffers,
1679 /* .sync_page = cifs_sync_page, */