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"
47 static inline int cifs_convert_flags(unsigned int flags)
49 if ((flags & O_ACCMODE) == O_RDONLY)
51 else if ((flags & O_ACCMODE) == O_WRONLY)
53 else if ((flags & O_ACCMODE) == O_RDWR) {
54 /* GENERIC_ALL is too much permission to request
55 can cause unnecessary access denied on create */
56 /* return GENERIC_ALL; */
57 return (GENERIC_READ | GENERIC_WRITE);
60 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
61 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
65 static u32 cifs_posix_convert_flags(unsigned int flags)
69 if ((flags & O_ACCMODE) == O_RDONLY)
70 posix_flags = SMB_O_RDONLY;
71 else if ((flags & O_ACCMODE) == O_WRONLY)
72 posix_flags = SMB_O_WRONLY;
73 else if ((flags & O_ACCMODE) == O_RDWR)
74 posix_flags = SMB_O_RDWR;
76 if (flags & O_CREAT) {
77 posix_flags |= SMB_O_CREAT;
79 posix_flags |= SMB_O_EXCL;
80 } else if (flags & O_EXCL)
81 cifs_dbg(FYI, "Application %s pid %d has incorrectly set O_EXCL flag but not O_CREAT on file open. Ignoring O_EXCL\n",
82 current->comm, current->tgid);
85 posix_flags |= SMB_O_TRUNC;
86 /* be safe and imply O_SYNC for O_DSYNC */
88 posix_flags |= SMB_O_SYNC;
89 if (flags & O_DIRECTORY)
90 posix_flags |= SMB_O_DIRECTORY;
91 if (flags & O_NOFOLLOW)
92 posix_flags |= SMB_O_NOFOLLOW;
94 posix_flags |= SMB_O_DIRECT;
99 static inline int cifs_get_disposition(unsigned int flags)
101 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
103 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
104 return FILE_OVERWRITE_IF;
105 else if ((flags & O_CREAT) == O_CREAT)
107 else if ((flags & O_TRUNC) == O_TRUNC)
108 return FILE_OVERWRITE;
113 int cifs_posix_open(char *full_path, struct inode **pinode,
114 struct super_block *sb, int mode, unsigned int f_flags,
115 __u32 *poplock, __u16 *pnetfid, unsigned int xid)
118 FILE_UNIX_BASIC_INFO *presp_data;
119 __u32 posix_flags = 0;
120 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
121 struct cifs_fattr fattr;
122 struct tcon_link *tlink;
123 struct cifs_tcon *tcon;
125 cifs_dbg(FYI, "posix open %s\n", full_path);
127 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
128 if (presp_data == NULL)
131 tlink = cifs_sb_tlink(cifs_sb);
137 tcon = tlink_tcon(tlink);
138 mode &= ~current_umask();
140 posix_flags = cifs_posix_convert_flags(f_flags);
141 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
142 poplock, full_path, cifs_sb->local_nls,
143 cifs_remap(cifs_sb));
144 cifs_put_tlink(tlink);
149 if (presp_data->Type == cpu_to_le32(-1))
150 goto posix_open_ret; /* open ok, caller does qpathinfo */
153 goto posix_open_ret; /* caller does not need info */
155 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
157 /* get new inode and set it up */
158 if (*pinode == NULL) {
159 cifs_fill_uniqueid(sb, &fattr);
160 *pinode = cifs_iget(sb, &fattr);
166 cifs_fattr_to_inode(*pinode, &fattr);
175 cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
176 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
177 struct cifs_fid *fid, unsigned int xid)
182 int create_options = CREATE_NOT_DIR;
184 struct TCP_Server_Info *server = tcon->ses->server;
185 struct cifs_open_parms oparms;
187 if (!server->ops->open)
190 desired_access = cifs_convert_flags(f_flags);
192 /*********************************************************************
193 * open flag mapping table:
195 * POSIX Flag CIFS Disposition
196 * ---------- ----------------
197 * O_CREAT FILE_OPEN_IF
198 * O_CREAT | O_EXCL FILE_CREATE
199 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
200 * O_TRUNC FILE_OVERWRITE
201 * none of the above FILE_OPEN
203 * Note that there is not a direct match between disposition
204 * FILE_SUPERSEDE (ie create whether or not file exists although
205 * O_CREAT | O_TRUNC is similar but truncates the existing
206 * file rather than creating a new file as FILE_SUPERSEDE does
207 * (which uses the attributes / metadata passed in on open call)
209 *? O_SYNC is a reasonable match to CIFS writethrough flag
210 *? and the read write flags match reasonably. O_LARGEFILE
211 *? is irrelevant because largefile support is always used
212 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
213 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
214 *********************************************************************/
216 disposition = cifs_get_disposition(f_flags);
218 /* BB pass O_SYNC flag through on file attributes .. BB */
220 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
224 if (backup_cred(cifs_sb))
225 create_options |= CREATE_OPEN_BACKUP_INTENT;
228 oparms.cifs_sb = cifs_sb;
229 oparms.desired_access = desired_access;
230 oparms.create_options = create_options;
231 oparms.disposition = disposition;
232 oparms.path = full_path;
234 oparms.reconnect = false;
236 rc = server->ops->open(xid, &oparms, oplock, buf);
242 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
245 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
254 cifs_has_mand_locks(struct cifsInodeInfo *cinode)
256 struct cifs_fid_locks *cur;
257 bool has_locks = false;
259 down_read(&cinode->lock_sem);
260 list_for_each_entry(cur, &cinode->llist, llist) {
261 if (!list_empty(&cur->locks)) {
266 up_read(&cinode->lock_sem);
270 struct cifsFileInfo *
271 cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
272 struct tcon_link *tlink, __u32 oplock)
274 struct dentry *dentry = file->f_path.dentry;
275 struct inode *inode = d_inode(dentry);
276 struct cifsInodeInfo *cinode = CIFS_I(inode);
277 struct cifsFileInfo *cfile;
278 struct cifs_fid_locks *fdlocks;
279 struct cifs_tcon *tcon = tlink_tcon(tlink);
280 struct TCP_Server_Info *server = tcon->ses->server;
282 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
286 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
292 INIT_LIST_HEAD(&fdlocks->locks);
293 fdlocks->cfile = cfile;
294 cfile->llist = fdlocks;
295 down_write(&cinode->lock_sem);
296 list_add(&fdlocks->llist, &cinode->llist);
297 up_write(&cinode->lock_sem);
300 cfile->pid = current->tgid;
301 cfile->uid = current_fsuid();
302 cfile->dentry = dget(dentry);
303 cfile->f_flags = file->f_flags;
304 cfile->invalidHandle = false;
305 cfile->tlink = cifs_get_tlink(tlink);
306 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
307 mutex_init(&cfile->fh_mutex);
308 spin_lock_init(&cfile->file_info_lock);
310 cifs_sb_active(inode->i_sb);
313 * If the server returned a read oplock and we have mandatory brlocks,
314 * set oplock level to None.
316 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
317 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
321 spin_lock(&tcon->open_file_lock);
322 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
323 oplock = fid->pending_open->oplock;
324 list_del(&fid->pending_open->olist);
326 fid->purge_cache = false;
327 server->ops->set_fid(cfile, fid, oplock);
329 list_add(&cfile->tlist, &tcon->openFileList);
331 /* if readable file instance put first in list*/
332 if (file->f_mode & FMODE_READ)
333 list_add(&cfile->flist, &cinode->openFileList);
335 list_add_tail(&cfile->flist, &cinode->openFileList);
336 spin_unlock(&tcon->open_file_lock);
338 if (fid->purge_cache)
339 cifs_zap_mapping(inode);
341 file->private_data = cfile;
345 struct cifsFileInfo *
346 cifsFileInfo_get(struct cifsFileInfo *cifs_file)
348 spin_lock(&cifs_file->file_info_lock);
349 cifsFileInfo_get_locked(cifs_file);
350 spin_unlock(&cifs_file->file_info_lock);
355 * Release a reference on the file private data. This may involve closing
356 * the filehandle out on the server. Must be called without holding
357 * tcon->open_file_lock and cifs_file->file_info_lock.
359 void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
361 struct inode *inode = d_inode(cifs_file->dentry);
362 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
363 struct TCP_Server_Info *server = tcon->ses->server;
364 struct cifsInodeInfo *cifsi = CIFS_I(inode);
365 struct super_block *sb = inode->i_sb;
366 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
367 struct cifsLockInfo *li, *tmp;
369 struct cifs_pending_open open;
370 bool oplock_break_cancelled;
372 spin_lock(&tcon->open_file_lock);
374 spin_lock(&cifs_file->file_info_lock);
375 if (--cifs_file->count > 0) {
376 spin_unlock(&cifs_file->file_info_lock);
377 spin_unlock(&tcon->open_file_lock);
380 spin_unlock(&cifs_file->file_info_lock);
382 if (server->ops->get_lease_key)
383 server->ops->get_lease_key(inode, &fid);
385 /* store open in pending opens to make sure we don't miss lease break */
386 cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
388 /* remove it from the lists */
389 list_del(&cifs_file->flist);
390 list_del(&cifs_file->tlist);
392 if (list_empty(&cifsi->openFileList)) {
393 cifs_dbg(FYI, "closing last open instance for inode %p\n",
394 d_inode(cifs_file->dentry));
396 * In strict cache mode we need invalidate mapping on the last
397 * close because it may cause a error when we open this file
398 * again and get at least level II oplock.
400 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
401 set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
402 cifs_set_oplock_level(cifsi, 0);
405 spin_unlock(&tcon->open_file_lock);
407 oplock_break_cancelled = cancel_work_sync(&cifs_file->oplock_break);
409 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
410 struct TCP_Server_Info *server = tcon->ses->server;
414 if (server->ops->close)
415 server->ops->close(xid, tcon, &cifs_file->fid);
419 if (oplock_break_cancelled)
420 cifs_done_oplock_break(cifsi);
422 cifs_del_pending_open(&open);
425 * Delete any outstanding lock records. We'll lose them when the file
428 down_write(&cifsi->lock_sem);
429 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
430 list_del(&li->llist);
431 cifs_del_lock_waiters(li);
434 list_del(&cifs_file->llist->llist);
435 kfree(cifs_file->llist);
436 up_write(&cifsi->lock_sem);
438 cifs_put_tlink(cifs_file->tlink);
439 dput(cifs_file->dentry);
440 cifs_sb_deactive(sb);
444 int cifs_open(struct inode *inode, struct file *file)
450 struct cifs_sb_info *cifs_sb;
451 struct TCP_Server_Info *server;
452 struct cifs_tcon *tcon;
453 struct tcon_link *tlink;
454 struct cifsFileInfo *cfile = NULL;
455 char *full_path = NULL;
456 bool posix_open_ok = false;
458 struct cifs_pending_open open;
462 cifs_sb = CIFS_SB(inode->i_sb);
463 tlink = cifs_sb_tlink(cifs_sb);
466 return PTR_ERR(tlink);
468 tcon = tlink_tcon(tlink);
469 server = tcon->ses->server;
471 full_path = build_path_from_dentry(file->f_path.dentry);
472 if (full_path == NULL) {
477 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
478 inode, file->f_flags, full_path);
480 if (file->f_flags & O_DIRECT &&
481 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
482 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
483 file->f_op = &cifs_file_direct_nobrl_ops;
485 file->f_op = &cifs_file_direct_ops;
493 if (!tcon->broken_posix_open && tcon->unix_ext &&
494 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
495 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
496 /* can not refresh inode info since size could be stale */
497 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
498 cifs_sb->mnt_file_mode /* ignored */,
499 file->f_flags, &oplock, &fid.netfid, xid);
501 cifs_dbg(FYI, "posix open succeeded\n");
502 posix_open_ok = true;
503 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
504 if (tcon->ses->serverNOS)
505 cifs_dbg(VFS, "server %s of type %s returned unexpected error on SMB posix open, disabling posix open support. Check if server update available.\n",
506 tcon->ses->serverName,
507 tcon->ses->serverNOS);
508 tcon->broken_posix_open = true;
509 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
510 (rc != -EOPNOTSUPP)) /* path not found or net err */
513 * Else fallthrough to retry open the old way on network i/o
518 if (server->ops->get_lease_key)
519 server->ops->get_lease_key(inode, &fid);
521 cifs_add_pending_open(&fid, tlink, &open);
523 if (!posix_open_ok) {
524 if (server->ops->get_lease_key)
525 server->ops->get_lease_key(inode, &fid);
527 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
528 file->f_flags, &oplock, &fid, xid);
530 cifs_del_pending_open(&open);
535 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
537 if (server->ops->close)
538 server->ops->close(xid, tcon, &fid);
539 cifs_del_pending_open(&open);
544 cifs_fscache_set_inode_cookie(inode, file);
546 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
548 * Time to set mode which we can not set earlier due to
549 * problems creating new read-only files.
551 struct cifs_unix_set_info_args args = {
552 .mode = inode->i_mode,
553 .uid = INVALID_UID, /* no change */
554 .gid = INVALID_GID, /* no change */
555 .ctime = NO_CHANGE_64,
556 .atime = NO_CHANGE_64,
557 .mtime = NO_CHANGE_64,
560 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
567 cifs_put_tlink(tlink);
571 static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
574 * Try to reacquire byte range locks that were released when session
575 * to server was lost.
578 cifs_relock_file(struct cifsFileInfo *cfile)
580 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
581 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
582 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
585 down_read(&cinode->lock_sem);
586 if (cinode->can_cache_brlcks) {
587 /* can cache locks - no need to relock */
588 up_read(&cinode->lock_sem);
592 if (cap_unix(tcon->ses) &&
593 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
594 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
595 rc = cifs_push_posix_locks(cfile);
597 rc = tcon->ses->server->ops->push_mand_locks(cfile);
599 up_read(&cinode->lock_sem);
604 cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
609 struct cifs_sb_info *cifs_sb;
610 struct cifs_tcon *tcon;
611 struct TCP_Server_Info *server;
612 struct cifsInodeInfo *cinode;
614 char *full_path = NULL;
616 int disposition = FILE_OPEN;
617 int create_options = CREATE_NOT_DIR;
618 struct cifs_open_parms oparms;
621 mutex_lock(&cfile->fh_mutex);
622 if (!cfile->invalidHandle) {
623 mutex_unlock(&cfile->fh_mutex);
629 inode = d_inode(cfile->dentry);
630 cifs_sb = CIFS_SB(inode->i_sb);
631 tcon = tlink_tcon(cfile->tlink);
632 server = tcon->ses->server;
635 * Can not grab rename sem here because various ops, including those
636 * that already have the rename sem can end up causing writepage to get
637 * called and if the server was down that means we end up here, and we
638 * can never tell if the caller already has the rename_sem.
640 full_path = build_path_from_dentry(cfile->dentry);
641 if (full_path == NULL) {
643 mutex_unlock(&cfile->fh_mutex);
648 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
649 inode, cfile->f_flags, full_path);
651 if (tcon->ses->server->oplocks)
656 if (tcon->unix_ext && cap_unix(tcon->ses) &&
657 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
658 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
660 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
661 * original open. Must mask them off for a reopen.
663 unsigned int oflags = cfile->f_flags &
664 ~(O_CREAT | O_EXCL | O_TRUNC);
666 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
667 cifs_sb->mnt_file_mode /* ignored */,
668 oflags, &oplock, &cfile->fid.netfid, xid);
670 cifs_dbg(FYI, "posix reopen succeeded\n");
671 oparms.reconnect = true;
675 * fallthrough to retry open the old way on errors, especially
676 * in the reconnect path it is important to retry hard
680 desired_access = cifs_convert_flags(cfile->f_flags);
682 if (backup_cred(cifs_sb))
683 create_options |= CREATE_OPEN_BACKUP_INTENT;
685 if (server->ops->get_lease_key)
686 server->ops->get_lease_key(inode, &cfile->fid);
689 oparms.cifs_sb = cifs_sb;
690 oparms.desired_access = desired_access;
691 oparms.create_options = create_options;
692 oparms.disposition = disposition;
693 oparms.path = full_path;
694 oparms.fid = &cfile->fid;
695 oparms.reconnect = true;
698 * Can not refresh inode by passing in file_info buf to be returned by
699 * ops->open and then calling get_inode_info with returned buf since
700 * file might have write behind data that needs to be flushed and server
701 * version of file size can be stale. If we knew for sure that inode was
702 * not dirty locally we could do this.
704 rc = server->ops->open(xid, &oparms, &oplock, NULL);
705 if (rc == -ENOENT && oparms.reconnect == false) {
706 /* durable handle timeout is expired - open the file again */
707 rc = server->ops->open(xid, &oparms, &oplock, NULL);
708 /* indicate that we need to relock the file */
709 oparms.reconnect = true;
713 mutex_unlock(&cfile->fh_mutex);
714 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
715 cifs_dbg(FYI, "oplock: %d\n", oplock);
716 goto reopen_error_exit;
720 cfile->invalidHandle = false;
721 mutex_unlock(&cfile->fh_mutex);
722 cinode = CIFS_I(inode);
725 rc = filemap_write_and_wait(inode->i_mapping);
726 mapping_set_error(inode->i_mapping, rc);
729 rc = cifs_get_inode_info_unix(&inode, full_path,
732 rc = cifs_get_inode_info(&inode, full_path, NULL,
733 inode->i_sb, xid, NULL);
736 * Else we are writing out data to server already and could deadlock if
737 * we tried to flush data, and since we do not know if we have data that
738 * would invalidate the current end of file on the server we can not go
739 * to the server to get the new inode info.
742 server->ops->set_fid(cfile, &cfile->fid, oplock);
743 if (oparms.reconnect)
744 cifs_relock_file(cfile);
752 int cifs_close(struct inode *inode, struct file *file)
754 if (file->private_data != NULL) {
755 cifsFileInfo_put(file->private_data);
756 file->private_data = NULL;
759 /* return code from the ->release op is always ignored */
763 int cifs_closedir(struct inode *inode, struct file *file)
767 struct cifsFileInfo *cfile = file->private_data;
768 struct cifs_tcon *tcon;
769 struct TCP_Server_Info *server;
772 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
778 tcon = tlink_tcon(cfile->tlink);
779 server = tcon->ses->server;
781 cifs_dbg(FYI, "Freeing private data in close dir\n");
782 spin_lock(&cfile->file_info_lock);
783 if (server->ops->dir_needs_close(cfile)) {
784 cfile->invalidHandle = true;
785 spin_unlock(&cfile->file_info_lock);
786 if (server->ops->close_dir)
787 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
790 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
791 /* not much we can do if it fails anyway, ignore rc */
794 spin_unlock(&cfile->file_info_lock);
796 buf = cfile->srch_inf.ntwrk_buf_start;
798 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
799 cfile->srch_inf.ntwrk_buf_start = NULL;
800 if (cfile->srch_inf.smallBuf)
801 cifs_small_buf_release(buf);
803 cifs_buf_release(buf);
806 cifs_put_tlink(cfile->tlink);
807 kfree(file->private_data);
808 file->private_data = NULL;
809 /* BB can we lock the filestruct while this is going on? */
814 static struct cifsLockInfo *
815 cifs_lock_init(__u64 offset, __u64 length, __u8 type)
817 struct cifsLockInfo *lock =
818 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
821 lock->offset = offset;
822 lock->length = length;
824 lock->pid = current->tgid;
825 INIT_LIST_HEAD(&lock->blist);
826 init_waitqueue_head(&lock->block_q);
831 cifs_del_lock_waiters(struct cifsLockInfo *lock)
833 struct cifsLockInfo *li, *tmp;
834 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
835 list_del_init(&li->blist);
836 wake_up(&li->block_q);
840 #define CIFS_LOCK_OP 0
841 #define CIFS_READ_OP 1
842 #define CIFS_WRITE_OP 2
844 /* @rw_check : 0 - no op, 1 - read, 2 - write */
846 cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
847 __u64 length, __u8 type, struct cifsFileInfo *cfile,
848 struct cifsLockInfo **conf_lock, int rw_check)
850 struct cifsLockInfo *li;
851 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
852 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
854 list_for_each_entry(li, &fdlocks->locks, llist) {
855 if (offset + length <= li->offset ||
856 offset >= li->offset + li->length)
858 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
859 server->ops->compare_fids(cfile, cur_cfile)) {
860 /* shared lock prevents write op through the same fid */
861 if (!(li->type & server->vals->shared_lock_type) ||
862 rw_check != CIFS_WRITE_OP)
865 if ((type & server->vals->shared_lock_type) &&
866 ((server->ops->compare_fids(cfile, cur_cfile) &&
867 current->tgid == li->pid) || type == li->type))
877 cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
878 __u8 type, struct cifsLockInfo **conf_lock,
882 struct cifs_fid_locks *cur;
883 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
885 list_for_each_entry(cur, &cinode->llist, llist) {
886 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
887 cfile, conf_lock, rw_check);
896 * Check if there is another lock that prevents us to set the lock (mandatory
897 * style). If such a lock exists, update the flock structure with its
898 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
899 * or leave it the same if we can't. Returns 0 if we don't need to request to
900 * the server or 1 otherwise.
903 cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
904 __u8 type, struct file_lock *flock)
907 struct cifsLockInfo *conf_lock;
908 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
909 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
912 down_read(&cinode->lock_sem);
914 exist = cifs_find_lock_conflict(cfile, offset, length, type,
915 &conf_lock, CIFS_LOCK_OP);
917 flock->fl_start = conf_lock->offset;
918 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
919 flock->fl_pid = conf_lock->pid;
920 if (conf_lock->type & server->vals->shared_lock_type)
921 flock->fl_type = F_RDLCK;
923 flock->fl_type = F_WRLCK;
924 } else if (!cinode->can_cache_brlcks)
927 flock->fl_type = F_UNLCK;
929 up_read(&cinode->lock_sem);
934 cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
936 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
937 down_write(&cinode->lock_sem);
938 list_add_tail(&lock->llist, &cfile->llist->locks);
939 up_write(&cinode->lock_sem);
943 * Set the byte-range lock (mandatory style). Returns:
944 * 1) 0, if we set the lock and don't need to request to the server;
945 * 2) 1, if no locks prevent us but we need to request to the server;
946 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
949 cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
952 struct cifsLockInfo *conf_lock;
953 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
959 down_write(&cinode->lock_sem);
961 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
962 lock->type, &conf_lock, CIFS_LOCK_OP);
963 if (!exist && cinode->can_cache_brlcks) {
964 list_add_tail(&lock->llist, &cfile->llist->locks);
965 up_write(&cinode->lock_sem);
974 list_add_tail(&lock->blist, &conf_lock->blist);
975 up_write(&cinode->lock_sem);
976 rc = wait_event_interruptible(lock->block_q,
977 (lock->blist.prev == &lock->blist) &&
978 (lock->blist.next == &lock->blist));
981 down_write(&cinode->lock_sem);
982 list_del_init(&lock->blist);
985 up_write(&cinode->lock_sem);
990 * Check if there is another lock that prevents us to set the lock (posix
991 * style). If such a lock exists, update the flock structure with its
992 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
993 * or leave it the same if we can't. Returns 0 if we don't need to request to
994 * the server or 1 otherwise.
997 cifs_posix_lock_test(struct file *file, struct file_lock *flock)
1000 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1001 unsigned char saved_type = flock->fl_type;
1003 if ((flock->fl_flags & FL_POSIX) == 0)
1006 down_read(&cinode->lock_sem);
1007 posix_test_lock(file, flock);
1009 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1010 flock->fl_type = saved_type;
1014 up_read(&cinode->lock_sem);
1019 * Set the byte-range lock (posix style). Returns:
1020 * 1) 0, if we set the lock and don't need to request to the server;
1021 * 2) 1, if we need to request to the server;
1022 * 3) <0, if the error occurs while setting the lock.
1025 cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1027 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
1030 if ((flock->fl_flags & FL_POSIX) == 0)
1034 down_write(&cinode->lock_sem);
1035 if (!cinode->can_cache_brlcks) {
1036 up_write(&cinode->lock_sem);
1040 rc = posix_lock_file(file, flock, NULL);
1041 up_write(&cinode->lock_sem);
1042 if (rc == FILE_LOCK_DEFERRED) {
1043 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
1046 posix_unblock_lock(flock);
1052 cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
1055 int rc = 0, stored_rc;
1056 struct cifsLockInfo *li, *tmp;
1057 struct cifs_tcon *tcon;
1058 unsigned int num, max_num, max_buf;
1059 LOCKING_ANDX_RANGE *buf, *cur;
1060 int types[] = {LOCKING_ANDX_LARGE_FILES,
1061 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1065 tcon = tlink_tcon(cfile->tlink);
1068 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1069 * and check it for zero before using.
1071 max_buf = tcon->ses->server->maxBuf;
1077 max_num = (max_buf - sizeof(struct smb_hdr)) /
1078 sizeof(LOCKING_ANDX_RANGE);
1079 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1085 for (i = 0; i < 2; i++) {
1088 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1089 if (li->type != types[i])
1091 cur->Pid = cpu_to_le16(li->pid);
1092 cur->LengthLow = cpu_to_le32((u32)li->length);
1093 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1094 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1095 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1096 if (++num == max_num) {
1097 stored_rc = cifs_lockv(xid, tcon,
1099 (__u8)li->type, 0, num,
1110 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1111 (__u8)types[i], 0, num, buf);
1122 struct lock_to_push {
1123 struct list_head llist;
1132 cifs_push_posix_locks(struct cifsFileInfo *cfile)
1134 struct inode *inode = d_inode(cfile->dentry);
1135 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1136 struct file_lock *flock;
1137 struct file_lock_context *flctx = inode->i_flctx;
1138 unsigned int count = 0, i;
1139 int rc = 0, xid, type;
1140 struct list_head locks_to_send, *el;
1141 struct lock_to_push *lck, *tmp;
1149 spin_lock(&flctx->flc_lock);
1150 list_for_each(el, &flctx->flc_posix) {
1153 spin_unlock(&flctx->flc_lock);
1155 INIT_LIST_HEAD(&locks_to_send);
1158 * Allocating count locks is enough because no FL_POSIX locks can be
1159 * added to the list while we are holding cinode->lock_sem that
1160 * protects locking operations of this inode.
1162 for (i = 0; i < count; i++) {
1163 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1168 list_add_tail(&lck->llist, &locks_to_send);
1171 el = locks_to_send.next;
1172 spin_lock(&flctx->flc_lock);
1173 list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
1174 if (el == &locks_to_send) {
1176 * The list ended. We don't have enough allocated
1177 * structures - something is really wrong.
1179 cifs_dbg(VFS, "Can't push all brlocks!\n");
1182 length = 1 + flock->fl_end - flock->fl_start;
1183 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1187 lck = list_entry(el, struct lock_to_push, llist);
1188 lck->pid = flock->fl_pid;
1189 lck->netfid = cfile->fid.netfid;
1190 lck->length = length;
1192 lck->offset = flock->fl_start;
1194 spin_unlock(&flctx->flc_lock);
1196 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1199 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1200 lck->offset, lck->length, NULL,
1204 list_del(&lck->llist);
1212 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1213 list_del(&lck->llist);
1220 cifs_push_locks(struct cifsFileInfo *cfile)
1222 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1223 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1224 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1227 /* we are going to update can_cache_brlcks here - need a write access */
1228 down_write(&cinode->lock_sem);
1229 if (!cinode->can_cache_brlcks) {
1230 up_write(&cinode->lock_sem);
1234 if (cap_unix(tcon->ses) &&
1235 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1236 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1237 rc = cifs_push_posix_locks(cfile);
1239 rc = tcon->ses->server->ops->push_mand_locks(cfile);
1241 cinode->can_cache_brlcks = false;
1242 up_write(&cinode->lock_sem);
1247 cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
1248 bool *wait_flag, struct TCP_Server_Info *server)
1250 if (flock->fl_flags & FL_POSIX)
1251 cifs_dbg(FYI, "Posix\n");
1252 if (flock->fl_flags & FL_FLOCK)
1253 cifs_dbg(FYI, "Flock\n");
1254 if (flock->fl_flags & FL_SLEEP) {
1255 cifs_dbg(FYI, "Blocking lock\n");
1258 if (flock->fl_flags & FL_ACCESS)
1259 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
1260 if (flock->fl_flags & FL_LEASE)
1261 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
1262 if (flock->fl_flags &
1263 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1264 FL_ACCESS | FL_LEASE | FL_CLOSE)))
1265 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
1267 *type = server->vals->large_lock_type;
1268 if (flock->fl_type == F_WRLCK) {
1269 cifs_dbg(FYI, "F_WRLCK\n");
1270 *type |= server->vals->exclusive_lock_type;
1272 } else if (flock->fl_type == F_UNLCK) {
1273 cifs_dbg(FYI, "F_UNLCK\n");
1274 *type |= server->vals->unlock_lock_type;
1276 /* Check if unlock includes more than one lock range */
1277 } else if (flock->fl_type == F_RDLCK) {
1278 cifs_dbg(FYI, "F_RDLCK\n");
1279 *type |= server->vals->shared_lock_type;
1281 } else if (flock->fl_type == F_EXLCK) {
1282 cifs_dbg(FYI, "F_EXLCK\n");
1283 *type |= server->vals->exclusive_lock_type;
1285 } else if (flock->fl_type == F_SHLCK) {
1286 cifs_dbg(FYI, "F_SHLCK\n");
1287 *type |= server->vals->shared_lock_type;
1290 cifs_dbg(FYI, "Unknown type of lock\n");
1294 cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
1295 bool wait_flag, bool posix_lck, unsigned int xid)
1298 __u64 length = 1 + flock->fl_end - flock->fl_start;
1299 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1300 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1301 struct TCP_Server_Info *server = tcon->ses->server;
1302 __u16 netfid = cfile->fid.netfid;
1305 int posix_lock_type;
1307 rc = cifs_posix_lock_test(file, flock);
1311 if (type & server->vals->shared_lock_type)
1312 posix_lock_type = CIFS_RDLCK;
1314 posix_lock_type = CIFS_WRLCK;
1315 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1316 flock->fl_start, length, flock,
1317 posix_lock_type, wait_flag);
1321 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
1325 /* BB we could chain these into one lock request BB */
1326 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1329 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1331 flock->fl_type = F_UNLCK;
1333 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1338 if (type & server->vals->shared_lock_type) {
1339 flock->fl_type = F_WRLCK;
1343 type &= ~server->vals->exclusive_lock_type;
1345 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1346 type | server->vals->shared_lock_type,
1349 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1350 type | server->vals->shared_lock_type, 0, 1, false);
1351 flock->fl_type = F_RDLCK;
1353 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1356 flock->fl_type = F_WRLCK;
1362 cifs_move_llist(struct list_head *source, struct list_head *dest)
1364 struct list_head *li, *tmp;
1365 list_for_each_safe(li, tmp, source)
1366 list_move(li, dest);
1370 cifs_free_llist(struct list_head *llist)
1372 struct cifsLockInfo *li, *tmp;
1373 list_for_each_entry_safe(li, tmp, llist, llist) {
1374 cifs_del_lock_waiters(li);
1375 list_del(&li->llist);
1381 cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1384 int rc = 0, stored_rc;
1385 int types[] = {LOCKING_ANDX_LARGE_FILES,
1386 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1388 unsigned int max_num, num, max_buf;
1389 LOCKING_ANDX_RANGE *buf, *cur;
1390 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1391 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
1392 struct cifsLockInfo *li, *tmp;
1393 __u64 length = 1 + flock->fl_end - flock->fl_start;
1394 struct list_head tmp_llist;
1396 INIT_LIST_HEAD(&tmp_llist);
1399 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1400 * and check it for zero before using.
1402 max_buf = tcon->ses->server->maxBuf;
1406 max_num = (max_buf - sizeof(struct smb_hdr)) /
1407 sizeof(LOCKING_ANDX_RANGE);
1408 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1412 down_write(&cinode->lock_sem);
1413 for (i = 0; i < 2; i++) {
1416 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
1417 if (flock->fl_start > li->offset ||
1418 (flock->fl_start + length) <
1419 (li->offset + li->length))
1421 if (current->tgid != li->pid)
1423 if (types[i] != li->type)
1425 if (cinode->can_cache_brlcks) {
1427 * We can cache brlock requests - simply remove
1428 * a lock from the file's list.
1430 list_del(&li->llist);
1431 cifs_del_lock_waiters(li);
1435 cur->Pid = cpu_to_le16(li->pid);
1436 cur->LengthLow = cpu_to_le32((u32)li->length);
1437 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1438 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1439 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1441 * We need to save a lock here to let us add it again to
1442 * the file's list if the unlock range request fails on
1445 list_move(&li->llist, &tmp_llist);
1446 if (++num == max_num) {
1447 stored_rc = cifs_lockv(xid, tcon,
1449 li->type, num, 0, buf);
1452 * We failed on the unlock range
1453 * request - add all locks from the tmp
1454 * list to the head of the file's list.
1456 cifs_move_llist(&tmp_llist,
1457 &cfile->llist->locks);
1461 * The unlock range request succeed -
1462 * free the tmp list.
1464 cifs_free_llist(&tmp_llist);
1471 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
1472 types[i], num, 0, buf);
1474 cifs_move_llist(&tmp_llist,
1475 &cfile->llist->locks);
1478 cifs_free_llist(&tmp_llist);
1482 up_write(&cinode->lock_sem);
1488 cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
1489 bool wait_flag, bool posix_lck, int lock, int unlock,
1493 __u64 length = 1 + flock->fl_end - flock->fl_start;
1494 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1495 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1496 struct TCP_Server_Info *server = tcon->ses->server;
1497 struct inode *inode = d_inode(cfile->dentry);
1500 int posix_lock_type;
1502 rc = cifs_posix_lock_set(file, flock);
1506 if (type & server->vals->shared_lock_type)
1507 posix_lock_type = CIFS_RDLCK;
1509 posix_lock_type = CIFS_WRLCK;
1512 posix_lock_type = CIFS_UNLCK;
1514 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1515 current->tgid, flock->fl_start, length,
1516 NULL, posix_lock_type, wait_flag);
1521 struct cifsLockInfo *lock;
1523 lock = cifs_lock_init(flock->fl_start, length, type);
1527 rc = cifs_lock_add_if(cfile, lock, wait_flag);
1536 * Windows 7 server can delay breaking lease from read to None
1537 * if we set a byte-range lock on a file - break it explicitly
1538 * before sending the lock to the server to be sure the next
1539 * read won't conflict with non-overlapted locks due to
1542 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1543 CIFS_CACHE_READ(CIFS_I(inode))) {
1544 cifs_zap_mapping(inode);
1545 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1547 CIFS_I(inode)->oplock = 0;
1550 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1551 type, 1, 0, wait_flag);
1557 cifs_lock_add(cfile, lock);
1559 rc = server->ops->mand_unlock_range(cfile, flock, xid);
1562 if (flock->fl_flags & FL_POSIX && !rc)
1563 rc = locks_lock_file_wait(file, flock);
1567 int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1570 int lock = 0, unlock = 0;
1571 bool wait_flag = false;
1572 bool posix_lck = false;
1573 struct cifs_sb_info *cifs_sb;
1574 struct cifs_tcon *tcon;
1575 struct cifsInodeInfo *cinode;
1576 struct cifsFileInfo *cfile;
1583 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1584 cmd, flock->fl_flags, flock->fl_type,
1585 flock->fl_start, flock->fl_end);
1587 cfile = (struct cifsFileInfo *)file->private_data;
1588 tcon = tlink_tcon(cfile->tlink);
1590 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1593 cifs_sb = CIFS_FILE_SB(file);
1594 netfid = cfile->fid.netfid;
1595 cinode = CIFS_I(file_inode(file));
1597 if (cap_unix(tcon->ses) &&
1598 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1599 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1602 * BB add code here to normalize offset and length to account for
1603 * negative length which we can not accept over the wire.
1605 if (IS_GETLK(cmd)) {
1606 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
1611 if (!lock && !unlock) {
1613 * if no lock or unlock then nothing to do since we do not
1620 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1627 * update the file size (if needed) after a write. Should be called with
1628 * the inode->i_lock held
1631 cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1632 unsigned int bytes_written)
1634 loff_t end_of_write = offset + bytes_written;
1636 if (end_of_write > cifsi->server_eof)
1637 cifsi->server_eof = end_of_write;
1641 cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1642 size_t write_size, loff_t *offset)
1645 unsigned int bytes_written = 0;
1646 unsigned int total_written;
1647 struct cifs_sb_info *cifs_sb;
1648 struct cifs_tcon *tcon;
1649 struct TCP_Server_Info *server;
1651 struct dentry *dentry = open_file->dentry;
1652 struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
1653 struct cifs_io_parms io_parms;
1655 cifs_sb = CIFS_SB(dentry->d_sb);
1657 cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1658 write_size, *offset, dentry);
1660 tcon = tlink_tcon(open_file->tlink);
1661 server = tcon->ses->server;
1663 if (!server->ops->sync_write)
1668 for (total_written = 0; write_size > total_written;
1669 total_written += bytes_written) {
1671 while (rc == -EAGAIN) {
1675 if (open_file->invalidHandle) {
1676 /* we could deadlock if we called
1677 filemap_fdatawait from here so tell
1678 reopen_file not to flush data to
1680 rc = cifs_reopen_file(open_file, false);
1685 len = min(server->ops->wp_retry_size(d_inode(dentry)),
1686 (unsigned int)write_size - total_written);
1687 /* iov[0] is reserved for smb header */
1688 iov[1].iov_base = (char *)write_data + total_written;
1689 iov[1].iov_len = len;
1691 io_parms.tcon = tcon;
1692 io_parms.offset = *offset;
1693 io_parms.length = len;
1694 rc = server->ops->sync_write(xid, &open_file->fid,
1695 &io_parms, &bytes_written, iov, 1);
1697 if (rc || (bytes_written == 0)) {
1705 spin_lock(&d_inode(dentry)->i_lock);
1706 cifs_update_eof(cifsi, *offset, bytes_written);
1707 spin_unlock(&d_inode(dentry)->i_lock);
1708 *offset += bytes_written;
1712 cifs_stats_bytes_written(tcon, total_written);
1714 if (total_written > 0) {
1715 spin_lock(&d_inode(dentry)->i_lock);
1716 if (*offset > d_inode(dentry)->i_size)
1717 i_size_write(d_inode(dentry), *offset);
1718 spin_unlock(&d_inode(dentry)->i_lock);
1720 mark_inode_dirty_sync(d_inode(dentry));
1722 return total_written;
1725 struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1728 struct cifsFileInfo *open_file = NULL;
1729 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1730 struct cifs_tcon *tcon = cifs_sb_master_tcon(cifs_sb);
1732 /* only filter by fsuid on multiuser mounts */
1733 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1736 spin_lock(&tcon->open_file_lock);
1737 /* we could simply get the first_list_entry since write-only entries
1738 are always at the end of the list but since the first entry might
1739 have a close pending, we go through the whole list */
1740 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1741 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1743 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
1744 if (!open_file->invalidHandle) {
1745 /* found a good file */
1746 /* lock it so it will not be closed on us */
1747 cifsFileInfo_get(open_file);
1748 spin_unlock(&tcon->open_file_lock);
1750 } /* else might as well continue, and look for
1751 another, or simply have the caller reopen it
1752 again rather than trying to fix this handle */
1753 } else /* write only file */
1754 break; /* write only files are last so must be done */
1756 spin_unlock(&tcon->open_file_lock);
1760 struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1763 struct cifsFileInfo *open_file, *inv_file = NULL;
1764 struct cifs_sb_info *cifs_sb;
1765 struct cifs_tcon *tcon;
1766 bool any_available = false;
1768 unsigned int refind = 0;
1770 /* Having a null inode here (because mapping->host was set to zero by
1771 the VFS or MM) should not happen but we had reports of on oops (due to
1772 it being zero) during stress testcases so we need to check for it */
1774 if (cifs_inode == NULL) {
1775 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
1780 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1781 tcon = cifs_sb_master_tcon(cifs_sb);
1783 /* only filter by fsuid on multiuser mounts */
1784 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1787 spin_lock(&tcon->open_file_lock);
1789 if (refind > MAX_REOPEN_ATT) {
1790 spin_unlock(&tcon->open_file_lock);
1793 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1794 if (!any_available && open_file->pid != current->tgid)
1796 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
1798 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
1799 if (!open_file->invalidHandle) {
1800 /* found a good writable file */
1801 cifsFileInfo_get(open_file);
1802 spin_unlock(&tcon->open_file_lock);
1806 inv_file = open_file;
1810 /* couldn't find useable FH with same pid, try any available */
1811 if (!any_available) {
1812 any_available = true;
1813 goto refind_writable;
1817 any_available = false;
1818 cifsFileInfo_get(inv_file);
1821 spin_unlock(&tcon->open_file_lock);
1824 rc = cifs_reopen_file(inv_file, false);
1828 spin_lock(&tcon->open_file_lock);
1829 list_move_tail(&inv_file->flist,
1830 &cifs_inode->openFileList);
1831 spin_unlock(&tcon->open_file_lock);
1832 cifsFileInfo_put(inv_file);
1835 spin_lock(&tcon->open_file_lock);
1836 goto refind_writable;
1843 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1845 struct address_space *mapping = page->mapping;
1846 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1849 int bytes_written = 0;
1850 struct inode *inode;
1851 struct cifsFileInfo *open_file;
1853 if (!mapping || !mapping->host)
1856 inode = page->mapping->host;
1858 offset += (loff_t)from;
1859 write_data = kmap(page);
1862 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1867 /* racing with truncate? */
1868 if (offset > mapping->host->i_size) {
1870 return 0; /* don't care */
1873 /* check to make sure that we are not extending the file */
1874 if (mapping->host->i_size - offset < (loff_t)to)
1875 to = (unsigned)(mapping->host->i_size - offset);
1877 open_file = find_writable_file(CIFS_I(mapping->host), false);
1879 bytes_written = cifs_write(open_file, open_file->pid,
1880 write_data, to - from, &offset);
1881 cifsFileInfo_put(open_file);
1882 /* Does mm or vfs already set times? */
1883 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1884 if ((bytes_written > 0) && (offset))
1886 else if (bytes_written < 0)
1889 cifs_dbg(FYI, "No writeable filehandles for inode\n");
1897 static struct cifs_writedata *
1898 wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
1899 pgoff_t end, pgoff_t *index,
1900 unsigned int *found_pages)
1902 unsigned int nr_pages;
1903 struct page **pages;
1904 struct cifs_writedata *wdata;
1906 wdata = cifs_writedata_alloc((unsigned int)tofind,
1907 cifs_writev_complete);
1912 * find_get_pages_tag seems to return a max of 256 on each
1913 * iteration, so we must call it several times in order to
1914 * fill the array or the wsize is effectively limited to
1915 * 256 * PAGE_CACHE_SIZE.
1918 pages = wdata->pages;
1920 nr_pages = find_get_pages_tag(mapping, index,
1921 PAGECACHE_TAG_DIRTY, tofind,
1923 *found_pages += nr_pages;
1926 } while (nr_pages && tofind && *index <= end);
1932 wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
1933 struct address_space *mapping,
1934 struct writeback_control *wbc,
1935 pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
1937 unsigned int nr_pages = 0, i;
1940 for (i = 0; i < found_pages; i++) {
1941 page = wdata->pages[i];
1943 * At this point we hold neither mapping->tree_lock nor
1944 * lock on the page itself: the page may be truncated or
1945 * invalidated (changing page->mapping to NULL), or even
1946 * swizzled back from swapper_space to tmpfs file
1952 else if (!trylock_page(page))
1955 if (unlikely(page->mapping != mapping)) {
1960 if (!wbc->range_cyclic && page->index > end) {
1966 if (*next && (page->index != *next)) {
1967 /* Not next consecutive page */
1972 if (wbc->sync_mode != WB_SYNC_NONE)
1973 wait_on_page_writeback(page);
1975 if (PageWriteback(page) ||
1976 !clear_page_dirty_for_io(page)) {
1982 * This actually clears the dirty bit in the radix tree.
1983 * See cifs_writepage() for more commentary.
1985 set_page_writeback(page);
1986 if (page_offset(page) >= i_size_read(mapping->host)) {
1989 end_page_writeback(page);
1993 wdata->pages[i] = page;
1994 *next = page->index + 1;
1998 /* reset index to refind any pages skipped */
2000 *index = wdata->pages[0]->index + 1;
2002 /* put any pages we aren't going to use */
2003 for (i = nr_pages; i < found_pages; i++) {
2004 page_cache_release(wdata->pages[i]);
2005 wdata->pages[i] = NULL;
2012 wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2013 struct address_space *mapping, struct writeback_control *wbc)
2016 struct TCP_Server_Info *server;
2019 wdata->sync_mode = wbc->sync_mode;
2020 wdata->nr_pages = nr_pages;
2021 wdata->offset = page_offset(wdata->pages[0]);
2022 wdata->pagesz = PAGE_CACHE_SIZE;
2023 wdata->tailsz = min(i_size_read(mapping->host) -
2024 page_offset(wdata->pages[nr_pages - 1]),
2025 (loff_t)PAGE_CACHE_SIZE);
2026 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) + wdata->tailsz;
2028 if (wdata->cfile != NULL)
2029 cifsFileInfo_put(wdata->cfile);
2030 wdata->cfile = find_writable_file(CIFS_I(mapping->host), false);
2031 if (!wdata->cfile) {
2032 cifs_dbg(VFS, "No writable handles for inode\n");
2035 wdata->pid = wdata->cfile->pid;
2036 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2037 rc = server->ops->async_writev(wdata, cifs_writedata_release);
2040 for (i = 0; i < nr_pages; ++i)
2041 unlock_page(wdata->pages[i]);
2046 static int cifs_writepages(struct address_space *mapping,
2047 struct writeback_control *wbc)
2049 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
2050 struct TCP_Server_Info *server;
2051 bool done = false, scanned = false, range_whole = false;
2053 struct cifs_writedata *wdata;
2057 * If wsize is smaller than the page cache size, default to writing
2058 * one page at a time via cifs_writepage
2060 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
2061 return generic_writepages(mapping, wbc);
2063 if (wbc->range_cyclic) {
2064 index = mapping->writeback_index; /* Start from prev offset */
2067 index = wbc->range_start >> PAGE_CACHE_SHIFT;
2068 end = wbc->range_end >> PAGE_CACHE_SHIFT;
2069 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
2073 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
2075 while (!done && index <= end) {
2076 unsigned int i, nr_pages, found_pages, wsize, credits;
2077 pgoff_t next = 0, tofind, saved_index = index;
2079 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2084 tofind = min((wsize / PAGE_CACHE_SIZE) - 1, end - index) + 1;
2086 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2090 add_credits_and_wake_if(server, credits, 0);
2094 if (found_pages == 0) {
2095 kref_put(&wdata->refcount, cifs_writedata_release);
2096 add_credits_and_wake_if(server, credits, 0);
2100 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2101 end, &index, &next, &done);
2103 /* nothing to write? */
2104 if (nr_pages == 0) {
2105 kref_put(&wdata->refcount, cifs_writedata_release);
2106 add_credits_and_wake_if(server, credits, 0);
2110 wdata->credits = credits;
2112 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
2114 /* send failure -- clean up the mess */
2116 add_credits_and_wake_if(server, wdata->credits, 0);
2117 for (i = 0; i < nr_pages; ++i) {
2119 redirty_page_for_writepage(wbc,
2122 SetPageError(wdata->pages[i]);
2123 end_page_writeback(wdata->pages[i]);
2124 page_cache_release(wdata->pages[i]);
2127 mapping_set_error(mapping, rc);
2129 kref_put(&wdata->refcount, cifs_writedata_release);
2131 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2132 index = saved_index;
2136 wbc->nr_to_write -= nr_pages;
2137 if (wbc->nr_to_write <= 0)
2143 if (!scanned && !done) {
2145 * We hit the last page and there is more work to be done: wrap
2146 * back to the start of the file
2153 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
2154 mapping->writeback_index = index;
2160 cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
2166 /* BB add check for wbc flags */
2167 page_cache_get(page);
2168 if (!PageUptodate(page))
2169 cifs_dbg(FYI, "ppw - page not up to date\n");
2172 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2174 * A writepage() implementation always needs to do either this,
2175 * or re-dirty the page with "redirty_page_for_writepage()" in
2176 * the case of a failure.
2178 * Just unlocking the page will cause the radix tree tag-bits
2179 * to fail to update with the state of the page correctly.
2181 set_page_writeback(page);
2183 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
2184 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2186 else if (rc == -EAGAIN)
2187 redirty_page_for_writepage(wbc, page);
2191 SetPageUptodate(page);
2192 end_page_writeback(page);
2193 page_cache_release(page);
2198 static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2200 int rc = cifs_writepage_locked(page, wbc);
2205 static int cifs_write_end(struct file *file, struct address_space *mapping,
2206 loff_t pos, unsigned len, unsigned copied,
2207 struct page *page, void *fsdata)
2210 struct inode *inode = mapping->host;
2211 struct cifsFileInfo *cfile = file->private_data;
2212 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2215 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2218 pid = current->tgid;
2220 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
2223 if (PageChecked(page)) {
2225 SetPageUptodate(page);
2226 ClearPageChecked(page);
2227 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
2228 SetPageUptodate(page);
2230 if (!PageUptodate(page)) {
2232 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
2236 /* this is probably better than directly calling
2237 partialpage_write since in this function the file handle is
2238 known which we might as well leverage */
2239 /* BB check if anything else missing out of ppw
2240 such as updating last write time */
2241 page_data = kmap(page);
2242 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
2243 /* if (rc < 0) should we set writebehind rc? */
2250 set_page_dirty(page);
2254 spin_lock(&inode->i_lock);
2255 if (pos > inode->i_size)
2256 i_size_write(inode, pos);
2257 spin_unlock(&inode->i_lock);
2261 page_cache_release(page);
2266 int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2271 struct cifs_tcon *tcon;
2272 struct TCP_Server_Info *server;
2273 struct cifsFileInfo *smbfile = file->private_data;
2274 struct inode *inode = file_inode(file);
2275 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2277 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2280 mutex_lock(&inode->i_mutex);
2284 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2287 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
2288 rc = cifs_zap_mapping(inode);
2290 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
2291 rc = 0; /* don't care about it in fsync */
2295 tcon = tlink_tcon(smbfile->tlink);
2296 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2297 server = tcon->ses->server;
2298 if (server->ops->flush)
2299 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2305 mutex_unlock(&inode->i_mutex);
2309 int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
2313 struct cifs_tcon *tcon;
2314 struct TCP_Server_Info *server;
2315 struct cifsFileInfo *smbfile = file->private_data;
2316 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
2317 struct inode *inode = file->f_mapping->host;
2319 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2322 mutex_lock(&inode->i_mutex);
2326 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2329 tcon = tlink_tcon(smbfile->tlink);
2330 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2331 server = tcon->ses->server;
2332 if (server->ops->flush)
2333 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2339 mutex_unlock(&inode->i_mutex);
2344 * As file closes, flush all cached write data for this inode checking
2345 * for write behind errors.
2347 int cifs_flush(struct file *file, fl_owner_t id)
2349 struct inode *inode = file_inode(file);
2352 if (file->f_mode & FMODE_WRITE)
2353 rc = filemap_write_and_wait(inode->i_mapping);
2355 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
2361 cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2366 for (i = 0; i < num_pages; i++) {
2367 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2370 * save number of pages we have already allocated and
2371 * return with ENOMEM error
2380 for (i = 0; i < num_pages; i++)
2387 size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2392 clen = min_t(const size_t, len, wsize);
2393 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
2402 cifs_uncached_writedata_release(struct kref *refcount)
2405 struct cifs_writedata *wdata = container_of(refcount,
2406 struct cifs_writedata, refcount);
2408 for (i = 0; i < wdata->nr_pages; i++)
2409 put_page(wdata->pages[i]);
2410 cifs_writedata_release(refcount);
2414 cifs_uncached_writev_complete(struct work_struct *work)
2416 struct cifs_writedata *wdata = container_of(work,
2417 struct cifs_writedata, work);
2418 struct inode *inode = d_inode(wdata->cfile->dentry);
2419 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2421 spin_lock(&inode->i_lock);
2422 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2423 if (cifsi->server_eof > inode->i_size)
2424 i_size_write(inode, cifsi->server_eof);
2425 spin_unlock(&inode->i_lock);
2427 complete(&wdata->done);
2429 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2433 wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2434 size_t *len, unsigned long *num_pages)
2436 size_t save_len, copied, bytes, cur_len = *len;
2437 unsigned long i, nr_pages = *num_pages;
2440 for (i = 0; i < nr_pages; i++) {
2441 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2442 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2445 * If we didn't copy as much as we expected, then that
2446 * may mean we trod into an unmapped area. Stop copying
2447 * at that point. On the next pass through the big
2448 * loop, we'll likely end up getting a zero-length
2449 * write and bailing out of it.
2454 cur_len = save_len - cur_len;
2458 * If we have no data to send, then that probably means that
2459 * the copy above failed altogether. That's most likely because
2460 * the address in the iovec was bogus. Return -EFAULT and let
2461 * the caller free anything we allocated and bail out.
2467 * i + 1 now represents the number of pages we actually used in
2468 * the copy phase above.
2475 cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2476 struct cifsFileInfo *open_file,
2477 struct cifs_sb_info *cifs_sb, struct list_head *wdata_list)
2481 unsigned long nr_pages, num_pages, i;
2482 struct cifs_writedata *wdata;
2483 struct iov_iter saved_from;
2484 loff_t saved_offset = offset;
2486 struct TCP_Server_Info *server;
2488 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2489 pid = open_file->pid;
2491 pid = current->tgid;
2493 server = tlink_tcon(open_file->tlink)->ses->server;
2494 memcpy(&saved_from, from, sizeof(struct iov_iter));
2497 unsigned int wsize, credits;
2499 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2504 nr_pages = get_numpages(wsize, len, &cur_len);
2505 wdata = cifs_writedata_alloc(nr_pages,
2506 cifs_uncached_writev_complete);
2509 add_credits_and_wake_if(server, credits, 0);
2513 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2516 add_credits_and_wake_if(server, credits, 0);
2520 num_pages = nr_pages;
2521 rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
2523 for (i = 0; i < nr_pages; i++)
2524 put_page(wdata->pages[i]);
2526 add_credits_and_wake_if(server, credits, 0);
2531 * Bring nr_pages down to the number of pages we actually used,
2532 * and free any pages that we didn't use.
2534 for ( ; nr_pages > num_pages; nr_pages--)
2535 put_page(wdata->pages[nr_pages - 1]);
2537 wdata->sync_mode = WB_SYNC_ALL;
2538 wdata->nr_pages = nr_pages;
2539 wdata->offset = (__u64)offset;
2540 wdata->cfile = cifsFileInfo_get(open_file);
2542 wdata->bytes = cur_len;
2543 wdata->pagesz = PAGE_SIZE;
2544 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
2545 wdata->credits = credits;
2547 if (!wdata->cfile->invalidHandle ||
2548 !cifs_reopen_file(wdata->cfile, false))
2549 rc = server->ops->async_writev(wdata,
2550 cifs_uncached_writedata_release);
2552 add_credits_and_wake_if(server, wdata->credits, 0);
2553 kref_put(&wdata->refcount,
2554 cifs_uncached_writedata_release);
2555 if (rc == -EAGAIN) {
2556 memcpy(from, &saved_from,
2557 sizeof(struct iov_iter));
2558 iov_iter_advance(from, offset - saved_offset);
2564 list_add_tail(&wdata->list, wdata_list);
2572 ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
2574 struct file *file = iocb->ki_filp;
2575 ssize_t total_written = 0;
2576 struct cifsFileInfo *open_file;
2577 struct cifs_tcon *tcon;
2578 struct cifs_sb_info *cifs_sb;
2579 struct cifs_writedata *wdata, *tmp;
2580 struct list_head wdata_list;
2581 struct iov_iter saved_from;
2585 * BB - optimize the way when signing is disabled. We can drop this
2586 * extra memory-to-memory copying and use iovec buffers for constructing
2590 rc = generic_write_checks(iocb, from);
2594 INIT_LIST_HEAD(&wdata_list);
2595 cifs_sb = CIFS_FILE_SB(file);
2596 open_file = file->private_data;
2597 tcon = tlink_tcon(open_file->tlink);
2599 if (!tcon->ses->server->ops->async_writev)
2602 memcpy(&saved_from, from, sizeof(struct iov_iter));
2604 rc = cifs_write_from_iter(iocb->ki_pos, iov_iter_count(from), from,
2605 open_file, cifs_sb, &wdata_list);
2608 * If at least one write was successfully sent, then discard any rc
2609 * value from the later writes. If the other write succeeds, then
2610 * we'll end up returning whatever was written. If it fails, then
2611 * we'll get a new rc value from that.
2613 if (!list_empty(&wdata_list))
2617 * Wait for and collect replies for any successful sends in order of
2618 * increasing offset. Once an error is hit or we get a fatal signal
2619 * while waiting, then return without waiting for any more replies.
2622 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2624 /* FIXME: freezable too? */
2625 rc = wait_for_completion_killable(&wdata->done);
2628 else if (wdata->result)
2631 total_written += wdata->bytes;
2633 /* resend call if it's a retryable error */
2634 if (rc == -EAGAIN) {
2635 struct list_head tmp_list;
2636 struct iov_iter tmp_from;
2638 INIT_LIST_HEAD(&tmp_list);
2639 list_del_init(&wdata->list);
2641 memcpy(&tmp_from, &saved_from,
2642 sizeof(struct iov_iter));
2643 iov_iter_advance(&tmp_from,
2644 wdata->offset - iocb->ki_pos);
2646 rc = cifs_write_from_iter(wdata->offset,
2647 wdata->bytes, &tmp_from,
2648 open_file, cifs_sb, &tmp_list);
2650 list_splice(&tmp_list, &wdata_list);
2652 kref_put(&wdata->refcount,
2653 cifs_uncached_writedata_release);
2657 list_del_init(&wdata->list);
2658 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
2661 if (unlikely(!total_written))
2664 iocb->ki_pos += total_written;
2665 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(file_inode(file))->flags);
2666 cifs_stats_bytes_written(tcon, total_written);
2667 return total_written;
2671 cifs_writev(struct kiocb *iocb, struct iov_iter *from)
2673 struct file *file = iocb->ki_filp;
2674 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2675 struct inode *inode = file->f_mapping->host;
2676 struct cifsInodeInfo *cinode = CIFS_I(inode);
2677 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2681 * We need to hold the sem to be sure nobody modifies lock list
2682 * with a brlock that prevents writing.
2684 down_read(&cinode->lock_sem);
2685 mutex_lock(&inode->i_mutex);
2687 rc = generic_write_checks(iocb, from);
2691 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
2692 server->vals->exclusive_lock_type, NULL,
2694 rc = __generic_file_write_iter(iocb, from);
2698 mutex_unlock(&inode->i_mutex);
2701 ssize_t err = generic_write_sync(file, iocb->ki_pos - rc, rc);
2705 up_read(&cinode->lock_sem);
2710 cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
2712 struct inode *inode = file_inode(iocb->ki_filp);
2713 struct cifsInodeInfo *cinode = CIFS_I(inode);
2714 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2715 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2716 iocb->ki_filp->private_data;
2717 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2720 written = cifs_get_writer(cinode);
2724 if (CIFS_CACHE_WRITE(cinode)) {
2725 if (cap_unix(tcon->ses) &&
2726 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2727 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
2728 written = generic_file_write_iter(iocb, from);
2731 written = cifs_writev(iocb, from);
2735 * For non-oplocked files in strict cache mode we need to write the data
2736 * to the server exactly from the pos to pos+len-1 rather than flush all
2737 * affected pages because it may cause a error with mandatory locks on
2738 * these pages but not on the region from pos to ppos+len-1.
2740 written = cifs_user_writev(iocb, from);
2741 if (written > 0 && CIFS_CACHE_READ(cinode)) {
2743 * Windows 7 server can delay breaking level2 oplock if a write
2744 * request comes - break it on the client to prevent reading
2747 cifs_zap_mapping(inode);
2748 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2753 cifs_put_writer(cinode);
2757 static struct cifs_readdata *
2758 cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
2760 struct cifs_readdata *rdata;
2762 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2764 if (rdata != NULL) {
2765 kref_init(&rdata->refcount);
2766 INIT_LIST_HEAD(&rdata->list);
2767 init_completion(&rdata->done);
2768 INIT_WORK(&rdata->work, complete);
2775 cifs_readdata_release(struct kref *refcount)
2777 struct cifs_readdata *rdata = container_of(refcount,
2778 struct cifs_readdata, refcount);
2781 cifsFileInfo_put(rdata->cfile);
2787 cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
2793 for (i = 0; i < nr_pages; i++) {
2794 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2799 rdata->pages[i] = page;
2803 for (i = 0; i < nr_pages; i++) {
2804 put_page(rdata->pages[i]);
2805 rdata->pages[i] = NULL;
2812 cifs_uncached_readdata_release(struct kref *refcount)
2814 struct cifs_readdata *rdata = container_of(refcount,
2815 struct cifs_readdata, refcount);
2818 for (i = 0; i < rdata->nr_pages; i++) {
2819 put_page(rdata->pages[i]);
2820 rdata->pages[i] = NULL;
2822 cifs_readdata_release(refcount);
2826 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2827 * @rdata: the readdata response with list of pages holding data
2828 * @iter: destination for our data
2830 * This function copies data from a list of pages in a readdata response into
2831 * an array of iovecs. It will first calculate where the data should go
2832 * based on the info in the readdata and then copy the data into that spot.
2835 cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
2837 size_t remaining = rdata->got_bytes;
2840 for (i = 0; i < rdata->nr_pages; i++) {
2841 struct page *page = rdata->pages[i];
2842 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
2843 size_t written = copy_page_to_iter(page, 0, copy, iter);
2844 remaining -= written;
2845 if (written < copy && iov_iter_count(iter) > 0)
2848 return remaining ? -EFAULT : 0;
2852 cifs_uncached_readv_complete(struct work_struct *work)
2854 struct cifs_readdata *rdata = container_of(work,
2855 struct cifs_readdata, work);
2857 complete(&rdata->done);
2858 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2862 cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2863 struct cifs_readdata *rdata, unsigned int len)
2867 unsigned int nr_pages = rdata->nr_pages;
2870 rdata->got_bytes = 0;
2871 rdata->tailsz = PAGE_SIZE;
2872 for (i = 0; i < nr_pages; i++) {
2873 struct page *page = rdata->pages[i];
2875 if (len >= PAGE_SIZE) {
2876 /* enough data to fill the page */
2877 iov.iov_base = kmap(page);
2878 iov.iov_len = PAGE_SIZE;
2879 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2880 i, iov.iov_base, iov.iov_len);
2882 } else if (len > 0) {
2883 /* enough for partial page, fill and zero the rest */
2884 iov.iov_base = kmap(page);
2886 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2887 i, iov.iov_base, iov.iov_len);
2888 memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2889 rdata->tailsz = len;
2892 /* no need to hold page hostage */
2893 rdata->pages[i] = NULL;
2899 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2904 rdata->got_bytes += result;
2907 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
2908 rdata->got_bytes : result;
2912 cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
2913 struct cifs_sb_info *cifs_sb, struct list_head *rdata_list)
2915 struct cifs_readdata *rdata;
2916 unsigned int npages, rsize, credits;
2920 struct TCP_Server_Info *server;
2922 server = tlink_tcon(open_file->tlink)->ses->server;
2924 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2925 pid = open_file->pid;
2927 pid = current->tgid;
2930 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
2935 cur_len = min_t(const size_t, len, rsize);
2936 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
2938 /* allocate a readdata struct */
2939 rdata = cifs_readdata_alloc(npages,
2940 cifs_uncached_readv_complete);
2942 add_credits_and_wake_if(server, credits, 0);
2947 rc = cifs_read_allocate_pages(rdata, npages);
2951 rdata->cfile = cifsFileInfo_get(open_file);
2952 rdata->nr_pages = npages;
2953 rdata->offset = offset;
2954 rdata->bytes = cur_len;
2956 rdata->pagesz = PAGE_SIZE;
2957 rdata->read_into_pages = cifs_uncached_read_into_pages;
2958 rdata->credits = credits;
2960 if (!rdata->cfile->invalidHandle ||
2961 !cifs_reopen_file(rdata->cfile, true))
2962 rc = server->ops->async_readv(rdata);
2965 add_credits_and_wake_if(server, rdata->credits, 0);
2966 kref_put(&rdata->refcount,
2967 cifs_uncached_readdata_release);
2973 list_add_tail(&rdata->list, rdata_list);
2981 ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
2983 struct file *file = iocb->ki_filp;
2986 ssize_t total_read = 0;
2987 loff_t offset = iocb->ki_pos;
2988 struct cifs_sb_info *cifs_sb;
2989 struct cifs_tcon *tcon;
2990 struct cifsFileInfo *open_file;
2991 struct cifs_readdata *rdata, *tmp;
2992 struct list_head rdata_list;
2994 len = iov_iter_count(to);
2998 INIT_LIST_HEAD(&rdata_list);
2999 cifs_sb = CIFS_FILE_SB(file);
3000 open_file = file->private_data;
3001 tcon = tlink_tcon(open_file->tlink);
3003 if (!tcon->ses->server->ops->async_readv)
3006 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3007 cifs_dbg(FYI, "attempting read on write only file instance\n");
3009 rc = cifs_send_async_read(offset, len, open_file, cifs_sb, &rdata_list);
3011 /* if at least one read request send succeeded, then reset rc */
3012 if (!list_empty(&rdata_list))
3015 len = iov_iter_count(to);
3016 /* the loop below should proceed in the order of increasing offsets */
3018 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
3020 /* FIXME: freezable sleep too? */
3021 rc = wait_for_completion_killable(&rdata->done);
3024 else if (rdata->result == -EAGAIN) {
3025 /* resend call if it's a retryable error */
3026 struct list_head tmp_list;
3027 unsigned int got_bytes = rdata->got_bytes;
3029 list_del_init(&rdata->list);
3030 INIT_LIST_HEAD(&tmp_list);
3033 * Got a part of data and then reconnect has
3034 * happened -- fill the buffer and continue
3037 if (got_bytes && got_bytes < rdata->bytes) {
3038 rc = cifs_readdata_to_iov(rdata, to);
3040 kref_put(&rdata->refcount,
3041 cifs_uncached_readdata_release);
3046 rc = cifs_send_async_read(
3047 rdata->offset + got_bytes,
3048 rdata->bytes - got_bytes,
3049 rdata->cfile, cifs_sb,
3052 list_splice(&tmp_list, &rdata_list);
3054 kref_put(&rdata->refcount,
3055 cifs_uncached_readdata_release);
3057 } else if (rdata->result)
3060 rc = cifs_readdata_to_iov(rdata, to);
3062 /* if there was a short read -- discard anything left */
3063 if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3066 list_del_init(&rdata->list);
3067 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
3070 total_read = len - iov_iter_count(to);
3072 cifs_stats_bytes_read(tcon, total_read);
3074 /* mask nodata case */
3079 iocb->ki_pos += total_read;
3086 cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
3088 struct inode *inode = file_inode(iocb->ki_filp);
3089 struct cifsInodeInfo *cinode = CIFS_I(inode);
3090 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3091 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3092 iocb->ki_filp->private_data;
3093 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3097 * In strict cache mode we need to read from the server all the time
3098 * if we don't have level II oplock because the server can delay mtime
3099 * change - so we can't make a decision about inode invalidating.
3100 * And we can also fail with pagereading if there are mandatory locks
3101 * on pages affected by this read but not on the region from pos to
3104 if (!CIFS_CACHE_READ(cinode))
3105 return cifs_user_readv(iocb, to);
3107 if (cap_unix(tcon->ses) &&
3108 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3109 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
3110 return generic_file_read_iter(iocb, to);
3113 * We need to hold the sem to be sure nobody modifies lock list
3114 * with a brlock that prevents reading.
3116 down_read(&cinode->lock_sem);
3117 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
3118 tcon->ses->server->vals->shared_lock_type,
3119 NULL, CIFS_READ_OP))
3120 rc = generic_file_read_iter(iocb, to);
3121 up_read(&cinode->lock_sem);
3126 cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
3129 unsigned int bytes_read = 0;
3130 unsigned int total_read;
3131 unsigned int current_read_size;
3133 struct cifs_sb_info *cifs_sb;
3134 struct cifs_tcon *tcon;
3135 struct TCP_Server_Info *server;
3138 struct cifsFileInfo *open_file;
3139 struct cifs_io_parms io_parms;
3140 int buf_type = CIFS_NO_BUFFER;
3144 cifs_sb = CIFS_FILE_SB(file);
3146 /* FIXME: set up handlers for larger reads and/or convert to async */
3147 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3149 if (file->private_data == NULL) {
3154 open_file = file->private_data;
3155 tcon = tlink_tcon(open_file->tlink);
3156 server = tcon->ses->server;
3158 if (!server->ops->sync_read) {
3163 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3164 pid = open_file->pid;
3166 pid = current->tgid;
3168 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3169 cifs_dbg(FYI, "attempting read on write only file instance\n");
3171 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3172 total_read += bytes_read, cur_offset += bytes_read) {
3174 current_read_size = min_t(uint, read_size - total_read,
3177 * For windows me and 9x we do not want to request more
3178 * than it negotiated since it will refuse the read
3181 if ((tcon->ses) && !(tcon->ses->capabilities &
3182 tcon->ses->server->vals->cap_large_files)) {
3183 current_read_size = min_t(uint,
3184 current_read_size, CIFSMaxBufSize);
3186 if (open_file->invalidHandle) {
3187 rc = cifs_reopen_file(open_file, true);
3192 io_parms.tcon = tcon;
3193 io_parms.offset = *offset;
3194 io_parms.length = current_read_size;
3195 rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
3196 &bytes_read, &cur_offset,
3198 } while (rc == -EAGAIN);
3200 if (rc || (bytes_read == 0)) {
3208 cifs_stats_bytes_read(tcon, total_read);
3209 *offset += bytes_read;
3217 * If the page is mmap'ed into a process' page tables, then we need to make
3218 * sure that it doesn't change while being written back.
3221 cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3223 struct page *page = vmf->page;
3226 return VM_FAULT_LOCKED;
3229 static const struct vm_operations_struct cifs_file_vm_ops = {
3230 .fault = filemap_fault,
3231 .map_pages = filemap_map_pages,
3232 .page_mkwrite = cifs_page_mkwrite,
3235 int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3238 struct inode *inode = file_inode(file);
3242 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
3243 rc = cifs_zap_mapping(inode);
3248 rc = generic_file_mmap(file, vma);
3250 vma->vm_ops = &cifs_file_vm_ops;
3255 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3260 rc = cifs_revalidate_file(file);
3262 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3267 rc = generic_file_mmap(file, vma);
3269 vma->vm_ops = &cifs_file_vm_ops;
3275 cifs_readv_complete(struct work_struct *work)
3277 unsigned int i, got_bytes;
3278 struct cifs_readdata *rdata = container_of(work,
3279 struct cifs_readdata, work);
3281 got_bytes = rdata->got_bytes;
3282 for (i = 0; i < rdata->nr_pages; i++) {
3283 struct page *page = rdata->pages[i];
3285 lru_cache_add_file(page);
3287 if (rdata->result == 0 ||
3288 (rdata->result == -EAGAIN && got_bytes)) {
3289 flush_dcache_page(page);
3290 SetPageUptodate(page);
3295 if (rdata->result == 0 ||
3296 (rdata->result == -EAGAIN && got_bytes))
3297 cifs_readpage_to_fscache(rdata->mapping->host, page);
3299 got_bytes -= min_t(unsigned int, PAGE_CACHE_SIZE, got_bytes);
3301 page_cache_release(page);
3302 rdata->pages[i] = NULL;
3304 kref_put(&rdata->refcount, cifs_readdata_release);
3308 cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3309 struct cifs_readdata *rdata, unsigned int len)
3315 unsigned int nr_pages = rdata->nr_pages;
3318 /* determine the eof that the server (probably) has */
3319 eof = CIFS_I(rdata->mapping->host)->server_eof;
3320 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
3321 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
3323 rdata->got_bytes = 0;
3324 rdata->tailsz = PAGE_CACHE_SIZE;
3325 for (i = 0; i < nr_pages; i++) {
3326 struct page *page = rdata->pages[i];
3328 if (len >= PAGE_CACHE_SIZE) {
3329 /* enough data to fill the page */
3330 iov.iov_base = kmap(page);
3331 iov.iov_len = PAGE_CACHE_SIZE;
3332 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3333 i, page->index, iov.iov_base, iov.iov_len);
3334 len -= PAGE_CACHE_SIZE;
3335 } else if (len > 0) {
3336 /* enough for partial page, fill and zero the rest */
3337 iov.iov_base = kmap(page);
3339 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3340 i, page->index, iov.iov_base, iov.iov_len);
3341 memset(iov.iov_base + len,
3342 '\0', PAGE_CACHE_SIZE - len);
3343 rdata->tailsz = len;
3345 } else if (page->index > eof_index) {
3347 * The VFS will not try to do readahead past the
3348 * i_size, but it's possible that we have outstanding
3349 * writes with gaps in the middle and the i_size hasn't
3350 * caught up yet. Populate those with zeroed out pages
3351 * to prevent the VFS from repeatedly attempting to
3352 * fill them until the writes are flushed.
3354 zero_user(page, 0, PAGE_CACHE_SIZE);
3355 lru_cache_add_file(page);
3356 flush_dcache_page(page);
3357 SetPageUptodate(page);
3359 page_cache_release(page);
3360 rdata->pages[i] = NULL;
3364 /* no need to hold page hostage */
3365 lru_cache_add_file(page);
3367 page_cache_release(page);
3368 rdata->pages[i] = NULL;
3373 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3378 rdata->got_bytes += result;
3381 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3382 rdata->got_bytes : result;
3386 readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
3387 unsigned int rsize, struct list_head *tmplist,
3388 unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
3390 struct page *page, *tpage;
3391 unsigned int expected_index;
3393 gfp_t gfp = mapping_gfp_constraint(mapping, GFP_KERNEL);
3395 INIT_LIST_HEAD(tmplist);
3397 page = list_entry(page_list->prev, struct page, lru);
3400 * Lock the page and put it in the cache. Since no one else
3401 * should have access to this page, we're safe to simply set
3402 * PG_locked without checking it first.
3404 __set_page_locked(page);
3405 rc = add_to_page_cache_locked(page, mapping,
3408 /* give up if we can't stick it in the cache */
3410 __clear_page_locked(page);
3414 /* move first page to the tmplist */
3415 *offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3416 *bytes = PAGE_CACHE_SIZE;
3418 list_move_tail(&page->lru, tmplist);
3420 /* now try and add more pages onto the request */
3421 expected_index = page->index + 1;
3422 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3423 /* discontinuity ? */
3424 if (page->index != expected_index)
3427 /* would this page push the read over the rsize? */
3428 if (*bytes + PAGE_CACHE_SIZE > rsize)
3431 __set_page_locked(page);
3432 if (add_to_page_cache_locked(page, mapping, page->index, gfp)) {
3433 __clear_page_locked(page);
3436 list_move_tail(&page->lru, tmplist);
3437 (*bytes) += PAGE_CACHE_SIZE;
3444 static int cifs_readpages(struct file *file, struct address_space *mapping,
3445 struct list_head *page_list, unsigned num_pages)
3448 struct list_head tmplist;
3449 struct cifsFileInfo *open_file = file->private_data;
3450 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
3451 struct TCP_Server_Info *server;
3455 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3456 * immediately if the cookie is negative
3458 * After this point, every page in the list might have PG_fscache set,
3459 * so we will need to clean that up off of every page we don't use.
3461 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3466 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3467 pid = open_file->pid;
3469 pid = current->tgid;
3472 server = tlink_tcon(open_file->tlink)->ses->server;
3474 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3475 __func__, file, mapping, num_pages);
3478 * Start with the page at end of list and move it to private
3479 * list. Do the same with any following pages until we hit
3480 * the rsize limit, hit an index discontinuity, or run out of
3481 * pages. Issue the async read and then start the loop again
3482 * until the list is empty.
3484 * Note that list order is important. The page_list is in
3485 * the order of declining indexes. When we put the pages in
3486 * the rdata->pages, then we want them in increasing order.
3488 while (!list_empty(page_list)) {
3489 unsigned int i, nr_pages, bytes, rsize;
3491 struct page *page, *tpage;
3492 struct cifs_readdata *rdata;
3495 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3501 * Give up immediately if rsize is too small to read an entire
3502 * page. The VFS will fall back to readpage. We should never
3503 * reach this point however since we set ra_pages to 0 when the
3504 * rsize is smaller than a cache page.
3506 if (unlikely(rsize < PAGE_CACHE_SIZE)) {
3507 add_credits_and_wake_if(server, credits, 0);
3511 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
3512 &nr_pages, &offset, &bytes);
3514 add_credits_and_wake_if(server, credits, 0);
3518 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
3520 /* best to give up if we're out of mem */
3521 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3522 list_del(&page->lru);
3523 lru_cache_add_file(page);
3525 page_cache_release(page);
3528 add_credits_and_wake_if(server, credits, 0);
3532 rdata->cfile = cifsFileInfo_get(open_file);
3533 rdata->mapping = mapping;
3534 rdata->offset = offset;
3535 rdata->bytes = bytes;
3537 rdata->pagesz = PAGE_CACHE_SIZE;
3538 rdata->read_into_pages = cifs_readpages_read_into_pages;
3539 rdata->credits = credits;
3541 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3542 list_del(&page->lru);
3543 rdata->pages[rdata->nr_pages++] = page;
3546 if (!rdata->cfile->invalidHandle ||
3547 !cifs_reopen_file(rdata->cfile, true))
3548 rc = server->ops->async_readv(rdata);
3550 add_credits_and_wake_if(server, rdata->credits, 0);
3551 for (i = 0; i < rdata->nr_pages; i++) {
3552 page = rdata->pages[i];
3553 lru_cache_add_file(page);
3555 page_cache_release(page);
3557 /* Fallback to the readpage in error/reconnect cases */
3558 kref_put(&rdata->refcount, cifs_readdata_release);
3562 kref_put(&rdata->refcount, cifs_readdata_release);
3565 /* Any pages that have been shown to fscache but didn't get added to
3566 * the pagecache must be uncached before they get returned to the
3569 cifs_fscache_readpages_cancel(mapping->host, page_list);
3574 * cifs_readpage_worker must be called with the page pinned
3576 static int cifs_readpage_worker(struct file *file, struct page *page,
3582 /* Is the page cached? */
3583 rc = cifs_readpage_from_fscache(file_inode(file), page);
3587 read_data = kmap(page);
3588 /* for reads over a certain size could initiate async read ahead */
3590 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
3595 cifs_dbg(FYI, "Bytes read %d\n", rc);
3597 file_inode(file)->i_atime =
3598 current_fs_time(file_inode(file)->i_sb);
3600 if (PAGE_CACHE_SIZE > rc)
3601 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3603 flush_dcache_page(page);
3604 SetPageUptodate(page);
3606 /* send this page to the cache */
3607 cifs_readpage_to_fscache(file_inode(file), page);
3619 static int cifs_readpage(struct file *file, struct page *page)
3621 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3627 if (file->private_data == NULL) {
3633 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
3634 page, (int)offset, (int)offset);
3636 rc = cifs_readpage_worker(file, page, &offset);
3642 static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3644 struct cifsFileInfo *open_file;
3645 struct cifs_tcon *tcon =
3646 cifs_sb_master_tcon(CIFS_SB(cifs_inode->vfs_inode.i_sb));
3648 spin_lock(&tcon->open_file_lock);
3649 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
3650 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
3651 spin_unlock(&tcon->open_file_lock);
3655 spin_unlock(&tcon->open_file_lock);
3659 /* We do not want to update the file size from server for inodes
3660 open for write - to avoid races with writepage extending
3661 the file - in the future we could consider allowing
3662 refreshing the inode only on increases in the file size
3663 but this is tricky to do without racing with writebehind
3664 page caching in the current Linux kernel design */
3665 bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
3670 if (is_inode_writable(cifsInode)) {
3671 /* This inode is open for write at least once */
3672 struct cifs_sb_info *cifs_sb;
3674 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
3675 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
3676 /* since no page cache to corrupt on directio
3677 we can change size safely */
3681 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
3689 static int cifs_write_begin(struct file *file, struct address_space *mapping,
3690 loff_t pos, unsigned len, unsigned flags,
3691 struct page **pagep, void **fsdata)
3694 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3695 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
3696 loff_t page_start = pos & PAGE_MASK;
3701 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
3704 page = grab_cache_page_write_begin(mapping, index, flags);
3710 if (PageUptodate(page))
3714 * If we write a full page it will be up to date, no need to read from
3715 * the server. If the write is short, we'll end up doing a sync write
3718 if (len == PAGE_CACHE_SIZE)
3722 * optimize away the read when we have an oplock, and we're not
3723 * expecting to use any of the data we'd be reading in. That
3724 * is, when the page lies beyond the EOF, or straddles the EOF
3725 * and the write will cover all of the existing data.
3727 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
3728 i_size = i_size_read(mapping->host);
3729 if (page_start >= i_size ||
3730 (offset == 0 && (pos + len) >= i_size)) {
3731 zero_user_segments(page, 0, offset,
3735 * PageChecked means that the parts of the page
3736 * to which we're not writing are considered up
3737 * to date. Once the data is copied to the
3738 * page, it can be set uptodate.
3740 SetPageChecked(page);
3745 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
3747 * might as well read a page, it is fast enough. If we get
3748 * an error, we don't need to return it. cifs_write_end will
3749 * do a sync write instead since PG_uptodate isn't set.
3751 cifs_readpage_worker(file, page, &page_start);
3752 page_cache_release(page);
3756 /* we could try using another file handle if there is one -
3757 but how would we lock it to prevent close of that handle
3758 racing with this read? In any case
3759 this will be written out by write_end so is fine */
3766 static int cifs_release_page(struct page *page, gfp_t gfp)
3768 if (PagePrivate(page))
3771 return cifs_fscache_release_page(page, gfp);
3774 static void cifs_invalidate_page(struct page *page, unsigned int offset,
3775 unsigned int length)
3777 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3779 if (offset == 0 && length == PAGE_CACHE_SIZE)
3780 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3783 static int cifs_launder_page(struct page *page)
3786 loff_t range_start = page_offset(page);
3787 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3788 struct writeback_control wbc = {
3789 .sync_mode = WB_SYNC_ALL,
3791 .range_start = range_start,
3792 .range_end = range_end,
3795 cifs_dbg(FYI, "Launder page: %p\n", page);
3797 if (clear_page_dirty_for_io(page))
3798 rc = cifs_writepage_locked(page, &wbc);
3800 cifs_fscache_invalidate_page(page, page->mapping->host);
3804 void cifs_oplock_break(struct work_struct *work)
3806 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3808 struct inode *inode = d_inode(cfile->dentry);
3809 struct cifsInodeInfo *cinode = CIFS_I(inode);
3810 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3811 struct TCP_Server_Info *server = tcon->ses->server;
3814 wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
3815 TASK_UNINTERRUPTIBLE);
3817 server->ops->downgrade_oplock(server, cinode,
3818 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
3820 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
3821 cifs_has_mand_locks(cinode)) {
3822 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3827 if (inode && S_ISREG(inode->i_mode)) {
3828 if (CIFS_CACHE_READ(cinode))
3829 break_lease(inode, O_RDONLY);
3831 break_lease(inode, O_WRONLY);
3832 rc = filemap_fdatawrite(inode->i_mapping);
3833 if (!CIFS_CACHE_READ(cinode)) {
3834 rc = filemap_fdatawait(inode->i_mapping);
3835 mapping_set_error(inode->i_mapping, rc);
3836 cifs_zap_mapping(inode);
3838 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
3841 rc = cifs_push_locks(cfile);
3843 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
3846 * releasing stale oplock after recent reconnect of smb session using
3847 * a now incorrect file handle is not a data integrity issue but do
3848 * not bother sending an oplock release if session to server still is
3849 * disconnected since oplock already released by the server
3851 if (!cfile->oplock_break_cancelled) {
3852 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3854 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
3856 cifs_done_oplock_break(cinode);
3860 * The presence of cifs_direct_io() in the address space ops vector
3861 * allowes open() O_DIRECT flags which would have failed otherwise.
3863 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
3864 * so this method should never be called.
3866 * Direct IO is not yet supported in the cached mode.
3869 cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter, loff_t pos)
3873 * Eventually need to support direct IO for non forcedirectio mounts
3879 const struct address_space_operations cifs_addr_ops = {
3880 .readpage = cifs_readpage,
3881 .readpages = cifs_readpages,
3882 .writepage = cifs_writepage,
3883 .writepages = cifs_writepages,
3884 .write_begin = cifs_write_begin,
3885 .write_end = cifs_write_end,
3886 .set_page_dirty = __set_page_dirty_nobuffers,
3887 .releasepage = cifs_release_page,
3888 .direct_IO = cifs_direct_io,
3889 .invalidatepage = cifs_invalidate_page,
3890 .launder_page = cifs_launder_page,
3894 * cifs_readpages requires the server to support a buffer large enough to
3895 * contain the header plus one complete page of data. Otherwise, we need
3896 * to leave cifs_readpages out of the address space operations.
3898 const struct address_space_operations cifs_addr_ops_smallbuf = {
3899 .readpage = cifs_readpage,
3900 .writepage = cifs_writepage,
3901 .writepages = cifs_writepages,
3902 .write_begin = cifs_write_begin,
3903 .write_end = cifs_write_end,
3904 .set_page_dirty = __set_page_dirty_nobuffers,
3905 .releasepage = cifs_release_page,
3906 .invalidatepage = cifs_invalidate_page,
3907 .launder_page = cifs_launder_page,