4 * vfs operations that deal with files
6 * Copyright (C) International Business Machines Corp., 2002,2010
7 * Author(s): Steve French (sfrench@us.ibm.com)
8 * Jeremy Allison (jra@samba.org)
10 * This library is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU Lesser General Public License as published
12 * by the Free Software Foundation; either version 2.1 of the License, or
13 * (at your option) any later version.
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
18 * the GNU Lesser General Public License for more details.
20 * You should have received a copy of the GNU Lesser General Public License
21 * along with this library; if not, write to the Free Software
22 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
25 #include <linux/backing-dev.h>
26 #include <linux/stat.h>
27 #include <linux/fcntl.h>
28 #include <linux/pagemap.h>
29 #include <linux/pagevec.h>
30 #include <linux/writeback.h>
31 #include <linux/task_io_accounting_ops.h>
32 #include <linux/delay.h>
33 #include <linux/mount.h>
34 #include <linux/slab.h>
35 #include <linux/swap.h>
36 #include <asm/div64.h>
40 #include "cifsproto.h"
41 #include "cifs_unicode.h"
42 #include "cifs_debug.h"
43 #include "cifs_fs_sb.h"
46 static inline int cifs_convert_flags(unsigned int flags)
48 if ((flags & O_ACCMODE) == O_RDONLY)
50 else if ((flags & O_ACCMODE) == O_WRONLY)
52 else if ((flags & O_ACCMODE) == O_RDWR) {
53 /* GENERIC_ALL is too much permission to request
54 can cause unnecessary access denied on create */
55 /* return GENERIC_ALL; */
56 return (GENERIC_READ | GENERIC_WRITE);
59 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
60 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
64 static u32 cifs_posix_convert_flags(unsigned int flags)
68 if ((flags & O_ACCMODE) == O_RDONLY)
69 posix_flags = SMB_O_RDONLY;
70 else if ((flags & O_ACCMODE) == O_WRONLY)
71 posix_flags = SMB_O_WRONLY;
72 else if ((flags & O_ACCMODE) == O_RDWR)
73 posix_flags = SMB_O_RDWR;
76 posix_flags |= SMB_O_CREAT;
78 posix_flags |= SMB_O_EXCL;
80 posix_flags |= SMB_O_TRUNC;
81 /* be safe and imply O_SYNC for O_DSYNC */
83 posix_flags |= SMB_O_SYNC;
84 if (flags & O_DIRECTORY)
85 posix_flags |= SMB_O_DIRECTORY;
86 if (flags & O_NOFOLLOW)
87 posix_flags |= SMB_O_NOFOLLOW;
89 posix_flags |= SMB_O_DIRECT;
94 static inline int cifs_get_disposition(unsigned int flags)
96 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
98 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
99 return FILE_OVERWRITE_IF;
100 else if ((flags & O_CREAT) == O_CREAT)
102 else if ((flags & O_TRUNC) == O_TRUNC)
103 return FILE_OVERWRITE;
108 int cifs_posix_open(char *full_path, struct inode **pinode,
109 struct super_block *sb, int mode, unsigned int f_flags,
110 __u32 *poplock, __u16 *pnetfid, int xid)
113 FILE_UNIX_BASIC_INFO *presp_data;
114 __u32 posix_flags = 0;
115 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
116 struct cifs_fattr fattr;
117 struct tcon_link *tlink;
118 struct cifs_tcon *tcon;
120 cFYI(1, "posix open %s", full_path);
122 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
123 if (presp_data == NULL)
126 tlink = cifs_sb_tlink(cifs_sb);
132 tcon = tlink_tcon(tlink);
133 mode &= ~current_umask();
135 posix_flags = cifs_posix_convert_flags(f_flags);
136 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
137 poplock, full_path, cifs_sb->local_nls,
138 cifs_sb->mnt_cifs_flags &
139 CIFS_MOUNT_MAP_SPECIAL_CHR);
140 cifs_put_tlink(tlink);
145 if (presp_data->Type == cpu_to_le32(-1))
146 goto posix_open_ret; /* open ok, caller does qpathinfo */
149 goto posix_open_ret; /* caller does not need info */
151 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
153 /* get new inode and set it up */
154 if (*pinode == NULL) {
155 cifs_fill_uniqueid(sb, &fattr);
156 *pinode = cifs_iget(sb, &fattr);
162 cifs_fattr_to_inode(*pinode, &fattr);
171 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
172 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *poplock,
173 __u16 *pnetfid, int xid)
178 int create_options = CREATE_NOT_DIR;
181 desiredAccess = cifs_convert_flags(f_flags);
183 /*********************************************************************
184 * open flag mapping table:
186 * POSIX Flag CIFS Disposition
187 * ---------- ----------------
188 * O_CREAT FILE_OPEN_IF
189 * O_CREAT | O_EXCL FILE_CREATE
190 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
191 * O_TRUNC FILE_OVERWRITE
192 * none of the above FILE_OPEN
194 * Note that there is not a direct match between disposition
195 * FILE_SUPERSEDE (ie create whether or not file exists although
196 * O_CREAT | O_TRUNC is similar but truncates the existing
197 * file rather than creating a new file as FILE_SUPERSEDE does
198 * (which uses the attributes / metadata passed in on open call)
200 *? O_SYNC is a reasonable match to CIFS writethrough flag
201 *? and the read write flags match reasonably. O_LARGEFILE
202 *? is irrelevant because largefile support is always used
203 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
204 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
205 *********************************************************************/
207 disposition = cifs_get_disposition(f_flags);
209 /* BB pass O_SYNC flag through on file attributes .. BB */
211 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
215 if (backup_cred(cifs_sb))
216 create_options |= CREATE_OPEN_BACKUP_INTENT;
218 if (tcon->ses->capabilities & CAP_NT_SMBS)
219 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
220 desiredAccess, create_options, pnetfid, poplock, buf,
221 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
222 & CIFS_MOUNT_MAP_SPECIAL_CHR);
224 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
225 desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
226 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
227 & CIFS_MOUNT_MAP_SPECIAL_CHR);
233 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
236 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
244 struct cifsFileInfo *
245 cifs_new_fileinfo(__u16 fileHandle, struct file *file,
246 struct tcon_link *tlink, __u32 oplock)
248 struct dentry *dentry = file->f_path.dentry;
249 struct inode *inode = dentry->d_inode;
250 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
251 struct cifsFileInfo *pCifsFile;
253 pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
254 if (pCifsFile == NULL)
257 pCifsFile->count = 1;
258 pCifsFile->netfid = fileHandle;
259 pCifsFile->pid = current->tgid;
260 pCifsFile->uid = current_fsuid();
261 pCifsFile->dentry = dget(dentry);
262 pCifsFile->f_flags = file->f_flags;
263 pCifsFile->invalidHandle = false;
264 pCifsFile->tlink = cifs_get_tlink(tlink);
265 mutex_init(&pCifsFile->fh_mutex);
266 INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
268 spin_lock(&cifs_file_list_lock);
269 list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
270 /* if readable file instance put first in list*/
271 if (file->f_mode & FMODE_READ)
272 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
274 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
275 spin_unlock(&cifs_file_list_lock);
277 cifs_set_oplock_level(pCifsInode, oplock);
278 pCifsInode->can_cache_brlcks = pCifsInode->clientCanCacheAll;
280 file->private_data = pCifsFile;
284 static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
287 * Release a reference on the file private data. This may involve closing
288 * the filehandle out on the server. Must be called without holding
289 * cifs_file_list_lock.
291 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
293 struct inode *inode = cifs_file->dentry->d_inode;
294 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
295 struct cifsInodeInfo *cifsi = CIFS_I(inode);
296 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
297 struct cifsLockInfo *li, *tmp;
299 spin_lock(&cifs_file_list_lock);
300 if (--cifs_file->count > 0) {
301 spin_unlock(&cifs_file_list_lock);
305 /* remove it from the lists */
306 list_del(&cifs_file->flist);
307 list_del(&cifs_file->tlist);
309 if (list_empty(&cifsi->openFileList)) {
310 cFYI(1, "closing last open instance for inode %p",
311 cifs_file->dentry->d_inode);
313 /* in strict cache mode we need invalidate mapping on the last
314 close because it may cause a error when we open this file
315 again and get at least level II oplock */
316 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
317 CIFS_I(inode)->invalid_mapping = true;
319 cifs_set_oplock_level(cifsi, 0);
321 spin_unlock(&cifs_file_list_lock);
323 cancel_work_sync(&cifs_file->oplock_break);
325 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
329 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
333 /* Delete any outstanding lock records. We'll lose them when the file
336 mutex_lock(&cifsi->lock_mutex);
337 list_for_each_entry_safe(li, tmp, &cifsi->llist, llist) {
338 if (li->netfid != cifs_file->netfid)
340 list_del(&li->llist);
341 cifs_del_lock_waiters(li);
344 mutex_unlock(&cifsi->lock_mutex);
346 cifs_put_tlink(cifs_file->tlink);
347 dput(cifs_file->dentry);
351 int cifs_open(struct inode *inode, struct file *file)
356 struct cifs_sb_info *cifs_sb;
357 struct cifs_tcon *tcon;
358 struct tcon_link *tlink;
359 struct cifsFileInfo *pCifsFile = NULL;
360 char *full_path = NULL;
361 bool posix_open_ok = false;
366 cifs_sb = CIFS_SB(inode->i_sb);
367 tlink = cifs_sb_tlink(cifs_sb);
370 return PTR_ERR(tlink);
372 tcon = tlink_tcon(tlink);
374 full_path = build_path_from_dentry(file->f_path.dentry);
375 if (full_path == NULL) {
380 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
381 inode, file->f_flags, full_path);
388 if (!tcon->broken_posix_open && tcon->unix_ext &&
389 (tcon->ses->capabilities & CAP_UNIX) &&
390 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
391 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
392 /* can not refresh inode info since size could be stale */
393 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
394 cifs_sb->mnt_file_mode /* ignored */,
395 file->f_flags, &oplock, &netfid, xid);
397 cFYI(1, "posix open succeeded");
398 posix_open_ok = true;
399 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
400 if (tcon->ses->serverNOS)
401 cERROR(1, "server %s of type %s returned"
402 " unexpected error on SMB posix open"
403 ", disabling posix open support."
404 " Check if server update available.",
405 tcon->ses->serverName,
406 tcon->ses->serverNOS);
407 tcon->broken_posix_open = true;
408 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
409 (rc != -EOPNOTSUPP)) /* path not found or net err */
411 /* else fallthrough to retry open the old way on network i/o
415 if (!posix_open_ok) {
416 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
417 file->f_flags, &oplock, &netfid, xid);
422 pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
423 if (pCifsFile == NULL) {
424 CIFSSMBClose(xid, tcon, netfid);
429 cifs_fscache_set_inode_cookie(inode, file);
431 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
432 /* time to set mode which we can not set earlier due to
433 problems creating new read-only files */
434 struct cifs_unix_set_info_args args = {
435 .mode = inode->i_mode,
438 .ctime = NO_CHANGE_64,
439 .atime = NO_CHANGE_64,
440 .mtime = NO_CHANGE_64,
443 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
450 cifs_put_tlink(tlink);
454 /* Try to reacquire byte range locks that were released when session */
455 /* to server was lost */
456 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
460 /* BB list all locks open on this file and relock */
465 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
470 struct cifs_sb_info *cifs_sb;
471 struct cifs_tcon *tcon;
472 struct cifsInodeInfo *pCifsInode;
474 char *full_path = NULL;
476 int disposition = FILE_OPEN;
477 int create_options = CREATE_NOT_DIR;
481 mutex_lock(&pCifsFile->fh_mutex);
482 if (!pCifsFile->invalidHandle) {
483 mutex_unlock(&pCifsFile->fh_mutex);
489 inode = pCifsFile->dentry->d_inode;
490 cifs_sb = CIFS_SB(inode->i_sb);
491 tcon = tlink_tcon(pCifsFile->tlink);
493 /* can not grab rename sem here because various ops, including
494 those that already have the rename sem can end up causing writepage
495 to get called and if the server was down that means we end up here,
496 and we can never tell if the caller already has the rename_sem */
497 full_path = build_path_from_dentry(pCifsFile->dentry);
498 if (full_path == NULL) {
500 mutex_unlock(&pCifsFile->fh_mutex);
505 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
506 inode, pCifsFile->f_flags, full_path);
513 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
514 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
515 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
518 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
519 * original open. Must mask them off for a reopen.
521 unsigned int oflags = pCifsFile->f_flags &
522 ~(O_CREAT | O_EXCL | O_TRUNC);
524 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
525 cifs_sb->mnt_file_mode /* ignored */,
526 oflags, &oplock, &netfid, xid);
528 cFYI(1, "posix reopen succeeded");
531 /* fallthrough to retry open the old way on errors, especially
532 in the reconnect path it is important to retry hard */
535 desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
537 if (backup_cred(cifs_sb))
538 create_options |= CREATE_OPEN_BACKUP_INTENT;
540 /* Can not refresh inode by passing in file_info buf to be returned
541 by SMBOpen and then calling get_inode_info with returned buf
542 since file might have write behind data that needs to be flushed
543 and server version of file size can be stale. If we knew for sure
544 that inode was not dirty locally we could do this */
546 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
547 create_options, &netfid, &oplock, NULL,
548 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
549 CIFS_MOUNT_MAP_SPECIAL_CHR);
551 mutex_unlock(&pCifsFile->fh_mutex);
552 cFYI(1, "cifs_open returned 0x%x", rc);
553 cFYI(1, "oplock: %d", oplock);
554 goto reopen_error_exit;
558 pCifsFile->netfid = netfid;
559 pCifsFile->invalidHandle = false;
560 mutex_unlock(&pCifsFile->fh_mutex);
561 pCifsInode = CIFS_I(inode);
564 rc = filemap_write_and_wait(inode->i_mapping);
565 mapping_set_error(inode->i_mapping, rc);
568 rc = cifs_get_inode_info_unix(&inode,
569 full_path, inode->i_sb, xid);
571 rc = cifs_get_inode_info(&inode,
572 full_path, NULL, inode->i_sb,
574 } /* else we are writing out data to server already
575 and could deadlock if we tried to flush data, and
576 since we do not know if we have data that would
577 invalidate the current end of file on the server
578 we can not go to the server to get the new inod
581 cifs_set_oplock_level(pCifsInode, oplock);
583 cifs_relock_file(pCifsFile);
591 int cifs_close(struct inode *inode, struct file *file)
593 if (file->private_data != NULL) {
594 cifsFileInfo_put(file->private_data);
595 file->private_data = NULL;
598 /* return code from the ->release op is always ignored */
602 int cifs_closedir(struct inode *inode, struct file *file)
606 struct cifsFileInfo *pCFileStruct = file->private_data;
609 cFYI(1, "Closedir inode = 0x%p", inode);
614 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
616 cFYI(1, "Freeing private data in close dir");
617 spin_lock(&cifs_file_list_lock);
618 if (!pCFileStruct->srch_inf.endOfSearch &&
619 !pCFileStruct->invalidHandle) {
620 pCFileStruct->invalidHandle = true;
621 spin_unlock(&cifs_file_list_lock);
622 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
623 cFYI(1, "Closing uncompleted readdir with rc %d",
625 /* not much we can do if it fails anyway, ignore rc */
628 spin_unlock(&cifs_file_list_lock);
629 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
631 cFYI(1, "closedir free smb buf in srch struct");
632 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
633 if (pCFileStruct->srch_inf.smallBuf)
634 cifs_small_buf_release(ptmp);
636 cifs_buf_release(ptmp);
638 cifs_put_tlink(pCFileStruct->tlink);
639 kfree(file->private_data);
640 file->private_data = NULL;
642 /* BB can we lock the filestruct while this is going on? */
647 static struct cifsLockInfo *
648 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 netfid)
650 struct cifsLockInfo *lock =
651 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
654 lock->offset = offset;
655 lock->length = length;
657 lock->netfid = netfid;
658 lock->pid = current->tgid;
659 INIT_LIST_HEAD(&lock->blist);
660 init_waitqueue_head(&lock->block_q);
665 cifs_del_lock_waiters(struct cifsLockInfo *lock)
667 struct cifsLockInfo *li, *tmp;
668 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
669 list_del_init(&li->blist);
670 wake_up(&li->block_q);
675 __cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
676 __u64 length, __u8 type, __u16 netfid,
677 struct cifsLockInfo **conf_lock)
679 struct cifsLockInfo *li, *tmp;
681 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
682 if (offset + length <= li->offset ||
683 offset >= li->offset + li->length)
685 else if ((type & LOCKING_ANDX_SHARED_LOCK) &&
686 ((netfid == li->netfid && current->tgid == li->pid) ||
698 cifs_find_lock_conflict(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
699 struct cifsLockInfo **conf_lock)
701 return __cifs_find_lock_conflict(cinode, lock->offset, lock->length,
702 lock->type, lock->netfid, conf_lock);
706 * Check if there is another lock that prevents us to set the lock (mandatory
707 * style). If such a lock exists, update the flock structure with its
708 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
709 * or leave it the same if we can't. Returns 0 if we don't need to request to
710 * the server or 1 otherwise.
713 cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
714 __u8 type, __u16 netfid, struct file_lock *flock)
717 struct cifsLockInfo *conf_lock;
720 mutex_lock(&cinode->lock_mutex);
722 exist = __cifs_find_lock_conflict(cinode, offset, length, type, netfid,
725 flock->fl_start = conf_lock->offset;
726 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
727 flock->fl_pid = conf_lock->pid;
728 if (conf_lock->type & LOCKING_ANDX_SHARED_LOCK)
729 flock->fl_type = F_RDLCK;
731 flock->fl_type = F_WRLCK;
732 } else if (!cinode->can_cache_brlcks)
735 flock->fl_type = F_UNLCK;
737 mutex_unlock(&cinode->lock_mutex);
742 cifs_lock_add(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock)
744 mutex_lock(&cinode->lock_mutex);
745 list_add_tail(&lock->llist, &cinode->llist);
746 mutex_unlock(&cinode->lock_mutex);
750 * Set the byte-range lock (mandatory style). Returns:
751 * 1) 0, if we set the lock and don't need to request to the server;
752 * 2) 1, if no locks prevent us but we need to request to the server;
753 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
756 cifs_lock_add_if(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
759 struct cifsLockInfo *conf_lock;
765 mutex_lock(&cinode->lock_mutex);
767 exist = cifs_find_lock_conflict(cinode, lock, &conf_lock);
768 if (!exist && cinode->can_cache_brlcks) {
769 list_add_tail(&lock->llist, &cinode->llist);
770 mutex_unlock(&cinode->lock_mutex);
779 list_add_tail(&lock->blist, &conf_lock->blist);
780 mutex_unlock(&cinode->lock_mutex);
781 rc = wait_event_interruptible(lock->block_q,
782 (lock->blist.prev == &lock->blist) &&
783 (lock->blist.next == &lock->blist));
786 mutex_lock(&cinode->lock_mutex);
787 list_del_init(&lock->blist);
790 mutex_unlock(&cinode->lock_mutex);
795 * Check if there is another lock that prevents us to set the lock (posix
796 * style). If such a lock exists, update the flock structure with its
797 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
798 * or leave it the same if we can't. Returns 0 if we don't need to request to
799 * the server or 1 otherwise.
802 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
805 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
806 unsigned char saved_type = flock->fl_type;
808 if ((flock->fl_flags & FL_POSIX) == 0)
811 mutex_lock(&cinode->lock_mutex);
812 posix_test_lock(file, flock);
814 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
815 flock->fl_type = saved_type;
819 mutex_unlock(&cinode->lock_mutex);
824 * Set the byte-range lock (posix style). Returns:
825 * 1) 0, if we set the lock and don't need to request to the server;
826 * 2) 1, if we need to request to the server;
827 * 3) <0, if the error occurs while setting the lock.
830 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
832 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
835 if ((flock->fl_flags & FL_POSIX) == 0)
838 mutex_lock(&cinode->lock_mutex);
839 if (!cinode->can_cache_brlcks) {
840 mutex_unlock(&cinode->lock_mutex);
843 rc = posix_lock_file_wait(file, flock);
844 mutex_unlock(&cinode->lock_mutex);
849 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
851 int xid, rc = 0, stored_rc;
852 struct cifsLockInfo *li, *tmp;
853 struct cifs_tcon *tcon;
854 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
855 unsigned int num, max_num;
856 LOCKING_ANDX_RANGE *buf, *cur;
857 int types[] = {LOCKING_ANDX_LARGE_FILES,
858 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
862 tcon = tlink_tcon(cfile->tlink);
864 mutex_lock(&cinode->lock_mutex);
865 if (!cinode->can_cache_brlcks) {
866 mutex_unlock(&cinode->lock_mutex);
871 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
872 sizeof(LOCKING_ANDX_RANGE);
873 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
875 mutex_unlock(&cinode->lock_mutex);
880 for (i = 0; i < 2; i++) {
883 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
884 if (li->type != types[i])
886 cur->Pid = cpu_to_le16(li->pid);
887 cur->LengthLow = cpu_to_le32((u32)li->length);
888 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
889 cur->OffsetLow = cpu_to_le32((u32)li->offset);
890 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
891 if (++num == max_num) {
892 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
893 li->type, 0, num, buf);
903 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
904 types[i], 0, num, buf);
910 cinode->can_cache_brlcks = false;
911 mutex_unlock(&cinode->lock_mutex);
918 /* copied from fs/locks.c with a name change */
919 #define cifs_for_each_lock(inode, lockp) \
920 for (lockp = &inode->i_flock; *lockp != NULL; \
921 lockp = &(*lockp)->fl_next)
923 struct lock_to_push {
924 struct list_head llist;
933 cifs_push_posix_locks(struct cifsFileInfo *cfile)
935 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
936 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
937 struct file_lock *flock, **before;
938 unsigned int count = 0, i = 0;
939 int rc = 0, xid, type;
940 struct list_head locks_to_send, *el;
941 struct lock_to_push *lck, *tmp;
946 mutex_lock(&cinode->lock_mutex);
947 if (!cinode->can_cache_brlcks) {
948 mutex_unlock(&cinode->lock_mutex);
954 cifs_for_each_lock(cfile->dentry->d_inode, before) {
955 if ((*before)->fl_flags & FL_POSIX)
960 INIT_LIST_HEAD(&locks_to_send);
963 * Allocating count locks is enough because no FL_POSIX locks can be
964 * added to the list while we are holding cinode->lock_mutex that
965 * protects locking operations of this inode.
967 for (; i < count; i++) {
968 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
973 list_add_tail(&lck->llist, &locks_to_send);
976 el = locks_to_send.next;
978 cifs_for_each_lock(cfile->dentry->d_inode, before) {
980 if ((flock->fl_flags & FL_POSIX) == 0)
982 if (el == &locks_to_send) {
984 * The list ended. We don't have enough allocated
985 * structures - something is really wrong.
987 cERROR(1, "Can't push all brlocks!");
990 length = 1 + flock->fl_end - flock->fl_start;
991 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
995 lck = list_entry(el, struct lock_to_push, llist);
996 lck->pid = flock->fl_pid;
997 lck->netfid = cfile->netfid;
998 lck->length = length;
1000 lck->offset = flock->fl_start;
1005 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1006 struct file_lock tmp_lock;
1009 tmp_lock.fl_start = lck->offset;
1010 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1011 0, lck->length, &tmp_lock,
1015 list_del(&lck->llist);
1020 cinode->can_cache_brlcks = false;
1021 mutex_unlock(&cinode->lock_mutex);
1026 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1027 list_del(&lck->llist);
1034 cifs_push_locks(struct cifsFileInfo *cfile)
1036 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1037 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1039 if ((tcon->ses->capabilities & CAP_UNIX) &&
1040 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1041 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1042 return cifs_push_posix_locks(cfile);
1044 return cifs_push_mandatory_locks(cfile);
1048 cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
1051 if (flock->fl_flags & FL_POSIX)
1053 if (flock->fl_flags & FL_FLOCK)
1055 if (flock->fl_flags & FL_SLEEP) {
1056 cFYI(1, "Blocking lock");
1059 if (flock->fl_flags & FL_ACCESS)
1060 cFYI(1, "Process suspended by mandatory locking - "
1061 "not implemented yet");
1062 if (flock->fl_flags & FL_LEASE)
1063 cFYI(1, "Lease on file - not implemented yet");
1064 if (flock->fl_flags &
1065 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
1066 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1068 *type = LOCKING_ANDX_LARGE_FILES;
1069 if (flock->fl_type == F_WRLCK) {
1070 cFYI(1, "F_WRLCK ");
1072 } else if (flock->fl_type == F_UNLCK) {
1075 /* Check if unlock includes more than one lock range */
1076 } else if (flock->fl_type == F_RDLCK) {
1078 *type |= LOCKING_ANDX_SHARED_LOCK;
1080 } else if (flock->fl_type == F_EXLCK) {
1083 } else if (flock->fl_type == F_SHLCK) {
1085 *type |= LOCKING_ANDX_SHARED_LOCK;
1088 cFYI(1, "Unknown type of lock");
1092 cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
1093 bool wait_flag, bool posix_lck, int xid)
1096 __u64 length = 1 + flock->fl_end - flock->fl_start;
1097 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1098 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1099 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1100 __u16 netfid = cfile->netfid;
1103 int posix_lock_type;
1105 rc = cifs_posix_lock_test(file, flock);
1109 if (type & LOCKING_ANDX_SHARED_LOCK)
1110 posix_lock_type = CIFS_RDLCK;
1112 posix_lock_type = CIFS_WRLCK;
1113 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1114 1 /* get */, length, flock,
1115 posix_lock_type, wait_flag);
1119 rc = cifs_lock_test(cinode, flock->fl_start, length, type, netfid,
1124 /* BB we could chain these into one lock request BB */
1125 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1126 flock->fl_start, 0, 1, type, 0, 0);
1128 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1129 length, flock->fl_start, 1, 0,
1131 flock->fl_type = F_UNLCK;
1133 cERROR(1, "Error unlocking previously locked "
1134 "range %d during test of lock", rc);
1138 if (type & LOCKING_ANDX_SHARED_LOCK) {
1139 flock->fl_type = F_WRLCK;
1143 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1144 flock->fl_start, 0, 1,
1145 type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1147 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1148 length, flock->fl_start, 1, 0,
1149 type | LOCKING_ANDX_SHARED_LOCK,
1151 flock->fl_type = F_RDLCK;
1153 cERROR(1, "Error unlocking previously locked "
1154 "range %d during test of lock", rc);
1156 flock->fl_type = F_WRLCK;
1162 cifs_move_llist(struct list_head *source, struct list_head *dest)
1164 struct list_head *li, *tmp;
1165 list_for_each_safe(li, tmp, source)
1166 list_move(li, dest);
1170 cifs_free_llist(struct list_head *llist)
1172 struct cifsLockInfo *li, *tmp;
1173 list_for_each_entry_safe(li, tmp, llist, llist) {
1174 cifs_del_lock_waiters(li);
1175 list_del(&li->llist);
1181 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1183 int rc = 0, stored_rc;
1184 int types[] = {LOCKING_ANDX_LARGE_FILES,
1185 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1187 unsigned int max_num, num;
1188 LOCKING_ANDX_RANGE *buf, *cur;
1189 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1190 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1191 struct cifsLockInfo *li, *tmp;
1192 __u64 length = 1 + flock->fl_end - flock->fl_start;
1193 struct list_head tmp_llist;
1195 INIT_LIST_HEAD(&tmp_llist);
1197 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1198 sizeof(LOCKING_ANDX_RANGE);
1199 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1203 mutex_lock(&cinode->lock_mutex);
1204 for (i = 0; i < 2; i++) {
1207 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
1208 if (flock->fl_start > li->offset ||
1209 (flock->fl_start + length) <
1210 (li->offset + li->length))
1212 if (current->tgid != li->pid)
1214 if (cfile->netfid != li->netfid)
1216 if (types[i] != li->type)
1218 if (!cinode->can_cache_brlcks) {
1219 cur->Pid = cpu_to_le16(li->pid);
1220 cur->LengthLow = cpu_to_le32((u32)li->length);
1222 cpu_to_le32((u32)(li->length>>32));
1223 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1225 cpu_to_le32((u32)(li->offset>>32));
1227 * We need to save a lock here to let us add
1228 * it again to the inode list if the unlock
1229 * range request fails on the server.
1231 list_move(&li->llist, &tmp_llist);
1232 if (++num == max_num) {
1233 stored_rc = cifs_lockv(xid, tcon,
1239 * We failed on the unlock range
1240 * request - add all locks from
1241 * the tmp list to the head of
1244 cifs_move_llist(&tmp_llist,
1249 * The unlock range request
1250 * succeed - free the tmp list.
1252 cifs_free_llist(&tmp_llist);
1259 * We can cache brlock requests - simply remove
1260 * a lock from the inode list.
1262 list_del(&li->llist);
1263 cifs_del_lock_waiters(li);
1268 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1269 types[i], num, 0, buf);
1271 cifs_move_llist(&tmp_llist, &cinode->llist);
1274 cifs_free_llist(&tmp_llist);
1278 mutex_unlock(&cinode->lock_mutex);
1284 cifs_setlk(struct file *file, struct file_lock *flock, __u8 type,
1285 bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1288 __u64 length = 1 + flock->fl_end - flock->fl_start;
1289 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1290 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1291 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
1292 __u16 netfid = cfile->netfid;
1295 int posix_lock_type;
1297 rc = cifs_posix_lock_set(file, flock);
1301 if (type & LOCKING_ANDX_SHARED_LOCK)
1302 posix_lock_type = CIFS_RDLCK;
1304 posix_lock_type = CIFS_WRLCK;
1307 posix_lock_type = CIFS_UNLCK;
1309 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1310 0 /* set */, length, flock,
1311 posix_lock_type, wait_flag);
1316 struct cifsLockInfo *lock;
1318 lock = cifs_lock_init(flock->fl_start, length, type, netfid);
1322 rc = cifs_lock_add_if(cinode, lock, wait_flag);
1328 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1329 flock->fl_start, 0, 1, type, wait_flag, 0);
1335 cifs_lock_add(cinode, lock);
1337 rc = cifs_unlock_range(cfile, flock, xid);
1340 if (flock->fl_flags & FL_POSIX)
1341 posix_lock_file_wait(file, flock);
1345 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1348 int lock = 0, unlock = 0;
1349 bool wait_flag = false;
1350 bool posix_lck = false;
1351 struct cifs_sb_info *cifs_sb;
1352 struct cifs_tcon *tcon;
1353 struct cifsInodeInfo *cinode;
1354 struct cifsFileInfo *cfile;
1361 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1362 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1363 flock->fl_start, flock->fl_end);
1365 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1367 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1368 cfile = (struct cifsFileInfo *)file->private_data;
1369 tcon = tlink_tcon(cfile->tlink);
1370 netfid = cfile->netfid;
1371 cinode = CIFS_I(file->f_path.dentry->d_inode);
1373 if ((tcon->ses->capabilities & CAP_UNIX) &&
1374 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1375 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1378 * BB add code here to normalize offset and length to account for
1379 * negative length which we can not accept over the wire.
1381 if (IS_GETLK(cmd)) {
1382 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1387 if (!lock && !unlock) {
1389 * if no lock or unlock then nothing to do since we do not
1396 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1402 /* update the file size (if needed) after a write */
1404 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1405 unsigned int bytes_written)
1407 loff_t end_of_write = offset + bytes_written;
1409 if (end_of_write > cifsi->server_eof)
1410 cifsi->server_eof = end_of_write;
1413 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1414 const char *write_data, size_t write_size,
1418 unsigned int bytes_written = 0;
1419 unsigned int total_written;
1420 struct cifs_sb_info *cifs_sb;
1421 struct cifs_tcon *pTcon;
1423 struct dentry *dentry = open_file->dentry;
1424 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1425 struct cifs_io_parms io_parms;
1427 cifs_sb = CIFS_SB(dentry->d_sb);
1429 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1430 *poffset, dentry->d_name.name);
1432 pTcon = tlink_tcon(open_file->tlink);
1436 for (total_written = 0; write_size > total_written;
1437 total_written += bytes_written) {
1439 while (rc == -EAGAIN) {
1443 if (open_file->invalidHandle) {
1444 /* we could deadlock if we called
1445 filemap_fdatawait from here so tell
1446 reopen_file not to flush data to
1448 rc = cifs_reopen_file(open_file, false);
1453 len = min((size_t)cifs_sb->wsize,
1454 write_size - total_written);
1455 /* iov[0] is reserved for smb header */
1456 iov[1].iov_base = (char *)write_data + total_written;
1457 iov[1].iov_len = len;
1458 io_parms.netfid = open_file->netfid;
1460 io_parms.tcon = pTcon;
1461 io_parms.offset = *poffset;
1462 io_parms.length = len;
1463 rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1466 if (rc || (bytes_written == 0)) {
1474 cifs_update_eof(cifsi, *poffset, bytes_written);
1475 *poffset += bytes_written;
1479 cifs_stats_bytes_written(pTcon, total_written);
1481 if (total_written > 0) {
1482 spin_lock(&dentry->d_inode->i_lock);
1483 if (*poffset > dentry->d_inode->i_size)
1484 i_size_write(dentry->d_inode, *poffset);
1485 spin_unlock(&dentry->d_inode->i_lock);
1487 mark_inode_dirty_sync(dentry->d_inode);
1489 return total_written;
1492 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1495 struct cifsFileInfo *open_file = NULL;
1496 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1498 /* only filter by fsuid on multiuser mounts */
1499 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1502 spin_lock(&cifs_file_list_lock);
1503 /* we could simply get the first_list_entry since write-only entries
1504 are always at the end of the list but since the first entry might
1505 have a close pending, we go through the whole list */
1506 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1507 if (fsuid_only && open_file->uid != current_fsuid())
1509 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1510 if (!open_file->invalidHandle) {
1511 /* found a good file */
1512 /* lock it so it will not be closed on us */
1513 cifsFileInfo_get(open_file);
1514 spin_unlock(&cifs_file_list_lock);
1516 } /* else might as well continue, and look for
1517 another, or simply have the caller reopen it
1518 again rather than trying to fix this handle */
1519 } else /* write only file */
1520 break; /* write only files are last so must be done */
1522 spin_unlock(&cifs_file_list_lock);
1526 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1529 struct cifsFileInfo *open_file;
1530 struct cifs_sb_info *cifs_sb;
1531 bool any_available = false;
1534 /* Having a null inode here (because mapping->host was set to zero by
1535 the VFS or MM) should not happen but we had reports of on oops (due to
1536 it being zero) during stress testcases so we need to check for it */
1538 if (cifs_inode == NULL) {
1539 cERROR(1, "Null inode passed to cifs_writeable_file");
1544 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1546 /* only filter by fsuid on multiuser mounts */
1547 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1550 spin_lock(&cifs_file_list_lock);
1552 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1553 if (!any_available && open_file->pid != current->tgid)
1555 if (fsuid_only && open_file->uid != current_fsuid())
1557 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1558 cifsFileInfo_get(open_file);
1560 if (!open_file->invalidHandle) {
1561 /* found a good writable file */
1562 spin_unlock(&cifs_file_list_lock);
1566 spin_unlock(&cifs_file_list_lock);
1568 /* Had to unlock since following call can block */
1569 rc = cifs_reopen_file(open_file, false);
1573 /* if it fails, try another handle if possible */
1574 cFYI(1, "wp failed on reopen file");
1575 cifsFileInfo_put(open_file);
1577 spin_lock(&cifs_file_list_lock);
1579 /* else we simply continue to the next entry. Thus
1580 we do not loop on reopen errors. If we
1581 can not reopen the file, for example if we
1582 reconnected to a server with another client
1583 racing to delete or lock the file we would not
1584 make progress if we restarted before the beginning
1585 of the loop here. */
1588 /* couldn't find useable FH with same pid, try any available */
1589 if (!any_available) {
1590 any_available = true;
1591 goto refind_writable;
1593 spin_unlock(&cifs_file_list_lock);
1597 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1599 struct address_space *mapping = page->mapping;
1600 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1603 int bytes_written = 0;
1604 struct inode *inode;
1605 struct cifsFileInfo *open_file;
1607 if (!mapping || !mapping->host)
1610 inode = page->mapping->host;
1612 offset += (loff_t)from;
1613 write_data = kmap(page);
1616 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1621 /* racing with truncate? */
1622 if (offset > mapping->host->i_size) {
1624 return 0; /* don't care */
1627 /* check to make sure that we are not extending the file */
1628 if (mapping->host->i_size - offset < (loff_t)to)
1629 to = (unsigned)(mapping->host->i_size - offset);
1631 open_file = find_writable_file(CIFS_I(mapping->host), false);
1633 bytes_written = cifs_write(open_file, open_file->pid,
1634 write_data, to - from, &offset);
1635 cifsFileInfo_put(open_file);
1636 /* Does mm or vfs already set times? */
1637 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1638 if ((bytes_written > 0) && (offset))
1640 else if (bytes_written < 0)
1643 cFYI(1, "No writeable filehandles for inode");
1651 static int cifs_writepages(struct address_space *mapping,
1652 struct writeback_control *wbc)
1654 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1655 bool done = false, scanned = false, range_whole = false;
1657 struct cifs_writedata *wdata;
1662 * If wsize is smaller than the page cache size, default to writing
1663 * one page at a time via cifs_writepage
1665 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1666 return generic_writepages(mapping, wbc);
1668 if (wbc->range_cyclic) {
1669 index = mapping->writeback_index; /* Start from prev offset */
1672 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1673 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1674 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1679 while (!done && index <= end) {
1680 unsigned int i, nr_pages, found_pages;
1681 pgoff_t next = 0, tofind;
1682 struct page **pages;
1684 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1687 wdata = cifs_writedata_alloc((unsigned int)tofind);
1694 * find_get_pages_tag seems to return a max of 256 on each
1695 * iteration, so we must call it several times in order to
1696 * fill the array or the wsize is effectively limited to
1697 * 256 * PAGE_CACHE_SIZE.
1700 pages = wdata->pages;
1702 nr_pages = find_get_pages_tag(mapping, &index,
1703 PAGECACHE_TAG_DIRTY,
1705 found_pages += nr_pages;
1708 } while (nr_pages && tofind && index <= end);
1710 if (found_pages == 0) {
1711 kref_put(&wdata->refcount, cifs_writedata_release);
1716 for (i = 0; i < found_pages; i++) {
1717 page = wdata->pages[i];
1719 * At this point we hold neither mapping->tree_lock nor
1720 * lock on the page itself: the page may be truncated or
1721 * invalidated (changing page->mapping to NULL), or even
1722 * swizzled back from swapper_space to tmpfs file
1728 else if (!trylock_page(page))
1731 if (unlikely(page->mapping != mapping)) {
1736 if (!wbc->range_cyclic && page->index > end) {
1742 if (next && (page->index != next)) {
1743 /* Not next consecutive page */
1748 if (wbc->sync_mode != WB_SYNC_NONE)
1749 wait_on_page_writeback(page);
1751 if (PageWriteback(page) ||
1752 !clear_page_dirty_for_io(page)) {
1758 * This actually clears the dirty bit in the radix tree.
1759 * See cifs_writepage() for more commentary.
1761 set_page_writeback(page);
1763 if (page_offset(page) >= mapping->host->i_size) {
1766 end_page_writeback(page);
1770 wdata->pages[i] = page;
1771 next = page->index + 1;
1775 /* reset index to refind any pages skipped */
1777 index = wdata->pages[0]->index + 1;
1779 /* put any pages we aren't going to use */
1780 for (i = nr_pages; i < found_pages; i++) {
1781 page_cache_release(wdata->pages[i]);
1782 wdata->pages[i] = NULL;
1785 /* nothing to write? */
1786 if (nr_pages == 0) {
1787 kref_put(&wdata->refcount, cifs_writedata_release);
1791 wdata->sync_mode = wbc->sync_mode;
1792 wdata->nr_pages = nr_pages;
1793 wdata->offset = page_offset(wdata->pages[0]);
1796 if (wdata->cfile != NULL)
1797 cifsFileInfo_put(wdata->cfile);
1798 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1800 if (!wdata->cfile) {
1801 cERROR(1, "No writable handles for inode");
1805 rc = cifs_async_writev(wdata);
1806 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1808 for (i = 0; i < nr_pages; ++i)
1809 unlock_page(wdata->pages[i]);
1811 /* send failure -- clean up the mess */
1813 for (i = 0; i < nr_pages; ++i) {
1815 redirty_page_for_writepage(wbc,
1818 SetPageError(wdata->pages[i]);
1819 end_page_writeback(wdata->pages[i]);
1820 page_cache_release(wdata->pages[i]);
1823 mapping_set_error(mapping, rc);
1825 kref_put(&wdata->refcount, cifs_writedata_release);
1827 wbc->nr_to_write -= nr_pages;
1828 if (wbc->nr_to_write <= 0)
1834 if (!scanned && !done) {
1836 * We hit the last page and there is more work to be done: wrap
1837 * back to the start of the file
1844 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1845 mapping->writeback_index = index;
1851 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1857 /* BB add check for wbc flags */
1858 page_cache_get(page);
1859 if (!PageUptodate(page))
1860 cFYI(1, "ppw - page not up to date");
1863 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1865 * A writepage() implementation always needs to do either this,
1866 * or re-dirty the page with "redirty_page_for_writepage()" in
1867 * the case of a failure.
1869 * Just unlocking the page will cause the radix tree tag-bits
1870 * to fail to update with the state of the page correctly.
1872 set_page_writeback(page);
1874 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1875 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1877 else if (rc == -EAGAIN)
1878 redirty_page_for_writepage(wbc, page);
1882 SetPageUptodate(page);
1883 end_page_writeback(page);
1884 page_cache_release(page);
1889 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1891 int rc = cifs_writepage_locked(page, wbc);
1896 static int cifs_write_end(struct file *file, struct address_space *mapping,
1897 loff_t pos, unsigned len, unsigned copied,
1898 struct page *page, void *fsdata)
1901 struct inode *inode = mapping->host;
1902 struct cifsFileInfo *cfile = file->private_data;
1903 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1906 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1909 pid = current->tgid;
1911 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1914 if (PageChecked(page)) {
1916 SetPageUptodate(page);
1917 ClearPageChecked(page);
1918 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1919 SetPageUptodate(page);
1921 if (!PageUptodate(page)) {
1923 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1927 /* this is probably better than directly calling
1928 partialpage_write since in this function the file handle is
1929 known which we might as well leverage */
1930 /* BB check if anything else missing out of ppw
1931 such as updating last write time */
1932 page_data = kmap(page);
1933 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1934 /* if (rc < 0) should we set writebehind rc? */
1941 set_page_dirty(page);
1945 spin_lock(&inode->i_lock);
1946 if (pos > inode->i_size)
1947 i_size_write(inode, pos);
1948 spin_unlock(&inode->i_lock);
1952 page_cache_release(page);
1957 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1962 struct cifs_tcon *tcon;
1963 struct cifsFileInfo *smbfile = file->private_data;
1964 struct inode *inode = file->f_path.dentry->d_inode;
1965 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1967 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1970 mutex_lock(&inode->i_mutex);
1974 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1975 file->f_path.dentry->d_name.name, datasync);
1977 if (!CIFS_I(inode)->clientCanCacheRead) {
1978 rc = cifs_invalidate_mapping(inode);
1980 cFYI(1, "rc: %d during invalidate phase", rc);
1981 rc = 0; /* don't care about it in fsync */
1985 tcon = tlink_tcon(smbfile->tlink);
1986 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1987 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1990 mutex_unlock(&inode->i_mutex);
1994 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
1998 struct cifs_tcon *tcon;
1999 struct cifsFileInfo *smbfile = file->private_data;
2000 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2001 struct inode *inode = file->f_mapping->host;
2003 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2006 mutex_lock(&inode->i_mutex);
2010 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2011 file->f_path.dentry->d_name.name, datasync);
2013 tcon = tlink_tcon(smbfile->tlink);
2014 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2015 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2018 mutex_unlock(&inode->i_mutex);
2023 * As file closes, flush all cached write data for this inode checking
2024 * for write behind errors.
2026 int cifs_flush(struct file *file, fl_owner_t id)
2028 struct inode *inode = file->f_path.dentry->d_inode;
2031 if (file->f_mode & FMODE_WRITE)
2032 rc = filemap_write_and_wait(inode->i_mapping);
2034 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2040 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2045 for (i = 0; i < num_pages; i++) {
2046 pages[i] = alloc_page(__GFP_HIGHMEM);
2049 * save number of pages we have already allocated and
2050 * return with ENOMEM error
2061 for (i = 0; i < num_pages; i++)
2067 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2072 clen = min_t(const size_t, len, wsize);
2073 num_pages = clen / PAGE_CACHE_SIZE;
2074 if (clen % PAGE_CACHE_SIZE)
2084 cifs_iovec_write(struct file *file, const struct iovec *iov,
2085 unsigned long nr_segs, loff_t *poffset)
2087 unsigned int written;
2088 unsigned long num_pages, npages, i;
2089 size_t copied, len, cur_len;
2090 ssize_t total_written = 0;
2091 struct kvec *to_send;
2092 struct page **pages;
2094 struct inode *inode;
2095 struct cifsFileInfo *open_file;
2096 struct cifs_tcon *pTcon;
2097 struct cifs_sb_info *cifs_sb;
2098 struct cifs_io_parms io_parms;
2102 len = iov_length(iov, nr_segs);
2106 rc = generic_write_checks(file, poffset, &len, 0);
2110 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2111 num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2113 pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2117 to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2123 rc = cifs_write_allocate_pages(pages, num_pages);
2131 open_file = file->private_data;
2133 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2134 pid = open_file->pid;
2136 pid = current->tgid;
2138 pTcon = tlink_tcon(open_file->tlink);
2139 inode = file->f_path.dentry->d_inode;
2141 iov_iter_init(&it, iov, nr_segs, len, 0);
2145 size_t save_len = cur_len;
2146 for (i = 0; i < npages; i++) {
2147 copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2148 copied = iov_iter_copy_from_user(pages[i], &it, 0,
2151 iov_iter_advance(&it, copied);
2152 to_send[i+1].iov_base = kmap(pages[i]);
2153 to_send[i+1].iov_len = copied;
2156 cur_len = save_len - cur_len;
2159 if (open_file->invalidHandle) {
2160 rc = cifs_reopen_file(open_file, false);
2164 io_parms.netfid = open_file->netfid;
2166 io_parms.tcon = pTcon;
2167 io_parms.offset = *poffset;
2168 io_parms.length = cur_len;
2169 rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2171 } while (rc == -EAGAIN);
2173 for (i = 0; i < npages; i++)
2178 total_written += written;
2179 cifs_update_eof(CIFS_I(inode), *poffset, written);
2180 *poffset += written;
2181 } else if (rc < 0) {
2187 /* get length and number of kvecs of the next write */
2188 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2191 if (total_written > 0) {
2192 spin_lock(&inode->i_lock);
2193 if (*poffset > inode->i_size)
2194 i_size_write(inode, *poffset);
2195 spin_unlock(&inode->i_lock);
2198 cifs_stats_bytes_written(pTcon, total_written);
2199 mark_inode_dirty_sync(inode);
2201 for (i = 0; i < num_pages; i++)
2206 return total_written;
2209 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2210 unsigned long nr_segs, loff_t pos)
2213 struct inode *inode;
2215 inode = iocb->ki_filp->f_path.dentry->d_inode;
2218 * BB - optimize the way when signing is disabled. We can drop this
2219 * extra memory-to-memory copying and use iovec buffers for constructing
2223 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2225 CIFS_I(inode)->invalid_mapping = true;
2232 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2233 unsigned long nr_segs, loff_t pos)
2235 struct inode *inode;
2237 inode = iocb->ki_filp->f_path.dentry->d_inode;
2239 if (CIFS_I(inode)->clientCanCacheAll)
2240 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2243 * In strict cache mode we need to write the data to the server exactly
2244 * from the pos to pos+len-1 rather than flush all affected pages
2245 * because it may cause a error with mandatory locks on these pages but
2246 * not on the region from pos to ppos+len-1.
2249 return cifs_user_writev(iocb, iov, nr_segs, pos);
2253 cifs_iovec_read(struct file *file, const struct iovec *iov,
2254 unsigned long nr_segs, loff_t *poffset)
2259 unsigned int bytes_read = 0;
2260 size_t len, cur_len;
2262 struct cifs_sb_info *cifs_sb;
2263 struct cifs_tcon *pTcon;
2264 struct cifsFileInfo *open_file;
2265 struct smb_com_read_rsp *pSMBr;
2266 struct cifs_io_parms io_parms;
2274 len = iov_length(iov, nr_segs);
2279 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2281 /* FIXME: set up handlers for larger reads and/or convert to async */
2282 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2284 open_file = file->private_data;
2285 pTcon = tlink_tcon(open_file->tlink);
2287 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2288 pid = open_file->pid;
2290 pid = current->tgid;
2292 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2293 cFYI(1, "attempting read on write only file instance");
2295 for (total_read = 0; total_read < len; total_read += bytes_read) {
2296 cur_len = min_t(const size_t, len - total_read, rsize);
2300 while (rc == -EAGAIN) {
2301 int buf_type = CIFS_NO_BUFFER;
2302 if (open_file->invalidHandle) {
2303 rc = cifs_reopen_file(open_file, true);
2307 io_parms.netfid = open_file->netfid;
2309 io_parms.tcon = pTcon;
2310 io_parms.offset = *poffset;
2311 io_parms.length = cur_len;
2312 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2313 &read_data, &buf_type);
2314 pSMBr = (struct smb_com_read_rsp *)read_data;
2316 char *data_offset = read_data + 4 +
2317 le16_to_cpu(pSMBr->DataOffset);
2318 if (memcpy_toiovecend(iov, data_offset,
2319 iov_offset, bytes_read))
2321 if (buf_type == CIFS_SMALL_BUFFER)
2322 cifs_small_buf_release(read_data);
2323 else if (buf_type == CIFS_LARGE_BUFFER)
2324 cifs_buf_release(read_data);
2326 iov_offset += bytes_read;
2330 if (rc || (bytes_read == 0)) {
2338 cifs_stats_bytes_read(pTcon, bytes_read);
2339 *poffset += bytes_read;
2347 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2348 unsigned long nr_segs, loff_t pos)
2352 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2359 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2360 unsigned long nr_segs, loff_t pos)
2362 struct inode *inode;
2364 inode = iocb->ki_filp->f_path.dentry->d_inode;
2366 if (CIFS_I(inode)->clientCanCacheRead)
2367 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2370 * In strict cache mode we need to read from the server all the time
2371 * if we don't have level II oplock because the server can delay mtime
2372 * change - so we can't make a decision about inode invalidating.
2373 * And we can also fail with pagereading if there are mandatory locks
2374 * on pages affected by this read but not on the region from pos to
2378 return cifs_user_readv(iocb, iov, nr_segs, pos);
2381 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2385 unsigned int bytes_read = 0;
2386 unsigned int total_read;
2387 unsigned int current_read_size;
2389 struct cifs_sb_info *cifs_sb;
2390 struct cifs_tcon *pTcon;
2392 char *current_offset;
2393 struct cifsFileInfo *open_file;
2394 struct cifs_io_parms io_parms;
2395 int buf_type = CIFS_NO_BUFFER;
2399 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2401 /* FIXME: set up handlers for larger reads and/or convert to async */
2402 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2404 if (file->private_data == NULL) {
2409 open_file = file->private_data;
2410 pTcon = tlink_tcon(open_file->tlink);
2412 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2413 pid = open_file->pid;
2415 pid = current->tgid;
2417 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2418 cFYI(1, "attempting read on write only file instance");
2420 for (total_read = 0, current_offset = read_data;
2421 read_size > total_read;
2422 total_read += bytes_read, current_offset += bytes_read) {
2423 current_read_size = min_t(uint, read_size - total_read, rsize);
2425 /* For windows me and 9x we do not want to request more
2426 than it negotiated since it will refuse the read then */
2428 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2429 current_read_size = min_t(uint, current_read_size,
2433 while (rc == -EAGAIN) {
2434 if (open_file->invalidHandle) {
2435 rc = cifs_reopen_file(open_file, true);
2439 io_parms.netfid = open_file->netfid;
2441 io_parms.tcon = pTcon;
2442 io_parms.offset = *poffset;
2443 io_parms.length = current_read_size;
2444 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2445 ¤t_offset, &buf_type);
2447 if (rc || (bytes_read == 0)) {
2455 cifs_stats_bytes_read(pTcon, total_read);
2456 *poffset += bytes_read;
2464 * If the page is mmap'ed into a process' page tables, then we need to make
2465 * sure that it doesn't change while being written back.
2468 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2470 struct page *page = vmf->page;
2473 return VM_FAULT_LOCKED;
2476 static struct vm_operations_struct cifs_file_vm_ops = {
2477 .fault = filemap_fault,
2478 .page_mkwrite = cifs_page_mkwrite,
2481 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2484 struct inode *inode = file->f_path.dentry->d_inode;
2488 if (!CIFS_I(inode)->clientCanCacheRead) {
2489 rc = cifs_invalidate_mapping(inode);
2494 rc = generic_file_mmap(file, vma);
2496 vma->vm_ops = &cifs_file_vm_ops;
2501 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2506 rc = cifs_revalidate_file(file);
2508 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2512 rc = generic_file_mmap(file, vma);
2514 vma->vm_ops = &cifs_file_vm_ops;
2519 static int cifs_readpages(struct file *file, struct address_space *mapping,
2520 struct list_head *page_list, unsigned num_pages)
2523 struct list_head tmplist;
2524 struct cifsFileInfo *open_file = file->private_data;
2525 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2526 unsigned int rsize = cifs_sb->rsize;
2530 * Give up immediately if rsize is too small to read an entire page.
2531 * The VFS will fall back to readpage. We should never reach this
2532 * point however since we set ra_pages to 0 when the rsize is smaller
2533 * than a cache page.
2535 if (unlikely(rsize < PAGE_CACHE_SIZE))
2539 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2540 * immediately if the cookie is negative
2542 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2547 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2548 pid = open_file->pid;
2550 pid = current->tgid;
2553 INIT_LIST_HEAD(&tmplist);
2555 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2556 mapping, num_pages);
2559 * Start with the page at end of list and move it to private
2560 * list. Do the same with any following pages until we hit
2561 * the rsize limit, hit an index discontinuity, or run out of
2562 * pages. Issue the async read and then start the loop again
2563 * until the list is empty.
2565 * Note that list order is important. The page_list is in
2566 * the order of declining indexes. When we put the pages in
2567 * the rdata->pages, then we want them in increasing order.
2569 while (!list_empty(page_list)) {
2570 unsigned int bytes = PAGE_CACHE_SIZE;
2571 unsigned int expected_index;
2572 unsigned int nr_pages = 1;
2574 struct page *page, *tpage;
2575 struct cifs_readdata *rdata;
2577 page = list_entry(page_list->prev, struct page, lru);
2580 * Lock the page and put it in the cache. Since no one else
2581 * should have access to this page, we're safe to simply set
2582 * PG_locked without checking it first.
2584 __set_page_locked(page);
2585 rc = add_to_page_cache_locked(page, mapping,
2586 page->index, GFP_KERNEL);
2588 /* give up if we can't stick it in the cache */
2590 __clear_page_locked(page);
2594 /* move first page to the tmplist */
2595 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2596 list_move_tail(&page->lru, &tmplist);
2598 /* now try and add more pages onto the request */
2599 expected_index = page->index + 1;
2600 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2601 /* discontinuity ? */
2602 if (page->index != expected_index)
2605 /* would this page push the read over the rsize? */
2606 if (bytes + PAGE_CACHE_SIZE > rsize)
2609 __set_page_locked(page);
2610 if (add_to_page_cache_locked(page, mapping,
2611 page->index, GFP_KERNEL)) {
2612 __clear_page_locked(page);
2615 list_move_tail(&page->lru, &tmplist);
2616 bytes += PAGE_CACHE_SIZE;
2621 rdata = cifs_readdata_alloc(nr_pages);
2623 /* best to give up if we're out of mem */
2624 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2625 list_del(&page->lru);
2626 lru_cache_add_file(page);
2628 page_cache_release(page);
2634 spin_lock(&cifs_file_list_lock);
2635 cifsFileInfo_get(open_file);
2636 spin_unlock(&cifs_file_list_lock);
2637 rdata->cfile = open_file;
2638 rdata->mapping = mapping;
2639 rdata->offset = offset;
2640 rdata->bytes = bytes;
2642 list_splice_init(&tmplist, &rdata->pages);
2645 if (open_file->invalidHandle) {
2646 rc = cifs_reopen_file(open_file, true);
2650 rc = cifs_async_readv(rdata);
2651 } while (rc == -EAGAIN);
2654 list_for_each_entry_safe(page, tpage, &rdata->pages,
2656 list_del(&page->lru);
2657 lru_cache_add_file(page);
2659 page_cache_release(page);
2661 cifs_readdata_free(rdata);
2669 static int cifs_readpage_worker(struct file *file, struct page *page,
2675 /* Is the page cached? */
2676 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2680 page_cache_get(page);
2681 read_data = kmap(page);
2682 /* for reads over a certain size could initiate async read ahead */
2684 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2689 cFYI(1, "Bytes read %d", rc);
2691 file->f_path.dentry->d_inode->i_atime =
2692 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2694 if (PAGE_CACHE_SIZE > rc)
2695 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2697 flush_dcache_page(page);
2698 SetPageUptodate(page);
2700 /* send this page to the cache */
2701 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2707 page_cache_release(page);
2713 static int cifs_readpage(struct file *file, struct page *page)
2715 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2721 if (file->private_data == NULL) {
2727 cFYI(1, "readpage %p at offset %d 0x%x\n",
2728 page, (int)offset, (int)offset);
2730 rc = cifs_readpage_worker(file, page, &offset);
2738 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2740 struct cifsFileInfo *open_file;
2742 spin_lock(&cifs_file_list_lock);
2743 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2744 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2745 spin_unlock(&cifs_file_list_lock);
2749 spin_unlock(&cifs_file_list_lock);
2753 /* We do not want to update the file size from server for inodes
2754 open for write - to avoid races with writepage extending
2755 the file - in the future we could consider allowing
2756 refreshing the inode only on increases in the file size
2757 but this is tricky to do without racing with writebehind
2758 page caching in the current Linux kernel design */
2759 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2764 if (is_inode_writable(cifsInode)) {
2765 /* This inode is open for write at least once */
2766 struct cifs_sb_info *cifs_sb;
2768 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2769 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2770 /* since no page cache to corrupt on directio
2771 we can change size safely */
2775 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2783 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2784 loff_t pos, unsigned len, unsigned flags,
2785 struct page **pagep, void **fsdata)
2787 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2788 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2789 loff_t page_start = pos & PAGE_MASK;
2794 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2796 page = grab_cache_page_write_begin(mapping, index, flags);
2802 if (PageUptodate(page))
2806 * If we write a full page it will be up to date, no need to read from
2807 * the server. If the write is short, we'll end up doing a sync write
2810 if (len == PAGE_CACHE_SIZE)
2814 * optimize away the read when we have an oplock, and we're not
2815 * expecting to use any of the data we'd be reading in. That
2816 * is, when the page lies beyond the EOF, or straddles the EOF
2817 * and the write will cover all of the existing data.
2819 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2820 i_size = i_size_read(mapping->host);
2821 if (page_start >= i_size ||
2822 (offset == 0 && (pos + len) >= i_size)) {
2823 zero_user_segments(page, 0, offset,
2827 * PageChecked means that the parts of the page
2828 * to which we're not writing are considered up
2829 * to date. Once the data is copied to the
2830 * page, it can be set uptodate.
2832 SetPageChecked(page);
2837 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2839 * might as well read a page, it is fast enough. If we get
2840 * an error, we don't need to return it. cifs_write_end will
2841 * do a sync write instead since PG_uptodate isn't set.
2843 cifs_readpage_worker(file, page, &page_start);
2845 /* we could try using another file handle if there is one -
2846 but how would we lock it to prevent close of that handle
2847 racing with this read? In any case
2848 this will be written out by write_end so is fine */
2855 static int cifs_release_page(struct page *page, gfp_t gfp)
2857 if (PagePrivate(page))
2860 return cifs_fscache_release_page(page, gfp);
2863 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2865 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2868 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2871 static int cifs_launder_page(struct page *page)
2874 loff_t range_start = page_offset(page);
2875 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2876 struct writeback_control wbc = {
2877 .sync_mode = WB_SYNC_ALL,
2879 .range_start = range_start,
2880 .range_end = range_end,
2883 cFYI(1, "Launder page: %p", page);
2885 if (clear_page_dirty_for_io(page))
2886 rc = cifs_writepage_locked(page, &wbc);
2888 cifs_fscache_invalidate_page(page, page->mapping->host);
2892 void cifs_oplock_break(struct work_struct *work)
2894 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2896 struct inode *inode = cfile->dentry->d_inode;
2897 struct cifsInodeInfo *cinode = CIFS_I(inode);
2900 if (inode && S_ISREG(inode->i_mode)) {
2901 if (cinode->clientCanCacheRead)
2902 break_lease(inode, O_RDONLY);
2904 break_lease(inode, O_WRONLY);
2905 rc = filemap_fdatawrite(inode->i_mapping);
2906 if (cinode->clientCanCacheRead == 0) {
2907 rc = filemap_fdatawait(inode->i_mapping);
2908 mapping_set_error(inode->i_mapping, rc);
2909 invalidate_remote_inode(inode);
2911 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2914 rc = cifs_push_locks(cfile);
2916 cERROR(1, "Push locks rc = %d", rc);
2919 * releasing stale oplock after recent reconnect of smb session using
2920 * a now incorrect file handle is not a data integrity issue but do
2921 * not bother sending an oplock release if session to server still is
2922 * disconnected since oplock already released by the server
2924 if (!cfile->oplock_break_cancelled) {
2925 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2926 current->tgid, 0, 0, 0, 0,
2927 LOCKING_ANDX_OPLOCK_RELEASE, false,
2928 cinode->clientCanCacheRead ? 1 : 0);
2929 cFYI(1, "Oplock release rc = %d", rc);
2933 const struct address_space_operations cifs_addr_ops = {
2934 .readpage = cifs_readpage,
2935 .readpages = cifs_readpages,
2936 .writepage = cifs_writepage,
2937 .writepages = cifs_writepages,
2938 .write_begin = cifs_write_begin,
2939 .write_end = cifs_write_end,
2940 .set_page_dirty = __set_page_dirty_nobuffers,
2941 .releasepage = cifs_release_page,
2942 .invalidatepage = cifs_invalidate_page,
2943 .launder_page = cifs_launder_page,
2947 * cifs_readpages requires the server to support a buffer large enough to
2948 * contain the header plus one complete page of data. Otherwise, we need
2949 * to leave cifs_readpages out of the address space operations.
2951 const struct address_space_operations cifs_addr_ops_smallbuf = {
2952 .readpage = cifs_readpage,
2953 .writepage = cifs_writepage,
2954 .writepages = cifs_writepages,
2955 .write_begin = cifs_write_begin,
2956 .write_end = cifs_write_end,
2957 .set_page_dirty = __set_page_dirty_nobuffers,
2958 .releasepage = cifs_release_page,
2959 .invalidatepage = cifs_invalidate_page,
2960 .launder_page = cifs_launder_page,