blob: 216d7e99f9219317bd0f2567c898925df77ec68d [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)
338 cifs_invalidate_mapping(inode);
339
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)
395 CIFS_I(inode)->invalid_mapping = true;
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
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700470 if (server->oplocks)
Steve French276a74a2009-03-03 18:00:34 +0000471 oplock = REQ_OPLOCK;
472 else
473 oplock = 0;
474
Steve French64cc2c62009-03-04 19:54:08 +0000475 if (!tcon->broken_posix_open && tcon->unix_ext &&
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400476 cap_unix(tcon->ses) && (CIFS_UNIX_POSIX_PATH_OPS_CAP &
477 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Steve French276a74a2009-03-03 18:00:34 +0000478 /* can not refresh inode info since size could be stale */
Jeff Layton2422f672010-06-16 13:40:16 -0400479 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000480 cifs_sb->mnt_file_mode /* ignored */,
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700481 file->f_flags, &oplock, &fid.netfid, xid);
Steve French276a74a2009-03-03 18:00:34 +0000482 if (rc == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500483 cifs_dbg(FYI, "posix open succeeded\n");
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300484 posix_open_ok = true;
Steve French64cc2c62009-03-04 19:54:08 +0000485 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
486 if (tcon->ses->serverNOS)
Joe Perchesf96637b2013-05-04 22:12:25 -0500487 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",
488 tcon->ses->serverName,
489 tcon->ses->serverNOS);
Steve French64cc2c62009-03-04 19:54:08 +0000490 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000491 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
492 (rc != -EOPNOTSUPP)) /* path not found or net err */
493 goto out;
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700494 /*
495 * Else fallthrough to retry open the old way on network i/o
496 * or DFS errors.
497 */
Steve French276a74a2009-03-03 18:00:34 +0000498 }
499
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700500 if (server->ops->get_lease_key)
501 server->ops->get_lease_key(inode, &fid);
502
503 cifs_add_pending_open(&fid, tlink, &open);
504
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300505 if (!posix_open_ok) {
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700506 if (server->ops->get_lease_key)
507 server->ops->get_lease_key(inode, &fid);
508
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300509 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700510 file->f_flags, &oplock, &fid, xid);
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700511 if (rc) {
512 cifs_del_pending_open(&open);
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300513 goto out;
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700514 }
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300515 }
Jeff Layton47c78b72010-06-16 13:40:17 -0400516
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700517 cfile = cifs_new_fileinfo(&fid, file, tlink, oplock);
518 if (cfile == NULL) {
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700519 if (server->ops->close)
520 server->ops->close(xid, tcon, &fid);
Pavel Shilovsky233839b2012-09-19 06:22:45 -0700521 cifs_del_pending_open(&open);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 rc = -ENOMEM;
523 goto out;
524 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700525
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530526 cifs_fscache_set_inode_cookie(inode, file);
527
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300528 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700529 /*
530 * Time to set mode which we can not set earlier due to
531 * problems creating new read-only files.
532 */
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300533 struct cifs_unix_set_info_args args = {
534 .mode = inode->i_mode,
Eric W. Biederman49418b22013-02-06 00:57:56 -0800535 .uid = INVALID_UID, /* no change */
536 .gid = INVALID_GID, /* no change */
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300537 .ctime = NO_CHANGE_64,
538 .atime = NO_CHANGE_64,
539 .mtime = NO_CHANGE_64,
540 .device = 0,
541 };
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700542 CIFSSMBUnixSetFileInfo(xid, tcon, &args, fid.netfid,
543 cfile->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 }
545
546out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400548 free_xid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400549 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 return rc;
551}
552
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400553static int cifs_push_posix_locks(struct cifsFileInfo *cfile);
554
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700555/*
556 * Try to reacquire byte range locks that were released when session
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400557 * to server was lost.
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700558 */
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400559static int
560cifs_relock_file(struct cifsFileInfo *cfile)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700561{
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400562 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
563 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
564 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700565 int rc = 0;
566
Pavel Shilovsky689c3db2013-07-11 11:17:45 +0400567 down_read(&cinode->lock_sem);
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400568 if (cinode->can_cache_brlcks) {
Pavel Shilovsky689c3db2013-07-11 11:17:45 +0400569 /* can cache locks - no need to relock */
570 up_read(&cinode->lock_sem);
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400571 return rc;
572 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700573
Pavel Shilovskyf152fd52012-11-22 17:10:57 +0400574 if (cap_unix(tcon->ses) &&
575 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
576 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
577 rc = cifs_push_posix_locks(cfile);
578 else
579 rc = tcon->ses->server->ops->push_mand_locks(cfile);
580
Pavel Shilovsky689c3db2013-07-11 11:17:45 +0400581 up_read(&cinode->lock_sem);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700582 return rc;
583}
584
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700585static int
586cifs_reopen_file(struct cifsFileInfo *cfile, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700587{
588 int rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400589 unsigned int xid;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400590 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700591 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +0000592 struct cifs_tcon *tcon;
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700593 struct TCP_Server_Info *server;
594 struct cifsInodeInfo *cinode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000595 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596 char *full_path = NULL;
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700597 int desired_access;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 int disposition = FILE_OPEN;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500599 int create_options = CREATE_NOT_DIR;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400600 struct cifs_open_parms oparms;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400602 xid = get_xid();
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700603 mutex_lock(&cfile->fh_mutex);
604 if (!cfile->invalidHandle) {
605 mutex_unlock(&cfile->fh_mutex);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530606 rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400607 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530608 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 }
610
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700611 inode = cfile->dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700612 cifs_sb = CIFS_SB(inode->i_sb);
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700613 tcon = tlink_tcon(cfile->tlink);
614 server = tcon->ses->server;
Steve French3a9f4622007-04-04 17:10:24 +0000615
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700616 /*
617 * Can not grab rename sem here because various ops, including those
618 * that already have the rename sem can end up causing writepage to get
619 * called and if the server was down that means we end up here, and we
620 * can never tell if the caller already has the rename_sem.
621 */
622 full_path = build_path_from_dentry(cfile->dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700623 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000624 rc = -ENOMEM;
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700625 mutex_unlock(&cfile->fh_mutex);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400626 free_xid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000627 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 }
629
Joe Perchesf96637b2013-05-04 22:12:25 -0500630 cifs_dbg(FYI, "inode = 0x%p file flags 0x%x for %s\n",
631 inode, cfile->f_flags, full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300633 if (tcon->ses->server->oplocks)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700634 oplock = REQ_OPLOCK;
635 else
Steve French4b18f2a2008-04-29 00:06:05 +0000636 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400638 if (tcon->unix_ext && cap_unix(tcon->ses) &&
Steve French7fc8f4e2009-02-23 20:43:11 +0000639 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
Pavel Shilovsky29e20f92012-07-13 13:58:14 +0400640 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton608712f2010-10-15 15:33:56 -0400641 /*
642 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
643 * original open. Must mask them off for a reopen.
644 */
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700645 unsigned int oflags = cfile->f_flags &
Jeff Layton15886172010-10-15 15:33:59 -0400646 ~(O_CREAT | O_EXCL | O_TRUNC);
Jeff Layton608712f2010-10-15 15:33:56 -0400647
Jeff Layton2422f672010-06-16 13:40:16 -0400648 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700649 cifs_sb->mnt_file_mode /* ignored */,
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400650 oflags, &oplock, &cfile->fid.netfid, xid);
Steve French7fc8f4e2009-02-23 20:43:11 +0000651 if (rc == 0) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500652 cifs_dbg(FYI, "posix reopen succeeded\n");
Andi Shytife090e42013-07-29 20:04:35 +0200653 oparms.reconnect = true;
Steve French7fc8f4e2009-02-23 20:43:11 +0000654 goto reopen_success;
655 }
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700656 /*
657 * fallthrough to retry open the old way on errors, especially
658 * in the reconnect path it is important to retry hard
659 */
Steve French7fc8f4e2009-02-23 20:43:11 +0000660 }
661
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700662 desired_access = cifs_convert_flags(cfile->f_flags);
Steve French7fc8f4e2009-02-23 20:43:11 +0000663
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500664 if (backup_cred(cifs_sb))
665 create_options |= CREATE_OPEN_BACKUP_INTENT;
666
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700667 if (server->ops->get_lease_key)
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400668 server->ops->get_lease_key(inode, &cfile->fid);
Pavel Shilovskyb8c32db2012-09-19 06:22:44 -0700669
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400670 oparms.tcon = tcon;
671 oparms.cifs_sb = cifs_sb;
672 oparms.desired_access = desired_access;
673 oparms.create_options = create_options;
674 oparms.disposition = disposition;
675 oparms.path = full_path;
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400676 oparms.fid = &cfile->fid;
677 oparms.reconnect = true;
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400678
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700679 /*
680 * Can not refresh inode by passing in file_info buf to be returned by
Pavel Shilovskyd81b8a42014-01-16 15:53:36 +0400681 * ops->open and then calling get_inode_info with returned buf since
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700682 * file might have write behind data that needs to be flushed and server
683 * version of file size can be stale. If we knew for sure that inode was
684 * not dirty locally we could do this.
685 */
Pavel Shilovsky226730b2013-07-05 12:00:30 +0400686 rc = server->ops->open(xid, &oparms, &oplock, NULL);
Pavel Shilovskyb33fcf12013-07-11 10:58:30 +0400687 if (rc == -ENOENT && oparms.reconnect == false) {
688 /* durable handle timeout is expired - open the file again */
689 rc = server->ops->open(xid, &oparms, &oplock, NULL);
690 /* indicate that we need to relock the file */
691 oparms.reconnect = true;
692 }
693
Linus Torvalds1da177e2005-04-16 15:20:36 -0700694 if (rc) {
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700695 mutex_unlock(&cfile->fh_mutex);
Joe Perchesf96637b2013-05-04 22:12:25 -0500696 cifs_dbg(FYI, "cifs_reopen returned 0x%x\n", rc);
697 cifs_dbg(FYI, "oplock: %d\n", oplock);
Jeff Layton15886172010-10-15 15:33:59 -0400698 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699 }
Jeff Layton15886172010-10-15 15:33:59 -0400700
701reopen_success:
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700702 cfile->invalidHandle = false;
703 mutex_unlock(&cfile->fh_mutex);
704 cinode = CIFS_I(inode);
Jeff Layton15886172010-10-15 15:33:59 -0400705
706 if (can_flush) {
707 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -0400708 mapping_set_error(inode->i_mapping, rc);
Jeff Layton15886172010-10-15 15:33:59 -0400709
Jeff Layton15886172010-10-15 15:33:59 -0400710 if (tcon->unix_ext)
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700711 rc = cifs_get_inode_info_unix(&inode, full_path,
712 inode->i_sb, xid);
Jeff Layton15886172010-10-15 15:33:59 -0400713 else
Pavel Shilovsky2ae78ba2012-09-18 16:20:27 -0700714 rc = cifs_get_inode_info(&inode, full_path, NULL,
715 inode->i_sb, xid, NULL);
716 }
717 /*
718 * Else we are writing out data to server already and could deadlock if
719 * we tried to flush data, and since we do not know if we have data that
720 * would invalidate the current end of file on the server we can not go
721 * to the server to get the new inode info.
722 */
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300723
Pavel Shilovsky9cbc0b72013-07-09 18:40:58 +0400724 server->ops->set_fid(cfile, &cfile->fid, oplock);
725 if (oparms.reconnect)
726 cifs_relock_file(cfile);
Jeff Layton15886172010-10-15 15:33:59 -0400727
728reopen_error_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700729 kfree(full_path);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400730 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700731 return rc;
732}
733
734int cifs_close(struct inode *inode, struct file *file)
735{
Jeff Layton77970692011-04-05 16:23:47 -0700736 if (file->private_data != NULL) {
737 cifsFileInfo_put(file->private_data);
738 file->private_data = NULL;
739 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740
Steve Frenchcdff08e2010-10-21 22:46:14 +0000741 /* return code from the ->release op is always ignored */
742 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700743}
744
745int cifs_closedir(struct inode *inode, struct file *file)
746{
747 int rc = 0;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400748 unsigned int xid;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -0700749 struct cifsFileInfo *cfile = file->private_data;
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700750 struct cifs_tcon *tcon;
751 struct TCP_Server_Info *server;
752 char *buf;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
Joe Perchesf96637b2013-05-04 22:12:25 -0500754 cifs_dbg(FYI, "Closedir inode = 0x%p\n", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700756 if (cfile == NULL)
757 return rc;
758
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400759 xid = get_xid();
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700760 tcon = tlink_tcon(cfile->tlink);
761 server = tcon->ses->server;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
Joe Perchesf96637b2013-05-04 22:12:25 -0500763 cifs_dbg(FYI, "Freeing private data in close dir\n");
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700764 spin_lock(&cifs_file_list_lock);
765 if (!cfile->srch_inf.endOfSearch && !cfile->invalidHandle) {
766 cfile->invalidHandle = true;
767 spin_unlock(&cifs_file_list_lock);
768 if (server->ops->close_dir)
769 rc = server->ops->close_dir(xid, tcon, &cfile->fid);
770 else
771 rc = -ENOSYS;
Joe Perchesf96637b2013-05-04 22:12:25 -0500772 cifs_dbg(FYI, "Closing uncompleted readdir with rc %d\n", rc);
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700773 /* not much we can do if it fails anyway, ignore rc */
774 rc = 0;
775 } else
776 spin_unlock(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700777
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700778 buf = cfile->srch_inf.ntwrk_buf_start;
779 if (buf) {
Joe Perchesf96637b2013-05-04 22:12:25 -0500780 cifs_dbg(FYI, "closedir free smb buf in srch struct\n");
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700781 cfile->srch_inf.ntwrk_buf_start = NULL;
782 if (cfile->srch_inf.smallBuf)
783 cifs_small_buf_release(buf);
784 else
785 cifs_buf_release(buf);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700786 }
Pavel Shilovsky92fc65a2012-09-18 16:20:32 -0700787
788 cifs_put_tlink(cfile->tlink);
789 kfree(file->private_data);
790 file->private_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700791 /* BB can we lock the filestruct while this is going on? */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +0400792 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 return rc;
794}
795
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400796static struct cifsLockInfo *
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300797cifs_lock_init(__u64 offset, __u64 length, __u8 type)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000798{
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400799 struct cifsLockInfo *lock =
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000800 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400801 if (!lock)
802 return lock;
803 lock->offset = offset;
804 lock->length = length;
805 lock->type = type;
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400806 lock->pid = current->tgid;
807 INIT_LIST_HEAD(&lock->blist);
808 init_waitqueue_head(&lock->block_q);
809 return lock;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400810}
811
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -0700812void
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400813cifs_del_lock_waiters(struct cifsLockInfo *lock)
814{
815 struct cifsLockInfo *li, *tmp;
816 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
817 list_del_init(&li->blist);
818 wake_up(&li->block_q);
819 }
820}
821
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400822#define CIFS_LOCK_OP 0
823#define CIFS_READ_OP 1
824#define CIFS_WRITE_OP 2
825
826/* @rw_check : 0 - no op, 1 - read, 2 - write */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400827static bool
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700828cifs_find_fid_lock_conflict(struct cifs_fid_locks *fdlocks, __u64 offset,
829 __u64 length, __u8 type, struct cifsFileInfo *cfile,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400830 struct cifsLockInfo **conf_lock, int rw_check)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400831{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300832 struct cifsLockInfo *li;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700833 struct cifsFileInfo *cur_cfile = fdlocks->cfile;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300834 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400835
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700836 list_for_each_entry(li, &fdlocks->locks, llist) {
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400837 if (offset + length <= li->offset ||
838 offset >= li->offset + li->length)
839 continue;
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400840 if (rw_check != CIFS_LOCK_OP && current->tgid == li->pid &&
841 server->ops->compare_fids(cfile, cur_cfile)) {
842 /* shared lock prevents write op through the same fid */
843 if (!(li->type & server->vals->shared_lock_type) ||
844 rw_check != CIFS_WRITE_OP)
845 continue;
846 }
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700847 if ((type & server->vals->shared_lock_type) &&
848 ((server->ops->compare_fids(cfile, cur_cfile) &&
849 current->tgid == li->pid) || type == li->type))
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400850 continue;
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700851 if (conf_lock)
852 *conf_lock = li;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700853 return true;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400854 }
855 return false;
856}
857
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700858bool
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300859cifs_find_lock_conflict(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700860 __u8 type, struct cifsLockInfo **conf_lock,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400861 int rw_check)
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400862{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300863 bool rc = false;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700864 struct cifs_fid_locks *cur;
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300865 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300866
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700867 list_for_each_entry(cur, &cinode->llist, llist) {
868 rc = cifs_find_fid_lock_conflict(cur, offset, length, type,
Pavel Shilovsky579f9052012-09-19 06:22:44 -0700869 cfile, conf_lock, rw_check);
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300870 if (rc)
871 break;
872 }
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300873
874 return rc;
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400875}
876
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300877/*
878 * Check if there is another lock that prevents us to set the lock (mandatory
879 * style). If such a lock exists, update the flock structure with its
880 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
881 * or leave it the same if we can't. Returns 0 if we don't need to request to
882 * the server or 1 otherwise.
883 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400884static int
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300885cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
886 __u8 type, struct file_lock *flock)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400887{
888 int rc = 0;
889 struct cifsLockInfo *conf_lock;
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300890 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300891 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400892 bool exist;
893
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700894 down_read(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400895
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300896 exist = cifs_find_lock_conflict(cfile, offset, length, type,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400897 &conf_lock, CIFS_LOCK_OP);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400898 if (exist) {
899 flock->fl_start = conf_lock->offset;
900 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
901 flock->fl_pid = conf_lock->pid;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300902 if (conf_lock->type & server->vals->shared_lock_type)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400903 flock->fl_type = F_RDLCK;
904 else
905 flock->fl_type = F_WRLCK;
906 } else if (!cinode->can_cache_brlcks)
907 rc = 1;
908 else
909 flock->fl_type = F_UNLCK;
910
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700911 up_read(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400912 return rc;
913}
914
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400915static void
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300916cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400917{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300918 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700919 down_write(&cinode->lock_sem);
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700920 list_add_tail(&lock->llist, &cfile->llist->locks);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700921 up_write(&cinode->lock_sem);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000922}
923
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300924/*
925 * Set the byte-range lock (mandatory style). Returns:
926 * 1) 0, if we set the lock and don't need to request to the server;
927 * 2) 1, if no locks prevent us but we need to request to the server;
928 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
929 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400930static int
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300931cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400932 bool wait)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400933{
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400934 struct cifsLockInfo *conf_lock;
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300935 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400936 bool exist;
937 int rc = 0;
938
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400939try_again:
940 exist = false;
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700941 down_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400942
Pavel Shilovsky55157df2012-02-28 14:04:17 +0300943 exist = cifs_find_lock_conflict(cfile, lock->offset, lock->length,
Pavel Shilovsky081c0412012-11-27 18:38:53 +0400944 lock->type, &conf_lock, CIFS_LOCK_OP);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400945 if (!exist && cinode->can_cache_brlcks) {
Pavel Shilovskyf45d3412012-09-19 06:22:43 -0700946 list_add_tail(&lock->llist, &cfile->llist->locks);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700947 up_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400948 return rc;
949 }
950
951 if (!exist)
952 rc = 1;
953 else if (!wait)
954 rc = -EACCES;
955 else {
956 list_add_tail(&lock->blist, &conf_lock->blist);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700957 up_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400958 rc = wait_event_interruptible(lock->block_q,
959 (lock->blist.prev == &lock->blist) &&
960 (lock->blist.next == &lock->blist));
961 if (!rc)
962 goto try_again;
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700963 down_write(&cinode->lock_sem);
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400964 list_del_init(&lock->blist);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400965 }
966
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700967 up_write(&cinode->lock_sem);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400968 return rc;
969}
970
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300971/*
972 * Check if there is another lock that prevents us to set the lock (posix
973 * style). If such a lock exists, update the flock structure with its
974 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
975 * or leave it the same if we can't. Returns 0 if we don't need to request to
976 * the server or 1 otherwise.
977 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400978static int
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400979cifs_posix_lock_test(struct file *file, struct file_lock *flock)
980{
981 int rc = 0;
Al Viro496ad9a2013-01-23 17:07:38 -0500982 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400983 unsigned char saved_type = flock->fl_type;
984
Pavel Shilovsky50792762011-10-29 17:17:57 +0400985 if ((flock->fl_flags & FL_POSIX) == 0)
986 return 1;
987
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700988 down_read(&cinode->lock_sem);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400989 posix_test_lock(file, flock);
990
991 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
992 flock->fl_type = saved_type;
993 rc = 1;
994 }
995
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -0700996 up_read(&cinode->lock_sem);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400997 return rc;
998}
999
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +03001000/*
1001 * Set the byte-range lock (posix style). Returns:
1002 * 1) 0, if we set the lock and don't need to request to the server;
1003 * 2) 1, if we need to request to the server;
1004 * 3) <0, if the error occurs while setting the lock.
1005 */
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001006static int
1007cifs_posix_lock_set(struct file *file, struct file_lock *flock)
1008{
Al Viro496ad9a2013-01-23 17:07:38 -05001009 struct cifsInodeInfo *cinode = CIFS_I(file_inode(file));
Pavel Shilovsky50792762011-10-29 17:17:57 +04001010 int rc = 1;
1011
1012 if ((flock->fl_flags & FL_POSIX) == 0)
1013 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001014
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001015try_again:
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001016 down_write(&cinode->lock_sem);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001017 if (!cinode->can_cache_brlcks) {
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001018 up_write(&cinode->lock_sem);
Pavel Shilovsky50792762011-10-29 17:17:57 +04001019 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001020 }
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001021
1022 rc = posix_lock_file(file, flock, NULL);
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001023 up_write(&cinode->lock_sem);
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001024 if (rc == FILE_LOCK_DEFERRED) {
1025 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
1026 if (!rc)
1027 goto try_again;
Jeff Layton1a9e64a2013-06-21 08:58:10 -04001028 posix_unblock_lock(flock);
Pavel Shilovsky66189be2012-03-28 21:56:19 +04001029 }
Steve French9ebb3892012-04-01 13:52:54 -05001030 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001031}
1032
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001033int
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001034cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001035{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001036 unsigned int xid;
1037 int rc = 0, stored_rc;
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001038 struct cifsLockInfo *li, *tmp;
1039 struct cifs_tcon *tcon;
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001040 unsigned int num, max_num, max_buf;
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001041 LOCKING_ANDX_RANGE *buf, *cur;
1042 int types[] = {LOCKING_ANDX_LARGE_FILES,
1043 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1044 int i;
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001045
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001046 xid = get_xid();
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001047 tcon = tlink_tcon(cfile->tlink);
1048
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001049 /*
1050 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1051 * and check it for zero before using.
1052 */
1053 max_buf = tcon->ses->server->maxBuf;
1054 if (!max_buf) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001055 free_xid(xid);
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001056 return -EINVAL;
1057 }
1058
1059 max_num = (max_buf - sizeof(struct smb_hdr)) /
1060 sizeof(LOCKING_ANDX_RANGE);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001061 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1062 if (!buf) {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001063 free_xid(xid);
Pavel Shilovskye2f28862012-08-29 21:13:38 +04001064 return -ENOMEM;
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001065 }
1066
1067 for (i = 0; i < 2; i++) {
1068 cur = buf;
1069 num = 0;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001070 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001071 if (li->type != types[i])
1072 continue;
1073 cur->Pid = cpu_to_le16(li->pid);
1074 cur->LengthLow = cpu_to_le32((u32)li->length);
1075 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1076 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1077 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1078 if (++num == max_num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001079 stored_rc = cifs_lockv(xid, tcon,
1080 cfile->fid.netfid,
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001081 (__u8)li->type, 0, num,
1082 buf);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001083 if (stored_rc)
1084 rc = stored_rc;
1085 cur = buf;
1086 num = 0;
1087 } else
1088 cur++;
1089 }
1090
1091 if (num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001092 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001093 (__u8)types[i], 0, num, buf);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001094 if (stored_rc)
1095 rc = stored_rc;
1096 }
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001097 }
1098
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +04001099 kfree(buf);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001100 free_xid(xid);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001101 return rc;
1102}
1103
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001104/* copied from fs/locks.c with a name change */
1105#define cifs_for_each_lock(inode, lockp) \
1106 for (lockp = &inode->i_flock; *lockp != NULL; \
1107 lockp = &(*lockp)->fl_next)
1108
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001109struct lock_to_push {
1110 struct list_head llist;
1111 __u64 offset;
1112 __u64 length;
1113 __u32 pid;
1114 __u16 netfid;
1115 __u8 type;
1116};
1117
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001118static int
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001119cifs_push_posix_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001120{
Jeff Layton1c8c6012013-06-21 08:58:15 -04001121 struct inode *inode = cfile->dentry->d_inode;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001122 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1123 struct file_lock *flock, **before;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001124 unsigned int count = 0, i = 0;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001125 int rc = 0, xid, type;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001126 struct list_head locks_to_send, *el;
1127 struct lock_to_push *lck, *tmp;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001128 __u64 length;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001129
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001130 xid = get_xid();
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001131
Jeff Layton1c8c6012013-06-21 08:58:15 -04001132 spin_lock(&inode->i_lock);
1133 cifs_for_each_lock(inode, before) {
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001134 if ((*before)->fl_flags & FL_POSIX)
1135 count++;
1136 }
Jeff Layton1c8c6012013-06-21 08:58:15 -04001137 spin_unlock(&inode->i_lock);
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001138
1139 INIT_LIST_HEAD(&locks_to_send);
1140
1141 /*
Pavel Shilovskyce858522012-03-17 09:46:55 +03001142 * Allocating count locks is enough because no FL_POSIX locks can be
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001143 * added to the list while we are holding cinode->lock_sem that
Pavel Shilovskyce858522012-03-17 09:46:55 +03001144 * protects locking operations of this inode.
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001145 */
1146 for (; i < count; i++) {
1147 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
1148 if (!lck) {
1149 rc = -ENOMEM;
1150 goto err_out;
1151 }
1152 list_add_tail(&lck->llist, &locks_to_send);
1153 }
1154
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001155 el = locks_to_send.next;
Jeff Layton1c8c6012013-06-21 08:58:15 -04001156 spin_lock(&inode->i_lock);
1157 cifs_for_each_lock(inode, before) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001158 flock = *before;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001159 if ((flock->fl_flags & FL_POSIX) == 0)
1160 continue;
Pavel Shilovskyce858522012-03-17 09:46:55 +03001161 if (el == &locks_to_send) {
1162 /*
1163 * The list ended. We don't have enough allocated
1164 * structures - something is really wrong.
1165 */
Joe Perchesf96637b2013-05-04 22:12:25 -05001166 cifs_dbg(VFS, "Can't push all brlocks!\n");
Pavel Shilovskyce858522012-03-17 09:46:55 +03001167 break;
1168 }
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001169 length = 1 + flock->fl_end - flock->fl_start;
1170 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1171 type = CIFS_RDLCK;
1172 else
1173 type = CIFS_WRLCK;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001174 lck = list_entry(el, struct lock_to_push, llist);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001175 lck->pid = flock->fl_pid;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001176 lck->netfid = cfile->fid.netfid;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001177 lck->length = length;
1178 lck->type = type;
1179 lck->offset = flock->fl_start;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001180 el = el->next;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001181 }
Jeff Layton1c8c6012013-06-21 08:58:15 -04001182 spin_unlock(&inode->i_lock);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001183
1184 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001185 int stored_rc;
1186
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001187 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
Jeff Laytonc5fd3632012-07-23 13:28:37 -04001188 lck->offset, lck->length, NULL,
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001189 lck->type, 0);
1190 if (stored_rc)
1191 rc = stored_rc;
1192 list_del(&lck->llist);
1193 kfree(lck);
1194 }
1195
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001196out:
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001197 free_xid(xid);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001198 return rc;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001199err_out:
1200 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1201 list_del(&lck->llist);
1202 kfree(lck);
1203 }
1204 goto out;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001205}
1206
1207static int
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001208cifs_push_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky9ec3c882012-11-22 17:00:10 +04001209{
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001210 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
Pavel Shilovsky9ec3c882012-11-22 17:00:10 +04001211 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001212 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky9ec3c882012-11-22 17:00:10 +04001213 int rc = 0;
1214
1215 /* we are going to update can_cache_brlcks here - need a write access */
1216 down_write(&cinode->lock_sem);
1217 if (!cinode->can_cache_brlcks) {
1218 up_write(&cinode->lock_sem);
1219 return rc;
1220 }
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001221
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001222 if (cap_unix(tcon->ses) &&
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001223 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1224 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001225 rc = cifs_push_posix_locks(cfile);
1226 else
1227 rc = tcon->ses->server->ops->push_mand_locks(cfile);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001228
Pavel Shilovskyb8db9282012-11-22 17:07:16 +04001229 cinode->can_cache_brlcks = false;
1230 up_write(&cinode->lock_sem);
1231 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001232}
1233
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001234static void
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001235cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001236 bool *wait_flag, struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001237{
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001238 if (flock->fl_flags & FL_POSIX)
Joe Perchesf96637b2013-05-04 22:12:25 -05001239 cifs_dbg(FYI, "Posix\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001240 if (flock->fl_flags & FL_FLOCK)
Joe Perchesf96637b2013-05-04 22:12:25 -05001241 cifs_dbg(FYI, "Flock\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001242 if (flock->fl_flags & FL_SLEEP) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001243 cifs_dbg(FYI, "Blocking lock\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001244 *wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001245 }
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001246 if (flock->fl_flags & FL_ACCESS)
Joe Perchesf96637b2013-05-04 22:12:25 -05001247 cifs_dbg(FYI, "Process suspended by mandatory locking - not implemented yet\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001248 if (flock->fl_flags & FL_LEASE)
Joe Perchesf96637b2013-05-04 22:12:25 -05001249 cifs_dbg(FYI, "Lease on file - not implemented yet\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001250 if (flock->fl_flags &
Jeff Layton3d6d8542012-09-19 06:22:46 -07001251 (~(FL_POSIX | FL_FLOCK | FL_SLEEP |
1252 FL_ACCESS | FL_LEASE | FL_CLOSE)))
Joe Perchesf96637b2013-05-04 22:12:25 -05001253 cifs_dbg(FYI, "Unknown lock flags 0x%x\n", flock->fl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001255 *type = server->vals->large_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001256 if (flock->fl_type == F_WRLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001257 cifs_dbg(FYI, "F_WRLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001258 *type |= server->vals->exclusive_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001259 *lock = 1;
1260 } else if (flock->fl_type == F_UNLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001261 cifs_dbg(FYI, "F_UNLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001262 *type |= server->vals->unlock_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001263 *unlock = 1;
1264 /* Check if unlock includes more than one lock range */
1265 } else if (flock->fl_type == F_RDLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001266 cifs_dbg(FYI, "F_RDLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001267 *type |= server->vals->shared_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001268 *lock = 1;
1269 } else if (flock->fl_type == F_EXLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001270 cifs_dbg(FYI, "F_EXLCK\n");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001271 *type |= server->vals->exclusive_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001272 *lock = 1;
1273 } else if (flock->fl_type == F_SHLCK) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001274 cifs_dbg(FYI, "F_SHLCK\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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001277 } else
Joe Perchesf96637b2013-05-04 22:12:25 -05001278 cifs_dbg(FYI, "Unknown type of lock\n");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001279}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001280
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001281static int
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001282cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001283 bool wait_flag, bool posix_lck, unsigned int xid)
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001284{
1285 int rc = 0;
1286 __u64 length = 1 + flock->fl_end - flock->fl_start;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001287 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1288 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001289 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001290 __u16 netfid = cfile->fid.netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001291
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001292 if (posix_lck) {
1293 int posix_lock_type;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001294
1295 rc = cifs_posix_lock_test(file, flock);
1296 if (!rc)
1297 return rc;
1298
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001299 if (type & server->vals->shared_lock_type)
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001300 posix_lock_type = CIFS_RDLCK;
1301 else
1302 posix_lock_type = CIFS_WRLCK;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001303 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
Jeff Laytonc5fd3632012-07-23 13:28:37 -04001304 flock->fl_start, length, flock,
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001305 posix_lock_type, wait_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001306 return rc;
1307 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001308
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001309 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001310 if (!rc)
1311 return rc;
1312
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001313 /* BB we could chain these into one lock request BB */
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001314 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length, type,
1315 1, 0, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001316 if (rc == 0) {
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001317 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1318 type, 0, 1, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001319 flock->fl_type = F_UNLCK;
1320 if (rc != 0)
Joe Perchesf96637b2013-05-04 22:12:25 -05001321 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1322 rc);
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001323 return 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001324 }
1325
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001326 if (type & server->vals->shared_lock_type) {
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001327 flock->fl_type = F_WRLCK;
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001328 return 0;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001329 }
1330
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001331 type &= ~server->vals->exclusive_lock_type;
1332
1333 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1334 type | server->vals->shared_lock_type,
1335 1, 0, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001336 if (rc == 0) {
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001337 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1338 type | server->vals->shared_lock_type, 0, 1, false);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001339 flock->fl_type = F_RDLCK;
1340 if (rc != 0)
Joe Perchesf96637b2013-05-04 22:12:25 -05001341 cifs_dbg(VFS, "Error unlocking previously locked range %d during test of lock\n",
1342 rc);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001343 } else
1344 flock->fl_type = F_WRLCK;
1345
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001346 return 0;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001347}
1348
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -07001349void
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001350cifs_move_llist(struct list_head *source, struct list_head *dest)
1351{
1352 struct list_head *li, *tmp;
1353 list_for_each_safe(li, tmp, source)
1354 list_move(li, dest);
1355}
1356
Pavel Shilovskyf7ba7fe2012-09-19 06:22:43 -07001357void
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001358cifs_free_llist(struct list_head *llist)
1359{
1360 struct cifsLockInfo *li, *tmp;
1361 list_for_each_entry_safe(li, tmp, llist, llist) {
1362 cifs_del_lock_waiters(li);
1363 list_del(&li->llist);
1364 kfree(li);
1365 }
1366}
1367
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001368int
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001369cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock,
1370 unsigned int xid)
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001371{
1372 int rc = 0, stored_rc;
1373 int types[] = {LOCKING_ANDX_LARGE_FILES,
1374 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1375 unsigned int i;
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001376 unsigned int max_num, num, max_buf;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001377 LOCKING_ANDX_RANGE *buf, *cur;
1378 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1379 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1380 struct cifsLockInfo *li, *tmp;
1381 __u64 length = 1 + flock->fl_end - flock->fl_start;
1382 struct list_head tmp_llist;
1383
1384 INIT_LIST_HEAD(&tmp_llist);
1385
Pavel Shilovsky0013fb42012-05-31 13:03:26 +04001386 /*
1387 * Accessing maxBuf is racy with cifs_reconnect - need to store value
1388 * and check it for zero before using.
1389 */
1390 max_buf = tcon->ses->server->maxBuf;
1391 if (!max_buf)
1392 return -EINVAL;
1393
1394 max_num = (max_buf - sizeof(struct smb_hdr)) /
1395 sizeof(LOCKING_ANDX_RANGE);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001396 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1397 if (!buf)
1398 return -ENOMEM;
1399
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001400 down_write(&cinode->lock_sem);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001401 for (i = 0; i < 2; i++) {
1402 cur = buf;
1403 num = 0;
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001404 list_for_each_entry_safe(li, tmp, &cfile->llist->locks, llist) {
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001405 if (flock->fl_start > li->offset ||
1406 (flock->fl_start + length) <
1407 (li->offset + li->length))
1408 continue;
1409 if (current->tgid != li->pid)
1410 continue;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001411 if (types[i] != li->type)
1412 continue;
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001413 if (cinode->can_cache_brlcks) {
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001414 /*
1415 * We can cache brlock requests - simply remove
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001416 * a lock from the file's list.
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001417 */
1418 list_del(&li->llist);
1419 cifs_del_lock_waiters(li);
1420 kfree(li);
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001421 continue;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001422 }
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001423 cur->Pid = cpu_to_le16(li->pid);
1424 cur->LengthLow = cpu_to_le32((u32)li->length);
1425 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
1426 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1427 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
1428 /*
1429 * We need to save a lock here to let us add it again to
1430 * the file's list if the unlock range request fails on
1431 * the server.
1432 */
1433 list_move(&li->llist, &tmp_llist);
1434 if (++num == max_num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001435 stored_rc = cifs_lockv(xid, tcon,
1436 cfile->fid.netfid,
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001437 li->type, num, 0, buf);
1438 if (stored_rc) {
1439 /*
1440 * We failed on the unlock range
1441 * request - add all locks from the tmp
1442 * list to the head of the file's list.
1443 */
1444 cifs_move_llist(&tmp_llist,
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001445 &cfile->llist->locks);
Pavel Shilovskyea319d52012-05-31 13:59:36 +04001446 rc = stored_rc;
1447 } else
1448 /*
1449 * The unlock range request succeed -
1450 * free the tmp list.
1451 */
1452 cifs_free_llist(&tmp_llist);
1453 cur = buf;
1454 num = 0;
1455 } else
1456 cur++;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001457 }
1458 if (num) {
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001459 stored_rc = cifs_lockv(xid, tcon, cfile->fid.netfid,
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001460 types[i], num, 0, buf);
1461 if (stored_rc) {
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001462 cifs_move_llist(&tmp_llist,
1463 &cfile->llist->locks);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001464 rc = stored_rc;
1465 } else
1466 cifs_free_llist(&tmp_llist);
1467 }
1468 }
1469
Pavel Shilovsky1b4b55a2012-09-19 06:22:44 -07001470 up_write(&cinode->lock_sem);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001471 kfree(buf);
1472 return rc;
1473}
1474
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001475static int
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001476cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001477 bool wait_flag, bool posix_lck, int lock, int unlock,
1478 unsigned int xid)
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001479{
1480 int rc = 0;
1481 __u64 length = 1 + flock->fl_end - flock->fl_start;
1482 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1483 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001484 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04001485 struct inode *inode = cfile->dentry->d_inode;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001486
1487 if (posix_lck) {
Steve French08547b02006-02-28 22:39:25 +00001488 int posix_lock_type;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001489
1490 rc = cifs_posix_lock_set(file, flock);
1491 if (!rc || rc < 0)
1492 return rc;
1493
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001494 if (type & server->vals->shared_lock_type)
Steve French08547b02006-02-28 22:39:25 +00001495 posix_lock_type = CIFS_RDLCK;
1496 else
1497 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +00001498
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001499 if (unlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +00001500 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001501
Pavel Shilovskyf45d3412012-09-19 06:22:43 -07001502 rc = CIFSSMBPosixLock(xid, tcon, cfile->fid.netfid,
1503 current->tgid, flock->fl_start, length,
1504 NULL, posix_lock_type, wait_flag);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001505 goto out;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001506 }
1507
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001508 if (lock) {
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001509 struct cifsLockInfo *lock;
1510
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001511 lock = cifs_lock_init(flock->fl_start, length, type);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001512 if (!lock)
1513 return -ENOMEM;
1514
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001515 rc = cifs_lock_add_if(cfile, lock, wait_flag);
Pavel Shilovsky21cb2d92012-11-22 18:56:39 +04001516 if (rc < 0) {
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001517 kfree(lock);
Pavel Shilovsky21cb2d92012-11-22 18:56:39 +04001518 return rc;
1519 }
1520 if (!rc)
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001521 goto out;
1522
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04001523 /*
1524 * Windows 7 server can delay breaking lease from read to None
1525 * if we set a byte-range lock on a file - break it explicitly
1526 * before sending the lock to the server to be sure the next
1527 * read won't conflict with non-overlapted locks due to
1528 * pagereading.
1529 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001530 if (!CIFS_CACHE_WRITE(CIFS_I(inode)) &&
1531 CIFS_CACHE_READ(CIFS_I(inode))) {
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04001532 cifs_invalidate_mapping(inode);
Joe Perchesf96637b2013-05-04 22:12:25 -05001533 cifs_dbg(FYI, "Set no oplock for inode=%p due to mand locks\n",
1534 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04001535 CIFS_I(inode)->oplock = 0;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04001536 }
1537
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001538 rc = server->ops->mand_lock(xid, cfile, flock->fl_start, length,
1539 type, 1, 0, wait_flag);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001540 if (rc) {
1541 kfree(lock);
Pavel Shilovsky21cb2d92012-11-22 18:56:39 +04001542 return rc;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001543 }
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001544
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001545 cifs_lock_add(cfile, lock);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001546 } else if (unlock)
Pavel Shilovskyd39a4f72012-09-19 06:22:43 -07001547 rc = server->ops->mand_unlock_range(cfile, flock, xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001548
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001549out:
1550 if (flock->fl_flags & FL_POSIX)
Steve French9ebb3892012-04-01 13:52:54 -05001551 posix_lock_file_wait(file, flock);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001552 return rc;
1553}
1554
1555int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1556{
1557 int rc, xid;
1558 int lock = 0, unlock = 0;
1559 bool wait_flag = false;
1560 bool posix_lck = false;
1561 struct cifs_sb_info *cifs_sb;
1562 struct cifs_tcon *tcon;
1563 struct cifsInodeInfo *cinode;
1564 struct cifsFileInfo *cfile;
1565 __u16 netfid;
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001566 __u32 type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001567
1568 rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001569 xid = get_xid();
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001570
Joe Perchesf96637b2013-05-04 22:12:25 -05001571 cifs_dbg(FYI, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld end: %lld\n",
1572 cmd, flock->fl_flags, flock->fl_type,
1573 flock->fl_start, flock->fl_end);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001574
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001575 cfile = (struct cifsFileInfo *)file->private_data;
1576 tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001577
1578 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1579 tcon->ses->server);
1580
1581 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Pavel Shilovsky4b4de762012-09-18 16:20:26 -07001582 netfid = cfile->fid.netfid;
Al Viro496ad9a2013-01-23 17:07:38 -05001583 cinode = CIFS_I(file_inode(file));
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001584
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04001585 if (cap_unix(tcon->ses) &&
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001586 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1587 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1588 posix_lck = true;
1589 /*
1590 * BB add code here to normalize offset and length to account for
1591 * negative length which we can not accept over the wire.
1592 */
1593 if (IS_GETLK(cmd)) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001594 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001595 free_xid(xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001596 return rc;
1597 }
1598
1599 if (!lock && !unlock) {
1600 /*
1601 * if no lock or unlock then nothing to do since we do not
1602 * know what it is
1603 */
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001604 free_xid(xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001605 return -EOPNOTSUPP;
1606 }
1607
1608 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1609 xid);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001610 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 return rc;
1612}
1613
Jeff Layton597b0272012-03-23 14:40:56 -04001614/*
1615 * update the file size (if needed) after a write. Should be called with
1616 * the inode->i_lock held
1617 */
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05001618void
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001619cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1620 unsigned int bytes_written)
1621{
1622 loff_t end_of_write = offset + bytes_written;
1623
1624 if (end_of_write > cifsi->server_eof)
1625 cifsi->server_eof = end_of_write;
1626}
1627
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001628static ssize_t
1629cifs_write(struct cifsFileInfo *open_file, __u32 pid, const char *write_data,
1630 size_t write_size, loff_t *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001631{
1632 int rc = 0;
1633 unsigned int bytes_written = 0;
1634 unsigned int total_written;
1635 struct cifs_sb_info *cifs_sb;
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001636 struct cifs_tcon *tcon;
1637 struct TCP_Server_Info *server;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001638 unsigned int xid;
Jeff Layton7da4b492010-10-15 15:34:00 -04001639 struct dentry *dentry = open_file->dentry;
1640 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001641 struct cifs_io_parms io_parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642
Jeff Layton7da4b492010-10-15 15:34:00 -04001643 cifs_sb = CIFS_SB(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644
Joe Perchesf96637b2013-05-04 22:12:25 -05001645 cifs_dbg(FYI, "write %zd bytes to offset %lld of %s\n",
1646 write_size, *offset, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001648 tcon = tlink_tcon(open_file->tlink);
1649 server = tcon->ses->server;
1650
1651 if (!server->ops->sync_write)
1652 return -ENOSYS;
Steve French50c2f752007-07-13 00:33:32 +00001653
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001654 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001655
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 for (total_written = 0; write_size > total_written;
1657 total_written += bytes_written) {
1658 rc = -EAGAIN;
1659 while (rc == -EAGAIN) {
Jeff Laytonca83ce32011-04-12 09:13:44 -04001660 struct kvec iov[2];
1661 unsigned int len;
1662
Linus Torvalds1da177e2005-04-16 15:20:36 -07001663 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 /* we could deadlock if we called
1665 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001666 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 server now */
Jeff Layton15886172010-10-15 15:33:59 -04001668 rc = cifs_reopen_file(open_file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 if (rc != 0)
1670 break;
1671 }
Steve French3e844692005-10-03 13:37:24 -07001672
Jeff Laytonca83ce32011-04-12 09:13:44 -04001673 len = min((size_t)cifs_sb->wsize,
1674 write_size - total_written);
1675 /* iov[0] is reserved for smb header */
1676 iov[1].iov_base = (char *)write_data + total_written;
1677 iov[1].iov_len = len;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001678 io_parms.pid = pid;
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001679 io_parms.tcon = tcon;
1680 io_parms.offset = *offset;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001681 io_parms.length = len;
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001682 rc = server->ops->sync_write(xid, open_file, &io_parms,
1683 &bytes_written, iov, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001684 }
1685 if (rc || (bytes_written == 0)) {
1686 if (total_written)
1687 break;
1688 else {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001689 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001690 return rc;
1691 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001692 } else {
Jeff Layton597b0272012-03-23 14:40:56 -04001693 spin_lock(&dentry->d_inode->i_lock);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001694 cifs_update_eof(cifsi, *offset, bytes_written);
Jeff Layton597b0272012-03-23 14:40:56 -04001695 spin_unlock(&dentry->d_inode->i_lock);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001696 *offset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001697 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001698 }
1699
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001700 cifs_stats_bytes_written(tcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001701
Jeff Layton7da4b492010-10-15 15:34:00 -04001702 if (total_written > 0) {
1703 spin_lock(&dentry->d_inode->i_lock);
Pavel Shilovskyba9ad7252012-09-18 16:20:30 -07001704 if (*offset > dentry->d_inode->i_size)
1705 i_size_write(dentry->d_inode, *offset);
Jeff Layton7da4b492010-10-15 15:34:00 -04001706 spin_unlock(&dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 }
Jeff Layton7da4b492010-10-15 15:34:00 -04001708 mark_inode_dirty_sync(dentry->d_inode);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04001709 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710 return total_written;
1711}
1712
Jeff Layton6508d902010-09-29 19:51:11 -04001713struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1714 bool fsuid_only)
Steve French630f3f0c2007-10-25 21:17:17 +00001715{
1716 struct cifsFileInfo *open_file = NULL;
Jeff Layton6508d902010-09-29 19:51:11 -04001717 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1718
1719 /* only filter by fsuid on multiuser mounts */
1720 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1721 fsuid_only = false;
Steve French630f3f0c2007-10-25 21:17:17 +00001722
Jeff Layton44772882010-10-15 15:34:03 -04001723 spin_lock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001724 /* we could simply get the first_list_entry since write-only entries
1725 are always at the end of the list but since the first entry might
1726 have a close pending, we go through the whole list */
1727 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Eric W. Biedermanfef59fd2013-02-06 02:23:02 -08001728 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
Jeff Layton6508d902010-09-29 19:51:11 -04001729 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001730 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
Steve French630f3f0c2007-10-25 21:17:17 +00001731 if (!open_file->invalidHandle) {
1732 /* found a good file */
1733 /* lock it so it will not be closed on us */
Jeff Layton764a1b12012-07-25 14:59:54 -04001734 cifsFileInfo_get_locked(open_file);
Jeff Layton44772882010-10-15 15:34:03 -04001735 spin_unlock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001736 return open_file;
1737 } /* else might as well continue, and look for
1738 another, or simply have the caller reopen it
1739 again rather than trying to fix this handle */
1740 } else /* write only file */
1741 break; /* write only files are last so must be done */
1742 }
Jeff Layton44772882010-10-15 15:34:03 -04001743 spin_unlock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001744 return NULL;
1745}
Steve French630f3f0c2007-10-25 21:17:17 +00001746
Jeff Layton6508d902010-09-29 19:51:11 -04001747struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1748 bool fsuid_only)
Steve French6148a742005-10-05 12:23:19 -07001749{
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001750 struct cifsFileInfo *open_file, *inv_file = NULL;
Jeff Laytond3892292010-11-02 16:22:50 -04001751 struct cifs_sb_info *cifs_sb;
Jeff Layton2846d382008-09-22 21:33:33 -04001752 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001753 int rc;
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001754 unsigned int refind = 0;
Steve French6148a742005-10-05 12:23:19 -07001755
Steve French60808232006-04-22 15:53:05 +00001756 /* Having a null inode here (because mapping->host was set to zero by
1757 the VFS or MM) should not happen but we had reports of on oops (due to
1758 it being zero) during stress testcases so we need to check for it */
1759
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001760 if (cifs_inode == NULL) {
Joe Perchesf96637b2013-05-04 22:12:25 -05001761 cifs_dbg(VFS, "Null inode passed to cifs_writeable_file\n");
Steve French60808232006-04-22 15:53:05 +00001762 dump_stack();
1763 return NULL;
1764 }
1765
Jeff Laytond3892292010-11-02 16:22:50 -04001766 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1767
Jeff Layton6508d902010-09-29 19:51:11 -04001768 /* only filter by fsuid on multiuser mounts */
1769 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1770 fsuid_only = false;
1771
Jeff Layton44772882010-10-15 15:34:03 -04001772 spin_lock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001773refind_writable:
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001774 if (refind > MAX_REOPEN_ATT) {
1775 spin_unlock(&cifs_file_list_lock);
1776 return NULL;
1777 }
Steve French6148a742005-10-05 12:23:19 -07001778 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton6508d902010-09-29 19:51:11 -04001779 if (!any_available && open_file->pid != current->tgid)
1780 continue;
Eric W. Biedermanfef59fd2013-02-06 02:23:02 -08001781 if (fsuid_only && !uid_eq(open_file->uid, current_fsuid()))
Jeff Layton6508d902010-09-29 19:51:11 -04001782 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001783 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Steve French9b22b0b2007-10-02 01:11:08 +00001784 if (!open_file->invalidHandle) {
1785 /* found a good writable file */
Jeff Layton764a1b12012-07-25 14:59:54 -04001786 cifsFileInfo_get_locked(open_file);
Jeff Layton44772882010-10-15 15:34:03 -04001787 spin_unlock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001788 return open_file;
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001789 } else {
1790 if (!inv_file)
1791 inv_file = open_file;
Steve French9b22b0b2007-10-02 01:11:08 +00001792 }
Steve French6148a742005-10-05 12:23:19 -07001793 }
1794 }
Jeff Layton2846d382008-09-22 21:33:33 -04001795 /* couldn't find useable FH with same pid, try any available */
1796 if (!any_available) {
1797 any_available = true;
1798 goto refind_writable;
1799 }
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001800
1801 if (inv_file) {
1802 any_available = false;
Jeff Layton764a1b12012-07-25 14:59:54 -04001803 cifsFileInfo_get_locked(inv_file);
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001804 }
1805
Jeff Layton44772882010-10-15 15:34:03 -04001806 spin_unlock(&cifs_file_list_lock);
Shirish Pargaonkar2c0c2a02012-05-21 09:20:12 -05001807
1808 if (inv_file) {
1809 rc = cifs_reopen_file(inv_file, false);
1810 if (!rc)
1811 return inv_file;
1812 else {
1813 spin_lock(&cifs_file_list_lock);
1814 list_move_tail(&inv_file->flist,
1815 &cifs_inode->openFileList);
1816 spin_unlock(&cifs_file_list_lock);
1817 cifsFileInfo_put(inv_file);
1818 spin_lock(&cifs_file_list_lock);
1819 ++refind;
1820 goto refind_writable;
1821 }
1822 }
1823
Steve French6148a742005-10-05 12:23:19 -07001824 return NULL;
1825}
1826
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1828{
1829 struct address_space *mapping = page->mapping;
1830 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1831 char *write_data;
1832 int rc = -EFAULT;
1833 int bytes_written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001835 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836
1837 if (!mapping || !mapping->host)
1838 return -EFAULT;
1839
1840 inode = page->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841
1842 offset += (loff_t)from;
1843 write_data = kmap(page);
1844 write_data += from;
1845
1846 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1847 kunmap(page);
1848 return -EIO;
1849 }
1850
1851 /* racing with truncate? */
1852 if (offset > mapping->host->i_size) {
1853 kunmap(page);
1854 return 0; /* don't care */
1855 }
1856
1857 /* check to make sure that we are not extending the file */
1858 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001859 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001860
Jeff Layton6508d902010-09-29 19:51:11 -04001861 open_file = find_writable_file(CIFS_I(mapping->host), false);
Steve French6148a742005-10-05 12:23:19 -07001862 if (open_file) {
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001863 bytes_written = cifs_write(open_file, open_file->pid,
1864 write_data, to - from, &offset);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001865 cifsFileInfo_put(open_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001867 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001868 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001869 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001870 else if (bytes_written < 0)
1871 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001872 } else {
Joe Perchesf96637b2013-05-04 22:12:25 -05001873 cifs_dbg(FYI, "No writeable filehandles for inode\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001874 rc = -EIO;
1875 }
1876
1877 kunmap(page);
1878 return rc;
1879}
1880
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001882 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883{
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001884 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1885 bool done = false, scanned = false, range_whole = false;
1886 pgoff_t end, index;
1887 struct cifs_writedata *wdata;
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -07001888 struct TCP_Server_Info *server;
Steve French37c0eb42005-10-05 14:50:29 -07001889 struct page *page;
Steve French37c0eb42005-10-05 14:50:29 -07001890 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00001891
Steve French37c0eb42005-10-05 14:50:29 -07001892 /*
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001893 * If wsize is smaller than the page cache size, default to writing
Steve French37c0eb42005-10-05 14:50:29 -07001894 * one page at a time via cifs_writepage
1895 */
1896 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1897 return generic_writepages(mapping, wbc);
1898
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001899 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001900 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001901 end = -1;
1902 } else {
1903 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1904 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1905 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001906 range_whole = true;
1907 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07001908 }
1909retry:
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001910 while (!done && index <= end) {
1911 unsigned int i, nr_pages, found_pages;
1912 pgoff_t next = 0, tofind;
1913 struct page **pages;
Steve French37c0eb42005-10-05 14:50:29 -07001914
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001915 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1916 end - index) + 1;
Steve French37c0eb42005-10-05 14:50:29 -07001917
Jeff Laytonc2e87642012-03-23 14:40:55 -04001918 wdata = cifs_writedata_alloc((unsigned int)tofind,
1919 cifs_writev_complete);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001920 if (!wdata) {
1921 rc = -ENOMEM;
1922 break;
1923 }
1924
1925 /*
1926 * find_get_pages_tag seems to return a max of 256 on each
1927 * iteration, so we must call it several times in order to
1928 * fill the array or the wsize is effectively limited to
1929 * 256 * PAGE_CACHE_SIZE.
1930 */
1931 found_pages = 0;
1932 pages = wdata->pages;
1933 do {
1934 nr_pages = find_get_pages_tag(mapping, &index,
1935 PAGECACHE_TAG_DIRTY,
1936 tofind, pages);
1937 found_pages += nr_pages;
1938 tofind -= nr_pages;
1939 pages += nr_pages;
1940 } while (nr_pages && tofind && index <= end);
1941
1942 if (found_pages == 0) {
1943 kref_put(&wdata->refcount, cifs_writedata_release);
1944 break;
1945 }
1946
1947 nr_pages = 0;
1948 for (i = 0; i < found_pages; i++) {
1949 page = wdata->pages[i];
Steve French37c0eb42005-10-05 14:50:29 -07001950 /*
1951 * At this point we hold neither mapping->tree_lock nor
1952 * lock on the page itself: the page may be truncated or
1953 * invalidated (changing page->mapping to NULL), or even
1954 * swizzled back from swapper_space to tmpfs file
1955 * mapping
1956 */
1957
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001958 if (nr_pages == 0)
Steve French37c0eb42005-10-05 14:50:29 -07001959 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001960 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001961 break;
1962
1963 if (unlikely(page->mapping != mapping)) {
1964 unlock_page(page);
1965 break;
1966 }
1967
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001968 if (!wbc->range_cyclic && page->index > end) {
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001969 done = true;
Steve French37c0eb42005-10-05 14:50:29 -07001970 unlock_page(page);
1971 break;
1972 }
1973
1974 if (next && (page->index != next)) {
1975 /* Not next consecutive page */
1976 unlock_page(page);
1977 break;
1978 }
1979
1980 if (wbc->sync_mode != WB_SYNC_NONE)
1981 wait_on_page_writeback(page);
1982
1983 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001984 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001985 unlock_page(page);
1986 break;
1987 }
Steve French84d2f072005-10-12 15:32:05 -07001988
Linus Torvaldscb876f42006-12-23 16:19:07 -08001989 /*
1990 * This actually clears the dirty bit in the radix tree.
1991 * See cifs_writepage() for more commentary.
1992 */
1993 set_page_writeback(page);
1994
Jeff Layton3a98b862012-11-26 09:48:41 -05001995 if (page_offset(page) >= i_size_read(mapping->host)) {
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001996 done = true;
Steve French84d2f072005-10-12 15:32:05 -07001997 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001998 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001999 break;
2000 }
2001
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002002 wdata->pages[i] = page;
Steve French37c0eb42005-10-05 14:50:29 -07002003 next = page->index + 1;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002004 ++nr_pages;
Steve French37c0eb42005-10-05 14:50:29 -07002005 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002006
2007 /* reset index to refind any pages skipped */
2008 if (nr_pages == 0)
2009 index = wdata->pages[0]->index + 1;
2010
2011 /* put any pages we aren't going to use */
2012 for (i = nr_pages; i < found_pages; i++) {
2013 page_cache_release(wdata->pages[i]);
2014 wdata->pages[i] = NULL;
2015 }
2016
2017 /* nothing to write? */
2018 if (nr_pages == 0) {
2019 kref_put(&wdata->refcount, cifs_writedata_release);
2020 continue;
2021 }
2022
2023 wdata->sync_mode = wbc->sync_mode;
2024 wdata->nr_pages = nr_pages;
2025 wdata->offset = page_offset(wdata->pages[0]);
Jeff Laytoneddb0792012-09-18 16:20:35 -07002026 wdata->pagesz = PAGE_CACHE_SIZE;
2027 wdata->tailsz =
Jeff Layton3a98b862012-11-26 09:48:41 -05002028 min(i_size_read(mapping->host) -
2029 page_offset(wdata->pages[nr_pages - 1]),
Jeff Laytoneddb0792012-09-18 16:20:35 -07002030 (loff_t)PAGE_CACHE_SIZE);
2031 wdata->bytes = ((nr_pages - 1) * PAGE_CACHE_SIZE) +
2032 wdata->tailsz;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002033
2034 do {
2035 if (wdata->cfile != NULL)
2036 cifsFileInfo_put(wdata->cfile);
2037 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
2038 false);
2039 if (!wdata->cfile) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002040 cifs_dbg(VFS, "No writable handles for inode\n");
Steve French23e7dd72005-10-20 13:44:56 -07002041 rc = -EBADF;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002042 break;
Steve French37c0eb42005-10-05 14:50:29 -07002043 }
Jeff Laytonfe5f5d22012-03-23 14:40:55 -04002044 wdata->pid = wdata->cfile->pid;
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -07002045 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
Steve French4a5c80d2014-02-07 20:45:12 -06002046 rc = server->ops->async_writev(wdata,
2047 cifs_writedata_release);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002048 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
Jeff Laytonf3983c22010-09-22 16:17:40 -07002049
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002050 for (i = 0; i < nr_pages; ++i)
2051 unlock_page(wdata->pages[i]);
Jeff Layton941b8532011-01-11 07:24:01 -05002052
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002053 /* send failure -- clean up the mess */
2054 if (rc != 0) {
2055 for (i = 0; i < nr_pages; ++i) {
Jeff Layton941b8532011-01-11 07:24:01 -05002056 if (rc == -EAGAIN)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002057 redirty_page_for_writepage(wbc,
2058 wdata->pages[i]);
2059 else
2060 SetPageError(wdata->pages[i]);
2061 end_page_writeback(wdata->pages[i]);
2062 page_cache_release(wdata->pages[i]);
Steve French37c0eb42005-10-05 14:50:29 -07002063 }
Jeff Layton941b8532011-01-11 07:24:01 -05002064 if (rc != -EAGAIN)
2065 mapping_set_error(mapping, rc);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002066 }
2067 kref_put(&wdata->refcount, cifs_writedata_release);
Jeff Layton941b8532011-01-11 07:24:01 -05002068
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002069 wbc->nr_to_write -= nr_pages;
2070 if (wbc->nr_to_write <= 0)
2071 done = true;
Dave Kleikampb066a482008-11-18 03:49:05 +00002072
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002073 index = next;
Steve French37c0eb42005-10-05 14:50:29 -07002074 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002075
Steve French37c0eb42005-10-05 14:50:29 -07002076 if (!scanned && !done) {
2077 /*
2078 * We hit the last page and there is more work to be done: wrap
2079 * back to the start of the file
2080 */
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002081 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07002082 index = 0;
2083 goto retry;
2084 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002085
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07002086 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07002087 mapping->writeback_index = index;
2088
Linus Torvalds1da177e2005-04-16 15:20:36 -07002089 return rc;
2090}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002092static int
2093cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094{
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002095 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002096 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002098 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002099/* BB add check for wbc flags */
2100 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00002101 if (!PageUptodate(page))
Joe Perchesf96637b2013-05-04 22:12:25 -05002102 cifs_dbg(FYI, "ppw - page not up to date\n");
Linus Torvaldscb876f42006-12-23 16:19:07 -08002103
2104 /*
2105 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2106 *
2107 * A writepage() implementation always needs to do either this,
2108 * or re-dirty the page with "redirty_page_for_writepage()" in
2109 * the case of a failure.
2110 *
2111 * Just unlocking the page will cause the radix tree tag-bits
2112 * to fail to update with the state of the page correctly.
2113 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002114 set_page_writeback(page);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002115retry_write:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002117 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2118 goto retry_write;
2119 else if (rc == -EAGAIN)
2120 redirty_page_for_writepage(wbc, page);
2121 else if (rc != 0)
2122 SetPageError(page);
2123 else
2124 SetPageUptodate(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08002125 end_page_writeback(page);
2126 page_cache_release(page);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002127 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002128 return rc;
2129}
2130
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002131static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2132{
2133 int rc = cifs_writepage_locked(page, wbc);
2134 unlock_page(page);
2135 return rc;
2136}
2137
Nick Piggind9414772008-09-24 11:32:59 -04002138static int cifs_write_end(struct file *file, struct address_space *mapping,
2139 loff_t pos, unsigned len, unsigned copied,
2140 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002141{
Nick Piggind9414772008-09-24 11:32:59 -04002142 int rc;
2143 struct inode *inode = mapping->host;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002144 struct cifsFileInfo *cfile = file->private_data;
2145 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2146 __u32 pid;
2147
2148 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2149 pid = cfile->pid;
2150 else
2151 pid = current->tgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002152
Joe Perchesf96637b2013-05-04 22:12:25 -05002153 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002154 page, pos, copied);
Steve Frenchad7a2922008-02-07 23:25:02 +00002155
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002156 if (PageChecked(page)) {
2157 if (copied == len)
2158 SetPageUptodate(page);
2159 ClearPageChecked(page);
2160 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04002161 SetPageUptodate(page);
2162
Linus Torvalds1da177e2005-04-16 15:20:36 -07002163 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04002164 char *page_data;
2165 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002166 unsigned int xid;
Nick Piggind9414772008-09-24 11:32:59 -04002167
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002168 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002169 /* this is probably better than directly calling
2170 partialpage_write since in this function the file handle is
2171 known which we might as well leverage */
2172 /* BB check if anything else missing out of ppw
2173 such as updating last write time */
2174 page_data = kmap(page);
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002175 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
Nick Piggind9414772008-09-24 11:32:59 -04002176 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002177 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04002178
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002179 free_xid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002180 } else {
Nick Piggind9414772008-09-24 11:32:59 -04002181 rc = copied;
2182 pos += copied;
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002183 set_page_dirty(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184 }
2185
Nick Piggind9414772008-09-24 11:32:59 -04002186 if (rc > 0) {
2187 spin_lock(&inode->i_lock);
2188 if (pos > inode->i_size)
2189 i_size_write(inode, pos);
2190 spin_unlock(&inode->i_lock);
2191 }
2192
2193 unlock_page(page);
2194 page_cache_release(page);
2195
Linus Torvalds1da177e2005-04-16 15:20:36 -07002196 return rc;
2197}
2198
Josef Bacik02c24a82011-07-16 20:44:56 -04002199int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2200 int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002201{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002202 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00002204 struct cifs_tcon *tcon;
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002205 struct TCP_Server_Info *server;
Joe Perchesc21dfb62010-07-12 13:50:14 -07002206 struct cifsFileInfo *smbfile = file->private_data;
Al Viro496ad9a2013-01-23 17:07:38 -05002207 struct inode *inode = file_inode(file);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002208 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002209
Josef Bacik02c24a82011-07-16 20:44:56 -04002210 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2211 if (rc)
2212 return rc;
2213 mutex_lock(&inode->i_mutex);
2214
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002215 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002216
Joe Perchesf96637b2013-05-04 22:12:25 -05002217 cifs_dbg(FYI, "Sync file - name: %s datasync: 0x%x\n",
2218 file->f_path.dentry->d_name.name, datasync);
Steve French50c2f752007-07-13 00:33:32 +00002219
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002220 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002221 rc = cifs_invalidate_mapping(inode);
2222 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002223 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002224 rc = 0; /* don't care about it in fsync */
2225 }
2226 }
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002227
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002228 tcon = tlink_tcon(smbfile->tlink);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002229 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2230 server = tcon->ses->server;
2231 if (server->ops->flush)
2232 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2233 else
2234 rc = -ENOSYS;
2235 }
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002236
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002237 free_xid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04002238 mutex_unlock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002239 return rc;
2240}
2241
Josef Bacik02c24a82011-07-16 20:44:56 -04002242int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002243{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002244 unsigned int xid;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002245 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00002246 struct cifs_tcon *tcon;
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002247 struct TCP_Server_Info *server;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002248 struct cifsFileInfo *smbfile = file->private_data;
2249 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Josef Bacik02c24a82011-07-16 20:44:56 -04002250 struct inode *inode = file->f_mapping->host;
2251
2252 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2253 if (rc)
2254 return rc;
2255 mutex_lock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002256
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002257 xid = get_xid();
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002258
Joe Perchesf96637b2013-05-04 22:12:25 -05002259 cifs_dbg(FYI, "Sync file - name: %s datasync: 0x%x\n",
2260 file->f_path.dentry->d_name.name, datasync);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002261
2262 tcon = tlink_tcon(smbfile->tlink);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002263 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2264 server = tcon->ses->server;
2265 if (server->ops->flush)
2266 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2267 else
2268 rc = -ENOSYS;
2269 }
Steve Frenchb298f222009-02-21 21:17:43 +00002270
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002271 free_xid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04002272 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002273 return rc;
2274}
2275
Linus Torvalds1da177e2005-04-16 15:20:36 -07002276/*
2277 * As file closes, flush all cached write data for this inode checking
2278 * for write behind errors.
2279 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07002280int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002281{
Al Viro496ad9a2013-01-23 17:07:38 -05002282 struct inode *inode = file_inode(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 int rc = 0;
2284
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002285 if (file->f_mode & FMODE_WRITE)
Jeff Laytond3f13222010-10-15 15:34:07 -04002286 rc = filemap_write_and_wait(inode->i_mapping);
Steve French50c2f752007-07-13 00:33:32 +00002287
Joe Perchesf96637b2013-05-04 22:12:25 -05002288 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289
2290 return rc;
2291}
2292
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002293static int
2294cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2295{
2296 int rc = 0;
2297 unsigned long i;
2298
2299 for (i = 0; i < num_pages; i++) {
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002300 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002301 if (!pages[i]) {
2302 /*
2303 * save number of pages we have already allocated and
2304 * return with ENOMEM error
2305 */
2306 num_pages = i;
2307 rc = -ENOMEM;
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002308 break;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002309 }
2310 }
2311
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002312 if (rc) {
2313 for (i = 0; i < num_pages; i++)
2314 put_page(pages[i]);
2315 }
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002316 return rc;
2317}
2318
2319static inline
2320size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2321{
2322 size_t num_pages;
2323 size_t clen;
2324
2325 clen = min_t(const size_t, len, wsize);
Jeff Laytona7103b92012-03-23 14:40:56 -04002326 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002327
2328 if (cur_len)
2329 *cur_len = clen;
2330
2331 return num_pages;
2332}
2333
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002334static void
Steve French4a5c80d2014-02-07 20:45:12 -06002335cifs_uncached_writedata_release(struct kref *refcount)
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002336{
2337 int i;
Steve French4a5c80d2014-02-07 20:45:12 -06002338 struct cifs_writedata *wdata = container_of(refcount,
2339 struct cifs_writedata, refcount);
2340
2341 for (i = 0; i < wdata->nr_pages; i++)
2342 put_page(wdata->pages[i]);
2343 cifs_writedata_release(refcount);
2344}
2345
2346static void
2347cifs_uncached_writev_complete(struct work_struct *work)
2348{
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002349 struct cifs_writedata *wdata = container_of(work,
2350 struct cifs_writedata, work);
2351 struct inode *inode = wdata->cfile->dentry->d_inode;
2352 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2353
2354 spin_lock(&inode->i_lock);
2355 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2356 if (cifsi->server_eof > inode->i_size)
2357 i_size_write(inode, cifsi->server_eof);
2358 spin_unlock(&inode->i_lock);
2359
2360 complete(&wdata->done);
2361
Steve French4a5c80d2014-02-07 20:45:12 -06002362 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002363}
2364
2365/* attempt to send write to server, retry on any -EAGAIN errors */
2366static int
2367cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2368{
2369 int rc;
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -07002370 struct TCP_Server_Info *server;
2371
2372 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002373
2374 do {
2375 if (wdata->cfile->invalidHandle) {
2376 rc = cifs_reopen_file(wdata->cfile, false);
2377 if (rc != 0)
2378 continue;
2379 }
Steve French4a5c80d2014-02-07 20:45:12 -06002380 rc = server->ops->async_writev(wdata,
2381 cifs_uncached_writedata_release);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002382 } while (rc == -EAGAIN);
2383
2384 return rc;
2385}
2386
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002387static ssize_t
2388cifs_iovec_write(struct file *file, const struct iovec *iov,
2389 unsigned long nr_segs, loff_t *poffset)
2390{
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002391 unsigned long nr_pages, i;
Jeff Layton5d81de82014-02-14 07:20:35 -05002392 size_t bytes, copied, len, cur_len;
Pavel Shilovsky76429c12011-01-31 16:03:08 +03002393 ssize_t total_written = 0;
Jeff Layton3af9d8f2012-04-13 17:16:59 -04002394 loff_t offset;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002395 struct iov_iter it;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002396 struct cifsFileInfo *open_file;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002397 struct cifs_tcon *tcon;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002398 struct cifs_sb_info *cifs_sb;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002399 struct cifs_writedata *wdata, *tmp;
2400 struct list_head wdata_list;
2401 int rc;
2402 pid_t pid;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002403
2404 len = iov_length(iov, nr_segs);
2405 if (!len)
2406 return 0;
2407
2408 rc = generic_write_checks(file, poffset, &len, 0);
2409 if (rc)
2410 return rc;
2411
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002412 INIT_LIST_HEAD(&wdata_list);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002413 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002414 open_file = file->private_data;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002415 tcon = tlink_tcon(open_file->tlink);
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -07002416
2417 if (!tcon->ses->server->ops->async_writev)
2418 return -ENOSYS;
2419
Jeff Layton3af9d8f2012-04-13 17:16:59 -04002420 offset = *poffset;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002421
2422 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2423 pid = open_file->pid;
2424 else
2425 pid = current->tgid;
2426
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002427 iov_iter_init(&it, iov, nr_segs, len, 0);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002428 do {
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002429 size_t save_len;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002430
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002431 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2432 wdata = cifs_writedata_alloc(nr_pages,
2433 cifs_uncached_writev_complete);
2434 if (!wdata) {
2435 rc = -ENOMEM;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002436 break;
2437 }
2438
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002439 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2440 if (rc) {
2441 kfree(wdata);
2442 break;
2443 }
2444
2445 save_len = cur_len;
2446 for (i = 0; i < nr_pages; i++) {
Jeff Layton5d81de82014-02-14 07:20:35 -05002447 bytes = min_t(const size_t, cur_len, PAGE_SIZE);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002448 copied = iov_iter_copy_from_user(wdata->pages[i], &it,
Jeff Layton5d81de82014-02-14 07:20:35 -05002449 0, bytes);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002450 cur_len -= copied;
2451 iov_iter_advance(&it, copied);
Jeff Layton5d81de82014-02-14 07:20:35 -05002452 /*
2453 * If we didn't copy as much as we expected, then that
2454 * may mean we trod into an unmapped area. Stop copying
2455 * at that point. On the next pass through the big
2456 * loop, we'll likely end up getting a zero-length
2457 * write and bailing out of it.
2458 */
2459 if (copied < bytes)
2460 break;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002461 }
2462 cur_len = save_len - cur_len;
2463
Jeff Layton5d81de82014-02-14 07:20:35 -05002464 /*
2465 * If we have no data to send, then that probably means that
2466 * the copy above failed altogether. That's most likely because
2467 * the address in the iovec was bogus. Set the rc to -EFAULT,
2468 * free anything we allocated and bail out.
2469 */
2470 if (!cur_len) {
2471 for (i = 0; i < nr_pages; i++)
2472 put_page(wdata->pages[i]);
2473 kfree(wdata);
2474 rc = -EFAULT;
2475 break;
2476 }
2477
2478 /*
2479 * i + 1 now represents the number of pages we actually used in
2480 * the copy phase above. Bring nr_pages down to that, and free
2481 * any pages that we didn't use.
2482 */
2483 for ( ; nr_pages > i + 1; nr_pages--)
2484 put_page(wdata->pages[nr_pages - 1]);
2485
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002486 wdata->sync_mode = WB_SYNC_ALL;
2487 wdata->nr_pages = nr_pages;
2488 wdata->offset = (__u64)offset;
2489 wdata->cfile = cifsFileInfo_get(open_file);
2490 wdata->pid = pid;
2491 wdata->bytes = cur_len;
Jeff Laytoneddb0792012-09-18 16:20:35 -07002492 wdata->pagesz = PAGE_SIZE;
2493 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002494 rc = cifs_uncached_retry_writev(wdata);
2495 if (rc) {
Steve French4a5c80d2014-02-07 20:45:12 -06002496 kref_put(&wdata->refcount,
2497 cifs_uncached_writedata_release);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002498 break;
2499 }
2500
2501 list_add_tail(&wdata->list, &wdata_list);
2502 offset += cur_len;
2503 len -= cur_len;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002504 } while (len > 0);
2505
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002506 /*
2507 * If at least one write was successfully sent, then discard any rc
2508 * value from the later writes. If the other write succeeds, then
2509 * we'll end up returning whatever was written. If it fails, then
2510 * we'll get a new rc value from that.
2511 */
2512 if (!list_empty(&wdata_list))
2513 rc = 0;
2514
2515 /*
2516 * Wait for and collect replies for any successful sends in order of
2517 * increasing offset. Once an error is hit or we get a fatal signal
2518 * while waiting, then return without waiting for any more replies.
2519 */
2520restart_loop:
2521 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2522 if (!rc) {
2523 /* FIXME: freezable too? */
2524 rc = wait_for_completion_killable(&wdata->done);
2525 if (rc)
2526 rc = -EINTR;
2527 else if (wdata->result)
2528 rc = wdata->result;
2529 else
2530 total_written += wdata->bytes;
2531
2532 /* resend call if it's a retryable error */
2533 if (rc == -EAGAIN) {
2534 rc = cifs_uncached_retry_writev(wdata);
2535 goto restart_loop;
2536 }
2537 }
2538 list_del_init(&wdata->list);
Steve French4a5c80d2014-02-07 20:45:12 -06002539 kref_put(&wdata->refcount, cifs_uncached_writedata_release);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002540 }
2541
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002542 if (total_written > 0)
2543 *poffset += total_written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002544
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002545 cifs_stats_bytes_written(tcon, total_written);
2546 return total_written ? total_written : (ssize_t)rc;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002547}
2548
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +03002549ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002550 unsigned long nr_segs, loff_t pos)
2551{
2552 ssize_t written;
2553 struct inode *inode;
2554
Al Viro496ad9a2013-01-23 17:07:38 -05002555 inode = file_inode(iocb->ki_filp);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002556
2557 /*
2558 * BB - optimize the way when signing is disabled. We can drop this
2559 * extra memory-to-memory copying and use iovec buffers for constructing
2560 * write request.
2561 */
2562
2563 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2564 if (written > 0) {
2565 CIFS_I(inode)->invalid_mapping = true;
2566 iocb->ki_pos = pos;
2567 }
2568
2569 return written;
2570}
2571
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002572static ssize_t
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002573cifs_writev(struct kiocb *iocb, const struct iovec *iov,
2574 unsigned long nr_segs, loff_t pos)
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002575{
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002576 struct file *file = iocb->ki_filp;
2577 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2578 struct inode *inode = file->f_mapping->host;
2579 struct cifsInodeInfo *cinode = CIFS_I(inode);
2580 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2581 ssize_t rc = -EACCES;
Pavel Shilovsky6b1168e2014-02-14 13:31:03 +04002582 loff_t lock_pos = pos;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002583
Pavel Shilovsky6b1168e2014-02-14 13:31:03 +04002584 if (file->f_flags & O_APPEND)
2585 lock_pos = i_size_read(inode);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002586 /*
2587 * We need to hold the sem to be sure nobody modifies lock list
2588 * with a brlock that prevents writing.
2589 */
2590 down_read(&cinode->lock_sem);
Pavel Shilovsky6b1168e2014-02-14 13:31:03 +04002591 if (!cifs_find_lock_conflict(cfile, lock_pos, iov_length(iov, nr_segs),
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002592 server->vals->exclusive_lock_type, NULL,
Pavel Shilovsky6b1168e2014-02-14 13:31:03 +04002593 CIFS_WRITE_OP))
2594 rc = generic_file_aio_write(iocb, iov, nr_segs, pos);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002595 up_read(&cinode->lock_sem);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002596 return rc;
2597}
2598
2599ssize_t
2600cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2601 unsigned long nr_segs, loff_t pos)
2602{
Al Viro496ad9a2013-01-23 17:07:38 -05002603 struct inode *inode = file_inode(iocb->ki_filp);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002604 struct cifsInodeInfo *cinode = CIFS_I(inode);
2605 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2606 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2607 iocb->ki_filp->private_data;
2608 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002609 ssize_t written;
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002610
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002611 if (CIFS_CACHE_WRITE(cinode)) {
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002612 if (cap_unix(tcon->ses) &&
2613 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2614 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2615 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2616 return cifs_writev(iocb, iov, nr_segs, pos);
Pavel Shilovskyc299dd02012-12-06 22:07:52 +04002617 }
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002618 /*
2619 * For non-oplocked files in strict cache mode we need to write the data
2620 * to the server exactly from the pos to pos+len-1 rather than flush all
2621 * affected pages because it may cause a error with mandatory locks on
2622 * these pages but not on the region from pos to ppos+len-1.
2623 */
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002624 written = cifs_user_writev(iocb, iov, nr_segs, pos);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002625 if (written > 0 && CIFS_CACHE_READ(cinode)) {
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002626 /*
2627 * Windows 7 server can delay breaking level2 oplock if a write
2628 * request comes - break it on the client to prevent reading
2629 * an old data.
2630 */
2631 cifs_invalidate_mapping(inode);
Joe Perchesf96637b2013-05-04 22:12:25 -05002632 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2633 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002634 cinode->oplock = 0;
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002635 }
2636 return written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002637}
2638
Jeff Layton0471ca32012-05-16 07:13:16 -04002639static struct cifs_readdata *
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002640cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
Jeff Layton0471ca32012-05-16 07:13:16 -04002641{
2642 struct cifs_readdata *rdata;
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002643
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002644 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2645 GFP_KERNEL);
Jeff Layton0471ca32012-05-16 07:13:16 -04002646 if (rdata != NULL) {
Jeff Layton6993f742012-05-16 07:13:17 -04002647 kref_init(&rdata->refcount);
Jeff Layton1c892542012-05-16 07:13:17 -04002648 INIT_LIST_HEAD(&rdata->list);
2649 init_completion(&rdata->done);
Jeff Layton0471ca32012-05-16 07:13:16 -04002650 INIT_WORK(&rdata->work, complete);
Jeff Layton0471ca32012-05-16 07:13:16 -04002651 }
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002652
Jeff Layton0471ca32012-05-16 07:13:16 -04002653 return rdata;
2654}
2655
Jeff Layton6993f742012-05-16 07:13:17 -04002656void
2657cifs_readdata_release(struct kref *refcount)
Jeff Layton0471ca32012-05-16 07:13:16 -04002658{
Jeff Layton6993f742012-05-16 07:13:17 -04002659 struct cifs_readdata *rdata = container_of(refcount,
2660 struct cifs_readdata, refcount);
2661
2662 if (rdata->cfile)
2663 cifsFileInfo_put(rdata->cfile);
2664
Jeff Layton0471ca32012-05-16 07:13:16 -04002665 kfree(rdata);
2666}
2667
Jeff Layton2a1bb132012-05-16 07:13:17 -04002668static int
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002669cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
Jeff Layton1c892542012-05-16 07:13:17 -04002670{
2671 int rc = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002672 struct page *page;
Jeff Layton1c892542012-05-16 07:13:17 -04002673 unsigned int i;
2674
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002675 for (i = 0; i < nr_pages; i++) {
Jeff Layton1c892542012-05-16 07:13:17 -04002676 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2677 if (!page) {
2678 rc = -ENOMEM;
2679 break;
2680 }
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002681 rdata->pages[i] = page;
Jeff Layton1c892542012-05-16 07:13:17 -04002682 }
2683
2684 if (rc) {
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002685 for (i = 0; i < nr_pages; i++) {
2686 put_page(rdata->pages[i]);
2687 rdata->pages[i] = NULL;
Jeff Layton1c892542012-05-16 07:13:17 -04002688 }
2689 }
2690 return rc;
2691}
2692
2693static void
2694cifs_uncached_readdata_release(struct kref *refcount)
2695{
Jeff Layton1c892542012-05-16 07:13:17 -04002696 struct cifs_readdata *rdata = container_of(refcount,
2697 struct cifs_readdata, refcount);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002698 unsigned int i;
Jeff Layton1c892542012-05-16 07:13:17 -04002699
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002700 for (i = 0; i < rdata->nr_pages; i++) {
2701 put_page(rdata->pages[i]);
2702 rdata->pages[i] = NULL;
Jeff Layton1c892542012-05-16 07:13:17 -04002703 }
2704 cifs_readdata_release(refcount);
2705}
2706
2707static int
Jeff Layton2a1bb132012-05-16 07:13:17 -04002708cifs_retry_async_readv(struct cifs_readdata *rdata)
2709{
2710 int rc;
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -07002711 struct TCP_Server_Info *server;
2712
2713 server = tlink_tcon(rdata->cfile->tlink)->ses->server;
Jeff Layton2a1bb132012-05-16 07:13:17 -04002714
2715 do {
2716 if (rdata->cfile->invalidHandle) {
2717 rc = cifs_reopen_file(rdata->cfile, true);
2718 if (rc != 0)
2719 continue;
2720 }
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -07002721 rc = server->ops->async_readv(rdata);
Jeff Layton2a1bb132012-05-16 07:13:17 -04002722 } while (rc == -EAGAIN);
2723
2724 return rc;
2725}
2726
Jeff Layton1c892542012-05-16 07:13:17 -04002727/**
2728 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2729 * @rdata: the readdata response with list of pages holding data
2730 * @iov: vector in which we should copy the data
2731 * @nr_segs: number of segments in vector
2732 * @offset: offset into file of the first iovec
2733 * @copied: used to return the amount of data copied to the iov
2734 *
2735 * This function copies data from a list of pages in a readdata response into
2736 * an array of iovecs. It will first calculate where the data should go
2737 * based on the info in the readdata and then copy the data into that spot.
2738 */
2739static ssize_t
2740cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2741 unsigned long nr_segs, loff_t offset, ssize_t *copied)
2742{
2743 int rc = 0;
2744 struct iov_iter ii;
2745 size_t pos = rdata->offset - offset;
Jeff Layton1c892542012-05-16 07:13:17 -04002746 ssize_t remaining = rdata->bytes;
2747 unsigned char *pdata;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002748 unsigned int i;
Jeff Layton1c892542012-05-16 07:13:17 -04002749
2750 /* set up iov_iter and advance to the correct offset */
2751 iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2752 iov_iter_advance(&ii, pos);
2753
2754 *copied = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002755 for (i = 0; i < rdata->nr_pages; i++) {
Jeff Layton1c892542012-05-16 07:13:17 -04002756 ssize_t copy;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002757 struct page *page = rdata->pages[i];
Jeff Layton1c892542012-05-16 07:13:17 -04002758
2759 /* copy a whole page or whatever's left */
2760 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2761
2762 /* ...but limit it to whatever space is left in the iov */
2763 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2764
2765 /* go while there's data to be copied and no errors */
2766 if (copy && !rc) {
2767 pdata = kmap(page);
2768 rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2769 (int)copy);
2770 kunmap(page);
2771 if (!rc) {
2772 *copied += copy;
2773 remaining -= copy;
2774 iov_iter_advance(&ii, copy);
2775 }
2776 }
Jeff Layton1c892542012-05-16 07:13:17 -04002777 }
2778
2779 return rc;
2780}
2781
2782static void
2783cifs_uncached_readv_complete(struct work_struct *work)
2784{
2785 struct cifs_readdata *rdata = container_of(work,
2786 struct cifs_readdata, work);
Jeff Layton1c892542012-05-16 07:13:17 -04002787
2788 complete(&rdata->done);
2789 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2790}
2791
2792static int
Jeff Layton8321fec2012-09-19 06:22:32 -07002793cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2794 struct cifs_readdata *rdata, unsigned int len)
Jeff Layton1c892542012-05-16 07:13:17 -04002795{
Jeff Layton8321fec2012-09-19 06:22:32 -07002796 int total_read = 0, result = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002797 unsigned int i;
2798 unsigned int nr_pages = rdata->nr_pages;
Jeff Layton8321fec2012-09-19 06:22:32 -07002799 struct kvec iov;
Jeff Layton1c892542012-05-16 07:13:17 -04002800
Jeff Layton8321fec2012-09-19 06:22:32 -07002801 rdata->tailsz = PAGE_SIZE;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002802 for (i = 0; i < nr_pages; i++) {
2803 struct page *page = rdata->pages[i];
2804
Jeff Layton8321fec2012-09-19 06:22:32 -07002805 if (len >= PAGE_SIZE) {
Jeff Layton1c892542012-05-16 07:13:17 -04002806 /* enough data to fill the page */
Jeff Layton8321fec2012-09-19 06:22:32 -07002807 iov.iov_base = kmap(page);
2808 iov.iov_len = PAGE_SIZE;
Joe Perchesf96637b2013-05-04 22:12:25 -05002809 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2810 i, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07002811 len -= PAGE_SIZE;
2812 } else if (len > 0) {
Jeff Layton1c892542012-05-16 07:13:17 -04002813 /* enough for partial page, fill and zero the rest */
Jeff Layton8321fec2012-09-19 06:22:32 -07002814 iov.iov_base = kmap(page);
2815 iov.iov_len = len;
Joe Perchesf96637b2013-05-04 22:12:25 -05002816 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2817 i, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07002818 memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2819 rdata->tailsz = len;
2820 len = 0;
Jeff Layton1c892542012-05-16 07:13:17 -04002821 } else {
2822 /* no need to hold page hostage */
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002823 rdata->pages[i] = NULL;
2824 rdata->nr_pages--;
Jeff Layton1c892542012-05-16 07:13:17 -04002825 put_page(page);
Jeff Layton8321fec2012-09-19 06:22:32 -07002826 continue;
Jeff Layton1c892542012-05-16 07:13:17 -04002827 }
Jeff Layton8321fec2012-09-19 06:22:32 -07002828
2829 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2830 kunmap(page);
2831 if (result < 0)
2832 break;
2833
2834 total_read += result;
Jeff Layton1c892542012-05-16 07:13:17 -04002835 }
2836
Jeff Layton8321fec2012-09-19 06:22:32 -07002837 return total_read > 0 ? total_read : result;
Jeff Layton1c892542012-05-16 07:13:17 -04002838}
2839
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002840static ssize_t
2841cifs_iovec_read(struct file *file, const struct iovec *iov,
2842 unsigned long nr_segs, loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002843{
Jeff Layton1c892542012-05-16 07:13:17 -04002844 ssize_t rc;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002845 size_t len, cur_len;
Jeff Layton1c892542012-05-16 07:13:17 -04002846 ssize_t total_read = 0;
2847 loff_t offset = *poffset;
2848 unsigned int npages;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002849 struct cifs_sb_info *cifs_sb;
Jeff Layton1c892542012-05-16 07:13:17 -04002850 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851 struct cifsFileInfo *open_file;
Jeff Layton1c892542012-05-16 07:13:17 -04002852 struct cifs_readdata *rdata, *tmp;
2853 struct list_head rdata_list;
2854 pid_t pid;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002855
2856 if (!nr_segs)
2857 return 0;
2858
2859 len = iov_length(iov, nr_segs);
2860 if (!len)
2861 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002862
Jeff Layton1c892542012-05-16 07:13:17 -04002863 INIT_LIST_HEAD(&rdata_list);
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002864 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -07002865 open_file = file->private_data;
Jeff Layton1c892542012-05-16 07:13:17 -04002866 tcon = tlink_tcon(open_file->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002867
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -07002868 if (!tcon->ses->server->ops->async_readv)
2869 return -ENOSYS;
2870
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002871 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2872 pid = open_file->pid;
2873 else
2874 pid = current->tgid;
2875
Steve Frenchad7a2922008-02-07 23:25:02 +00002876 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesf96637b2013-05-04 22:12:25 -05002877 cifs_dbg(FYI, "attempting read on write only file instance\n");
Steve Frenchad7a2922008-02-07 23:25:02 +00002878
Jeff Layton1c892542012-05-16 07:13:17 -04002879 do {
2880 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2881 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002882
Jeff Layton1c892542012-05-16 07:13:17 -04002883 /* allocate a readdata struct */
2884 rdata = cifs_readdata_alloc(npages,
2885 cifs_uncached_readv_complete);
2886 if (!rdata) {
2887 rc = -ENOMEM;
2888 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002890
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002891 rc = cifs_read_allocate_pages(rdata, npages);
Jeff Layton1c892542012-05-16 07:13:17 -04002892 if (rc)
2893 goto error;
2894
2895 rdata->cfile = cifsFileInfo_get(open_file);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002896 rdata->nr_pages = npages;
Jeff Layton1c892542012-05-16 07:13:17 -04002897 rdata->offset = offset;
2898 rdata->bytes = cur_len;
2899 rdata->pid = pid;
Jeff Layton8321fec2012-09-19 06:22:32 -07002900 rdata->pagesz = PAGE_SIZE;
2901 rdata->read_into_pages = cifs_uncached_read_into_pages;
Jeff Layton1c892542012-05-16 07:13:17 -04002902
2903 rc = cifs_retry_async_readv(rdata);
2904error:
2905 if (rc) {
2906 kref_put(&rdata->refcount,
2907 cifs_uncached_readdata_release);
2908 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002909 }
Jeff Layton1c892542012-05-16 07:13:17 -04002910
2911 list_add_tail(&rdata->list, &rdata_list);
2912 offset += cur_len;
2913 len -= cur_len;
2914 } while (len > 0);
2915
2916 /* if at least one read request send succeeded, then reset rc */
2917 if (!list_empty(&rdata_list))
2918 rc = 0;
2919
2920 /* the loop below should proceed in the order of increasing offsets */
2921restart_loop:
2922 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2923 if (!rc) {
2924 ssize_t copied;
2925
2926 /* FIXME: freezable sleep too? */
2927 rc = wait_for_completion_killable(&rdata->done);
2928 if (rc)
2929 rc = -EINTR;
2930 else if (rdata->result)
2931 rc = rdata->result;
2932 else {
2933 rc = cifs_readdata_to_iov(rdata, iov,
2934 nr_segs, *poffset,
2935 &copied);
2936 total_read += copied;
2937 }
2938
2939 /* resend call if it's a retryable error */
2940 if (rc == -EAGAIN) {
2941 rc = cifs_retry_async_readv(rdata);
2942 goto restart_loop;
2943 }
2944 }
2945 list_del_init(&rdata->list);
2946 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002947 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002948
Jeff Layton1c892542012-05-16 07:13:17 -04002949 cifs_stats_bytes_read(tcon, total_read);
2950 *poffset += total_read;
2951
Pavel Shilovsky09a47072012-09-18 16:20:29 -07002952 /* mask nodata case */
2953 if (rc == -ENODATA)
2954 rc = 0;
2955
Jeff Layton1c892542012-05-16 07:13:17 -04002956 return total_read ? total_read : rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002957}
2958
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +03002959ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002960 unsigned long nr_segs, loff_t pos)
2961{
2962 ssize_t read;
2963
2964 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2965 if (read > 0)
2966 iocb->ki_pos = pos;
2967
2968 return read;
2969}
2970
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002971ssize_t
2972cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2973 unsigned long nr_segs, loff_t pos)
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002974{
Al Viro496ad9a2013-01-23 17:07:38 -05002975 struct inode *inode = file_inode(iocb->ki_filp);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002976 struct cifsInodeInfo *cinode = CIFS_I(inode);
2977 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2978 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2979 iocb->ki_filp->private_data;
2980 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2981 int rc = -EACCES;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002982
2983 /*
2984 * In strict cache mode we need to read from the server all the time
2985 * if we don't have level II oplock because the server can delay mtime
2986 * change - so we can't make a decision about inode invalidating.
2987 * And we can also fail with pagereading if there are mandatory locks
2988 * on pages affected by this read but not on the region from pos to
2989 * pos+len-1.
2990 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002991 if (!CIFS_CACHE_READ(cinode))
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002992 return cifs_user_readv(iocb, iov, nr_segs, pos);
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002993
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002994 if (cap_unix(tcon->ses) &&
2995 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2996 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2997 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2998
2999 /*
3000 * We need to hold the sem to be sure nobody modifies lock list
3001 * with a brlock that prevents reading.
3002 */
3003 down_read(&cinode->lock_sem);
3004 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
3005 tcon->ses->server->vals->shared_lock_type,
Pavel Shilovsky081c0412012-11-27 18:38:53 +04003006 NULL, CIFS_READ_OP))
Pavel Shilovsky579f9052012-09-19 06:22:44 -07003007 rc = generic_file_aio_read(iocb, iov, nr_segs, pos);
3008 up_read(&cinode->lock_sem);
3009 return rc;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03003010}
Linus Torvalds1da177e2005-04-16 15:20:36 -07003011
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003012static ssize_t
3013cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003014{
3015 int rc = -EACCES;
3016 unsigned int bytes_read = 0;
3017 unsigned int total_read;
3018 unsigned int current_read_size;
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003019 unsigned int rsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003020 struct cifs_sb_info *cifs_sb;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003021 struct cifs_tcon *tcon;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003022 struct TCP_Server_Info *server;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003023 unsigned int xid;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003024 char *cur_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003025 struct cifsFileInfo *open_file;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003026 struct cifs_io_parms io_parms;
Steve Frenchec637e32005-12-12 20:53:18 -08003027 int buf_type = CIFS_NO_BUFFER;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003028 __u32 pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003030 xid = get_xid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08003031 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003032
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003033 /* FIXME: set up handlers for larger reads and/or convert to async */
3034 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3035
Linus Torvalds1da177e2005-04-16 15:20:36 -07003036 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303037 rc = -EBADF;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003038 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303039 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003040 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07003041 open_file = file->private_data;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003042 tcon = tlink_tcon(open_file->tlink);
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003043 server = tcon->ses->server;
3044
3045 if (!server->ops->sync_read) {
3046 free_xid(xid);
3047 return -ENOSYS;
3048 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003049
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003050 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3051 pid = open_file->pid;
3052 else
3053 pid = current->tgid;
3054
Linus Torvalds1da177e2005-04-16 15:20:36 -07003055 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesf96637b2013-05-04 22:12:25 -05003056 cifs_dbg(FYI, "attempting read on write only file instance\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003057
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003058 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3059 total_read += bytes_read, cur_offset += bytes_read) {
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003060 current_read_size = min_t(uint, read_size - total_read, rsize);
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003061 /*
3062 * For windows me and 9x we do not want to request more than it
3063 * negotiated since it will refuse the read then.
3064 */
3065 if ((tcon->ses) && !(tcon->ses->capabilities &
3066 tcon->ses->server->vals->cap_large_files)) {
Dan Carpenter7748dd62011-10-18 12:41:35 +03003067 current_read_size = min_t(uint, current_read_size,
Jeff Laytonc974bef2011-10-11 06:41:32 -04003068 CIFSMaxBufSize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07003069 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070 rc = -EAGAIN;
3071 while (rc == -EAGAIN) {
Steve Frenchcdff08e2010-10-21 22:46:14 +00003072 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04003073 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074 if (rc != 0)
3075 break;
3076 }
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003077 io_parms.pid = pid;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003078 io_parms.tcon = tcon;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003079 io_parms.offset = *offset;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003080 io_parms.length = current_read_size;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003081 rc = server->ops->sync_read(xid, open_file, &io_parms,
3082 &bytes_read, &cur_offset,
3083 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003084 }
3085 if (rc || (bytes_read == 0)) {
3086 if (total_read) {
3087 break;
3088 } else {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003089 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003090 return rc;
3091 }
3092 } else {
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003093 cifs_stats_bytes_read(tcon, total_read);
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003094 *offset += bytes_read;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003095 }
3096 }
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003097 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098 return total_read;
3099}
3100
Jeff Laytonca83ce32011-04-12 09:13:44 -04003101/*
3102 * If the page is mmap'ed into a process' page tables, then we need to make
3103 * sure that it doesn't change while being written back.
3104 */
3105static int
3106cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3107{
3108 struct page *page = vmf->page;
3109
3110 lock_page(page);
3111 return VM_FAULT_LOCKED;
3112}
3113
3114static struct vm_operations_struct cifs_file_vm_ops = {
3115 .fault = filemap_fault,
Kirill A. Shutemovf1820362014-04-07 15:37:19 -07003116 .map_pages = filemap_map_pages,
Jeff Laytonca83ce32011-04-12 09:13:44 -04003117 .page_mkwrite = cifs_page_mkwrite,
Konstantin Khlebnikov0b173bc2012-10-08 16:28:46 -07003118 .remap_pages = generic_file_remap_pages,
Jeff Laytonca83ce32011-04-12 09:13:44 -04003119};
3120
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003121int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3122{
3123 int rc, xid;
Al Viro496ad9a2013-01-23 17:07:38 -05003124 struct inode *inode = file_inode(file);
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003125
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003126 xid = get_xid();
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003127
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003128 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04003129 rc = cifs_invalidate_mapping(inode);
3130 if (rc)
3131 return rc;
3132 }
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003133
3134 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04003135 if (rc == 0)
3136 vma->vm_ops = &cifs_file_vm_ops;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003137 free_xid(xid);
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003138 return rc;
3139}
3140
Linus Torvalds1da177e2005-04-16 15:20:36 -07003141int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3142{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003143 int rc, xid;
3144
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003145 xid = get_xid();
Jeff Laytonabab0952010-02-12 07:44:18 -05003146 rc = cifs_revalidate_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003147 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003148 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3149 rc);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003150 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003151 return rc;
3152 }
3153 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04003154 if (rc == 0)
3155 vma->vm_ops = &cifs_file_vm_ops;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003156 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003157 return rc;
3158}
3159
Jeff Layton0471ca32012-05-16 07:13:16 -04003160static void
3161cifs_readv_complete(struct work_struct *work)
3162{
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003163 unsigned int i;
Jeff Layton0471ca32012-05-16 07:13:16 -04003164 struct cifs_readdata *rdata = container_of(work,
3165 struct cifs_readdata, work);
Jeff Layton0471ca32012-05-16 07:13:16 -04003166
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003167 for (i = 0; i < rdata->nr_pages; i++) {
3168 struct page *page = rdata->pages[i];
3169
Jeff Layton0471ca32012-05-16 07:13:16 -04003170 lru_cache_add_file(page);
3171
3172 if (rdata->result == 0) {
Jeff Layton0471ca32012-05-16 07:13:16 -04003173 flush_dcache_page(page);
3174 SetPageUptodate(page);
3175 }
3176
3177 unlock_page(page);
3178
3179 if (rdata->result == 0)
3180 cifs_readpage_to_fscache(rdata->mapping->host, page);
3181
3182 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003183 rdata->pages[i] = NULL;
Jeff Layton0471ca32012-05-16 07:13:16 -04003184 }
Jeff Layton6993f742012-05-16 07:13:17 -04003185 kref_put(&rdata->refcount, cifs_readdata_release);
Jeff Layton0471ca32012-05-16 07:13:16 -04003186}
3187
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003188static int
Jeff Layton8321fec2012-09-19 06:22:32 -07003189cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3190 struct cifs_readdata *rdata, unsigned int len)
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003191{
Jeff Layton8321fec2012-09-19 06:22:32 -07003192 int total_read = 0, result = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003193 unsigned int i;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003194 u64 eof;
3195 pgoff_t eof_index;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003196 unsigned int nr_pages = rdata->nr_pages;
Jeff Layton8321fec2012-09-19 06:22:32 -07003197 struct kvec iov;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003198
3199 /* determine the eof that the server (probably) has */
3200 eof = CIFS_I(rdata->mapping->host)->server_eof;
3201 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
Joe Perchesf96637b2013-05-04 22:12:25 -05003202 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003203
Jeff Layton8321fec2012-09-19 06:22:32 -07003204 rdata->tailsz = PAGE_CACHE_SIZE;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003205 for (i = 0; i < nr_pages; i++) {
3206 struct page *page = rdata->pages[i];
3207
Jeff Layton8321fec2012-09-19 06:22:32 -07003208 if (len >= PAGE_CACHE_SIZE) {
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003209 /* enough data to fill the page */
Jeff Layton8321fec2012-09-19 06:22:32 -07003210 iov.iov_base = kmap(page);
3211 iov.iov_len = PAGE_CACHE_SIZE;
Joe Perchesf96637b2013-05-04 22:12:25 -05003212 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3213 i, page->index, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07003214 len -= PAGE_CACHE_SIZE;
3215 } else if (len > 0) {
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003216 /* enough for partial page, fill and zero the rest */
Jeff Layton8321fec2012-09-19 06:22:32 -07003217 iov.iov_base = kmap(page);
3218 iov.iov_len = len;
Joe Perchesf96637b2013-05-04 22:12:25 -05003219 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3220 i, page->index, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07003221 memset(iov.iov_base + len,
3222 '\0', PAGE_CACHE_SIZE - len);
3223 rdata->tailsz = len;
3224 len = 0;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003225 } else if (page->index > eof_index) {
3226 /*
3227 * The VFS will not try to do readahead past the
3228 * i_size, but it's possible that we have outstanding
3229 * writes with gaps in the middle and the i_size hasn't
3230 * caught up yet. Populate those with zeroed out pages
3231 * to prevent the VFS from repeatedly attempting to
3232 * fill them until the writes are flushed.
3233 */
3234 zero_user(page, 0, PAGE_CACHE_SIZE);
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003235 lru_cache_add_file(page);
3236 flush_dcache_page(page);
3237 SetPageUptodate(page);
3238 unlock_page(page);
3239 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003240 rdata->pages[i] = NULL;
3241 rdata->nr_pages--;
Jeff Layton8321fec2012-09-19 06:22:32 -07003242 continue;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003243 } else {
3244 /* no need to hold page hostage */
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003245 lru_cache_add_file(page);
3246 unlock_page(page);
3247 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003248 rdata->pages[i] = NULL;
3249 rdata->nr_pages--;
Jeff Layton8321fec2012-09-19 06:22:32 -07003250 continue;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003251 }
Jeff Layton8321fec2012-09-19 06:22:32 -07003252
3253 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3254 kunmap(page);
3255 if (result < 0)
3256 break;
3257
3258 total_read += result;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003259 }
3260
Jeff Layton8321fec2012-09-19 06:22:32 -07003261 return total_read > 0 ? total_read : result;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003262}
3263
Linus Torvalds1da177e2005-04-16 15:20:36 -07003264static int cifs_readpages(struct file *file, struct address_space *mapping,
3265 struct list_head *page_list, unsigned num_pages)
3266{
Jeff Layton690c5e32011-10-19 15:30:16 -04003267 int rc;
3268 struct list_head tmplist;
3269 struct cifsFileInfo *open_file = file->private_data;
3270 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3271 unsigned int rsize = cifs_sb->rsize;
3272 pid_t pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003273
Jeff Layton690c5e32011-10-19 15:30:16 -04003274 /*
3275 * Give up immediately if rsize is too small to read an entire page.
3276 * The VFS will fall back to readpage. We should never reach this
3277 * point however since we set ra_pages to 0 when the rsize is smaller
3278 * than a cache page.
3279 */
3280 if (unlikely(rsize < PAGE_CACHE_SIZE))
3281 return 0;
Steve Frenchbfa0d752005-08-31 21:50:37 -07003282
Suresh Jayaraman56698232010-07-05 18:13:25 +05303283 /*
3284 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3285 * immediately if the cookie is negative
David Howells54afa992013-09-04 17:10:39 +00003286 *
3287 * After this point, every page in the list might have PG_fscache set,
3288 * so we will need to clean that up off of every page we don't use.
Suresh Jayaraman56698232010-07-05 18:13:25 +05303289 */
3290 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3291 &num_pages);
3292 if (rc == 0)
Jeff Layton690c5e32011-10-19 15:30:16 -04003293 return rc;
Suresh Jayaraman56698232010-07-05 18:13:25 +05303294
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003295 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3296 pid = open_file->pid;
3297 else
3298 pid = current->tgid;
3299
Jeff Layton690c5e32011-10-19 15:30:16 -04003300 rc = 0;
3301 INIT_LIST_HEAD(&tmplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003302
Joe Perchesf96637b2013-05-04 22:12:25 -05003303 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3304 __func__, file, mapping, num_pages);
Jeff Layton690c5e32011-10-19 15:30:16 -04003305
3306 /*
3307 * Start with the page at end of list and move it to private
3308 * list. Do the same with any following pages until we hit
3309 * the rsize limit, hit an index discontinuity, or run out of
3310 * pages. Issue the async read and then start the loop again
3311 * until the list is empty.
3312 *
3313 * Note that list order is important. The page_list is in
3314 * the order of declining indexes. When we put the pages in
3315 * the rdata->pages, then we want them in increasing order.
3316 */
3317 while (!list_empty(page_list)) {
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003318 unsigned int i;
Jeff Layton690c5e32011-10-19 15:30:16 -04003319 unsigned int bytes = PAGE_CACHE_SIZE;
3320 unsigned int expected_index;
3321 unsigned int nr_pages = 1;
3322 loff_t offset;
3323 struct page *page, *tpage;
3324 struct cifs_readdata *rdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003325
3326 page = list_entry(page_list->prev, struct page, lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003327
Jeff Layton690c5e32011-10-19 15:30:16 -04003328 /*
3329 * Lock the page and put it in the cache. Since no one else
3330 * should have access to this page, we're safe to simply set
3331 * PG_locked without checking it first.
3332 */
3333 __set_page_locked(page);
3334 rc = add_to_page_cache_locked(page, mapping,
3335 page->index, GFP_KERNEL);
3336
3337 /* give up if we can't stick it in the cache */
3338 if (rc) {
3339 __clear_page_locked(page);
3340 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003341 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003342
Jeff Layton690c5e32011-10-19 15:30:16 -04003343 /* move first page to the tmplist */
3344 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3345 list_move_tail(&page->lru, &tmplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003346
Jeff Layton690c5e32011-10-19 15:30:16 -04003347 /* now try and add more pages onto the request */
3348 expected_index = page->index + 1;
3349 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3350 /* discontinuity ? */
3351 if (page->index != expected_index)
3352 break;
3353
3354 /* would this page push the read over the rsize? */
3355 if (bytes + PAGE_CACHE_SIZE > rsize)
3356 break;
3357
3358 __set_page_locked(page);
3359 if (add_to_page_cache_locked(page, mapping,
3360 page->index, GFP_KERNEL)) {
3361 __clear_page_locked(page);
3362 break;
3363 }
3364 list_move_tail(&page->lru, &tmplist);
3365 bytes += PAGE_CACHE_SIZE;
3366 expected_index++;
3367 nr_pages++;
3368 }
3369
Jeff Layton0471ca32012-05-16 07:13:16 -04003370 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
Jeff Layton690c5e32011-10-19 15:30:16 -04003371 if (!rdata) {
3372 /* best to give up if we're out of mem */
3373 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3374 list_del(&page->lru);
3375 lru_cache_add_file(page);
3376 unlock_page(page);
3377 page_cache_release(page);
3378 }
3379 rc = -ENOMEM;
3380 break;
3381 }
3382
Jeff Layton6993f742012-05-16 07:13:17 -04003383 rdata->cfile = cifsFileInfo_get(open_file);
Jeff Layton690c5e32011-10-19 15:30:16 -04003384 rdata->mapping = mapping;
3385 rdata->offset = offset;
3386 rdata->bytes = bytes;
3387 rdata->pid = pid;
Jeff Layton8321fec2012-09-19 06:22:32 -07003388 rdata->pagesz = PAGE_CACHE_SIZE;
3389 rdata->read_into_pages = cifs_readpages_read_into_pages;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003390
3391 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3392 list_del(&page->lru);
3393 rdata->pages[rdata->nr_pages++] = page;
3394 }
Jeff Layton690c5e32011-10-19 15:30:16 -04003395
Jeff Layton2a1bb132012-05-16 07:13:17 -04003396 rc = cifs_retry_async_readv(rdata);
Jeff Layton690c5e32011-10-19 15:30:16 -04003397 if (rc != 0) {
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003398 for (i = 0; i < rdata->nr_pages; i++) {
3399 page = rdata->pages[i];
Jeff Layton690c5e32011-10-19 15:30:16 -04003400 lru_cache_add_file(page);
3401 unlock_page(page);
3402 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003403 }
Jeff Layton6993f742012-05-16 07:13:17 -04003404 kref_put(&rdata->refcount, cifs_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003405 break;
3406 }
Jeff Layton6993f742012-05-16 07:13:17 -04003407
3408 kref_put(&rdata->refcount, cifs_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409 }
3410
David Howells54afa992013-09-04 17:10:39 +00003411 /* Any pages that have been shown to fscache but didn't get added to
3412 * the pagecache must be uncached before they get returned to the
3413 * allocator.
3414 */
3415 cifs_fscache_readpages_cancel(mapping->host, page_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003416 return rc;
3417}
3418
Sachin Prabhua9e9b7b2013-09-13 14:11:56 +01003419/*
3420 * cifs_readpage_worker must be called with the page pinned
3421 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003422static int cifs_readpage_worker(struct file *file, struct page *page,
3423 loff_t *poffset)
3424{
3425 char *read_data;
3426 int rc;
3427
Suresh Jayaraman56698232010-07-05 18:13:25 +05303428 /* Is the page cached? */
Al Viro496ad9a2013-01-23 17:07:38 -05003429 rc = cifs_readpage_from_fscache(file_inode(file), page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05303430 if (rc == 0)
3431 goto read_complete;
3432
Linus Torvalds1da177e2005-04-16 15:20:36 -07003433 read_data = kmap(page);
3434 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003435
Linus Torvalds1da177e2005-04-16 15:20:36 -07003436 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003437
Linus Torvalds1da177e2005-04-16 15:20:36 -07003438 if (rc < 0)
3439 goto io_error;
3440 else
Joe Perchesf96637b2013-05-04 22:12:25 -05003441 cifs_dbg(FYI, "Bytes read %d\n", rc);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003442
Al Viro496ad9a2013-01-23 17:07:38 -05003443 file_inode(file)->i_atime =
3444 current_fs_time(file_inode(file)->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003445
Linus Torvalds1da177e2005-04-16 15:20:36 -07003446 if (PAGE_CACHE_SIZE > rc)
3447 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3448
3449 flush_dcache_page(page);
3450 SetPageUptodate(page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05303451
3452 /* send this page to the cache */
Al Viro496ad9a2013-01-23 17:07:38 -05003453 cifs_readpage_to_fscache(file_inode(file), page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05303454
Linus Torvalds1da177e2005-04-16 15:20:36 -07003455 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003456
Linus Torvalds1da177e2005-04-16 15:20:36 -07003457io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003458 kunmap(page);
Sachin Prabhu466bd312013-09-13 14:11:57 +01003459 unlock_page(page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05303460
3461read_complete:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003462 return rc;
3463}
3464
3465static int cifs_readpage(struct file *file, struct page *page)
3466{
3467 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3468 int rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003469 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003470
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003471 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003472
3473 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303474 rc = -EBADF;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003475 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303476 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003477 }
3478
Joe Perchesf96637b2013-05-04 22:12:25 -05003479 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003480 page, (int)offset, (int)offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003481
3482 rc = cifs_readpage_worker(file, page, &offset);
3483
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003484 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003485 return rc;
3486}
3487
Steve Frencha403a0a2007-07-26 15:54:16 +00003488static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3489{
3490 struct cifsFileInfo *open_file;
3491
Jeff Layton44772882010-10-15 15:34:03 -04003492 spin_lock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003493 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2e396b82010-10-15 15:34:01 -04003494 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Jeff Layton44772882010-10-15 15:34:03 -04003495 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003496 return 1;
3497 }
3498 }
Jeff Layton44772882010-10-15 15:34:03 -04003499 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003500 return 0;
3501}
3502
Linus Torvalds1da177e2005-04-16 15:20:36 -07003503/* We do not want to update the file size from server for inodes
3504 open for write - to avoid races with writepage extending
3505 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003506 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507 but this is tricky to do without racing with writebehind
3508 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00003509bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003510{
Steve Frencha403a0a2007-07-26 15:54:16 +00003511 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00003512 return true;
Steve French23e7dd72005-10-20 13:44:56 -07003513
Steve Frencha403a0a2007-07-26 15:54:16 +00003514 if (is_inode_writable(cifsInode)) {
3515 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08003516 struct cifs_sb_info *cifs_sb;
3517
Steve Frenchc32a0b62006-01-12 14:41:28 -08003518 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00003519 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003520 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08003521 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00003522 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08003523 }
3524
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003525 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00003526 return true;
Steve French7ba52632007-02-08 18:14:13 +00003527
Steve French4b18f2a2008-04-29 00:06:05 +00003528 return false;
Steve French23e7dd72005-10-20 13:44:56 -07003529 } else
Steve French4b18f2a2008-04-29 00:06:05 +00003530 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003531}
3532
Nick Piggind9414772008-09-24 11:32:59 -04003533static int cifs_write_begin(struct file *file, struct address_space *mapping,
3534 loff_t pos, unsigned len, unsigned flags,
3535 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003536{
Sachin Prabhu466bd312013-09-13 14:11:57 +01003537 int oncethru = 0;
Nick Piggind9414772008-09-24 11:32:59 -04003538 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3539 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003540 loff_t page_start = pos & PAGE_MASK;
3541 loff_t i_size;
3542 struct page *page;
3543 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003544
Joe Perchesf96637b2013-05-04 22:12:25 -05003545 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
Nick Piggind9414772008-09-24 11:32:59 -04003546
Sachin Prabhu466bd312013-09-13 14:11:57 +01003547start:
Nick Piggin54566b22009-01-04 12:00:53 -08003548 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003549 if (!page) {
3550 rc = -ENOMEM;
3551 goto out;
3552 }
Nick Piggind9414772008-09-24 11:32:59 -04003553
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003554 if (PageUptodate(page))
3555 goto out;
Steve French8a236262007-03-06 00:31:00 +00003556
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003557 /*
3558 * If we write a full page it will be up to date, no need to read from
3559 * the server. If the write is short, we'll end up doing a sync write
3560 * instead.
3561 */
3562 if (len == PAGE_CACHE_SIZE)
3563 goto out;
3564
3565 /*
3566 * optimize away the read when we have an oplock, and we're not
3567 * expecting to use any of the data we'd be reading in. That
3568 * is, when the page lies beyond the EOF, or straddles the EOF
3569 * and the write will cover all of the existing data.
3570 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003571 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003572 i_size = i_size_read(mapping->host);
3573 if (page_start >= i_size ||
3574 (offset == 0 && (pos + len) >= i_size)) {
3575 zero_user_segments(page, 0, offset,
3576 offset + len,
3577 PAGE_CACHE_SIZE);
3578 /*
3579 * PageChecked means that the parts of the page
3580 * to which we're not writing are considered up
3581 * to date. Once the data is copied to the
3582 * page, it can be set uptodate.
3583 */
3584 SetPageChecked(page);
3585 goto out;
3586 }
3587 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003588
Sachin Prabhu466bd312013-09-13 14:11:57 +01003589 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003590 /*
3591 * might as well read a page, it is fast enough. If we get
3592 * an error, we don't need to return it. cifs_write_end will
3593 * do a sync write instead since PG_uptodate isn't set.
3594 */
3595 cifs_readpage_worker(file, page, &page_start);
Sachin Prabhu466bd312013-09-13 14:11:57 +01003596 page_cache_release(page);
3597 oncethru = 1;
3598 goto start;
Steve French8a236262007-03-06 00:31:00 +00003599 } else {
3600 /* we could try using another file handle if there is one -
3601 but how would we lock it to prevent close of that handle
3602 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04003603 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00003604 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003605out:
3606 *pagep = page;
3607 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003608}
3609
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303610static int cifs_release_page(struct page *page, gfp_t gfp)
3611{
3612 if (PagePrivate(page))
3613 return 0;
3614
3615 return cifs_fscache_release_page(page, gfp);
3616}
3617
Lukas Czernerd47992f2013-05-21 23:17:23 -04003618static void cifs_invalidate_page(struct page *page, unsigned int offset,
3619 unsigned int length)
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303620{
3621 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3622
Lukas Czernerd47992f2013-05-21 23:17:23 -04003623 if (offset == 0 && length == PAGE_CACHE_SIZE)
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303624 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3625}
3626
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003627static int cifs_launder_page(struct page *page)
3628{
3629 int rc = 0;
3630 loff_t range_start = page_offset(page);
3631 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3632 struct writeback_control wbc = {
3633 .sync_mode = WB_SYNC_ALL,
3634 .nr_to_write = 0,
3635 .range_start = range_start,
3636 .range_end = range_end,
3637 };
3638
Joe Perchesf96637b2013-05-04 22:12:25 -05003639 cifs_dbg(FYI, "Launder page: %p\n", page);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003640
3641 if (clear_page_dirty_for_io(page))
3642 rc = cifs_writepage_locked(page, &wbc);
3643
3644 cifs_fscache_invalidate_page(page, page->mapping->host);
3645 return rc;
3646}
3647
Tejun Heo9b646972010-07-20 22:09:02 +02003648void cifs_oplock_break(struct work_struct *work)
Jeff Layton3bc303c2009-09-21 06:47:50 -04003649{
3650 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3651 oplock_break);
Jeff Laytona5e18bc2010-10-11 15:07:18 -04003652 struct inode *inode = cfile->dentry->d_inode;
Jeff Layton3bc303c2009-09-21 06:47:50 -04003653 struct cifsInodeInfo *cinode = CIFS_I(inode);
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -07003654 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04003655 int rc = 0;
Jeff Layton3bc303c2009-09-21 06:47:50 -04003656
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003657 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04003658 cifs_has_mand_locks(cinode)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003659 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3660 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003661 cinode->oplock = 0;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04003662 }
3663
Jeff Layton3bc303c2009-09-21 06:47:50 -04003664 if (inode && S_ISREG(inode->i_mode)) {
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003665 if (CIFS_CACHE_READ(cinode))
Al Viro8737c932009-12-24 06:47:55 -05003666 break_lease(inode, O_RDONLY);
Steve Frenchd54ff732010-04-27 04:38:15 +00003667 else
Al Viro8737c932009-12-24 06:47:55 -05003668 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003669 rc = filemap_fdatawrite(inode->i_mapping);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003670 if (!CIFS_CACHE_READ(cinode)) {
Jeff Laytoneb4b7562010-10-22 14:52:29 -04003671 rc = filemap_fdatawait(inode->i_mapping);
3672 mapping_set_error(inode->i_mapping, rc);
Pavel Shilovsky03eca702012-12-06 21:24:33 +04003673 cifs_invalidate_mapping(inode);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003674 }
Joe Perchesf96637b2013-05-04 22:12:25 -05003675 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003676 }
3677
Pavel Shilovsky85160e02011-10-22 15:33:29 +04003678 rc = cifs_push_locks(cfile);
3679 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003680 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04003681
Jeff Layton3bc303c2009-09-21 06:47:50 -04003682 /*
3683 * releasing stale oplock after recent reconnect of smb session using
3684 * a now incorrect file handle is not a data integrity issue but do
3685 * not bother sending an oplock release if session to server still is
3686 * disconnected since oplock already released by the server
3687 */
Steve Frenchcdff08e2010-10-21 22:46:14 +00003688 if (!cfile->oplock_break_cancelled) {
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -07003689 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3690 cinode);
Joe Perchesf96637b2013-05-04 22:12:25 -05003691 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003692 }
Jeff Layton3bc303c2009-09-21 06:47:50 -04003693}
3694
Steve Frenchdca69282013-11-11 16:42:37 -06003695/*
3696 * The presence of cifs_direct_io() in the address space ops vector
3697 * allowes open() O_DIRECT flags which would have failed otherwise.
3698 *
3699 * In the non-cached mode (mount with cache=none), we shunt off direct read and write requests
3700 * so this method should never be called.
3701 *
3702 * Direct IO is not yet supported in the cached mode.
3703 */
3704static ssize_t
3705cifs_direct_io(int rw, struct kiocb *iocb, const struct iovec *iov,
3706 loff_t pos, unsigned long nr_segs)
3707{
3708 /*
3709 * FIXME
3710 * Eventually need to support direct IO for non forcedirectio mounts
3711 */
3712 return -EINVAL;
3713}
3714
3715
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07003716const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003717 .readpage = cifs_readpage,
3718 .readpages = cifs_readpages,
3719 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07003720 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04003721 .write_begin = cifs_write_begin,
3722 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003723 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303724 .releasepage = cifs_release_page,
Steve Frenchdca69282013-11-11 16:42:37 -06003725 .direct_IO = cifs_direct_io,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303726 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003727 .launder_page = cifs_launder_page,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003728};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003729
3730/*
3731 * cifs_readpages requires the server to support a buffer large enough to
3732 * contain the header plus one complete page of data. Otherwise, we need
3733 * to leave cifs_readpages out of the address space operations.
3734 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07003735const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003736 .readpage = cifs_readpage,
3737 .writepage = cifs_writepage,
3738 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04003739 .write_begin = cifs_write_begin,
3740 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003741 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303742 .releasepage = cifs_release_page,
3743 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003744 .launder_page = cifs_launder_page,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003745};