blob: 3e4d00a06c446b997750888bd080b9868a8771f9 [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,
143 cifs_sb->mnt_cifs_flags &
144 CIFS_MOUNT_MAP_SPECIAL_CHR);
145 cifs_put_tlink(tlink);
146
147 if (rc)
148 goto posix_open_ret;
149
150 if (presp_data->Type == cpu_to_le32(-1))
151 goto posix_open_ret; /* open ok, caller does qpathinfo */
152
153 if (!pinode)
154 goto posix_open_ret; /* caller does not need info */
155
156 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
157
158 /* get new inode and set it up */
159 if (*pinode == NULL) {
160 cifs_fill_uniqueid(sb, &fattr);
161 *pinode = cifs_iget(sb, &fattr);
162 if (!*pinode) {
163 rc = -ENOMEM;
164 goto posix_open_ret;
165 }
166 } else {
167 cifs_fattr_to_inode(*pinode, &fattr);
168 }
169
170posix_open_ret:
171 kfree(presp_data);
172 return rc;
173}
174
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300175static int
176cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700177 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *oplock,
178 struct cifs_fid *fid, unsigned int xid)
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300179{
180 int rc;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700181 int desired_access;
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300182 int disposition;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500183 int create_options = CREATE_NOT_DIR;
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300184 FILE_ALL_INFO *buf;
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700185 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400186 struct cifs_open_parms oparms;
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300187
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700188 if (!server->ops->open)
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700189 return -ENOSYS;
190
191 desired_access = cifs_convert_flags(f_flags);
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300192
193/*********************************************************************
194 * open flag mapping table:
195 *
196 * POSIX Flag CIFS Disposition
197 * ---------- ----------------
198 * O_CREAT FILE_OPEN_IF
199 * O_CREAT | O_EXCL FILE_CREATE
200 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
201 * O_TRUNC FILE_OVERWRITE
202 * none of the above FILE_OPEN
203 *
204 * Note that there is not a direct match between disposition
205 * FILE_SUPERSEDE (ie create whether or not file exists although
206 * O_CREAT | O_TRUNC is similar but truncates the existing
207 * file rather than creating a new file as FILE_SUPERSEDE does
208 * (which uses the attributes / metadata passed in on open call)
209 *?
210 *? O_SYNC is a reasonable match to CIFS writethrough flag
211 *? and the read write flags match reasonably. O_LARGEFILE
212 *? is irrelevant because largefile support is always used
213 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
214 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
215 *********************************************************************/
216
217 disposition = cifs_get_disposition(f_flags);
218
219 /* BB pass O_SYNC flag through on file attributes .. BB */
220
221 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
222 if (!buf)
223 return -ENOMEM;
224
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500225 if (backup_cred(cifs_sb))
226 create_options |= CREATE_OPEN_BACKUP_INTENT;
227
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400228 oparms.tcon = tcon;
229 oparms.cifs_sb = cifs_sb;
230 oparms.desired_access = desired_access;
231 oparms.create_options = create_options;
232 oparms.disposition = disposition;
233 oparms.path = full_path;
234 oparms.fid = fid;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400235 oparms.reconnect = false;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400236
237 rc = server->ops->open(xid, &oparms, oplock, buf);
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300238
239 if (rc)
240 goto out;
241
242 if (tcon->unix_ext)
243 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
244 xid);
245 else
246 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
Steve French42eacf92014-02-10 14:08:16 -0600247 xid, fid);
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300248
249out:
250 kfree(buf);
251 return rc;
252}
253
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400254static bool
255cifs_has_mand_locks(struct cifsInodeInfo *cinode)
256{
257 struct cifs_fid_locks *cur;
258 bool has_locks = false;
259
260 down_read(&cinode->lock_sem);
261 list_for_each_entry(cur, &cinode->llist, llist) {
262 if (!list_empty(&cur->locks)) {
263 has_locks = true;
264 break;
265 }
266 }
267 up_read(&cinode->lock_sem);
268 return has_locks;
269}
270
Jeff Layton15ecb432010-10-15 15:34:02 -0400271struct cifsFileInfo *
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700272cifs_new_fileinfo(struct cifs_fid *fid, struct file *file,
Jeff Layton15ecb432010-10-15 15:34:02 -0400273 struct tcon_link *tlink, __u32 oplock)
274{
275 struct dentry *dentry = file->f_path.dentry;
276 struct inode *inode = dentry->d_inode;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700277 struct cifsInodeInfo *cinode = CIFS_I(inode);
278 struct cifsFileInfo *cfile;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700279 struct cifs_fid_locks *fdlocks;
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700280 struct cifs_tcon *tcon = tlink_tcon(tlink);
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400281 struct TCP_Server_Info *server = tcon->ses->server;
Jeff Layton15ecb432010-10-15 15:34:02 -0400282
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700283 cfile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
284 if (cfile == NULL)
285 return cfile;
Jeff Layton15ecb432010-10-15 15:34:02 -0400286
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700287 fdlocks = kzalloc(sizeof(struct cifs_fid_locks), GFP_KERNEL);
288 if (!fdlocks) {
289 kfree(cfile);
290 return NULL;
291 }
292
293 INIT_LIST_HEAD(&fdlocks->locks);
294 fdlocks->cfile = cfile;
295 cfile->llist = fdlocks;
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700296 down_write(&cinode->lock_sem);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700297 list_add(&fdlocks->llist, &cinode->llist);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700298 up_write(&cinode->lock_sem);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700299
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700300 cfile->count = 1;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700301 cfile->pid = current->tgid;
302 cfile->uid = current_fsuid();
303 cfile->dentry = dget(dentry);
304 cfile->f_flags = file->f_flags;
305 cfile->invalidHandle = false;
306 cfile->tlink = cifs_get_tlink(tlink);
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700307 INIT_WORK(&cfile->oplock_break, cifs_oplock_break);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700308 mutex_init(&cfile->fh_mutex);
Jeff Layton15ecb432010-10-15 15:34:02 -0400309
Mateusz Guzik24261fc2013-03-08 16:30:03 +0100310 cifs_sb_active(inode->i_sb);
311
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400312 /*
313 * If the server returned a read oplock and we have mandatory brlocks,
314 * set oplock level to None.
315 */
Pavel Shilovsky53ef1012013-09-05 16:11:28 +0400316 if (server->ops->is_read_op(oplock) && cifs_has_mand_locks(cinode)) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500317 cifs_dbg(FYI, "Reset oplock val from read to None due to mand locks\n");
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400318 oplock = 0;
319 }
320
Jeff Layton44772882010-10-15 15:34:03 -0400321 spin_lock(&cifs_file_list_lock);
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400322 if (fid->pending_open->oplock != CIFS_OPLOCK_NO_CHANGE && oplock)
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700323 oplock = fid->pending_open->oplock;
324 list_del(&fid->pending_open->olist);
325
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400326 fid->purge_cache = false;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +0400327 server->ops->set_fid(cfile, fid, oplock);
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700328
329 list_add(&cfile->tlist, &tcon->openFileList);
Jeff Layton15ecb432010-10-15 15:34:02 -0400330 /* if readable file instance put first in list*/
331 if (file->f_mode & FMODE_READ)
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700332 list_add(&cfile->flist, &cinode->openFileList);
Jeff Layton15ecb432010-10-15 15:34:02 -0400333 else
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700334 list_add_tail(&cfile->flist, &cinode->openFileList);
Jeff Layton44772882010-10-15 15:34:03 -0400335 spin_unlock(&cifs_file_list_lock);
Jeff Layton15ecb432010-10-15 15:34:02 -0400336
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400337 if (fid->purge_cache)
Jeff Layton4f73c7d2014-04-30 09:31:47 -0400338 cifs_zap_mapping(inode);
Pavel Shilovsky42873b02013-09-05 21:30:16 +0400339
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700340 file->private_data = cfile;
341 return cfile;
Jeff Layton15ecb432010-10-15 15:34:02 -0400342}
343
Jeff Layton764a1b12012-07-25 14:59:54 -0400344struct cifsFileInfo *
345cifsFileInfo_get(struct cifsFileInfo *cifs_file)
346{
347 spin_lock(&cifs_file_list_lock);
348 cifsFileInfo_get_locked(cifs_file);
349 spin_unlock(&cifs_file_list_lock);
350 return cifs_file;
351}
352
Steve Frenchcdff08e2010-10-21 22:46:14 +0000353/*
354 * Release a reference on the file private data. This may involve closing
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400355 * the filehandle out on the server. Must be called without holding
356 * cifs_file_list_lock.
Steve Frenchcdff08e2010-10-21 22:46:14 +0000357 */
Jeff Laytonb33879a2010-10-15 15:34:04 -0400358void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
359{
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300360 struct inode *inode = cifs_file->dentry->d_inode;
Steve French96daf2b2011-05-27 04:34:02 +0000361 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700362 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300363 struct cifsInodeInfo *cifsi = CIFS_I(inode);
Mateusz Guzik24261fc2013-03-08 16:30:03 +0100364 struct super_block *sb = inode->i_sb;
365 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000366 struct cifsLockInfo *li, *tmp;
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700367 struct cifs_fid fid;
368 struct cifs_pending_open open;
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",
388 cifs_file->dentry->d_inode);
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
Jeff Laytonad635942011-07-26 12:20:17 -0400400 cancel_work_sync(&cifs_file->oplock_break);
401
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
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700412 cifs_del_pending_open(&open);
413
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700414 /*
415 * Delete any outstanding lock records. We'll lose them when the file
Steve Frenchcdff08e2010-10-21 22:46:14 +0000416 * is closed anyway.
417 */
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700418 down_write(&cifsi->lock_sem);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700419 list_for_each_entry_safe(li, tmp, &cifs_file->llist->locks, llist) {
Steve Frenchcdff08e2010-10-21 22:46:14 +0000420 list_del(&li->llist);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400421 cifs_del_lock_waiters(li);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000422 kfree(li);
423 }
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700424 list_del(&cifs_file->llist->llist);
425 kfree(cifs_file->llist);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700426 up_write(&cifsi->lock_sem);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000427
428 cifs_put_tlink(cifs_file->tlink);
429 dput(cifs_file->dentry);
Mateusz Guzik24261fc2013-03-08 16:30:03 +0100430 cifs_sb_deactive(sb);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000431 kfree(cifs_file);
Jeff Laytonb33879a2010-10-15 15:34:04 -0400432}
433
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434int cifs_open(struct inode *inode, struct file *file)
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700435
Linus Torvalds1da177e2005-04-16 15:20:36 -0700436{
437 int rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400438 unsigned int xid;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400439 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700440 struct cifs_sb_info *cifs_sb;
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700441 struct TCP_Server_Info *server;
Steve French96daf2b2011-05-27 04:34:02 +0000442 struct cifs_tcon *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400443 struct tcon_link *tlink;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700444 struct cifsFileInfo *cfile = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 char *full_path = NULL;
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300446 bool posix_open_ok = false;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700447 struct cifs_fid fid;
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700448 struct cifs_pending_open open;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400450 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451
452 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400453 tlink = cifs_sb_tlink(cifs_sb);
454 if (IS_ERR(tlink)) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400455 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400456 return PTR_ERR(tlink);
457 }
458 tcon = tlink_tcon(tlink);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700459 server = tcon->ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800461 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700462 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530463 rc = -ENOMEM;
Jeff Layton232341b2010-08-05 13:58:38 -0400464 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465 }
466
Joe Perchesf96637b2013-05-04 22:12:25 -0500467 cifs_dbg(FYI, "inode = 0x%p file flags are 0x%x for %s\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +0000468 inode, file->f_flags, full_path);
Steve French276a74a2009-03-03 18:00:34 +0000469
Namjae Jeon787aded2014-08-22 14:22:51 +0900470 if (file->f_flags & O_DIRECT &&
471 cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO) {
472 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NO_BRL)
473 file->f_op = &cifs_file_direct_nobrl_ops;
474 else
475 file->f_op = &cifs_file_direct_ops;
476 }
477
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700478 if (server->oplocks)
Steve French276a74a2009-03-03 18:00:34 +0000479 oplock = REQ_OPLOCK;
480 else
481 oplock = 0;
482
Steve French64cc2c62009-03-04 19:54:08 +0000483 if (!tcon->broken_posix_open && tcon->unix_ext &&
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400484 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
485 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Steve French276a74a2009-03-03 18:00:34 +0000486 /* can not refresh inode info since size could be stale */
Jeff Layton2422f672010-06-16 13:40:16 -0400487 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000488 cifs_sb->mnt_file_mode /* ignored */,
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700489 file->f_flags, &oplock, &fid.netfid, xid);
Steve French276a74a2009-03-03 18:00:34 +0000490 if (rc == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500491 cifs_dbg(FYI, "posix open succeeded\n");
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300492 posix_open_ok = true;
Steve French64cc2c62009-03-04 19:54:08 +0000493 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
494 if (tcon->ses->serverNOS)
Joe Perchesf96637b2013-05-04 22:12:25 -0500495 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",
496 tcon->ses->serverName,
497 tcon->ses->serverNOS);
Steve French64cc2c62009-03-04 19:54:08 +0000498 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000499 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
500 (rc != -EOPNOTSUPP)) /* path not found or net err */
501 goto out;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700502 /*
503 * Else fallthrough to retry open the old way on network i/o
504 * or DFS errors.
505 */
Steve French276a74a2009-03-03 18:00:34 +0000506 }
507
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700508 if (server->ops->get_lease_key)
509 server->ops->get_lease_key(inode, &fid);
510
511 cifs_add_pending_open(&fid, tlink, &open);
512
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300513 if (!posix_open_ok) {
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700514 if (server->ops->get_lease_key)
515 server->ops->get_lease_key(inode, &fid);
516
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300517 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700518 file->f_flags, &oplock, &fid, xid);
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700519 if (rc) {
520 cifs_del_pending_open(&open);
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300521 goto out;
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700522 }
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300523 }
Jeff Layton47c78b72010-06-16 13:40:17 -0400524
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700525 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
526 if (cfile == NULL) {
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700527 if (server->ops->close)
528 server->ops->close(xid, tcon, &fid);
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700529 cifs_del_pending_open(&open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530 rc = -ENOMEM;
531 goto out;
532 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530534 cifs_fscache_set_inode_cookie(inode, file);
535
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300536 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700537 /*
538 * Time to set mode which we can not set earlier due to
539 * problems creating new read-only files.
540 */
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300541 struct cifs_unix_set_info_args args = {
542 .mode = inode->i_mode,
Eric W. Biederman49418b22013-02-06 00:57:56 -0800543 .uid = INVALID_UID, /* no change */
544 .gid = INVALID_GID, /* no change */
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300545 .ctime = NO_CHANGE_64,
546 .atime = NO_CHANGE_64,
547 .mtime = NO_CHANGE_64,
548 .device = 0,
549 };
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700550 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
551 cfile->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700552 }
553
554out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400556 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400557 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558 return rc;
559}
560
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400561static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
562
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700563/*
564 * Try to reacquire byte range locks that were released when session
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400565 * to server was lost.
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700566 */
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400567static int
568cifs_relock_file(struct cifsFileInfo *cfile)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569{
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400570 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
571 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
572 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573 int rc = 0;
574
Pavel Shilovsky689c3db2013-07-11 11:17:45 +0400575 down_read(&cinode->lock_sem);
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400576 if (cinode->can_cache_brlcks) {
Pavel Shilovsky689c3db2013-07-11 11:17:45 +0400577 /* can cache locks - no need to relock */
578 up_read(&cinode->lock_sem);
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400579 return rc;
580 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400582 if (cap_unix(tcon->ses) &&
583 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
584 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
585 rc = cifs_push_posix_locks(cfile);
586 else
587 rc = tcon->ses->server->ops->push_mand_locks(cfile);
588
Pavel Shilovsky689c3db2013-07-11 11:17:45 +0400589 up_read(&cinode->lock_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 return rc;
591}
592
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700593static int
594cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700595{
596 int rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400597 unsigned int xid;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400598 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +0000600 struct cifs_tcon *tcon;
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700601 struct TCP_Server_Info *server;
602 struct cifsInodeInfo *cinode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000603 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 char *full_path = NULL;
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700605 int desired_access;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 int disposition = FILE_OPEN;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500607 int create_options = CREATE_NOT_DIR;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400608 struct cifs_open_parms oparms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400610 xid = get_xid();
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700611 mutex_lock(&cfile->fh_mutex);
612 if (!cfile->invalidHandle) {
613 mutex_unlock(&cfile->fh_mutex);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530614 rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400615 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530616 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 }
618
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700619 inode = cfile->dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 cifs_sb = CIFS_SB(inode->i_sb);
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700621 tcon = tlink_tcon(cfile->tlink);
622 server = tcon->ses->server;
Steve French3a9f4622007-04-04 17:10:24 +0000623
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700624 /*
625 * Can not grab rename sem here because various ops, including those
626 * that already have the rename sem can end up causing writepage to get
627 * called and if the server was down that means we end up here, and we
628 * can never tell if the caller already has the rename_sem.
629 */
630 full_path = build_path_from_dentry(cfile->dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000632 rc = -ENOMEM;
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700633 mutex_unlock(&cfile->fh_mutex);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400634 free_xid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000635 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 }
637
Joe Perchesf96637b2013-05-04 22:12:25 -0500638 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
639 inode, cfile->f_flags, full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300641 if (tcon->ses->server->oplocks)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 oplock = REQ_OPLOCK;
643 else
Steve French4b18f2a2008-04-29 00:06:05 +0000644 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400646 if (tcon->unix_ext && cap_unix(tcon->ses) &&
Steve French7fc8f4e2009-02-23 20:43:11 +0000647 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400648 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton608712f2010-10-15 15:33:56 -0400649 /*
650 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
651 * original open. Must mask them off for a reopen.
652 */
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700653 unsigned int oflags = cfile->f_flags &
Jeff Layton15886172010-10-15 15:33:59 -0400654 ~(O_CREAT | O_EXCL | O_TRUNC);
Jeff Layton608712f2010-10-15 15:33:56 -0400655
Jeff Layton2422f672010-06-16 13:40:16 -0400656 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700657 cifs_sb->mnt_file_mode /* ignored */,
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400658 oflags, &oplock, &cfile->fid.netfid, xid);
Steve French7fc8f4e2009-02-23 20:43:11 +0000659 if (rc == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500660 cifs_dbg(FYI, "posix reopen succeeded\n");
Andi Shytife090e42013-07-29 20:04:35 +0200661 oparms.reconnect = true;
Steve French7fc8f4e2009-02-23 20:43:11 +0000662 goto reopen_success;
663 }
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700664 /*
665 * fallthrough to retry open the old way on errors, especially
666 * in the reconnect path it is important to retry hard
667 */
Steve French7fc8f4e2009-02-23 20:43:11 +0000668 }
669
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700670 desired_access = cifs_convert_flags(cfile->f_flags);
Steve French7fc8f4e2009-02-23 20:43:11 +0000671
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500672 if (backup_cred(cifs_sb))
673 create_options |= CREATE_OPEN_BACKUP_INTENT;
674
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700675 if (server->ops->get_lease_key)
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400676 server->ops->get_lease_key(inode, &cfile->fid);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700677
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400678 oparms.tcon = tcon;
679 oparms.cifs_sb = cifs_sb;
680 oparms.desired_access = desired_access;
681 oparms.create_options = create_options;
682 oparms.disposition = disposition;
683 oparms.path = full_path;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400684 oparms.fid = &cfile->fid;
685 oparms.reconnect = true;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400686
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700687 /*
688 * Can not refresh inode by passing in file_info buf to be returned by
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400689 * ops->open and then calling get_inode_info with returned buf since
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700690 * file might have write behind data that needs to be flushed and server
691 * version of file size can be stale. If we knew for sure that inode was
692 * not dirty locally we could do this.
693 */
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400694 rc = server->ops->open(xid, &oparms, &oplock, NULL);
Pavel Shilovskyb33fcf12013-07-11 10:58:30 +0400695 if (rc == -ENOENT && oparms.reconnect == false) {
696 /* durable handle timeout is expired - open the file again */
697 rc = server->ops->open(xid, &oparms, &oplock, NULL);
698 /* indicate that we need to relock the file */
699 oparms.reconnect = true;
700 }
701
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 if (rc) {
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700703 mutex_unlock(&cfile->fh_mutex);
Joe Perchesf96637b2013-05-04 22:12:25 -0500704 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
705 cifs_dbg(FYI, "oplock: %d\n", oplock);
Jeff Layton15886172010-10-15 15:33:59 -0400706 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 }
Jeff Layton15886172010-10-15 15:33:59 -0400708
709reopen_success:
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700710 cfile->invalidHandle = false;
711 mutex_unlock(&cfile->fh_mutex);
712 cinode = CIFS_I(inode);
Jeff Layton15886172010-10-15 15:33:59 -0400713
714 if (can_flush) {
715 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -0400716 mapping_set_error(inode->i_mapping, rc);
Jeff Layton15886172010-10-15 15:33:59 -0400717
Jeff Layton15886172010-10-15 15:33:59 -0400718 if (tcon->unix_ext)
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700719 rc = cifs_get_inode_info_unix(&inode, full_path,
720 inode->i_sb, xid);
Jeff Layton15886172010-10-15 15:33:59 -0400721 else
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700722 rc = cifs_get_inode_info(&inode, full_path, NULL,
723 inode->i_sb, xid, NULL);
724 }
725 /*
726 * Else we are writing out data to server already and could deadlock if
727 * we tried to flush data, and since we do not know if we have data that
728 * would invalidate the current end of file on the server we can not go
729 * to the server to get the new inode info.
730 */
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300731
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400732 server->ops->set_fid(cfile, &cfile->fid, oplock);
733 if (oparms.reconnect)
734 cifs_relock_file(cfile);
Jeff Layton15886172010-10-15 15:33:59 -0400735
736reopen_error_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700737 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400738 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 return rc;
740}
741
742int cifs_close(struct inode *inode, struct file *file)
743{
Jeff Layton77970692011-04-05 16:23:47 -0700744 if (file->private_data != NULL) {
745 cifsFileInfo_put(file->private_data);
746 file->private_data = NULL;
747 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
Steve Frenchcdff08e2010-10-21 22:46:14 +0000749 /* return code from the ->release op is always ignored */
750 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751}
752
753int cifs_closedir(struct inode *inode, struct file *file)
754{
755 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400756 unsigned int xid;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700757 struct cifsFileInfo *cfile = file->private_data;
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700758 struct cifs_tcon *tcon;
759 struct TCP_Server_Info *server;
760 char *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761
Joe Perchesf96637b2013-05-04 22:12:25 -0500762 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700763
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700764 if (cfile == NULL)
765 return rc;
766
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400767 xid = get_xid();
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700768 tcon = tlink_tcon(cfile->tlink);
769 server = tcon->ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770
Joe Perchesf96637b2013-05-04 22:12:25 -0500771 cifs_dbg(FYI, "Freeing private data in close dir\n");
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700772 spin_lock(&cifs_file_list_lock);
Pavel Shilovsky52755802014-08-18 20:49:57 +0400773 if (server->ops->dir_needs_close(cfile)) {
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700774 cfile->invalidHandle = true;
775 spin_unlock(&cifs_file_list_lock);
776 if (server->ops->close_dir)
777 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
778 else
779 rc = -ENOSYS;
Joe Perchesf96637b2013-05-04 22:12:25 -0500780 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700781 /* not much we can do if it fails anyway, ignore rc */
782 rc = 0;
783 } else
784 spin_unlock(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700786 buf = cfile->srch_inf.ntwrk_buf_start;
787 if (buf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500788 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700789 cfile->srch_inf.ntwrk_buf_start = NULL;
790 if (cfile->srch_inf.smallBuf)
791 cifs_small_buf_release(buf);
792 else
793 cifs_buf_release(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794 }
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700795
796 cifs_put_tlink(cfile->tlink);
797 kfree(file->private_data);
798 file->private_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 /* BB can we lock the filestruct while this is going on? */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400800 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700801 return rc;
802}
803
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400804static struct cifsLockInfo *
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300805cifs_lock_init(__u64 offset, __u64 length, __u8 type)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000806{
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400807 struct cifsLockInfo *lock =
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000808 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400809 if (!lock)
810 return lock;
811 lock->offset = offset;
812 lock->length = length;
813 lock->type = type;
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400814 lock->pid = current->tgid;
815 INIT_LIST_HEAD(&lock->blist);
816 init_waitqueue_head(&lock->block_q);
817 return lock;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400818}
819
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -0700820void
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400821cifs_del_lock_waiters(struct cifsLockInfo *lock)
822{
823 struct cifsLockInfo *li, *tmp;
824 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
825 list_del_init(&li->blist);
826 wake_up(&li->block_q);
827 }
828}
829
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400830#define CIFS_LOCK_OP 0
831#define CIFS_READ_OP 1
832#define CIFS_WRITE_OP 2
833
834/* @rw_check : 0 - no op, 1 - read, 2 - write */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400835static bool
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700836cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
837 __u64 length, __u8 type, struct cifsFileInfo *cfile,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400838 struct cifsLockInfo **conf_lock, int rw_check)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400839{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300840 struct cifsLockInfo *li;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700841 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300842 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400843
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700844 list_for_each_entry(li, &fdlocks->locks, llist) {
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400845 if (offset + length <= li->offset ||
846 offset >= li->offset + li->length)
847 continue;
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400848 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
849 server->ops->compare_fids(cfile, cur_cfile)) {
850 /* shared lock prevents write op through the same fid */
851 if (!(li->type & server->vals->shared_lock_type) ||
852 rw_check != CIFS_WRITE_OP)
853 continue;
854 }
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700855 if ((type & server->vals->shared_lock_type) &&
856 ((server->ops->compare_fids(cfile, cur_cfile) &&
857 current->tgid == li->pid) || type == li->type))
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400858 continue;
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700859 if (conf_lock)
860 *conf_lock = li;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700861 return true;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400862 }
863 return false;
864}
865
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700866bool
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300867cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700868 __u8 type, struct cifsLockInfo **conf_lock,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400869 int rw_check)
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400870{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300871 bool rc = false;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700872 struct cifs_fid_locks *cur;
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300873 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300874
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700875 list_for_each_entry(cur, &cinode->llist, llist) {
876 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700877 cfile, conf_lock, rw_check);
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300878 if (rc)
879 break;
880 }
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300881
882 return rc;
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400883}
884
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300885/*
886 * Check if there is another lock that prevents us to set the lock (mandatory
887 * style). If such a lock exists, update the flock structure with its
888 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
889 * or leave it the same if we can't. Returns 0 if we don't need to request to
890 * the server or 1 otherwise.
891 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400892static int
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300893cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
894 __u8 type, struct file_lock *flock)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400895{
896 int rc = 0;
897 struct cifsLockInfo *conf_lock;
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300898 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300899 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400900 bool exist;
901
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700902 down_read(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400903
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300904 exist = cifs_find_lock_conflict(cfile, offset, length, type,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400905 &conf_lock, CIFS_LOCK_OP);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400906 if (exist) {
907 flock->fl_start = conf_lock->offset;
908 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
909 flock->fl_pid = conf_lock->pid;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300910 if (conf_lock->type & server->vals->shared_lock_type)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400911 flock->fl_type = F_RDLCK;
912 else
913 flock->fl_type = F_WRLCK;
914 } else if (!cinode->can_cache_brlcks)
915 rc = 1;
916 else
917 flock->fl_type = F_UNLCK;
918
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700919 up_read(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400920 return rc;
921}
922
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400923static void
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300924cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400925{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300926 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700927 down_write(&cinode->lock_sem);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700928 list_add_tail(&lock->llist, &cfile->llist->locks);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700929 up_write(&cinode->lock_sem);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000930}
931
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300932/*
933 * Set the byte-range lock (mandatory style). Returns:
934 * 1) 0, if we set the lock and don't need to request to the server;
935 * 2) 1, if no locks prevent us but we need to request to the server;
936 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
937 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400938static int
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300939cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400940 bool wait)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400941{
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400942 struct cifsLockInfo *conf_lock;
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300943 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400944 bool exist;
945 int rc = 0;
946
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400947try_again:
948 exist = false;
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700949 down_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400950
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300951 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400952 lock->type, &conf_lock, CIFS_LOCK_OP);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400953 if (!exist && cinode->can_cache_brlcks) {
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700954 list_add_tail(&lock->llist, &cfile->llist->locks);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700955 up_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400956 return rc;
957 }
958
959 if (!exist)
960 rc = 1;
961 else if (!wait)
962 rc = -EACCES;
963 else {
964 list_add_tail(&lock->blist, &conf_lock->blist);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700965 up_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400966 rc = wait_event_interruptible(lock->block_q,
967 (lock->blist.prev == &lock->blist) &&
968 (lock->blist.next == &lock->blist));
969 if (!rc)
970 goto try_again;
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700971 down_write(&cinode->lock_sem);
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400972 list_del_init(&lock->blist);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400973 }
974
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700975 up_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400976 return rc;
977}
978
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300979/*
980 * Check if there is another lock that prevents us to set the lock (posix
981 * style). If such a lock exists, update the flock structure with its
982 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
983 * or leave it the same if we can't. Returns 0 if we don't need to request to
984 * the server or 1 otherwise.
985 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400986static int
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400987cifs_posix_lock_test(struct file *file, struct file_lock *flock)
988{
989 int rc = 0;
Al Viro496ad9a2013-01-23 17:07:38 -0500990 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400991 unsigned char saved_type = flock->fl_type;
992
Pavel Shilovsky50792762011-10-29 17:17:57 +0400993 if ((flock->fl_flags & FL_POSIX) == 0)
994 return 1;
995
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700996 down_read(&cinode->lock_sem);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400997 posix_test_lock(file, flock);
998
999 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
1000 flock->fl_type = saved_type;
1001 rc = 1;
1002 }
1003
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001004 up_read(&cinode->lock_sem);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001005 return rc;
1006}
1007
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +03001008/*
1009 * Set the byte-range lock (posix style). Returns:
1010 * 1) 0, if we set the lock and don't need to request to the server;
1011 * 2) 1, if we need to request to the server;
1012 * 3) <0, if the error occurs while setting the lock.
1013 */
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001014static int
1015cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1016{
Al Viro496ad9a2013-01-23 17:07:38 -05001017 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
Pavel Shilovsky50792762011-10-29 17:17:57 +04001018 int rc = 1;
1019
1020 if ((flock->fl_flags & FL_POSIX) == 0)
1021 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001022
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001023try_again:
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001024 down_write(&cinode->lock_sem);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001025 if (!cinode->can_cache_brlcks) {
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001026 up_write(&cinode->lock_sem);
Pavel Shilovsky50792762011-10-29 17:17:57 +04001027 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001028 }
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001029
1030 rc = posix_lock_file(file, flock, NULL);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001031 up_write(&cinode->lock_sem);
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001032 if (rc == FILE_LOCK_DEFERRED) {
1033 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
1034 if (!rc)
1035 goto try_again;
Jeff Layton1a9e64a2013-06-21 08:58:10 -04001036 posix_unblock_lock(flock);
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001037 }
Steve French9ebb3892012-04-01 13:52:54 -05001038 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001039}
1040
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001041int
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001042cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001043{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001044 unsigned int xid;
1045 int rc = 0, stored_rc;
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001046 struct cifsLockInfo *li, *tmp;
1047 struct cifs_tcon *tcon;
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001048 unsigned int num, max_num, max_buf;
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001049 LOCKING_ANDX_RANGE *buf, *cur;
1050 int types[] = {LOCKING_ANDX_LARGE_FILES,
1051 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1052 int i;
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001053
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001054 xid = get_xid();
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001055 tcon = tlink_tcon(cfile->tlink);
1056
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001057 /*
1058 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1059 * and check it for zero before using.
1060 */
1061 max_buf = tcon->ses->server->maxBuf;
1062 if (!max_buf) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001063 free_xid(xid);
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001064 return -EINVAL;
1065 }
1066
1067 max_num = (max_buf - sizeof(struct smb_hdr)) /
1068 sizeof(LOCKING_ANDX_RANGE);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001069 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1070 if (!buf) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001071 free_xid(xid);
Pavel Shilovskye2f28862012-08-29 21:13:38 +04001072 return -ENOMEM;
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001073 }
1074
1075 for (i = 0; i < 2; i++) {
1076 cur = buf;
1077 num = 0;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001078 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001079 if (li->type != types[i])
1080 continue;
1081 cur->Pid = cpu_to_le16(li->pid);
1082 cur->LengthLow = cpu_to_le32((u32)li->length);
1083 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1084 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1085 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1086 if (++num == max_num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001087 stored_rc = cifs_lockv(xid, tcon,
1088 cfile->fid.netfid,
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001089 (__u8)li->type, 0, num,
1090 buf);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001091 if (stored_rc)
1092 rc = stored_rc;
1093 cur = buf;
1094 num = 0;
1095 } else
1096 cur++;
1097 }
1098
1099 if (num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001100 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001101 (__u8)types[i], 0, num, buf);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001102 if (stored_rc)
1103 rc = stored_rc;
1104 }
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001105 }
1106
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001107 kfree(buf);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001108 free_xid(xid);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001109 return rc;
1110}
1111
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001112/* copied from fs/locks.c with a name change */
1113#define cifs_for_each_lock(inode, lockp) \
1114 for (lockp = &inode->i_flock; *lockp != NULL; \
1115 lockp = &(*lockp)->fl_next)
1116
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001117struct lock_to_push {
1118 struct list_head llist;
1119 __u64 offset;
1120 __u64 length;
1121 __u32 pid;
1122 __u16 netfid;
1123 __u8 type;
1124};
1125
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001126static int
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001127cifs_push_posix_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001128{
Jeff Layton1c8c6012013-06-21 08:58:15 -04001129 struct inode *inode = cfile->dentry->d_inode;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001130 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1131 struct file_lock *flock, **before;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001132 unsigned int count = 0, i = 0;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001133 int rc = 0, xid, type;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001134 struct list_head locks_to_send, *el;
1135 struct lock_to_push *lck, *tmp;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001136 __u64 length;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001137
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001138 xid = get_xid();
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001139
Jeff Layton1c8c6012013-06-21 08:58:15 -04001140 spin_lock(&inode->i_lock);
1141 cifs_for_each_lock(inode, before) {
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001142 if ((*before)->fl_flags & FL_POSIX)
1143 count++;
1144 }
Jeff Layton1c8c6012013-06-21 08:58:15 -04001145 spin_unlock(&inode->i_lock);
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001146
1147 INIT_LIST_HEAD(&locks_to_send);
1148
1149 /*
Pavel Shilovskyce858522012-03-17 09:46:55 +03001150 * Allocating count locks is enough because no FL_POSIX locks can be
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001151 * added to the list while we are holding cinode->lock_sem that
Pavel Shilovskyce858522012-03-17 09:46:55 +03001152 * protects locking operations of this inode.
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001153 */
1154 for (; i < count; i++) {
1155 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1156 if (!lck) {
1157 rc = -ENOMEM;
1158 goto err_out;
1159 }
1160 list_add_tail(&lck->llist, &locks_to_send);
1161 }
1162
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001163 el = locks_to_send.next;
Jeff Layton1c8c6012013-06-21 08:58:15 -04001164 spin_lock(&inode->i_lock);
1165 cifs_for_each_lock(inode, before) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001166 flock = *before;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001167 if ((flock->fl_flags & FL_POSIX) == 0)
1168 continue;
Pavel Shilovskyce858522012-03-17 09:46:55 +03001169 if (el == &locks_to_send) {
1170 /*
1171 * The list ended. We don't have enough allocated
1172 * structures - something is really wrong.
1173 */
Joe Perchesf96637b2013-05-04 22:12:25 -05001174 cifs_dbg(VFS, "Can't push all brlocks!\n");
Pavel Shilovskyce858522012-03-17 09:46:55 +03001175 break;
1176 }
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001177 length = 1 + flock->fl_end - flock->fl_start;
1178 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1179 type = CIFS_RDLCK;
1180 else
1181 type = CIFS_WRLCK;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001182 lck = list_entry(el, struct lock_to_push, llist);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001183 lck->pid = flock->fl_pid;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001184 lck->netfid = cfile->fid.netfid;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001185 lck->length = length;
1186 lck->type = type;
1187 lck->offset = flock->fl_start;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001188 el = el->next;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001189 }
Jeff Layton1c8c6012013-06-21 08:58:15 -04001190 spin_unlock(&inode->i_lock);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001191
1192 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001193 int stored_rc;
1194
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001195 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
Jeff Laytonc5fd3632012-07-23 13:28:37 -04001196 lck->offset, lck->length, NULL,
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001197 lck->type, 0);
1198 if (stored_rc)
1199 rc = stored_rc;
1200 list_del(&lck->llist);
1201 kfree(lck);
1202 }
1203
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001204out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001205 free_xid(xid);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001206 return rc;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001207err_out:
1208 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1209 list_del(&lck->llist);
1210 kfree(lck);
1211 }
1212 goto out;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001213}
1214
1215static int
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001216cifs_push_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky9ec3c882012-11-22 17:00:10 +04001217{
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001218 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
Pavel Shilovsky9ec3c882012-11-22 17:00:10 +04001219 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001220 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky9ec3c882012-11-22 17:00:10 +04001221 int rc = 0;
1222
1223 /* we are going to update can_cache_brlcks here - need a write access */
1224 down_write(&cinode->lock_sem);
1225 if (!cinode->can_cache_brlcks) {
1226 up_write(&cinode->lock_sem);
1227 return rc;
1228 }
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001229
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001230 if (cap_unix(tcon->ses) &&
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001231 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1232 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001233 rc = cifs_push_posix_locks(cfile);
1234 else
1235 rc = tcon->ses->server->ops->push_mand_locks(cfile);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001236
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001237 cinode->can_cache_brlcks = false;
1238 up_write(&cinode->lock_sem);
1239 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001240}
1241
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001242static void
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001243cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001244 bool *wait_flag, struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245{
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001246 if (flock->fl_flags & FL_POSIX)
Joe Perchesf96637b2013-05-04 22:12:25 -05001247 cifs_dbg(FYI, "Posix\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001248 if (flock->fl_flags & FL_FLOCK)
Joe Perchesf96637b2013-05-04 22:12:25 -05001249 cifs_dbg(FYI, "Flock\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001250 if (flock->fl_flags & FL_SLEEP) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001251 cifs_dbg(FYI, "Blocking lock\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001252 *wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001253 }
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001254 if (flock->fl_flags & FL_ACCESS)
Joe Perchesf96637b2013-05-04 22:12:25 -05001255 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001256 if (flock->fl_flags & FL_LEASE)
Joe Perchesf96637b2013-05-04 22:12:25 -05001257 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001258 if (flock->fl_flags &
Jeff Layton3d6d8542012-09-19 06:22:46 -07001259 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1260 FL_ACCESS | FL_LEASE | FL_CLOSE)))
Joe Perchesf96637b2013-05-04 22:12:25 -05001261 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001263 *type = server->vals->large_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001264 if (flock->fl_type == F_WRLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001265 cifs_dbg(FYI, "F_WRLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001266 *type |= server->vals->exclusive_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001267 *lock = 1;
1268 } else if (flock->fl_type == F_UNLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001269 cifs_dbg(FYI, "F_UNLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001270 *type |= server->vals->unlock_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001271 *unlock = 1;
1272 /* Check if unlock includes more than one lock range */
1273 } else if (flock->fl_type == F_RDLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001274 cifs_dbg(FYI, "F_RDLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001275 *type |= server->vals->shared_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001276 *lock = 1;
1277 } else if (flock->fl_type == F_EXLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001278 cifs_dbg(FYI, "F_EXLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001279 *type |= server->vals->exclusive_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001280 *lock = 1;
1281 } else if (flock->fl_type == F_SHLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001282 cifs_dbg(FYI, "F_SHLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001283 *type |= server->vals->shared_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001284 *lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285 } else
Joe Perchesf96637b2013-05-04 22:12:25 -05001286 cifs_dbg(FYI, "Unknown type of lock\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001287}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001289static int
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001290cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001291 bool wait_flag, bool posix_lck, unsigned int xid)
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001292{
1293 int rc = 0;
1294 __u64 length = 1 + flock->fl_end - flock->fl_start;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001295 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1296 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001297 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001298 __u16 netfid = cfile->fid.netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001299
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001300 if (posix_lck) {
1301 int posix_lock_type;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001302
1303 rc = cifs_posix_lock_test(file, flock);
1304 if (!rc)
1305 return rc;
1306
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001307 if (type & server->vals->shared_lock_type)
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001308 posix_lock_type = CIFS_RDLCK;
1309 else
1310 posix_lock_type = CIFS_WRLCK;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001311 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
Jeff Laytonc5fd3632012-07-23 13:28:37 -04001312 flock->fl_start, length, flock,
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001313 posix_lock_type, wait_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 return rc;
1315 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001316
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001317 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001318 if (!rc)
1319 return rc;
1320
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001321 /* BB we could chain these into one lock request BB */
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001322 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1323 1, 0, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001324 if (rc == 0) {
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001325 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1326 type, 0, 1, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001327 flock->fl_type = F_UNLCK;
1328 if (rc != 0)
Joe Perchesf96637b2013-05-04 22:12:25 -05001329 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1330 rc);
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001331 return 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001332 }
1333
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001334 if (type & server->vals->shared_lock_type) {
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001335 flock->fl_type = F_WRLCK;
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001336 return 0;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001337 }
1338
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001339 type &= ~server->vals->exclusive_lock_type;
1340
1341 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1342 type | server->vals->shared_lock_type,
1343 1, 0, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001344 if (rc == 0) {
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001345 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1346 type | server->vals->shared_lock_type, 0, 1, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001347 flock->fl_type = F_RDLCK;
1348 if (rc != 0)
Joe Perchesf96637b2013-05-04 22:12:25 -05001349 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1350 rc);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001351 } else
1352 flock->fl_type = F_WRLCK;
1353
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001354 return 0;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001355}
1356
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -07001357void
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001358cifs_move_llist(struct list_head *source, struct list_head *dest)
1359{
1360 struct list_head *li, *tmp;
1361 list_for_each_safe(li, tmp, source)
1362 list_move(li, dest);
1363}
1364
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -07001365void
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001366cifs_free_llist(struct list_head *llist)
1367{
1368 struct cifsLockInfo *li, *tmp;
1369 list_for_each_entry_safe(li, tmp, llist, llist) {
1370 cifs_del_lock_waiters(li);
1371 list_del(&li->llist);
1372 kfree(li);
1373 }
1374}
1375
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001376int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001377cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1378 unsigned int xid)
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001379{
1380 int rc = 0, stored_rc;
1381 int types[] = {LOCKING_ANDX_LARGE_FILES,
1382 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1383 unsigned int i;
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001384 unsigned int max_num, num, max_buf;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001385 LOCKING_ANDX_RANGE *buf, *cur;
1386 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1387 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1388 struct cifsLockInfo *li, *tmp;
1389 __u64 length = 1 + flock->fl_end - flock->fl_start;
1390 struct list_head tmp_llist;
1391
1392 INIT_LIST_HEAD(&tmp_llist);
1393
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001394 /*
1395 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1396 * and check it for zero before using.
1397 */
1398 max_buf = tcon->ses->server->maxBuf;
1399 if (!max_buf)
1400 return -EINVAL;
1401
1402 max_num = (max_buf - sizeof(struct smb_hdr)) /
1403 sizeof(LOCKING_ANDX_RANGE);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001404 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1405 if (!buf)
1406 return -ENOMEM;
1407
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001408 down_write(&cinode->lock_sem);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001409 for (i = 0; i < 2; i++) {
1410 cur = buf;
1411 num = 0;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001412 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001413 if (flock->fl_start > li->offset ||
1414 (flock->fl_start + length) <
1415 (li->offset + li->length))
1416 continue;
1417 if (current->tgid != li->pid)
1418 continue;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001419 if (types[i] != li->type)
1420 continue;
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001421 if (cinode->can_cache_brlcks) {
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001422 /*
1423 * We can cache brlock requests - simply remove
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001424 * a lock from the file's list.
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001425 */
1426 list_del(&li->llist);
1427 cifs_del_lock_waiters(li);
1428 kfree(li);
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001429 continue;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001430 }
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001431 cur->Pid = cpu_to_le16(li->pid);
1432 cur->LengthLow = cpu_to_le32((u32)li->length);
1433 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1434 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1435 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1436 /*
1437 * We need to save a lock here to let us add it again to
1438 * the file's list if the unlock range request fails on
1439 * the server.
1440 */
1441 list_move(&li->llist, &tmp_llist);
1442 if (++num == max_num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001443 stored_rc = cifs_lockv(xid, tcon,
1444 cfile->fid.netfid,
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001445 li->type, num, 0, buf);
1446 if (stored_rc) {
1447 /*
1448 * We failed on the unlock range
1449 * request - add all locks from the tmp
1450 * list to the head of the file's list.
1451 */
1452 cifs_move_llist(&tmp_llist,
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001453 &cfile->llist->locks);
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001454 rc = stored_rc;
1455 } else
1456 /*
1457 * The unlock range request succeed -
1458 * free the tmp list.
1459 */
1460 cifs_free_llist(&tmp_llist);
1461 cur = buf;
1462 num = 0;
1463 } else
1464 cur++;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001465 }
1466 if (num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001467 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001468 types[i], num, 0, buf);
1469 if (stored_rc) {
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001470 cifs_move_llist(&tmp_llist,
1471 &cfile->llist->locks);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001472 rc = stored_rc;
1473 } else
1474 cifs_free_llist(&tmp_llist);
1475 }
1476 }
1477
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001478 up_write(&cinode->lock_sem);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001479 kfree(buf);
1480 return rc;
1481}
1482
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001483static int
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001484cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001485 bool wait_flag, bool posix_lck, int lock, int unlock,
1486 unsigned int xid)
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001487{
1488 int rc = 0;
1489 __u64 length = 1 + flock->fl_end - flock->fl_start;
1490 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1491 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001492 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04001493 struct inode *inode = cfile->dentry->d_inode;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001494
1495 if (posix_lck) {
Steve French08547b02006-02-28 22:39:25 +00001496 int posix_lock_type;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001497
1498 rc = cifs_posix_lock_set(file, flock);
1499 if (!rc || rc < 0)
1500 return rc;
1501
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001502 if (type & server->vals->shared_lock_type)
Steve French08547b02006-02-28 22:39:25 +00001503 posix_lock_type = CIFS_RDLCK;
1504 else
1505 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +00001506
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001507 if (unlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +00001508 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001509
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001510 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1511 current->tgid, flock->fl_start, length,
1512 NULL, posix_lock_type, wait_flag);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001513 goto out;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001514 }
1515
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001516 if (lock) {
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001517 struct cifsLockInfo *lock;
1518
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001519 lock = cifs_lock_init(flock->fl_start, length, type);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001520 if (!lock)
1521 return -ENOMEM;
1522
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001523 rc = cifs_lock_add_if(cfile, lock, wait_flag);
Pavel Shilovsky21cb2d92012-11-22 18:56:39 +04001524 if (rc < 0) {
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001525 kfree(lock);
Pavel Shilovsky21cb2d92012-11-22 18:56:39 +04001526 return rc;
1527 }
1528 if (!rc)
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001529 goto out;
1530
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04001531 /*
1532 * Windows 7 server can delay breaking lease from read to None
1533 * if we set a byte-range lock on a file - break it explicitly
1534 * before sending the lock to the server to be sure the next
1535 * read won't conflict with non-overlapted locks due to
1536 * pagereading.
1537 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001538 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1539 CIFS_CACHE_READ(CIFS_I(inode))) {
Jeff Layton4f73c7d2014-04-30 09:31:47 -04001540 cifs_zap_mapping(inode);
Joe Perchesf96637b2013-05-04 22:12:25 -05001541 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1542 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001543 CIFS_I(inode)->oplock = 0;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04001544 }
1545
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001546 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1547 type, 1, 0, wait_flag);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001548 if (rc) {
1549 kfree(lock);
Pavel Shilovsky21cb2d92012-11-22 18:56:39 +04001550 return rc;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001551 }
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001552
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001553 cifs_lock_add(cfile, lock);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001554 } else if (unlock)
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001555 rc = server->ops->mand_unlock_range(cfile, flock, xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001556
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001557out:
1558 if (flock->fl_flags & FL_POSIX)
Steve French9ebb3892012-04-01 13:52:54 -05001559 posix_lock_file_wait(file, flock);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001560 return rc;
1561}
1562
1563int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1564{
1565 int rc, xid;
1566 int lock = 0, unlock = 0;
1567 bool wait_flag = false;
1568 bool posix_lck = false;
1569 struct cifs_sb_info *cifs_sb;
1570 struct cifs_tcon *tcon;
1571 struct cifsInodeInfo *cinode;
1572 struct cifsFileInfo *cfile;
1573 __u16 netfid;
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001574 __u32 type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001575
1576 rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001577 xid = get_xid();
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001578
Joe Perchesf96637b2013-05-04 22:12:25 -05001579 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1580 cmd, flock->fl_flags, flock->fl_type,
1581 flock->fl_start, flock->fl_end);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001582
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001583 cfile = (struct cifsFileInfo *)file->private_data;
1584 tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001585
1586 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1587 tcon->ses->server);
1588
1589 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001590 netfid = cfile->fid.netfid;
Al Viro496ad9a2013-01-23 17:07:38 -05001591 cinode = CIFS_I(file_inode(file));
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001592
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001593 if (cap_unix(tcon->ses) &&
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001594 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1595 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1596 posix_lck = true;
1597 /*
1598 * BB add code here to normalize offset and length to account for
1599 * negative length which we can not accept over the wire.
1600 */
1601 if (IS_GETLK(cmd)) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001602 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001603 free_xid(xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001604 return rc;
1605 }
1606
1607 if (!lock && !unlock) {
1608 /*
1609 * if no lock or unlock then nothing to do since we do not
1610 * know what it is
1611 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001612 free_xid(xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001613 return -EOPNOTSUPP;
1614 }
1615
1616 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1617 xid);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001618 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001619 return rc;
1620}
1621
Jeff Layton597b0272012-03-23 14:40:56 -04001622/*
1623 * update the file size (if needed) after a write. Should be called with
1624 * the inode->i_lock held
1625 */
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05001626void
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001627cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1628 unsigned int bytes_written)
1629{
1630 loff_t end_of_write = offset + bytes_written;
1631
1632 if (end_of_write > cifsi->server_eof)
1633 cifsi->server_eof = end_of_write;
1634}
1635
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001636static ssize_t
1637cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1638 size_t write_size, loff_t *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639{
1640 int rc = 0;
1641 unsigned int bytes_written = 0;
1642 unsigned int total_written;
1643 struct cifs_sb_info *cifs_sb;
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001644 struct cifs_tcon *tcon;
1645 struct TCP_Server_Info *server;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001646 unsigned int xid;
Jeff Layton7da4b492010-10-15 15:34:00 -04001647 struct dentry *dentry = open_file->dentry;
1648 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001649 struct cifs_io_parms io_parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001650
Jeff Layton7da4b492010-10-15 15:34:00 -04001651 cifs_sb = CIFS_SB(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001652
Al Viro35c265e2014-08-19 20:25:34 -04001653 cifs_dbg(FYI, "write %zd bytes to offset %lld of %pd\n",
1654 write_size, *offset, dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001656 tcon = tlink_tcon(open_file->tlink);
1657 server = tcon->ses->server;
1658
1659 if (!server->ops->sync_write)
1660 return -ENOSYS;
Steve French50c2f752007-07-13 00:33:32 +00001661
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001662 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 for (total_written = 0; write_size > total_written;
1665 total_written += bytes_written) {
1666 rc = -EAGAIN;
1667 while (rc == -EAGAIN) {
Jeff Laytonca83ce32011-04-12 09:13:44 -04001668 struct kvec iov[2];
1669 unsigned int len;
1670
Linus Torvalds1da177e2005-04-16 15:20:36 -07001671 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001672 /* we could deadlock if we called
1673 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001674 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 server now */
Jeff Layton15886172010-10-15 15:33:59 -04001676 rc = cifs_reopen_file(open_file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001677 if (rc != 0)
1678 break;
1679 }
Steve French3e844692005-10-03 13:37:24 -07001680
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04001681 len = min(server->ops->wp_retry_size(dentry->d_inode),
1682 (unsigned int)write_size - total_written);
Jeff Laytonca83ce32011-04-12 09:13:44 -04001683 /* iov[0] is reserved for smb header */
1684 iov[1].iov_base = (char *)write_data + total_written;
1685 iov[1].iov_len = len;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001686 io_parms.pid = pid;
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001687 io_parms.tcon = tcon;
1688 io_parms.offset = *offset;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001689 io_parms.length = len;
Steve Frenchdb8b6312014-09-22 05:13:55 -05001690 rc = server->ops->sync_write(xid, &open_file->fid,
1691 &io_parms, &bytes_written, iov, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 }
1693 if (rc || (bytes_written == 0)) {
1694 if (total_written)
1695 break;
1696 else {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001697 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 return rc;
1699 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001700 } else {
Jeff Layton597b0272012-03-23 14:40:56 -04001701 spin_lock(&dentry->d_inode->i_lock);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001702 cifs_update_eof(cifsi, *offset, bytes_written);
Jeff Layton597b0272012-03-23 14:40:56 -04001703 spin_unlock(&dentry->d_inode->i_lock);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001704 *offset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001705 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001706 }
1707
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001708 cifs_stats_bytes_written(tcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709
Jeff Layton7da4b492010-10-15 15:34:00 -04001710 if (total_written > 0) {
1711 spin_lock(&dentry->d_inode->i_lock);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001712 if (*offset > dentry->d_inode->i_size)
1713 i_size_write(dentry->d_inode, *offset);
Jeff Layton7da4b492010-10-15 15:34:00 -04001714 spin_unlock(&dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 }
Jeff Layton7da4b492010-10-15 15:34:00 -04001716 mark_inode_dirty_sync(dentry->d_inode);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001717 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 return total_written;
1719}
1720
Jeff Layton6508d902010-09-29 19:51:11 -04001721struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1722 bool fsuid_only)
Steve French630f3f0c2007-10-25 21:17:17 +00001723{
1724 struct cifsFileInfo *open_file = NULL;
Jeff Layton6508d902010-09-29 19:51:11 -04001725 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1726
1727 /* only filter by fsuid on multiuser mounts */
1728 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1729 fsuid_only = false;
Steve French630f3f0c2007-10-25 21:17:17 +00001730
Jeff Layton44772882010-10-15 15:34:03 -04001731 spin_lock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001732 /* we could simply get the first_list_entry since write-only entries
1733 are always at the end of the list but since the first entry might
1734 have a close pending, we go through the whole list */
1735 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Eric W. Biedermanfef59fd2013-02-06 02:23:02 -08001736 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
Jeff Layton6508d902010-09-29 19:51:11 -04001737 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001738 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
Steve French630f3f0c2007-10-25 21:17:17 +00001739 if (!open_file->invalidHandle) {
1740 /* found a good file */
1741 /* lock it so it will not be closed on us */
Jeff Layton764a1b12012-07-25 14:59:54 -04001742 cifsFileInfo_get_locked(open_file);
Jeff Layton44772882010-10-15 15:34:03 -04001743 spin_unlock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001744 return open_file;
1745 } /* else might as well continue, and look for
1746 another, or simply have the caller reopen it
1747 again rather than trying to fix this handle */
1748 } else /* write only file */
1749 break; /* write only files are last so must be done */
1750 }
Jeff Layton44772882010-10-15 15:34:03 -04001751 spin_unlock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001752 return NULL;
1753}
Steve French630f3f0c2007-10-25 21:17:17 +00001754
Jeff Layton6508d902010-09-29 19:51:11 -04001755struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1756 bool fsuid_only)
Steve French6148a742005-10-05 12:23:19 -07001757{
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001758 struct cifsFileInfo *open_file, *inv_file = NULL;
Jeff Laytond3892292010-11-02 16:22:50 -04001759 struct cifs_sb_info *cifs_sb;
Jeff Layton2846d382008-09-22 21:33:33 -04001760 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001761 int rc;
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001762 unsigned int refind = 0;
Steve French6148a742005-10-05 12:23:19 -07001763
Steve French60808232006-04-22 15:53:05 +00001764 /* Having a null inode here (because mapping->host was set to zero by
1765 the VFS or MM) should not happen but we had reports of on oops (due to
1766 it being zero) during stress testcases so we need to check for it */
1767
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001768 if (cifs_inode == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001769 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
Steve French60808232006-04-22 15:53:05 +00001770 dump_stack();
1771 return NULL;
1772 }
1773
Jeff Laytond3892292010-11-02 16:22:50 -04001774 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1775
Jeff Layton6508d902010-09-29 19:51:11 -04001776 /* only filter by fsuid on multiuser mounts */
1777 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1778 fsuid_only = false;
1779
Jeff Layton44772882010-10-15 15:34:03 -04001780 spin_lock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001781refind_writable:
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001782 if (refind > MAX_REOPEN_ATT) {
1783 spin_unlock(&cifs_file_list_lock);
1784 return NULL;
1785 }
Steve French6148a742005-10-05 12:23:19 -07001786 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton6508d902010-09-29 19:51:11 -04001787 if (!any_available && open_file->pid != current->tgid)
1788 continue;
Eric W. Biedermanfef59fd2013-02-06 02:23:02 -08001789 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
Jeff Layton6508d902010-09-29 19:51:11 -04001790 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001791 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Steve French9b22b0b2007-10-02 01:11:08 +00001792 if (!open_file->invalidHandle) {
1793 /* found a good writable file */
Jeff Layton764a1b12012-07-25 14:59:54 -04001794 cifsFileInfo_get_locked(open_file);
Jeff Layton44772882010-10-15 15:34:03 -04001795 spin_unlock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001796 return open_file;
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001797 } else {
1798 if (!inv_file)
1799 inv_file = open_file;
Steve French9b22b0b2007-10-02 01:11:08 +00001800 }
Steve French6148a742005-10-05 12:23:19 -07001801 }
1802 }
Jeff Layton2846d382008-09-22 21:33:33 -04001803 /* couldn't find useable FH with same pid, try any available */
1804 if (!any_available) {
1805 any_available = true;
1806 goto refind_writable;
1807 }
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001808
1809 if (inv_file) {
1810 any_available = false;
Jeff Layton764a1b12012-07-25 14:59:54 -04001811 cifsFileInfo_get_locked(inv_file);
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001812 }
1813
Jeff Layton44772882010-10-15 15:34:03 -04001814 spin_unlock(&cifs_file_list_lock);
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001815
1816 if (inv_file) {
1817 rc = cifs_reopen_file(inv_file, false);
1818 if (!rc)
1819 return inv_file;
1820 else {
1821 spin_lock(&cifs_file_list_lock);
1822 list_move_tail(&inv_file->flist,
1823 &cifs_inode->openFileList);
1824 spin_unlock(&cifs_file_list_lock);
1825 cifsFileInfo_put(inv_file);
1826 spin_lock(&cifs_file_list_lock);
1827 ++refind;
1828 goto refind_writable;
1829 }
1830 }
1831
Steve French6148a742005-10-05 12:23:19 -07001832 return NULL;
1833}
1834
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1836{
1837 struct address_space *mapping = page->mapping;
1838 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1839 char *write_data;
1840 int rc = -EFAULT;
1841 int bytes_written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001842 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001843 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844
1845 if (!mapping || !mapping->host)
1846 return -EFAULT;
1847
1848 inode = page->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001849
1850 offset += (loff_t)from;
1851 write_data = kmap(page);
1852 write_data += from;
1853
1854 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1855 kunmap(page);
1856 return -EIO;
1857 }
1858
1859 /* racing with truncate? */
1860 if (offset > mapping->host->i_size) {
1861 kunmap(page);
1862 return 0; /* don't care */
1863 }
1864
1865 /* check to make sure that we are not extending the file */
1866 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001867 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001868
Jeff Layton6508d902010-09-29 19:51:11 -04001869 open_file = find_writable_file(CIFS_I(mapping->host), false);
Steve French6148a742005-10-05 12:23:19 -07001870 if (open_file) {
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001871 bytes_written = cifs_write(open_file, open_file->pid,
1872 write_data, to - from, &offset);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001873 cifsFileInfo_put(open_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001875 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001876 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001877 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001878 else if (bytes_written < 0)
1879 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001880 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05001881 cifs_dbg(FYI, "No writeable filehandles for inode\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001882 rc = -EIO;
1883 }
1884
1885 kunmap(page);
1886 return rc;
1887}
1888
Pavel Shilovsky90ac1382014-06-19 16:11:00 +04001889static struct cifs_writedata *
1890wdata_alloc_and_fillpages(pgoff_t tofind, struct address_space *mapping,
1891 pgoff_t end, pgoff_t *index,
1892 unsigned int *found_pages)
1893{
1894 unsigned int nr_pages;
1895 struct page **pages;
1896 struct cifs_writedata *wdata;
1897
1898 wdata = cifs_writedata_alloc((unsigned int)tofind,
1899 cifs_writev_complete);
1900 if (!wdata)
1901 return NULL;
1902
1903 /*
1904 * find_get_pages_tag seems to return a max of 256 on each
1905 * iteration, so we must call it several times in order to
1906 * fill the array or the wsize is effectively limited to
1907 * 256 * PAGE_CACHE_SIZE.
1908 */
1909 *found_pages = 0;
1910 pages = wdata->pages;
1911 do {
1912 nr_pages = find_get_pages_tag(mapping, index,
1913 PAGECACHE_TAG_DIRTY, tofind,
1914 pages);
1915 *found_pages += nr_pages;
1916 tofind -= nr_pages;
1917 pages += nr_pages;
1918 } while (nr_pages && tofind && *index <= end);
1919
1920 return wdata;
1921}
1922
Pavel Shilovsky7e48ff82014-06-19 15:01:03 +04001923static unsigned int
1924wdata_prepare_pages(struct cifs_writedata *wdata, unsigned int found_pages,
1925 struct address_space *mapping,
1926 struct writeback_control *wbc,
1927 pgoff_t end, pgoff_t *index, pgoff_t *next, bool *done)
1928{
1929 unsigned int nr_pages = 0, i;
1930 struct page *page;
1931
1932 for (i = 0; i < found_pages; i++) {
1933 page = wdata->pages[i];
1934 /*
1935 * At this point we hold neither mapping->tree_lock nor
1936 * lock on the page itself: the page may be truncated or
1937 * invalidated (changing page->mapping to NULL), or even
1938 * swizzled back from swapper_space to tmpfs file
1939 * mapping
1940 */
1941
1942 if (nr_pages == 0)
1943 lock_page(page);
1944 else if (!trylock_page(page))
1945 break;
1946
1947 if (unlikely(page->mapping != mapping)) {
1948 unlock_page(page);
1949 break;
1950 }
1951
1952 if (!wbc->range_cyclic && page->index > end) {
1953 *done = true;
1954 unlock_page(page);
1955 break;
1956 }
1957
1958 if (*next && (page->index != *next)) {
1959 /* Not next consecutive page */
1960 unlock_page(page);
1961 break;
1962 }
1963
1964 if (wbc->sync_mode != WB_SYNC_NONE)
1965 wait_on_page_writeback(page);
1966
1967 if (PageWriteback(page) ||
1968 !clear_page_dirty_for_io(page)) {
1969 unlock_page(page);
1970 break;
1971 }
1972
1973 /*
1974 * This actually clears the dirty bit in the radix tree.
1975 * See cifs_writepage() for more commentary.
1976 */
1977 set_page_writeback(page);
1978 if (page_offset(page) >= i_size_read(mapping->host)) {
1979 *done = true;
1980 unlock_page(page);
1981 end_page_writeback(page);
1982 break;
1983 }
1984
1985 wdata->pages[i] = page;
1986 *next = page->index + 1;
1987 ++nr_pages;
1988 }
1989
1990 /* reset index to refind any pages skipped */
1991 if (nr_pages == 0)
1992 *index = wdata->pages[0]->index + 1;
1993
1994 /* put any pages we aren't going to use */
1995 for (i = nr_pages; i < found_pages; i++) {
1996 page_cache_release(wdata->pages[i]);
1997 wdata->pages[i] = NULL;
1998 }
1999
2000 return nr_pages;
2001}
2002
Pavel Shilovsky619aa482014-06-19 15:28:37 +04002003static int
2004wdata_send_pages(struct cifs_writedata *wdata, unsigned int nr_pages,
2005 struct address_space *mapping, struct writeback_control *wbc)
2006{
2007 int rc = 0;
2008 struct TCP_Server_Info *server;
2009 unsigned int i;
2010
2011 wdata->sync_mode = wbc->sync_mode;
2012 wdata->nr_pages = nr_pages;
2013 wdata->offset = page_offset(wdata->pages[0]);
2014 wdata->pagesz = PAGE_CACHE_SIZE;
2015 wdata->tailsz = min(i_size_read(mapping->host) -
2016 page_offset(wdata->pages[nr_pages - 1]),
2017 (loff_t)PAGE_CACHE_SIZE);
2018 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) + wdata->tailsz;
2019
Pavel Shilovsky66231a42014-06-19 16:15:16 +04002020 if (wdata->cfile != NULL)
2021 cifsFileInfo_put(wdata->cfile);
2022 wdata->cfile = find_writable_file(CIFS_I(mapping->host), false);
2023 if (!wdata->cfile) {
2024 cifs_dbg(VFS, "No writable handles for inode\n");
2025 rc = -EBADF;
2026 } else {
Pavel Shilovsky619aa482014-06-19 15:28:37 +04002027 wdata->pid = wdata->cfile->pid;
2028 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
2029 rc = server->ops->async_writev(wdata, cifs_writedata_release);
Pavel Shilovsky66231a42014-06-19 16:15:16 +04002030 }
Pavel Shilovsky619aa482014-06-19 15:28:37 +04002031
2032 for (i = 0; i < nr_pages; ++i)
2033 unlock_page(wdata->pages[i]);
2034
2035 return rc;
2036}
2037
Linus Torvalds1da177e2005-04-16 15:20:36 -07002038static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07002039 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002040{
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002041 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002042 struct TCP_Server_Info *server;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002043 bool done = false, scanned = false, range_whole = false;
2044 pgoff_t end, index;
2045 struct cifs_writedata *wdata;
Steve French37c0eb42005-10-05 14:50:29 -07002046 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00002047
Steve French37c0eb42005-10-05 14:50:29 -07002048 /*
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002049 * If wsize is smaller than the page cache size, default to writing
Steve French37c0eb42005-10-05 14:50:29 -07002050 * one page at a time via cifs_writepage
2051 */
2052 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
2053 return generic_writepages(mapping, wbc);
2054
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07002055 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07002056 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07002057 end = -1;
2058 } else {
2059 index = wbc->range_start >> PAGE_CACHE_SHIFT;
2060 end = wbc->range_end >> PAGE_CACHE_SHIFT;
2061 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002062 range_whole = true;
2063 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07002064 }
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002065 server = cifs_sb_master_tcon(cifs_sb)->ses->server;
Steve French37c0eb42005-10-05 14:50:29 -07002066retry:
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002067 while (!done && index <= end) {
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002068 unsigned int i, nr_pages, found_pages, wsize, credits;
Pavel Shilovsky66231a42014-06-19 16:15:16 +04002069 pgoff_t next = 0, tofind, saved_index = index;
Steve French37c0eb42005-10-05 14:50:29 -07002070
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002071 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2072 &wsize, &credits);
2073 if (rc)
2074 break;
Steve French37c0eb42005-10-05 14:50:29 -07002075
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002076 tofind = min((wsize / PAGE_CACHE_SIZE) - 1, end - index) + 1;
Steve French37c0eb42005-10-05 14:50:29 -07002077
Pavel Shilovsky90ac1382014-06-19 16:11:00 +04002078 wdata = wdata_alloc_and_fillpages(tofind, mapping, end, &index,
2079 &found_pages);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002080 if (!wdata) {
2081 rc = -ENOMEM;
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002082 add_credits_and_wake_if(server, credits, 0);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002083 break;
2084 }
2085
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002086 if (found_pages == 0) {
2087 kref_put(&wdata->refcount, cifs_writedata_release);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002088 add_credits_and_wake_if(server, credits, 0);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002089 break;
2090 }
2091
Pavel Shilovsky7e48ff82014-06-19 15:01:03 +04002092 nr_pages = wdata_prepare_pages(wdata, found_pages, mapping, wbc,
2093 end, &index, &next, &done);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002094
2095 /* nothing to write? */
2096 if (nr_pages == 0) {
2097 kref_put(&wdata->refcount, cifs_writedata_release);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002098 add_credits_and_wake_if(server, credits, 0);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002099 continue;
2100 }
2101
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002102 wdata->credits = credits;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002103
Pavel Shilovsky619aa482014-06-19 15:28:37 +04002104 rc = wdata_send_pages(wdata, nr_pages, mapping, wbc);
Jeff Layton941b8532011-01-11 07:24:01 -05002105
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002106 /* send failure -- clean up the mess */
2107 if (rc != 0) {
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002108 add_credits_and_wake_if(server, wdata->credits, 0);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002109 for (i = 0; i < nr_pages; ++i) {
Jeff Layton941b8532011-01-11 07:24:01 -05002110 if (rc == -EAGAIN)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002111 redirty_page_for_writepage(wbc,
2112 wdata->pages[i]);
2113 else
2114 SetPageError(wdata->pages[i]);
2115 end_page_writeback(wdata->pages[i]);
2116 page_cache_release(wdata->pages[i]);
Steve French37c0eb42005-10-05 14:50:29 -07002117 }
Jeff Layton941b8532011-01-11 07:24:01 -05002118 if (rc != -EAGAIN)
2119 mapping_set_error(mapping, rc);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002120 }
2121 kref_put(&wdata->refcount, cifs_writedata_release);
Jeff Layton941b8532011-01-11 07:24:01 -05002122
Pavel Shilovsky66231a42014-06-19 16:15:16 +04002123 if (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN) {
2124 index = saved_index;
2125 continue;
2126 }
2127
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002128 wbc->nr_to_write -= nr_pages;
2129 if (wbc->nr_to_write <= 0)
2130 done = true;
Dave Kleikampb066a482008-11-18 03:49:05 +00002131
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002132 index = next;
Steve French37c0eb42005-10-05 14:50:29 -07002133 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002134
Steve French37c0eb42005-10-05 14:50:29 -07002135 if (!scanned && !done) {
2136 /*
2137 * We hit the last page and there is more work to be done: wrap
2138 * back to the start of the file
2139 */
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002140 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07002141 index = 0;
2142 goto retry;
2143 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002144
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07002145 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07002146 mapping->writeback_index = index;
2147
Linus Torvalds1da177e2005-04-16 15:20:36 -07002148 return rc;
2149}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002150
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002151static int
2152cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002153{
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002154 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002155 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002157 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002158/* BB add check for wbc flags */
2159 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00002160 if (!PageUptodate(page))
Joe Perchesf96637b2013-05-04 22:12:25 -05002161 cifs_dbg(FYI, "ppw - page not up to date\n");
Linus Torvaldscb876f42006-12-23 16:19:07 -08002162
2163 /*
2164 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2165 *
2166 * A writepage() implementation always needs to do either this,
2167 * or re-dirty the page with "redirty_page_for_writepage()" in
2168 * the case of a failure.
2169 *
2170 * Just unlocking the page will cause the radix tree tag-bits
2171 * to fail to update with the state of the page correctly.
2172 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002173 set_page_writeback(page);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002174retry_write:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002175 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002176 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2177 goto retry_write;
2178 else if (rc == -EAGAIN)
2179 redirty_page_for_writepage(wbc, page);
2180 else if (rc != 0)
2181 SetPageError(page);
2182 else
2183 SetPageUptodate(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08002184 end_page_writeback(page);
2185 page_cache_release(page);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002186 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002187 return rc;
2188}
2189
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002190static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2191{
2192 int rc = cifs_writepage_locked(page, wbc);
2193 unlock_page(page);
2194 return rc;
2195}
2196
Nick Piggind9414772008-09-24 11:32:59 -04002197static int cifs_write_end(struct file *file, struct address_space *mapping,
2198 loff_t pos, unsigned len, unsigned copied,
2199 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200{
Nick Piggind9414772008-09-24 11:32:59 -04002201 int rc;
2202 struct inode *inode = mapping->host;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002203 struct cifsFileInfo *cfile = file->private_data;
2204 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2205 __u32 pid;
2206
2207 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2208 pid = cfile->pid;
2209 else
2210 pid = current->tgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211
Joe Perchesf96637b2013-05-04 22:12:25 -05002212 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002213 page, pos, copied);
Steve Frenchad7a2922008-02-07 23:25:02 +00002214
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002215 if (PageChecked(page)) {
2216 if (copied == len)
2217 SetPageUptodate(page);
2218 ClearPageChecked(page);
2219 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04002220 SetPageUptodate(page);
2221
Linus Torvalds1da177e2005-04-16 15:20:36 -07002222 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04002223 char *page_data;
2224 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002225 unsigned int xid;
Nick Piggind9414772008-09-24 11:32:59 -04002226
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002227 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228 /* this is probably better than directly calling
2229 partialpage_write since in this function the file handle is
2230 known which we might as well leverage */
2231 /* BB check if anything else missing out of ppw
2232 such as updating last write time */
2233 page_data = kmap(page);
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002234 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
Nick Piggind9414772008-09-24 11:32:59 -04002235 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04002237
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002238 free_xid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002239 } else {
Nick Piggind9414772008-09-24 11:32:59 -04002240 rc = copied;
2241 pos += copied;
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002242 set_page_dirty(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002243 }
2244
Nick Piggind9414772008-09-24 11:32:59 -04002245 if (rc > 0) {
2246 spin_lock(&inode->i_lock);
2247 if (pos > inode->i_size)
2248 i_size_write(inode, pos);
2249 spin_unlock(&inode->i_lock);
2250 }
2251
2252 unlock_page(page);
2253 page_cache_release(page);
2254
Linus Torvalds1da177e2005-04-16 15:20:36 -07002255 return rc;
2256}
2257
Josef Bacik02c24a82011-07-16 20:44:56 -04002258int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2259 int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002261 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00002263 struct cifs_tcon *tcon;
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002264 struct TCP_Server_Info *server;
Joe Perchesc21dfb62010-07-12 13:50:14 -07002265 struct cifsFileInfo *smbfile = file->private_data;
Al Viro496ad9a2013-01-23 17:07:38 -05002266 struct inode *inode = file_inode(file);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002267 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002268
Josef Bacik02c24a82011-07-16 20:44:56 -04002269 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2270 if (rc)
2271 return rc;
2272 mutex_lock(&inode->i_mutex);
2273
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002274 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275
Al Viro35c265e2014-08-19 20:25:34 -04002276 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2277 file, datasync);
Steve French50c2f752007-07-13 00:33:32 +00002278
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002279 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002280 rc = cifs_zap_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002281 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002282 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002283 rc = 0; /* don't care about it in fsync */
2284 }
2285 }
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002286
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002287 tcon = tlink_tcon(smbfile->tlink);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002288 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2289 server = tcon->ses->server;
2290 if (server->ops->flush)
2291 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2292 else
2293 rc = -ENOSYS;
2294 }
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002295
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002296 free_xid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04002297 mutex_unlock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002298 return rc;
2299}
2300
Josef Bacik02c24a82011-07-16 20:44:56 -04002301int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002302{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002303 unsigned int xid;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002304 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00002305 struct cifs_tcon *tcon;
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002306 struct TCP_Server_Info *server;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002307 struct cifsFileInfo *smbfile = file->private_data;
2308 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Josef Bacik02c24a82011-07-16 20:44:56 -04002309 struct inode *inode = file->f_mapping->host;
2310
2311 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2312 if (rc)
2313 return rc;
2314 mutex_lock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002315
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002316 xid = get_xid();
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002317
Al Viro35c265e2014-08-19 20:25:34 -04002318 cifs_dbg(FYI, "Sync file - name: %pD datasync: 0x%x\n",
2319 file, datasync);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002320
2321 tcon = tlink_tcon(smbfile->tlink);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002322 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2323 server = tcon->ses->server;
2324 if (server->ops->flush)
2325 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2326 else
2327 rc = -ENOSYS;
2328 }
Steve Frenchb298f222009-02-21 21:17:43 +00002329
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002330 free_xid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04002331 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002332 return rc;
2333}
2334
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335/*
2336 * As file closes, flush all cached write data for this inode checking
2337 * for write behind errors.
2338 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07002339int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340{
Al Viro496ad9a2013-01-23 17:07:38 -05002341 struct inode *inode = file_inode(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002342 int rc = 0;
2343
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002344 if (file->f_mode & FMODE_WRITE)
Jeff Laytond3f13222010-10-15 15:34:07 -04002345 rc = filemap_write_and_wait(inode->i_mapping);
Steve French50c2f752007-07-13 00:33:32 +00002346
Joe Perchesf96637b2013-05-04 22:12:25 -05002347 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002348
2349 return rc;
2350}
2351
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002352static int
2353cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2354{
2355 int rc = 0;
2356 unsigned long i;
2357
2358 for (i = 0; i < num_pages; i++) {
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002359 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002360 if (!pages[i]) {
2361 /*
2362 * save number of pages we have already allocated and
2363 * return with ENOMEM error
2364 */
2365 num_pages = i;
2366 rc = -ENOMEM;
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002367 break;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002368 }
2369 }
2370
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002371 if (rc) {
2372 for (i = 0; i < num_pages; i++)
2373 put_page(pages[i]);
2374 }
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002375 return rc;
2376}
2377
2378static inline
2379size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2380{
2381 size_t num_pages;
2382 size_t clen;
2383
2384 clen = min_t(const size_t, len, wsize);
Jeff Laytona7103b92012-03-23 14:40:56 -04002385 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002386
2387 if (cur_len)
2388 *cur_len = clen;
2389
2390 return num_pages;
2391}
2392
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002393static void
Steve French4a5c80d2014-02-07 20:45:12 -06002394cifs_uncached_writedata_release(struct kref *refcount)
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002395{
2396 int i;
Steve French4a5c80d2014-02-07 20:45:12 -06002397 struct cifs_writedata *wdata = container_of(refcount,
2398 struct cifs_writedata, refcount);
2399
2400 for (i = 0; i < wdata->nr_pages; i++)
2401 put_page(wdata->pages[i]);
2402 cifs_writedata_release(refcount);
2403}
2404
2405static void
2406cifs_uncached_writev_complete(struct work_struct *work)
2407{
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002408 struct cifs_writedata *wdata = container_of(work,
2409 struct cifs_writedata, work);
2410 struct inode *inode = wdata->cfile->dentry->d_inode;
2411 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2412
2413 spin_lock(&inode->i_lock);
2414 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2415 if (cifsi->server_eof > inode->i_size)
2416 i_size_write(inode, cifsi->server_eof);
2417 spin_unlock(&inode->i_lock);
2418
2419 complete(&wdata->done);
2420
Steve French4a5c80d2014-02-07 20:45:12 -06002421 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002422}
2423
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002424static int
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002425wdata_fill_from_iovec(struct cifs_writedata *wdata, struct iov_iter *from,
2426 size_t *len, unsigned long *num_pages)
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002427{
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002428 size_t save_len, copied, bytes, cur_len = *len;
2429 unsigned long i, nr_pages = *num_pages;
2430
2431 save_len = cur_len;
2432 for (i = 0; i < nr_pages; i++) {
2433 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
2434 copied = copy_page_from_iter(wdata->pages[i], 0, bytes, from);
2435 cur_len -= copied;
2436 /*
2437 * If we didn't copy as much as we expected, then that
2438 * may mean we trod into an unmapped area. Stop copying
2439 * at that point. On the next pass through the big
2440 * loop, we'll likely end up getting a zero-length
2441 * write and bailing out of it.
2442 */
2443 if (copied < bytes)
2444 break;
2445 }
2446 cur_len = save_len - cur_len;
2447 *len = cur_len;
2448
2449 /*
2450 * If we have no data to send, then that probably means that
2451 * the copy above failed altogether. That's most likely because
2452 * the address in the iovec was bogus. Return -EFAULT and let
2453 * the caller free anything we allocated and bail out.
2454 */
2455 if (!cur_len)
2456 return -EFAULT;
2457
2458 /*
2459 * i + 1 now represents the number of pages we actually used in
2460 * the copy phase above.
2461 */
2462 *num_pages = i + 1;
2463 return 0;
2464}
2465
Pavel Shilovsky43de94e2014-06-20 16:10:52 +04002466static int
2467cifs_write_from_iter(loff_t offset, size_t len, struct iov_iter *from,
2468 struct cifsFileInfo *open_file,
2469 struct cifs_sb_info *cifs_sb, struct list_head *wdata_list)
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002470{
Pavel Shilovsky43de94e2014-06-20 16:10:52 +04002471 int rc = 0;
2472 size_t cur_len;
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002473 unsigned long nr_pages, num_pages, i;
Pavel Shilovsky43de94e2014-06-20 16:10:52 +04002474 struct cifs_writedata *wdata;
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002475 struct iov_iter saved_from;
2476 loff_t saved_offset = offset;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002477 pid_t pid;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002478 struct TCP_Server_Info *server;
2479
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002480 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2481 pid = open_file->pid;
2482 else
2483 pid = current->tgid;
2484
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002485 server = tlink_tcon(open_file->tlink)->ses->server;
2486 memcpy(&saved_from, from, sizeof(struct iov_iter));
Pavel Shilovsky76429c12011-01-31 16:03:08 +03002487
2488 do {
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002489 unsigned int wsize, credits;
2490
2491 rc = server->ops->wait_mtu_credits(server, cifs_sb->wsize,
2492 &wsize, &credits);
2493 if (rc)
2494 break;
2495
2496 nr_pages = get_numpages(wsize, len, &cur_len);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002497 wdata = cifs_writedata_alloc(nr_pages,
2498 cifs_uncached_writev_complete);
2499 if (!wdata) {
2500 rc = -ENOMEM;
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002501 add_credits_and_wake_if(server, credits, 0);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002502 break;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002503 }
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002504
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002505 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2506 if (rc) {
2507 kfree(wdata);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002508 add_credits_and_wake_if(server, credits, 0);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002509 break;
2510 }
2511
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002512 num_pages = nr_pages;
2513 rc = wdata_fill_from_iovec(wdata, from, &cur_len, &num_pages);
2514 if (rc) {
Jeff Layton5d81de82014-02-14 07:20:35 -05002515 for (i = 0; i < nr_pages; i++)
2516 put_page(wdata->pages[i]);
2517 kfree(wdata);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002518 add_credits_and_wake_if(server, credits, 0);
Jeff Layton5d81de82014-02-14 07:20:35 -05002519 break;
2520 }
2521
2522 /*
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002523 * Bring nr_pages down to the number of pages we actually used,
2524 * and free any pages that we didn't use.
Jeff Layton5d81de82014-02-14 07:20:35 -05002525 */
Pavel Shilovsky66386c02014-06-20 15:48:40 +04002526 for ( ; nr_pages > num_pages; nr_pages--)
Jeff Layton5d81de82014-02-14 07:20:35 -05002527 put_page(wdata->pages[nr_pages - 1]);
2528
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002529 wdata->sync_mode = WB_SYNC_ALL;
2530 wdata->nr_pages = nr_pages;
2531 wdata->offset = (__u64)offset;
2532 wdata->cfile = cifsFileInfo_get(open_file);
2533 wdata->pid = pid;
2534 wdata->bytes = cur_len;
Jeff Laytoneddb0792012-09-18 16:20:35 -07002535 wdata->pagesz = PAGE_SIZE;
2536 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002537 wdata->credits = credits;
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002538
2539 if (!wdata->cfile->invalidHandle ||
2540 !cifs_reopen_file(wdata->cfile, false))
2541 rc = server->ops->async_writev(wdata,
2542 cifs_uncached_writedata_release);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002543 if (rc) {
Pavel Shilovskycb7e9ea2014-06-05 19:03:27 +04002544 add_credits_and_wake_if(server, wdata->credits, 0);
Steve French4a5c80d2014-02-07 20:45:12 -06002545 kref_put(&wdata->refcount,
2546 cifs_uncached_writedata_release);
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002547 if (rc == -EAGAIN) {
2548 memcpy(from, &saved_from,
2549 sizeof(struct iov_iter));
2550 iov_iter_advance(from, offset - saved_offset);
2551 continue;
2552 }
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002553 break;
2554 }
2555
Pavel Shilovsky43de94e2014-06-20 16:10:52 +04002556 list_add_tail(&wdata->list, wdata_list);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002557 offset += cur_len;
2558 len -= cur_len;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002559 } while (len > 0);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002560
2561 return rc;
2562}
2563
2564static ssize_t
2565cifs_iovec_write(struct file *file, struct iov_iter *from, loff_t *poffset)
2566{
Pavel Shilovsky43de94e2014-06-20 16:10:52 +04002567 size_t len;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002568 ssize_t total_written = 0;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002569 struct cifsFileInfo *open_file;
2570 struct cifs_tcon *tcon;
2571 struct cifs_sb_info *cifs_sb;
2572 struct cifs_writedata *wdata, *tmp;
2573 struct list_head wdata_list;
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002574 struct iov_iter saved_from;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002575 int rc;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002576
2577 len = iov_iter_count(from);
2578 rc = generic_write_checks(file, poffset, &len, 0);
2579 if (rc)
2580 return rc;
2581
2582 if (!len)
2583 return 0;
2584
2585 iov_iter_truncate(from, len);
2586
2587 INIT_LIST_HEAD(&wdata_list);
2588 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2589 open_file = file->private_data;
2590 tcon = tlink_tcon(open_file->tlink);
2591
2592 if (!tcon->ses->server->ops->async_writev)
2593 return -ENOSYS;
2594
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002595 memcpy(&saved_from, from, sizeof(struct iov_iter));
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002596
Pavel Shilovsky43de94e2014-06-20 16:10:52 +04002597 rc = cifs_write_from_iter(*poffset, len, from, open_file, cifs_sb,
2598 &wdata_list);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002599
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002600 /*
2601 * If at least one write was successfully sent, then discard any rc
2602 * value from the later writes. If the other write succeeds, then
2603 * we'll end up returning whatever was written. If it fails, then
2604 * we'll get a new rc value from that.
2605 */
2606 if (!list_empty(&wdata_list))
2607 rc = 0;
2608
2609 /*
2610 * Wait for and collect replies for any successful sends in order of
2611 * increasing offset. Once an error is hit or we get a fatal signal
2612 * while waiting, then return without waiting for any more replies.
2613 */
2614restart_loop:
2615 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2616 if (!rc) {
2617 /* FIXME: freezable too? */
2618 rc = wait_for_completion_killable(&wdata->done);
2619 if (rc)
2620 rc = -EINTR;
2621 else if (wdata->result)
2622 rc = wdata->result;
2623 else
2624 total_written += wdata->bytes;
2625
2626 /* resend call if it's a retryable error */
2627 if (rc == -EAGAIN) {
Pavel Shilovsky6ec0b012014-06-20 16:30:46 +04002628 struct list_head tmp_list;
2629 struct iov_iter tmp_from;
2630
2631 INIT_LIST_HEAD(&tmp_list);
2632 list_del_init(&wdata->list);
2633
2634 memcpy(&tmp_from, &saved_from,
2635 sizeof(struct iov_iter));
2636 iov_iter_advance(&tmp_from,
2637 wdata->offset - *poffset);
2638
2639 rc = cifs_write_from_iter(wdata->offset,
2640 wdata->bytes, &tmp_from,
2641 open_file, cifs_sb, &tmp_list);
2642
2643 list_splice(&tmp_list, &wdata_list);
2644
2645 kref_put(&wdata->refcount,
2646 cifs_uncached_writedata_release);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002647 goto restart_loop;
2648 }
2649 }
2650 list_del_init(&wdata->list);
Steve French4a5c80d2014-02-07 20:45:12 -06002651 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002652 }
2653
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002654 if (total_written > 0)
2655 *poffset += total_written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002656
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002657 cifs_stats_bytes_written(tcon, total_written);
2658 return total_written ? total_written : (ssize_t)rc;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002659}
2660
Al Viro3dae8752014-04-03 12:05:17 -04002661ssize_t cifs_user_writev(struct kiocb *iocb, struct iov_iter *from)
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002662{
2663 ssize_t written;
2664 struct inode *inode;
Al Viro3dae8752014-04-03 12:05:17 -04002665 loff_t pos = iocb->ki_pos;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002666
Al Viro496ad9a2013-01-23 17:07:38 -05002667 inode = file_inode(iocb->ki_filp);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002668
2669 /*
2670 * BB - optimize the way when signing is disabled. We can drop this
2671 * extra memory-to-memory copying and use iovec buffers for constructing
2672 * write request.
2673 */
2674
Al Viro3dae8752014-04-03 12:05:17 -04002675 written = cifs_iovec_write(iocb->ki_filp, from, &pos);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002676 if (written > 0) {
Jeff Laytonaff8d5c2014-04-30 09:31:45 -04002677 set_bit(CIFS_INO_INVALID_MAPPING, &CIFS_I(inode)->flags);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002678 iocb->ki_pos = pos;
2679 }
2680
2681 return written;
2682}
2683
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002684static ssize_t
Al Viro3dae8752014-04-03 12:05:17 -04002685cifs_writev(struct kiocb *iocb, struct iov_iter *from)
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002686{
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002687 struct file *file = iocb->ki_filp;
2688 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2689 struct inode *inode = file->f_mapping->host;
2690 struct cifsInodeInfo *cinode = CIFS_I(inode);
2691 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2692 ssize_t rc = -EACCES;
Al Viro19dfc1f2014-04-03 10:27:17 -04002693 loff_t lock_pos = iocb->ki_pos;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002694
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002695 /*
2696 * We need to hold the sem to be sure nobody modifies lock list
2697 * with a brlock that prevents writing.
2698 */
2699 down_read(&cinode->lock_sem);
Al Viro19dfc1f2014-04-03 10:27:17 -04002700 mutex_lock(&inode->i_mutex);
2701 if (file->f_flags & O_APPEND)
2702 lock_pos = i_size_read(inode);
Al Viro3dae8752014-04-03 12:05:17 -04002703 if (!cifs_find_lock_conflict(cfile, lock_pos, iov_iter_count(from),
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002704 server->vals->exclusive_lock_type, NULL,
Al Viro19dfc1f2014-04-03 10:27:17 -04002705 CIFS_WRITE_OP)) {
Al Viro3dae8752014-04-03 12:05:17 -04002706 rc = __generic_file_write_iter(iocb, from);
Al Viro19dfc1f2014-04-03 10:27:17 -04002707 mutex_unlock(&inode->i_mutex);
2708
2709 if (rc > 0) {
2710 ssize_t err;
2711
2712 err = generic_write_sync(file, iocb->ki_pos - rc, rc);
Michael Opdenacker1f80c0c2014-04-15 10:06:50 +02002713 if (err < 0)
Al Viro19dfc1f2014-04-03 10:27:17 -04002714 rc = err;
2715 }
2716 } else {
2717 mutex_unlock(&inode->i_mutex);
2718 }
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002719 up_read(&cinode->lock_sem);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002720 return rc;
2721}
2722
2723ssize_t
Al Viro3dae8752014-04-03 12:05:17 -04002724cifs_strict_writev(struct kiocb *iocb, struct iov_iter *from)
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002725{
Al Viro496ad9a2013-01-23 17:07:38 -05002726 struct inode *inode = file_inode(iocb->ki_filp);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002727 struct cifsInodeInfo *cinode = CIFS_I(inode);
2728 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2729 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2730 iocb->ki_filp->private_data;
2731 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002732 ssize_t written;
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002733
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00002734 written = cifs_get_writer(cinode);
2735 if (written)
2736 return written;
2737
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002738 if (CIFS_CACHE_WRITE(cinode)) {
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002739 if (cap_unix(tcon->ses) &&
2740 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00002741 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0)) {
Al Viro3dae8752014-04-03 12:05:17 -04002742 written = generic_file_write_iter(iocb, from);
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00002743 goto out;
2744 }
Al Viro3dae8752014-04-03 12:05:17 -04002745 written = cifs_writev(iocb, from);
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00002746 goto out;
Pavel Shilovskyc299dd02012-12-06 22:07:52 +04002747 }
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002748 /*
2749 * For non-oplocked files in strict cache mode we need to write the data
2750 * to the server exactly from the pos to pos+len-1 rather than flush all
2751 * affected pages because it may cause a error with mandatory locks on
2752 * these pages but not on the region from pos to ppos+len-1.
2753 */
Al Viro3dae8752014-04-03 12:05:17 -04002754 written = cifs_user_writev(iocb, from);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002755 if (written > 0 && CIFS_CACHE_READ(cinode)) {
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002756 /*
2757 * Windows 7 server can delay breaking level2 oplock if a write
2758 * request comes - break it on the client to prevent reading
2759 * an old data.
2760 */
Jeff Layton4f73c7d2014-04-30 09:31:47 -04002761 cifs_zap_mapping(inode);
Joe Perchesf96637b2013-05-04 22:12:25 -05002762 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2763 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002764 cinode->oplock = 0;
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002765 }
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00002766out:
2767 cifs_put_writer(cinode);
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002768 return written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002769}
2770
Jeff Layton0471ca32012-05-16 07:13:16 -04002771static struct cifs_readdata *
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002772cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
Jeff Layton0471ca32012-05-16 07:13:16 -04002773{
2774 struct cifs_readdata *rdata;
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002775
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002776 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2777 GFP_KERNEL);
Jeff Layton0471ca32012-05-16 07:13:16 -04002778 if (rdata != NULL) {
Jeff Layton6993f742012-05-16 07:13:17 -04002779 kref_init(&rdata->refcount);
Jeff Layton1c892542012-05-16 07:13:17 -04002780 INIT_LIST_HEAD(&rdata->list);
2781 init_completion(&rdata->done);
Jeff Layton0471ca32012-05-16 07:13:16 -04002782 INIT_WORK(&rdata->work, complete);
Jeff Layton0471ca32012-05-16 07:13:16 -04002783 }
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002784
Jeff Layton0471ca32012-05-16 07:13:16 -04002785 return rdata;
2786}
2787
Jeff Layton6993f742012-05-16 07:13:17 -04002788void
2789cifs_readdata_release(struct kref *refcount)
Jeff Layton0471ca32012-05-16 07:13:16 -04002790{
Jeff Layton6993f742012-05-16 07:13:17 -04002791 struct cifs_readdata *rdata = container_of(refcount,
2792 struct cifs_readdata, refcount);
2793
2794 if (rdata->cfile)
2795 cifsFileInfo_put(rdata->cfile);
2796
Jeff Layton0471ca32012-05-16 07:13:16 -04002797 kfree(rdata);
2798}
2799
Jeff Layton2a1bb132012-05-16 07:13:17 -04002800static int
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002801cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
Jeff Layton1c892542012-05-16 07:13:17 -04002802{
2803 int rc = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002804 struct page *page;
Jeff Layton1c892542012-05-16 07:13:17 -04002805 unsigned int i;
2806
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002807 for (i = 0; i < nr_pages; i++) {
Jeff Layton1c892542012-05-16 07:13:17 -04002808 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2809 if (!page) {
2810 rc = -ENOMEM;
2811 break;
2812 }
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002813 rdata->pages[i] = page;
Jeff Layton1c892542012-05-16 07:13:17 -04002814 }
2815
2816 if (rc) {
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002817 for (i = 0; i < nr_pages; i++) {
2818 put_page(rdata->pages[i]);
2819 rdata->pages[i] = NULL;
Jeff Layton1c892542012-05-16 07:13:17 -04002820 }
2821 }
2822 return rc;
2823}
2824
2825static void
2826cifs_uncached_readdata_release(struct kref *refcount)
2827{
Jeff Layton1c892542012-05-16 07:13:17 -04002828 struct cifs_readdata *rdata = container_of(refcount,
2829 struct cifs_readdata, refcount);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002830 unsigned int i;
Jeff Layton1c892542012-05-16 07:13:17 -04002831
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002832 for (i = 0; i < rdata->nr_pages; i++) {
2833 put_page(rdata->pages[i]);
2834 rdata->pages[i] = NULL;
Jeff Layton1c892542012-05-16 07:13:17 -04002835 }
2836 cifs_readdata_release(refcount);
2837}
2838
Jeff Layton1c892542012-05-16 07:13:17 -04002839/**
2840 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2841 * @rdata: the readdata response with list of pages holding data
Al Viro7f25bba2014-02-04 14:07:43 -05002842 * @iter: destination for our data
Jeff Layton1c892542012-05-16 07:13:17 -04002843 *
2844 * This function copies data from a list of pages in a readdata response into
2845 * an array of iovecs. It will first calculate where the data should go
2846 * based on the info in the readdata and then copy the data into that spot.
2847 */
Al Viro7f25bba2014-02-04 14:07:43 -05002848static int
2849cifs_readdata_to_iov(struct cifs_readdata *rdata, struct iov_iter *iter)
Jeff Layton1c892542012-05-16 07:13:17 -04002850{
Pavel Shilovsky34a54d62014-07-10 10:03:29 +04002851 size_t remaining = rdata->got_bytes;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002852 unsigned int i;
Jeff Layton1c892542012-05-16 07:13:17 -04002853
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002854 for (i = 0; i < rdata->nr_pages; i++) {
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002855 struct page *page = rdata->pages[i];
Geert Uytterhoevene686bd82014-04-13 20:46:21 +02002856 size_t copy = min_t(size_t, remaining, PAGE_SIZE);
Al Viro7f25bba2014-02-04 14:07:43 -05002857 size_t written = copy_page_to_iter(page, 0, copy, iter);
2858 remaining -= written;
2859 if (written < copy && iov_iter_count(iter) > 0)
2860 break;
Jeff Layton1c892542012-05-16 07:13:17 -04002861 }
Al Viro7f25bba2014-02-04 14:07:43 -05002862 return remaining ? -EFAULT : 0;
Jeff Layton1c892542012-05-16 07:13:17 -04002863}
2864
2865static void
2866cifs_uncached_readv_complete(struct work_struct *work)
2867{
2868 struct cifs_readdata *rdata = container_of(work,
2869 struct cifs_readdata, work);
Jeff Layton1c892542012-05-16 07:13:17 -04002870
2871 complete(&rdata->done);
2872 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2873}
2874
2875static int
Jeff Layton8321fec2012-09-19 06:22:32 -07002876cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2877 struct cifs_readdata *rdata, unsigned int len)
Jeff Layton1c892542012-05-16 07:13:17 -04002878{
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04002879 int result = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002880 unsigned int i;
2881 unsigned int nr_pages = rdata->nr_pages;
Jeff Layton8321fec2012-09-19 06:22:32 -07002882 struct kvec iov;
Jeff Layton1c892542012-05-16 07:13:17 -04002883
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04002884 rdata->got_bytes = 0;
Jeff Layton8321fec2012-09-19 06:22:32 -07002885 rdata->tailsz = PAGE_SIZE;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002886 for (i = 0; i < nr_pages; i++) {
2887 struct page *page = rdata->pages[i];
2888
Jeff Layton8321fec2012-09-19 06:22:32 -07002889 if (len >= PAGE_SIZE) {
Jeff Layton1c892542012-05-16 07:13:17 -04002890 /* enough data to fill the page */
Jeff Layton8321fec2012-09-19 06:22:32 -07002891 iov.iov_base = kmap(page);
2892 iov.iov_len = PAGE_SIZE;
Joe Perchesf96637b2013-05-04 22:12:25 -05002893 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2894 i, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07002895 len -= PAGE_SIZE;
2896 } else if (len > 0) {
Jeff Layton1c892542012-05-16 07:13:17 -04002897 /* enough for partial page, fill and zero the rest */
Jeff Layton8321fec2012-09-19 06:22:32 -07002898 iov.iov_base = kmap(page);
2899 iov.iov_len = len;
Joe Perchesf96637b2013-05-04 22:12:25 -05002900 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2901 i, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07002902 memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2903 rdata->tailsz = len;
2904 len = 0;
Jeff Layton1c892542012-05-16 07:13:17 -04002905 } else {
2906 /* no need to hold page hostage */
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002907 rdata->pages[i] = NULL;
2908 rdata->nr_pages--;
Jeff Layton1c892542012-05-16 07:13:17 -04002909 put_page(page);
Jeff Layton8321fec2012-09-19 06:22:32 -07002910 continue;
Jeff Layton1c892542012-05-16 07:13:17 -04002911 }
Jeff Layton8321fec2012-09-19 06:22:32 -07002912
2913 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2914 kunmap(page);
2915 if (result < 0)
2916 break;
2917
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04002918 rdata->got_bytes += result;
Jeff Layton1c892542012-05-16 07:13:17 -04002919 }
2920
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04002921 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
2922 rdata->got_bytes : result;
Jeff Layton1c892542012-05-16 07:13:17 -04002923}
2924
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002925static int
2926cifs_send_async_read(loff_t offset, size_t len, struct cifsFileInfo *open_file,
2927 struct cifs_sb_info *cifs_sb, struct list_head *rdata_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002928{
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002929 struct cifs_readdata *rdata;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04002930 unsigned int npages, rsize, credits;
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002931 size_t cur_len;
2932 int rc;
Jeff Layton1c892542012-05-16 07:13:17 -04002933 pid_t pid;
Pavel Shilovsky25f40252014-06-25 10:45:07 +04002934 struct TCP_Server_Info *server;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002935
Pavel Shilovsky25f40252014-06-25 10:45:07 +04002936 server = tlink_tcon(open_file->tlink)->ses->server;
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -07002937
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002938 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2939 pid = open_file->pid;
2940 else
2941 pid = current->tgid;
2942
Jeff Layton1c892542012-05-16 07:13:17 -04002943 do {
Pavel Shilovskybed9da02014-06-25 11:28:57 +04002944 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
2945 &rsize, &credits);
2946 if (rc)
2947 break;
2948
2949 cur_len = min_t(const size_t, len, rsize);
Jeff Layton1c892542012-05-16 07:13:17 -04002950 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002951
Jeff Layton1c892542012-05-16 07:13:17 -04002952 /* allocate a readdata struct */
2953 rdata = cifs_readdata_alloc(npages,
2954 cifs_uncached_readv_complete);
2955 if (!rdata) {
Pavel Shilovskybed9da02014-06-25 11:28:57 +04002956 add_credits_and_wake_if(server, credits, 0);
Jeff Layton1c892542012-05-16 07:13:17 -04002957 rc = -ENOMEM;
Jeff Laytonbae9f742014-04-15 12:48:49 -04002958 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002959 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002960
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002961 rc = cifs_read_allocate_pages(rdata, npages);
Jeff Layton1c892542012-05-16 07:13:17 -04002962 if (rc)
2963 goto error;
2964
2965 rdata->cfile = cifsFileInfo_get(open_file);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002966 rdata->nr_pages = npages;
Jeff Layton1c892542012-05-16 07:13:17 -04002967 rdata->offset = offset;
2968 rdata->bytes = cur_len;
2969 rdata->pid = pid;
Jeff Layton8321fec2012-09-19 06:22:32 -07002970 rdata->pagesz = PAGE_SIZE;
2971 rdata->read_into_pages = cifs_uncached_read_into_pages;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04002972 rdata->credits = credits;
Jeff Layton1c892542012-05-16 07:13:17 -04002973
Pavel Shilovsky25f40252014-06-25 10:45:07 +04002974 if (!rdata->cfile->invalidHandle ||
2975 !cifs_reopen_file(rdata->cfile, true))
2976 rc = server->ops->async_readv(rdata);
Jeff Layton1c892542012-05-16 07:13:17 -04002977error:
2978 if (rc) {
Pavel Shilovskybed9da02014-06-25 11:28:57 +04002979 add_credits_and_wake_if(server, rdata->credits, 0);
Jeff Layton1c892542012-05-16 07:13:17 -04002980 kref_put(&rdata->refcount,
2981 cifs_uncached_readdata_release);
Pavel Shilovsky25f40252014-06-25 10:45:07 +04002982 if (rc == -EAGAIN)
2983 continue;
Jeff Layton1c892542012-05-16 07:13:17 -04002984 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002985 }
Jeff Layton1c892542012-05-16 07:13:17 -04002986
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002987 list_add_tail(&rdata->list, rdata_list);
Jeff Layton1c892542012-05-16 07:13:17 -04002988 offset += cur_len;
2989 len -= cur_len;
2990 } while (len > 0);
2991
Pavel Shilovsky0ada36b2014-06-25 10:42:28 +04002992 return rc;
2993}
2994
2995ssize_t cifs_user_readv(struct kiocb *iocb, struct iov_iter *to)
2996{
2997 struct file *file = iocb->ki_filp;
2998 ssize_t rc;
2999 size_t len;
3000 ssize_t total_read = 0;
3001 loff_t offset = iocb->ki_pos;
3002 struct cifs_sb_info *cifs_sb;
3003 struct cifs_tcon *tcon;
3004 struct cifsFileInfo *open_file;
3005 struct cifs_readdata *rdata, *tmp;
3006 struct list_head rdata_list;
3007
3008 len = iov_iter_count(to);
3009 if (!len)
3010 return 0;
3011
3012 INIT_LIST_HEAD(&rdata_list);
3013 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3014 open_file = file->private_data;
3015 tcon = tlink_tcon(open_file->tlink);
3016
3017 if (!tcon->ses->server->ops->async_readv)
3018 return -ENOSYS;
3019
3020 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
3021 cifs_dbg(FYI, "attempting read on write only file instance\n");
3022
3023 rc = cifs_send_async_read(offset, len, open_file, cifs_sb, &rdata_list);
3024
Jeff Layton1c892542012-05-16 07:13:17 -04003025 /* if at least one read request send succeeded, then reset rc */
3026 if (!list_empty(&rdata_list))
3027 rc = 0;
3028
Al Viroe6a7bcb2014-04-02 19:53:36 -04003029 len = iov_iter_count(to);
Jeff Layton1c892542012-05-16 07:13:17 -04003030 /* the loop below should proceed in the order of increasing offsets */
Pavel Shilovsky25f40252014-06-25 10:45:07 +04003031again:
Jeff Layton1c892542012-05-16 07:13:17 -04003032 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
3033 if (!rc) {
Jeff Layton1c892542012-05-16 07:13:17 -04003034 /* FIXME: freezable sleep too? */
3035 rc = wait_for_completion_killable(&rdata->done);
3036 if (rc)
3037 rc = -EINTR;
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003038 else if (rdata->result == -EAGAIN) {
Al Viro74027f42014-02-04 13:47:26 -05003039 /* resend call if it's a retryable error */
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003040 struct list_head tmp_list;
Pavel Shilovskyd913ed12014-07-10 11:31:48 +04003041 unsigned int got_bytes = rdata->got_bytes;
Jeff Layton1c892542012-05-16 07:13:17 -04003042
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003043 list_del_init(&rdata->list);
3044 INIT_LIST_HEAD(&tmp_list);
Pavel Shilovsky25f40252014-06-25 10:45:07 +04003045
Pavel Shilovskyd913ed12014-07-10 11:31:48 +04003046 /*
3047 * Got a part of data and then reconnect has
3048 * happened -- fill the buffer and continue
3049 * reading.
3050 */
3051 if (got_bytes && got_bytes < rdata->bytes) {
3052 rc = cifs_readdata_to_iov(rdata, to);
3053 if (rc) {
3054 kref_put(&rdata->refcount,
3055 cifs_uncached_readdata_release);
3056 continue;
3057 }
3058 }
3059
3060 rc = cifs_send_async_read(
3061 rdata->offset + got_bytes,
3062 rdata->bytes - got_bytes,
3063 rdata->cfile, cifs_sb,
3064 &tmp_list);
Pavel Shilovsky25f40252014-06-25 10:45:07 +04003065
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003066 list_splice(&tmp_list, &rdata_list);
Pavel Shilovsky25f40252014-06-25 10:45:07 +04003067
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003068 kref_put(&rdata->refcount,
3069 cifs_uncached_readdata_release);
3070 goto again;
3071 } else if (rdata->result)
3072 rc = rdata->result;
3073 else
Jeff Layton1c892542012-05-16 07:13:17 -04003074 rc = cifs_readdata_to_iov(rdata, to);
Pavel Shilovskyfb8a3e52014-07-10 11:50:39 +04003075
Pavel Shilovsky2e8a05d2014-07-10 10:21:15 +04003076 /* if there was a short read -- discard anything left */
3077 if (rdata->got_bytes && rdata->got_bytes < rdata->bytes)
3078 rc = -ENODATA;
Jeff Layton1c892542012-05-16 07:13:17 -04003079 }
3080 list_del_init(&rdata->list);
3081 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003083
Al Viroe6a7bcb2014-04-02 19:53:36 -04003084 total_read = len - iov_iter_count(to);
Al Viro7f25bba2014-02-04 14:07:43 -05003085
Jeff Layton1c892542012-05-16 07:13:17 -04003086 cifs_stats_bytes_read(tcon, total_read);
Jeff Layton1c892542012-05-16 07:13:17 -04003087
Pavel Shilovsky09a47072012-09-18 16:20:29 -07003088 /* mask nodata case */
3089 if (rc == -ENODATA)
3090 rc = 0;
3091
Al Viro0165e812014-02-04 14:19:48 -05003092 if (total_read) {
Al Viroe6a7bcb2014-04-02 19:53:36 -04003093 iocb->ki_pos += total_read;
Al Viro0165e812014-02-04 14:19:48 -05003094 return total_read;
3095 }
3096 return rc;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003097}
3098
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003099ssize_t
Al Viroe6a7bcb2014-04-02 19:53:36 -04003100cifs_strict_readv(struct kiocb *iocb, struct iov_iter *to)
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003101{
Al Viro496ad9a2013-01-23 17:07:38 -05003102 struct inode *inode = file_inode(iocb->ki_filp);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003103 struct cifsInodeInfo *cinode = CIFS_I(inode);
3104 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
3105 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
3106 iocb->ki_filp->private_data;
3107 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
3108 int rc = -EACCES;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003109
3110 /*
3111 * In strict cache mode we need to read from the server all the time
3112 * if we don't have level II oplock because the server can delay mtime
3113 * change - so we can't make a decision about inode invalidating.
3114 * And we can also fail with pagereading if there are mandatory locks
3115 * on pages affected by this read but not on the region from pos to
3116 * pos+len-1.
3117 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003118 if (!CIFS_CACHE_READ(cinode))
Al Viroe6a7bcb2014-04-02 19:53:36 -04003119 return cifs_user_readv(iocb, to);
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003120
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003121 if (cap_unix(tcon->ses) &&
3122 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
3123 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
Al Viroe6a7bcb2014-04-02 19:53:36 -04003124 return generic_file_read_iter(iocb, to);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003125
3126 /*
3127 * We need to hold the sem to be sure nobody modifies lock list
3128 * with a brlock that prevents reading.
3129 */
3130 down_read(&cinode->lock_sem);
Al Viroe6a7bcb2014-04-02 19:53:36 -04003131 if (!cifs_find_lock_conflict(cfile, iocb->ki_pos, iov_iter_count(to),
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003132 tcon->ses->server->vals->shared_lock_type,
Pavel Shilovsky081c0412012-11-27 18:38:53 +04003133 NULL, CIFS_READ_OP))
Al Viroe6a7bcb2014-04-02 19:53:36 -04003134 rc = generic_file_read_iter(iocb, to);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003135 up_read(&cinode->lock_sem);
3136 return rc;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003137}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003138
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003139static ssize_t
3140cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003141{
3142 int rc = -EACCES;
3143 unsigned int bytes_read = 0;
3144 unsigned int total_read;
3145 unsigned int current_read_size;
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003146 unsigned int rsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147 struct cifs_sb_info *cifs_sb;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003148 struct cifs_tcon *tcon;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003149 struct TCP_Server_Info *server;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003150 unsigned int xid;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003151 char *cur_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003152 struct cifsFileInfo *open_file;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003153 struct cifs_io_parms io_parms;
Steve Frenchec637e32005-12-12 20:53:18 -08003154 int buf_type = CIFS_NO_BUFFER;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003155 __u32 pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003156
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003157 xid = get_xid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08003158 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003159
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003160 /* FIXME: set up handlers for larger reads and/or convert to async */
3161 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3162
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303164 rc = -EBADF;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003165 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303166 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07003168 open_file = file->private_data;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003169 tcon = tlink_tcon(open_file->tlink);
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003170 server = tcon->ses->server;
3171
3172 if (!server->ops->sync_read) {
3173 free_xid(xid);
3174 return -ENOSYS;
3175 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003176
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003177 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3178 pid = open_file->pid;
3179 else
3180 pid = current->tgid;
3181
Linus Torvalds1da177e2005-04-16 15:20:36 -07003182 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesf96637b2013-05-04 22:12:25 -05003183 cifs_dbg(FYI, "attempting read on write only file instance\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003184
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003185 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3186 total_read += bytes_read, cur_offset += bytes_read) {
Pavel Shilovskye374d902014-06-25 16:19:02 +04003187 do {
3188 current_read_size = min_t(uint, read_size - total_read,
3189 rsize);
3190 /*
3191 * For windows me and 9x we do not want to request more
3192 * than it negotiated since it will refuse the read
3193 * then.
3194 */
3195 if ((tcon->ses) && !(tcon->ses->capabilities &
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003196 tcon->ses->server->vals->cap_large_files)) {
Pavel Shilovskye374d902014-06-25 16:19:02 +04003197 current_read_size = min_t(uint,
3198 current_read_size, CIFSMaxBufSize);
3199 }
Steve Frenchcdff08e2010-10-21 22:46:14 +00003200 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04003201 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003202 if (rc != 0)
3203 break;
3204 }
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003205 io_parms.pid = pid;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003206 io_parms.tcon = tcon;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003207 io_parms.offset = *offset;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003208 io_parms.length = current_read_size;
Steve Frenchdb8b6312014-09-22 05:13:55 -05003209 rc = server->ops->sync_read(xid, &open_file->fid, &io_parms,
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003210 &bytes_read, &cur_offset,
3211 &buf_type);
Pavel Shilovskye374d902014-06-25 16:19:02 +04003212 } while (rc == -EAGAIN);
3213
Linus Torvalds1da177e2005-04-16 15:20:36 -07003214 if (rc || (bytes_read == 0)) {
3215 if (total_read) {
3216 break;
3217 } else {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003218 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003219 return rc;
3220 }
3221 } else {
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003222 cifs_stats_bytes_read(tcon, total_read);
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003223 *offset += bytes_read;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003224 }
3225 }
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003226 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003227 return total_read;
3228}
3229
Jeff Laytonca83ce32011-04-12 09:13:44 -04003230/*
3231 * If the page is mmap'ed into a process' page tables, then we need to make
3232 * sure that it doesn't change while being written back.
3233 */
3234static int
3235cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3236{
3237 struct page *page = vmf->page;
3238
3239 lock_page(page);
3240 return VM_FAULT_LOCKED;
3241}
3242
3243static struct vm_operations_struct cifs_file_vm_ops = {
3244 .fault = filemap_fault,
Kirill A. Shutemovf1820362014-04-07 15:37:19 -07003245 .map_pages = filemap_map_pages,
Jeff Laytonca83ce32011-04-12 09:13:44 -04003246 .page_mkwrite = cifs_page_mkwrite,
Konstantin Khlebnikov0b173bc2012-10-08 16:28:46 -07003247 .remap_pages = generic_file_remap_pages,
Jeff Laytonca83ce32011-04-12 09:13:44 -04003248};
3249
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003250int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3251{
3252 int rc, xid;
Al Viro496ad9a2013-01-23 17:07:38 -05003253 struct inode *inode = file_inode(file);
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003254
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003255 xid = get_xid();
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003256
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003257 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
Jeff Layton4f73c7d2014-04-30 09:31:47 -04003258 rc = cifs_zap_mapping(inode);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04003259 if (rc)
3260 return rc;
3261 }
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003262
3263 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04003264 if (rc == 0)
3265 vma->vm_ops = &cifs_file_vm_ops;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003266 free_xid(xid);
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003267 return rc;
3268}
3269
Linus Torvalds1da177e2005-04-16 15:20:36 -07003270int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3271{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003272 int rc, xid;
3273
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003274 xid = get_xid();
Jeff Laytonabab0952010-02-12 07:44:18 -05003275 rc = cifs_revalidate_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003276 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003277 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3278 rc);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003279 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003280 return rc;
3281 }
3282 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04003283 if (rc == 0)
3284 vma->vm_ops = &cifs_file_vm_ops;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003285 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003286 return rc;
3287}
3288
Jeff Layton0471ca32012-05-16 07:13:16 -04003289static void
3290cifs_readv_complete(struct work_struct *work)
3291{
Pavel Shilovskyb770ddf2014-07-10 11:31:53 +04003292 unsigned int i, got_bytes;
Jeff Layton0471ca32012-05-16 07:13:16 -04003293 struct cifs_readdata *rdata = container_of(work,
3294 struct cifs_readdata, work);
Jeff Layton0471ca32012-05-16 07:13:16 -04003295
Pavel Shilovskyb770ddf2014-07-10 11:31:53 +04003296 got_bytes = rdata->got_bytes;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003297 for (i = 0; i < rdata->nr_pages; i++) {
3298 struct page *page = rdata->pages[i];
3299
Jeff Layton0471ca32012-05-16 07:13:16 -04003300 lru_cache_add_file(page);
3301
Pavel Shilovskyb770ddf2014-07-10 11:31:53 +04003302 if (rdata->result == 0 ||
3303 (rdata->result == -EAGAIN && got_bytes)) {
Jeff Layton0471ca32012-05-16 07:13:16 -04003304 flush_dcache_page(page);
3305 SetPageUptodate(page);
3306 }
3307
3308 unlock_page(page);
3309
Pavel Shilovskyb770ddf2014-07-10 11:31:53 +04003310 if (rdata->result == 0 ||
3311 (rdata->result == -EAGAIN && got_bytes))
Jeff Layton0471ca32012-05-16 07:13:16 -04003312 cifs_readpage_to_fscache(rdata->mapping->host, page);
3313
Pavel Shilovskyb770ddf2014-07-10 11:31:53 +04003314 got_bytes -= min_t(unsigned int, PAGE_CACHE_SIZE, got_bytes);
3315
Jeff Layton0471ca32012-05-16 07:13:16 -04003316 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003317 rdata->pages[i] = NULL;
Jeff Layton0471ca32012-05-16 07:13:16 -04003318 }
Jeff Layton6993f742012-05-16 07:13:17 -04003319 kref_put(&rdata->refcount, cifs_readdata_release);
Jeff Layton0471ca32012-05-16 07:13:16 -04003320}
3321
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003322static int
Jeff Layton8321fec2012-09-19 06:22:32 -07003323cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3324 struct cifs_readdata *rdata, unsigned int len)
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003325{
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04003326 int result = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003327 unsigned int i;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003328 u64 eof;
3329 pgoff_t eof_index;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003330 unsigned int nr_pages = rdata->nr_pages;
Jeff Layton8321fec2012-09-19 06:22:32 -07003331 struct kvec iov;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003332
3333 /* determine the eof that the server (probably) has */
3334 eof = CIFS_I(rdata->mapping->host)->server_eof;
3335 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
Joe Perchesf96637b2013-05-04 22:12:25 -05003336 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003337
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04003338 rdata->got_bytes = 0;
Jeff Layton8321fec2012-09-19 06:22:32 -07003339 rdata->tailsz = PAGE_CACHE_SIZE;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003340 for (i = 0; i < nr_pages; i++) {
3341 struct page *page = rdata->pages[i];
3342
Jeff Layton8321fec2012-09-19 06:22:32 -07003343 if (len >= PAGE_CACHE_SIZE) {
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003344 /* enough data to fill the page */
Jeff Layton8321fec2012-09-19 06:22:32 -07003345 iov.iov_base = kmap(page);
3346 iov.iov_len = PAGE_CACHE_SIZE;
Joe Perchesf96637b2013-05-04 22:12:25 -05003347 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3348 i, page->index, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07003349 len -= PAGE_CACHE_SIZE;
3350 } else if (len > 0) {
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003351 /* enough for partial page, fill and zero the rest */
Jeff Layton8321fec2012-09-19 06:22:32 -07003352 iov.iov_base = kmap(page);
3353 iov.iov_len = len;
Joe Perchesf96637b2013-05-04 22:12:25 -05003354 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3355 i, page->index, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07003356 memset(iov.iov_base + len,
3357 '\0', PAGE_CACHE_SIZE - len);
3358 rdata->tailsz = len;
3359 len = 0;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003360 } else if (page->index > eof_index) {
3361 /*
3362 * The VFS will not try to do readahead past the
3363 * i_size, but it's possible that we have outstanding
3364 * writes with gaps in the middle and the i_size hasn't
3365 * caught up yet. Populate those with zeroed out pages
3366 * to prevent the VFS from repeatedly attempting to
3367 * fill them until the writes are flushed.
3368 */
3369 zero_user(page, 0, PAGE_CACHE_SIZE);
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003370 lru_cache_add_file(page);
3371 flush_dcache_page(page);
3372 SetPageUptodate(page);
3373 unlock_page(page);
3374 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003375 rdata->pages[i] = NULL;
3376 rdata->nr_pages--;
Jeff Layton8321fec2012-09-19 06:22:32 -07003377 continue;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003378 } else {
3379 /* no need to hold page hostage */
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003380 lru_cache_add_file(page);
3381 unlock_page(page);
3382 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003383 rdata->pages[i] = NULL;
3384 rdata->nr_pages--;
Jeff Layton8321fec2012-09-19 06:22:32 -07003385 continue;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003386 }
Jeff Layton8321fec2012-09-19 06:22:32 -07003387
3388 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3389 kunmap(page);
3390 if (result < 0)
3391 break;
3392
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04003393 rdata->got_bytes += result;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003394 }
3395
Pavel Shilovskyb3160ae2014-07-10 10:16:25 +04003396 return rdata->got_bytes > 0 && result != -ECONNABORTED ?
3397 rdata->got_bytes : result;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003398}
3399
Pavel Shilovsky387eb922014-06-24 13:08:54 +04003400static int
3401readpages_get_pages(struct address_space *mapping, struct list_head *page_list,
3402 unsigned int rsize, struct list_head *tmplist,
3403 unsigned int *nr_pages, loff_t *offset, unsigned int *bytes)
3404{
3405 struct page *page, *tpage;
3406 unsigned int expected_index;
3407 int rc;
3408
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003409 INIT_LIST_HEAD(tmplist);
3410
Pavel Shilovsky387eb922014-06-24 13:08:54 +04003411 page = list_entry(page_list->prev, struct page, lru);
3412
3413 /*
3414 * Lock the page and put it in the cache. Since no one else
3415 * should have access to this page, we're safe to simply set
3416 * PG_locked without checking it first.
3417 */
3418 __set_page_locked(page);
3419 rc = add_to_page_cache_locked(page, mapping,
3420 page->index, GFP_KERNEL);
3421
3422 /* give up if we can't stick it in the cache */
3423 if (rc) {
3424 __clear_page_locked(page);
3425 return rc;
3426 }
3427
3428 /* move first page to the tmplist */
3429 *offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3430 *bytes = PAGE_CACHE_SIZE;
3431 *nr_pages = 1;
3432 list_move_tail(&page->lru, tmplist);
3433
3434 /* now try and add more pages onto the request */
3435 expected_index = page->index + 1;
3436 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3437 /* discontinuity ? */
3438 if (page->index != expected_index)
3439 break;
3440
3441 /* would this page push the read over the rsize? */
3442 if (*bytes + PAGE_CACHE_SIZE > rsize)
3443 break;
3444
3445 __set_page_locked(page);
3446 if (add_to_page_cache_locked(page, mapping, page->index,
3447 GFP_KERNEL)) {
3448 __clear_page_locked(page);
3449 break;
3450 }
3451 list_move_tail(&page->lru, tmplist);
3452 (*bytes) += PAGE_CACHE_SIZE;
3453 expected_index++;
3454 (*nr_pages)++;
3455 }
3456 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003457}
3458
Linus Torvalds1da177e2005-04-16 15:20:36 -07003459static int cifs_readpages(struct file *file, struct address_space *mapping,
3460 struct list_head *page_list, unsigned num_pages)
3461{
Jeff Layton690c5e32011-10-19 15:30:16 -04003462 int rc;
3463 struct list_head tmplist;
3464 struct cifsFileInfo *open_file = file->private_data;
3465 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003466 struct TCP_Server_Info *server;
Jeff Layton690c5e32011-10-19 15:30:16 -04003467 pid_t pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003468
Jeff Layton690c5e32011-10-19 15:30:16 -04003469 /*
Suresh Jayaraman56698232010-07-05 18:13:25 +05303470 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3471 * immediately if the cookie is negative
David Howells54afa992013-09-04 17:10:39 +00003472 *
3473 * After this point, every page in the list might have PG_fscache set,
3474 * so we will need to clean that up off of every page we don't use.
Suresh Jayaraman56698232010-07-05 18:13:25 +05303475 */
3476 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3477 &num_pages);
3478 if (rc == 0)
Jeff Layton690c5e32011-10-19 15:30:16 -04003479 return rc;
Suresh Jayaraman56698232010-07-05 18:13:25 +05303480
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003481 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3482 pid = open_file->pid;
3483 else
3484 pid = current->tgid;
3485
Jeff Layton690c5e32011-10-19 15:30:16 -04003486 rc = 0;
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003487 server = tlink_tcon(open_file->tlink)->ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003488
Joe Perchesf96637b2013-05-04 22:12:25 -05003489 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3490 __func__, file, mapping, num_pages);
Jeff Layton690c5e32011-10-19 15:30:16 -04003491
3492 /*
3493 * Start with the page at end of list and move it to private
3494 * list. Do the same with any following pages until we hit
3495 * the rsize limit, hit an index discontinuity, or run out of
3496 * pages. Issue the async read and then start the loop again
3497 * until the list is empty.
3498 *
3499 * Note that list order is important. The page_list is in
3500 * the order of declining indexes. When we put the pages in
3501 * the rdata->pages, then we want them in increasing order.
3502 */
3503 while (!list_empty(page_list)) {
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003504 unsigned int i, nr_pages, bytes, rsize;
Jeff Layton690c5e32011-10-19 15:30:16 -04003505 loff_t offset;
3506 struct page *page, *tpage;
3507 struct cifs_readdata *rdata;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003508 unsigned credits;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003509
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003510 rc = server->ops->wait_mtu_credits(server, cifs_sb->rsize,
3511 &rsize, &credits);
3512 if (rc)
3513 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003514
Jeff Layton690c5e32011-10-19 15:30:16 -04003515 /*
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003516 * Give up immediately if rsize is too small to read an entire
3517 * page. The VFS will fall back to readpage. We should never
3518 * reach this point however since we set ra_pages to 0 when the
3519 * rsize is smaller than a cache page.
Jeff Layton690c5e32011-10-19 15:30:16 -04003520 */
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003521 if (unlikely(rsize < PAGE_CACHE_SIZE)) {
3522 add_credits_and_wake_if(server, credits, 0);
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003523 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003524 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003525
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003526 rc = readpages_get_pages(mapping, page_list, rsize, &tmplist,
3527 &nr_pages, &offset, &bytes);
3528 if (rc) {
3529 add_credits_and_wake_if(server, credits, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003530 break;
Jeff Layton690c5e32011-10-19 15:30:16 -04003531 }
3532
Jeff Layton0471ca32012-05-16 07:13:16 -04003533 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
Jeff Layton690c5e32011-10-19 15:30:16 -04003534 if (!rdata) {
3535 /* best to give up if we're out of mem */
3536 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3537 list_del(&page->lru);
3538 lru_cache_add_file(page);
3539 unlock_page(page);
3540 page_cache_release(page);
3541 }
3542 rc = -ENOMEM;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003543 add_credits_and_wake_if(server, credits, 0);
Jeff Layton690c5e32011-10-19 15:30:16 -04003544 break;
3545 }
3546
Jeff Layton6993f742012-05-16 07:13:17 -04003547 rdata->cfile = cifsFileInfo_get(open_file);
Jeff Layton690c5e32011-10-19 15:30:16 -04003548 rdata->mapping = mapping;
3549 rdata->offset = offset;
3550 rdata->bytes = bytes;
3551 rdata->pid = pid;
Jeff Layton8321fec2012-09-19 06:22:32 -07003552 rdata->pagesz = PAGE_CACHE_SIZE;
3553 rdata->read_into_pages = cifs_readpages_read_into_pages;
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003554 rdata->credits = credits;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003555
3556 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3557 list_del(&page->lru);
3558 rdata->pages[rdata->nr_pages++] = page;
3559 }
Jeff Layton690c5e32011-10-19 15:30:16 -04003560
Pavel Shilovsky69cebd72014-06-24 13:42:03 +04003561 if (!rdata->cfile->invalidHandle ||
3562 !cifs_reopen_file(rdata->cfile, true))
3563 rc = server->ops->async_readv(rdata);
3564 if (rc) {
Pavel Shilovskybed9da02014-06-25 11:28:57 +04003565 add_credits_and_wake_if(server, rdata->credits, 0);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003566 for (i = 0; i < rdata->nr_pages; i++) {
3567 page = rdata->pages[i];
Jeff Layton690c5e32011-10-19 15:30:16 -04003568 lru_cache_add_file(page);
3569 unlock_page(page);
3570 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003571 }
Pavel Shilovsky1209bbd2014-10-02 20:13:35 +04003572 /* Fallback to the readpage in error/reconnect cases */
Jeff Layton6993f742012-05-16 07:13:17 -04003573 kref_put(&rdata->refcount, cifs_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003574 break;
3575 }
Jeff Layton6993f742012-05-16 07:13:17 -04003576
3577 kref_put(&rdata->refcount, cifs_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003578 }
3579
David Howells54afa992013-09-04 17:10:39 +00003580 /* Any pages that have been shown to fscache but didn't get added to
3581 * the pagecache must be uncached before they get returned to the
3582 * allocator.
3583 */
3584 cifs_fscache_readpages_cancel(mapping->host, page_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003585 return rc;
3586}
3587
Sachin Prabhua9e9b7b2013-09-13 14:11:56 +01003588/*
3589 * cifs_readpage_worker must be called with the page pinned
3590 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003591static int cifs_readpage_worker(struct file *file, struct page *page,
3592 loff_t *poffset)
3593{
3594 char *read_data;
3595 int rc;
3596
Suresh Jayaraman56698232010-07-05 18:13:25 +05303597 /* Is the page cached? */
Al Viro496ad9a2013-01-23 17:07:38 -05003598 rc = cifs_readpage_from_fscache(file_inode(file), page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05303599 if (rc == 0)
3600 goto read_complete;
3601
Linus Torvalds1da177e2005-04-16 15:20:36 -07003602 read_data = kmap(page);
3603 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003604
Linus Torvalds1da177e2005-04-16 15:20:36 -07003605 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003606
Linus Torvalds1da177e2005-04-16 15:20:36 -07003607 if (rc < 0)
3608 goto io_error;
3609 else
Joe Perchesf96637b2013-05-04 22:12:25 -05003610 cifs_dbg(FYI, "Bytes read %d\n", rc);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003611
Al Viro496ad9a2013-01-23 17:07:38 -05003612 file_inode(file)->i_atime =
3613 current_fs_time(file_inode(file)->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003614
Linus Torvalds1da177e2005-04-16 15:20:36 -07003615 if (PAGE_CACHE_SIZE > rc)
3616 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3617
3618 flush_dcache_page(page);
3619 SetPageUptodate(page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05303620
3621 /* send this page to the cache */
Al Viro496ad9a2013-01-23 17:07:38 -05003622 cifs_readpage_to_fscache(file_inode(file), page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05303623
Linus Torvalds1da177e2005-04-16 15:20:36 -07003624 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003625
Linus Torvalds1da177e2005-04-16 15:20:36 -07003626io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003627 kunmap(page);
Sachin Prabhu466bd312013-09-13 14:11:57 +01003628 unlock_page(page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05303629
3630read_complete:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003631 return rc;
3632}
3633
3634static int cifs_readpage(struct file *file, struct page *page)
3635{
3636 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3637 int rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003638 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003639
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003640 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003641
3642 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303643 rc = -EBADF;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003644 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303645 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003646 }
3647
Joe Perchesf96637b2013-05-04 22:12:25 -05003648 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003649 page, (int)offset, (int)offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003650
3651 rc = cifs_readpage_worker(file, page, &offset);
3652
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003653 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003654 return rc;
3655}
3656
Steve Frencha403a0a2007-07-26 15:54:16 +00003657static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3658{
3659 struct cifsFileInfo *open_file;
3660
Jeff Layton44772882010-10-15 15:34:03 -04003661 spin_lock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003662 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2e396b82010-10-15 15:34:01 -04003663 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Jeff Layton44772882010-10-15 15:34:03 -04003664 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003665 return 1;
3666 }
3667 }
Jeff Layton44772882010-10-15 15:34:03 -04003668 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003669 return 0;
3670}
3671
Linus Torvalds1da177e2005-04-16 15:20:36 -07003672/* We do not want to update the file size from server for inodes
3673 open for write - to avoid races with writepage extending
3674 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003675 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07003676 but this is tricky to do without racing with writebehind
3677 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00003678bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003679{
Steve Frencha403a0a2007-07-26 15:54:16 +00003680 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00003681 return true;
Steve French23e7dd72005-10-20 13:44:56 -07003682
Steve Frencha403a0a2007-07-26 15:54:16 +00003683 if (is_inode_writable(cifsInode)) {
3684 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08003685 struct cifs_sb_info *cifs_sb;
3686
Steve Frenchc32a0b62006-01-12 14:41:28 -08003687 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00003688 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003689 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08003690 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00003691 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08003692 }
3693
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003694 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00003695 return true;
Steve French7ba52632007-02-08 18:14:13 +00003696
Steve French4b18f2a2008-04-29 00:06:05 +00003697 return false;
Steve French23e7dd72005-10-20 13:44:56 -07003698 } else
Steve French4b18f2a2008-04-29 00:06:05 +00003699 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003700}
3701
Nick Piggind9414772008-09-24 11:32:59 -04003702static int cifs_write_begin(struct file *file, struct address_space *mapping,
3703 loff_t pos, unsigned len, unsigned flags,
3704 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003705{
Sachin Prabhu466bd312013-09-13 14:11:57 +01003706 int oncethru = 0;
Nick Piggind9414772008-09-24 11:32:59 -04003707 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3708 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003709 loff_t page_start = pos & PAGE_MASK;
3710 loff_t i_size;
3711 struct page *page;
3712 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003713
Joe Perchesf96637b2013-05-04 22:12:25 -05003714 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
Nick Piggind9414772008-09-24 11:32:59 -04003715
Sachin Prabhu466bd312013-09-13 14:11:57 +01003716start:
Nick Piggin54566b22009-01-04 12:00:53 -08003717 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003718 if (!page) {
3719 rc = -ENOMEM;
3720 goto out;
3721 }
Nick Piggind9414772008-09-24 11:32:59 -04003722
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003723 if (PageUptodate(page))
3724 goto out;
Steve French8a236262007-03-06 00:31:00 +00003725
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003726 /*
3727 * If we write a full page it will be up to date, no need to read from
3728 * the server. If the write is short, we'll end up doing a sync write
3729 * instead.
3730 */
3731 if (len == PAGE_CACHE_SIZE)
3732 goto out;
3733
3734 /*
3735 * optimize away the read when we have an oplock, and we're not
3736 * expecting to use any of the data we'd be reading in. That
3737 * is, when the page lies beyond the EOF, or straddles the EOF
3738 * and the write will cover all of the existing data.
3739 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003740 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003741 i_size = i_size_read(mapping->host);
3742 if (page_start >= i_size ||
3743 (offset == 0 && (pos + len) >= i_size)) {
3744 zero_user_segments(page, 0, offset,
3745 offset + len,
3746 PAGE_CACHE_SIZE);
3747 /*
3748 * PageChecked means that the parts of the page
3749 * to which we're not writing are considered up
3750 * to date. Once the data is copied to the
3751 * page, it can be set uptodate.
3752 */
3753 SetPageChecked(page);
3754 goto out;
3755 }
3756 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003757
Sachin Prabhu466bd312013-09-13 14:11:57 +01003758 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003759 /*
3760 * might as well read a page, it is fast enough. If we get
3761 * an error, we don't need to return it. cifs_write_end will
3762 * do a sync write instead since PG_uptodate isn't set.
3763 */
3764 cifs_readpage_worker(file, page, &page_start);
Sachin Prabhu466bd312013-09-13 14:11:57 +01003765 page_cache_release(page);
3766 oncethru = 1;
3767 goto start;
Steve French8a236262007-03-06 00:31:00 +00003768 } else {
3769 /* we could try using another file handle if there is one -
3770 but how would we lock it to prevent close of that handle
3771 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04003772 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00003773 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003774out:
3775 *pagep = page;
3776 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003777}
3778
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303779static int cifs_release_page(struct page *page, gfp_t gfp)
3780{
3781 if (PagePrivate(page))
3782 return 0;
3783
3784 return cifs_fscache_release_page(page, gfp);
3785}
3786
Lukas Czernerd47992f2013-05-21 23:17:23 -04003787static void cifs_invalidate_page(struct page *page, unsigned int offset,
3788 unsigned int length)
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303789{
3790 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3791
Lukas Czernerd47992f2013-05-21 23:17:23 -04003792 if (offset == 0 && length == PAGE_CACHE_SIZE)
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303793 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3794}
3795
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003796static int cifs_launder_page(struct page *page)
3797{
3798 int rc = 0;
3799 loff_t range_start = page_offset(page);
3800 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3801 struct writeback_control wbc = {
3802 .sync_mode = WB_SYNC_ALL,
3803 .nr_to_write = 0,
3804 .range_start = range_start,
3805 .range_end = range_end,
3806 };
3807
Joe Perchesf96637b2013-05-04 22:12:25 -05003808 cifs_dbg(FYI, "Launder page: %p\n", page);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003809
3810 if (clear_page_dirty_for_io(page))
3811 rc = cifs_writepage_locked(page, &wbc);
3812
3813 cifs_fscache_invalidate_page(page, page->mapping->host);
3814 return rc;
3815}
3816
Tejun Heo9b646972010-07-20 22:09:02 +02003817void cifs_oplock_break(struct work_struct *work)
Jeff Layton3bc303c2009-09-21 06:47:50 -04003818{
3819 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3820 oplock_break);
Jeff Laytona5e18bc2010-10-11 15:07:18 -04003821 struct inode *inode = cfile->dentry->d_inode;
Jeff Layton3bc303c2009-09-21 06:47:50 -04003822 struct cifsInodeInfo *cinode = CIFS_I(inode);
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -07003823 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00003824 struct TCP_Server_Info *server = tcon->ses->server;
Jeff Laytoneb4b7562010-10-22 14:52:29 -04003825 int rc = 0;
Jeff Layton3bc303c2009-09-21 06:47:50 -04003826
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00003827 wait_on_bit(&cinode->flags, CIFS_INODE_PENDING_WRITERS,
NeilBrown74316202014-07-07 15:16:04 +10003828 TASK_UNINTERRUPTIBLE);
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00003829
3830 server->ops->downgrade_oplock(server, cinode,
3831 test_bit(CIFS_INODE_DOWNGRADE_OPLOCK_TO_L2, &cinode->flags));
3832
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003833 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04003834 cifs_has_mand_locks(cinode)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003835 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3836 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003837 cinode->oplock = 0;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04003838 }
3839
Jeff Layton3bc303c2009-09-21 06:47:50 -04003840 if (inode && S_ISREG(inode->i_mode)) {
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003841 if (CIFS_CACHE_READ(cinode))
Al Viro8737c932009-12-24 06:47:55 -05003842 break_lease(inode, O_RDONLY);
Steve Frenchd54ff732010-04-27 04:38:15 +00003843 else
Al Viro8737c932009-12-24 06:47:55 -05003844 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003845 rc = filemap_fdatawrite(inode->i_mapping);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003846 if (!CIFS_CACHE_READ(cinode)) {
Jeff Laytoneb4b7562010-10-22 14:52:29 -04003847 rc = filemap_fdatawait(inode->i_mapping);
3848 mapping_set_error(inode->i_mapping, rc);
Jeff Layton4f73c7d2014-04-30 09:31:47 -04003849 cifs_zap_mapping(inode);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003850 }
Joe Perchesf96637b2013-05-04 22:12:25 -05003851 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003852 }
3853
Pavel Shilovsky85160e02011-10-22 15:33:29 +04003854 rc = cifs_push_locks(cfile);
3855 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003856 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04003857
Jeff Layton3bc303c2009-09-21 06:47:50 -04003858 /*
3859 * releasing stale oplock after recent reconnect of smb session using
3860 * a now incorrect file handle is not a data integrity issue but do
3861 * not bother sending an oplock release if session to server still is
3862 * disconnected since oplock already released by the server
3863 */
Steve Frenchcdff08e2010-10-21 22:46:14 +00003864 if (!cfile->oplock_break_cancelled) {
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -07003865 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3866 cinode);
Joe Perchesf96637b2013-05-04 22:12:25 -05003867 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003868 }
Sachin Prabhuc11f1df2014-03-11 16:11:47 +00003869 cifs_done_oplock_break(cinode);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003870}
3871
Steve Frenchdca69282013-11-11 16:42:37 -06003872/*
3873 * The presence of cifs_direct_io() in the address space ops vector
3874 * allowes open() O_DIRECT flags which would have failed otherwise.
3875 *
3876 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
3877 * so this method should never be called.
3878 *
3879 * Direct IO is not yet supported in the cached mode.
3880 */
3881static ssize_t
Al Virod8d3d942014-03-04 21:27:34 -05003882cifs_direct_io(int rw, struct kiocb *iocb, struct iov_iter *iter,
3883 loff_t pos)
Steve Frenchdca69282013-11-11 16:42:37 -06003884{
3885 /*
3886 * FIXME
3887 * Eventually need to support direct IO for non forcedirectio mounts
3888 */
3889 return -EINVAL;
3890}
3891
3892
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07003893const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003894 .readpage = cifs_readpage,
3895 .readpages = cifs_readpages,
3896 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07003897 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04003898 .write_begin = cifs_write_begin,
3899 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003900 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303901 .releasepage = cifs_release_page,
Steve Frenchdca69282013-11-11 16:42:37 -06003902 .direct_IO = cifs_direct_io,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303903 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003904 .launder_page = cifs_launder_page,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003905};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003906
3907/*
3908 * cifs_readpages requires the server to support a buffer large enough to
3909 * contain the header plus one complete page of data. Otherwise, we need
3910 * to leave cifs_readpages out of the address space operations.
3911 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07003912const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003913 .readpage = cifs_readpage,
3914 .writepage = cifs_writepage,
3915 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04003916 .write_begin = cifs_write_begin,
3917 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003918 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303919 .releasepage = cifs_release_page,
3920 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003921 .launder_page = cifs_launder_page,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003922};