4 * vfs operations that deal with files
6 * Copyright (C) International Business Machines Corp., 2002,2007
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 * Jeremy Allison (jra@samba.org)
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/writeback.h>
31 #include <linux/task_io_accounting_ops.h>
32 #include <linux/delay.h>
33 #include <asm/div64.h>
37 #include "cifsproto.h"
38 #include "cifs_unicode.h"
39 #include "cifs_debug.h"
40 #include "cifs_fs_sb.h"
42 static inline struct cifsFileInfo *cifs_init_private(
43 struct cifsFileInfo *private_data, struct inode *inode,
44 struct file *file, __u16 netfid)
46 memset(private_data, 0, sizeof(struct cifsFileInfo));
47 private_data->netfid = netfid;
48 private_data->pid = current->tgid;
49 mutex_init(&private_data->fh_mutex);
50 mutex_init(&private_data->lock_mutex);
51 INIT_LIST_HEAD(&private_data->llist);
52 private_data->pfile = file; /* needed for writepage */
53 private_data->pInode = inode;
54 private_data->invalidHandle = false;
55 private_data->closePend = false;
56 /* we have to track num writers to the inode, since writepages
57 does not tell us which handle the write is for so there can
58 be a close (overlapping with write) of the filehandle that
59 cifs_writepages chose to use */
60 atomic_set(&private_data->wrtPending, 0);
65 static inline int cifs_convert_flags(unsigned int flags)
67 if ((flags & O_ACCMODE) == O_RDONLY)
69 else if ((flags & O_ACCMODE) == O_WRONLY)
71 else if ((flags & O_ACCMODE) == O_RDWR) {
72 /* GENERIC_ALL is too much permission to request
73 can cause unnecessary access denied on create */
74 /* return GENERIC_ALL; */
75 return (GENERIC_READ | GENERIC_WRITE);
78 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
79 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
83 static inline fmode_t cifs_posix_convert_flags(unsigned int flags)
85 fmode_t posix_flags = 0;
87 if ((flags & O_ACCMODE) == O_RDONLY)
88 posix_flags = FMODE_READ;
89 else if ((flags & O_ACCMODE) == O_WRONLY)
90 posix_flags = FMODE_WRITE;
91 else if ((flags & O_ACCMODE) == O_RDWR) {
92 /* GENERIC_ALL is too much permission to request
93 can cause unnecessary access denied on create */
94 /* return GENERIC_ALL; */
95 posix_flags = FMODE_READ | FMODE_WRITE;
97 /* can not map O_CREAT or O_EXCL or O_TRUNC flags when
98 reopening a file. They had their effect on the original open */
100 posix_flags |= (fmode_t)O_APPEND;
102 posix_flags |= (fmode_t)O_SYNC;
103 if (flags & O_DIRECTORY)
104 posix_flags |= (fmode_t)O_DIRECTORY;
105 if (flags & O_NOFOLLOW)
106 posix_flags |= (fmode_t)O_NOFOLLOW;
107 if (flags & O_DIRECT)
108 posix_flags |= (fmode_t)O_DIRECT;
113 static inline int cifs_get_disposition(unsigned int flags)
115 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
117 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
118 return FILE_OVERWRITE_IF;
119 else if ((flags & O_CREAT) == O_CREAT)
121 else if ((flags & O_TRUNC) == O_TRUNC)
122 return FILE_OVERWRITE;
127 /* all arguments to this function must be checked for validity in caller */
128 static inline int cifs_posix_open_inode_helper(struct inode *inode,
129 struct file *file, struct cifsInodeInfo *pCifsInode,
130 struct cifsFileInfo *pCifsFile, int oplock, u16 netfid)
132 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
133 /* struct timespec temp; */ /* BB REMOVEME BB */
135 file->private_data = kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
136 if (file->private_data == NULL)
138 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
139 write_lock(&GlobalSMBSeslock);
140 list_add(&pCifsFile->tlist, &cifs_sb->tcon->openFileList);
142 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
143 if (pCifsInode == NULL) {
144 write_unlock(&GlobalSMBSeslock);
148 /* want handles we can use to read with first
149 in the list so we do not have to walk the
150 list to search for one in write_begin */
151 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
152 list_add_tail(&pCifsFile->flist,
153 &pCifsInode->openFileList);
155 list_add(&pCifsFile->flist,
156 &pCifsInode->openFileList);
159 if (pCifsInode->clientCanCacheRead) {
160 /* we have the inode open somewhere else
161 no need to discard cache data */
162 goto psx_client_can_cache;
165 /* BB FIXME need to fix this check to move it earlier into posix_open
166 BB fIX following section BB FIXME */
168 /* if not oplocked, invalidate inode pages if mtime or file
170 /* temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
171 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
172 (file->f_path.dentry->d_inode->i_size ==
173 (loff_t)le64_to_cpu(buf->EndOfFile))) {
174 cFYI(1, ("inode unchanged on server"));
176 if (file->f_path.dentry->d_inode->i_mapping) {
177 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
179 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
181 cFYI(1, ("invalidating remote inode since open detected it "
183 invalidate_remote_inode(file->f_path.dentry->d_inode);
186 psx_client_can_cache:
187 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
188 pCifsInode->clientCanCacheAll = true;
189 pCifsInode->clientCanCacheRead = true;
190 cFYI(1, ("Exclusive Oplock granted on inode %p",
191 file->f_path.dentry->d_inode));
192 } else if ((oplock & 0xF) == OPLOCK_READ)
193 pCifsInode->clientCanCacheRead = true;
195 /* will have to change the unlock if we reenable the
196 filemap_fdatawrite (which does not seem necessary */
197 write_unlock(&GlobalSMBSeslock);
201 /* all arguments to this function must be checked for validity in caller */
202 static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
203 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
204 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
205 char *full_path, int xid)
207 struct timespec temp;
210 /* want handles we can use to read with first
211 in the list so we do not have to walk the
212 list to search for one in write_begin */
213 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
214 list_add_tail(&pCifsFile->flist,
215 &pCifsInode->openFileList);
217 list_add(&pCifsFile->flist,
218 &pCifsInode->openFileList);
220 write_unlock(&GlobalSMBSeslock);
221 if (pCifsInode->clientCanCacheRead) {
222 /* we have the inode open somewhere else
223 no need to discard cache data */
224 goto client_can_cache;
227 /* BB need same check in cifs_create too? */
228 /* if not oplocked, invalidate inode pages if mtime or file
230 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
231 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
232 (file->f_path.dentry->d_inode->i_size ==
233 (loff_t)le64_to_cpu(buf->EndOfFile))) {
234 cFYI(1, ("inode unchanged on server"));
236 if (file->f_path.dentry->d_inode->i_mapping) {
237 /* BB no need to lock inode until after invalidate
238 since namei code should already have it locked? */
239 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
241 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
243 cFYI(1, ("invalidating remote inode since open detected it "
245 invalidate_remote_inode(file->f_path.dentry->d_inode);
250 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
251 full_path, inode->i_sb, xid);
253 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
254 full_path, buf, inode->i_sb, xid, NULL);
256 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
257 pCifsInode->clientCanCacheAll = true;
258 pCifsInode->clientCanCacheRead = true;
259 cFYI(1, ("Exclusive Oplock granted on inode %p",
260 file->f_path.dentry->d_inode));
261 } else if ((*oplock & 0xF) == OPLOCK_READ)
262 pCifsInode->clientCanCacheRead = true;
267 int cifs_open(struct inode *inode, struct file *file)
271 struct cifs_sb_info *cifs_sb;
272 struct cifsTconInfo *tcon;
273 struct cifsFileInfo *pCifsFile;
274 struct cifsInodeInfo *pCifsInode;
275 struct list_head *tmp;
276 char *full_path = NULL;
280 FILE_ALL_INFO *buf = NULL;
284 cifs_sb = CIFS_SB(inode->i_sb);
285 tcon = cifs_sb->tcon;
287 /* search inode for this file and fill in file->private_data */
288 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
289 read_lock(&GlobalSMBSeslock);
290 list_for_each(tmp, &pCifsInode->openFileList) {
291 pCifsFile = list_entry(tmp, struct cifsFileInfo,
293 if ((pCifsFile->pfile == NULL) &&
294 (pCifsFile->pid == current->tgid)) {
295 /* mode set in cifs_create */
297 /* needed for writepage */
298 pCifsFile->pfile = file;
300 file->private_data = pCifsFile;
304 read_unlock(&GlobalSMBSeslock);
306 if (file->private_data != NULL) {
311 if ((file->f_flags & O_CREAT) && (file->f_flags & O_EXCL))
312 cERROR(1, ("could not find file instance for "
313 "new file %p", file));
316 full_path = build_path_from_dentry(file->f_path.dentry);
317 if (full_path == NULL) {
322 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
323 inode, file->f_flags, full_path));
330 if (!tcon->broken_posix_open && tcon->unix_ext &&
331 (tcon->ses->capabilities & CAP_UNIX) &&
332 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
333 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
334 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
335 /* can not refresh inode info since size could be stale */
336 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
337 cifs_sb->mnt_file_mode /* ignored */,
338 oflags, &oplock, &netfid, xid);
340 cFYI(1, ("posix open succeeded"));
341 /* no need for special case handling of setting mode
342 on read only files needed here */
344 cifs_posix_open_inode_helper(inode, file, pCifsInode,
345 pCifsFile, oplock, netfid);
347 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
348 if (tcon->ses->serverNOS)
349 cERROR(1, ("server %s of type %s returned"
350 " unexpected error on SMB posix open"
351 ", disabling posix open support."
352 " Check if server update available.",
353 tcon->ses->serverName,
354 tcon->ses->serverNOS));
355 tcon->broken_posix_open = true;
356 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
357 (rc != -EOPNOTSUPP)) /* path not found or net err */
359 /* else fallthrough to retry open the old way on network i/o
363 desiredAccess = cifs_convert_flags(file->f_flags);
365 /*********************************************************************
366 * open flag mapping table:
368 * POSIX Flag CIFS Disposition
369 * ---------- ----------------
370 * O_CREAT FILE_OPEN_IF
371 * O_CREAT | O_EXCL FILE_CREATE
372 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
373 * O_TRUNC FILE_OVERWRITE
374 * none of the above FILE_OPEN
376 * Note that there is not a direct match between disposition
377 * FILE_SUPERSEDE (ie create whether or not file exists although
378 * O_CREAT | O_TRUNC is similar but truncates the existing
379 * file rather than creating a new file as FILE_SUPERSEDE does
380 * (which uses the attributes / metadata passed in on open call)
382 *? O_SYNC is a reasonable match to CIFS writethrough flag
383 *? and the read write flags match reasonably. O_LARGEFILE
384 *? is irrelevant because largefile support is always used
385 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
386 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
387 *********************************************************************/
389 disposition = cifs_get_disposition(file->f_flags);
391 /* BB pass O_SYNC flag through on file attributes .. BB */
393 /* Also refresh inode by passing in file_info buf returned by SMBOpen
394 and calling get_inode_info with returned buf (at least helps
395 non-Unix server case) */
397 /* BB we can not do this if this is the second open of a file
398 and the first handle has writebehind data, we might be
399 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
400 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
406 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
407 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
408 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
409 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
410 & CIFS_MOUNT_MAP_SPECIAL_CHR);
412 rc = -EIO; /* no NT SMB support fall into legacy open below */
415 /* Old server, try legacy style OpenX */
416 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
417 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
418 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
419 & CIFS_MOUNT_MAP_SPECIAL_CHR);
422 cFYI(1, ("cifs_open returned 0x%x", rc));
426 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
427 if (file->private_data == NULL) {
431 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
432 write_lock(&GlobalSMBSeslock);
433 list_add(&pCifsFile->tlist, &tcon->openFileList);
435 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
437 rc = cifs_open_inode_helper(inode, file, pCifsInode,
439 &oplock, buf, full_path, xid);
441 write_unlock(&GlobalSMBSeslock);
444 if (oplock & CIFS_CREATE_ACTION) {
445 /* time to set mode which we can not set earlier due to
446 problems creating new read-only files */
447 if (tcon->unix_ext) {
448 struct cifs_unix_set_info_args args = {
449 .mode = inode->i_mode,
452 .ctime = NO_CHANGE_64,
453 .atime = NO_CHANGE_64,
454 .mtime = NO_CHANGE_64,
457 CIFSSMBUnixSetInfo(xid, tcon, full_path, &args,
459 cifs_sb->mnt_cifs_flags &
460 CIFS_MOUNT_MAP_SPECIAL_CHR);
471 /* Try to reacquire byte range locks that were released when session */
472 /* to server was lost */
473 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
477 /* BB list all locks open on this file and relock */
482 static int cifs_reopen_file(struct file *file, bool can_flush)
486 struct cifs_sb_info *cifs_sb;
487 struct cifsTconInfo *tcon;
488 struct cifsFileInfo *pCifsFile;
489 struct cifsInodeInfo *pCifsInode;
491 char *full_path = NULL;
493 int disposition = FILE_OPEN;
496 if (file->private_data)
497 pCifsFile = (struct cifsFileInfo *)file->private_data;
502 mutex_unlock(&pCifsFile->fh_mutex);
503 if (!pCifsFile->invalidHandle) {
504 mutex_lock(&pCifsFile->fh_mutex);
509 if (file->f_path.dentry == NULL) {
510 cERROR(1, ("no valid name if dentry freed"));
513 goto reopen_error_exit;
516 inode = file->f_path.dentry->d_inode;
518 cERROR(1, ("inode not valid"));
521 goto reopen_error_exit;
524 cifs_sb = CIFS_SB(inode->i_sb);
525 tcon = cifs_sb->tcon;
527 /* can not grab rename sem here because various ops, including
528 those that already have the rename sem can end up causing writepage
529 to get called and if the server was down that means we end up here,
530 and we can never tell if the caller already has the rename_sem */
531 full_path = build_path_from_dentry(file->f_path.dentry);
532 if (full_path == NULL) {
535 mutex_lock(&pCifsFile->fh_mutex);
540 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
541 inode, file->f_flags, full_path));
548 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
549 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
550 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
551 int oflags = (int) cifs_posix_convert_flags(file->f_flags);
552 /* can not refresh inode info since size could be stale */
553 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
554 cifs_sb->mnt_file_mode /* ignored */,
555 oflags, &oplock, &netfid, xid);
557 cFYI(1, ("posix reopen succeeded"));
560 /* fallthrough to retry open the old way on errors, especially
561 in the reconnect path it is important to retry hard */
564 desiredAccess = cifs_convert_flags(file->f_flags);
566 /* Can not refresh inode by passing in file_info buf to be returned
567 by SMBOpen and then calling get_inode_info with returned buf
568 since file might have write behind data that needs to be flushed
569 and server version of file size can be stale. If we knew for sure
570 that inode was not dirty locally we could do this */
572 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
573 CREATE_NOT_DIR, &netfid, &oplock, NULL,
574 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
575 CIFS_MOUNT_MAP_SPECIAL_CHR);
577 mutex_lock(&pCifsFile->fh_mutex);
578 cFYI(1, ("cifs_open returned 0x%x", rc));
579 cFYI(1, ("oplock: %d", oplock));
582 pCifsFile->netfid = netfid;
583 pCifsFile->invalidHandle = false;
584 mutex_lock(&pCifsFile->fh_mutex);
585 pCifsInode = CIFS_I(inode);
588 rc = filemap_write_and_wait(inode->i_mapping);
590 CIFS_I(inode)->write_behind_rc = rc;
591 /* temporarily disable caching while we
592 go to server to get inode info */
593 pCifsInode->clientCanCacheAll = false;
594 pCifsInode->clientCanCacheRead = false;
596 rc = cifs_get_inode_info_unix(&inode,
597 full_path, inode->i_sb, xid);
599 rc = cifs_get_inode_info(&inode,
600 full_path, NULL, inode->i_sb,
602 } /* else we are writing out data to server already
603 and could deadlock if we tried to flush data, and
604 since we do not know if we have data that would
605 invalidate the current end of file on the server
606 we can not go to the server to get the new inod
608 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
609 pCifsInode->clientCanCacheAll = true;
610 pCifsInode->clientCanCacheRead = true;
611 cFYI(1, ("Exclusive Oplock granted on inode %p",
612 file->f_path.dentry->d_inode));
613 } else if ((oplock & 0xF) == OPLOCK_READ) {
614 pCifsInode->clientCanCacheRead = true;
615 pCifsInode->clientCanCacheAll = false;
617 pCifsInode->clientCanCacheRead = false;
618 pCifsInode->clientCanCacheAll = false;
620 cifs_relock_file(pCifsFile);
628 int cifs_close(struct inode *inode, struct file *file)
632 struct cifs_sb_info *cifs_sb;
633 struct cifsTconInfo *pTcon;
634 struct cifsFileInfo *pSMBFile =
635 (struct cifsFileInfo *)file->private_data;
639 cifs_sb = CIFS_SB(inode->i_sb);
640 pTcon = cifs_sb->tcon;
642 struct cifsLockInfo *li, *tmp;
643 write_lock(&GlobalSMBSeslock);
644 pSMBFile->closePend = true;
646 /* no sense reconnecting to close a file that is
648 if (!pTcon->need_reconnect) {
649 write_unlock(&GlobalSMBSeslock);
651 while ((atomic_read(&pSMBFile->wrtPending) != 0)
652 && (timeout <= 2048)) {
653 /* Give write a better chance to get to
654 server ahead of the close. We do not
655 want to add a wait_q here as it would
656 increase the memory utilization as
657 the struct would be in each open file,
658 but this should give enough time to
661 ("close delay, write pending"));
665 if (atomic_read(&pSMBFile->wrtPending))
666 cERROR(1, ("close with pending write"));
667 if (!pTcon->need_reconnect &&
668 !pSMBFile->invalidHandle)
669 rc = CIFSSMBClose(xid, pTcon,
672 write_unlock(&GlobalSMBSeslock);
674 write_unlock(&GlobalSMBSeslock);
676 /* Delete any outstanding lock records.
677 We'll lose them when the file is closed anyway. */
678 mutex_lock(&pSMBFile->lock_mutex);
679 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
680 list_del(&li->llist);
683 mutex_unlock(&pSMBFile->lock_mutex);
685 write_lock(&GlobalSMBSeslock);
686 list_del(&pSMBFile->flist);
687 list_del(&pSMBFile->tlist);
688 write_unlock(&GlobalSMBSeslock);
690 /* We waited above to give the SMBWrite a chance to issue
691 on the wire (so we do not get SMBWrite returning EBADF
692 if writepages is racing with close. Note that writepages
693 does not specify a file handle, so it is possible for a file
694 to be opened twice, and the application close the "wrong"
695 file handle - in these cases we delay long enough to allow
696 the SMBWrite to get on the wire before the SMB Close.
697 We allow total wait here over 45 seconds, more than
698 oplock break time, and more than enough to allow any write
699 to complete on the server, or to time out on the client */
700 while ((atomic_read(&pSMBFile->wrtPending) != 0)
701 && (timeout <= 50000)) {
702 cERROR(1, ("writes pending, delay free of handle"));
706 kfree(file->private_data);
707 file->private_data = NULL;
711 read_lock(&GlobalSMBSeslock);
712 if (list_empty(&(CIFS_I(inode)->openFileList))) {
713 cFYI(1, ("closing last open instance for inode %p", inode));
714 /* if the file is not open we do not know if we can cache info
715 on this inode, much less write behind and read ahead */
716 CIFS_I(inode)->clientCanCacheRead = false;
717 CIFS_I(inode)->clientCanCacheAll = false;
719 read_unlock(&GlobalSMBSeslock);
720 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
721 rc = CIFS_I(inode)->write_behind_rc;
726 int cifs_closedir(struct inode *inode, struct file *file)
730 struct cifsFileInfo *pCFileStruct =
731 (struct cifsFileInfo *)file->private_data;
734 cFYI(1, ("Closedir inode = 0x%p", inode));
739 struct cifsTconInfo *pTcon;
740 struct cifs_sb_info *cifs_sb =
741 CIFS_SB(file->f_path.dentry->d_sb);
743 pTcon = cifs_sb->tcon;
745 cFYI(1, ("Freeing private data in close dir"));
746 write_lock(&GlobalSMBSeslock);
747 if (!pCFileStruct->srch_inf.endOfSearch &&
748 !pCFileStruct->invalidHandle) {
749 pCFileStruct->invalidHandle = true;
750 write_unlock(&GlobalSMBSeslock);
751 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
752 cFYI(1, ("Closing uncompleted readdir with rc %d",
754 /* not much we can do if it fails anyway, ignore rc */
757 write_unlock(&GlobalSMBSeslock);
758 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
760 cFYI(1, ("closedir free smb buf in srch struct"));
761 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
762 if (pCFileStruct->srch_inf.smallBuf)
763 cifs_small_buf_release(ptmp);
765 cifs_buf_release(ptmp);
767 kfree(file->private_data);
768 file->private_data = NULL;
770 /* BB can we lock the filestruct while this is going on? */
775 static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
776 __u64 offset, __u8 lockType)
778 struct cifsLockInfo *li =
779 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
785 mutex_lock(&fid->lock_mutex);
786 list_add(&li->llist, &fid->llist);
787 mutex_unlock(&fid->lock_mutex);
791 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
797 bool wait_flag = false;
798 struct cifs_sb_info *cifs_sb;
799 struct cifsTconInfo *tcon;
801 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
802 bool posix_locking = 0;
804 length = 1 + pfLock->fl_end - pfLock->fl_start;
808 cFYI(1, ("Lock parm: 0x%x flockflags: "
809 "0x%x flocktype: 0x%x start: %lld end: %lld",
810 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
813 if (pfLock->fl_flags & FL_POSIX)
815 if (pfLock->fl_flags & FL_FLOCK)
817 if (pfLock->fl_flags & FL_SLEEP) {
818 cFYI(1, ("Blocking lock"));
821 if (pfLock->fl_flags & FL_ACCESS)
822 cFYI(1, ("Process suspended by mandatory locking - "
823 "not implemented yet"));
824 if (pfLock->fl_flags & FL_LEASE)
825 cFYI(1, ("Lease on file - not implemented yet"));
826 if (pfLock->fl_flags &
827 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
828 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
830 if (pfLock->fl_type == F_WRLCK) {
831 cFYI(1, ("F_WRLCK "));
833 } else if (pfLock->fl_type == F_UNLCK) {
834 cFYI(1, ("F_UNLCK"));
836 /* Check if unlock includes more than
838 } else if (pfLock->fl_type == F_RDLCK) {
839 cFYI(1, ("F_RDLCK"));
840 lockType |= LOCKING_ANDX_SHARED_LOCK;
842 } else if (pfLock->fl_type == F_EXLCK) {
843 cFYI(1, ("F_EXLCK"));
845 } else if (pfLock->fl_type == F_SHLCK) {
846 cFYI(1, ("F_SHLCK"));
847 lockType |= LOCKING_ANDX_SHARED_LOCK;
850 cFYI(1, ("Unknown type of lock"));
852 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
853 tcon = cifs_sb->tcon;
855 if (file->private_data == NULL) {
859 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
861 if ((tcon->ses->capabilities & CAP_UNIX) &&
862 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
863 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
865 /* BB add code here to normalize offset and length to
866 account for negative length which we can not accept over the
871 if (lockType & LOCKING_ANDX_SHARED_LOCK)
872 posix_lock_type = CIFS_RDLCK;
874 posix_lock_type = CIFS_WRLCK;
875 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
877 posix_lock_type, wait_flag);
882 /* BB we could chain these into one lock request BB */
883 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
884 0, 1, lockType, 0 /* wait flag */ );
886 rc = CIFSSMBLock(xid, tcon, netfid, length,
887 pfLock->fl_start, 1 /* numUnlock */ ,
888 0 /* numLock */ , lockType,
890 pfLock->fl_type = F_UNLCK;
892 cERROR(1, ("Error unlocking previously locked "
893 "range %d during test of lock", rc));
897 /* if rc == ERR_SHARING_VIOLATION ? */
898 rc = 0; /* do not change lock type to unlock
899 since range in use */
906 if (!numLock && !numUnlock) {
907 /* if no lock or unlock then nothing
908 to do since we do not know what it is */
915 if (lockType & LOCKING_ANDX_SHARED_LOCK)
916 posix_lock_type = CIFS_RDLCK;
918 posix_lock_type = CIFS_WRLCK;
921 posix_lock_type = CIFS_UNLCK;
923 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
925 posix_lock_type, wait_flag);
927 struct cifsFileInfo *fid =
928 (struct cifsFileInfo *)file->private_data;
931 rc = CIFSSMBLock(xid, tcon, netfid, length,
933 0, numLock, lockType, wait_flag);
936 /* For Windows locks we must store them. */
937 rc = store_file_lock(fid, length,
938 pfLock->fl_start, lockType);
940 } else if (numUnlock) {
941 /* For each stored lock that this unlock overlaps
942 completely, unlock it. */
944 struct cifsLockInfo *li, *tmp;
947 mutex_lock(&fid->lock_mutex);
948 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
949 if (pfLock->fl_start <= li->offset &&
950 (pfLock->fl_start + length) >=
951 (li->offset + li->length)) {
952 stored_rc = CIFSSMBLock(xid, tcon,
954 li->length, li->offset,
955 1, 0, li->type, false);
959 list_del(&li->llist);
963 mutex_unlock(&fid->lock_mutex);
967 if (pfLock->fl_flags & FL_POSIX)
968 posix_lock_file_wait(file, pfLock);
974 * Set the timeout on write requests past EOF. For some servers (Windows)
975 * these calls can be very long.
977 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
978 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
979 * The 10M cutoff is totally arbitrary. A better scheme for this would be
980 * welcome if someone wants to suggest one.
982 * We may be able to do a better job with this if there were some way to
983 * declare that a file should be sparse.
986 cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
988 if (offset <= cifsi->server_eof)
990 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
991 return CIFS_VLONG_OP;
996 /* update the file size (if needed) after a write */
998 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
999 unsigned int bytes_written)
1001 loff_t end_of_write = offset + bytes_written;
1003 if (end_of_write > cifsi->server_eof)
1004 cifsi->server_eof = end_of_write;
1007 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
1008 size_t write_size, loff_t *poffset)
1011 unsigned int bytes_written = 0;
1012 unsigned int total_written;
1013 struct cifs_sb_info *cifs_sb;
1014 struct cifsTconInfo *pTcon;
1016 struct cifsFileInfo *open_file;
1017 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1019 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1021 pTcon = cifs_sb->tcon;
1024 (" write %d bytes to offset %lld of %s", write_size,
1025 *poffset, file->f_path.dentry->d_name.name)); */
1027 if (file->private_data == NULL)
1029 open_file = (struct cifsFileInfo *) file->private_data;
1031 rc = generic_write_checks(file, poffset, &write_size, 0);
1037 long_op = cifs_write_timeout(cifsi, *poffset);
1038 for (total_written = 0; write_size > total_written;
1039 total_written += bytes_written) {
1041 while (rc == -EAGAIN) {
1042 if (file->private_data == NULL) {
1043 /* file has been closed on us */
1045 /* if we have gotten here we have written some data
1046 and blocked, and the file has been freed on us while
1047 we blocked so return what we managed to write */
1048 return total_written;
1050 if (open_file->closePend) {
1053 return total_written;
1057 if (open_file->invalidHandle) {
1058 /* we could deadlock if we called
1059 filemap_fdatawait from here so tell
1060 reopen_file not to flush data to server
1062 rc = cifs_reopen_file(file, false);
1067 rc = CIFSSMBWrite(xid, pTcon,
1069 min_t(const int, cifs_sb->wsize,
1070 write_size - total_written),
1071 *poffset, &bytes_written,
1072 NULL, write_data + total_written, long_op);
1074 if (rc || (bytes_written == 0)) {
1082 cifs_update_eof(cifsi, *poffset, bytes_written);
1083 *poffset += bytes_written;
1085 long_op = CIFS_STD_OP; /* subsequent writes fast -
1086 15 seconds is plenty */
1089 cifs_stats_bytes_written(pTcon, total_written);
1091 /* since the write may have blocked check these pointers again */
1092 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1093 struct inode *inode = file->f_path.dentry->d_inode;
1094 /* Do not update local mtime - server will set its actual value on write
1095 * inode->i_ctime = inode->i_mtime =
1096 * current_fs_time(inode->i_sb);*/
1097 if (total_written > 0) {
1098 spin_lock(&inode->i_lock);
1099 if (*poffset > file->f_path.dentry->d_inode->i_size)
1100 i_size_write(file->f_path.dentry->d_inode,
1102 spin_unlock(&inode->i_lock);
1104 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1107 return total_written;
1110 static ssize_t cifs_write(struct file *file, const char *write_data,
1111 size_t write_size, loff_t *poffset)
1114 unsigned int bytes_written = 0;
1115 unsigned int total_written;
1116 struct cifs_sb_info *cifs_sb;
1117 struct cifsTconInfo *pTcon;
1119 struct cifsFileInfo *open_file;
1120 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
1122 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1124 pTcon = cifs_sb->tcon;
1126 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
1127 *poffset, file->f_path.dentry->d_name.name));
1129 if (file->private_data == NULL)
1131 open_file = (struct cifsFileInfo *)file->private_data;
1135 long_op = cifs_write_timeout(cifsi, *poffset);
1136 for (total_written = 0; write_size > total_written;
1137 total_written += bytes_written) {
1139 while (rc == -EAGAIN) {
1140 if (file->private_data == NULL) {
1141 /* file has been closed on us */
1143 /* if we have gotten here we have written some data
1144 and blocked, and the file has been freed on us
1145 while we blocked so return what we managed to
1147 return total_written;
1149 if (open_file->closePend) {
1152 return total_written;
1156 if (open_file->invalidHandle) {
1157 /* we could deadlock if we called
1158 filemap_fdatawait from here so tell
1159 reopen_file not to flush data to
1161 rc = cifs_reopen_file(file, false);
1165 if (experimEnabled || (pTcon->ses->server &&
1166 ((pTcon->ses->server->secMode &
1167 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1172 len = min((size_t)cifs_sb->wsize,
1173 write_size - total_written);
1174 /* iov[0] is reserved for smb header */
1175 iov[1].iov_base = (char *)write_data +
1177 iov[1].iov_len = len;
1178 rc = CIFSSMBWrite2(xid, pTcon,
1179 open_file->netfid, len,
1180 *poffset, &bytes_written,
1183 rc = CIFSSMBWrite(xid, pTcon,
1185 min_t(const int, cifs_sb->wsize,
1186 write_size - total_written),
1187 *poffset, &bytes_written,
1188 write_data + total_written,
1191 if (rc || (bytes_written == 0)) {
1199 cifs_update_eof(cifsi, *poffset, bytes_written);
1200 *poffset += bytes_written;
1202 long_op = CIFS_STD_OP; /* subsequent writes fast -
1203 15 seconds is plenty */
1206 cifs_stats_bytes_written(pTcon, total_written);
1208 /* since the write may have blocked check these pointers again */
1209 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1210 /*BB We could make this contingent on superblock ATIME flag too */
1211 /* file->f_path.dentry->d_inode->i_ctime =
1212 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1213 if (total_written > 0) {
1214 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1215 if (*poffset > file->f_path.dentry->d_inode->i_size)
1216 i_size_write(file->f_path.dentry->d_inode,
1218 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
1220 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
1223 return total_written;
1226 #ifdef CONFIG_CIFS_EXPERIMENTAL
1227 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1229 struct cifsFileInfo *open_file = NULL;
1231 read_lock(&GlobalSMBSeslock);
1232 /* we could simply get the first_list_entry since write-only entries
1233 are always at the end of the list but since the first entry might
1234 have a close pending, we go through the whole list */
1235 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1236 if (open_file->closePend)
1238 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1239 (open_file->pfile->f_flags & O_RDONLY))) {
1240 if (!open_file->invalidHandle) {
1241 /* found a good file */
1242 /* lock it so it will not be closed on us */
1243 atomic_inc(&open_file->wrtPending);
1244 read_unlock(&GlobalSMBSeslock);
1246 } /* else might as well continue, and look for
1247 another, or simply have the caller reopen it
1248 again rather than trying to fix this handle */
1249 } else /* write only file */
1250 break; /* write only files are last so must be done */
1252 read_unlock(&GlobalSMBSeslock);
1257 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
1259 struct cifsFileInfo *open_file;
1260 bool any_available = false;
1263 /* Having a null inode here (because mapping->host was set to zero by
1264 the VFS or MM) should not happen but we had reports of on oops (due to
1265 it being zero) during stress testcases so we need to check for it */
1267 if (cifs_inode == NULL) {
1268 cERROR(1, ("Null inode passed to cifs_writeable_file"));
1273 read_lock(&GlobalSMBSeslock);
1275 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1276 if (open_file->closePend ||
1277 (!any_available && open_file->pid != current->tgid))
1280 if (open_file->pfile &&
1281 ((open_file->pfile->f_flags & O_RDWR) ||
1282 (open_file->pfile->f_flags & O_WRONLY))) {
1283 atomic_inc(&open_file->wrtPending);
1285 if (!open_file->invalidHandle) {
1286 /* found a good writable file */
1287 read_unlock(&GlobalSMBSeslock);
1291 read_unlock(&GlobalSMBSeslock);
1292 /* Had to unlock since following call can block */
1293 rc = cifs_reopen_file(open_file->pfile, false);
1295 if (!open_file->closePend)
1297 else { /* start over in case this was deleted */
1298 /* since the list could be modified */
1299 read_lock(&GlobalSMBSeslock);
1300 atomic_dec(&open_file->wrtPending);
1301 goto refind_writable;
1305 /* if it fails, try another handle if possible -
1306 (we can not do this if closePending since
1307 loop could be modified - in which case we
1308 have to start at the beginning of the list
1309 again. Note that it would be bad
1310 to hold up writepages here (rather than
1311 in caller) with continuous retries */
1312 cFYI(1, ("wp failed on reopen file"));
1313 read_lock(&GlobalSMBSeslock);
1314 /* can not use this handle, no write
1315 pending on this one after all */
1316 atomic_dec(&open_file->wrtPending);
1318 if (open_file->closePend) /* list could have changed */
1319 goto refind_writable;
1320 /* else we simply continue to the next entry. Thus
1321 we do not loop on reopen errors. If we
1322 can not reopen the file, for example if we
1323 reconnected to a server with another client
1324 racing to delete or lock the file we would not
1325 make progress if we restarted before the beginning
1326 of the loop here. */
1329 /* couldn't find useable FH with same pid, try any available */
1330 if (!any_available) {
1331 any_available = true;
1332 goto refind_writable;
1334 read_unlock(&GlobalSMBSeslock);
1338 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1340 struct address_space *mapping = page->mapping;
1341 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1344 int bytes_written = 0;
1345 struct cifs_sb_info *cifs_sb;
1346 struct cifsTconInfo *pTcon;
1347 struct inode *inode;
1348 struct cifsFileInfo *open_file;
1350 if (!mapping || !mapping->host)
1353 inode = page->mapping->host;
1354 cifs_sb = CIFS_SB(inode->i_sb);
1355 pTcon = cifs_sb->tcon;
1357 offset += (loff_t)from;
1358 write_data = kmap(page);
1361 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1366 /* racing with truncate? */
1367 if (offset > mapping->host->i_size) {
1369 return 0; /* don't care */
1372 /* check to make sure that we are not extending the file */
1373 if (mapping->host->i_size - offset < (loff_t)to)
1374 to = (unsigned)(mapping->host->i_size - offset);
1376 open_file = find_writable_file(CIFS_I(mapping->host));
1378 bytes_written = cifs_write(open_file->pfile, write_data,
1380 atomic_dec(&open_file->wrtPending);
1381 /* Does mm or vfs already set times? */
1382 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1383 if ((bytes_written > 0) && (offset))
1385 else if (bytes_written < 0)
1388 cFYI(1, ("No writeable filehandles for inode"));
1396 static int cifs_writepages(struct address_space *mapping,
1397 struct writeback_control *wbc)
1399 struct backing_dev_info *bdi = mapping->backing_dev_info;
1400 unsigned int bytes_to_write;
1401 unsigned int bytes_written;
1402 struct cifs_sb_info *cifs_sb;
1406 int range_whole = 0;
1413 struct cifsFileInfo *open_file;
1414 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
1416 struct pagevec pvec;
1421 cifs_sb = CIFS_SB(mapping->host->i_sb);
1424 * If wsize is smaller that the page cache size, default to writing
1425 * one page at a time via cifs_writepage
1427 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1428 return generic_writepages(mapping, wbc);
1430 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1431 if (cifs_sb->tcon->ses->server->secMode &
1432 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1433 if (!experimEnabled)
1434 return generic_writepages(mapping, wbc);
1436 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1438 return generic_writepages(mapping, wbc);
1442 * BB: Is this meaningful for a non-block-device file system?
1443 * If it is, we should test it again after we do I/O
1445 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1446 wbc->encountered_congestion = 1;
1453 pagevec_init(&pvec, 0);
1454 if (wbc->range_cyclic) {
1455 index = mapping->writeback_index; /* Start from prev offset */
1458 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1459 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1460 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1465 while (!done && (index <= end) &&
1466 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1467 PAGECACHE_TAG_DIRTY,
1468 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1477 for (i = 0; i < nr_pages; i++) {
1478 page = pvec.pages[i];
1480 * At this point we hold neither mapping->tree_lock nor
1481 * lock on the page itself: the page may be truncated or
1482 * invalidated (changing page->mapping to NULL), or even
1483 * swizzled back from swapper_space to tmpfs file
1489 else if (!trylock_page(page))
1492 if (unlikely(page->mapping != mapping)) {
1497 if (!wbc->range_cyclic && page->index > end) {
1503 if (next && (page->index != next)) {
1504 /* Not next consecutive page */
1509 if (wbc->sync_mode != WB_SYNC_NONE)
1510 wait_on_page_writeback(page);
1512 if (PageWriteback(page) ||
1513 !clear_page_dirty_for_io(page)) {
1519 * This actually clears the dirty bit in the radix tree.
1520 * See cifs_writepage() for more commentary.
1522 set_page_writeback(page);
1524 if (page_offset(page) >= mapping->host->i_size) {
1527 end_page_writeback(page);
1532 * BB can we get rid of this? pages are held by pvec
1534 page_cache_get(page);
1536 len = min(mapping->host->i_size - page_offset(page),
1537 (loff_t)PAGE_CACHE_SIZE);
1539 /* reserve iov[0] for the smb header */
1541 iov[n_iov].iov_base = kmap(page);
1542 iov[n_iov].iov_len = len;
1543 bytes_to_write += len;
1547 offset = page_offset(page);
1549 next = page->index + 1;
1550 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1554 /* Search for a writable handle every time we call
1555 * CIFSSMBWrite2. We can't rely on the last handle
1556 * we used to still be valid
1558 open_file = find_writable_file(CIFS_I(mapping->host));
1560 cERROR(1, ("No writable handles for inode"));
1563 long_op = cifs_write_timeout(cifsi, offset);
1564 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1566 bytes_to_write, offset,
1567 &bytes_written, iov, n_iov,
1569 atomic_dec(&open_file->wrtPending);
1570 cifs_update_eof(cifsi, offset, bytes_written);
1572 if (rc || bytes_written < bytes_to_write) {
1573 cERROR(1, ("Write2 ret %d, wrote %d",
1574 rc, bytes_written));
1575 /* BB what if continued retry is
1576 requested via mount flags? */
1578 set_bit(AS_ENOSPC, &mapping->flags);
1580 set_bit(AS_EIO, &mapping->flags);
1582 cifs_stats_bytes_written(cifs_sb->tcon,
1586 for (i = 0; i < n_iov; i++) {
1587 page = pvec.pages[first + i];
1588 /* Should we also set page error on
1589 success rc but too little data written? */
1590 /* BB investigate retry logic on temporary
1591 server crash cases and how recovery works
1592 when page marked as error */
1597 end_page_writeback(page);
1598 page_cache_release(page);
1600 if ((wbc->nr_to_write -= n_iov) <= 0)
1604 /* Need to re-find the pages we skipped */
1605 index = pvec.pages[0]->index + 1;
1607 pagevec_release(&pvec);
1609 if (!scanned && !done) {
1611 * We hit the last page and there is more work to be done: wrap
1612 * back to the start of the file
1618 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1619 mapping->writeback_index = index;
1626 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1632 /* BB add check for wbc flags */
1633 page_cache_get(page);
1634 if (!PageUptodate(page))
1635 cFYI(1, ("ppw - page not up to date"));
1638 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1640 * A writepage() implementation always needs to do either this,
1641 * or re-dirty the page with "redirty_page_for_writepage()" in
1642 * the case of a failure.
1644 * Just unlocking the page will cause the radix tree tag-bits
1645 * to fail to update with the state of the page correctly.
1647 set_page_writeback(page);
1648 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1649 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1651 end_page_writeback(page);
1652 page_cache_release(page);
1657 static int cifs_write_end(struct file *file, struct address_space *mapping,
1658 loff_t pos, unsigned len, unsigned copied,
1659 struct page *page, void *fsdata)
1662 struct inode *inode = mapping->host;
1664 cFYI(1, ("write_end for page %p from pos %lld with %d bytes",
1665 page, pos, copied));
1667 if (PageChecked(page)) {
1669 SetPageUptodate(page);
1670 ClearPageChecked(page);
1671 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1672 SetPageUptodate(page);
1674 if (!PageUptodate(page)) {
1676 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1680 /* this is probably better than directly calling
1681 partialpage_write since in this function the file handle is
1682 known which we might as well leverage */
1683 /* BB check if anything else missing out of ppw
1684 such as updating last write time */
1685 page_data = kmap(page);
1686 rc = cifs_write(file, page_data + offset, copied, &pos);
1687 /* if (rc < 0) should we set writebehind rc? */
1694 set_page_dirty(page);
1698 spin_lock(&inode->i_lock);
1699 if (pos > inode->i_size)
1700 i_size_write(inode, pos);
1701 spin_unlock(&inode->i_lock);
1705 page_cache_release(page);
1710 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1714 struct cifsTconInfo *tcon;
1715 struct cifsFileInfo *smbfile =
1716 (struct cifsFileInfo *)file->private_data;
1717 struct inode *inode = file->f_path.dentry->d_inode;
1721 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
1722 dentry->d_name.name, datasync));
1724 rc = filemap_write_and_wait(inode->i_mapping);
1726 rc = CIFS_I(inode)->write_behind_rc;
1727 CIFS_I(inode)->write_behind_rc = 0;
1728 tcon = CIFS_SB(inode->i_sb)->tcon;
1729 if (!rc && tcon && smbfile &&
1730 !(CIFS_SB(inode->i_sb)->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1731 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1738 /* static void cifs_sync_page(struct page *page)
1740 struct address_space *mapping;
1741 struct inode *inode;
1742 unsigned long index = page->index;
1743 unsigned int rpages = 0;
1746 cFYI(1, ("sync page %p",page));
1747 mapping = page->mapping;
1750 inode = mapping->host;
1754 /* fill in rpages then
1755 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1757 /* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
1767 * As file closes, flush all cached write data for this inode checking
1768 * for write behind errors.
1770 int cifs_flush(struct file *file, fl_owner_t id)
1772 struct inode *inode = file->f_path.dentry->d_inode;
1775 /* Rather than do the steps manually:
1776 lock the inode for writing
1777 loop through pages looking for write behind data (dirty pages)
1778 coalesce into contiguous 16K (or smaller) chunks to write to server
1779 send to server (prefer in parallel)
1780 deal with writebehind errors
1781 unlock inode for writing
1782 filemapfdatawrite appears easier for the time being */
1784 rc = filemap_fdatawrite(inode->i_mapping);
1785 /* reset wb rc if we were able to write out dirty pages */
1787 rc = CIFS_I(inode)->write_behind_rc;
1788 CIFS_I(inode)->write_behind_rc = 0;
1791 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
1796 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1797 size_t read_size, loff_t *poffset)
1800 unsigned int bytes_read = 0;
1801 unsigned int total_read = 0;
1802 unsigned int current_read_size;
1803 struct cifs_sb_info *cifs_sb;
1804 struct cifsTconInfo *pTcon;
1806 struct cifsFileInfo *open_file;
1807 char *smb_read_data;
1808 char __user *current_offset;
1809 struct smb_com_read_rsp *pSMBr;
1812 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1813 pTcon = cifs_sb->tcon;
1815 if (file->private_data == NULL) {
1819 open_file = (struct cifsFileInfo *)file->private_data;
1821 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1822 cFYI(1, ("attempting read on write only file instance"));
1824 for (total_read = 0, current_offset = read_data;
1825 read_size > total_read;
1826 total_read += bytes_read, current_offset += bytes_read) {
1827 current_read_size = min_t(const int, read_size - total_read,
1830 smb_read_data = NULL;
1831 while (rc == -EAGAIN) {
1832 int buf_type = CIFS_NO_BUFFER;
1833 if ((open_file->invalidHandle) &&
1834 (!open_file->closePend)) {
1835 rc = cifs_reopen_file(file, true);
1839 rc = CIFSSMBRead(xid, pTcon,
1841 current_read_size, *poffset,
1842 &bytes_read, &smb_read_data,
1844 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1845 if (smb_read_data) {
1846 if (copy_to_user(current_offset,
1848 4 /* RFC1001 length field */ +
1849 le16_to_cpu(pSMBr->DataOffset),
1853 if (buf_type == CIFS_SMALL_BUFFER)
1854 cifs_small_buf_release(smb_read_data);
1855 else if (buf_type == CIFS_LARGE_BUFFER)
1856 cifs_buf_release(smb_read_data);
1857 smb_read_data = NULL;
1860 if (rc || (bytes_read == 0)) {
1868 cifs_stats_bytes_read(pTcon, bytes_read);
1869 *poffset += bytes_read;
1877 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1881 unsigned int bytes_read = 0;
1882 unsigned int total_read;
1883 unsigned int current_read_size;
1884 struct cifs_sb_info *cifs_sb;
1885 struct cifsTconInfo *pTcon;
1887 char *current_offset;
1888 struct cifsFileInfo *open_file;
1889 int buf_type = CIFS_NO_BUFFER;
1892 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1893 pTcon = cifs_sb->tcon;
1895 if (file->private_data == NULL) {
1899 open_file = (struct cifsFileInfo *)file->private_data;
1901 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1902 cFYI(1, ("attempting read on write only file instance"));
1904 for (total_read = 0, current_offset = read_data;
1905 read_size > total_read;
1906 total_read += bytes_read, current_offset += bytes_read) {
1907 current_read_size = min_t(const int, read_size - total_read,
1909 /* For windows me and 9x we do not want to request more
1910 than it negotiated since it will refuse the read then */
1912 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1913 current_read_size = min_t(const int, current_read_size,
1914 pTcon->ses->server->maxBuf - 128);
1917 while (rc == -EAGAIN) {
1918 if ((open_file->invalidHandle) &&
1919 (!open_file->closePend)) {
1920 rc = cifs_reopen_file(file, true);
1924 rc = CIFSSMBRead(xid, pTcon,
1926 current_read_size, *poffset,
1927 &bytes_read, ¤t_offset,
1930 if (rc || (bytes_read == 0)) {
1938 cifs_stats_bytes_read(pTcon, total_read);
1939 *poffset += bytes_read;
1946 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1948 struct dentry *dentry = file->f_path.dentry;
1952 rc = cifs_revalidate(dentry);
1954 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1958 rc = generic_file_mmap(file, vma);
1964 static void cifs_copy_cache_pages(struct address_space *mapping,
1965 struct list_head *pages, int bytes_read, char *data,
1966 struct pagevec *plru_pvec)
1971 while (bytes_read > 0) {
1972 if (list_empty(pages))
1975 page = list_entry(pages->prev, struct page, lru);
1976 list_del(&page->lru);
1978 if (add_to_page_cache(page, mapping, page->index,
1980 page_cache_release(page);
1981 cFYI(1, ("Add page cache failed"));
1982 data += PAGE_CACHE_SIZE;
1983 bytes_read -= PAGE_CACHE_SIZE;
1987 target = kmap_atomic(page, KM_USER0);
1989 if (PAGE_CACHE_SIZE > bytes_read) {
1990 memcpy(target, data, bytes_read);
1991 /* zero the tail end of this partial page */
1992 memset(target + bytes_read, 0,
1993 PAGE_CACHE_SIZE - bytes_read);
1996 memcpy(target, data, PAGE_CACHE_SIZE);
1997 bytes_read -= PAGE_CACHE_SIZE;
1999 kunmap_atomic(target, KM_USER0);
2001 flush_dcache_page(page);
2002 SetPageUptodate(page);
2004 if (!pagevec_add(plru_pvec, page))
2005 __pagevec_lru_add_file(plru_pvec);
2006 data += PAGE_CACHE_SIZE;
2011 static int cifs_readpages(struct file *file, struct address_space *mapping,
2012 struct list_head *page_list, unsigned num_pages)
2018 struct cifs_sb_info *cifs_sb;
2019 struct cifsTconInfo *pTcon;
2020 unsigned int bytes_read = 0;
2021 unsigned int read_size, i;
2022 char *smb_read_data = NULL;
2023 struct smb_com_read_rsp *pSMBr;
2024 struct pagevec lru_pvec;
2025 struct cifsFileInfo *open_file;
2026 int buf_type = CIFS_NO_BUFFER;
2029 if (file->private_data == NULL) {
2033 open_file = (struct cifsFileInfo *)file->private_data;
2034 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2035 pTcon = cifs_sb->tcon;
2037 pagevec_init(&lru_pvec, 0);
2038 cFYI(DBG2, ("rpages: num pages %d", num_pages));
2039 for (i = 0; i < num_pages; ) {
2040 unsigned contig_pages;
2041 struct page *tmp_page;
2042 unsigned long expected_index;
2044 if (list_empty(page_list))
2047 page = list_entry(page_list->prev, struct page, lru);
2048 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2050 /* count adjacent pages that we will read into */
2053 list_entry(page_list->prev, struct page, lru)->index;
2054 list_for_each_entry_reverse(tmp_page, page_list, lru) {
2055 if (tmp_page->index == expected_index) {
2061 if (contig_pages + i > num_pages)
2062 contig_pages = num_pages - i;
2064 /* for reads over a certain size could initiate async
2067 read_size = contig_pages * PAGE_CACHE_SIZE;
2068 /* Read size needs to be in multiples of one page */
2069 read_size = min_t(const unsigned int, read_size,
2070 cifs_sb->rsize & PAGE_CACHE_MASK);
2071 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
2072 read_size, contig_pages));
2074 while (rc == -EAGAIN) {
2075 if ((open_file->invalidHandle) &&
2076 (!open_file->closePend)) {
2077 rc = cifs_reopen_file(file, true);
2082 rc = CIFSSMBRead(xid, pTcon,
2085 &bytes_read, &smb_read_data,
2087 /* BB more RC checks ? */
2088 if (rc == -EAGAIN) {
2089 if (smb_read_data) {
2090 if (buf_type == CIFS_SMALL_BUFFER)
2091 cifs_small_buf_release(smb_read_data);
2092 else if (buf_type == CIFS_LARGE_BUFFER)
2093 cifs_buf_release(smb_read_data);
2094 smb_read_data = NULL;
2098 if ((rc < 0) || (smb_read_data == NULL)) {
2099 cFYI(1, ("Read error in readpages: %d", rc));
2101 } else if (bytes_read > 0) {
2102 task_io_account_read(bytes_read);
2103 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2104 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2105 smb_read_data + 4 /* RFC1001 hdr */ +
2106 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
2108 i += bytes_read >> PAGE_CACHE_SHIFT;
2109 cifs_stats_bytes_read(pTcon, bytes_read);
2110 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
2111 i++; /* account for partial page */
2113 /* server copy of file can have smaller size
2115 /* BB do we need to verify this common case ?
2116 this case is ok - if we are at server EOF
2117 we will hit it on next read */
2122 cFYI(1, ("No bytes read (%d) at offset %lld . "
2123 "Cleaning remaining pages from readahead list",
2124 bytes_read, offset));
2125 /* BB turn off caching and do new lookup on
2126 file size at server? */
2129 if (smb_read_data) {
2130 if (buf_type == CIFS_SMALL_BUFFER)
2131 cifs_small_buf_release(smb_read_data);
2132 else if (buf_type == CIFS_LARGE_BUFFER)
2133 cifs_buf_release(smb_read_data);
2134 smb_read_data = NULL;
2139 pagevec_lru_add_file(&lru_pvec);
2141 /* need to free smb_read_data buf before exit */
2142 if (smb_read_data) {
2143 if (buf_type == CIFS_SMALL_BUFFER)
2144 cifs_small_buf_release(smb_read_data);
2145 else if (buf_type == CIFS_LARGE_BUFFER)
2146 cifs_buf_release(smb_read_data);
2147 smb_read_data = NULL;
2154 static int cifs_readpage_worker(struct file *file, struct page *page,
2160 page_cache_get(page);
2161 read_data = kmap(page);
2162 /* for reads over a certain size could initiate async read ahead */
2164 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2169 cFYI(1, ("Bytes read %d", rc));
2171 file->f_path.dentry->d_inode->i_atime =
2172 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2174 if (PAGE_CACHE_SIZE > rc)
2175 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2177 flush_dcache_page(page);
2178 SetPageUptodate(page);
2183 page_cache_release(page);
2187 static int cifs_readpage(struct file *file, struct page *page)
2189 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2195 if (file->private_data == NULL) {
2200 cFYI(1, ("readpage %p at offset %d 0x%x\n",
2201 page, (int)offset, (int)offset));
2203 rc = cifs_readpage_worker(file, page, &offset);
2211 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2213 struct cifsFileInfo *open_file;
2215 read_lock(&GlobalSMBSeslock);
2216 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2217 if (open_file->closePend)
2219 if (open_file->pfile &&
2220 ((open_file->pfile->f_flags & O_RDWR) ||
2221 (open_file->pfile->f_flags & O_WRONLY))) {
2222 read_unlock(&GlobalSMBSeslock);
2226 read_unlock(&GlobalSMBSeslock);
2230 /* We do not want to update the file size from server for inodes
2231 open for write - to avoid races with writepage extending
2232 the file - in the future we could consider allowing
2233 refreshing the inode only on increases in the file size
2234 but this is tricky to do without racing with writebehind
2235 page caching in the current Linux kernel design */
2236 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2241 if (is_inode_writable(cifsInode)) {
2242 /* This inode is open for write at least once */
2243 struct cifs_sb_info *cifs_sb;
2245 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2246 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2247 /* since no page cache to corrupt on directio
2248 we can change size safely */
2252 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2260 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2261 loff_t pos, unsigned len, unsigned flags,
2262 struct page **pagep, void **fsdata)
2264 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2265 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2266 loff_t page_start = pos & PAGE_MASK;
2271 cFYI(1, ("write_begin from %lld len %d", (long long)pos, len));
2273 page = grab_cache_page_write_begin(mapping, index, flags);
2279 if (PageUptodate(page))
2283 * If we write a full page it will be up to date, no need to read from
2284 * the server. If the write is short, we'll end up doing a sync write
2287 if (len == PAGE_CACHE_SIZE)
2291 * optimize away the read when we have an oplock, and we're not
2292 * expecting to use any of the data we'd be reading in. That
2293 * is, when the page lies beyond the EOF, or straddles the EOF
2294 * and the write will cover all of the existing data.
2296 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2297 i_size = i_size_read(mapping->host);
2298 if (page_start >= i_size ||
2299 (offset == 0 && (pos + len) >= i_size)) {
2300 zero_user_segments(page, 0, offset,
2304 * PageChecked means that the parts of the page
2305 * to which we're not writing are considered up
2306 * to date. Once the data is copied to the
2307 * page, it can be set uptodate.
2309 SetPageChecked(page);
2314 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2316 * might as well read a page, it is fast enough. If we get
2317 * an error, we don't need to return it. cifs_write_end will
2318 * do a sync write instead since PG_uptodate isn't set.
2320 cifs_readpage_worker(file, page, &page_start);
2322 /* we could try using another file handle if there is one -
2323 but how would we lock it to prevent close of that handle
2324 racing with this read? In any case
2325 this will be written out by write_end so is fine */
2332 const struct address_space_operations cifs_addr_ops = {
2333 .readpage = cifs_readpage,
2334 .readpages = cifs_readpages,
2335 .writepage = cifs_writepage,
2336 .writepages = cifs_writepages,
2337 .write_begin = cifs_write_begin,
2338 .write_end = cifs_write_end,
2339 .set_page_dirty = __set_page_dirty_nobuffers,
2340 /* .sync_page = cifs_sync_page, */
2345 * cifs_readpages requires the server to support a buffer large enough to
2346 * contain the header plus one complete page of data. Otherwise, we need
2347 * to leave cifs_readpages out of the address space operations.
2349 const struct address_space_operations cifs_addr_ops_smallbuf = {
2350 .readpage = cifs_readpage,
2351 .writepage = cifs_writepage,
2352 .writepages = cifs_writepages,
2353 .write_begin = cifs_write_begin,
2354 .write_end = cifs_write_end,
2355 .set_page_dirty = __set_page_dirty_nobuffers,
2356 /* .sync_page = cifs_sync_page, */