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);
1612 goto refind_writable;
1619 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1621 struct address_space *mapping = page->mapping;
1622 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1625 int bytes_written = 0;
1626 struct inode *inode;
1627 struct cifsFileInfo *open_file;
1629 if (!mapping || !mapping->host)
1632 inode = page->mapping->host;
1634 offset += (loff_t)from;
1635 write_data = kmap(page);
1638 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1643 /* racing with truncate? */
1644 if (offset > mapping->host->i_size) {
1646 return 0; /* don't care */
1649 /* check to make sure that we are not extending the file */
1650 if (mapping->host->i_size - offset < (loff_t)to)
1651 to = (unsigned)(mapping->host->i_size - offset);
1653 open_file = find_writable_file(CIFS_I(mapping->host), false);
1655 bytes_written = cifs_write(open_file, open_file->pid,
1656 write_data, to - from, &offset);
1657 cifsFileInfo_put(open_file);
1658 /* Does mm or vfs already set times? */
1659 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1660 if ((bytes_written > 0) && (offset))
1662 else if (bytes_written < 0)
1665 cFYI(1, "No writeable filehandles for inode");
1673 static int cifs_writepages(struct address_space *mapping,
1674 struct writeback_control *wbc)
1676 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1677 bool done = false, scanned = false, range_whole = false;
1679 struct cifs_writedata *wdata;
1684 * If wsize is smaller than the page cache size, default to writing
1685 * one page at a time via cifs_writepage
1687 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1688 return generic_writepages(mapping, wbc);
1690 if (wbc->range_cyclic) {
1691 index = mapping->writeback_index; /* Start from prev offset */
1694 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1695 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1696 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1701 while (!done && index <= end) {
1702 unsigned int i, nr_pages, found_pages;
1703 pgoff_t next = 0, tofind;
1704 struct page **pages;
1706 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1709 wdata = cifs_writedata_alloc((unsigned int)tofind);
1716 * find_get_pages_tag seems to return a max of 256 on each
1717 * iteration, so we must call it several times in order to
1718 * fill the array or the wsize is effectively limited to
1719 * 256 * PAGE_CACHE_SIZE.
1722 pages = wdata->pages;
1724 nr_pages = find_get_pages_tag(mapping, &index,
1725 PAGECACHE_TAG_DIRTY,
1727 found_pages += nr_pages;
1730 } while (nr_pages && tofind && index <= end);
1732 if (found_pages == 0) {
1733 kref_put(&wdata->refcount, cifs_writedata_release);
1738 for (i = 0; i < found_pages; i++) {
1739 page = wdata->pages[i];
1741 * At this point we hold neither mapping->tree_lock nor
1742 * lock on the page itself: the page may be truncated or
1743 * invalidated (changing page->mapping to NULL), or even
1744 * swizzled back from swapper_space to tmpfs file
1750 else if (!trylock_page(page))
1753 if (unlikely(page->mapping != mapping)) {
1758 if (!wbc->range_cyclic && page->index > end) {
1764 if (next && (page->index != next)) {
1765 /* Not next consecutive page */
1770 if (wbc->sync_mode != WB_SYNC_NONE)
1771 wait_on_page_writeback(page);
1773 if (PageWriteback(page) ||
1774 !clear_page_dirty_for_io(page)) {
1780 * This actually clears the dirty bit in the radix tree.
1781 * See cifs_writepage() for more commentary.
1783 set_page_writeback(page);
1785 if (page_offset(page) >= mapping->host->i_size) {
1788 end_page_writeback(page);
1792 wdata->pages[i] = page;
1793 next = page->index + 1;
1797 /* reset index to refind any pages skipped */
1799 index = wdata->pages[0]->index + 1;
1801 /* put any pages we aren't going to use */
1802 for (i = nr_pages; i < found_pages; i++) {
1803 page_cache_release(wdata->pages[i]);
1804 wdata->pages[i] = NULL;
1807 /* nothing to write? */
1808 if (nr_pages == 0) {
1809 kref_put(&wdata->refcount, cifs_writedata_release);
1813 wdata->sync_mode = wbc->sync_mode;
1814 wdata->nr_pages = nr_pages;
1815 wdata->offset = page_offset(wdata->pages[0]);
1818 if (wdata->cfile != NULL)
1819 cifsFileInfo_put(wdata->cfile);
1820 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1822 if (!wdata->cfile) {
1823 cERROR(1, "No writable handles for inode");
1827 rc = cifs_async_writev(wdata);
1828 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
1830 for (i = 0; i < nr_pages; ++i)
1831 unlock_page(wdata->pages[i]);
1833 /* send failure -- clean up the mess */
1835 for (i = 0; i < nr_pages; ++i) {
1837 redirty_page_for_writepage(wbc,
1840 SetPageError(wdata->pages[i]);
1841 end_page_writeback(wdata->pages[i]);
1842 page_cache_release(wdata->pages[i]);
1845 mapping_set_error(mapping, rc);
1847 kref_put(&wdata->refcount, cifs_writedata_release);
1849 wbc->nr_to_write -= nr_pages;
1850 if (wbc->nr_to_write <= 0)
1856 if (!scanned && !done) {
1858 * We hit the last page and there is more work to be done: wrap
1859 * back to the start of the file
1866 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
1867 mapping->writeback_index = index;
1873 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
1879 /* BB add check for wbc flags */
1880 page_cache_get(page);
1881 if (!PageUptodate(page))
1882 cFYI(1, "ppw - page not up to date");
1885 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1887 * A writepage() implementation always needs to do either this,
1888 * or re-dirty the page with "redirty_page_for_writepage()" in
1889 * the case of a failure.
1891 * Just unlocking the page will cause the radix tree tag-bits
1892 * to fail to update with the state of the page correctly.
1894 set_page_writeback(page);
1896 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1897 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1899 else if (rc == -EAGAIN)
1900 redirty_page_for_writepage(wbc, page);
1904 SetPageUptodate(page);
1905 end_page_writeback(page);
1906 page_cache_release(page);
1911 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1913 int rc = cifs_writepage_locked(page, wbc);
1918 static int cifs_write_end(struct file *file, struct address_space *mapping,
1919 loff_t pos, unsigned len, unsigned copied,
1920 struct page *page, void *fsdata)
1923 struct inode *inode = mapping->host;
1924 struct cifsFileInfo *cfile = file->private_data;
1925 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1928 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1931 pid = current->tgid;
1933 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1936 if (PageChecked(page)) {
1938 SetPageUptodate(page);
1939 ClearPageChecked(page);
1940 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1941 SetPageUptodate(page);
1943 if (!PageUptodate(page)) {
1945 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1949 /* this is probably better than directly calling
1950 partialpage_write since in this function the file handle is
1951 known which we might as well leverage */
1952 /* BB check if anything else missing out of ppw
1953 such as updating last write time */
1954 page_data = kmap(page);
1955 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
1956 /* if (rc < 0) should we set writebehind rc? */
1963 set_page_dirty(page);
1967 spin_lock(&inode->i_lock);
1968 if (pos > inode->i_size)
1969 i_size_write(inode, pos);
1970 spin_unlock(&inode->i_lock);
1974 page_cache_release(page);
1979 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1984 struct cifs_tcon *tcon;
1985 struct cifsFileInfo *smbfile = file->private_data;
1986 struct inode *inode = file->f_path.dentry->d_inode;
1987 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1989 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1992 mutex_lock(&inode->i_mutex);
1996 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1997 file->f_path.dentry->d_name.name, datasync);
1999 if (!CIFS_I(inode)->clientCanCacheRead) {
2000 rc = cifs_invalidate_mapping(inode);
2002 cFYI(1, "rc: %d during invalidate phase", rc);
2003 rc = 0; /* don't care about it in fsync */
2007 tcon = tlink_tcon(smbfile->tlink);
2008 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2009 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2012 mutex_unlock(&inode->i_mutex);
2016 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2020 struct cifs_tcon *tcon;
2021 struct cifsFileInfo *smbfile = file->private_data;
2022 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2023 struct inode *inode = file->f_mapping->host;
2025 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2028 mutex_lock(&inode->i_mutex);
2032 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2033 file->f_path.dentry->d_name.name, datasync);
2035 tcon = tlink_tcon(smbfile->tlink);
2036 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2037 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2040 mutex_unlock(&inode->i_mutex);
2045 * As file closes, flush all cached write data for this inode checking
2046 * for write behind errors.
2048 int cifs_flush(struct file *file, fl_owner_t id)
2050 struct inode *inode = file->f_path.dentry->d_inode;
2053 if (file->f_mode & FMODE_WRITE)
2054 rc = filemap_write_and_wait(inode->i_mapping);
2056 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
2062 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2067 for (i = 0; i < num_pages; i++) {
2068 pages[i] = alloc_page(__GFP_HIGHMEM);
2071 * save number of pages we have already allocated and
2072 * return with ENOMEM error
2083 for (i = 0; i < num_pages; i++)
2089 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2094 clen = min_t(const size_t, len, wsize);
2095 num_pages = clen / PAGE_CACHE_SIZE;
2096 if (clen % PAGE_CACHE_SIZE)
2106 cifs_iovec_write(struct file *file, const struct iovec *iov,
2107 unsigned long nr_segs, loff_t *poffset)
2109 unsigned int written;
2110 unsigned long num_pages, npages, i;
2111 size_t bytes, copied, len, cur_len;
2112 ssize_t total_written = 0;
2113 struct kvec *to_send;
2114 struct page **pages;
2116 struct inode *inode;
2117 struct cifsFileInfo *open_file;
2118 struct cifs_tcon *pTcon;
2119 struct cifs_sb_info *cifs_sb;
2120 struct cifs_io_parms io_parms;
2124 len = iov_length(iov, nr_segs);
2128 rc = generic_write_checks(file, poffset, &len, 0);
2132 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2133 num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2135 pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2139 to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2145 rc = cifs_write_allocate_pages(pages, num_pages);
2153 open_file = file->private_data;
2155 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2156 pid = open_file->pid;
2158 pid = current->tgid;
2160 pTcon = tlink_tcon(open_file->tlink);
2161 inode = file->f_path.dentry->d_inode;
2163 iov_iter_init(&it, iov, nr_segs, len, 0);
2167 size_t save_len = cur_len;
2168 for (i = 0; i < npages; i++) {
2169 bytes = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2170 copied = iov_iter_copy_from_user(pages[i], &it, 0,
2173 iov_iter_advance(&it, copied);
2174 to_send[i+1].iov_base = kmap(pages[i]);
2175 to_send[i+1].iov_len = copied;
2177 * If we didn't copy as much as we expected, then that
2178 * may mean we trod into an unmapped area. Stop copying
2179 * at that point. On the next pass through the big
2180 * loop, we'll likely end up getting a zero-length
2181 * write and bailing out of it.
2187 cur_len = save_len - cur_len;
2190 * If we have no data to send, then that probably means that
2191 * the copy above failed altogether. That's most likely because
2192 * the address in the iovec was bogus. Set the rc to -EFAULT,
2193 * free anything we allocated and bail out.
2198 total_written = -EFAULT;
2203 * i + 1 now represents the number of pages we actually used in
2204 * the copy phase above.
2206 npages = min(npages, i + 1);
2209 if (open_file->invalidHandle) {
2210 rc = cifs_reopen_file(open_file, false);
2214 io_parms.netfid = open_file->netfid;
2216 io_parms.tcon = pTcon;
2217 io_parms.offset = *poffset;
2218 io_parms.length = cur_len;
2219 rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2221 } while (rc == -EAGAIN);
2223 for (i = 0; i < npages; i++)
2228 total_written += written;
2229 cifs_update_eof(CIFS_I(inode), *poffset, written);
2230 *poffset += written;
2231 } else if (rc < 0) {
2237 /* get length and number of kvecs of the next write */
2238 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2241 if (total_written > 0) {
2242 spin_lock(&inode->i_lock);
2243 if (*poffset > inode->i_size)
2244 i_size_write(inode, *poffset);
2245 spin_unlock(&inode->i_lock);
2248 cifs_stats_bytes_written(pTcon, total_written);
2249 mark_inode_dirty_sync(inode);
2251 for (i = 0; i < num_pages; i++)
2256 return total_written;
2259 ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
2260 unsigned long nr_segs, loff_t pos)
2263 struct inode *inode;
2265 inode = iocb->ki_filp->f_path.dentry->d_inode;
2268 * BB - optimize the way when signing is disabled. We can drop this
2269 * extra memory-to-memory copying and use iovec buffers for constructing
2273 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2275 CIFS_I(inode)->invalid_mapping = true;
2282 ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2283 unsigned long nr_segs, loff_t pos)
2285 struct inode *inode;
2287 inode = iocb->ki_filp->f_path.dentry->d_inode;
2289 if (CIFS_I(inode)->clientCanCacheAll)
2290 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2293 * In strict cache mode we need to write the data to the server exactly
2294 * from the pos to pos+len-1 rather than flush all affected pages
2295 * because it may cause a error with mandatory locks on these pages but
2296 * not on the region from pos to ppos+len-1.
2299 return cifs_user_writev(iocb, iov, nr_segs, pos);
2303 cifs_iovec_read(struct file *file, const struct iovec *iov,
2304 unsigned long nr_segs, loff_t *poffset)
2309 unsigned int bytes_read = 0;
2310 size_t len, cur_len;
2312 struct cifs_sb_info *cifs_sb;
2313 struct cifs_tcon *pTcon;
2314 struct cifsFileInfo *open_file;
2315 struct smb_com_read_rsp *pSMBr;
2316 struct cifs_io_parms io_parms;
2324 len = iov_length(iov, nr_segs);
2329 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2331 /* FIXME: set up handlers for larger reads and/or convert to async */
2332 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2334 open_file = file->private_data;
2335 pTcon = tlink_tcon(open_file->tlink);
2337 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2338 pid = open_file->pid;
2340 pid = current->tgid;
2342 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2343 cFYI(1, "attempting read on write only file instance");
2345 for (total_read = 0; total_read < len; total_read += bytes_read) {
2346 cur_len = min_t(const size_t, len - total_read, rsize);
2350 while (rc == -EAGAIN) {
2351 int buf_type = CIFS_NO_BUFFER;
2352 if (open_file->invalidHandle) {
2353 rc = cifs_reopen_file(open_file, true);
2357 io_parms.netfid = open_file->netfid;
2359 io_parms.tcon = pTcon;
2360 io_parms.offset = *poffset;
2361 io_parms.length = cur_len;
2362 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2363 &read_data, &buf_type);
2364 pSMBr = (struct smb_com_read_rsp *)read_data;
2366 char *data_offset = read_data + 4 +
2367 le16_to_cpu(pSMBr->DataOffset);
2368 if (memcpy_toiovecend(iov, data_offset,
2369 iov_offset, bytes_read))
2371 if (buf_type == CIFS_SMALL_BUFFER)
2372 cifs_small_buf_release(read_data);
2373 else if (buf_type == CIFS_LARGE_BUFFER)
2374 cifs_buf_release(read_data);
2376 iov_offset += bytes_read;
2380 if (rc || (bytes_read == 0)) {
2388 cifs_stats_bytes_read(pTcon, bytes_read);
2389 *poffset += bytes_read;
2397 ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
2398 unsigned long nr_segs, loff_t pos)
2402 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2409 ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2410 unsigned long nr_segs, loff_t pos)
2412 struct inode *inode;
2414 inode = iocb->ki_filp->f_path.dentry->d_inode;
2416 if (CIFS_I(inode)->clientCanCacheRead)
2417 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2420 * In strict cache mode we need to read from the server all the time
2421 * if we don't have level II oplock because the server can delay mtime
2422 * change - so we can't make a decision about inode invalidating.
2423 * And we can also fail with pagereading if there are mandatory locks
2424 * on pages affected by this read but not on the region from pos to
2428 return cifs_user_readv(iocb, iov, nr_segs, pos);
2431 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
2435 unsigned int bytes_read = 0;
2436 unsigned int total_read;
2437 unsigned int current_read_size;
2439 struct cifs_sb_info *cifs_sb;
2440 struct cifs_tcon *pTcon;
2442 char *current_offset;
2443 struct cifsFileInfo *open_file;
2444 struct cifs_io_parms io_parms;
2445 int buf_type = CIFS_NO_BUFFER;
2449 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2451 /* FIXME: set up handlers for larger reads and/or convert to async */
2452 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2454 if (file->private_data == NULL) {
2459 open_file = file->private_data;
2460 pTcon = tlink_tcon(open_file->tlink);
2462 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2463 pid = open_file->pid;
2465 pid = current->tgid;
2467 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2468 cFYI(1, "attempting read on write only file instance");
2470 for (total_read = 0, current_offset = read_data;
2471 read_size > total_read;
2472 total_read += bytes_read, current_offset += bytes_read) {
2473 current_read_size = min_t(uint, read_size - total_read, rsize);
2475 /* For windows me and 9x we do not want to request more
2476 than it negotiated since it will refuse the read then */
2478 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
2479 current_read_size = min_t(uint, current_read_size,
2483 while (rc == -EAGAIN) {
2484 if (open_file->invalidHandle) {
2485 rc = cifs_reopen_file(open_file, true);
2489 io_parms.netfid = open_file->netfid;
2491 io_parms.tcon = pTcon;
2492 io_parms.offset = *poffset;
2493 io_parms.length = current_read_size;
2494 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2495 ¤t_offset, &buf_type);
2497 if (rc || (bytes_read == 0)) {
2505 cifs_stats_bytes_read(pTcon, total_read);
2506 *poffset += bytes_read;
2514 * If the page is mmap'ed into a process' page tables, then we need to make
2515 * sure that it doesn't change while being written back.
2518 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2520 struct page *page = vmf->page;
2523 return VM_FAULT_LOCKED;
2526 static struct vm_operations_struct cifs_file_vm_ops = {
2527 .fault = filemap_fault,
2528 .page_mkwrite = cifs_page_mkwrite,
2531 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2534 struct inode *inode = file->f_path.dentry->d_inode;
2538 if (!CIFS_I(inode)->clientCanCacheRead) {
2539 rc = cifs_invalidate_mapping(inode);
2544 rc = generic_file_mmap(file, vma);
2546 vma->vm_ops = &cifs_file_vm_ops;
2551 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2556 rc = cifs_revalidate_file(file);
2558 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
2562 rc = generic_file_mmap(file, vma);
2564 vma->vm_ops = &cifs_file_vm_ops;
2569 static int cifs_readpages(struct file *file, struct address_space *mapping,
2570 struct list_head *page_list, unsigned num_pages)
2573 struct list_head tmplist;
2574 struct cifsFileInfo *open_file = file->private_data;
2575 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2576 unsigned int rsize = cifs_sb->rsize;
2580 * Give up immediately if rsize is too small to read an entire page.
2581 * The VFS will fall back to readpage. We should never reach this
2582 * point however since we set ra_pages to 0 when the rsize is smaller
2583 * than a cache page.
2585 if (unlikely(rsize < PAGE_CACHE_SIZE))
2589 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2590 * immediately if the cookie is negative
2592 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2597 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2598 pid = open_file->pid;
2600 pid = current->tgid;
2603 INIT_LIST_HEAD(&tmplist);
2605 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2606 mapping, num_pages);
2609 * Start with the page at end of list and move it to private
2610 * list. Do the same with any following pages until we hit
2611 * the rsize limit, hit an index discontinuity, or run out of
2612 * pages. Issue the async read and then start the loop again
2613 * until the list is empty.
2615 * Note that list order is important. The page_list is in
2616 * the order of declining indexes. When we put the pages in
2617 * the rdata->pages, then we want them in increasing order.
2619 while (!list_empty(page_list)) {
2620 unsigned int bytes = PAGE_CACHE_SIZE;
2621 unsigned int expected_index;
2622 unsigned int nr_pages = 1;
2624 struct page *page, *tpage;
2625 struct cifs_readdata *rdata;
2627 page = list_entry(page_list->prev, struct page, lru);
2630 * Lock the page and put it in the cache. Since no one else
2631 * should have access to this page, we're safe to simply set
2632 * PG_locked without checking it first.
2634 __set_page_locked(page);
2635 rc = add_to_page_cache_locked(page, mapping,
2636 page->index, GFP_KERNEL);
2638 /* give up if we can't stick it in the cache */
2640 __clear_page_locked(page);
2644 /* move first page to the tmplist */
2645 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2646 list_move_tail(&page->lru, &tmplist);
2648 /* now try and add more pages onto the request */
2649 expected_index = page->index + 1;
2650 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2651 /* discontinuity ? */
2652 if (page->index != expected_index)
2655 /* would this page push the read over the rsize? */
2656 if (bytes + PAGE_CACHE_SIZE > rsize)
2659 __set_page_locked(page);
2660 if (add_to_page_cache_locked(page, mapping,
2661 page->index, GFP_KERNEL)) {
2662 __clear_page_locked(page);
2665 list_move_tail(&page->lru, &tmplist);
2666 bytes += PAGE_CACHE_SIZE;
2671 rdata = cifs_readdata_alloc(nr_pages);
2673 /* best to give up if we're out of mem */
2674 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2675 list_del(&page->lru);
2676 lru_cache_add_file(page);
2678 page_cache_release(page);
2684 spin_lock(&cifs_file_list_lock);
2685 cifsFileInfo_get(open_file);
2686 spin_unlock(&cifs_file_list_lock);
2687 rdata->cfile = open_file;
2688 rdata->mapping = mapping;
2689 rdata->offset = offset;
2690 rdata->bytes = bytes;
2692 list_splice_init(&tmplist, &rdata->pages);
2695 if (open_file->invalidHandle) {
2696 rc = cifs_reopen_file(open_file, true);
2700 rc = cifs_async_readv(rdata);
2701 } while (rc == -EAGAIN);
2704 list_for_each_entry_safe(page, tpage, &rdata->pages,
2706 list_del(&page->lru);
2707 lru_cache_add_file(page);
2709 page_cache_release(page);
2711 cifs_readdata_free(rdata);
2719 static int cifs_readpage_worker(struct file *file, struct page *page,
2725 /* Is the page cached? */
2726 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2730 page_cache_get(page);
2731 read_data = kmap(page);
2732 /* for reads over a certain size could initiate async read ahead */
2734 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
2739 cFYI(1, "Bytes read %d", rc);
2741 file->f_path.dentry->d_inode->i_atime =
2742 current_fs_time(file->f_path.dentry->d_inode->i_sb);
2744 if (PAGE_CACHE_SIZE > rc)
2745 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2747 flush_dcache_page(page);
2748 SetPageUptodate(page);
2750 /* send this page to the cache */
2751 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2757 page_cache_release(page);
2763 static int cifs_readpage(struct file *file, struct page *page)
2765 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2771 if (file->private_data == NULL) {
2777 cFYI(1, "readpage %p at offset %d 0x%x\n",
2778 page, (int)offset, (int)offset);
2780 rc = cifs_readpage_worker(file, page, &offset);
2788 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2790 struct cifsFileInfo *open_file;
2792 spin_lock(&cifs_file_list_lock);
2793 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2794 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
2795 spin_unlock(&cifs_file_list_lock);
2799 spin_unlock(&cifs_file_list_lock);
2803 /* We do not want to update the file size from server for inodes
2804 open for write - to avoid races with writepage extending
2805 the file - in the future we could consider allowing
2806 refreshing the inode only on increases in the file size
2807 but this is tricky to do without racing with writebehind
2808 page caching in the current Linux kernel design */
2809 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
2814 if (is_inode_writable(cifsInode)) {
2815 /* This inode is open for write at least once */
2816 struct cifs_sb_info *cifs_sb;
2818 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
2819 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
2820 /* since no page cache to corrupt on directio
2821 we can change size safely */
2825 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
2833 static int cifs_write_begin(struct file *file, struct address_space *mapping,
2834 loff_t pos, unsigned len, unsigned flags,
2835 struct page **pagep, void **fsdata)
2837 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2838 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
2839 loff_t page_start = pos & PAGE_MASK;
2844 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
2846 page = grab_cache_page_write_begin(mapping, index, flags);
2852 if (PageUptodate(page))
2856 * If we write a full page it will be up to date, no need to read from
2857 * the server. If the write is short, we'll end up doing a sync write
2860 if (len == PAGE_CACHE_SIZE)
2864 * optimize away the read when we have an oplock, and we're not
2865 * expecting to use any of the data we'd be reading in. That
2866 * is, when the page lies beyond the EOF, or straddles the EOF
2867 * and the write will cover all of the existing data.
2869 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2870 i_size = i_size_read(mapping->host);
2871 if (page_start >= i_size ||
2872 (offset == 0 && (pos + len) >= i_size)) {
2873 zero_user_segments(page, 0, offset,
2877 * PageChecked means that the parts of the page
2878 * to which we're not writing are considered up
2879 * to date. Once the data is copied to the
2880 * page, it can be set uptodate.
2882 SetPageChecked(page);
2887 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2889 * might as well read a page, it is fast enough. If we get
2890 * an error, we don't need to return it. cifs_write_end will
2891 * do a sync write instead since PG_uptodate isn't set.
2893 cifs_readpage_worker(file, page, &page_start);
2895 /* we could try using another file handle if there is one -
2896 but how would we lock it to prevent close of that handle
2897 racing with this read? In any case
2898 this will be written out by write_end so is fine */
2905 static int cifs_release_page(struct page *page, gfp_t gfp)
2907 if (PagePrivate(page))
2910 return cifs_fscache_release_page(page, gfp);
2913 static void cifs_invalidate_page(struct page *page, unsigned long offset)
2915 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2918 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2921 static int cifs_launder_page(struct page *page)
2924 loff_t range_start = page_offset(page);
2925 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2926 struct writeback_control wbc = {
2927 .sync_mode = WB_SYNC_ALL,
2929 .range_start = range_start,
2930 .range_end = range_end,
2933 cFYI(1, "Launder page: %p", page);
2935 if (clear_page_dirty_for_io(page))
2936 rc = cifs_writepage_locked(page, &wbc);
2938 cifs_fscache_invalidate_page(page, page->mapping->host);
2942 void cifs_oplock_break(struct work_struct *work)
2944 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2946 struct inode *inode = cfile->dentry->d_inode;
2947 struct cifsInodeInfo *cinode = CIFS_I(inode);
2950 if (inode && S_ISREG(inode->i_mode)) {
2951 if (cinode->clientCanCacheRead)
2952 break_lease(inode, O_RDONLY);
2954 break_lease(inode, O_WRONLY);
2955 rc = filemap_fdatawrite(inode->i_mapping);
2956 if (cinode->clientCanCacheRead == 0) {
2957 rc = filemap_fdatawait(inode->i_mapping);
2958 mapping_set_error(inode->i_mapping, rc);
2959 invalidate_remote_inode(inode);
2961 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
2964 rc = cifs_push_locks(cfile);
2966 cERROR(1, "Push locks rc = %d", rc);
2969 * releasing stale oplock after recent reconnect of smb session using
2970 * a now incorrect file handle is not a data integrity issue but do
2971 * not bother sending an oplock release if session to server still is
2972 * disconnected since oplock already released by the server
2974 if (!cfile->oplock_break_cancelled) {
2975 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2976 current->tgid, 0, 0, 0, 0,
2977 LOCKING_ANDX_OPLOCK_RELEASE, false,
2978 cinode->clientCanCacheRead ? 1 : 0);
2979 cFYI(1, "Oplock release rc = %d", rc);
2983 const struct address_space_operations cifs_addr_ops = {
2984 .readpage = cifs_readpage,
2985 .readpages = cifs_readpages,
2986 .writepage = cifs_writepage,
2987 .writepages = cifs_writepages,
2988 .write_begin = cifs_write_begin,
2989 .write_end = cifs_write_end,
2990 .set_page_dirty = __set_page_dirty_nobuffers,
2991 .releasepage = cifs_release_page,
2992 .invalidatepage = cifs_invalidate_page,
2993 .launder_page = cifs_launder_page,
2997 * cifs_readpages requires the server to support a buffer large enough to
2998 * contain the header plus one complete page of data. Otherwise, we need
2999 * to leave cifs_readpages out of the address space operations.
3001 const struct address_space_operations cifs_addr_ops_smallbuf = {
3002 .readpage = cifs_readpage,
3003 .writepage = cifs_writepage,
3004 .writepages = cifs_writepages,
3005 .write_begin = cifs_write_begin,
3006 .write_end = cifs_write_end,
3007 .set_page_dirty = __set_page_dirty_nobuffers,
3008 .releasepage = cifs_release_page,
3009 .invalidatepage = cifs_invalidate_page,
3010 .launder_page = cifs_launder_page,