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 cifs_sb_active(inode->i_sb);
270 spin_lock(&cifs_file_list_lock);
271 list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
272 /* if readable file instance put first in list*/
273 if (file->f_mode & FMODE_READ)
274 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
276 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
277 spin_unlock(&cifs_file_list_lock);
279 cifs_set_oplock_level(pCifsInode, oplock);
280 pCifsInode->can_cache_brlcks = pCifsInode->clientCanCacheAll;
282 file->private_data = pCifsFile;
286 static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
289 * Release a reference on the file private data. This may involve closing
290 * the filehandle out on the server. Must be called without holding
291 * cifs_file_list_lock.
293 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
295 struct inode *inode = cifs_file->dentry->d_inode;
296 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
297 struct cifsInodeInfo *cifsi = CIFS_I(inode);
298 struct super_block *sb = inode->i_sb;
299 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
300 struct cifsLockInfo *li, *tmp;
302 spin_lock(&cifs_file_list_lock);
303 if (--cifs_file->count > 0) {
304 spin_unlock(&cifs_file_list_lock);
308 /* remove it from the lists */
309 list_del(&cifs_file->flist);
310 list_del(&cifs_file->tlist);
312 if (list_empty(&cifsi->openFileList)) {
313 cFYI(1, "closing last open instance for inode %p",
314 cifs_file->dentry->d_inode);
316 /* in strict cache mode we need invalidate mapping on the last
317 close because it may cause a error when we open this file
318 again and get at least level II oplock */
319 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
320 CIFS_I(inode)->invalid_mapping = true;
322 cifs_set_oplock_level(cifsi, 0);
324 spin_unlock(&cifs_file_list_lock);
326 cancel_work_sync(&cifs_file->oplock_break);
328 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
332 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
336 /* Delete any outstanding lock records. We'll lose them when the file
339 mutex_lock(&cifsi->lock_mutex);
340 list_for_each_entry_safe(li, tmp, &cifsi->llist, llist) {
341 if (li->netfid != cifs_file->netfid)
343 list_del(&li->llist);
344 cifs_del_lock_waiters(li);
347 mutex_unlock(&cifsi->lock_mutex);
349 cifs_put_tlink(cifs_file->tlink);
350 dput(cifs_file->dentry);
351 cifs_sb_deactive(sb);
355 int cifs_open(struct inode *inode, struct file *file)
360 struct cifs_sb_info *cifs_sb;
361 struct cifs_tcon *tcon;
362 struct tcon_link *tlink;
363 struct cifsFileInfo *pCifsFile = NULL;
364 char *full_path = NULL;
365 bool posix_open_ok = false;
370 cifs_sb = CIFS_SB(inode->i_sb);
371 tlink = cifs_sb_tlink(cifs_sb);
374 return PTR_ERR(tlink);
376 tcon = tlink_tcon(tlink);
378 full_path = build_path_from_dentry(file->f_path.dentry);
379 if (full_path == NULL) {
384 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
385 inode, file->f_flags, full_path);
387 if (tcon->ses->server->oplocks)
392 if (!tcon->broken_posix_open && tcon->unix_ext &&
393 (tcon->ses->capabilities & CAP_UNIX) &&
394 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
395 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
396 /* can not refresh inode info since size could be stale */
397 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
398 cifs_sb->mnt_file_mode /* ignored */,
399 file->f_flags, &oplock, &netfid, xid);
401 cFYI(1, "posix open succeeded");
402 posix_open_ok = true;
403 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
404 if (tcon->ses->serverNOS)
405 cERROR(1, "server %s of type %s returned"
406 " unexpected error on SMB posix open"
407 ", disabling posix open support."
408 " Check if server update available.",
409 tcon->ses->serverName,
410 tcon->ses->serverNOS);
411 tcon->broken_posix_open = true;
412 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
413 (rc != -EOPNOTSUPP)) /* path not found or net err */
415 /* else fallthrough to retry open the old way on network i/o
419 if (!posix_open_ok) {
420 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
421 file->f_flags, &oplock, &netfid, xid);
426 pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
427 if (pCifsFile == NULL) {
428 CIFSSMBClose(xid, tcon, netfid);
433 cifs_fscache_set_inode_cookie(inode, file);
435 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
436 /* time to set mode which we can not set earlier due to
437 problems creating new read-only files */
438 struct cifs_unix_set_info_args args = {
439 .mode = inode->i_mode,
442 .ctime = NO_CHANGE_64,
443 .atime = NO_CHANGE_64,
444 .mtime = NO_CHANGE_64,
447 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
454 cifs_put_tlink(tlink);
458 /* Try to reacquire byte range locks that were released when session */
459 /* to server was lost */
460 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
464 /* BB list all locks open on this file and relock */
469 static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
474 struct cifs_sb_info *cifs_sb;
475 struct cifs_tcon *tcon;
476 struct cifsInodeInfo *pCifsInode;
478 char *full_path = NULL;
480 int disposition = FILE_OPEN;
481 int create_options = CREATE_NOT_DIR;
485 mutex_lock(&pCifsFile->fh_mutex);
486 if (!pCifsFile->invalidHandle) {
487 mutex_unlock(&pCifsFile->fh_mutex);
493 inode = pCifsFile->dentry->d_inode;
494 cifs_sb = CIFS_SB(inode->i_sb);
495 tcon = tlink_tcon(pCifsFile->tlink);
497 /* can not grab rename sem here because various ops, including
498 those that already have the rename sem can end up causing writepage
499 to get called and if the server was down that means we end up here,
500 and we can never tell if the caller already has the rename_sem */
501 full_path = build_path_from_dentry(pCifsFile->dentry);
502 if (full_path == NULL) {
504 mutex_unlock(&pCifsFile->fh_mutex);
509 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
510 inode, pCifsFile->f_flags, full_path);
512 if (tcon->ses->server->oplocks)
517 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
518 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
519 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
522 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
523 * original open. Must mask them off for a reopen.
525 unsigned int oflags = pCifsFile->f_flags &
526 ~(O_CREAT | O_EXCL | O_TRUNC);
528 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
529 cifs_sb->mnt_file_mode /* ignored */,
530 oflags, &oplock, &netfid, xid);
532 cFYI(1, "posix reopen succeeded");
535 /* fallthrough to retry open the old way on errors, especially
536 in the reconnect path it is important to retry hard */
539 desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
541 if (backup_cred(cifs_sb))
542 create_options |= CREATE_OPEN_BACKUP_INTENT;
544 /* Can not refresh inode by passing in file_info buf to be returned
545 by SMBOpen and then calling get_inode_info with returned buf
546 since file might have write behind data that needs to be flushed
547 and server version of file size can be stale. If we knew for sure
548 that inode was not dirty locally we could do this */
550 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
551 create_options, &netfid, &oplock, NULL,
552 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
553 CIFS_MOUNT_MAP_SPECIAL_CHR);
555 mutex_unlock(&pCifsFile->fh_mutex);
556 cFYI(1, "cifs_open returned 0x%x", rc);
557 cFYI(1, "oplock: %d", oplock);
558 goto reopen_error_exit;
562 pCifsFile->netfid = netfid;
563 pCifsFile->invalidHandle = false;
564 mutex_unlock(&pCifsFile->fh_mutex);
565 pCifsInode = CIFS_I(inode);
568 rc = filemap_write_and_wait(inode->i_mapping);
569 mapping_set_error(inode->i_mapping, rc);
572 rc = cifs_get_inode_info_unix(&inode,
573 full_path, inode->i_sb, xid);
575 rc = cifs_get_inode_info(&inode,
576 full_path, NULL, inode->i_sb,
578 } /* else we are writing out data to server already
579 and could deadlock if we tried to flush data, and
580 since we do not know if we have data that would
581 invalidate the current end of file on the server
582 we can not go to the server to get the new inod
585 cifs_set_oplock_level(pCifsInode, oplock);
587 cifs_relock_file(pCifsFile);
595 int cifs_close(struct inode *inode, struct file *file)
597 if (file->private_data != NULL) {
598 cifsFileInfo_put(file->private_data);
599 file->private_data = NULL;
602 /* return code from the ->release op is always ignored */
606 int cifs_closedir(struct inode *inode, struct file *file)
610 struct cifsFileInfo *pCFileStruct = file->private_data;
613 cFYI(1, "Closedir inode = 0x%p", inode);
618 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
620 cFYI(1, "Freeing private data in close dir");
621 spin_lock(&cifs_file_list_lock);
622 if (!pCFileStruct->srch_inf.endOfSearch &&
623 !pCFileStruct->invalidHandle) {
624 pCFileStruct->invalidHandle = true;
625 spin_unlock(&cifs_file_list_lock);
626 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
627 cFYI(1, "Closing uncompleted readdir with rc %d",
629 /* not much we can do if it fails anyway, ignore rc */
632 spin_unlock(&cifs_file_list_lock);
633 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
635 cFYI(1, "closedir free smb buf in srch struct");
636 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
637 if (pCFileStruct->srch_inf.smallBuf)
638 cifs_small_buf_release(ptmp);
640 cifs_buf_release(ptmp);
642 cifs_put_tlink(pCFileStruct->tlink);
643 kfree(file->private_data);
644 file->private_data = NULL;
646 /* BB can we lock the filestruct while this is going on? */
651 static struct cifsLockInfo *
652 cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 netfid)
654 struct cifsLockInfo *lock =
655 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
658 lock->offset = offset;
659 lock->length = length;
661 lock->netfid = netfid;
662 lock->pid = current->tgid;
663 INIT_LIST_HEAD(&lock->blist);
664 init_waitqueue_head(&lock->block_q);
669 cifs_del_lock_waiters(struct cifsLockInfo *lock)
671 struct cifsLockInfo *li, *tmp;
672 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
673 list_del_init(&li->blist);
674 wake_up(&li->block_q);
679 __cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
680 __u64 length, __u8 type, __u16 netfid,
681 struct cifsLockInfo **conf_lock)
683 struct cifsLockInfo *li, *tmp;
685 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
686 if (offset + length <= li->offset ||
687 offset >= li->offset + li->length)
689 else if ((type & LOCKING_ANDX_SHARED_LOCK) &&
690 ((netfid == li->netfid && current->tgid == li->pid) ||
702 cifs_find_lock_conflict(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
703 struct cifsLockInfo **conf_lock)
705 return __cifs_find_lock_conflict(cinode, lock->offset, lock->length,
706 lock->type, lock->netfid, conf_lock);
710 * Check if there is another lock that prevents us to set the lock (mandatory
711 * style). If such a lock exists, update the flock structure with its
712 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
713 * or leave it the same if we can't. Returns 0 if we don't need to request to
714 * the server or 1 otherwise.
717 cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
718 __u8 type, __u16 netfid, struct file_lock *flock)
721 struct cifsLockInfo *conf_lock;
724 mutex_lock(&cinode->lock_mutex);
726 exist = __cifs_find_lock_conflict(cinode, offset, length, type, netfid,
729 flock->fl_start = conf_lock->offset;
730 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
731 flock->fl_pid = conf_lock->pid;
732 if (conf_lock->type & LOCKING_ANDX_SHARED_LOCK)
733 flock->fl_type = F_RDLCK;
735 flock->fl_type = F_WRLCK;
736 } else if (!cinode->can_cache_brlcks)
739 flock->fl_type = F_UNLCK;
741 mutex_unlock(&cinode->lock_mutex);
746 cifs_lock_add(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock)
748 mutex_lock(&cinode->lock_mutex);
749 list_add_tail(&lock->llist, &cinode->llist);
750 mutex_unlock(&cinode->lock_mutex);
754 * Set the byte-range lock (mandatory style). Returns:
755 * 1) 0, if we set the lock and don't need to request to the server;
756 * 2) 1, if no locks prevent us but we need to request to the server;
757 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
760 cifs_lock_add_if(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
763 struct cifsLockInfo *conf_lock;
769 mutex_lock(&cinode->lock_mutex);
771 exist = cifs_find_lock_conflict(cinode, lock, &conf_lock);
772 if (!exist && cinode->can_cache_brlcks) {
773 list_add_tail(&lock->llist, &cinode->llist);
774 mutex_unlock(&cinode->lock_mutex);
783 list_add_tail(&lock->blist, &conf_lock->blist);
784 mutex_unlock(&cinode->lock_mutex);
785 rc = wait_event_interruptible(lock->block_q,
786 (lock->blist.prev == &lock->blist) &&
787 (lock->blist.next == &lock->blist));
790 mutex_lock(&cinode->lock_mutex);
791 list_del_init(&lock->blist);
794 mutex_unlock(&cinode->lock_mutex);
799 * Check if there is another lock that prevents us to set the lock (posix
800 * style). If such a lock exists, update the flock structure with its
801 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
802 * or leave it the same if we can't. Returns 0 if we don't need to request to
803 * the server or 1 otherwise.
806 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
809 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
810 unsigned char saved_type = flock->fl_type;
812 if ((flock->fl_flags & FL_POSIX) == 0)
815 mutex_lock(&cinode->lock_mutex);
816 posix_test_lock(file, flock);
818 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
819 flock->fl_type = saved_type;
823 mutex_unlock(&cinode->lock_mutex);
828 * Set the byte-range lock (posix style). Returns:
829 * 1) 0, if we set the lock and don't need to request to the server;
830 * 2) 1, if we need to request to the server;
831 * 3) <0, if the error occurs while setting the lock.
834 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
836 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
839 if ((flock->fl_flags & FL_POSIX) == 0)
843 mutex_lock(&cinode->lock_mutex);
844 if (!cinode->can_cache_brlcks) {
845 mutex_unlock(&cinode->lock_mutex);
849 rc = posix_lock_file(file, flock, NULL);
850 mutex_unlock(&cinode->lock_mutex);
851 if (rc == FILE_LOCK_DEFERRED) {
852 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
855 locks_delete_block(flock);
861 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
863 int xid, rc = 0, stored_rc;
864 struct cifsLockInfo *li, *tmp;
865 struct cifs_tcon *tcon;
866 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
867 unsigned int num, max_num;
868 LOCKING_ANDX_RANGE *buf, *cur;
869 int types[] = {LOCKING_ANDX_LARGE_FILES,
870 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
874 tcon = tlink_tcon(cfile->tlink);
876 mutex_lock(&cinode->lock_mutex);
877 if (!cinode->can_cache_brlcks) {
878 mutex_unlock(&cinode->lock_mutex);
883 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
884 sizeof(LOCKING_ANDX_RANGE);
885 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
887 mutex_unlock(&cinode->lock_mutex);
892 for (i = 0; i < 2; i++) {
895 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
896 if (li->type != types[i])
898 cur->Pid = cpu_to_le16(li->pid);
899 cur->LengthLow = cpu_to_le32((u32)li->length);
900 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
901 cur->OffsetLow = cpu_to_le32((u32)li->offset);
902 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
903 if (++num == max_num) {
904 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
905 li->type, 0, num, buf);
915 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
916 types[i], 0, num, buf);
922 cinode->can_cache_brlcks = false;
923 mutex_unlock(&cinode->lock_mutex);
930 /* copied from fs/locks.c with a name change */
931 #define cifs_for_each_lock(inode, lockp) \
932 for (lockp = &inode->i_flock; *lockp != NULL; \
933 lockp = &(*lockp)->fl_next)
935 struct lock_to_push {
936 struct list_head llist;
945 cifs_push_posix_locks(struct cifsFileInfo *cfile)
947 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
948 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
949 struct file_lock *flock, **before;
950 unsigned int count = 0, i = 0;
951 int rc = 0, xid, type;
952 struct list_head locks_to_send, *el;
953 struct lock_to_push *lck, *tmp;
958 mutex_lock(&cinode->lock_mutex);
959 if (!cinode->can_cache_brlcks) {
960 mutex_unlock(&cinode->lock_mutex);
966 cifs_for_each_lock(cfile->dentry->d_inode, before) {
967 if ((*before)->fl_flags & FL_POSIX)
972 INIT_LIST_HEAD(&locks_to_send);
975 * Allocating count locks is enough because no FL_POSIX locks can be
976 * added to the list while we are holding cinode->lock_mutex that
977 * protects locking operations of this inode.
979 for (; i < count; i++) {
980 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
985 list_add_tail(&lck->llist, &locks_to_send);
988 el = locks_to_send.next;
990 cifs_for_each_lock(cfile->dentry->d_inode, before) {
992 if ((flock->fl_flags & FL_POSIX) == 0)
994 if (el == &locks_to_send) {
996 * The list ended. We don't have enough allocated
997 * structures - something is really wrong.
999 cERROR(1, "Can't push all brlocks!");
1002 length = 1 + flock->fl_end - flock->fl_start;
1003 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1007 lck = list_entry(el, struct lock_to_push, llist);
1008 lck->pid = flock->fl_pid;
1009 lck->netfid = cfile->netfid;
1010 lck->length = length;
1012 lck->offset = flock->fl_start;
1017 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1018 struct file_lock tmp_lock;
1021 tmp_lock.fl_start = lck->offset;
1022 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1023 0, lck->length, &tmp_lock,
1027 list_del(&lck->llist);
1032 cinode->can_cache_brlcks = false;
1033 mutex_unlock(&cinode->lock_mutex);
1038 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1039 list_del(&lck->llist);
1046 cifs_push_locks(struct cifsFileInfo *cfile)
1048 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1049 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1051 if ((tcon->ses->capabilities & CAP_UNIX) &&
1052 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1053 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1054 return cifs_push_posix_locks(cfile);
1056 return cifs_push_mandatory_locks(cfile);
1060 cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
1063 if (flock->fl_flags & FL_POSIX)
1065 if (flock->fl_flags & FL_FLOCK)
1067 if (flock->fl_flags & FL_SLEEP) {
1068 cFYI(1, "Blocking lock");
1071 if (flock->fl_flags & FL_ACCESS)
1072 cFYI(1, "Process suspended by mandatory locking - "
1073 "not implemented yet");
1074 if (flock->fl_flags & FL_LEASE)
1075 cFYI(1, "Lease on file - not implemented yet");
1076 if (flock->fl_flags &
1077 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
1078 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
1080 *type = LOCKING_ANDX_LARGE_FILES;
1081 if (flock->fl_type == F_WRLCK) {
1082 cFYI(1, "F_WRLCK ");
1084 } else if (flock->fl_type == F_UNLCK) {
1087 /* Check if unlock includes more than one lock range */
1088 } else if (flock->fl_type == F_RDLCK) {
1090 *type |= LOCKING_ANDX_SHARED_LOCK;
1092 } else if (flock->fl_type == F_EXLCK) {
1095 } else if (flock->fl_type == F_SHLCK) {
1097 *type |= LOCKING_ANDX_SHARED_LOCK;
1100 cFYI(1, "Unknown type of lock");
1104 cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
1105 bool wait_flag, bool posix_lck, int xid)
1108 __u64 length = 1 + flock->fl_end - flock->fl_start;
1109 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1110 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1111 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1112 __u16 netfid = cfile->netfid;
1115 int posix_lock_type;
1117 rc = cifs_posix_lock_test(file, flock);
1121 if (type & LOCKING_ANDX_SHARED_LOCK)
1122 posix_lock_type = CIFS_RDLCK;
1124 posix_lock_type = CIFS_WRLCK;
1125 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1126 1 /* get */, length, flock,
1127 posix_lock_type, wait_flag);
1131 rc = cifs_lock_test(cinode, flock->fl_start, length, type, netfid,
1136 /* BB we could chain these into one lock request BB */
1137 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1138 flock->fl_start, 0, 1, type, 0, 0);
1140 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1141 length, flock->fl_start, 1, 0,
1143 flock->fl_type = F_UNLCK;
1145 cERROR(1, "Error unlocking previously locked "
1146 "range %d during test of lock", rc);
1150 if (type & LOCKING_ANDX_SHARED_LOCK) {
1151 flock->fl_type = F_WRLCK;
1155 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1156 flock->fl_start, 0, 1,
1157 type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1159 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1160 length, flock->fl_start, 1, 0,
1161 type | LOCKING_ANDX_SHARED_LOCK,
1163 flock->fl_type = F_RDLCK;
1165 cERROR(1, "Error unlocking previously locked "
1166 "range %d during test of lock", rc);
1168 flock->fl_type = F_WRLCK;
1174 cifs_move_llist(struct list_head *source, struct list_head *dest)
1176 struct list_head *li, *tmp;
1177 list_for_each_safe(li, tmp, source)
1178 list_move(li, dest);
1182 cifs_free_llist(struct list_head *llist)
1184 struct cifsLockInfo *li, *tmp;
1185 list_for_each_entry_safe(li, tmp, llist, llist) {
1186 cifs_del_lock_waiters(li);
1187 list_del(&li->llist);
1193 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1195 int rc = 0, stored_rc;
1196 int types[] = {LOCKING_ANDX_LARGE_FILES,
1197 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1199 unsigned int max_num, num;
1200 LOCKING_ANDX_RANGE *buf, *cur;
1201 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1202 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1203 struct cifsLockInfo *li, *tmp;
1204 __u64 length = 1 + flock->fl_end - flock->fl_start;
1205 struct list_head tmp_llist;
1207 INIT_LIST_HEAD(&tmp_llist);
1209 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1210 sizeof(LOCKING_ANDX_RANGE);
1211 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1215 mutex_lock(&cinode->lock_mutex);
1216 for (i = 0; i < 2; i++) {
1219 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
1220 if (flock->fl_start > li->offset ||
1221 (flock->fl_start + length) <
1222 (li->offset + li->length))
1224 if (current->tgid != li->pid)
1226 if (cfile->netfid != li->netfid)
1228 if (types[i] != li->type)
1230 if (!cinode->can_cache_brlcks) {
1231 cur->Pid = cpu_to_le16(li->pid);
1232 cur->LengthLow = cpu_to_le32((u32)li->length);
1234 cpu_to_le32((u32)(li->length>>32));
1235 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1237 cpu_to_le32((u32)(li->offset>>32));
1239 * We need to save a lock here to let us add
1240 * it again to the inode list if the unlock
1241 * range request fails on the server.
1243 list_move(&li->llist, &tmp_llist);
1244 if (++num == max_num) {
1245 stored_rc = cifs_lockv(xid, tcon,
1251 * We failed on the unlock range
1252 * request - add all locks from
1253 * the tmp list to the head of
1256 cifs_move_llist(&tmp_llist,
1261 * The unlock range request
1262 * succeed - free the tmp list.
1264 cifs_free_llist(&tmp_llist);
1271 * We can cache brlock requests - simply remove
1272 * a lock from the inode list.
1274 list_del(&li->llist);
1275 cifs_del_lock_waiters(li);
1280 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1281 types[i], num, 0, buf);
1283 cifs_move_llist(&tmp_llist, &cinode->llist);
1286 cifs_free_llist(&tmp_llist);
1290 mutex_unlock(&cinode->lock_mutex);
1296 cifs_setlk(struct file *file, struct file_lock *flock, __u8 type,
1297 bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1300 __u64 length = 1 + flock->fl_end - flock->fl_start;
1301 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1302 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1303 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
1304 __u16 netfid = cfile->netfid;
1307 int posix_lock_type;
1309 rc = cifs_posix_lock_set(file, flock);
1313 if (type & LOCKING_ANDX_SHARED_LOCK)
1314 posix_lock_type = CIFS_RDLCK;
1316 posix_lock_type = CIFS_WRLCK;
1319 posix_lock_type = CIFS_UNLCK;
1321 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1322 0 /* set */, length, flock,
1323 posix_lock_type, wait_flag);
1328 struct cifsLockInfo *lock;
1330 lock = cifs_lock_init(flock->fl_start, length, type, netfid);
1334 rc = cifs_lock_add_if(cinode, lock, wait_flag);
1340 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1341 flock->fl_start, 0, 1, type, wait_flag, 0);
1347 cifs_lock_add(cinode, lock);
1349 rc = cifs_unlock_range(cfile, flock, xid);
1352 if (flock->fl_flags & FL_POSIX)
1353 posix_lock_file_wait(file, flock);
1357 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1360 int lock = 0, unlock = 0;
1361 bool wait_flag = false;
1362 bool posix_lck = false;
1363 struct cifs_sb_info *cifs_sb;
1364 struct cifs_tcon *tcon;
1365 struct cifsInodeInfo *cinode;
1366 struct cifsFileInfo *cfile;
1373 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1374 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1375 flock->fl_start, flock->fl_end);
1377 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1379 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1380 cfile = (struct cifsFileInfo *)file->private_data;
1381 tcon = tlink_tcon(cfile->tlink);
1382 netfid = cfile->netfid;
1383 cinode = CIFS_I(file->f_path.dentry->d_inode);
1385 if ((tcon->ses->capabilities & CAP_UNIX) &&
1386 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1387 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1390 * BB add code here to normalize offset and length to account for
1391 * negative length which we can not accept over the wire.
1393 if (IS_GETLK(cmd)) {
1394 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1399 if (!lock && !unlock) {
1401 * if no lock or unlock then nothing to do since we do not
1408 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1414 /* update the file size (if needed) after a write */
1416 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1417 unsigned int bytes_written)
1419 loff_t end_of_write = offset + bytes_written;
1421 if (end_of_write > cifsi->server_eof)
1422 cifsi->server_eof = end_of_write;
1425 static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
1426 const char *write_data, size_t write_size,
1430 unsigned int bytes_written = 0;
1431 unsigned int total_written;
1432 struct cifs_sb_info *cifs_sb;
1433 struct cifs_tcon *pTcon;
1435 struct dentry *dentry = open_file->dentry;
1436 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
1437 struct cifs_io_parms io_parms;
1439 cifs_sb = CIFS_SB(dentry->d_sb);
1441 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
1442 *poffset, dentry->d_name.name);
1444 pTcon = tlink_tcon(open_file->tlink);
1448 for (total_written = 0; write_size > total_written;
1449 total_written += bytes_written) {
1451 while (rc == -EAGAIN) {
1455 if (open_file->invalidHandle) {
1456 /* we could deadlock if we called
1457 filemap_fdatawait from here so tell
1458 reopen_file not to flush data to
1460 rc = cifs_reopen_file(open_file, false);
1465 len = min((size_t)cifs_sb->wsize,
1466 write_size - total_written);
1467 /* iov[0] is reserved for smb header */
1468 iov[1].iov_base = (char *)write_data + total_written;
1469 iov[1].iov_len = len;
1470 io_parms.netfid = open_file->netfid;
1472 io_parms.tcon = pTcon;
1473 io_parms.offset = *poffset;
1474 io_parms.length = len;
1475 rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1478 if (rc || (bytes_written == 0)) {
1486 cifs_update_eof(cifsi, *poffset, bytes_written);
1487 *poffset += bytes_written;
1491 cifs_stats_bytes_written(pTcon, total_written);
1493 if (total_written > 0) {
1494 spin_lock(&dentry->d_inode->i_lock);
1495 if (*poffset > dentry->d_inode->i_size)
1496 i_size_write(dentry->d_inode, *poffset);
1497 spin_unlock(&dentry->d_inode->i_lock);
1499 mark_inode_dirty_sync(dentry->d_inode);
1501 return total_written;
1504 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1507 struct cifsFileInfo *open_file = NULL;
1508 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1510 /* only filter by fsuid on multiuser mounts */
1511 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1514 spin_lock(&cifs_file_list_lock);
1515 /* we could simply get the first_list_entry since write-only entries
1516 are always at the end of the list but since the first entry might
1517 have a close pending, we go through the whole list */
1518 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1519 if (fsuid_only && open_file->uid != current_fsuid())
1521 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1522 if (!open_file->invalidHandle) {
1523 /* found a good file */
1524 /* lock it so it will not be closed on us */
1525 cifsFileInfo_get(open_file);
1526 spin_unlock(&cifs_file_list_lock);
1528 } /* else might as well continue, and look for
1529 another, or simply have the caller reopen it
1530 again rather than trying to fix this handle */
1531 } else /* write only file */
1532 break; /* write only files are last so must be done */
1534 spin_unlock(&cifs_file_list_lock);
1538 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1541 struct cifsFileInfo *open_file, *inv_file = NULL;
1542 struct cifs_sb_info *cifs_sb;
1543 bool any_available = false;
1545 unsigned int refind = 0;
1547 /* Having a null inode here (because mapping->host was set to zero by
1548 the VFS or MM) should not happen but we had reports of on oops (due to
1549 it being zero) during stress testcases so we need to check for it */
1551 if (cifs_inode == NULL) {
1552 cERROR(1, "Null inode passed to cifs_writeable_file");
1557 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1559 /* only filter by fsuid on multiuser mounts */
1560 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1563 spin_lock(&cifs_file_list_lock);
1565 if (refind > MAX_REOPEN_ATT) {
1566 spin_unlock(&cifs_file_list_lock);
1569 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1570 if (!any_available && open_file->pid != current->tgid)
1572 if (fsuid_only && open_file->uid != current_fsuid())
1574 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1575 if (!open_file->invalidHandle) {
1576 /* found a good writable file */
1577 cifsFileInfo_get(open_file);
1578 spin_unlock(&cifs_file_list_lock);
1582 inv_file = open_file;
1586 /* couldn't find useable FH with same pid, try any available */
1587 if (!any_available) {
1588 any_available = true;
1589 goto refind_writable;
1593 any_available = false;
1594 cifsFileInfo_get(inv_file);
1597 spin_unlock(&cifs_file_list_lock);
1600 rc = cifs_reopen_file(inv_file, false);
1604 spin_lock(&cifs_file_list_lock);
1605 list_move_tail(&inv_file->flist,
1606 &cifs_inode->openFileList);
1607 spin_unlock(&cifs_file_list_lock);
1608 cifsFileInfo_put(inv_file);
1609 spin_lock(&cifs_file_list_lock);
1611 goto refind_writable;
1618 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1620 struct address_space *mapping = page->mapping;
1621 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1624 int bytes_written = 0;
1625 struct inode *inode;
1626 struct cifsFileInfo *open_file;
1628 if (!mapping || !mapping->host)
1631 inode = page->mapping->host;
1633 offset += (loff_t)from;
1634 write_data = kmap(page);
1637 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1642 /* racing with truncate? */
1643 if (offset > mapping->host->i_size) {
1645 return 0; /* don't care */
1648 /* check to make sure that we are not extending the file */
1649 if (mapping->host->i_size - offset < (loff_t)to)
1650 to = (unsigned)(mapping->host->i_size - offset);
1652 open_file = find_writable_file(CIFS_I(mapping->host), false);
1654 bytes_written = cifs_write(open_file, open_file->pid,
1655 write_data, to - from, &offset);
1656 cifsFileInfo_put(open_file);
1657 /* Does mm or vfs already set times? */
1658 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1659 if ((bytes_written > 0) && (offset))
1661 else if (bytes_written < 0)
1664 cFYI(1, "No writeable filehandles for inode");
1672 static int cifs_writepages(struct address_space *mapping,
1673 struct writeback_control *wbc)
1675 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1676 bool done = false, scanned = false, range_whole = false;
1678 struct cifs_writedata *wdata;
1683 * If wsize is smaller than the page cache size, default to writing
1684 * one page at a time via cifs_writepage
1686 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1687 return generic_writepages(mapping, wbc);
1689 if (wbc->range_cyclic) {
1690 index = mapping->writeback_index; /* Start from prev offset */
1693 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1694 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1695 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1700 while (!done && index <= end) {
1701 unsigned int i, nr_pages, found_pages;
1702 pgoff_t next = 0, tofind;
1703 struct page **pages;
1705 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1708 wdata = cifs_writedata_alloc((unsigned int)tofind);
1715 * find_get_pages_tag seems to return a max of 256 on each
1716 * iteration, so we must call it several times in order to
1717 * fill the array or the wsize is effectively limited to
1718 * 256 * PAGE_CACHE_SIZE.
1721 pages = wdata->pages;
1723 nr_pages = find_get_pages_tag(mapping, &index,
1724 PAGECACHE_TAG_DIRTY,
1726 found_pages += nr_pages;
1729 } while (nr_pages && tofind && index <= end);
1731 if (found_pages == 0) {
1732 kref_put(&wdata->refcount, cifs_writedata_release);
1737 for (i = 0; i < found_pages; i++) {
1738 page = wdata->pages[i];
1740 * At this point we hold neither mapping->tree_lock nor
1741 * lock on the page itself: the page may be truncated or
1742 * invalidated (changing page->mapping to NULL), or even
1743 * swizzled back from swapper_space to tmpfs file
1749 else if (!trylock_page(page))
1752 if (unlikely(page->mapping != mapping)) {
1757 if (!wbc->range_cyclic && page->index > end) {
1763 if (next && (page->index != next)) {
1764 /* Not next consecutive page */
1769 if (wbc->sync_mode != WB_SYNC_NONE)
1770 wait_on_page_writeback(page);
1772 if (PageWriteback(page) ||
1773 !clear_page_dirty_for_io(page)) {
1779 * This actually clears the dirty bit in the radix tree.
1780 * See cifs_writepage() for more commentary.
1782 set_page_writeback(page);
1784 if (page_offset(page) >= mapping->host->i_size) {
1787 end_page_writeback(page);
1791 wdata->pages[i] = page;
1792 next = page->index + 1;
1796 /* reset index to refind any pages skipped */
1798 index = wdata->pages[0]->index + 1;
1800 /* put any pages we aren't going to use */
1801 for (i = nr_pages; i < found_pages; i++) {
1802 page_cache_release(wdata->pages[i]);
1803 wdata->pages[i] = NULL;
1806 /* nothing to write? */
1807 if (nr_pages == 0) {
1808 kref_put(&wdata->refcount, cifs_writedata_release);
1812 wdata->sync_mode = wbc->sync_mode;
1813 wdata->nr_pages = nr_pages;
1814 wdata->offset = page_offset(wdata->pages[0]);
1817 if (wdata->cfile != NULL)
1818 cifsFileInfo_put(wdata->cfile);
1819 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1821 if (!wdata->cfile) {
1822 cERROR(1, "No writable handles for inode");
1826 rc = cifs_async_writev(wdata);
1827 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1829 for (i = 0; i < nr_pages; ++i)
1830 unlock_page(wdata->pages[i]);
1832 /* send failure -- clean up the mess */
1834 for (i = 0; i < nr_pages; ++i) {
1836 redirty_page_for_writepage(wbc,
1839 SetPageError(wdata->pages[i]);
1840 end_page_writeback(wdata->pages[i]);
1841 page_cache_release(wdata->pages[i]);
1844 mapping_set_error(mapping, rc);
1846 kref_put(&wdata->refcount, cifs_writedata_release);
1848 wbc->nr_to_write -= nr_pages;
1849 if (wbc->nr_to_write <= 0)
1855 if (!scanned && !done) {
1857 * We hit the last page and there is more work to be done: wrap
1858 * back to the start of the file
1865 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1866 mapping->writeback_index = index;
1872 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1878 /* BB add check for wbc flags */
1879 page_cache_get(page);
1880 if (!PageUptodate(page))
1881 cFYI(1, "ppw - page not up to date");
1884 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1886 * A writepage() implementation always needs to do either this,
1887 * or re-dirty the page with "redirty_page_for_writepage()" in
1888 * the case of a failure.
1890 * Just unlocking the page will cause the radix tree tag-bits
1891 * to fail to update with the state of the page correctly.
1893 set_page_writeback(page);
1895 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1896 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1898 else if (rc == -EAGAIN)
1899 redirty_page_for_writepage(wbc, page);
1903 SetPageUptodate(page);
1904 end_page_writeback(page);
1905 page_cache_release(page);
1910 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1912 int rc = cifs_writepage_locked(page, wbc);
1917 static int cifs_write_end(struct file *file, struct address_space *mapping,
1918 loff_t pos, unsigned len, unsigned copied,
1919 struct page *page, void *fsdata)
1922 struct inode *inode = mapping->host;
1923 struct cifsFileInfo *cfile = file->private_data;
1924 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1927 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1930 pid = current->tgid;
1932 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1935 if (PageChecked(page)) {
1937 SetPageUptodate(page);
1938 ClearPageChecked(page);
1939 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1940 SetPageUptodate(page);
1942 if (!PageUptodate(page)) {
1944 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1948 /* this is probably better than directly calling
1949 partialpage_write since in this function the file handle is
1950 known which we might as well leverage */
1951 /* BB check if anything else missing out of ppw
1952 such as updating last write time */
1953 page_data = kmap(page);
1954 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1955 /* if (rc < 0) should we set writebehind rc? */
1962 set_page_dirty(page);
1966 spin_lock(&inode->i_lock);
1967 if (pos > inode->i_size)
1968 i_size_write(inode, pos);
1969 spin_unlock(&inode->i_lock);
1973 page_cache_release(page);
1978 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1983 struct cifs_tcon *tcon;
1984 struct cifsFileInfo *smbfile = file->private_data;
1985 struct inode *inode = file->f_path.dentry->d_inode;
1986 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1988 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1991 mutex_lock(&inode->i_mutex);
1995 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1996 file->f_path.dentry->d_name.name, datasync);
1998 if (!CIFS_I(inode)->clientCanCacheRead) {
1999 rc = cifs_invalidate_mapping(inode);
2001 cFYI(1, "rc: %d during invalidate phase", rc);
2002 rc = 0; /* don't care about it in fsync */
2006 tcon = tlink_tcon(smbfile->tlink);
2007 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2008 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2011 mutex_unlock(&inode->i_mutex);
2015 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2019 struct cifs_tcon *tcon;
2020 struct cifsFileInfo *smbfile = file->private_data;
2021 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2022 struct inode *inode = file->f_mapping->host;
2024 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2027 mutex_lock(&inode->i_mutex);
2031 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2032 file->f_path.dentry->d_name.name, datasync);
2034 tcon = tlink_tcon(smbfile->tlink);
2035 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2036 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2039 mutex_unlock(&inode->i_mutex);
2044 * As file closes, flush all cached write data for this inode checking
2045 * for write behind errors.
2047 int cifs_flush(struct file *file, fl_owner_t id)
2049 struct inode *inode = file->f_path.dentry->d_inode;
2052 if (file->f_mode & FMODE_WRITE)
2053 rc = filemap_write_and_wait(inode->i_mapping);
2055 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2061 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2066 for (i = 0; i < num_pages; i++) {
2067 pages[i] = alloc_page(__GFP_HIGHMEM);
2070 * save number of pages we have already allocated and
2071 * return with ENOMEM error
2082 for (i = 0; i < num_pages; i++)
2088 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2093 clen = min_t(const size_t, len, wsize);
2094 num_pages = clen / PAGE_CACHE_SIZE;
2095 if (clen % PAGE_CACHE_SIZE)
2105 cifs_iovec_write(struct file *file, const struct iovec *iov,
2106 unsigned long nr_segs, loff_t *poffset)
2108 unsigned int written;
2109 unsigned long num_pages, npages, i;
2110 size_t copied, len, cur_len;
2111 ssize_t total_written = 0;
2112 struct kvec *to_send;
2113 struct page **pages;
2115 struct inode *inode;
2116 struct cifsFileInfo *open_file;
2117 struct cifs_tcon *pTcon;
2118 struct cifs_sb_info *cifs_sb;
2119 struct cifs_io_parms io_parms;
2123 len = iov_length(iov, nr_segs);
2127 rc = generic_write_checks(file, poffset, &len, 0);
2131 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2132 num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2134 pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2138 to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2144 rc = cifs_write_allocate_pages(pages, num_pages);
2152 open_file = file->private_data;
2154 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2155 pid = open_file->pid;
2157 pid = current->tgid;
2159 pTcon = tlink_tcon(open_file->tlink);
2160 inode = file->f_path.dentry->d_inode;
2162 iov_iter_init(&it, iov, nr_segs, len, 0);
2166 size_t save_len = cur_len;
2167 for (i = 0; i < npages; i++) {
2168 copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2169 copied = iov_iter_copy_from_user(pages[i], &it, 0,
2172 iov_iter_advance(&it, copied);
2173 to_send[i+1].iov_base = kmap(pages[i]);
2174 to_send[i+1].iov_len = copied;
2177 cur_len = save_len - cur_len;
2180 if (open_file->invalidHandle) {
2181 rc = cifs_reopen_file(open_file, false);
2185 io_parms.netfid = open_file->netfid;
2187 io_parms.tcon = pTcon;
2188 io_parms.offset = *poffset;
2189 io_parms.length = cur_len;
2190 rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2192 } while (rc == -EAGAIN);
2194 for (i = 0; i < npages; i++)
2199 total_written += written;
2200 cifs_update_eof(CIFS_I(inode), *poffset, written);
2201 *poffset += written;
2202 } else if (rc < 0) {
2208 /* get length and number of kvecs of the next write */
2209 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2212 if (total_written > 0) {
2213 spin_lock(&inode->i_lock);
2214 if (*poffset > inode->i_size)
2215 i_size_write(inode, *poffset);
2216 spin_unlock(&inode->i_lock);
2219 cifs_stats_bytes_written(pTcon, total_written);
2220 mark_inode_dirty_sync(inode);
2222 for (i = 0; i < num_pages; i++)
2227 return total_written;
2230 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2231 unsigned long nr_segs, loff_t pos)
2234 struct inode *inode;
2236 inode = iocb->ki_filp->f_path.dentry->d_inode;
2239 * BB - optimize the way when signing is disabled. We can drop this
2240 * extra memory-to-memory copying and use iovec buffers for constructing
2244 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2246 CIFS_I(inode)->invalid_mapping = true;
2253 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2254 unsigned long nr_segs, loff_t pos)
2256 struct inode *inode;
2258 inode = iocb->ki_filp->f_path.dentry->d_inode;
2260 if (CIFS_I(inode)->clientCanCacheAll)
2261 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2264 * In strict cache mode we need to write the data to the server exactly
2265 * from the pos to pos+len-1 rather than flush all affected pages
2266 * because it may cause a error with mandatory locks on these pages but
2267 * not on the region from pos to ppos+len-1.
2270 return cifs_user_writev(iocb, iov, nr_segs, pos);
2274 cifs_iovec_read(struct file *file, const struct iovec *iov,
2275 unsigned long nr_segs, loff_t *poffset)
2280 unsigned int bytes_read = 0;
2281 size_t len, cur_len;
2283 struct cifs_sb_info *cifs_sb;
2284 struct cifs_tcon *pTcon;
2285 struct cifsFileInfo *open_file;
2286 struct smb_com_read_rsp *pSMBr;
2287 struct cifs_io_parms io_parms;
2295 len = iov_length(iov, nr_segs);
2300 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2302 /* FIXME: set up handlers for larger reads and/or convert to async */
2303 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2305 open_file = file->private_data;
2306 pTcon = tlink_tcon(open_file->tlink);
2308 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2309 pid = open_file->pid;
2311 pid = current->tgid;
2313 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2314 cFYI(1, "attempting read on write only file instance");
2316 for (total_read = 0; total_read < len; total_read += bytes_read) {
2317 cur_len = min_t(const size_t, len - total_read, rsize);
2321 while (rc == -EAGAIN) {
2322 int buf_type = CIFS_NO_BUFFER;
2323 if (open_file->invalidHandle) {
2324 rc = cifs_reopen_file(open_file, true);
2328 io_parms.netfid = open_file->netfid;
2330 io_parms.tcon = pTcon;
2331 io_parms.offset = *poffset;
2332 io_parms.length = cur_len;
2333 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2334 &read_data, &buf_type);
2335 pSMBr = (struct smb_com_read_rsp *)read_data;
2337 char *data_offset = read_data + 4 +
2338 le16_to_cpu(pSMBr->DataOffset);
2339 if (memcpy_toiovecend(iov, data_offset,
2340 iov_offset, bytes_read))
2342 if (buf_type == CIFS_SMALL_BUFFER)
2343 cifs_small_buf_release(read_data);
2344 else if (buf_type == CIFS_LARGE_BUFFER)
2345 cifs_buf_release(read_data);
2347 iov_offset += bytes_read;
2351 if (rc || (bytes_read == 0)) {
2359 cifs_stats_bytes_read(pTcon, bytes_read);
2360 *poffset += bytes_read;
2368 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2369 unsigned long nr_segs, loff_t pos)
2373 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2380 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2381 unsigned long nr_segs, loff_t pos)
2383 struct inode *inode;
2385 inode = iocb->ki_filp->f_path.dentry->d_inode;
2387 if (CIFS_I(inode)->clientCanCacheRead)
2388 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2391 * In strict cache mode we need to read from the server all the time
2392 * if we don't have level II oplock because the server can delay mtime
2393 * change - so we can't make a decision about inode invalidating.
2394 * And we can also fail with pagereading if there are mandatory locks
2395 * on pages affected by this read but not on the region from pos to
2399 return cifs_user_readv(iocb, iov, nr_segs, pos);
2402 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2406 unsigned int bytes_read = 0;
2407 unsigned int total_read;
2408 unsigned int current_read_size;
2410 struct cifs_sb_info *cifs_sb;
2411 struct cifs_tcon *pTcon;
2413 char *current_offset;
2414 struct cifsFileInfo *open_file;
2415 struct cifs_io_parms io_parms;
2416 int buf_type = CIFS_NO_BUFFER;
2420 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2422 /* FIXME: set up handlers for larger reads and/or convert to async */
2423 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2425 if (file->private_data == NULL) {
2430 open_file = file->private_data;
2431 pTcon = tlink_tcon(open_file->tlink);
2433 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2434 pid = open_file->pid;
2436 pid = current->tgid;
2438 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2439 cFYI(1, "attempting read on write only file instance");
2441 for (total_read = 0, current_offset = read_data;
2442 read_size > total_read;
2443 total_read += bytes_read, current_offset += bytes_read) {
2444 current_read_size = min_t(uint, read_size - total_read, rsize);
2446 /* For windows me and 9x we do not want to request more
2447 than it negotiated since it will refuse the read then */
2449 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2450 current_read_size = min_t(uint, current_read_size,
2454 while (rc == -EAGAIN) {
2455 if (open_file->invalidHandle) {
2456 rc = cifs_reopen_file(open_file, true);
2460 io_parms.netfid = open_file->netfid;
2462 io_parms.tcon = pTcon;
2463 io_parms.offset = *poffset;
2464 io_parms.length = current_read_size;
2465 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2466 ¤t_offset, &buf_type);
2468 if (rc || (bytes_read == 0)) {
2476 cifs_stats_bytes_read(pTcon, total_read);
2477 *poffset += bytes_read;
2485 * If the page is mmap'ed into a process' page tables, then we need to make
2486 * sure that it doesn't change while being written back.
2489 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2491 struct page *page = vmf->page;
2494 return VM_FAULT_LOCKED;
2497 static struct vm_operations_struct cifs_file_vm_ops = {
2498 .fault = filemap_fault,
2499 .page_mkwrite = cifs_page_mkwrite,
2502 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2505 struct inode *inode = file->f_path.dentry->d_inode;
2509 if (!CIFS_I(inode)->clientCanCacheRead) {
2510 rc = cifs_invalidate_mapping(inode);
2515 rc = generic_file_mmap(file, vma);
2517 vma->vm_ops = &cifs_file_vm_ops;
2522 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2527 rc = cifs_revalidate_file(file);
2529 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2533 rc = generic_file_mmap(file, vma);
2535 vma->vm_ops = &cifs_file_vm_ops;
2540 static int cifs_readpages(struct file *file, struct address_space *mapping,
2541 struct list_head *page_list, unsigned num_pages)
2544 struct list_head tmplist;
2545 struct cifsFileInfo *open_file = file->private_data;
2546 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2547 unsigned int rsize = cifs_sb->rsize;
2551 * Give up immediately if rsize is too small to read an entire page.
2552 * The VFS will fall back to readpage. We should never reach this
2553 * point however since we set ra_pages to 0 when the rsize is smaller
2554 * than a cache page.
2556 if (unlikely(rsize < PAGE_CACHE_SIZE))
2560 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2561 * immediately if the cookie is negative
2563 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2568 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2569 pid = open_file->pid;
2571 pid = current->tgid;
2574 INIT_LIST_HEAD(&tmplist);
2576 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2577 mapping, num_pages);
2580 * Start with the page at end of list and move it to private
2581 * list. Do the same with any following pages until we hit
2582 * the rsize limit, hit an index discontinuity, or run out of
2583 * pages. Issue the async read and then start the loop again
2584 * until the list is empty.
2586 * Note that list order is important. The page_list is in
2587 * the order of declining indexes. When we put the pages in
2588 * the rdata->pages, then we want them in increasing order.
2590 while (!list_empty(page_list)) {
2591 unsigned int bytes = PAGE_CACHE_SIZE;
2592 unsigned int expected_index;
2593 unsigned int nr_pages = 1;
2595 struct page *page, *tpage;
2596 struct cifs_readdata *rdata;
2598 page = list_entry(page_list->prev, struct page, lru);
2601 * Lock the page and put it in the cache. Since no one else
2602 * should have access to this page, we're safe to simply set
2603 * PG_locked without checking it first.
2605 __set_page_locked(page);
2606 rc = add_to_page_cache_locked(page, mapping,
2607 page->index, GFP_KERNEL);
2609 /* give up if we can't stick it in the cache */
2611 __clear_page_locked(page);
2615 /* move first page to the tmplist */
2616 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2617 list_move_tail(&page->lru, &tmplist);
2619 /* now try and add more pages onto the request */
2620 expected_index = page->index + 1;
2621 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2622 /* discontinuity ? */
2623 if (page->index != expected_index)
2626 /* would this page push the read over the rsize? */
2627 if (bytes + PAGE_CACHE_SIZE > rsize)
2630 __set_page_locked(page);
2631 if (add_to_page_cache_locked(page, mapping,
2632 page->index, GFP_KERNEL)) {
2633 __clear_page_locked(page);
2636 list_move_tail(&page->lru, &tmplist);
2637 bytes += PAGE_CACHE_SIZE;
2642 rdata = cifs_readdata_alloc(nr_pages);
2644 /* best to give up if we're out of mem */
2645 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2646 list_del(&page->lru);
2647 lru_cache_add_file(page);
2649 page_cache_release(page);
2655 spin_lock(&cifs_file_list_lock);
2656 cifsFileInfo_get(open_file);
2657 spin_unlock(&cifs_file_list_lock);
2658 rdata->cfile = open_file;
2659 rdata->mapping = mapping;
2660 rdata->offset = offset;
2661 rdata->bytes = bytes;
2663 list_splice_init(&tmplist, &rdata->pages);
2666 if (open_file->invalidHandle) {
2667 rc = cifs_reopen_file(open_file, true);
2671 rc = cifs_async_readv(rdata);
2672 } while (rc == -EAGAIN);
2675 list_for_each_entry_safe(page, tpage, &rdata->pages,
2677 list_del(&page->lru);
2678 lru_cache_add_file(page);
2680 page_cache_release(page);
2682 cifs_readdata_free(rdata);
2690 static int cifs_readpage_worker(struct file *file, struct page *page,
2696 /* Is the page cached? */
2697 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2701 page_cache_get(page);
2702 read_data = kmap(page);
2703 /* for reads over a certain size could initiate async read ahead */
2705 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2710 cFYI(1, "Bytes read %d", rc);
2712 file->f_path.dentry->d_inode->i_atime =
2713 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2715 if (PAGE_CACHE_SIZE > rc)
2716 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2718 flush_dcache_page(page);
2719 SetPageUptodate(page);
2721 /* send this page to the cache */
2722 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2728 page_cache_release(page);
2734 static int cifs_readpage(struct file *file, struct page *page)
2736 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2742 if (file->private_data == NULL) {
2748 cFYI(1, "readpage %p at offset %d 0x%x\n",
2749 page, (int)offset, (int)offset);
2751 rc = cifs_readpage_worker(file, page, &offset);
2759 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2761 struct cifsFileInfo *open_file;
2763 spin_lock(&cifs_file_list_lock);
2764 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2765 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2766 spin_unlock(&cifs_file_list_lock);
2770 spin_unlock(&cifs_file_list_lock);
2774 /* We do not want to update the file size from server for inodes
2775 open for write - to avoid races with writepage extending
2776 the file - in the future we could consider allowing
2777 refreshing the inode only on increases in the file size
2778 but this is tricky to do without racing with writebehind
2779 page caching in the current Linux kernel design */
2780 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2785 if (is_inode_writable(cifsInode)) {
2786 /* This inode is open for write at least once */
2787 struct cifs_sb_info *cifs_sb;
2789 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2790 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2791 /* since no page cache to corrupt on directio
2792 we can change size safely */
2796 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2804 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2805 loff_t pos, unsigned len, unsigned flags,
2806 struct page **pagep, void **fsdata)
2808 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2809 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2810 loff_t page_start = pos & PAGE_MASK;
2815 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2817 page = grab_cache_page_write_begin(mapping, index, flags);
2823 if (PageUptodate(page))
2827 * If we write a full page it will be up to date, no need to read from
2828 * the server. If the write is short, we'll end up doing a sync write
2831 if (len == PAGE_CACHE_SIZE)
2835 * optimize away the read when we have an oplock, and we're not
2836 * expecting to use any of the data we'd be reading in. That
2837 * is, when the page lies beyond the EOF, or straddles the EOF
2838 * and the write will cover all of the existing data.
2840 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2841 i_size = i_size_read(mapping->host);
2842 if (page_start >= i_size ||
2843 (offset == 0 && (pos + len) >= i_size)) {
2844 zero_user_segments(page, 0, offset,
2848 * PageChecked means that the parts of the page
2849 * to which we're not writing are considered up
2850 * to date. Once the data is copied to the
2851 * page, it can be set uptodate.
2853 SetPageChecked(page);
2858 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2860 * might as well read a page, it is fast enough. If we get
2861 * an error, we don't need to return it. cifs_write_end will
2862 * do a sync write instead since PG_uptodate isn't set.
2864 cifs_readpage_worker(file, page, &page_start);
2866 /* we could try using another file handle if there is one -
2867 but how would we lock it to prevent close of that handle
2868 racing with this read? In any case
2869 this will be written out by write_end so is fine */
2876 static int cifs_release_page(struct page *page, gfp_t gfp)
2878 if (PagePrivate(page))
2881 return cifs_fscache_release_page(page, gfp);
2884 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2886 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2889 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2892 static int cifs_launder_page(struct page *page)
2895 loff_t range_start = page_offset(page);
2896 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2897 struct writeback_control wbc = {
2898 .sync_mode = WB_SYNC_ALL,
2900 .range_start = range_start,
2901 .range_end = range_end,
2904 cFYI(1, "Launder page: %p", page);
2906 if (clear_page_dirty_for_io(page))
2907 rc = cifs_writepage_locked(page, &wbc);
2909 cifs_fscache_invalidate_page(page, page->mapping->host);
2913 void cifs_oplock_break(struct work_struct *work)
2915 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2917 struct inode *inode = cfile->dentry->d_inode;
2918 struct cifsInodeInfo *cinode = CIFS_I(inode);
2921 if (inode && S_ISREG(inode->i_mode)) {
2922 if (cinode->clientCanCacheRead)
2923 break_lease(inode, O_RDONLY);
2925 break_lease(inode, O_WRONLY);
2926 rc = filemap_fdatawrite(inode->i_mapping);
2927 if (cinode->clientCanCacheRead == 0) {
2928 rc = filemap_fdatawait(inode->i_mapping);
2929 mapping_set_error(inode->i_mapping, rc);
2930 invalidate_remote_inode(inode);
2932 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2935 rc = cifs_push_locks(cfile);
2937 cERROR(1, "Push locks rc = %d", rc);
2940 * releasing stale oplock after recent reconnect of smb session using
2941 * a now incorrect file handle is not a data integrity issue but do
2942 * not bother sending an oplock release if session to server still is
2943 * disconnected since oplock already released by the server
2945 if (!cfile->oplock_break_cancelled) {
2946 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2947 current->tgid, 0, 0, 0, 0,
2948 LOCKING_ANDX_OPLOCK_RELEASE, false,
2949 cinode->clientCanCacheRead ? 1 : 0);
2950 cFYI(1, "Oplock release rc = %d", rc);
2954 const struct address_space_operations cifs_addr_ops = {
2955 .readpage = cifs_readpage,
2956 .readpages = cifs_readpages,
2957 .writepage = cifs_writepage,
2958 .writepages = cifs_writepages,
2959 .write_begin = cifs_write_begin,
2960 .write_end = cifs_write_end,
2961 .set_page_dirty = __set_page_dirty_nobuffers,
2962 .releasepage = cifs_release_page,
2963 .invalidatepage = cifs_invalidate_page,
2964 .launder_page = cifs_launder_page,
2968 * cifs_readpages requires the server to support a buffer large enough to
2969 * contain the header plus one complete page of data. Otherwise, we need
2970 * to leave cifs_readpages out of the address space operations.
2972 const struct address_space_operations cifs_addr_ops_smallbuf = {
2973 .readpage = cifs_readpage,
2974 .writepage = cifs_writepage,
2975 .writepages = cifs_writepages,
2976 .write_begin = cifs_write_begin,
2977 .write_end = cifs_write_end,
2978 .set_page_dirty = __set_page_dirty_nobuffers,
2979 .releasepage = cifs_release_page,
2980 .invalidatepage = cifs_invalidate_page,
2981 .launder_page = cifs_launder_page,