blob: 3f50cee79df9d3318209e19281acef536b34af37 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/file.c
3 *
4 * vfs operations that deal with files
Steve Frenchfb8c4b12007-07-10 01:16:18 +00005 *
Steve Frenchf19159d2010-04-21 04:12:10 +00006 * Copyright (C) International Business Machines Corp., 2002,2010
Linus Torvalds1da177e2005-04-16 15:20:36 -07007 * Author(s): Steve French (sfrench@us.ibm.com)
Jeremy Allison7ee1af72006-08-02 21:56:33 +00008 * Jeremy Allison (jra@samba.org)
Linus Torvalds1da177e2005-04-16 15:20:36 -07009 *
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.
14 *
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.
19 *
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
23 */
24#include <linux/fs.h>
Steve French37c0eb42005-10-05 14:50:29 -070025#include <linux/backing-dev.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070026#include <linux/stat.h>
27#include <linux/fcntl.h>
28#include <linux/pagemap.h>
29#include <linux/pagevec.h>
Steve French37c0eb42005-10-05 14:50:29 -070030#include <linux/writeback.h>
Andrew Morton6f88cc22006-12-10 02:19:44 -080031#include <linux/task_io_accounting_ops.h>
Steve French23e7dd72005-10-20 13:44:56 -070032#include <linux/delay.h>
Jeff Layton3bc303c2009-09-21 06:47:50 -040033#include <linux/mount.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090034#include <linux/slab.h>
Jeff Layton690c5e32011-10-19 15:30:16 -040035#include <linux/swap.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070036#include <asm/div64.h>
37#include "cifsfs.h"
38#include "cifspdu.h"
39#include "cifsglob.h"
40#include "cifsproto.h"
41#include "cifs_unicode.h"
42#include "cifs_debug.h"
43#include "cifs_fs_sb.h"
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +053044#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070045
Steve French07b92d02013-02-18 10:34:26 -060046
Linus Torvalds1da177e2005-04-16 15:20:36 -070047static inline int cifs_convert_flags(unsigned int flags)
48{
49 if ((flags & O_ACCMODE) == O_RDONLY)
50 return GENERIC_READ;
51 else if ((flags & O_ACCMODE) == O_WRONLY)
52 return GENERIC_WRITE;
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);
58 }
59
Jeff Laytone10f7b52008-05-14 10:21:33 -070060 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
61 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
62 FILE_READ_DATA);
Steve French7fc8f4e2009-02-23 20:43:11 +000063}
Jeff Laytone10f7b52008-05-14 10:21:33 -070064
Jeff Layton608712f2010-10-15 15:33:56 -040065static u32 cifs_posix_convert_flags(unsigned int flags)
Steve French7fc8f4e2009-02-23 20:43:11 +000066{
Jeff Layton608712f2010-10-15 15:33:56 -040067 u32 posix_flags = 0;
Jeff Laytone10f7b52008-05-14 10:21:33 -070068
Steve French7fc8f4e2009-02-23 20:43:11 +000069 if ((flags & O_ACCMODE) == O_RDONLY)
Jeff Layton608712f2010-10-15 15:33:56 -040070 posix_flags = SMB_O_RDONLY;
Steve French7fc8f4e2009-02-23 20:43:11 +000071 else if ((flags & O_ACCMODE) == O_WRONLY)
Jeff Layton608712f2010-10-15 15:33:56 -040072 posix_flags = SMB_O_WRONLY;
73 else if ((flags & O_ACCMODE) == O_RDWR)
74 posix_flags = SMB_O_RDWR;
75
Steve French07b92d02013-02-18 10:34:26 -060076 if (flags & O_CREAT) {
Jeff Layton608712f2010-10-15 15:33:56 -040077 posix_flags |= SMB_O_CREAT;
Steve French07b92d02013-02-18 10:34:26 -060078 if (flags & O_EXCL)
79 posix_flags |= SMB_O_EXCL;
80 } else if (flags & O_EXCL)
Joe Perchesf96637b2013-05-04 22:12:25 -050081 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);
Steve French07b92d02013-02-18 10:34:26 -060083
Jeff Layton608712f2010-10-15 15:33:56 -040084 if (flags & O_TRUNC)
85 posix_flags |= SMB_O_TRUNC;
86 /* be safe and imply O_SYNC for O_DSYNC */
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +010087 if (flags & O_DSYNC)
Jeff Layton608712f2010-10-15 15:33:56 -040088 posix_flags |= SMB_O_SYNC;
Steve French7fc8f4e2009-02-23 20:43:11 +000089 if (flags & O_DIRECTORY)
Jeff Layton608712f2010-10-15 15:33:56 -040090 posix_flags |= SMB_O_DIRECTORY;
Steve French7fc8f4e2009-02-23 20:43:11 +000091 if (flags & O_NOFOLLOW)
Jeff Layton608712f2010-10-15 15:33:56 -040092 posix_flags |= SMB_O_NOFOLLOW;
Steve French7fc8f4e2009-02-23 20:43:11 +000093 if (flags & O_DIRECT)
Jeff Layton608712f2010-10-15 15:33:56 -040094 posix_flags |= SMB_O_DIRECT;
Steve French7fc8f4e2009-02-23 20:43:11 +000095
96 return posix_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -070097}
98
99static inline int cifs_get_disposition(unsigned int flags)
100{
101 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
102 return FILE_CREATE;
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)
106 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +0000107 else if ((flags & O_TRUNC) == O_TRUNC)
108 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 else
110 return FILE_OPEN;
111}
112
Jeff Layton608712f2010-10-15 15:33:56 -0400113int cifs_posix_open(char *full_path, struct inode **pinode,
114 struct super_block *sb, int mode, unsigned int f_flags,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400115 __u32 *poplock, __u16 *pnetfid, unsigned int xid)
Jeff Layton608712f2010-10-15 15:33:56 -0400116{
117 int rc;
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;
Steve French96daf2b2011-05-27 04:34:02 +0000123 struct cifs_tcon *tcon;
Jeff Layton608712f2010-10-15 15:33:56 -0400124
Joe Perchesf96637b2013-05-04 22:12:25 -0500125 cifs_dbg(FYI, "posix open %s\n", full_path);
Jeff Layton608712f2010-10-15 15:33:56 -0400126
127 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
128 if (presp_data == NULL)
129 return -ENOMEM;
130
131 tlink = cifs_sb_tlink(cifs_sb);
132 if (IS_ERR(tlink)) {
133 rc = PTR_ERR(tlink);
134 goto posix_open_ret;
135 }
136
137 tcon = tlink_tcon(tlink);
138 mode &= ~current_umask();
139
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,
Nakajima Akirabc8ebdc42015-02-13 15:35:58 +0900143 cifs_remap(cifs_sb));
Jeff Layton608712f2010-10-15 15:33:56 -0400144 cifs_put_tlink(tlink);
145
146 if (rc)
147 goto posix_open_ret;
148
149 if (presp_data->Type == cpu_to_le32(-1))
150 goto posix_open_ret; /* open ok, caller does qpathinfo */
151
152 if (!pinode)
153 goto posix_open_ret; /* caller does not need info */
154
155 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
156
157 /* get new inode and set it up */
158 if (*pinode == NULL) {
159 cifs_fill_uniqueid(sb, &fattr);
160 *pinode = cifs_iget(sb, &fattr);
161 if (!*pinode) {
162 rc = -ENOMEM;
163 goto posix_open_ret;
164 }
165 } else {
166 cifs_fattr_to_inode(*pinode, &fattr);
167 }
168
169posix_open_ret:
170 kfree(presp_data);
171 return rc;
172}
173
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300174static int
175cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700176 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
177 struct cifs_fid *fid, unsigned int xid)
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300178{
179 int rc;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700180 int desired_access;
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300181 int disposition;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500182 int create_options = CREATE_NOT_DIR;
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300183 FILE_ALL_INFO *buf;
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700184 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400185 struct cifs_open_parms oparms;
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300186
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700187 if (!server->ops->open)
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700188 return -ENOSYS;
189
190 desired_access = cifs_convert_flags(f_flags);
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300191
192/*********************************************************************
193 * open flag mapping table:
194 *
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
202 *
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)
208 *?
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 *********************************************************************/
215
216 disposition = cifs_get_disposition(f_flags);
217
218 /* BB pass O_SYNC flag through on file attributes .. BB */
219
220 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
221 if (!buf)
222 return -ENOMEM;
223
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500224 if (backup_cred(cifs_sb))
225 create_options |= CREATE_OPEN_BACKUP_INTENT;
226
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400227 oparms.tcon = tcon;
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;
233 oparms.fid = fid;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400234 oparms.reconnect = false;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400235
236 rc = server->ops->open(xid, &oparms, oplock, buf);
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300237
238 if (rc)
239 goto out;
240
241 if (tcon->unix_ext)
242 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
243 xid);
244 else
245 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
Steve French42eacf92014-02-10 14:08:16 -0600246 xid, fid);
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300247
248out:
249 kfree(buf);
250 return rc;
251}
252
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400253static bool
254cifs_has_mand_locks(struct cifsInodeInfo *cinode)
255{
256 struct cifs_fid_locks *cur;
257 bool has_locks = false;
258
259 down_read(&cinode->lock_sem);
260 list_for_each_entry(cur, &cinode->llist, llist) {
261 if (!list_empty(&cur->locks)) {
262 has_locks = true;
263 break;
264 }
265 }
266 up_read(&cinode->lock_sem);
267 return has_locks;
268}
269
Jeff Layton15ecb432010-10-15 15:34:02 -0400270struct cifsFileInfo *
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700271cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
Jeff Layton15ecb432010-10-15 15:34:02 -0400272 struct tcon_link *tlink, __u32 oplock)
273{
274 struct dentry *dentry = file->f_path.dentry;
David Howells2b0143b2015-03-17 22:25:59 +0000275 struct inode *inode = d_inode(dentry);
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700276 struct cifsInodeInfo *cinode = CIFS_I(inode);
277 struct cifsFileInfo *cfile;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700278 struct cifs_fid_locks *fdlocks;
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700279 struct cifs_tcon *tcon = tlink_tcon(tlink);
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400280 struct TCP_Server_Info *server = tcon->ses->server;
Jeff Layton15ecb432010-10-15 15:34:02 -0400281
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700282 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
283 if (cfile == NULL)
284 return cfile;
Jeff Layton15ecb432010-10-15 15:34:02 -0400285
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700286 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
287 if (!fdlocks) {
288 kfree(cfile);
289 return NULL;
290 }
291
292 INIT_LIST_HEAD(&fdlocks->locks);
293 fdlocks->cfile = cfile;
294 cfile->llist = fdlocks;
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700295 down_write(&cinode->lock_sem);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700296 list_add(&fdlocks->llist, &cinode->llist);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700297 up_write(&cinode->lock_sem);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700298
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700299 cfile->count = 1;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700300 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);
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700306 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700307 mutex_init(&cfile->fh_mutex);
Jeff Layton15ecb432010-10-15 15:34:02 -0400308
Mateusz Guzik24261fc2013-03-08 16:30:03 +0100309 cifs_sb_active(inode->i_sb);
310
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400311 /*
312 * If the server returned a read oplock and we have mandatory brlocks,
313 * set oplock level to None.
314 */
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400315 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500316 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400317 oplock = 0;
318 }
319
Jeff Layton44772882010-10-15 15:34:03 -0400320 spin_lock(&cifs_file_list_lock);
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400321 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700322 oplock = fid->pending_open->oplock;
323 list_del(&fid->pending_open->olist);
324
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400325 fid->purge_cache = false;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400326 server->ops->set_fid(cfile, fid, oplock);
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700327
328 list_add(&cfile->tlist, &tcon->openFileList);
Jeff Layton15ecb432010-10-15 15:34:02 -0400329 /* if readable file instance put first in list*/
330 if (file->f_mode & FMODE_READ)
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700331 list_add(&cfile->flist, &cinode->openFileList);
Jeff Layton15ecb432010-10-15 15:34:02 -0400332 else
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700333 list_add_tail(&cfile->flist, &cinode->openFileList);
Jeff Layton44772882010-10-15 15:34:03 -0400334 spin_unlock(&cifs_file_list_lock);
Jeff Layton15ecb432010-10-15 15:34:02 -0400335
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400336 if (fid->purge_cache)
Jeff Layton4f73c7d2014-04-30 09:31:47 -0400337 cifs_zap_mapping(inode);
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400338
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700339 file->private_data = cfile;
340 return cfile;
Jeff Layton15ecb432010-10-15 15:34:02 -0400341}
342
Jeff Layton764a1b12012-07-25 14:59:54 -0400343struct cifsFileInfo *
344cifsFileInfo_get(struct cifsFileInfo *cifs_file)
345{
346 spin_lock(&cifs_file_list_lock);
347 cifsFileInfo_get_locked(cifs_file);
348 spin_unlock(&cifs_file_list_lock);
349 return cifs_file;
350}
351
Steve Frenchcdff08e2010-10-21 22:46:14 +0000352/*
353 * Release a reference on the file private data. This may involve closing
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400354 * the filehandle out on the server. Must be called without holding
355 * cifs_file_list_lock.
Steve Frenchcdff08e2010-10-21 22:46:14 +0000356 */
Jeff Laytonb33879a2010-10-15 15:34:04 -0400357void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
358{
David Howells2b0143b2015-03-17 22:25:59 +0000359 struct inode *inode = d_inode(cifs_file->dentry);
Steve French96daf2b2011-05-27 04:34:02 +0000360 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700361 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300362 struct cifsInodeInfo *cifsi = CIFS_I(inode);
Mateusz Guzik24261fc2013-03-08 16:30:03 +0100363 struct super_block *sb = inode->i_sb;
364 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000365 struct cifsLockInfo *li, *tmp;
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700366 struct cifs_fid fid;
367 struct cifs_pending_open open;
Sachin Prabhuca7df8e2015-01-15 12:22:04 +0000368 bool oplock_break_cancelled;
Steve Frenchcdff08e2010-10-21 22:46:14 +0000369
370 spin_lock(&cifs_file_list_lock);
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400371 if (--cifs_file->count > 0) {
Steve Frenchcdff08e2010-10-21 22:46:14 +0000372 spin_unlock(&cifs_file_list_lock);
373 return;
Jeff Laytonb33879a2010-10-15 15:34:04 -0400374 }
Steve Frenchcdff08e2010-10-21 22:46:14 +0000375
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700376 if (server->ops->get_lease_key)
377 server->ops->get_lease_key(inode, &fid);
378
379 /* store open in pending opens to make sure we don't miss lease break */
380 cifs_add_pending_open_locked(&fid, cifs_file->tlink, &open);
381
Steve Frenchcdff08e2010-10-21 22:46:14 +0000382 /* remove it from the lists */
383 list_del(&cifs_file->flist);
384 list_del(&cifs_file->tlist);
385
386 if (list_empty(&cifsi->openFileList)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500387 cifs_dbg(FYI, "closing last open instance for inode %p\n",
David Howells2b0143b2015-03-17 22:25:59 +0000388 d_inode(cifs_file->dentry));
Pavel Shilovsky25364132012-09-18 16:20:27 -0700389 /*
390 * In strict cache mode we need invalidate mapping on the last
391 * close because it may cause a error when we open this file
392 * again and get at least level II oplock.
393 */
Pavel Shilovsky4f8ba8a2010-11-21 22:36:12 +0300394 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
Jeff Laytonaff8d5c2014-04-30 09:31:45 -0400395 set_bit(CIFS_INO_INVALID_MAPPING, &cifsi->flags);
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300396 cifs_set_oplock_level(cifsi, 0);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000397 }
398 spin_unlock(&cifs_file_list_lock);
399
Sachin Prabhuca7df8e2015-01-15 12:22:04 +0000400 oplock_break_cancelled = cancel_work_sync(&cifs_file->oplock_break);
Jeff Laytonad635942011-07-26 12:20:17 -0400401
Steve Frenchcdff08e2010-10-21 22:46:14 +0000402 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
Pavel Shilovsky0ff78a22012-09-18 16:20:26 -0700403 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400404 unsigned int xid;
Pavel Shilovsky0ff78a22012-09-18 16:20:26 -0700405
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400406 xid = get_xid();
Pavel Shilovsky0ff78a22012-09-18 16:20:26 -0700407 if (server->ops->close)
Pavel Shilovsky760ad0c2012-09-25 11:00:07 +0400408 server->ops->close(xid, tcon, &cifs_file->fid);
409 _free_xid(xid);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000410 }
411
Sachin Prabhuca7df8e2015-01-15 12:22:04 +0000412 if (oplock_break_cancelled)
413 cifs_done_oplock_break(cifsi);
414
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700415 cifs_del_pending_open(&open);
416
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700417 /*
418 * Delete any outstanding lock records. We'll lose them when the file
Steve Frenchcdff08e2010-10-21 22:46:14 +0000419 * is closed anyway.
420 */
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700421 down_write(&cifsi->lock_sem);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700422 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
Steve Frenchcdff08e2010-10-21 22:46:14 +0000423 list_del(&li->llist);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400424 cifs_del_lock_waiters(li);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000425 kfree(li);
426 }
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700427 list_del(&cifs_file->llist->llist);
428 kfree(cifs_file->llist);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700429 up_write(&cifsi->lock_sem);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000430
431 cifs_put_tlink(cifs_file->tlink);
432 dput(cifs_file->dentry);
Mateusz Guzik24261fc2013-03-08 16:30:03 +0100433 cifs_sb_deactive(sb);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000434 kfree(cifs_file);
Jeff Laytonb33879a2010-10-15 15:34:04 -0400435}
436
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437int cifs_open(struct inode *inode, struct file *file)
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439{
440 int rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400441 unsigned int xid;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400442 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 struct cifs_sb_info *cifs_sb;
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700444 struct TCP_Server_Info *server;
Steve French96daf2b2011-05-27 04:34:02 +0000445 struct cifs_tcon *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400446 struct tcon_link *tlink;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700447 struct cifsFileInfo *cfile = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 char *full_path = NULL;
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300449 bool posix_open_ok = false;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700450 struct cifs_fid fid;
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700451 struct cifs_pending_open open;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400453 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454
455 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400456 tlink = cifs_sb_tlink(cifs_sb);
457 if (IS_ERR(tlink)) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400458 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400459 return PTR_ERR(tlink);
460 }
461 tcon = tlink_tcon(tlink);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700462 server = tcon->ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800464 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530466 rc = -ENOMEM;
Jeff Layton232341b2010-08-05 13:58:38 -0400467 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700468 }
469
Joe Perchesf96637b2013-05-04 22:12:25 -0500470 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +0000471 inode, file->f_flags, full_path);
Steve French276a74a2009-03-03 18:00:34 +0000472
Namjae Jeon787aded2014-08-22 14:22:51 +0900473 if (file->f_flags & O_DIRECT &&
474 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
475 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
476 file->f_op = &cifs_file_direct_nobrl_ops;
477 else
478 file->f_op = &cifs_file_direct_ops;
479 }
480
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700481 if (server->oplocks)
Steve French276a74a2009-03-03 18:00:34 +0000482 oplock = REQ_OPLOCK;
483 else
484 oplock = 0;
485
Steve French64cc2c62009-03-04 19:54:08 +0000486 if (!tcon->broken_posix_open && tcon->unix_ext &&
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400487 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
488 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Steve French276a74a2009-03-03 18:00:34 +0000489 /* can not refresh inode info since size could be stale */
Jeff Layton2422f672010-06-16 13:40:16 -0400490 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000491 cifs_sb->mnt_file_mode /* ignored */,
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700492 file->f_flags, &oplock, &fid.netfid, xid);
Steve French276a74a2009-03-03 18:00:34 +0000493 if (rc == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500494 cifs_dbg(FYI, "posix open succeeded\n");
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300495 posix_open_ok = true;
Steve French64cc2c62009-03-04 19:54:08 +0000496 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
497 if (tcon->ses->serverNOS)
Joe Perchesf96637b2013-05-04 22:12:25 -0500498 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",
499 tcon->ses->serverName,
500 tcon->ses->serverNOS);
Steve French64cc2c62009-03-04 19:54:08 +0000501 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000502 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
503 (rc != -EOPNOTSUPP)) /* path not found or net err */
504 goto out;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700505 /*
506 * Else fallthrough to retry open the old way on network i/o
507 * or DFS errors.
508 */
Steve French276a74a2009-03-03 18:00:34 +0000509 }
510
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700511 if (server->ops->get_lease_key)
512 server->ops->get_lease_key(inode, &fid);
513
514 cifs_add_pending_open(&fid, tlink, &open);
515
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300516 if (!posix_open_ok) {
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700517 if (server->ops->get_lease_key)
518 server->ops->get_lease_key(inode, &fid);
519
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300520 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700521 file->f_flags, &oplock, &fid, xid);
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700522 if (rc) {
523 cifs_del_pending_open(&open);
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300524 goto out;
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700525 }
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300526 }
Jeff Layton47c78b72010-06-16 13:40:17 -0400527
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700528 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
529 if (cfile == NULL) {
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700530 if (server->ops->close)
531 server->ops->close(xid, tcon, &fid);
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700532 cifs_del_pending_open(&open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 rc = -ENOMEM;
534 goto out;
535 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530537 cifs_fscache_set_inode_cookie(inode, file);
538
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300539 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700540 /*
541 * Time to set mode which we can not set earlier due to
542 * problems creating new read-only files.
543 */
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300544 struct cifs_unix_set_info_args args = {
545 .mode = inode->i_mode,
Eric W. Biederman49418b22013-02-06 00:57:56 -0800546 .uid = INVALID_UID, /* no change */
547 .gid = INVALID_GID, /* no change */
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300548 .ctime = NO_CHANGE_64,
549 .atime = NO_CHANGE_64,
550 .mtime = NO_CHANGE_64,
551 .device = 0,
552 };
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700553 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
554 cfile->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 }
556
557out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400559 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400560 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561 return rc;
562}
563
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400564static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
565
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700566/*
567 * Try to reacquire byte range locks that were released when session
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400568 * to server was lost.
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700569 */
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400570static int
571cifs_relock_file(struct cifsFileInfo *cfile)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572{
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400573 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
David Howells2b0143b2015-03-17 22:25:59 +0000574 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400575 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 int rc = 0;
577
Pavel Shilovsky689c3db2013-07-11 11:17:45 +0400578 down_read(&cinode->lock_sem);
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400579 if (cinode->can_cache_brlcks) {
Pavel Shilovsky689c3db2013-07-11 11:17:45 +0400580 /* can cache locks - no need to relock */
581 up_read(&cinode->lock_sem);
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400582 return rc;
583 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700584
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400585 if (cap_unix(tcon->ses) &&
586 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
587 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
588 rc = cifs_push_posix_locks(cfile);
589 else
590 rc = tcon->ses->server->ops->push_mand_locks(cfile);
591
Pavel Shilovsky689c3db2013-07-11 11:17:45 +0400592 up_read(&cinode->lock_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 return rc;
594}
595
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700596static int
597cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598{
599 int rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400600 unsigned int xid;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400601 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +0000603 struct cifs_tcon *tcon;
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700604 struct TCP_Server_Info *server;
605 struct cifsInodeInfo *cinode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000606 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 char *full_path = NULL;
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700608 int desired_access;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 int disposition = FILE_OPEN;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500610 int create_options = CREATE_NOT_DIR;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400611 struct cifs_open_parms oparms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400613 xid = get_xid();
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700614 mutex_lock(&cfile->fh_mutex);
615 if (!cfile->invalidHandle) {
616 mutex_unlock(&cfile->fh_mutex);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530617 rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400618 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530619 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 }
621
David Howells2b0143b2015-03-17 22:25:59 +0000622 inode = d_inode(cfile->dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 cifs_sb = CIFS_SB(inode->i_sb);
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700624 tcon = tlink_tcon(cfile->tlink);
625 server = tcon->ses->server;
Steve French3a9f4622007-04-04 17:10:24 +0000626
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700627 /*
628 * Can not grab rename sem here because various ops, including those
629 * that already have the rename sem can end up causing writepage to get
630 * called and if the server was down that means we end up here, and we
631 * can never tell if the caller already has the rename_sem.
632 */
633 full_path = build_path_from_dentry(cfile->dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000635 rc = -ENOMEM;
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700636 mutex_unlock(&cfile->fh_mutex);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400637 free_xid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000638 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 }
640
Joe Perchesf96637b2013-05-04 22:12:25 -0500641 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
642 inode, cfile->f_flags, full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300644 if (tcon->ses->server->oplocks)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 oplock = REQ_OPLOCK;
646 else
Steve French4b18f2a2008-04-29 00:06:05 +0000647 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400649 if (tcon->unix_ext && cap_unix(tcon->ses) &&
Steve French7fc8f4e2009-02-23 20:43:11 +0000650 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400651 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton608712f2010-10-15 15:33:56 -0400652 /*
653 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
654 * original open. Must mask them off for a reopen.
655 */
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700656 unsigned int oflags = cfile->f_flags &
Jeff Layton15886172010-10-15 15:33:59 -0400657 ~(O_CREAT | O_EXCL | O_TRUNC);
Jeff Layton608712f2010-10-15 15:33:56 -0400658
Jeff Layton2422f672010-06-16 13:40:16 -0400659 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700660 cifs_sb->mnt_file_mode /* ignored */,
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400661 oflags, &oplock, &cfile->fid.netfid, xid);
Steve French7fc8f4e2009-02-23 20:43:11 +0000662 if (rc == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500663 cifs_dbg(FYI, "posix reopen succeeded\n");
Andi Shytife090e42013-07-29 20:04:35 +0200664 oparms.reconnect = true;
Steve French7fc8f4e2009-02-23 20:43:11 +0000665 goto reopen_success;
666 }
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700667 /*
668 * fallthrough to retry open the old way on errors, especially
669 * in the reconnect path it is important to retry hard
670 */
Steve French7fc8f4e2009-02-23 20:43:11 +0000671 }
672
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700673 desired_access = cifs_convert_flags(cfile->f_flags);
Steve French7fc8f4e2009-02-23 20:43:11 +0000674
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500675 if (backup_cred(cifs_sb))
676 create_options |= CREATE_OPEN_BACKUP_INTENT;
677
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700678 if (server->ops->get_lease_key)
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400679 server->ops->get_lease_key(inode, &cfile->fid);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700680
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400681 oparms.tcon = tcon;
682 oparms.cifs_sb = cifs_sb;
683 oparms.desired_access = desired_access;
684 oparms.create_options = create_options;
685 oparms.disposition = disposition;
686 oparms.path = full_path;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400687 oparms.fid = &cfile->fid;
688 oparms.reconnect = true;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400689
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700690 /*
691 * Can not refresh inode by passing in file_info buf to be returned by
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400692 * ops->open and then calling get_inode_info with returned buf since
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700693 * file might have write behind data that needs to be flushed and server
694 * version of file size can be stale. If we knew for sure that inode was
695 * not dirty locally we could do this.
696 */
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400697 rc = server->ops->open(xid, &oparms, &oplock, NULL);
Pavel Shilovskyb33fcf12013-07-11 10:58:30 +0400698 if (rc == -ENOENT && oparms.reconnect == false) {
699 /* durable handle timeout is expired - open the file again */
700 rc = server->ops->open(xid, &oparms, &oplock, NULL);
701 /* indicate that we need to relock the file */
702 oparms.reconnect = true;
703 }
704
Linus Torvalds1da177e2005-04-16 15:20:36 -0700705 if (rc) {
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700706 mutex_unlock(&cfile->fh_mutex);
Joe Perchesf96637b2013-05-04 22:12:25 -0500707 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
708 cifs_dbg(FYI, "oplock: %d\n", oplock);
Jeff Layton15886172010-10-15 15:33:59 -0400709 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700710 }
Jeff Layton15886172010-10-15 15:33:59 -0400711
712reopen_success:
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700713 cfile->invalidHandle = false;
714 mutex_unlock(&cfile->fh_mutex);
715 cinode = CIFS_I(inode);
Jeff Layton15886172010-10-15 15:33:59 -0400716
717 if (can_flush) {
718 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -0400719 mapping_set_error(inode->i_mapping, rc);
Jeff Layton15886172010-10-15 15:33:59 -0400720
Jeff Layton15886172010-10-15 15:33:59 -0400721 if (tcon->unix_ext)
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700722 rc = cifs_get_inode_info_unix(&inode, full_path,
723 inode->i_sb, xid);
Jeff Layton15886172010-10-15 15:33:59 -0400724 else
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700725 rc = cifs_get_inode_info(&inode, full_path, NULL,
726 inode->i_sb, xid, NULL);
727 }
728 /*
729 * Else we are writing out data to server already and could deadlock if
730 * we tried to flush data, and since we do not know if we have data that
731 * would invalidate the current end of file on the server we can not go
732 * to the server to get the new inode info.
733 */
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300734
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400735 server->ops->set_fid(cfile, &cfile->fid, oplock);
736 if (oparms.reconnect)
737 cifs_relock_file(cfile);
Jeff Layton15886172010-10-15 15:33:59 -0400738
739reopen_error_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400741 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 return rc;
743}
744
745int cifs_close(struct inode *inode, struct file *file)
746{
Jeff Layton77970692011-04-05 16:23:47 -0700747 if (file->private_data != NULL) {
748 cifsFileInfo_put(file->private_data);
749 file->private_data = NULL;
750 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751
Steve Frenchcdff08e2010-10-21 22:46:14 +0000752 /* return code from the ->release op is always ignored */
753 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754}
755
756int cifs_closedir(struct inode *inode, struct file *file)
757{
758 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400759 unsigned int xid;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700760 struct cifsFileInfo *cfile = file->private_data;
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700761 struct cifs_tcon *tcon;
762 struct TCP_Server_Info *server;
763 char *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
Joe Perchesf96637b2013-05-04 22:12:25 -0500765 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700767 if (cfile == NULL)
768 return rc;
769
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400770 xid = get_xid();
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700771 tcon = tlink_tcon(cfile->tlink);
772 server = tcon->ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700773
Joe Perchesf96637b2013-05-04 22:12:25 -0500774 cifs_dbg(FYI, "Freeing private data in close dir\n");
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700775 spin_lock(&cifs_file_list_lock);
Pavel Shilovsky52755802014-08-18 20:49:57 +0400776 if (server->ops->dir_needs_close(cfile)) {
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700777 cfile->invalidHandle = true;
778 spin_unlock(&cifs_file_list_lock);
779 if (server->ops->close_dir)
780 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
781 else
782 rc = -ENOSYS;
Joe Perchesf96637b2013-05-04 22:12:25 -0500783 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700784 /* not much we can do if it fails anyway, ignore rc */
785 rc = 0;
786 } else
787 spin_unlock(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700788
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700789 buf = cfile->srch_inf.ntwrk_buf_start;
790 if (buf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500791 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700792 cfile->srch_inf.ntwrk_buf_start = NULL;
793 if (cfile->srch_inf.smallBuf)
794 cifs_small_buf_release(buf);
795 else
796 cifs_buf_release(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700797 }
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700798
799 cifs_put_tlink(cfile->tlink);
800 kfree(file->private_data);
801 file->private_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802 /* BB can we lock the filestruct while this is going on? */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400803 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804 return rc;
805}
806
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400807static struct cifsLockInfo *
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300808cifs_lock_init(__u64 offset, __u64 length, __u8 type)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000809{
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400810 struct cifsLockInfo *lock =
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000811 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400812 if (!lock)
813 return lock;
814 lock->offset = offset;
815 lock->length = length;
816 lock->type = type;
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400817 lock->pid = current->tgid;
818 INIT_LIST_HEAD(&lock->blist);
819 init_waitqueue_head(&lock->block_q);
820 return lock;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400821}
822
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -0700823void
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400824cifs_del_lock_waiters(struct cifsLockInfo *lock)
825{
826 struct cifsLockInfo *li, *tmp;
827 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
828 list_del_init(&li->blist);
829 wake_up(&li->block_q);
830 }
831}
832
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400833#define CIFS_LOCK_OP 0
834#define CIFS_READ_OP 1
835#define CIFS_WRITE_OP 2
836
837/* @rw_check : 0 - no op, 1 - read, 2 - write */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400838static bool
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700839cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
840 __u64 length, __u8 type, struct cifsFileInfo *cfile,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400841 struct cifsLockInfo **conf_lock, int rw_check)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400842{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300843 struct cifsLockInfo *li;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700844 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300845 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400846
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700847 list_for_each_entry(li, &fdlocks->locks, llist) {
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400848 if (offset + length <= li->offset ||
849 offset >= li->offset + li->length)
850 continue;
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400851 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
852 server->ops->compare_fids(cfile, cur_cfile)) {
853 /* shared lock prevents write op through the same fid */
854 if (!(li->type & server->vals->shared_lock_type) ||
855 rw_check != CIFS_WRITE_OP)
856 continue;
857 }
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700858 if ((type & server->vals->shared_lock_type) &&
859 ((server->ops->compare_fids(cfile, cur_cfile) &&
860 current->tgid == li->pid) || type == li->type))
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400861 continue;
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700862 if (conf_lock)
863 *conf_lock = li;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700864 return true;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400865 }
866 return false;
867}
868
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700869bool
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300870cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700871 __u8 type, struct cifsLockInfo **conf_lock,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400872 int rw_check)
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400873{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300874 bool rc = false;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700875 struct cifs_fid_locks *cur;
David Howells2b0143b2015-03-17 22:25:59 +0000876 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300877
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700878 list_for_each_entry(cur, &cinode->llist, llist) {
879 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700880 cfile, conf_lock, rw_check);
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300881 if (rc)
882 break;
883 }
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300884
885 return rc;
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400886}
887
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300888/*
889 * Check if there is another lock that prevents us to set the lock (mandatory
890 * style). If such a lock exists, update the flock structure with its
891 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
892 * or leave it the same if we can't. Returns 0 if we don't need to request to
893 * the server or 1 otherwise.
894 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400895static int
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300896cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
897 __u8 type, struct file_lock *flock)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400898{
899 int rc = 0;
900 struct cifsLockInfo *conf_lock;
David Howells2b0143b2015-03-17 22:25:59 +0000901 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300902 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400903 bool exist;
904
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700905 down_read(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400906
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300907 exist = cifs_find_lock_conflict(cfile, offset, length, type,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400908 &conf_lock, CIFS_LOCK_OP);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400909 if (exist) {
910 flock->fl_start = conf_lock->offset;
911 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
912 flock->fl_pid = conf_lock->pid;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300913 if (conf_lock->type & server->vals->shared_lock_type)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400914 flock->fl_type = F_RDLCK;
915 else
916 flock->fl_type = F_WRLCK;
917 } else if (!cinode->can_cache_brlcks)
918 rc = 1;
919 else
920 flock->fl_type = F_UNLCK;
921
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700922 up_read(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400923 return rc;
924}
925
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400926static void
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300927cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400928{
David Howells2b0143b2015-03-17 22:25:59 +0000929 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700930 down_write(&cinode->lock_sem);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700931 list_add_tail(&lock->llist, &cfile->llist->locks);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700932 up_write(&cinode->lock_sem);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000933}
934
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300935/*
936 * Set the byte-range lock (mandatory style). Returns:
937 * 1) 0, if we set the lock and don't need to request to the server;
938 * 2) 1, if no locks prevent us but we need to request to the server;
939 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
940 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400941static int
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300942cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400943 bool wait)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400944{
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400945 struct cifsLockInfo *conf_lock;
David Howells2b0143b2015-03-17 22:25:59 +0000946 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400947 bool exist;
948 int rc = 0;
949
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400950try_again:
951 exist = false;
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700952 down_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400953
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300954 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400955 lock->type, &conf_lock, CIFS_LOCK_OP);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400956 if (!exist && cinode->can_cache_brlcks) {
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700957 list_add_tail(&lock->llist, &cfile->llist->locks);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700958 up_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400959 return rc;
960 }
961
962 if (!exist)
963 rc = 1;
964 else if (!wait)
965 rc = -EACCES;
966 else {
967 list_add_tail(&lock->blist, &conf_lock->blist);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700968 up_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400969 rc = wait_event_interruptible(lock->block_q,
970 (lock->blist.prev == &lock->blist) &&
971 (lock->blist.next == &lock->blist));
972 if (!rc)
973 goto try_again;
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700974 down_write(&cinode->lock_sem);
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400975 list_del_init(&lock->blist);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400976 }
977
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700978 up_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400979 return rc;
980}
981
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300982/*
983 * Check if there is another lock that prevents us to set the lock (posix
984 * style). If such a lock exists, update the flock structure with its
985 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
986 * or leave it the same if we can't. Returns 0 if we don't need to request to
987 * the server or 1 otherwise.
988 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400989static int
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400990cifs_posix_lock_test(struct file *file, struct file_lock *flock)
991{
992 int rc = 0;
Al Viro496ad9a2013-01-23 17:07:38 -0500993 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400994 unsigned char saved_type = flock->fl_type;
995
Pavel Shilovsky50792762011-10-29 17:17:57 +0400996 if ((flock->fl_flags & FL_POSIX) == 0)
997 return 1;
998
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700999 down_read(&cinode->lock_sem);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001000 posix_test_lock(file, flock);
1001
1002 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1003 flock->fl_type = saved_type;
1004 rc = 1;
1005 }
1006
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001007 up_read(&cinode->lock_sem);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001008 return rc;
1009}
1010
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +03001011/*
1012 * Set the byte-range lock (posix style). Returns:
1013 * 1) 0, if we set the lock and don't need to request to the server;
1014 * 2) 1, if we need to request to the server;
1015 * 3) <0, if the error occurs while setting the lock.
1016 */
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001017static int
1018cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1019{
Al Viro496ad9a2013-01-23 17:07:38 -05001020 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
Pavel Shilovsky50792762011-10-29 17:17:57 +04001021 int rc = 1;
1022
1023 if ((flock->fl_flags & FL_POSIX) == 0)
1024 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001025
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001026try_again:
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001027 down_write(&cinode->lock_sem);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001028 if (!cinode->can_cache_brlcks) {
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001029 up_write(&cinode->lock_sem);
Pavel Shilovsky50792762011-10-29 17:17:57 +04001030 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001031 }
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001032
1033 rc = posix_lock_file(file, flock, NULL);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001034 up_write(&cinode->lock_sem);
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001035 if (rc == FILE_LOCK_DEFERRED) {
1036 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
1037 if (!rc)
1038 goto try_again;
Jeff Layton1a9e64a2013-06-21 08:58:10 -04001039 posix_unblock_lock(flock);
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001040 }
Steve French9ebb3892012-04-01 13:52:54 -05001041 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001042}
1043
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001044int
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001045cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001046{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001047 unsigned int xid;
1048 int rc = 0, stored_rc;
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001049 struct cifsLockInfo *li, *tmp;
1050 struct cifs_tcon *tcon;
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001051 unsigned int num, max_num, max_buf;
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001052 LOCKING_ANDX_RANGE *buf, *cur;
1053 int types[] = {LOCKING_ANDX_LARGE_FILES,
1054 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1055 int i;
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001056
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001057 xid = get_xid();
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001058 tcon = tlink_tcon(cfile->tlink);
1059
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001060 /*
1061 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1062 * and check it for zero before using.
1063 */
1064 max_buf = tcon->ses->server->maxBuf;
1065 if (!max_buf) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001066 free_xid(xid);
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001067 return -EINVAL;
1068 }
1069
1070 max_num = (max_buf - sizeof(struct smb_hdr)) /
1071 sizeof(LOCKING_ANDX_RANGE);
Fabian Frederick4b99d392014-12-10 15:41:17 -08001072 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001073 if (!buf) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001074 free_xid(xid);
Pavel Shilovskye2f28862012-08-29 21:13:38 +04001075 return -ENOMEM;
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001076 }
1077
1078 for (i = 0; i < 2; i++) {
1079 cur = buf;
1080 num = 0;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001081 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001082 if (li->type != types[i])
1083 continue;
1084 cur->Pid = cpu_to_le16(li->pid);
1085 cur->LengthLow = cpu_to_le32((u32)li->length);
1086 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1087 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1088 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1089 if (++num == max_num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001090 stored_rc = cifs_lockv(xid, tcon,
1091 cfile->fid.netfid,
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001092 (__u8)li->type, 0, num,
1093 buf);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001094 if (stored_rc)
1095 rc = stored_rc;
1096 cur = buf;
1097 num = 0;
1098 } else
1099 cur++;
1100 }
1101
1102 if (num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001103 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001104 (__u8)types[i], 0, num, buf);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001105 if (stored_rc)
1106 rc = stored_rc;
1107 }
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001108 }
1109
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001110 kfree(buf);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001111 free_xid(xid);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001112 return rc;
1113}
1114
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001115struct lock_to_push {
1116 struct list_head llist;
1117 __u64 offset;
1118 __u64 length;
1119 __u32 pid;
1120 __u16 netfid;
1121 __u8 type;
1122};
1123
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001124static int
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001125cifs_push_posix_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001126{
David Howells2b0143b2015-03-17 22:25:59 +00001127 struct inode *inode = d_inode(cfile->dentry);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001128 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05001129 struct file_lock *flock;
1130 struct file_lock_context *flctx = inode->i_flctx;
Jeff Laytone084c1b2015-02-16 14:32:03 -05001131 unsigned int count = 0, i;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001132 int rc = 0, xid, type;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001133 struct list_head locks_to_send, *el;
1134 struct lock_to_push *lck, *tmp;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001135 __u64 length;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001136
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001137 xid = get_xid();
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001138
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05001139 if (!flctx)
1140 goto out;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001141
Jeff Laytone084c1b2015-02-16 14:32:03 -05001142 spin_lock(&flctx->flc_lock);
1143 list_for_each(el, &flctx->flc_posix) {
1144 count++;
1145 }
1146 spin_unlock(&flctx->flc_lock);
1147
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001148 INIT_LIST_HEAD(&locks_to_send);
1149
1150 /*
Jeff Laytone084c1b2015-02-16 14:32:03 -05001151 * Allocating count locks is enough because no FL_POSIX locks can be
1152 * added to the list while we are holding cinode->lock_sem that
Pavel Shilovskyce858522012-03-17 09:46:55 +03001153 * protects locking operations of this inode.
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001154 */
Jeff Laytone084c1b2015-02-16 14:32:03 -05001155 for (i = 0; i < count; i++) {
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001156 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1157 if (!lck) {
1158 rc = -ENOMEM;
1159 goto err_out;
1160 }
1161 list_add_tail(&lck->llist, &locks_to_send);
1162 }
1163
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001164 el = locks_to_send.next;
Jeff Layton6109c852015-01-16 15:05:57 -05001165 spin_lock(&flctx->flc_lock);
Jeff Laytonbd61e0a2015-01-16 15:05:55 -05001166 list_for_each_entry(flock, &flctx->flc_posix, fl_list) {
Pavel Shilovskyce858522012-03-17 09:46:55 +03001167 if (el == &locks_to_send) {
1168 /*
1169 * The list ended. We don't have enough allocated
1170 * structures - something is really wrong.
1171 */
Joe Perchesf96637b2013-05-04 22:12:25 -05001172 cifs_dbg(VFS, "Can't push all brlocks!\n");
Pavel Shilovskyce858522012-03-17 09:46:55 +03001173 break;
1174 }
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001175 length = 1 + flock->fl_end - flock->fl_start;
1176 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1177 type = CIFS_RDLCK;
1178 else
1179 type = CIFS_WRLCK;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001180 lck = list_entry(el, struct lock_to_push, llist);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001181 lck->pid = flock->fl_pid;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001182 lck->netfid = cfile->fid.netfid;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001183 lck->length = length;
1184 lck->type = type;
1185 lck->offset = flock->fl_start;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001186 }
Jeff Layton6109c852015-01-16 15:05:57 -05001187 spin_unlock(&flctx->flc_lock);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001188
1189 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001190 int stored_rc;
1191
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001192 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
Jeff Laytonc5fd3632012-07-23 13:28:37 -04001193 lck->offset, lck->length, NULL,
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001194 lck->type, 0);
1195 if (stored_rc)
1196 rc = stored_rc;
1197 list_del(&lck->llist);
1198 kfree(lck);
1199 }
1200
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001201out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001202 free_xid(xid);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001203 return rc;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001204err_out:
1205 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1206 list_del(&lck->llist);
1207 kfree(lck);
1208 }
1209 goto out;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001210}
1211
1212static int
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001213cifs_push_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky9ec3c882012-11-22 17:00:10 +04001214{
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001215 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
David Howells2b0143b2015-03-17 22:25:59 +00001216 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001217 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky9ec3c882012-11-22 17:00:10 +04001218 int rc = 0;
1219
1220 /* we are going to update can_cache_brlcks here - need a write access */
1221 down_write(&cinode->lock_sem);
1222 if (!cinode->can_cache_brlcks) {
1223 up_write(&cinode->lock_sem);
1224 return rc;
1225 }
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001226
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001227 if (cap_unix(tcon->ses) &&
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001228 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1229 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001230 rc = cifs_push_posix_locks(cfile);
1231 else
1232 rc = tcon->ses->server->ops->push_mand_locks(cfile);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001233
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001234 cinode->can_cache_brlcks = false;
1235 up_write(&cinode->lock_sem);
1236 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001237}
1238
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001239static void
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001240cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001241 bool *wait_flag, struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242{
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001243 if (flock->fl_flags & FL_POSIX)
Joe Perchesf96637b2013-05-04 22:12:25 -05001244 cifs_dbg(FYI, "Posix\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001245 if (flock->fl_flags & FL_FLOCK)
Joe Perchesf96637b2013-05-04 22:12:25 -05001246 cifs_dbg(FYI, "Flock\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001247 if (flock->fl_flags & FL_SLEEP) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001248 cifs_dbg(FYI, "Blocking lock\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001249 *wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001250 }
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001251 if (flock->fl_flags & FL_ACCESS)
Joe Perchesf96637b2013-05-04 22:12:25 -05001252 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001253 if (flock->fl_flags & FL_LEASE)
Joe Perchesf96637b2013-05-04 22:12:25 -05001254 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001255 if (flock->fl_flags &
Jeff Layton3d6d8542012-09-19 06:22:46 -07001256 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1257 FL_ACCESS | FL_LEASE | FL_CLOSE)))
Joe Perchesf96637b2013-05-04 22:12:25 -05001258 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001260 *type = server->vals->large_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001261 if (flock->fl_type == F_WRLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001262 cifs_dbg(FYI, "F_WRLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001263 *type |= server->vals->exclusive_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001264 *lock = 1;
1265 } else if (flock->fl_type == F_UNLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001266 cifs_dbg(FYI, "F_UNLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001267 *type |= server->vals->unlock_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001268 *unlock = 1;
1269 /* Check if unlock includes more than one lock range */
1270 } else if (flock->fl_type == F_RDLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001271 cifs_dbg(FYI, "F_RDLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001272 *type |= server->vals->shared_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001273 *lock = 1;
1274 } else if (flock->fl_type == F_EXLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001275 cifs_dbg(FYI, "F_EXLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001276 *type |= server->vals->exclusive_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001277 *lock = 1;
1278 } else if (flock->fl_type == F_SHLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001279 cifs_dbg(FYI, "F_SHLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001280 *type |= server->vals->shared_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001281 *lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001282 } else
Joe Perchesf96637b2013-05-04 22:12:25 -05001283 cifs_dbg(FYI, "Unknown type of lock\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001284}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001286static int
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001287cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001288 bool wait_flag, bool posix_lck, unsigned int xid)
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001289{
1290 int rc = 0;
1291 __u64 length = 1 + flock->fl_end - flock->fl_start;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001292 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1293 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001294 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001295 __u16 netfid = cfile->fid.netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001297 if (posix_lck) {
1298 int posix_lock_type;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001299
1300 rc = cifs_posix_lock_test(file, flock);
1301 if (!rc)
1302 return rc;
1303
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001304 if (type & server->vals->shared_lock_type)
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001305 posix_lock_type = CIFS_RDLCK;
1306 else
1307 posix_lock_type = CIFS_WRLCK;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001308 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
Jeff Laytonc5fd3632012-07-23 13:28:37 -04001309 flock->fl_start, length, flock,
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001310 posix_lock_type, wait_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001311 return rc;
1312 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001313
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001314 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001315 if (!rc)
1316 return rc;
1317
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001318 /* BB we could chain these into one lock request BB */
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001319 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1320 1, 0, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001321 if (rc == 0) {
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001322 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1323 type, 0, 1, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001324 flock->fl_type = F_UNLCK;
1325 if (rc != 0)
Joe Perchesf96637b2013-05-04 22:12:25 -05001326 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1327 rc);
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001328 return 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001329 }
1330
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001331 if (type & server->vals->shared_lock_type) {
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001332 flock->fl_type = F_WRLCK;
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001333 return 0;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001334 }
1335
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001336 type &= ~server->vals->exclusive_lock_type;
1337
1338 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1339 type | server->vals->shared_lock_type,
1340 1, 0, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001341 if (rc == 0) {
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001342 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1343 type | server->vals->shared_lock_type, 0, 1, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001344 flock->fl_type = F_RDLCK;
1345 if (rc != 0)
Joe Perchesf96637b2013-05-04 22:12:25 -05001346 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1347 rc);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001348 } else
1349 flock->fl_type = F_WRLCK;
1350
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001351 return 0;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001352}
1353
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -07001354void
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001355cifs_move_llist(struct list_head *source, struct list_head *dest)
1356{
1357 struct list_head *li, *tmp;
1358 list_for_each_safe(li, tmp, source)
1359 list_move(li, dest);
1360}
1361
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -07001362void
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001363cifs_free_llist(struct list_head *llist)
1364{
1365 struct cifsLockInfo *li, *tmp;
1366 list_for_each_entry_safe(li, tmp, llist, llist) {
1367 cifs_del_lock_waiters(li);
1368 list_del(&li->llist);
1369 kfree(li);
1370 }
1371}
1372
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001373int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001374cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1375 unsigned int xid)
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001376{
1377 int rc = 0, stored_rc;
1378 int types[] = {LOCKING_ANDX_LARGE_FILES,
1379 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1380 unsigned int i;
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001381 unsigned int max_num, num, max_buf;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001382 LOCKING_ANDX_RANGE *buf, *cur;
1383 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
David Howells2b0143b2015-03-17 22:25:59 +00001384 struct cifsInodeInfo *cinode = CIFS_I(d_inode(cfile->dentry));
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001385 struct cifsLockInfo *li, *tmp;
1386 __u64 length = 1 + flock->fl_end - flock->fl_start;
1387 struct list_head tmp_llist;
1388
1389 INIT_LIST_HEAD(&tmp_llist);
1390
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001391 /*
1392 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1393 * and check it for zero before using.
1394 */
1395 max_buf = tcon->ses->server->maxBuf;
1396 if (!max_buf)
1397 return -EINVAL;
1398
1399 max_num = (max_buf - sizeof(struct smb_hdr)) /
1400 sizeof(LOCKING_ANDX_RANGE);
Fabian Frederick4b99d392014-12-10 15:41:17 -08001401 buf = kcalloc(max_num, sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001402 if (!buf)
1403 return -ENOMEM;
1404
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001405 down_write(&cinode->lock_sem);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001406 for (i = 0; i < 2; i++) {
1407 cur = buf;
1408 num = 0;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001409 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001410 if (flock->fl_start > li->offset ||
1411 (flock->fl_start + length) <
1412 (li->offset + li->length))
1413 continue;
1414 if (current->tgid != li->pid)
1415 continue;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001416 if (types[i] != li->type)
1417 continue;
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001418 if (cinode->can_cache_brlcks) {
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001419 /*
1420 * We can cache brlock requests - simply remove
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001421 * a lock from the file's list.
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001422 */
1423 list_del(&li->llist);
1424 cifs_del_lock_waiters(li);
1425 kfree(li);
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001426 continue;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001427 }
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001428 cur->Pid = cpu_to_le16(li->pid);
1429 cur->LengthLow = cpu_to_le32((u32)li->length);
1430 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1431 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1432 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1433 /*
1434 * We need to save a lock here to let us add it again to
1435 * the file's list if the unlock range request fails on
1436 * the server.
1437 */
1438 list_move(&li->llist, &tmp_llist);
1439 if (++num == max_num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001440 stored_rc = cifs_lockv(xid, tcon,
1441 cfile->fid.netfid,
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001442 li->type, num, 0, buf);
1443 if (stored_rc) {
1444 /*
1445 * We failed on the unlock range
1446 * request - add all locks from the tmp
1447 * list to the head of the file's list.
1448 */
1449 cifs_move_llist(&tmp_llist,
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001450 &cfile->llist->locks);
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001451 rc = stored_rc;
1452 } else
1453 /*
1454 * The unlock range request succeed -
1455 * free the tmp list.
1456 */
1457 cifs_free_llist(&tmp_llist);
1458 cur = buf;
1459 num = 0;
1460 } else
1461 cur++;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001462 }
1463 if (num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001464 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001465 types[i], num, 0, buf);
1466 if (stored_rc) {
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001467 cifs_move_llist(&tmp_llist,
1468 &cfile->llist->locks);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001469 rc = stored_rc;
1470 } else
1471 cifs_free_llist(&tmp_llist);
1472 }
1473 }
1474
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001475 up_write(&cinode->lock_sem);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001476 kfree(buf);
1477 return rc;
1478}
1479
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001480static int
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001481cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001482 bool wait_flag, bool posix_lck, int lock, int unlock,
1483 unsigned int xid)
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001484{
1485 int rc = 0;
1486 __u64 length = 1 + flock->fl_end - flock->fl_start;
1487 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1488 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001489 struct TCP_Server_Info *server = tcon->ses->server;
David Howells2b0143b2015-03-17 22:25:59 +00001490 struct inode *inode = d_inode(cfile->dentry);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001491
1492 if (posix_lck) {
Steve French08547b02006-02-28 22:39:25 +00001493 int posix_lock_type;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001494
1495 rc = cifs_posix_lock_set(file, flock);
1496 if (!rc || rc < 0)
1497 return rc;
1498
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001499 if (type & server->vals->shared_lock_type)
Steve French08547b02006-02-28 22:39:25 +00001500 posix_lock_type = CIFS_RDLCK;
1501 else
1502 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +00001503
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001504 if (unlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +00001505 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001506
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001507 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1508 current->tgid, flock->fl_start, length,
1509 NULL, posix_lock_type, wait_flag);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001510 goto out;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001511 }
1512
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001513 if (lock) {
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001514 struct cifsLockInfo *lock;
1515
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001516 lock = cifs_lock_init(flock->fl_start, length, type);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001517 if (!lock)
1518 return -ENOMEM;
1519
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001520 rc = cifs_lock_add_if(cfile, lock, wait_flag);
Pavel Shilovsky21cb2d92012-11-22 18:56:39 +04001521 if (rc < 0) {
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001522 kfree(lock);
Pavel Shilovsky21cb2d92012-11-22 18:56:39 +04001523 return rc;
1524 }
1525 if (!rc)
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001526 goto out;
1527
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04001528 /*
1529 * Windows 7 server can delay breaking lease from read to None
1530 * if we set a byte-range lock on a file - break it explicitly
1531 * before sending the lock to the server to be sure the next
1532 * read won't conflict with non-overlapted locks due to
1533 * pagereading.
1534 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001535 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1536 CIFS_CACHE_READ(CIFS_I(inode))) {
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001537 cifs_zap_mapping(inode);
Joe Perchesf96637b2013-05-04 22:12:25 -05001538 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1539 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001540 CIFS_I(inode)->oplock = 0;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04001541 }
1542
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001543 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1544 type, 1, 0, wait_flag);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001545 if (rc) {
1546 kfree(lock);
Pavel Shilovsky21cb2d92012-11-22 18:56:39 +04001547 return rc;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001548 }
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001549
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001550 cifs_lock_add(cfile, lock);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001551 } else if (unlock)
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001552 rc = server->ops->mand_unlock_range(cfile, flock, xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001553
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001554out:
Chengyu Song00b8c952015-03-24 20:18:49 -04001555 if (flock->fl_flags & FL_POSIX && !rc)
1556 rc = posix_lock_file_wait(file, flock);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001557 return rc;
1558}
1559
1560int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1561{
1562 int rc, xid;
1563 int lock = 0, unlock = 0;
1564 bool wait_flag = false;
1565 bool posix_lck = false;
1566 struct cifs_sb_info *cifs_sb;
1567 struct cifs_tcon *tcon;
1568 struct cifsInodeInfo *cinode;
1569 struct cifsFileInfo *cfile;
1570 __u16 netfid;
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001571 __u32 type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001572
1573 rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001574 xid = get_xid();
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001575
Joe Perchesf96637b2013-05-04 22:12:25 -05001576 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1577 cmd, flock->fl_flags, flock->fl_type,
1578 flock->fl_start, flock->fl_end);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001579
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001580 cfile = (struct cifsFileInfo *)file->private_data;
1581 tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001582
1583 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1584 tcon->ses->server);
1585
Al Viro7119e222014-10-22 00:25:12 -04001586 cifs_sb = CIFS_FILE_SB(file);
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001587 netfid = cfile->fid.netfid;
Al Viro496ad9a2013-01-23 17:07:38 -05001588 cinode = CIFS_I(file_inode(file));
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001589
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001590 if (cap_unix(tcon->ses) &&
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001591 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1592 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1593 posix_lck = true;
1594 /*
1595 * BB add code here to normalize offset and length to account for
1596 * negative length which we can not accept over the wire.
1597 */
1598 if (IS_GETLK(cmd)) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001599 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001600 free_xid(xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001601 return rc;
1602 }
1603
1604 if (!lock && !unlock) {
1605 /*
1606 * if no lock or unlock then nothing to do since we do not
1607 * know what it is
1608 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001609 free_xid(xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001610 return -EOPNOTSUPP;
1611 }
1612
1613 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1614 xid);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001615 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001616 return rc;
1617}
1618
Jeff Layton597b0272012-03-23 14:40:56 -04001619/*
1620 * update the file size (if needed) after a write. Should be called with
1621 * the inode->i_lock held
1622 */
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05001623void
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001624cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1625 unsigned int bytes_written)
1626{
1627 loff_t end_of_write = offset + bytes_written;
1628
1629 if (end_of_write > cifsi->server_eof)
1630 cifsi->server_eof = end_of_write;
1631}
1632
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001633static ssize_t
1634cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1635 size_t write_size, loff_t *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636{
1637 int rc = 0;
1638 unsigned int bytes_written = 0;
1639 unsigned int total_written;
1640 struct cifs_sb_info *cifs_sb;
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001641 struct cifs_tcon *tcon;
1642 struct TCP_Server_Info *server;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001643 unsigned int xid;
Jeff Layton7da4b492010-10-15 15:34:00 -04001644 struct dentry *dentry = open_file->dentry;
David Howells2b0143b2015-03-17 22:25:59 +00001645 struct cifsInodeInfo *cifsi = CIFS_I(d_inode(dentry));
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001646 struct cifs_io_parms io_parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
Jeff Layton7da4b492010-10-15 15:34:00 -04001648 cifs_sb = CIFS_SB(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649
Al Viro35c265e2014-08-19 20:25:34 -04001650 cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1651 write_size, *offset, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001653 tcon = tlink_tcon(open_file->tlink);
1654 server = tcon->ses->server;
1655
1656 if (!server->ops->sync_write)
1657 return -ENOSYS;
Steve French50c2f752007-07-13 00:33:32 +00001658
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001659 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661 for (total_written = 0; write_size > total_written;
1662 total_written += bytes_written) {
1663 rc = -EAGAIN;
1664 while (rc == -EAGAIN) {
Jeff Laytonca83ce32011-04-12 09:13:44 -04001665 struct kvec iov[2];
1666 unsigned int len;
1667
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 /* we could deadlock if we called
1670 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001671 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 server now */
Jeff Layton15886172010-10-15 15:33:59 -04001673 rc = cifs_reopen_file(open_file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674 if (rc != 0)
1675 break;
1676 }
Steve French3e844692005-10-03 13:37:24 -07001677
David Howells2b0143b2015-03-17 22:25:59 +00001678 len = min(server->ops->wp_retry_size(d_inode(dentry)),
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04001679 (unsigned int)write_size - total_written);
Jeff Laytonca83ce32011-04-12 09:13:44 -04001680 /* iov[0] is reserved for smb header */
1681 iov[1].iov_base = (char *)write_data + total_written;
1682 iov[1].iov_len = len;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001683 io_parms.pid = pid;
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001684 io_parms.tcon = tcon;
1685 io_parms.offset = *offset;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001686 io_parms.length = len;
Steve Frenchdb8b6312014-09-22 05:13:55 -05001687 rc = server->ops->sync_write(xid, &open_file->fid,
1688 &io_parms, &bytes_written, iov, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689 }
1690 if (rc || (bytes_written == 0)) {
1691 if (total_written)
1692 break;
1693 else {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001694 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001695 return rc;
1696 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001697 } else {
David Howells2b0143b2015-03-17 22:25:59 +00001698 spin_lock(&d_inode(dentry)->i_lock);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001699 cifs_update_eof(cifsi, *offset, bytes_written);
David Howells2b0143b2015-03-17 22:25:59 +00001700 spin_unlock(&d_inode(dentry)->i_lock);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001701 *offset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001702 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 }
1704
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001705 cifs_stats_bytes_written(tcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706
Jeff Layton7da4b492010-10-15 15:34:00 -04001707 if (total_written > 0) {
David Howells2b0143b2015-03-17 22:25:59 +00001708 spin_lock(&d_inode(dentry)->i_lock);
1709 if (*offset > d_inode(dentry)->i_size)
1710 i_size_write(d_inode(dentry), *offset);
1711 spin_unlock(&d_inode(dentry)->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 }
David Howells2b0143b2015-03-17 22:25:59 +00001713 mark_inode_dirty_sync(d_inode(dentry));
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001714 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 return total_written;
1716}
1717
Jeff Layton6508d902010-09-29 19:51:11 -04001718struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1719 bool fsuid_only)
Steve French630f3f0c2007-10-25 21:17:17 +00001720{
1721 struct cifsFileInfo *open_file = NULL;
Jeff Layton6508d902010-09-29 19:51:11 -04001722 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1723
1724 /* only filter by fsuid on multiuser mounts */
1725 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1726 fsuid_only = false;
Steve French630f3f0c2007-10-25 21:17:17 +00001727
Jeff Layton44772882010-10-15 15:34:03 -04001728 spin_lock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001729 /* we could simply get the first_list_entry since write-only entries
1730 are always at the end of the list but since the first entry might
1731 have a close pending, we go through the whole list */
1732 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Eric W. Biedermanfef59fd2013-02-06 02:23:02 -08001733 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
Jeff Layton6508d902010-09-29 19:51:11 -04001734 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001735 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
Steve French630f3f0c2007-10-25 21:17:17 +00001736 if (!open_file->invalidHandle) {
1737 /* found a good file */
1738 /* lock it so it will not be closed on us */
Jeff Layton764a1b12012-07-25 14:59:54 -04001739 cifsFileInfo_get_locked(open_file);
Jeff Layton44772882010-10-15 15:34:03 -04001740 spin_unlock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001741 return open_file;
1742 } /* else might as well continue, and look for
1743 another, or simply have the caller reopen it
1744 again rather than trying to fix this handle */
1745 } else /* write only file */
1746 break; /* write only files are last so must be done */
1747 }
Jeff Layton44772882010-10-15 15:34:03 -04001748 spin_unlock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001749 return NULL;
1750}
Steve French630f3f0c2007-10-25 21:17:17 +00001751
Jeff Layton6508d902010-09-29 19:51:11 -04001752struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1753 bool fsuid_only)
Steve French6148a742005-10-05 12:23:19 -07001754{
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001755 struct cifsFileInfo *open_file, *inv_file = NULL;
Jeff Laytond3892292010-11-02 16:22:50 -04001756 struct cifs_sb_info *cifs_sb;
Jeff Layton2846d382008-09-22 21:33:33 -04001757 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001758 int rc;
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001759 unsigned int refind = 0;
Steve French6148a742005-10-05 12:23:19 -07001760
Steve French60808232006-04-22 15:53:05 +00001761 /* Having a null inode here (because mapping->host was set to zero by
1762 the VFS or MM) should not happen but we had reports of on oops (due to
1763 it being zero) during stress testcases so we need to check for it */
1764
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001765 if (cifs_inode == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001766 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
Steve French60808232006-04-22 15:53:05 +00001767 dump_stack();
1768 return NULL;
1769 }
1770
Jeff Laytond3892292010-11-02 16:22:50 -04001771 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1772
Jeff Layton6508d902010-09-29 19:51:11 -04001773 /* only filter by fsuid on multiuser mounts */
1774 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1775 fsuid_only = false;
1776
Jeff Layton44772882010-10-15 15:34:03 -04001777 spin_lock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001778refind_writable:
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001779 if (refind > MAX_REOPEN_ATT) {
1780 spin_unlock(&cifs_file_list_lock);
1781 return NULL;
1782 }
Steve French6148a742005-10-05 12:23:19 -07001783 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton6508d902010-09-29 19:51:11 -04001784 if (!any_available && open_file->pid != current->tgid)
1785 continue;
Eric W. Biedermanfef59fd2013-02-06 02:23:02 -08001786 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
Jeff Layton6508d902010-09-29 19:51:11 -04001787 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001788 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Steve French9b22b0b2007-10-02 01:11:08 +00001789 if (!open_file->invalidHandle) {
1790 /* found a good writable file */
Jeff Layton764a1b12012-07-25 14:59:54 -04001791 cifsFileInfo_get_locked(open_file);
Jeff Layton44772882010-10-15 15:34:03 -04001792 spin_unlock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001793 return open_file;
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001794 } else {
1795 if (!inv_file)
1796 inv_file = open_file;
Steve French9b22b0b2007-10-02 01:11:08 +00001797 }
Steve French6148a742005-10-05 12:23:19 -07001798 }
1799 }
Jeff Layton2846d382008-09-22 21:33:33 -04001800 /* couldn't find useable FH with same pid, try any available */
1801 if (!any_available) {
1802 any_available = true;
1803 goto refind_writable;
1804 }
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001805
1806 if (inv_file) {
1807 any_available = false;
Jeff Layton764a1b12012-07-25 14:59:54 -04001808 cifsFileInfo_get_locked(inv_file);
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001809 }
1810
Jeff Layton44772882010-10-15 15:34:03 -04001811 spin_unlock(&cifs_file_list_lock);
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001812
1813 if (inv_file) {
1814 rc = cifs_reopen_file(inv_file, false);
1815 if (!rc)
1816 return inv_file;
1817 else {
1818 spin_lock(&cifs_file_list_lock);
1819 list_move_tail(&inv_file->flist,
1820 &cifs_inode->openFileList);
1821 spin_unlock(&cifs_file_list_lock);
1822 cifsFileInfo_put(inv_file);
1823 spin_lock(&cifs_file_list_lock);
1824 ++refind;
David Disseldorpe1e9bda2015-03-13 14:20:29 +01001825 inv_file = NULL;
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001826 goto refind_writable;
1827 }
1828 }
1829
Steve French6148a742005-10-05 12:23:19 -07001830 return NULL;
1831}
1832
Linus Torvalds1da177e2005-04-16 15:20:36 -07001833static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1834{
1835 struct address_space *mapping = page->mapping;
1836 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1837 char *write_data;
1838 int rc = -EFAULT;
1839 int bytes_written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001840 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001841 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842
1843 if (!mapping || !mapping->host)
1844 return -EFAULT;
1845
1846 inode = page->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847
1848 offset += (loff_t)from;
1849 write_data = kmap(page);
1850 write_data += from;
1851
1852 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1853 kunmap(page);
1854 return -EIO;
1855 }
1856
1857 /* racing with truncate? */
1858 if (offset > mapping->host->i_size) {
1859 kunmap(page);
1860 return 0; /* don't care */
1861 }
1862
1863 /* check to make sure that we are not extending the file */
1864 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001865 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866
Jeff Layton6508d902010-09-29 19:51:11 -04001867 open_file = find_writable_file(CIFS_I(mapping->host), false);
Steve French6148a742005-10-05 12:23:19 -07001868 if (open_file) {
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001869 bytes_written = cifs_write(open_file, open_file->pid,
1870 write_data, to - from, &offset);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001871 cifsFileInfo_put(open_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001873 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001874 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001875 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001876 else if (bytes_written < 0)
1877 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001878 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05001879 cifs_dbg(FYI, "No writeable filehandles for inode\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001880 rc = -EIO;
1881 }
1882
1883 kunmap(page);
1884 return rc;
1885}
1886
Pavel Shilovsky90ac1382014-06-19 16:11:00 +04001887static struct cifs_writedata *
1888wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
1889 pgoff_t end, pgoff_t *index,
1890 unsigned int *found_pages)
1891{
1892 unsigned int nr_pages;
1893 struct page **pages;
1894 struct cifs_writedata *wdata;
1895
1896 wdata = cifs_writedata_alloc((unsigned int)tofind,
1897 cifs_writev_complete);
1898 if (!wdata)
1899 return NULL;
1900
1901 /*
1902 * find_get_pages_tag seems to return a max of 256 on each
1903 * iteration, so we must call it several times in order to
1904 * fill the array or the wsize is effectively limited to
1905 * 256 * PAGE_CACHE_SIZE.
1906 */
1907 *found_pages = 0;
1908 pages = wdata->pages;
1909 do {
1910 nr_pages = find_get_pages_tag(mapping, index,
1911 PAGECACHE_TAG_DIRTY, tofind,
1912 pages);
1913 *found_pages += nr_pages;
1914 tofind -= nr_pages;
1915 pages += nr_pages;
1916 } while (nr_pages && tofind && *index <= end);
1917
1918 return wdata;
1919}
1920
Pavel Shilovsky7e48ff82014-06-19 15:01:03 +04001921static unsigned int
1922wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
1923 struct address_space *mapping,
1924 struct writeback_control *wbc,
1925 pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
1926{
1927 unsigned int nr_pages = 0, i;
1928 struct page *page;
1929
1930 for (i = 0; i < found_pages; i++) {
1931 page = wdata->pages[i];
1932 /*
1933 * At this point we hold neither mapping->tree_lock nor
1934 * lock on the page itself: the page may be truncated or
1935 * invalidated (changing page->mapping to NULL), or even
1936 * swizzled back from swapper_space to tmpfs file
1937 * mapping
1938 */
1939
1940 if (nr_pages == 0)
1941 lock_page(page);
1942 else if (!trylock_page(page))
1943 break;
1944
1945 if (unlikely(page->mapping != mapping)) {
1946 unlock_page(page);
1947 break;
1948 }
1949
1950 if (!wbc->range_cyclic && page->index > end) {
1951 *done = true;
1952 unlock_page(page);
1953 break;
1954 }
1955
1956 if (*next && (page->index != *next)) {
1957 /* Not next consecutive page */
1958 unlock_page(page);
1959 break;
1960 }
1961
1962 if (wbc->sync_mode != WB_SYNC_NONE)
1963 wait_on_page_writeback(page);
1964
1965 if (PageWriteback(page) ||
1966 !clear_page_dirty_for_io(page)) {
1967 unlock_page(page);
1968 break;
1969 }
1970
1971 /*
1972 * This actually clears the dirty bit in the radix tree.
1973 * See cifs_writepage() for more commentary.
1974 */
1975 set_page_writeback(page);
1976 if (page_offset(page) >= i_size_read(mapping->host)) {
1977 *done = true;
1978 unlock_page(page);
1979 end_page_writeback(page);
1980 break;
1981 }
1982
1983 wdata->pages[i] = page;
1984 *next = page->index + 1;
1985 ++nr_pages;
1986 }
1987
1988 /* reset index to refind any pages skipped */
1989 if (nr_pages == 0)
1990 *index = wdata->pages[0]->index + 1;
1991
1992 /* put any pages we aren't going to use */
1993 for (i = nr_pages; i < found_pages; i++) {
1994 page_cache_release(wdata->pages[i]);
1995 wdata->pages[i] = NULL;
1996 }
1997
1998 return nr_pages;
1999}
2000
Pavel Shilovsky619aa482014-06-19 15:28:37 +04002001static int
2002wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2003 struct address_space *mapping, struct writeback_control *wbc)
2004{
2005 int rc = 0;
2006 struct TCP_Server_Info *server;
2007 unsigned int i;
2008
2009 wdata->sync_mode = wbc->sync_mode;
2010 wdata->nr_pages = nr_pages;
2011 wdata->offset = page_offset(wdata->pages[0]);
2012 wdata->pagesz = PAGE_CACHE_SIZE;
2013 wdata->tailsz = min(i_size_read(mapping->host) -
2014 page_offset(wdata->pages[nr_pages - 1]),
2015 (loff_t)PAGE_CACHE_SIZE);
2016 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) + wdata->tailsz;
2017
Pavel Shilovsky66231a42014-06-19 16:15:16 +04002018 if (wdata->cfile != NULL)
2019 cifsFileInfo_put(wdata->cfile);
2020 wdata->cfile = find_writable_file(CIFS_I(mapping->host), false);
2021 if (!wdata->cfile) {
2022 cifs_dbg(VFS, "No writable handles for inode\n");
2023 rc = -EBADF;
2024 } else {
Pavel Shilovsky619aa482014-06-19 15:28:37 +04002025 wdata->pid = wdata->cfile->pid;
2026 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2027 rc = server->ops->async_writev(wdata, cifs_writedata_release);
Pavel Shilovsky66231a42014-06-19 16:15:16 +04002028 }
Pavel Shilovsky619aa482014-06-19 15:28:37 +04002029
2030 for (i = 0; i < nr_pages; ++i)
2031 unlock_page(wdata->pages[i]);
2032
2033 return rc;
2034}
2035
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07002037 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038{
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002039 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002040 struct TCP_Server_Info *server;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002041 bool done = false, scanned = false, range_whole = false;
2042 pgoff_t end, index;
2043 struct cifs_writedata *wdata;
Steve French37c0eb42005-10-05 14:50:29 -07002044 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00002045
Steve French37c0eb42005-10-05 14:50:29 -07002046 /*
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002047 * If wsize is smaller than the page cache size, default to writing
Steve French37c0eb42005-10-05 14:50:29 -07002048 * one page at a time via cifs_writepage
2049 */
2050 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
2051 return generic_writepages(mapping, wbc);
2052
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07002053 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07002054 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07002055 end = -1;
2056 } else {
2057 index = wbc->range_start >> PAGE_CACHE_SHIFT;
2058 end = wbc->range_end >> PAGE_CACHE_SHIFT;
2059 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002060 range_whole = true;
2061 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07002062 }
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002063 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
Steve French37c0eb42005-10-05 14:50:29 -07002064retry:
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002065 while (!done && index <= end) {
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002066 unsigned int i, nr_pages, found_pages, wsize, credits;
Pavel Shilovsky66231a42014-06-19 16:15:16 +04002067 pgoff_t next = 0, tofind, saved_index = index;
Steve French37c0eb42005-10-05 14:50:29 -07002068
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002069 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2070 &wsize, &credits);
2071 if (rc)
2072 break;
Steve French37c0eb42005-10-05 14:50:29 -07002073
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002074 tofind = min((wsize / PAGE_CACHE_SIZE) - 1, end - index) + 1;
Steve French37c0eb42005-10-05 14:50:29 -07002075
Pavel Shilovsky90ac1382014-06-19 16:11:00 +04002076 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2077 &found_pages);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002078 if (!wdata) {
2079 rc = -ENOMEM;
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002080 add_credits_and_wake_if(server, credits, 0);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002081 break;
2082 }
2083
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002084 if (found_pages == 0) {
2085 kref_put(&wdata->refcount, cifs_writedata_release);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002086 add_credits_and_wake_if(server, credits, 0);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002087 break;
2088 }
2089
Pavel Shilovsky7e48ff82014-06-19 15:01:03 +04002090 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2091 end, &index, &next, &done);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002092
2093 /* nothing to write? */
2094 if (nr_pages == 0) {
2095 kref_put(&wdata->refcount, cifs_writedata_release);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002096 add_credits_and_wake_if(server, credits, 0);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002097 continue;
2098 }
2099
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002100 wdata->credits = credits;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002101
Pavel Shilovsky619aa482014-06-19 15:28:37 +04002102 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
Jeff Layton941b8532011-01-11 07:24:01 -05002103
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002104 /* send failure -- clean up the mess */
2105 if (rc != 0) {
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002106 add_credits_and_wake_if(server, wdata->credits, 0);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002107 for (i = 0; i < nr_pages; ++i) {
Jeff Layton941b8532011-01-11 07:24:01 -05002108 if (rc == -EAGAIN)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002109 redirty_page_for_writepage(wbc,
2110 wdata->pages[i]);
2111 else
2112 SetPageError(wdata->pages[i]);
2113 end_page_writeback(wdata->pages[i]);
2114 page_cache_release(wdata->pages[i]);
Steve French37c0eb42005-10-05 14:50:29 -07002115 }
Jeff Layton941b8532011-01-11 07:24:01 -05002116 if (rc != -EAGAIN)
2117 mapping_set_error(mapping, rc);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002118 }
2119 kref_put(&wdata->refcount, cifs_writedata_release);
Jeff Layton941b8532011-01-11 07:24:01 -05002120
Pavel Shilovsky66231a42014-06-19 16:15:16 +04002121 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2122 index = saved_index;
2123 continue;
2124 }
2125
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002126 wbc->nr_to_write -= nr_pages;
2127 if (wbc->nr_to_write <= 0)
2128 done = true;
Dave Kleikampb066a482008-11-18 03:49:05 +00002129
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002130 index = next;
Steve French37c0eb42005-10-05 14:50:29 -07002131 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002132
Steve French37c0eb42005-10-05 14:50:29 -07002133 if (!scanned && !done) {
2134 /*
2135 * We hit the last page and there is more work to be done: wrap
2136 * back to the start of the file
2137 */
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002138 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07002139 index = 0;
2140 goto retry;
2141 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002142
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07002143 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07002144 mapping->writeback_index = index;
2145
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146 return rc;
2147}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002149static int
2150cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151{
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002152 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002153 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002154
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002155 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156/* BB add check for wbc flags */
2157 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00002158 if (!PageUptodate(page))
Joe Perchesf96637b2013-05-04 22:12:25 -05002159 cifs_dbg(FYI, "ppw - page not up to date\n");
Linus Torvaldscb876f42006-12-23 16:19:07 -08002160
2161 /*
2162 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2163 *
2164 * A writepage() implementation always needs to do either this,
2165 * or re-dirty the page with "redirty_page_for_writepage()" in
2166 * the case of a failure.
2167 *
2168 * Just unlocking the page will cause the radix tree tag-bits
2169 * to fail to update with the state of the page correctly.
2170 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002171 set_page_writeback(page);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002172retry_write:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002174 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2175 goto retry_write;
2176 else if (rc == -EAGAIN)
2177 redirty_page_for_writepage(wbc, page);
2178 else if (rc != 0)
2179 SetPageError(page);
2180 else
2181 SetPageUptodate(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08002182 end_page_writeback(page);
2183 page_cache_release(page);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002184 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002185 return rc;
2186}
2187
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002188static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2189{
2190 int rc = cifs_writepage_locked(page, wbc);
2191 unlock_page(page);
2192 return rc;
2193}
2194
Nick Piggind9414772008-09-24 11:32:59 -04002195static int cifs_write_end(struct file *file, struct address_space *mapping,
2196 loff_t pos, unsigned len, unsigned copied,
2197 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002198{
Nick Piggind9414772008-09-24 11:32:59 -04002199 int rc;
2200 struct inode *inode = mapping->host;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002201 struct cifsFileInfo *cfile = file->private_data;
2202 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2203 __u32 pid;
2204
2205 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2206 pid = cfile->pid;
2207 else
2208 pid = current->tgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209
Joe Perchesf96637b2013-05-04 22:12:25 -05002210 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002211 page, pos, copied);
Steve Frenchad7a2922008-02-07 23:25:02 +00002212
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002213 if (PageChecked(page)) {
2214 if (copied == len)
2215 SetPageUptodate(page);
2216 ClearPageChecked(page);
2217 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04002218 SetPageUptodate(page);
2219
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04002221 char *page_data;
2222 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002223 unsigned int xid;
Nick Piggind9414772008-09-24 11:32:59 -04002224
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002225 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002226 /* this is probably better than directly calling
2227 partialpage_write since in this function the file handle is
2228 known which we might as well leverage */
2229 /* BB check if anything else missing out of ppw
2230 such as updating last write time */
2231 page_data = kmap(page);
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002232 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
Nick Piggind9414772008-09-24 11:32:59 -04002233 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002234 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04002235
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002236 free_xid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002237 } else {
Nick Piggind9414772008-09-24 11:32:59 -04002238 rc = copied;
2239 pos += copied;
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002240 set_page_dirty(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002241 }
2242
Nick Piggind9414772008-09-24 11:32:59 -04002243 if (rc > 0) {
2244 spin_lock(&inode->i_lock);
2245 if (pos > inode->i_size)
2246 i_size_write(inode, pos);
2247 spin_unlock(&inode->i_lock);
2248 }
2249
2250 unlock_page(page);
2251 page_cache_release(page);
2252
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 return rc;
2254}
2255
Josef Bacik02c24a82011-07-16 20:44:56 -04002256int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2257 int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002259 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00002261 struct cifs_tcon *tcon;
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002262 struct TCP_Server_Info *server;
Joe Perchesc21dfb62010-07-12 13:50:14 -07002263 struct cifsFileInfo *smbfile = file->private_data;
Al Viro496ad9a2013-01-23 17:07:38 -05002264 struct inode *inode = file_inode(file);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002265 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266
Josef Bacik02c24a82011-07-16 20:44:56 -04002267 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2268 if (rc)
2269 return rc;
2270 mutex_lock(&inode->i_mutex);
2271
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002272 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273
Al Viro35c265e2014-08-19 20:25:34 -04002274 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2275 file, datasync);
Steve French50c2f752007-07-13 00:33:32 +00002276
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002277 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002278 rc = cifs_zap_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002279 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002280 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002281 rc = 0; /* don't care about it in fsync */
2282 }
2283 }
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002284
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002285 tcon = tlink_tcon(smbfile->tlink);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002286 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2287 server = tcon->ses->server;
2288 if (server->ops->flush)
2289 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2290 else
2291 rc = -ENOSYS;
2292 }
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002293
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002294 free_xid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04002295 mutex_unlock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002296 return rc;
2297}
2298
Josef Bacik02c24a82011-07-16 20:44:56 -04002299int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002300{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002301 unsigned int xid;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002302 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00002303 struct cifs_tcon *tcon;
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002304 struct TCP_Server_Info *server;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002305 struct cifsFileInfo *smbfile = file->private_data;
Al Viro7119e222014-10-22 00:25:12 -04002306 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
Josef Bacik02c24a82011-07-16 20:44:56 -04002307 struct inode *inode = file->f_mapping->host;
2308
2309 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2310 if (rc)
2311 return rc;
2312 mutex_lock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002313
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002314 xid = get_xid();
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002315
Al Viro35c265e2014-08-19 20:25:34 -04002316 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2317 file, datasync);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002318
2319 tcon = tlink_tcon(smbfile->tlink);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002320 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2321 server = tcon->ses->server;
2322 if (server->ops->flush)
2323 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2324 else
2325 rc = -ENOSYS;
2326 }
Steve Frenchb298f222009-02-21 21:17:43 +00002327
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002328 free_xid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04002329 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002330 return rc;
2331}
2332
Linus Torvalds1da177e2005-04-16 15:20:36 -07002333/*
2334 * As file closes, flush all cached write data for this inode checking
2335 * for write behind errors.
2336 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07002337int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002338{
Al Viro496ad9a2013-01-23 17:07:38 -05002339 struct inode *inode = file_inode(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340 int rc = 0;
2341
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002342 if (file->f_mode & FMODE_WRITE)
Jeff Laytond3f13222010-10-15 15:34:07 -04002343 rc = filemap_write_and_wait(inode->i_mapping);
Steve French50c2f752007-07-13 00:33:32 +00002344
Joe Perchesf96637b2013-05-04 22:12:25 -05002345 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346
2347 return rc;
2348}
2349
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002350static int
2351cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2352{
2353 int rc = 0;
2354 unsigned long i;
2355
2356 for (i = 0; i < num_pages; i++) {
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002357 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002358 if (!pages[i]) {
2359 /*
2360 * save number of pages we have already allocated and
2361 * return with ENOMEM error
2362 */
2363 num_pages = i;
2364 rc = -ENOMEM;
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002365 break;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002366 }
2367 }
2368
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002369 if (rc) {
2370 for (i = 0; i < num_pages; i++)
2371 put_page(pages[i]);
2372 }
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002373 return rc;
2374}
2375
2376static inline
2377size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2378{
2379 size_t num_pages;
2380 size_t clen;
2381
2382 clen = min_t(const size_t, len, wsize);
Jeff Laytona7103b92012-03-23 14:40:56 -04002383 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002384
2385 if (cur_len)
2386 *cur_len = clen;
2387
2388 return num_pages;
2389}
2390
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002391static void
Steve French4a5c80d2014-02-07 20:45:12 -06002392cifs_uncached_writedata_release(struct kref *refcount)
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002393{
2394 int i;
Steve French4a5c80d2014-02-07 20:45:12 -06002395 struct cifs_writedata *wdata = container_of(refcount,
2396 struct cifs_writedata, refcount);
2397
2398 for (i = 0; i < wdata->nr_pages; i++)
2399 put_page(wdata->pages[i]);
2400 cifs_writedata_release(refcount);
2401}
2402
2403static void
2404cifs_uncached_writev_complete(struct work_struct *work)
2405{
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002406 struct cifs_writedata *wdata = container_of(work,
2407 struct cifs_writedata, work);
David Howells2b0143b2015-03-17 22:25:59 +00002408 struct inode *inode = d_inode(wdata->cfile->dentry);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002409 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2410
2411 spin_lock(&inode->i_lock);
2412 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2413 if (cifsi->server_eof > inode->i_size)
2414 i_size_write(inode, cifsi->server_eof);
2415 spin_unlock(&inode->i_lock);
2416
2417 complete(&wdata->done);
2418
Steve French4a5c80d2014-02-07 20:45:12 -06002419 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002420}
2421
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002422static int
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002423wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2424 size_t *len, unsigned long *num_pages)
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002425{
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002426 size_t save_len, copied, bytes, cur_len = *len;
2427 unsigned long i, nr_pages = *num_pages;
2428
2429 save_len = cur_len;
2430 for (i = 0; i < nr_pages; i++) {
2431 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2432 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2433 cur_len -= copied;
2434 /*
2435 * If we didn't copy as much as we expected, then that
2436 * may mean we trod into an unmapped area. Stop copying
2437 * at that point. On the next pass through the big
2438 * loop, we'll likely end up getting a zero-length
2439 * write and bailing out of it.
2440 */
2441 if (copied < bytes)
2442 break;
2443 }
2444 cur_len = save_len - cur_len;
2445 *len = cur_len;
2446
2447 /*
2448 * If we have no data to send, then that probably means that
2449 * the copy above failed altogether. That's most likely because
2450 * the address in the iovec was bogus. Return -EFAULT and let
2451 * the caller free anything we allocated and bail out.
2452 */
2453 if (!cur_len)
2454 return -EFAULT;
2455
2456 /*
2457 * i + 1 now represents the number of pages we actually used in
2458 * the copy phase above.
2459 */
2460 *num_pages = i + 1;
2461 return 0;
2462}
2463
Pavel Shilovsky43de94e2014-06-20 16:10:52 +04002464static int
2465cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2466 struct cifsFileInfo *open_file,
2467 struct cifs_sb_info *cifs_sb, struct list_head *wdata_list)
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002468{
Pavel Shilovsky43de94e2014-06-20 16:10:52 +04002469 int rc = 0;
2470 size_t cur_len;
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002471 unsigned long nr_pages, num_pages, i;
Pavel Shilovsky43de94e2014-06-20 16:10:52 +04002472 struct cifs_writedata *wdata;
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002473 struct iov_iter saved_from;
2474 loff_t saved_offset = offset;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002475 pid_t pid;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002476 struct TCP_Server_Info *server;
2477
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002478 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2479 pid = open_file->pid;
2480 else
2481 pid = current->tgid;
2482
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002483 server = tlink_tcon(open_file->tlink)->ses->server;
2484 memcpy(&saved_from, from, sizeof(struct iov_iter));
Pavel Shilovsky76429c12011-01-31 16:03:08 +03002485
2486 do {
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002487 unsigned int wsize, credits;
2488
2489 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2490 &wsize, &credits);
2491 if (rc)
2492 break;
2493
2494 nr_pages = get_numpages(wsize, len, &cur_len);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002495 wdata = cifs_writedata_alloc(nr_pages,
2496 cifs_uncached_writev_complete);
2497 if (!wdata) {
2498 rc = -ENOMEM;
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002499 add_credits_and_wake_if(server, credits, 0);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002500 break;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002501 }
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002502
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002503 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2504 if (rc) {
2505 kfree(wdata);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002506 add_credits_and_wake_if(server, credits, 0);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002507 break;
2508 }
2509
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002510 num_pages = nr_pages;
2511 rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
2512 if (rc) {
Jeff Layton5d81de82014-02-14 07:20:35 -05002513 for (i = 0; i < nr_pages; i++)
2514 put_page(wdata->pages[i]);
2515 kfree(wdata);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002516 add_credits_and_wake_if(server, credits, 0);
Jeff Layton5d81de82014-02-14 07:20:35 -05002517 break;
2518 }
2519
2520 /*
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002521 * Bring nr_pages down to the number of pages we actually used,
2522 * and free any pages that we didn't use.
Jeff Layton5d81de82014-02-14 07:20:35 -05002523 */
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002524 for ( ; nr_pages > num_pages; nr_pages--)
Jeff Layton5d81de82014-02-14 07:20:35 -05002525 put_page(wdata->pages[nr_pages - 1]);
2526
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002527 wdata->sync_mode = WB_SYNC_ALL;
2528 wdata->nr_pages = nr_pages;
2529 wdata->offset = (__u64)offset;
2530 wdata->cfile = cifsFileInfo_get(open_file);
2531 wdata->pid = pid;
2532 wdata->bytes = cur_len;
Jeff Laytoneddb0792012-09-18 16:20:35 -07002533 wdata->pagesz = PAGE_SIZE;
2534 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002535 wdata->credits = credits;
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002536
2537 if (!wdata->cfile->invalidHandle ||
2538 !cifs_reopen_file(wdata->cfile, false))
2539 rc = server->ops->async_writev(wdata,
2540 cifs_uncached_writedata_release);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002541 if (rc) {
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002542 add_credits_and_wake_if(server, wdata->credits, 0);
Steve French4a5c80d2014-02-07 20:45:12 -06002543 kref_put(&wdata->refcount,
2544 cifs_uncached_writedata_release);
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002545 if (rc == -EAGAIN) {
2546 memcpy(from, &saved_from,
2547 sizeof(struct iov_iter));
2548 iov_iter_advance(from, offset - saved_offset);
2549 continue;
2550 }
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002551 break;
2552 }
2553
Pavel Shilovsky43de94e2014-06-20 16:10:52 +04002554 list_add_tail(&wdata->list, wdata_list);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002555 offset += cur_len;
2556 len -= cur_len;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002557 } while (len > 0);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002558
2559 return rc;
2560}
2561
Al Viroe9d15932015-04-06 22:44:11 -04002562ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002563{
Al Viroe9d15932015-04-06 22:44:11 -04002564 struct file *file = iocb->ki_filp;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002565 ssize_t total_written = 0;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002566 struct cifsFileInfo *open_file;
2567 struct cifs_tcon *tcon;
2568 struct cifs_sb_info *cifs_sb;
2569 struct cifs_writedata *wdata, *tmp;
2570 struct list_head wdata_list;
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002571 struct iov_iter saved_from;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002572 int rc;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002573
Al Viroe9d15932015-04-06 22:44:11 -04002574 /*
2575 * BB - optimize the way when signing is disabled. We can drop this
2576 * extra memory-to-memory copying and use iovec buffers for constructing
2577 * write request.
2578 */
2579
Al Viro3309dd02015-04-09 12:55:47 -04002580 rc = generic_write_checks(iocb, from);
2581 if (rc <= 0)
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002582 return rc;
2583
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002584 INIT_LIST_HEAD(&wdata_list);
Al Viro7119e222014-10-22 00:25:12 -04002585 cifs_sb = CIFS_FILE_SB(file);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002586 open_file = file->private_data;
2587 tcon = tlink_tcon(open_file->tlink);
2588
2589 if (!tcon->ses->server->ops->async_writev)
2590 return -ENOSYS;
2591
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002592 memcpy(&saved_from, from, sizeof(struct iov_iter));
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002593
Al Viro3309dd02015-04-09 12:55:47 -04002594 rc = cifs_write_from_iter(iocb->ki_pos, iov_iter_count(from), from,
2595 open_file, cifs_sb, &wdata_list);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002596
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002597 /*
2598 * If at least one write was successfully sent, then discard any rc
2599 * value from the later writes. If the other write succeeds, then
2600 * we'll end up returning whatever was written. If it fails, then
2601 * we'll get a new rc value from that.
2602 */
2603 if (!list_empty(&wdata_list))
2604 rc = 0;
2605
2606 /*
2607 * Wait for and collect replies for any successful sends in order of
2608 * increasing offset. Once an error is hit or we get a fatal signal
2609 * while waiting, then return without waiting for any more replies.
2610 */
2611restart_loop:
2612 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2613 if (!rc) {
2614 /* FIXME: freezable too? */
2615 rc = wait_for_completion_killable(&wdata->done);
2616 if (rc)
2617 rc = -EINTR;
2618 else if (wdata->result)
2619 rc = wdata->result;
2620 else
2621 total_written += wdata->bytes;
2622
2623 /* resend call if it's a retryable error */
2624 if (rc == -EAGAIN) {
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002625 struct list_head tmp_list;
2626 struct iov_iter tmp_from;
2627
2628 INIT_LIST_HEAD(&tmp_list);
2629 list_del_init(&wdata->list);
2630
2631 memcpy(&tmp_from, &saved_from,
2632 sizeof(struct iov_iter));
2633 iov_iter_advance(&tmp_from,
Al Viroe9d15932015-04-06 22:44:11 -04002634 wdata->offset - iocb->ki_pos);
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002635
2636 rc = cifs_write_from_iter(wdata->offset,
2637 wdata->bytes, &tmp_from,
2638 open_file, cifs_sb, &tmp_list);
2639
2640 list_splice(&tmp_list, &wdata_list);
2641
2642 kref_put(&wdata->refcount,
2643 cifs_uncached_writedata_release);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002644 goto restart_loop;
2645 }
2646 }
2647 list_del_init(&wdata->list);
Steve French4a5c80d2014-02-07 20:45:12 -06002648 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002649 }
2650
Al Viroe9d15932015-04-06 22:44:11 -04002651 if (unlikely(!total_written))
2652 return rc;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002653
Al Viroe9d15932015-04-06 22:44:11 -04002654 iocb->ki_pos += total_written;
2655 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(file_inode(file))->flags);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002656 cifs_stats_bytes_written(tcon, total_written);
Al Viroe9d15932015-04-06 22:44:11 -04002657 return total_written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002658}
2659
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002660static ssize_t
Al Viro3dae8752014-04-03 12:05:17 -04002661cifs_writev(struct kiocb *iocb, struct iov_iter *from)
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002662{
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002663 struct file *file = iocb->ki_filp;
2664 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2665 struct inode *inode = file->f_mapping->host;
2666 struct cifsInodeInfo *cinode = CIFS_I(inode);
2667 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
Al Viro5f380c72015-04-07 11:28:12 -04002668 ssize_t rc;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002669
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002670 /*
2671 * We need to hold the sem to be sure nobody modifies lock list
2672 * with a brlock that prevents writing.
2673 */
2674 down_read(&cinode->lock_sem);
Al Viro19dfc1f2014-04-03 10:27:17 -04002675 mutex_lock(&inode->i_mutex);
Al Viro5f380c72015-04-07 11:28:12 -04002676
Al Viro3309dd02015-04-09 12:55:47 -04002677 rc = generic_write_checks(iocb, from);
2678 if (rc <= 0)
Al Viro5f380c72015-04-07 11:28:12 -04002679 goto out;
2680
Al Viro5f380c72015-04-07 11:28:12 -04002681 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(from),
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002682 server->vals->exclusive_lock_type, NULL,
Al Viro5f380c72015-04-07 11:28:12 -04002683 CIFS_WRITE_OP))
Al Viro3dae8752014-04-03 12:05:17 -04002684 rc = __generic_file_write_iter(iocb, from);
Al Viro5f380c72015-04-07 11:28:12 -04002685 else
2686 rc = -EACCES;
2687out:
2688 mutex_unlock(&inode->i_mutex);
Al Viro19dfc1f2014-04-03 10:27:17 -04002689
Al Viro5f380c72015-04-07 11:28:12 -04002690 if (rc > 0) {
2691 ssize_t err = generic_write_sync(file, iocb->ki_pos - rc, rc);
2692 if (err < 0)
2693 rc = err;
Al Viro19dfc1f2014-04-03 10:27:17 -04002694 }
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002695 up_read(&cinode->lock_sem);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002696 return rc;
2697}
2698
2699ssize_t
Al Viro3dae8752014-04-03 12:05:17 -04002700cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002701{
Al Viro496ad9a2013-01-23 17:07:38 -05002702 struct inode *inode = file_inode(iocb->ki_filp);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002703 struct cifsInodeInfo *cinode = CIFS_I(inode);
2704 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2705 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2706 iocb->ki_filp->private_data;
2707 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002708 ssize_t written;
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002709
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00002710 written = cifs_get_writer(cinode);
2711 if (written)
2712 return written;
2713
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002714 if (CIFS_CACHE_WRITE(cinode)) {
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002715 if (cap_unix(tcon->ses) &&
2716 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00002717 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
Al Viro3dae8752014-04-03 12:05:17 -04002718 written = generic_file_write_iter(iocb, from);
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00002719 goto out;
2720 }
Al Viro3dae8752014-04-03 12:05:17 -04002721 written = cifs_writev(iocb, from);
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00002722 goto out;
Pavel Shilovskyc299dd02012-12-06 22:07:52 +04002723 }
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002724 /*
2725 * For non-oplocked files in strict cache mode we need to write the data
2726 * to the server exactly from the pos to pos+len-1 rather than flush all
2727 * affected pages because it may cause a error with mandatory locks on
2728 * these pages but not on the region from pos to ppos+len-1.
2729 */
Al Viro3dae8752014-04-03 12:05:17 -04002730 written = cifs_user_writev(iocb, from);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002731 if (written > 0 && CIFS_CACHE_READ(cinode)) {
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002732 /*
2733 * Windows 7 server can delay breaking level2 oplock if a write
2734 * request comes - break it on the client to prevent reading
2735 * an old data.
2736 */
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002737 cifs_zap_mapping(inode);
Joe Perchesf96637b2013-05-04 22:12:25 -05002738 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2739 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002740 cinode->oplock = 0;
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002741 }
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00002742out:
2743 cifs_put_writer(cinode);
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002744 return written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002745}
2746
Jeff Layton0471ca32012-05-16 07:13:16 -04002747static struct cifs_readdata *
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002748cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
Jeff Layton0471ca32012-05-16 07:13:16 -04002749{
2750 struct cifs_readdata *rdata;
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002751
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002752 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2753 GFP_KERNEL);
Jeff Layton0471ca32012-05-16 07:13:16 -04002754 if (rdata != NULL) {
Jeff Layton6993f742012-05-16 07:13:17 -04002755 kref_init(&rdata->refcount);
Jeff Layton1c892542012-05-16 07:13:17 -04002756 INIT_LIST_HEAD(&rdata->list);
2757 init_completion(&rdata->done);
Jeff Layton0471ca32012-05-16 07:13:16 -04002758 INIT_WORK(&rdata->work, complete);
Jeff Layton0471ca32012-05-16 07:13:16 -04002759 }
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002760
Jeff Layton0471ca32012-05-16 07:13:16 -04002761 return rdata;
2762}
2763
Jeff Layton6993f742012-05-16 07:13:17 -04002764void
2765cifs_readdata_release(struct kref *refcount)
Jeff Layton0471ca32012-05-16 07:13:16 -04002766{
Jeff Layton6993f742012-05-16 07:13:17 -04002767 struct cifs_readdata *rdata = container_of(refcount,
2768 struct cifs_readdata, refcount);
2769
2770 if (rdata->cfile)
2771 cifsFileInfo_put(rdata->cfile);
2772
Jeff Layton0471ca32012-05-16 07:13:16 -04002773 kfree(rdata);
2774}
2775
Jeff Layton2a1bb132012-05-16 07:13:17 -04002776static int
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002777cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
Jeff Layton1c892542012-05-16 07:13:17 -04002778{
2779 int rc = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002780 struct page *page;
Jeff Layton1c892542012-05-16 07:13:17 -04002781 unsigned int i;
2782
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002783 for (i = 0; i < nr_pages; i++) {
Jeff Layton1c892542012-05-16 07:13:17 -04002784 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2785 if (!page) {
2786 rc = -ENOMEM;
2787 break;
2788 }
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002789 rdata->pages[i] = page;
Jeff Layton1c892542012-05-16 07:13:17 -04002790 }
2791
2792 if (rc) {
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002793 for (i = 0; i < nr_pages; i++) {
2794 put_page(rdata->pages[i]);
2795 rdata->pages[i] = NULL;
Jeff Layton1c892542012-05-16 07:13:17 -04002796 }
2797 }
2798 return rc;
2799}
2800
2801static void
2802cifs_uncached_readdata_release(struct kref *refcount)
2803{
Jeff Layton1c892542012-05-16 07:13:17 -04002804 struct cifs_readdata *rdata = container_of(refcount,
2805 struct cifs_readdata, refcount);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002806 unsigned int i;
Jeff Layton1c892542012-05-16 07:13:17 -04002807
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002808 for (i = 0; i < rdata->nr_pages; i++) {
2809 put_page(rdata->pages[i]);
2810 rdata->pages[i] = NULL;
Jeff Layton1c892542012-05-16 07:13:17 -04002811 }
2812 cifs_readdata_release(refcount);
2813}
2814
Jeff Layton1c892542012-05-16 07:13:17 -04002815/**
2816 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2817 * @rdata: the readdata response with list of pages holding data
Al Viro7f25bba2014-02-04 14:07:43 -05002818 * @iter: destination for our data
Jeff Layton1c892542012-05-16 07:13:17 -04002819 *
2820 * This function copies data from a list of pages in a readdata response into
2821 * an array of iovecs. It will first calculate where the data should go
2822 * based on the info in the readdata and then copy the data into that spot.
2823 */
Al Viro7f25bba2014-02-04 14:07:43 -05002824static int
2825cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
Jeff Layton1c892542012-05-16 07:13:17 -04002826{
Pavel Shilovsky34a54d62014-07-10 10:03:29 +04002827 size_t remaining = rdata->got_bytes;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002828 unsigned int i;
Jeff Layton1c892542012-05-16 07:13:17 -04002829
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002830 for (i = 0; i < rdata->nr_pages; i++) {
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002831 struct page *page = rdata->pages[i];
Geert Uytterhoevene686bd82014-04-13 20:46:21 +02002832 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
Al Viro7f25bba2014-02-04 14:07:43 -05002833 size_t written = copy_page_to_iter(page, 0, copy, iter);
2834 remaining -= written;
2835 if (written < copy && iov_iter_count(iter) > 0)
2836 break;
Jeff Layton1c892542012-05-16 07:13:17 -04002837 }
Al Viro7f25bba2014-02-04 14:07:43 -05002838 return remaining ? -EFAULT : 0;
Jeff Layton1c892542012-05-16 07:13:17 -04002839}
2840
2841static void
2842cifs_uncached_readv_complete(struct work_struct *work)
2843{
2844 struct cifs_readdata *rdata = container_of(work,
2845 struct cifs_readdata, work);
Jeff Layton1c892542012-05-16 07:13:17 -04002846
2847 complete(&rdata->done);
2848 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2849}
2850
2851static int
Jeff Layton8321fec2012-09-19 06:22:32 -07002852cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2853 struct cifs_readdata *rdata, unsigned int len)
Jeff Layton1c892542012-05-16 07:13:17 -04002854{
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04002855 int result = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002856 unsigned int i;
2857 unsigned int nr_pages = rdata->nr_pages;
Jeff Layton8321fec2012-09-19 06:22:32 -07002858 struct kvec iov;
Jeff Layton1c892542012-05-16 07:13:17 -04002859
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04002860 rdata->got_bytes = 0;
Jeff Layton8321fec2012-09-19 06:22:32 -07002861 rdata->tailsz = PAGE_SIZE;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002862 for (i = 0; i < nr_pages; i++) {
2863 struct page *page = rdata->pages[i];
2864
Jeff Layton8321fec2012-09-19 06:22:32 -07002865 if (len >= PAGE_SIZE) {
Jeff Layton1c892542012-05-16 07:13:17 -04002866 /* enough data to fill the page */
Jeff Layton8321fec2012-09-19 06:22:32 -07002867 iov.iov_base = kmap(page);
2868 iov.iov_len = PAGE_SIZE;
Joe Perchesf96637b2013-05-04 22:12:25 -05002869 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2870 i, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07002871 len -= PAGE_SIZE;
2872 } else if (len > 0) {
Jeff Layton1c892542012-05-16 07:13:17 -04002873 /* enough for partial page, fill and zero the rest */
Jeff Layton8321fec2012-09-19 06:22:32 -07002874 iov.iov_base = kmap(page);
2875 iov.iov_len = len;
Joe Perchesf96637b2013-05-04 22:12:25 -05002876 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2877 i, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07002878 memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2879 rdata->tailsz = len;
2880 len = 0;
Jeff Layton1c892542012-05-16 07:13:17 -04002881 } else {
2882 /* no need to hold page hostage */
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002883 rdata->pages[i] = NULL;
2884 rdata->nr_pages--;
Jeff Layton1c892542012-05-16 07:13:17 -04002885 put_page(page);
Jeff Layton8321fec2012-09-19 06:22:32 -07002886 continue;
Jeff Layton1c892542012-05-16 07:13:17 -04002887 }
Jeff Layton8321fec2012-09-19 06:22:32 -07002888
2889 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2890 kunmap(page);
2891 if (result < 0)
2892 break;
2893
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04002894 rdata->got_bytes += result;
Jeff Layton1c892542012-05-16 07:13:17 -04002895 }
2896
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04002897 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
2898 rdata->got_bytes : result;
Jeff Layton1c892542012-05-16 07:13:17 -04002899}
2900
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002901static int
2902cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
2903 struct cifs_sb_info *cifs_sb, struct list_head *rdata_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002904{
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002905 struct cifs_readdata *rdata;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04002906 unsigned int npages, rsize, credits;
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002907 size_t cur_len;
2908 int rc;
Jeff Layton1c892542012-05-16 07:13:17 -04002909 pid_t pid;
Pavel Shilovsky25f40252014-06-25 10:45:07 +04002910 struct TCP_Server_Info *server;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002911
Pavel Shilovsky25f40252014-06-25 10:45:07 +04002912 server = tlink_tcon(open_file->tlink)->ses->server;
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -07002913
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002914 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2915 pid = open_file->pid;
2916 else
2917 pid = current->tgid;
2918
Jeff Layton1c892542012-05-16 07:13:17 -04002919 do {
Pavel Shilovskybed9da02014-06-25 11:28:57 +04002920 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
2921 &rsize, &credits);
2922 if (rc)
2923 break;
2924
2925 cur_len = min_t(const size_t, len, rsize);
Jeff Layton1c892542012-05-16 07:13:17 -04002926 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002927
Jeff Layton1c892542012-05-16 07:13:17 -04002928 /* allocate a readdata struct */
2929 rdata = cifs_readdata_alloc(npages,
2930 cifs_uncached_readv_complete);
2931 if (!rdata) {
Pavel Shilovskybed9da02014-06-25 11:28:57 +04002932 add_credits_and_wake_if(server, credits, 0);
Jeff Layton1c892542012-05-16 07:13:17 -04002933 rc = -ENOMEM;
Jeff Laytonbae9f742014-04-15 12:48:49 -04002934 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002935 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002936
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002937 rc = cifs_read_allocate_pages(rdata, npages);
Jeff Layton1c892542012-05-16 07:13:17 -04002938 if (rc)
2939 goto error;
2940
2941 rdata->cfile = cifsFileInfo_get(open_file);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002942 rdata->nr_pages = npages;
Jeff Layton1c892542012-05-16 07:13:17 -04002943 rdata->offset = offset;
2944 rdata->bytes = cur_len;
2945 rdata->pid = pid;
Jeff Layton8321fec2012-09-19 06:22:32 -07002946 rdata->pagesz = PAGE_SIZE;
2947 rdata->read_into_pages = cifs_uncached_read_into_pages;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04002948 rdata->credits = credits;
Jeff Layton1c892542012-05-16 07:13:17 -04002949
Pavel Shilovsky25f40252014-06-25 10:45:07 +04002950 if (!rdata->cfile->invalidHandle ||
2951 !cifs_reopen_file(rdata->cfile, true))
2952 rc = server->ops->async_readv(rdata);
Jeff Layton1c892542012-05-16 07:13:17 -04002953error:
2954 if (rc) {
Pavel Shilovskybed9da02014-06-25 11:28:57 +04002955 add_credits_and_wake_if(server, rdata->credits, 0);
Jeff Layton1c892542012-05-16 07:13:17 -04002956 kref_put(&rdata->refcount,
2957 cifs_uncached_readdata_release);
Pavel Shilovsky25f40252014-06-25 10:45:07 +04002958 if (rc == -EAGAIN)
2959 continue;
Jeff Layton1c892542012-05-16 07:13:17 -04002960 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002961 }
Jeff Layton1c892542012-05-16 07:13:17 -04002962
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002963 list_add_tail(&rdata->list, rdata_list);
Jeff Layton1c892542012-05-16 07:13:17 -04002964 offset += cur_len;
2965 len -= cur_len;
2966 } while (len > 0);
2967
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002968 return rc;
2969}
2970
2971ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
2972{
2973 struct file *file = iocb->ki_filp;
2974 ssize_t rc;
2975 size_t len;
2976 ssize_t total_read = 0;
2977 loff_t offset = iocb->ki_pos;
2978 struct cifs_sb_info *cifs_sb;
2979 struct cifs_tcon *tcon;
2980 struct cifsFileInfo *open_file;
2981 struct cifs_readdata *rdata, *tmp;
2982 struct list_head rdata_list;
2983
2984 len = iov_iter_count(to);
2985 if (!len)
2986 return 0;
2987
2988 INIT_LIST_HEAD(&rdata_list);
Al Viro7119e222014-10-22 00:25:12 -04002989 cifs_sb = CIFS_FILE_SB(file);
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002990 open_file = file->private_data;
2991 tcon = tlink_tcon(open_file->tlink);
2992
2993 if (!tcon->ses->server->ops->async_readv)
2994 return -ENOSYS;
2995
2996 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
2997 cifs_dbg(FYI, "attempting read on write only file instance\n");
2998
2999 rc = cifs_send_async_read(offset, len, open_file, cifs_sb, &rdata_list);
3000
Jeff Layton1c892542012-05-16 07:13:17 -04003001 /* if at least one read request send succeeded, then reset rc */
3002 if (!list_empty(&rdata_list))
3003 rc = 0;
3004
Al Viroe6a7bcb2014-04-02 19:53:36 -04003005 len = iov_iter_count(to);
Jeff Layton1c892542012-05-16 07:13:17 -04003006 /* the loop below should proceed in the order of increasing offsets */
Pavel Shilovsky25f40252014-06-25 10:45:07 +04003007again:
Jeff Layton1c892542012-05-16 07:13:17 -04003008 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
3009 if (!rc) {
Jeff Layton1c892542012-05-16 07:13:17 -04003010 /* FIXME: freezable sleep too? */
3011 rc = wait_for_completion_killable(&rdata->done);
3012 if (rc)
3013 rc = -EINTR;
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003014 else if (rdata->result == -EAGAIN) {
Al Viro74027f42014-02-04 13:47:26 -05003015 /* resend call if it's a retryable error */
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003016 struct list_head tmp_list;
Pavel Shilovskyd913ed12014-07-10 11:31:48 +04003017 unsigned int got_bytes = rdata->got_bytes;
Jeff Layton1c892542012-05-16 07:13:17 -04003018
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003019 list_del_init(&rdata->list);
3020 INIT_LIST_HEAD(&tmp_list);
Pavel Shilovsky25f40252014-06-25 10:45:07 +04003021
Pavel Shilovskyd913ed12014-07-10 11:31:48 +04003022 /*
3023 * Got a part of data and then reconnect has
3024 * happened -- fill the buffer and continue
3025 * reading.
3026 */
3027 if (got_bytes && got_bytes < rdata->bytes) {
3028 rc = cifs_readdata_to_iov(rdata, to);
3029 if (rc) {
3030 kref_put(&rdata->refcount,
3031 cifs_uncached_readdata_release);
3032 continue;
3033 }
3034 }
3035
3036 rc = cifs_send_async_read(
3037 rdata->offset + got_bytes,
3038 rdata->bytes - got_bytes,
3039 rdata->cfile, cifs_sb,
3040 &tmp_list);
Pavel Shilovsky25f40252014-06-25 10:45:07 +04003041
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003042 list_splice(&tmp_list, &rdata_list);
Pavel Shilovsky25f40252014-06-25 10:45:07 +04003043
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003044 kref_put(&rdata->refcount,
3045 cifs_uncached_readdata_release);
3046 goto again;
3047 } else if (rdata->result)
3048 rc = rdata->result;
3049 else
Jeff Layton1c892542012-05-16 07:13:17 -04003050 rc = cifs_readdata_to_iov(rdata, to);
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003051
Pavel Shilovsky2e8a05d2014-07-10 10:21:15 +04003052 /* if there was a short read -- discard anything left */
3053 if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3054 rc = -ENODATA;
Jeff Layton1c892542012-05-16 07:13:17 -04003055 }
3056 list_del_init(&rdata->list);
3057 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003058 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003059
Al Viroe6a7bcb2014-04-02 19:53:36 -04003060 total_read = len - iov_iter_count(to);
Al Viro7f25bba2014-02-04 14:07:43 -05003061
Jeff Layton1c892542012-05-16 07:13:17 -04003062 cifs_stats_bytes_read(tcon, total_read);
Jeff Layton1c892542012-05-16 07:13:17 -04003063
Pavel Shilovsky09a47072012-09-18 16:20:29 -07003064 /* mask nodata case */
3065 if (rc == -ENODATA)
3066 rc = 0;
3067
Al Viro0165e812014-02-04 14:19:48 -05003068 if (total_read) {
Al Viroe6a7bcb2014-04-02 19:53:36 -04003069 iocb->ki_pos += total_read;
Al Viro0165e812014-02-04 14:19:48 -05003070 return total_read;
3071 }
3072 return rc;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003073}
3074
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003075ssize_t
Al Viroe6a7bcb2014-04-02 19:53:36 -04003076cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003077{
Al Viro496ad9a2013-01-23 17:07:38 -05003078 struct inode *inode = file_inode(iocb->ki_filp);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003079 struct cifsInodeInfo *cinode = CIFS_I(inode);
3080 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3081 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3082 iocb->ki_filp->private_data;
3083 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3084 int rc = -EACCES;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003085
3086 /*
3087 * In strict cache mode we need to read from the server all the time
3088 * if we don't have level II oplock because the server can delay mtime
3089 * change - so we can't make a decision about inode invalidating.
3090 * And we can also fail with pagereading if there are mandatory locks
3091 * on pages affected by this read but not on the region from pos to
3092 * pos+len-1.
3093 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003094 if (!CIFS_CACHE_READ(cinode))
Al Viroe6a7bcb2014-04-02 19:53:36 -04003095 return cifs_user_readv(iocb, to);
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003096
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003097 if (cap_unix(tcon->ses) &&
3098 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3099 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
Al Viroe6a7bcb2014-04-02 19:53:36 -04003100 return generic_file_read_iter(iocb, to);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003101
3102 /*
3103 * We need to hold the sem to be sure nobody modifies lock list
3104 * with a brlock that prevents reading.
3105 */
3106 down_read(&cinode->lock_sem);
Al Viroe6a7bcb2014-04-02 19:53:36 -04003107 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003108 tcon->ses->server->vals->shared_lock_type,
Pavel Shilovsky081c0412012-11-27 18:38:53 +04003109 NULL, CIFS_READ_OP))
Al Viroe6a7bcb2014-04-02 19:53:36 -04003110 rc = generic_file_read_iter(iocb, to);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003111 up_read(&cinode->lock_sem);
3112 return rc;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003113}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003115static ssize_t
3116cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117{
3118 int rc = -EACCES;
3119 unsigned int bytes_read = 0;
3120 unsigned int total_read;
3121 unsigned int current_read_size;
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003122 unsigned int rsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003123 struct cifs_sb_info *cifs_sb;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003124 struct cifs_tcon *tcon;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003125 struct TCP_Server_Info *server;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003126 unsigned int xid;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003127 char *cur_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128 struct cifsFileInfo *open_file;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003129 struct cifs_io_parms io_parms;
Steve Frenchec637e32005-12-12 20:53:18 -08003130 int buf_type = CIFS_NO_BUFFER;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003131 __u32 pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003132
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003133 xid = get_xid();
Al Viro7119e222014-10-22 00:25:12 -04003134 cifs_sb = CIFS_FILE_SB(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003135
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003136 /* FIXME: set up handlers for larger reads and/or convert to async */
3137 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3138
Linus Torvalds1da177e2005-04-16 15:20:36 -07003139 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303140 rc = -EBADF;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003141 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303142 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003143 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07003144 open_file = file->private_data;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003145 tcon = tlink_tcon(open_file->tlink);
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003146 server = tcon->ses->server;
3147
3148 if (!server->ops->sync_read) {
3149 free_xid(xid);
3150 return -ENOSYS;
3151 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003153 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3154 pid = open_file->pid;
3155 else
3156 pid = current->tgid;
3157
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesf96637b2013-05-04 22:12:25 -05003159 cifs_dbg(FYI, "attempting read on write only file instance\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003160
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003161 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3162 total_read += bytes_read, cur_offset += bytes_read) {
Pavel Shilovskye374d902014-06-25 16:19:02 +04003163 do {
3164 current_read_size = min_t(uint, read_size - total_read,
3165 rsize);
3166 /*
3167 * For windows me and 9x we do not want to request more
3168 * than it negotiated since it will refuse the read
3169 * then.
3170 */
3171 if ((tcon->ses) && !(tcon->ses->capabilities &
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003172 tcon->ses->server->vals->cap_large_files)) {
Pavel Shilovskye374d902014-06-25 16:19:02 +04003173 current_read_size = min_t(uint,
3174 current_read_size, CIFSMaxBufSize);
3175 }
Steve Frenchcdff08e2010-10-21 22:46:14 +00003176 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04003177 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003178 if (rc != 0)
3179 break;
3180 }
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003181 io_parms.pid = pid;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003182 io_parms.tcon = tcon;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003183 io_parms.offset = *offset;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003184 io_parms.length = current_read_size;
Steve Frenchdb8b6312014-09-22 05:13:55 -05003185 rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003186 &bytes_read, &cur_offset,
3187 &buf_type);
Pavel Shilovskye374d902014-06-25 16:19:02 +04003188 } while (rc == -EAGAIN);
3189
Linus Torvalds1da177e2005-04-16 15:20:36 -07003190 if (rc || (bytes_read == 0)) {
3191 if (total_read) {
3192 break;
3193 } else {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003194 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003195 return rc;
3196 }
3197 } else {
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003198 cifs_stats_bytes_read(tcon, total_read);
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003199 *offset += bytes_read;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200 }
3201 }
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003202 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003203 return total_read;
3204}
3205
Jeff Laytonca83ce32011-04-12 09:13:44 -04003206/*
3207 * If the page is mmap'ed into a process' page tables, then we need to make
3208 * sure that it doesn't change while being written back.
3209 */
3210static int
3211cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3212{
3213 struct page *page = vmf->page;
3214
3215 lock_page(page);
3216 return VM_FAULT_LOCKED;
3217}
3218
3219static struct vm_operations_struct cifs_file_vm_ops = {
3220 .fault = filemap_fault,
Kirill A. Shutemovf1820362014-04-07 15:37:19 -07003221 .map_pages = filemap_map_pages,
Jeff Laytonca83ce32011-04-12 09:13:44 -04003222 .page_mkwrite = cifs_page_mkwrite,
3223};
3224
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003225int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3226{
3227 int rc, xid;
Al Viro496ad9a2013-01-23 17:07:38 -05003228 struct inode *inode = file_inode(file);
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003229
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003230 xid = get_xid();
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003231
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003232 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
Jeff Layton4f73c7d2014-04-30 09:31:47 -04003233 rc = cifs_zap_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04003234 if (rc)
3235 return rc;
3236 }
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003237
3238 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04003239 if (rc == 0)
3240 vma->vm_ops = &cifs_file_vm_ops;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003241 free_xid(xid);
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003242 return rc;
3243}
3244
Linus Torvalds1da177e2005-04-16 15:20:36 -07003245int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3246{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003247 int rc, xid;
3248
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003249 xid = get_xid();
Jeff Laytonabab0952010-02-12 07:44:18 -05003250 rc = cifs_revalidate_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003251 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003252 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3253 rc);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003254 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003255 return rc;
3256 }
3257 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04003258 if (rc == 0)
3259 vma->vm_ops = &cifs_file_vm_ops;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003260 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003261 return rc;
3262}
3263
Jeff Layton0471ca32012-05-16 07:13:16 -04003264static void
3265cifs_readv_complete(struct work_struct *work)
3266{
Pavel Shilovskyb770ddf2014-07-10 11:31:53 +04003267 unsigned int i, got_bytes;
Jeff Layton0471ca32012-05-16 07:13:16 -04003268 struct cifs_readdata *rdata = container_of(work,
3269 struct cifs_readdata, work);
Jeff Layton0471ca32012-05-16 07:13:16 -04003270
Pavel Shilovskyb770ddf2014-07-10 11:31:53 +04003271 got_bytes = rdata->got_bytes;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003272 for (i = 0; i < rdata->nr_pages; i++) {
3273 struct page *page = rdata->pages[i];
3274
Jeff Layton0471ca32012-05-16 07:13:16 -04003275 lru_cache_add_file(page);
3276
Pavel Shilovskyb770ddf2014-07-10 11:31:53 +04003277 if (rdata->result == 0 ||
3278 (rdata->result == -EAGAIN && got_bytes)) {
Jeff Layton0471ca32012-05-16 07:13:16 -04003279 flush_dcache_page(page);
3280 SetPageUptodate(page);
3281 }
3282
3283 unlock_page(page);
3284
Pavel Shilovskyb770ddf2014-07-10 11:31:53 +04003285 if (rdata->result == 0 ||
3286 (rdata->result == -EAGAIN && got_bytes))
Jeff Layton0471ca32012-05-16 07:13:16 -04003287 cifs_readpage_to_fscache(rdata->mapping->host, page);
3288
Pavel Shilovskyb770ddf2014-07-10 11:31:53 +04003289 got_bytes -= min_t(unsigned int, PAGE_CACHE_SIZE, got_bytes);
3290
Jeff Layton0471ca32012-05-16 07:13:16 -04003291 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003292 rdata->pages[i] = NULL;
Jeff Layton0471ca32012-05-16 07:13:16 -04003293 }
Jeff Layton6993f742012-05-16 07:13:17 -04003294 kref_put(&rdata->refcount, cifs_readdata_release);
Jeff Layton0471ca32012-05-16 07:13:16 -04003295}
3296
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003297static int
Jeff Layton8321fec2012-09-19 06:22:32 -07003298cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3299 struct cifs_readdata *rdata, unsigned int len)
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003300{
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04003301 int result = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003302 unsigned int i;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003303 u64 eof;
3304 pgoff_t eof_index;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003305 unsigned int nr_pages = rdata->nr_pages;
Jeff Layton8321fec2012-09-19 06:22:32 -07003306 struct kvec iov;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003307
3308 /* determine the eof that the server (probably) has */
3309 eof = CIFS_I(rdata->mapping->host)->server_eof;
3310 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
Joe Perchesf96637b2013-05-04 22:12:25 -05003311 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003312
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04003313 rdata->got_bytes = 0;
Jeff Layton8321fec2012-09-19 06:22:32 -07003314 rdata->tailsz = PAGE_CACHE_SIZE;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003315 for (i = 0; i < nr_pages; i++) {
3316 struct page *page = rdata->pages[i];
3317
Jeff Layton8321fec2012-09-19 06:22:32 -07003318 if (len >= PAGE_CACHE_SIZE) {
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003319 /* enough data to fill the page */
Jeff Layton8321fec2012-09-19 06:22:32 -07003320 iov.iov_base = kmap(page);
3321 iov.iov_len = PAGE_CACHE_SIZE;
Joe Perchesf96637b2013-05-04 22:12:25 -05003322 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3323 i, page->index, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07003324 len -= PAGE_CACHE_SIZE;
3325 } else if (len > 0) {
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003326 /* enough for partial page, fill and zero the rest */
Jeff Layton8321fec2012-09-19 06:22:32 -07003327 iov.iov_base = kmap(page);
3328 iov.iov_len = len;
Joe Perchesf96637b2013-05-04 22:12:25 -05003329 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3330 i, page->index, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07003331 memset(iov.iov_base + len,
3332 '\0', PAGE_CACHE_SIZE - len);
3333 rdata->tailsz = len;
3334 len = 0;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003335 } else if (page->index > eof_index) {
3336 /*
3337 * The VFS will not try to do readahead past the
3338 * i_size, but it's possible that we have outstanding
3339 * writes with gaps in the middle and the i_size hasn't
3340 * caught up yet. Populate those with zeroed out pages
3341 * to prevent the VFS from repeatedly attempting to
3342 * fill them until the writes are flushed.
3343 */
3344 zero_user(page, 0, PAGE_CACHE_SIZE);
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003345 lru_cache_add_file(page);
3346 flush_dcache_page(page);
3347 SetPageUptodate(page);
3348 unlock_page(page);
3349 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003350 rdata->pages[i] = NULL;
3351 rdata->nr_pages--;
Jeff Layton8321fec2012-09-19 06:22:32 -07003352 continue;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003353 } else {
3354 /* no need to hold page hostage */
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003355 lru_cache_add_file(page);
3356 unlock_page(page);
3357 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003358 rdata->pages[i] = NULL;
3359 rdata->nr_pages--;
Jeff Layton8321fec2012-09-19 06:22:32 -07003360 continue;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003361 }
Jeff Layton8321fec2012-09-19 06:22:32 -07003362
3363 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3364 kunmap(page);
3365 if (result < 0)
3366 break;
3367
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04003368 rdata->got_bytes += result;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003369 }
3370
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04003371 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3372 rdata->got_bytes : result;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003373}
3374
Pavel Shilovsky387eb922014-06-24 13:08:54 +04003375static int
3376readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
3377 unsigned int rsize, struct list_head *tmplist,
3378 unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
3379{
3380 struct page *page, *tpage;
3381 unsigned int expected_index;
3382 int rc;
3383
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003384 INIT_LIST_HEAD(tmplist);
3385
Pavel Shilovsky387eb922014-06-24 13:08:54 +04003386 page = list_entry(page_list->prev, struct page, lru);
3387
3388 /*
3389 * Lock the page and put it in the cache. Since no one else
3390 * should have access to this page, we're safe to simply set
3391 * PG_locked without checking it first.
3392 */
3393 __set_page_locked(page);
3394 rc = add_to_page_cache_locked(page, mapping,
3395 page->index, GFP_KERNEL);
3396
3397 /* give up if we can't stick it in the cache */
3398 if (rc) {
3399 __clear_page_locked(page);
3400 return rc;
3401 }
3402
3403 /* move first page to the tmplist */
3404 *offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3405 *bytes = PAGE_CACHE_SIZE;
3406 *nr_pages = 1;
3407 list_move_tail(&page->lru, tmplist);
3408
3409 /* now try and add more pages onto the request */
3410 expected_index = page->index + 1;
3411 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3412 /* discontinuity ? */
3413 if (page->index != expected_index)
3414 break;
3415
3416 /* would this page push the read over the rsize? */
3417 if (*bytes + PAGE_CACHE_SIZE > rsize)
3418 break;
3419
3420 __set_page_locked(page);
3421 if (add_to_page_cache_locked(page, mapping, page->index,
3422 GFP_KERNEL)) {
3423 __clear_page_locked(page);
3424 break;
3425 }
3426 list_move_tail(&page->lru, tmplist);
3427 (*bytes) += PAGE_CACHE_SIZE;
3428 expected_index++;
3429 (*nr_pages)++;
3430 }
3431 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003432}
3433
Linus Torvalds1da177e2005-04-16 15:20:36 -07003434static int cifs_readpages(struct file *file, struct address_space *mapping,
3435 struct list_head *page_list, unsigned num_pages)
3436{
Jeff Layton690c5e32011-10-19 15:30:16 -04003437 int rc;
3438 struct list_head tmplist;
3439 struct cifsFileInfo *open_file = file->private_data;
Al Viro7119e222014-10-22 00:25:12 -04003440 struct cifs_sb_info *cifs_sb = CIFS_FILE_SB(file);
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003441 struct TCP_Server_Info *server;
Jeff Layton690c5e32011-10-19 15:30:16 -04003442 pid_t pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003443
Jeff Layton690c5e32011-10-19 15:30:16 -04003444 /*
Suresh Jayaraman56698232010-07-05 18:13:25 +05303445 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3446 * immediately if the cookie is negative
David Howells54afa992013-09-04 17:10:39 +00003447 *
3448 * After this point, every page in the list might have PG_fscache set,
3449 * so we will need to clean that up off of every page we don't use.
Suresh Jayaraman56698232010-07-05 18:13:25 +05303450 */
3451 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3452 &num_pages);
3453 if (rc == 0)
Jeff Layton690c5e32011-10-19 15:30:16 -04003454 return rc;
Suresh Jayaraman56698232010-07-05 18:13:25 +05303455
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003456 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3457 pid = open_file->pid;
3458 else
3459 pid = current->tgid;
3460
Jeff Layton690c5e32011-10-19 15:30:16 -04003461 rc = 0;
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003462 server = tlink_tcon(open_file->tlink)->ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003463
Joe Perchesf96637b2013-05-04 22:12:25 -05003464 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3465 __func__, file, mapping, num_pages);
Jeff Layton690c5e32011-10-19 15:30:16 -04003466
3467 /*
3468 * Start with the page at end of list and move it to private
3469 * list. Do the same with any following pages until we hit
3470 * the rsize limit, hit an index discontinuity, or run out of
3471 * pages. Issue the async read and then start the loop again
3472 * until the list is empty.
3473 *
3474 * Note that list order is important. The page_list is in
3475 * the order of declining indexes. When we put the pages in
3476 * the rdata->pages, then we want them in increasing order.
3477 */
3478 while (!list_empty(page_list)) {
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003479 unsigned int i, nr_pages, bytes, rsize;
Jeff Layton690c5e32011-10-19 15:30:16 -04003480 loff_t offset;
3481 struct page *page, *tpage;
3482 struct cifs_readdata *rdata;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003483 unsigned credits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003484
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003485 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3486 &rsize, &credits);
3487 if (rc)
3488 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003489
Jeff Layton690c5e32011-10-19 15:30:16 -04003490 /*
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003491 * Give up immediately if rsize is too small to read an entire
3492 * page. The VFS will fall back to readpage. We should never
3493 * reach this point however since we set ra_pages to 0 when the
3494 * rsize is smaller than a cache page.
Jeff Layton690c5e32011-10-19 15:30:16 -04003495 */
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003496 if (unlikely(rsize < PAGE_CACHE_SIZE)) {
3497 add_credits_and_wake_if(server, credits, 0);
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003498 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003499 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003500
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003501 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
3502 &nr_pages, &offset, &bytes);
3503 if (rc) {
3504 add_credits_and_wake_if(server, credits, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003505 break;
Jeff Layton690c5e32011-10-19 15:30:16 -04003506 }
3507
Jeff Layton0471ca32012-05-16 07:13:16 -04003508 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
Jeff Layton690c5e32011-10-19 15:30:16 -04003509 if (!rdata) {
3510 /* best to give up if we're out of mem */
3511 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3512 list_del(&page->lru);
3513 lru_cache_add_file(page);
3514 unlock_page(page);
3515 page_cache_release(page);
3516 }
3517 rc = -ENOMEM;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003518 add_credits_and_wake_if(server, credits, 0);
Jeff Layton690c5e32011-10-19 15:30:16 -04003519 break;
3520 }
3521
Jeff Layton6993f742012-05-16 07:13:17 -04003522 rdata->cfile = cifsFileInfo_get(open_file);
Jeff Layton690c5e32011-10-19 15:30:16 -04003523 rdata->mapping = mapping;
3524 rdata->offset = offset;
3525 rdata->bytes = bytes;
3526 rdata->pid = pid;
Jeff Layton8321fec2012-09-19 06:22:32 -07003527 rdata->pagesz = PAGE_CACHE_SIZE;
3528 rdata->read_into_pages = cifs_readpages_read_into_pages;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003529 rdata->credits = credits;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003530
3531 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3532 list_del(&page->lru);
3533 rdata->pages[rdata->nr_pages++] = page;
3534 }
Jeff Layton690c5e32011-10-19 15:30:16 -04003535
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003536 if (!rdata->cfile->invalidHandle ||
3537 !cifs_reopen_file(rdata->cfile, true))
3538 rc = server->ops->async_readv(rdata);
3539 if (rc) {
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003540 add_credits_and_wake_if(server, rdata->credits, 0);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003541 for (i = 0; i < rdata->nr_pages; i++) {
3542 page = rdata->pages[i];
Jeff Layton690c5e32011-10-19 15:30:16 -04003543 lru_cache_add_file(page);
3544 unlock_page(page);
3545 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003546 }
Pavel Shilovsky1209bbd2014-10-02 20:13:35 +04003547 /* Fallback to the readpage in error/reconnect cases */
Jeff Layton6993f742012-05-16 07:13:17 -04003548 kref_put(&rdata->refcount, cifs_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003549 break;
3550 }
Jeff Layton6993f742012-05-16 07:13:17 -04003551
3552 kref_put(&rdata->refcount, cifs_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003553 }
3554
David Howells54afa992013-09-04 17:10:39 +00003555 /* Any pages that have been shown to fscache but didn't get added to
3556 * the pagecache must be uncached before they get returned to the
3557 * allocator.
3558 */
3559 cifs_fscache_readpages_cancel(mapping->host, page_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003560 return rc;
3561}
3562
Sachin Prabhua9e9b7b2013-09-13 14:11:56 +01003563/*
3564 * cifs_readpage_worker must be called with the page pinned
3565 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003566static int cifs_readpage_worker(struct file *file, struct page *page,
3567 loff_t *poffset)
3568{
3569 char *read_data;
3570 int rc;
3571
Suresh Jayaraman56698232010-07-05 18:13:25 +05303572 /* Is the page cached? */
Al Viro496ad9a2013-01-23 17:07:38 -05003573 rc = cifs_readpage_from_fscache(file_inode(file), page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05303574 if (rc == 0)
3575 goto read_complete;
3576
Linus Torvalds1da177e2005-04-16 15:20:36 -07003577 read_data = kmap(page);
3578 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003579
Linus Torvalds1da177e2005-04-16 15:20:36 -07003580 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003581
Linus Torvalds1da177e2005-04-16 15:20:36 -07003582 if (rc < 0)
3583 goto io_error;
3584 else
Joe Perchesf96637b2013-05-04 22:12:25 -05003585 cifs_dbg(FYI, "Bytes read %d\n", rc);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003586
Al Viro496ad9a2013-01-23 17:07:38 -05003587 file_inode(file)->i_atime =
3588 current_fs_time(file_inode(file)->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003589
Linus Torvalds1da177e2005-04-16 15:20:36 -07003590 if (PAGE_CACHE_SIZE > rc)
3591 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3592
3593 flush_dcache_page(page);
3594 SetPageUptodate(page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05303595
3596 /* send this page to the cache */
Al Viro496ad9a2013-01-23 17:07:38 -05003597 cifs_readpage_to_fscache(file_inode(file), page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05303598
Linus Torvalds1da177e2005-04-16 15:20:36 -07003599 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003600
Linus Torvalds1da177e2005-04-16 15:20:36 -07003601io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003602 kunmap(page);
Sachin Prabhu466bd312013-09-13 14:11:57 +01003603 unlock_page(page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05303604
3605read_complete:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003606 return rc;
3607}
3608
3609static int cifs_readpage(struct file *file, struct page *page)
3610{
3611 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3612 int rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003613 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003614
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003615 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003616
3617 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303618 rc = -EBADF;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003619 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303620 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003621 }
3622
Joe Perchesf96637b2013-05-04 22:12:25 -05003623 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003624 page, (int)offset, (int)offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003625
3626 rc = cifs_readpage_worker(file, page, &offset);
3627
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003628 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003629 return rc;
3630}
3631
Steve Frencha403a0a2007-07-26 15:54:16 +00003632static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3633{
3634 struct cifsFileInfo *open_file;
3635
Jeff Layton44772882010-10-15 15:34:03 -04003636 spin_lock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003637 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2e396b82010-10-15 15:34:01 -04003638 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Jeff Layton44772882010-10-15 15:34:03 -04003639 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003640 return 1;
3641 }
3642 }
Jeff Layton44772882010-10-15 15:34:03 -04003643 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003644 return 0;
3645}
3646
Linus Torvalds1da177e2005-04-16 15:20:36 -07003647/* We do not want to update the file size from server for inodes
3648 open for write - to avoid races with writepage extending
3649 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003650 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07003651 but this is tricky to do without racing with writebehind
3652 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00003653bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654{
Steve Frencha403a0a2007-07-26 15:54:16 +00003655 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00003656 return true;
Steve French23e7dd72005-10-20 13:44:56 -07003657
Steve Frencha403a0a2007-07-26 15:54:16 +00003658 if (is_inode_writable(cifsInode)) {
3659 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08003660 struct cifs_sb_info *cifs_sb;
3661
Steve Frenchc32a0b62006-01-12 14:41:28 -08003662 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00003663 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003664 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08003665 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00003666 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08003667 }
3668
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003669 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00003670 return true;
Steve French7ba52632007-02-08 18:14:13 +00003671
Steve French4b18f2a2008-04-29 00:06:05 +00003672 return false;
Steve French23e7dd72005-10-20 13:44:56 -07003673 } else
Steve French4b18f2a2008-04-29 00:06:05 +00003674 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003675}
3676
Nick Piggind9414772008-09-24 11:32:59 -04003677static int cifs_write_begin(struct file *file, struct address_space *mapping,
3678 loff_t pos, unsigned len, unsigned flags,
3679 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003680{
Sachin Prabhu466bd312013-09-13 14:11:57 +01003681 int oncethru = 0;
Nick Piggind9414772008-09-24 11:32:59 -04003682 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3683 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003684 loff_t page_start = pos & PAGE_MASK;
3685 loff_t i_size;
3686 struct page *page;
3687 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003688
Joe Perchesf96637b2013-05-04 22:12:25 -05003689 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
Nick Piggind9414772008-09-24 11:32:59 -04003690
Sachin Prabhu466bd312013-09-13 14:11:57 +01003691start:
Nick Piggin54566b22009-01-04 12:00:53 -08003692 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003693 if (!page) {
3694 rc = -ENOMEM;
3695 goto out;
3696 }
Nick Piggind9414772008-09-24 11:32:59 -04003697
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003698 if (PageUptodate(page))
3699 goto out;
Steve French8a236262007-03-06 00:31:00 +00003700
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003701 /*
3702 * If we write a full page it will be up to date, no need to read from
3703 * the server. If the write is short, we'll end up doing a sync write
3704 * instead.
3705 */
3706 if (len == PAGE_CACHE_SIZE)
3707 goto out;
3708
3709 /*
3710 * optimize away the read when we have an oplock, and we're not
3711 * expecting to use any of the data we'd be reading in. That
3712 * is, when the page lies beyond the EOF, or straddles the EOF
3713 * and the write will cover all of the existing data.
3714 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003715 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003716 i_size = i_size_read(mapping->host);
3717 if (page_start >= i_size ||
3718 (offset == 0 && (pos + len) >= i_size)) {
3719 zero_user_segments(page, 0, offset,
3720 offset + len,
3721 PAGE_CACHE_SIZE);
3722 /*
3723 * PageChecked means that the parts of the page
3724 * to which we're not writing are considered up
3725 * to date. Once the data is copied to the
3726 * page, it can be set uptodate.
3727 */
3728 SetPageChecked(page);
3729 goto out;
3730 }
3731 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003732
Sachin Prabhu466bd312013-09-13 14:11:57 +01003733 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003734 /*
3735 * might as well read a page, it is fast enough. If we get
3736 * an error, we don't need to return it. cifs_write_end will
3737 * do a sync write instead since PG_uptodate isn't set.
3738 */
3739 cifs_readpage_worker(file, page, &page_start);
Sachin Prabhu466bd312013-09-13 14:11:57 +01003740 page_cache_release(page);
3741 oncethru = 1;
3742 goto start;
Steve French8a236262007-03-06 00:31:00 +00003743 } else {
3744 /* we could try using another file handle if there is one -
3745 but how would we lock it to prevent close of that handle
3746 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04003747 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00003748 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003749out:
3750 *pagep = page;
3751 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003752}
3753
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303754static int cifs_release_page(struct page *page, gfp_t gfp)
3755{
3756 if (PagePrivate(page))
3757 return 0;
3758
3759 return cifs_fscache_release_page(page, gfp);
3760}
3761
Lukas Czernerd47992f2013-05-21 23:17:23 -04003762static void cifs_invalidate_page(struct page *page, unsigned int offset,
3763 unsigned int length)
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303764{
3765 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3766
Lukas Czernerd47992f2013-05-21 23:17:23 -04003767 if (offset == 0 && length == PAGE_CACHE_SIZE)
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303768 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3769}
3770
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003771static int cifs_launder_page(struct page *page)
3772{
3773 int rc = 0;
3774 loff_t range_start = page_offset(page);
3775 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3776 struct writeback_control wbc = {
3777 .sync_mode = WB_SYNC_ALL,
3778 .nr_to_write = 0,
3779 .range_start = range_start,
3780 .range_end = range_end,
3781 };
3782
Joe Perchesf96637b2013-05-04 22:12:25 -05003783 cifs_dbg(FYI, "Launder page: %p\n", page);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003784
3785 if (clear_page_dirty_for_io(page))
3786 rc = cifs_writepage_locked(page, &wbc);
3787
3788 cifs_fscache_invalidate_page(page, page->mapping->host);
3789 return rc;
3790}
3791
Tejun Heo9b646972010-07-20 22:09:02 +02003792void cifs_oplock_break(struct work_struct *work)
Jeff Layton3bc303c2009-09-21 06:47:50 -04003793{
3794 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3795 oplock_break);
David Howells2b0143b2015-03-17 22:25:59 +00003796 struct inode *inode = d_inode(cfile->dentry);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003797 struct cifsInodeInfo *cinode = CIFS_I(inode);
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -07003798 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00003799 struct TCP_Server_Info *server = tcon->ses->server;
Jeff Laytoneb4b7562010-10-22 14:52:29 -04003800 int rc = 0;
Jeff Layton3bc303c2009-09-21 06:47:50 -04003801
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00003802 wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
NeilBrown74316202014-07-07 15:16:04 +10003803 TASK_UNINTERRUPTIBLE);
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00003804
3805 server->ops->downgrade_oplock(server, cinode,
3806 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
3807
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003808 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04003809 cifs_has_mand_locks(cinode)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003810 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3811 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003812 cinode->oplock = 0;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04003813 }
3814
Jeff Layton3bc303c2009-09-21 06:47:50 -04003815 if (inode && S_ISREG(inode->i_mode)) {
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003816 if (CIFS_CACHE_READ(cinode))
Al Viro8737c932009-12-24 06:47:55 -05003817 break_lease(inode, O_RDONLY);
Steve Frenchd54ff732010-04-27 04:38:15 +00003818 else
Al Viro8737c932009-12-24 06:47:55 -05003819 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003820 rc = filemap_fdatawrite(inode->i_mapping);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003821 if (!CIFS_CACHE_READ(cinode)) {
Jeff Laytoneb4b7562010-10-22 14:52:29 -04003822 rc = filemap_fdatawait(inode->i_mapping);
3823 mapping_set_error(inode->i_mapping, rc);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04003824 cifs_zap_mapping(inode);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003825 }
Joe Perchesf96637b2013-05-04 22:12:25 -05003826 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003827 }
3828
Pavel Shilovsky85160e02011-10-22 15:33:29 +04003829 rc = cifs_push_locks(cfile);
3830 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003831 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04003832
Jeff Layton3bc303c2009-09-21 06:47:50 -04003833 /*
3834 * releasing stale oplock after recent reconnect of smb session using
3835 * a now incorrect file handle is not a data integrity issue but do
3836 * not bother sending an oplock release if session to server still is
3837 * disconnected since oplock already released by the server
3838 */
Steve Frenchcdff08e2010-10-21 22:46:14 +00003839 if (!cfile->oplock_break_cancelled) {
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -07003840 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3841 cinode);
Joe Perchesf96637b2013-05-04 22:12:25 -05003842 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003843 }
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00003844 cifs_done_oplock_break(cinode);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003845}
3846
Steve Frenchdca69282013-11-11 16:42:37 -06003847/*
3848 * The presence of cifs_direct_io() in the address space ops vector
3849 * allowes open() O_DIRECT flags which would have failed otherwise.
3850 *
3851 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
3852 * so this method should never be called.
3853 *
3854 * Direct IO is not yet supported in the cached mode.
3855 */
3856static ssize_t
Omar Sandoval22c61862015-03-16 04:33:53 -07003857cifs_direct_io(struct kiocb *iocb, struct iov_iter *iter, loff_t pos)
Steve Frenchdca69282013-11-11 16:42:37 -06003858{
3859 /*
3860 * FIXME
3861 * Eventually need to support direct IO for non forcedirectio mounts
3862 */
3863 return -EINVAL;
3864}
3865
3866
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07003867const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003868 .readpage = cifs_readpage,
3869 .readpages = cifs_readpages,
3870 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07003871 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04003872 .write_begin = cifs_write_begin,
3873 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003874 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303875 .releasepage = cifs_release_page,
Steve Frenchdca69282013-11-11 16:42:37 -06003876 .direct_IO = cifs_direct_io,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303877 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003878 .launder_page = cifs_launder_page,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003879};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003880
3881/*
3882 * cifs_readpages requires the server to support a buffer large enough to
3883 * contain the header plus one complete page of data. Otherwise, we need
3884 * to leave cifs_readpages out of the address space operations.
3885 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07003886const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003887 .readpage = cifs_readpage,
3888 .writepage = cifs_writepage,
3889 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04003890 .write_begin = cifs_write_begin,
3891 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003892 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303893 .releasepage = cifs_release_page,
3894 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003895 .launder_page = cifs_launder_page,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003896};