blob: 7ddddf2e25046af5fceb6fcbe097e2b14750710c [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,
Pavel Shilovskyfb1214e2012-09-18 16:20:26 -0700247 xid, &fid->netfid);
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
681 * CIFSSMBOpen and then calling get_inode_info with returned buf since
682 * 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;
2046 rc = server->ops->async_writev(wdata);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002047 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
Jeff Laytonf3983c22010-09-22 16:17:40 -07002048
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002049 for (i = 0; i < nr_pages; ++i)
2050 unlock_page(wdata->pages[i]);
Jeff Layton941b8532011-01-11 07:24:01 -05002051
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002052 /* send failure -- clean up the mess */
2053 if (rc != 0) {
2054 for (i = 0; i < nr_pages; ++i) {
Jeff Layton941b8532011-01-11 07:24:01 -05002055 if (rc == -EAGAIN)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002056 redirty_page_for_writepage(wbc,
2057 wdata->pages[i]);
2058 else
2059 SetPageError(wdata->pages[i]);
2060 end_page_writeback(wdata->pages[i]);
2061 page_cache_release(wdata->pages[i]);
Steve French37c0eb42005-10-05 14:50:29 -07002062 }
Jeff Layton941b8532011-01-11 07:24:01 -05002063 if (rc != -EAGAIN)
2064 mapping_set_error(mapping, rc);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002065 }
2066 kref_put(&wdata->refcount, cifs_writedata_release);
Jeff Layton941b8532011-01-11 07:24:01 -05002067
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002068 wbc->nr_to_write -= nr_pages;
2069 if (wbc->nr_to_write <= 0)
2070 done = true;
Dave Kleikampb066a482008-11-18 03:49:05 +00002071
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002072 index = next;
Steve French37c0eb42005-10-05 14:50:29 -07002073 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002074
Steve French37c0eb42005-10-05 14:50:29 -07002075 if (!scanned && !done) {
2076 /*
2077 * We hit the last page and there is more work to be done: wrap
2078 * back to the start of the file
2079 */
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002080 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07002081 index = 0;
2082 goto retry;
2083 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04002084
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07002085 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07002086 mapping->writeback_index = index;
2087
Linus Torvalds1da177e2005-04-16 15:20:36 -07002088 return rc;
2089}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002091static int
2092cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002093{
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002094 int rc;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002095 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002096
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002097 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002098/* BB add check for wbc flags */
2099 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00002100 if (!PageUptodate(page))
Joe Perchesf96637b2013-05-04 22:12:25 -05002101 cifs_dbg(FYI, "ppw - page not up to date\n");
Linus Torvaldscb876f42006-12-23 16:19:07 -08002102
2103 /*
2104 * Set the "writeback" flag, and clear "dirty" in the radix tree.
2105 *
2106 * A writepage() implementation always needs to do either this,
2107 * or re-dirty the page with "redirty_page_for_writepage()" in
2108 * the case of a failure.
2109 *
2110 * Just unlocking the page will cause the radix tree tag-bits
2111 * to fail to update with the state of the page correctly.
2112 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002113 set_page_writeback(page);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002114retry_write:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002115 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002116 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
2117 goto retry_write;
2118 else if (rc == -EAGAIN)
2119 redirty_page_for_writepage(wbc, page);
2120 else if (rc != 0)
2121 SetPageError(page);
2122 else
2123 SetPageUptodate(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08002124 end_page_writeback(page);
2125 page_cache_release(page);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002126 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002127 return rc;
2128}
2129
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002130static int cifs_writepage(struct page *page, struct writeback_control *wbc)
2131{
2132 int rc = cifs_writepage_locked(page, wbc);
2133 unlock_page(page);
2134 return rc;
2135}
2136
Nick Piggind9414772008-09-24 11:32:59 -04002137static int cifs_write_end(struct file *file, struct address_space *mapping,
2138 loff_t pos, unsigned len, unsigned copied,
2139 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140{
Nick Piggind9414772008-09-24 11:32:59 -04002141 int rc;
2142 struct inode *inode = mapping->host;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002143 struct cifsFileInfo *cfile = file->private_data;
2144 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
2145 __u32 pid;
2146
2147 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2148 pid = cfile->pid;
2149 else
2150 pid = current->tgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002151
Joe Perchesf96637b2013-05-04 22:12:25 -05002152 cifs_dbg(FYI, "write_end for page %p from pos %lld with %d bytes\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002153 page, pos, copied);
Steve Frenchad7a2922008-02-07 23:25:02 +00002154
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002155 if (PageChecked(page)) {
2156 if (copied == len)
2157 SetPageUptodate(page);
2158 ClearPageChecked(page);
2159 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04002160 SetPageUptodate(page);
2161
Linus Torvalds1da177e2005-04-16 15:20:36 -07002162 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04002163 char *page_data;
2164 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002165 unsigned int xid;
Nick Piggind9414772008-09-24 11:32:59 -04002166
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002167 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168 /* this is probably better than directly calling
2169 partialpage_write since in this function the file handle is
2170 known which we might as well leverage */
2171 /* BB check if anything else missing out of ppw
2172 such as updating last write time */
2173 page_data = kmap(page);
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002174 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
Nick Piggind9414772008-09-24 11:32:59 -04002175 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04002177
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002178 free_xid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002179 } else {
Nick Piggind9414772008-09-24 11:32:59 -04002180 rc = copied;
2181 pos += copied;
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002182 set_page_dirty(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002183 }
2184
Nick Piggind9414772008-09-24 11:32:59 -04002185 if (rc > 0) {
2186 spin_lock(&inode->i_lock);
2187 if (pos > inode->i_size)
2188 i_size_write(inode, pos);
2189 spin_unlock(&inode->i_lock);
2190 }
2191
2192 unlock_page(page);
2193 page_cache_release(page);
2194
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 return rc;
2196}
2197
Josef Bacik02c24a82011-07-16 20:44:56 -04002198int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2199 int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002200{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002201 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00002203 struct cifs_tcon *tcon;
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002204 struct TCP_Server_Info *server;
Joe Perchesc21dfb62010-07-12 13:50:14 -07002205 struct cifsFileInfo *smbfile = file->private_data;
Al Viro496ad9a2013-01-23 17:07:38 -05002206 struct inode *inode = file_inode(file);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002207 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002208
Josef Bacik02c24a82011-07-16 20:44:56 -04002209 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2210 if (rc)
2211 return rc;
2212 mutex_lock(&inode->i_mutex);
2213
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002214 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07002215
Joe Perchesf96637b2013-05-04 22:12:25 -05002216 cifs_dbg(FYI, "Sync file - name: %s datasync: 0x%x\n",
2217 file->f_path.dentry->d_name.name, datasync);
Steve French50c2f752007-07-13 00:33:32 +00002218
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002219 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002220 rc = cifs_invalidate_mapping(inode);
2221 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05002222 cifs_dbg(FYI, "rc: %d during invalidate phase\n", rc);
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002223 rc = 0; /* don't care about it in fsync */
2224 }
2225 }
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002226
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002227 tcon = tlink_tcon(smbfile->tlink);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002228 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2229 server = tcon->ses->server;
2230 if (server->ops->flush)
2231 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2232 else
2233 rc = -ENOSYS;
2234 }
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002235
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002236 free_xid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04002237 mutex_unlock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002238 return rc;
2239}
2240
Josef Bacik02c24a82011-07-16 20:44:56 -04002241int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002242{
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002243 unsigned int xid;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002244 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00002245 struct cifs_tcon *tcon;
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002246 struct TCP_Server_Info *server;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002247 struct cifsFileInfo *smbfile = file->private_data;
2248 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Josef Bacik02c24a82011-07-16 20:44:56 -04002249 struct inode *inode = file->f_mapping->host;
2250
2251 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2252 if (rc)
2253 return rc;
2254 mutex_lock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002255
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002256 xid = get_xid();
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002257
Joe Perchesf96637b2013-05-04 22:12:25 -05002258 cifs_dbg(FYI, "Sync file - name: %s datasync: 0x%x\n",
2259 file->f_path.dentry->d_name.name, datasync);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002260
2261 tcon = tlink_tcon(smbfile->tlink);
Pavel Shilovsky1d8c4c02012-09-18 16:20:27 -07002262 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC)) {
2263 server = tcon->ses->server;
2264 if (server->ops->flush)
2265 rc = server->ops->flush(xid, tcon, &smbfile->fid);
2266 else
2267 rc = -ENOSYS;
2268 }
Steve Frenchb298f222009-02-21 21:17:43 +00002269
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002270 free_xid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04002271 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002272 return rc;
2273}
2274
Linus Torvalds1da177e2005-04-16 15:20:36 -07002275/*
2276 * As file closes, flush all cached write data for this inode checking
2277 * for write behind errors.
2278 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07002279int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280{
Al Viro496ad9a2013-01-23 17:07:38 -05002281 struct inode *inode = file_inode(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 int rc = 0;
2283
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002284 if (file->f_mode & FMODE_WRITE)
Jeff Laytond3f13222010-10-15 15:34:07 -04002285 rc = filemap_write_and_wait(inode->i_mapping);
Steve French50c2f752007-07-13 00:33:32 +00002286
Joe Perchesf96637b2013-05-04 22:12:25 -05002287 cifs_dbg(FYI, "Flush inode %p file %p rc %d\n", inode, file, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288
2289 return rc;
2290}
2291
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002292static int
2293cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2294{
2295 int rc = 0;
2296 unsigned long i;
2297
2298 for (i = 0; i < num_pages; i++) {
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002299 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002300 if (!pages[i]) {
2301 /*
2302 * save number of pages we have already allocated and
2303 * return with ENOMEM error
2304 */
2305 num_pages = i;
2306 rc = -ENOMEM;
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002307 break;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002308 }
2309 }
2310
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002311 if (rc) {
2312 for (i = 0; i < num_pages; i++)
2313 put_page(pages[i]);
2314 }
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002315 return rc;
2316}
2317
2318static inline
2319size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2320{
2321 size_t num_pages;
2322 size_t clen;
2323
2324 clen = min_t(const size_t, len, wsize);
Jeff Laytona7103b92012-03-23 14:40:56 -04002325 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002326
2327 if (cur_len)
2328 *cur_len = clen;
2329
2330 return num_pages;
2331}
2332
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002333static void
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002334cifs_uncached_writev_complete(struct work_struct *work)
2335{
2336 int i;
2337 struct cifs_writedata *wdata = container_of(work,
2338 struct cifs_writedata, work);
2339 struct inode *inode = wdata->cfile->dentry->d_inode;
2340 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2341
2342 spin_lock(&inode->i_lock);
2343 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2344 if (cifsi->server_eof > inode->i_size)
2345 i_size_write(inode, cifsi->server_eof);
2346 spin_unlock(&inode->i_lock);
2347
2348 complete(&wdata->done);
2349
2350 if (wdata->result != -EAGAIN) {
2351 for (i = 0; i < wdata->nr_pages; i++)
2352 put_page(wdata->pages[i]);
2353 }
2354
2355 kref_put(&wdata->refcount, cifs_writedata_release);
2356}
2357
2358/* attempt to send write to server, retry on any -EAGAIN errors */
2359static int
2360cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2361{
2362 int rc;
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -07002363 struct TCP_Server_Info *server;
2364
2365 server = tlink_tcon(wdata->cfile->tlink)->ses->server;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002366
2367 do {
2368 if (wdata->cfile->invalidHandle) {
2369 rc = cifs_reopen_file(wdata->cfile, false);
2370 if (rc != 0)
2371 continue;
2372 }
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -07002373 rc = server->ops->async_writev(wdata);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002374 } while (rc == -EAGAIN);
2375
2376 return rc;
2377}
2378
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002379static ssize_t
2380cifs_iovec_write(struct file *file, const struct iovec *iov,
2381 unsigned long nr_segs, loff_t *poffset)
2382{
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002383 unsigned long nr_pages, i;
Pavel Shilovsky76429c12011-01-31 16:03:08 +03002384 size_t copied, len, cur_len;
2385 ssize_t total_written = 0;
Jeff Layton3af9d8f2012-04-13 17:16:59 -04002386 loff_t offset;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002387 struct iov_iter it;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002388 struct cifsFileInfo *open_file;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002389 struct cifs_tcon *tcon;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002390 struct cifs_sb_info *cifs_sb;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002391 struct cifs_writedata *wdata, *tmp;
2392 struct list_head wdata_list;
2393 int rc;
2394 pid_t pid;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002395
2396 len = iov_length(iov, nr_segs);
2397 if (!len)
2398 return 0;
2399
2400 rc = generic_write_checks(file, poffset, &len, 0);
2401 if (rc)
2402 return rc;
2403
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002404 INIT_LIST_HEAD(&wdata_list);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002405 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002406 open_file = file->private_data;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002407 tcon = tlink_tcon(open_file->tlink);
Pavel Shilovskyc9de5c82012-09-18 16:20:29 -07002408
2409 if (!tcon->ses->server->ops->async_writev)
2410 return -ENOSYS;
2411
Jeff Layton3af9d8f2012-04-13 17:16:59 -04002412 offset = *poffset;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002413
2414 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2415 pid = open_file->pid;
2416 else
2417 pid = current->tgid;
2418
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002419 iov_iter_init(&it, iov, nr_segs, len, 0);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002420 do {
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002421 size_t save_len;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002422
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002423 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2424 wdata = cifs_writedata_alloc(nr_pages,
2425 cifs_uncached_writev_complete);
2426 if (!wdata) {
2427 rc = -ENOMEM;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002428 break;
2429 }
2430
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002431 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2432 if (rc) {
2433 kfree(wdata);
2434 break;
2435 }
2436
2437 save_len = cur_len;
2438 for (i = 0; i < nr_pages; i++) {
2439 copied = min_t(const size_t, cur_len, PAGE_SIZE);
2440 copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2441 0, copied);
2442 cur_len -= copied;
2443 iov_iter_advance(&it, copied);
2444 }
2445 cur_len = save_len - cur_len;
2446
2447 wdata->sync_mode = WB_SYNC_ALL;
2448 wdata->nr_pages = nr_pages;
2449 wdata->offset = (__u64)offset;
2450 wdata->cfile = cifsFileInfo_get(open_file);
2451 wdata->pid = pid;
2452 wdata->bytes = cur_len;
Jeff Laytoneddb0792012-09-18 16:20:35 -07002453 wdata->pagesz = PAGE_SIZE;
2454 wdata->tailsz = cur_len - ((nr_pages - 1) * PAGE_SIZE);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002455 rc = cifs_uncached_retry_writev(wdata);
2456 if (rc) {
2457 kref_put(&wdata->refcount, cifs_writedata_release);
2458 break;
2459 }
2460
2461 list_add_tail(&wdata->list, &wdata_list);
2462 offset += cur_len;
2463 len -= cur_len;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002464 } while (len > 0);
2465
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002466 /*
2467 * If at least one write was successfully sent, then discard any rc
2468 * value from the later writes. If the other write succeeds, then
2469 * we'll end up returning whatever was written. If it fails, then
2470 * we'll get a new rc value from that.
2471 */
2472 if (!list_empty(&wdata_list))
2473 rc = 0;
2474
2475 /*
2476 * Wait for and collect replies for any successful sends in order of
2477 * increasing offset. Once an error is hit or we get a fatal signal
2478 * while waiting, then return without waiting for any more replies.
2479 */
2480restart_loop:
2481 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2482 if (!rc) {
2483 /* FIXME: freezable too? */
2484 rc = wait_for_completion_killable(&wdata->done);
2485 if (rc)
2486 rc = -EINTR;
2487 else if (wdata->result)
2488 rc = wdata->result;
2489 else
2490 total_written += wdata->bytes;
2491
2492 /* resend call if it's a retryable error */
2493 if (rc == -EAGAIN) {
2494 rc = cifs_uncached_retry_writev(wdata);
2495 goto restart_loop;
2496 }
2497 }
2498 list_del_init(&wdata->list);
2499 kref_put(&wdata->refcount, cifs_writedata_release);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002500 }
2501
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002502 if (total_written > 0)
2503 *poffset += total_written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002504
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002505 cifs_stats_bytes_written(tcon, total_written);
2506 return total_written ? total_written : (ssize_t)rc;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002507}
2508
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +03002509ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002510 unsigned long nr_segs, loff_t pos)
2511{
2512 ssize_t written;
2513 struct inode *inode;
2514
Al Viro496ad9a2013-01-23 17:07:38 -05002515 inode = file_inode(iocb->ki_filp);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002516
2517 /*
2518 * BB - optimize the way when signing is disabled. We can drop this
2519 * extra memory-to-memory copying and use iovec buffers for constructing
2520 * write request.
2521 */
2522
2523 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2524 if (written > 0) {
2525 CIFS_I(inode)->invalid_mapping = true;
2526 iocb->ki_pos = pos;
2527 }
2528
2529 return written;
2530}
2531
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002532static ssize_t
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002533cifs_writev(struct kiocb *iocb, const struct iovec *iov,
2534 unsigned long nr_segs, loff_t pos)
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002535{
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002536 struct file *file = iocb->ki_filp;
2537 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
2538 struct inode *inode = file->f_mapping->host;
2539 struct cifsInodeInfo *cinode = CIFS_I(inode);
2540 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
2541 ssize_t rc = -EACCES;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002542
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002543 BUG_ON(iocb->ki_pos != pos);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002544
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002545 /*
2546 * We need to hold the sem to be sure nobody modifies lock list
2547 * with a brlock that prevents writing.
2548 */
2549 down_read(&cinode->lock_sem);
2550 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2551 server->vals->exclusive_lock_type, NULL,
Pavel Shilovsky081c0412012-11-27 18:38:53 +04002552 CIFS_WRITE_OP)) {
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002553 mutex_lock(&inode->i_mutex);
2554 rc = __generic_file_aio_write(iocb, iov, nr_segs,
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002555 &iocb->ki_pos);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002556 mutex_unlock(&inode->i_mutex);
2557 }
2558
Christoph Hellwig02afc272013-09-04 15:04:40 +02002559 if (rc > 0) {
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002560 ssize_t err;
2561
2562 err = generic_write_sync(file, pos, rc);
2563 if (err < 0 && rc > 0)
2564 rc = err;
2565 }
2566
2567 up_read(&cinode->lock_sem);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002568 return rc;
2569}
2570
2571ssize_t
2572cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2573 unsigned long nr_segs, loff_t pos)
2574{
Al Viro496ad9a2013-01-23 17:07:38 -05002575 struct inode *inode = file_inode(iocb->ki_filp);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002576 struct cifsInodeInfo *cinode = CIFS_I(inode);
2577 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2578 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2579 iocb->ki_filp->private_data;
2580 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002581 ssize_t written;
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002582
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002583 if (CIFS_CACHE_WRITE(cinode)) {
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002584 if (cap_unix(tcon->ses) &&
2585 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability))
2586 && ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2587 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2588 return cifs_writev(iocb, iov, nr_segs, pos);
Pavel Shilovskyc299dd02012-12-06 22:07:52 +04002589 }
Pavel Shilovskyca8aa292012-12-21 15:05:47 +04002590 /*
2591 * For non-oplocked files in strict cache mode we need to write the data
2592 * to the server exactly from the pos to pos+len-1 rather than flush all
2593 * affected pages because it may cause a error with mandatory locks on
2594 * these pages but not on the region from pos to ppos+len-1.
2595 */
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002596 written = cifs_user_writev(iocb, iov, nr_segs, pos);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002597 if (written > 0 && CIFS_CACHE_READ(cinode)) {
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002598 /*
2599 * Windows 7 server can delay breaking level2 oplock if a write
2600 * request comes - break it on the client to prevent reading
2601 * an old data.
2602 */
2603 cifs_invalidate_mapping(inode);
Joe Perchesf96637b2013-05-04 22:12:25 -05002604 cifs_dbg(FYI, "Set no oplock for inode=%p after a write operation\n",
2605 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002606 cinode->oplock = 0;
Pavel Shilovsky88cf75a2012-12-21 15:07:52 +04002607 }
2608 return written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002609}
2610
Jeff Layton0471ca32012-05-16 07:13:16 -04002611static struct cifs_readdata *
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002612cifs_readdata_alloc(unsigned int nr_pages, work_func_t complete)
Jeff Layton0471ca32012-05-16 07:13:16 -04002613{
2614 struct cifs_readdata *rdata;
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002615
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002616 rdata = kzalloc(sizeof(*rdata) + (sizeof(struct page *) * nr_pages),
2617 GFP_KERNEL);
Jeff Layton0471ca32012-05-16 07:13:16 -04002618 if (rdata != NULL) {
Jeff Layton6993f742012-05-16 07:13:17 -04002619 kref_init(&rdata->refcount);
Jeff Layton1c892542012-05-16 07:13:17 -04002620 INIT_LIST_HEAD(&rdata->list);
2621 init_completion(&rdata->done);
Jeff Layton0471ca32012-05-16 07:13:16 -04002622 INIT_WORK(&rdata->work, complete);
Jeff Layton0471ca32012-05-16 07:13:16 -04002623 }
Jeff Laytonf4e49cd2012-09-18 16:20:36 -07002624
Jeff Layton0471ca32012-05-16 07:13:16 -04002625 return rdata;
2626}
2627
Jeff Layton6993f742012-05-16 07:13:17 -04002628void
2629cifs_readdata_release(struct kref *refcount)
Jeff Layton0471ca32012-05-16 07:13:16 -04002630{
Jeff Layton6993f742012-05-16 07:13:17 -04002631 struct cifs_readdata *rdata = container_of(refcount,
2632 struct cifs_readdata, refcount);
2633
2634 if (rdata->cfile)
2635 cifsFileInfo_put(rdata->cfile);
2636
Jeff Layton0471ca32012-05-16 07:13:16 -04002637 kfree(rdata);
2638}
2639
Jeff Layton2a1bb132012-05-16 07:13:17 -04002640static int
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002641cifs_read_allocate_pages(struct cifs_readdata *rdata, unsigned int nr_pages)
Jeff Layton1c892542012-05-16 07:13:17 -04002642{
2643 int rc = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002644 struct page *page;
Jeff Layton1c892542012-05-16 07:13:17 -04002645 unsigned int i;
2646
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002647 for (i = 0; i < nr_pages; i++) {
Jeff Layton1c892542012-05-16 07:13:17 -04002648 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2649 if (!page) {
2650 rc = -ENOMEM;
2651 break;
2652 }
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002653 rdata->pages[i] = page;
Jeff Layton1c892542012-05-16 07:13:17 -04002654 }
2655
2656 if (rc) {
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002657 for (i = 0; i < nr_pages; i++) {
2658 put_page(rdata->pages[i]);
2659 rdata->pages[i] = NULL;
Jeff Layton1c892542012-05-16 07:13:17 -04002660 }
2661 }
2662 return rc;
2663}
2664
2665static void
2666cifs_uncached_readdata_release(struct kref *refcount)
2667{
Jeff Layton1c892542012-05-16 07:13:17 -04002668 struct cifs_readdata *rdata = container_of(refcount,
2669 struct cifs_readdata, refcount);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002670 unsigned int i;
Jeff Layton1c892542012-05-16 07:13:17 -04002671
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002672 for (i = 0; i < rdata->nr_pages; i++) {
2673 put_page(rdata->pages[i]);
2674 rdata->pages[i] = NULL;
Jeff Layton1c892542012-05-16 07:13:17 -04002675 }
2676 cifs_readdata_release(refcount);
2677}
2678
2679static int
Jeff Layton2a1bb132012-05-16 07:13:17 -04002680cifs_retry_async_readv(struct cifs_readdata *rdata)
2681{
2682 int rc;
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -07002683 struct TCP_Server_Info *server;
2684
2685 server = tlink_tcon(rdata->cfile->tlink)->ses->server;
Jeff Layton2a1bb132012-05-16 07:13:17 -04002686
2687 do {
2688 if (rdata->cfile->invalidHandle) {
2689 rc = cifs_reopen_file(rdata->cfile, true);
2690 if (rc != 0)
2691 continue;
2692 }
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -07002693 rc = server->ops->async_readv(rdata);
Jeff Layton2a1bb132012-05-16 07:13:17 -04002694 } while (rc == -EAGAIN);
2695
2696 return rc;
2697}
2698
Jeff Layton1c892542012-05-16 07:13:17 -04002699/**
2700 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2701 * @rdata: the readdata response with list of pages holding data
2702 * @iov: vector in which we should copy the data
2703 * @nr_segs: number of segments in vector
2704 * @offset: offset into file of the first iovec
2705 * @copied: used to return the amount of data copied to the iov
2706 *
2707 * This function copies data from a list of pages in a readdata response into
2708 * an array of iovecs. It will first calculate where the data should go
2709 * based on the info in the readdata and then copy the data into that spot.
2710 */
2711static ssize_t
2712cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2713 unsigned long nr_segs, loff_t offset, ssize_t *copied)
2714{
2715 int rc = 0;
2716 struct iov_iter ii;
2717 size_t pos = rdata->offset - offset;
Jeff Layton1c892542012-05-16 07:13:17 -04002718 ssize_t remaining = rdata->bytes;
2719 unsigned char *pdata;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002720 unsigned int i;
Jeff Layton1c892542012-05-16 07:13:17 -04002721
2722 /* set up iov_iter and advance to the correct offset */
2723 iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2724 iov_iter_advance(&ii, pos);
2725
2726 *copied = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002727 for (i = 0; i < rdata->nr_pages; i++) {
Jeff Layton1c892542012-05-16 07:13:17 -04002728 ssize_t copy;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002729 struct page *page = rdata->pages[i];
Jeff Layton1c892542012-05-16 07:13:17 -04002730
2731 /* copy a whole page or whatever's left */
2732 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2733
2734 /* ...but limit it to whatever space is left in the iov */
2735 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2736
2737 /* go while there's data to be copied and no errors */
2738 if (copy && !rc) {
2739 pdata = kmap(page);
2740 rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2741 (int)copy);
2742 kunmap(page);
2743 if (!rc) {
2744 *copied += copy;
2745 remaining -= copy;
2746 iov_iter_advance(&ii, copy);
2747 }
2748 }
Jeff Layton1c892542012-05-16 07:13:17 -04002749 }
2750
2751 return rc;
2752}
2753
2754static void
2755cifs_uncached_readv_complete(struct work_struct *work)
2756{
2757 struct cifs_readdata *rdata = container_of(work,
2758 struct cifs_readdata, work);
Jeff Layton1c892542012-05-16 07:13:17 -04002759
2760 complete(&rdata->done);
2761 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2762}
2763
2764static int
Jeff Layton8321fec2012-09-19 06:22:32 -07002765cifs_uncached_read_into_pages(struct TCP_Server_Info *server,
2766 struct cifs_readdata *rdata, unsigned int len)
Jeff Layton1c892542012-05-16 07:13:17 -04002767{
Jeff Layton8321fec2012-09-19 06:22:32 -07002768 int total_read = 0, result = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002769 unsigned int i;
2770 unsigned int nr_pages = rdata->nr_pages;
Jeff Layton8321fec2012-09-19 06:22:32 -07002771 struct kvec iov;
Jeff Layton1c892542012-05-16 07:13:17 -04002772
Jeff Layton8321fec2012-09-19 06:22:32 -07002773 rdata->tailsz = PAGE_SIZE;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002774 for (i = 0; i < nr_pages; i++) {
2775 struct page *page = rdata->pages[i];
2776
Jeff Layton8321fec2012-09-19 06:22:32 -07002777 if (len >= PAGE_SIZE) {
Jeff Layton1c892542012-05-16 07:13:17 -04002778 /* enough data to fill the page */
Jeff Layton8321fec2012-09-19 06:22:32 -07002779 iov.iov_base = kmap(page);
2780 iov.iov_len = PAGE_SIZE;
Joe Perchesf96637b2013-05-04 22:12:25 -05002781 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2782 i, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07002783 len -= PAGE_SIZE;
2784 } else if (len > 0) {
Jeff Layton1c892542012-05-16 07:13:17 -04002785 /* enough for partial page, fill and zero the rest */
Jeff Layton8321fec2012-09-19 06:22:32 -07002786 iov.iov_base = kmap(page);
2787 iov.iov_len = len;
Joe Perchesf96637b2013-05-04 22:12:25 -05002788 cifs_dbg(FYI, "%u: iov_base=%p iov_len=%zu\n",
2789 i, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07002790 memset(iov.iov_base + len, '\0', PAGE_SIZE - len);
2791 rdata->tailsz = len;
2792 len = 0;
Jeff Layton1c892542012-05-16 07:13:17 -04002793 } else {
2794 /* no need to hold page hostage */
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002795 rdata->pages[i] = NULL;
2796 rdata->nr_pages--;
Jeff Layton1c892542012-05-16 07:13:17 -04002797 put_page(page);
Jeff Layton8321fec2012-09-19 06:22:32 -07002798 continue;
Jeff Layton1c892542012-05-16 07:13:17 -04002799 }
Jeff Layton8321fec2012-09-19 06:22:32 -07002800
2801 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
2802 kunmap(page);
2803 if (result < 0)
2804 break;
2805
2806 total_read += result;
Jeff Layton1c892542012-05-16 07:13:17 -04002807 }
2808
Jeff Layton8321fec2012-09-19 06:22:32 -07002809 return total_read > 0 ? total_read : result;
Jeff Layton1c892542012-05-16 07:13:17 -04002810}
2811
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002812static ssize_t
2813cifs_iovec_read(struct file *file, const struct iovec *iov,
2814 unsigned long nr_segs, loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002815{
Jeff Layton1c892542012-05-16 07:13:17 -04002816 ssize_t rc;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002817 size_t len, cur_len;
Jeff Layton1c892542012-05-16 07:13:17 -04002818 ssize_t total_read = 0;
2819 loff_t offset = *poffset;
2820 unsigned int npages;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002821 struct cifs_sb_info *cifs_sb;
Jeff Layton1c892542012-05-16 07:13:17 -04002822 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002823 struct cifsFileInfo *open_file;
Jeff Layton1c892542012-05-16 07:13:17 -04002824 struct cifs_readdata *rdata, *tmp;
2825 struct list_head rdata_list;
2826 pid_t pid;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002827
2828 if (!nr_segs)
2829 return 0;
2830
2831 len = iov_length(iov, nr_segs);
2832 if (!len)
2833 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002834
Jeff Layton1c892542012-05-16 07:13:17 -04002835 INIT_LIST_HEAD(&rdata_list);
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002836 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -07002837 open_file = file->private_data;
Jeff Layton1c892542012-05-16 07:13:17 -04002838 tcon = tlink_tcon(open_file->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839
Pavel Shilovskyfc9c5962012-09-18 16:20:28 -07002840 if (!tcon->ses->server->ops->async_readv)
2841 return -ENOSYS;
2842
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002843 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2844 pid = open_file->pid;
2845 else
2846 pid = current->tgid;
2847
Steve Frenchad7a2922008-02-07 23:25:02 +00002848 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesf96637b2013-05-04 22:12:25 -05002849 cifs_dbg(FYI, "attempting read on write only file instance\n");
Steve Frenchad7a2922008-02-07 23:25:02 +00002850
Jeff Layton1c892542012-05-16 07:13:17 -04002851 do {
2852 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2853 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002854
Jeff Layton1c892542012-05-16 07:13:17 -04002855 /* allocate a readdata struct */
2856 rdata = cifs_readdata_alloc(npages,
2857 cifs_uncached_readv_complete);
2858 if (!rdata) {
2859 rc = -ENOMEM;
2860 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002861 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002862
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002863 rc = cifs_read_allocate_pages(rdata, npages);
Jeff Layton1c892542012-05-16 07:13:17 -04002864 if (rc)
2865 goto error;
2866
2867 rdata->cfile = cifsFileInfo_get(open_file);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07002868 rdata->nr_pages = npages;
Jeff Layton1c892542012-05-16 07:13:17 -04002869 rdata->offset = offset;
2870 rdata->bytes = cur_len;
2871 rdata->pid = pid;
Jeff Layton8321fec2012-09-19 06:22:32 -07002872 rdata->pagesz = PAGE_SIZE;
2873 rdata->read_into_pages = cifs_uncached_read_into_pages;
Jeff Layton1c892542012-05-16 07:13:17 -04002874
2875 rc = cifs_retry_async_readv(rdata);
2876error:
2877 if (rc) {
2878 kref_put(&rdata->refcount,
2879 cifs_uncached_readdata_release);
2880 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881 }
Jeff Layton1c892542012-05-16 07:13:17 -04002882
2883 list_add_tail(&rdata->list, &rdata_list);
2884 offset += cur_len;
2885 len -= cur_len;
2886 } while (len > 0);
2887
2888 /* if at least one read request send succeeded, then reset rc */
2889 if (!list_empty(&rdata_list))
2890 rc = 0;
2891
2892 /* the loop below should proceed in the order of increasing offsets */
2893restart_loop:
2894 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2895 if (!rc) {
2896 ssize_t copied;
2897
2898 /* FIXME: freezable sleep too? */
2899 rc = wait_for_completion_killable(&rdata->done);
2900 if (rc)
2901 rc = -EINTR;
2902 else if (rdata->result)
2903 rc = rdata->result;
2904 else {
2905 rc = cifs_readdata_to_iov(rdata, iov,
2906 nr_segs, *poffset,
2907 &copied);
2908 total_read += copied;
2909 }
2910
2911 /* resend call if it's a retryable error */
2912 if (rc == -EAGAIN) {
2913 rc = cifs_retry_async_readv(rdata);
2914 goto restart_loop;
2915 }
2916 }
2917 list_del_init(&rdata->list);
2918 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002919 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002920
Jeff Layton1c892542012-05-16 07:13:17 -04002921 cifs_stats_bytes_read(tcon, total_read);
2922 *poffset += total_read;
2923
Pavel Shilovsky09a47072012-09-18 16:20:29 -07002924 /* mask nodata case */
2925 if (rc == -ENODATA)
2926 rc = 0;
2927
Jeff Layton1c892542012-05-16 07:13:17 -04002928 return total_read ? total_read : rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002929}
2930
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +03002931ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002932 unsigned long nr_segs, loff_t pos)
2933{
2934 ssize_t read;
2935
2936 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2937 if (read > 0)
2938 iocb->ki_pos = pos;
2939
2940 return read;
2941}
2942
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002943ssize_t
2944cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2945 unsigned long nr_segs, loff_t pos)
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002946{
Al Viro496ad9a2013-01-23 17:07:38 -05002947 struct inode *inode = file_inode(iocb->ki_filp);
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002948 struct cifsInodeInfo *cinode = CIFS_I(inode);
2949 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
2950 struct cifsFileInfo *cfile = (struct cifsFileInfo *)
2951 iocb->ki_filp->private_data;
2952 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
2953 int rc = -EACCES;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002954
2955 /*
2956 * In strict cache mode we need to read from the server all the time
2957 * if we don't have level II oplock because the server can delay mtime
2958 * change - so we can't make a decision about inode invalidating.
2959 * And we can also fail with pagereading if there are mandatory locks
2960 * on pages affected by this read but not on the region from pos to
2961 * pos+len-1.
2962 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04002963 if (!CIFS_CACHE_READ(cinode))
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002964 return cifs_user_readv(iocb, iov, nr_segs, pos);
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002965
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002966 if (cap_unix(tcon->ses) &&
2967 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
2968 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
2969 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2970
2971 /*
2972 * We need to hold the sem to be sure nobody modifies lock list
2973 * with a brlock that prevents reading.
2974 */
2975 down_read(&cinode->lock_sem);
2976 if (!cifs_find_lock_conflict(cfile, pos, iov_length(iov, nr_segs),
2977 tcon->ses->server->vals->shared_lock_type,
Pavel Shilovsky081c0412012-11-27 18:38:53 +04002978 NULL, CIFS_READ_OP))
Pavel Shilovsky579f9052012-09-19 06:22:44 -07002979 rc = generic_file_aio_read(iocb, iov, nr_segs, pos);
2980 up_read(&cinode->lock_sem);
2981 return rc;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002982}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07002984static ssize_t
2985cifs_read(struct file *file, char *read_data, size_t read_size, loff_t *offset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002986{
2987 int rc = -EACCES;
2988 unsigned int bytes_read = 0;
2989 unsigned int total_read;
2990 unsigned int current_read_size;
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002991 unsigned int rsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002992 struct cifs_sb_info *cifs_sb;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04002993 struct cifs_tcon *tcon;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07002994 struct TCP_Server_Info *server;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04002995 unsigned int xid;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07002996 char *cur_offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002997 struct cifsFileInfo *open_file;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002998 struct cifs_io_parms io_parms;
Steve Frenchec637e32005-12-12 20:53:18 -08002999 int buf_type = CIFS_NO_BUFFER;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003000 __u32 pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003001
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003002 xid = get_xid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08003003 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003004
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003005 /* FIXME: set up handlers for larger reads and/or convert to async */
3006 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
3007
Linus Torvalds1da177e2005-04-16 15:20:36 -07003008 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303009 rc = -EBADF;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003010 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303011 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07003013 open_file = file->private_data;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003014 tcon = tlink_tcon(open_file->tlink);
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003015 server = tcon->ses->server;
3016
3017 if (!server->ops->sync_read) {
3018 free_xid(xid);
3019 return -ENOSYS;
3020 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003021
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003022 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3023 pid = open_file->pid;
3024 else
3025 pid = current->tgid;
3026
Linus Torvalds1da177e2005-04-16 15:20:36 -07003027 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesf96637b2013-05-04 22:12:25 -05003028 cifs_dbg(FYI, "attempting read on write only file instance\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003029
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003030 for (total_read = 0, cur_offset = read_data; read_size > total_read;
3031 total_read += bytes_read, cur_offset += bytes_read) {
Jeff Layton5eba8ab2011-10-19 15:30:26 -04003032 current_read_size = min_t(uint, read_size - total_read, rsize);
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003033 /*
3034 * For windows me and 9x we do not want to request more than it
3035 * negotiated since it will refuse the read then.
3036 */
3037 if ((tcon->ses) && !(tcon->ses->capabilities &
3038 tcon->ses->server->vals->cap_large_files)) {
Dan Carpenter7748dd62011-10-18 12:41:35 +03003039 current_read_size = min_t(uint, current_read_size,
Jeff Laytonc974bef2011-10-11 06:41:32 -04003040 CIFSMaxBufSize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07003041 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003042 rc = -EAGAIN;
3043 while (rc == -EAGAIN) {
Steve Frenchcdff08e2010-10-21 22:46:14 +00003044 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04003045 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003046 if (rc != 0)
3047 break;
3048 }
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003049 io_parms.pid = pid;
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003050 io_parms.tcon = tcon;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003051 io_parms.offset = *offset;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003052 io_parms.length = current_read_size;
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003053 rc = server->ops->sync_read(xid, open_file, &io_parms,
3054 &bytes_read, &cur_offset,
3055 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003056 }
3057 if (rc || (bytes_read == 0)) {
3058 if (total_read) {
3059 break;
3060 } else {
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003061 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003062 return rc;
3063 }
3064 } else {
Pavel Shilovsky29e20f92012-07-13 13:58:14 +04003065 cifs_stats_bytes_read(tcon, total_read);
Pavel Shilovskyf9c6e232012-09-18 16:20:29 -07003066 *offset += bytes_read;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067 }
3068 }
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003069 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003070 return total_read;
3071}
3072
Jeff Laytonca83ce32011-04-12 09:13:44 -04003073/*
3074 * If the page is mmap'ed into a process' page tables, then we need to make
3075 * sure that it doesn't change while being written back.
3076 */
3077static int
3078cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
3079{
3080 struct page *page = vmf->page;
3081
3082 lock_page(page);
3083 return VM_FAULT_LOCKED;
3084}
3085
3086static struct vm_operations_struct cifs_file_vm_ops = {
3087 .fault = filemap_fault,
3088 .page_mkwrite = cifs_page_mkwrite,
Konstantin Khlebnikov0b173bc2012-10-08 16:28:46 -07003089 .remap_pages = generic_file_remap_pages,
Jeff Laytonca83ce32011-04-12 09:13:44 -04003090};
3091
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003092int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
3093{
3094 int rc, xid;
Al Viro496ad9a2013-01-23 17:07:38 -05003095 struct inode *inode = file_inode(file);
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003096
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003097 xid = get_xid();
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003098
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003099 if (!CIFS_CACHE_READ(CIFS_I(inode))) {
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04003100 rc = cifs_invalidate_mapping(inode);
3101 if (rc)
3102 return rc;
3103 }
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003104
3105 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04003106 if (rc == 0)
3107 vma->vm_ops = &cifs_file_vm_ops;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003108 free_xid(xid);
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03003109 return rc;
3110}
3111
Linus Torvalds1da177e2005-04-16 15:20:36 -07003112int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
3113{
Linus Torvalds1da177e2005-04-16 15:20:36 -07003114 int rc, xid;
3115
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003116 xid = get_xid();
Jeff Laytonabab0952010-02-12 07:44:18 -05003117 rc = cifs_revalidate_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003118 if (rc) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003119 cifs_dbg(FYI, "Validation prior to mmap failed, error=%d\n",
3120 rc);
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003121 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003122 return rc;
3123 }
3124 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04003125 if (rc == 0)
3126 vma->vm_ops = &cifs_file_vm_ops;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003127 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003128 return rc;
3129}
3130
Jeff Layton0471ca32012-05-16 07:13:16 -04003131static void
3132cifs_readv_complete(struct work_struct *work)
3133{
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003134 unsigned int i;
Jeff Layton0471ca32012-05-16 07:13:16 -04003135 struct cifs_readdata *rdata = container_of(work,
3136 struct cifs_readdata, work);
Jeff Layton0471ca32012-05-16 07:13:16 -04003137
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003138 for (i = 0; i < rdata->nr_pages; i++) {
3139 struct page *page = rdata->pages[i];
3140
Jeff Layton0471ca32012-05-16 07:13:16 -04003141 lru_cache_add_file(page);
3142
3143 if (rdata->result == 0) {
Jeff Layton0471ca32012-05-16 07:13:16 -04003144 flush_dcache_page(page);
3145 SetPageUptodate(page);
3146 }
3147
3148 unlock_page(page);
3149
3150 if (rdata->result == 0)
3151 cifs_readpage_to_fscache(rdata->mapping->host, page);
3152
3153 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003154 rdata->pages[i] = NULL;
Jeff Layton0471ca32012-05-16 07:13:16 -04003155 }
Jeff Layton6993f742012-05-16 07:13:17 -04003156 kref_put(&rdata->refcount, cifs_readdata_release);
Jeff Layton0471ca32012-05-16 07:13:16 -04003157}
3158
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003159static int
Jeff Layton8321fec2012-09-19 06:22:32 -07003160cifs_readpages_read_into_pages(struct TCP_Server_Info *server,
3161 struct cifs_readdata *rdata, unsigned int len)
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003162{
Jeff Layton8321fec2012-09-19 06:22:32 -07003163 int total_read = 0, result = 0;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003164 unsigned int i;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003165 u64 eof;
3166 pgoff_t eof_index;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003167 unsigned int nr_pages = rdata->nr_pages;
Jeff Layton8321fec2012-09-19 06:22:32 -07003168 struct kvec iov;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003169
3170 /* determine the eof that the server (probably) has */
3171 eof = CIFS_I(rdata->mapping->host)->server_eof;
3172 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
Joe Perchesf96637b2013-05-04 22:12:25 -05003173 cifs_dbg(FYI, "eof=%llu eof_index=%lu\n", eof, eof_index);
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003174
Jeff Layton8321fec2012-09-19 06:22:32 -07003175 rdata->tailsz = PAGE_CACHE_SIZE;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003176 for (i = 0; i < nr_pages; i++) {
3177 struct page *page = rdata->pages[i];
3178
Jeff Layton8321fec2012-09-19 06:22:32 -07003179 if (len >= PAGE_CACHE_SIZE) {
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003180 /* enough data to fill the page */
Jeff Layton8321fec2012-09-19 06:22:32 -07003181 iov.iov_base = kmap(page);
3182 iov.iov_len = PAGE_CACHE_SIZE;
Joe Perchesf96637b2013-05-04 22:12:25 -05003183 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3184 i, page->index, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07003185 len -= PAGE_CACHE_SIZE;
3186 } else if (len > 0) {
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003187 /* enough for partial page, fill and zero the rest */
Jeff Layton8321fec2012-09-19 06:22:32 -07003188 iov.iov_base = kmap(page);
3189 iov.iov_len = len;
Joe Perchesf96637b2013-05-04 22:12:25 -05003190 cifs_dbg(FYI, "%u: idx=%lu iov_base=%p iov_len=%zu\n",
3191 i, page->index, iov.iov_base, iov.iov_len);
Jeff Layton8321fec2012-09-19 06:22:32 -07003192 memset(iov.iov_base + len,
3193 '\0', PAGE_CACHE_SIZE - len);
3194 rdata->tailsz = len;
3195 len = 0;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003196 } else if (page->index > eof_index) {
3197 /*
3198 * The VFS will not try to do readahead past the
3199 * i_size, but it's possible that we have outstanding
3200 * writes with gaps in the middle and the i_size hasn't
3201 * caught up yet. Populate those with zeroed out pages
3202 * to prevent the VFS from repeatedly attempting to
3203 * fill them until the writes are flushed.
3204 */
3205 zero_user(page, 0, PAGE_CACHE_SIZE);
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003206 lru_cache_add_file(page);
3207 flush_dcache_page(page);
3208 SetPageUptodate(page);
3209 unlock_page(page);
3210 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003211 rdata->pages[i] = NULL;
3212 rdata->nr_pages--;
Jeff Layton8321fec2012-09-19 06:22:32 -07003213 continue;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003214 } else {
3215 /* no need to hold page hostage */
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003216 lru_cache_add_file(page);
3217 unlock_page(page);
3218 page_cache_release(page);
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003219 rdata->pages[i] = NULL;
3220 rdata->nr_pages--;
Jeff Layton8321fec2012-09-19 06:22:32 -07003221 continue;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003222 }
Jeff Layton8321fec2012-09-19 06:22:32 -07003223
3224 result = cifs_readv_from_socket(server, &iov, 1, iov.iov_len);
3225 kunmap(page);
3226 if (result < 0)
3227 break;
3228
3229 total_read += result;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003230 }
3231
Jeff Layton8321fec2012-09-19 06:22:32 -07003232 return total_read > 0 ? total_read : result;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003233}
3234
Linus Torvalds1da177e2005-04-16 15:20:36 -07003235static int cifs_readpages(struct file *file, struct address_space *mapping,
3236 struct list_head *page_list, unsigned num_pages)
3237{
Jeff Layton690c5e32011-10-19 15:30:16 -04003238 int rc;
3239 struct list_head tmplist;
3240 struct cifsFileInfo *open_file = file->private_data;
3241 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
3242 unsigned int rsize = cifs_sb->rsize;
3243 pid_t pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003244
Jeff Layton690c5e32011-10-19 15:30:16 -04003245 /*
3246 * Give up immediately if rsize is too small to read an entire page.
3247 * The VFS will fall back to readpage. We should never reach this
3248 * point however since we set ra_pages to 0 when the rsize is smaller
3249 * than a cache page.
3250 */
3251 if (unlikely(rsize < PAGE_CACHE_SIZE))
3252 return 0;
Steve Frenchbfa0d752005-08-31 21:50:37 -07003253
Suresh Jayaraman56698232010-07-05 18:13:25 +05303254 /*
3255 * Reads as many pages as possible from fscache. Returns -ENOBUFS
3256 * immediately if the cookie is negative
David Howells54afa992013-09-04 17:10:39 +00003257 *
3258 * After this point, every page in the list might have PG_fscache set,
3259 * so we will need to clean that up off of every page we don't use.
Suresh Jayaraman56698232010-07-05 18:13:25 +05303260 */
3261 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
3262 &num_pages);
3263 if (rc == 0)
Jeff Layton690c5e32011-10-19 15:30:16 -04003264 return rc;
Suresh Jayaraman56698232010-07-05 18:13:25 +05303265
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00003266 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
3267 pid = open_file->pid;
3268 else
3269 pid = current->tgid;
3270
Jeff Layton690c5e32011-10-19 15:30:16 -04003271 rc = 0;
3272 INIT_LIST_HEAD(&tmplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003273
Joe Perchesf96637b2013-05-04 22:12:25 -05003274 cifs_dbg(FYI, "%s: file=%p mapping=%p num_pages=%u\n",
3275 __func__, file, mapping, num_pages);
Jeff Layton690c5e32011-10-19 15:30:16 -04003276
3277 /*
3278 * Start with the page at end of list and move it to private
3279 * list. Do the same with any following pages until we hit
3280 * the rsize limit, hit an index discontinuity, or run out of
3281 * pages. Issue the async read and then start the loop again
3282 * until the list is empty.
3283 *
3284 * Note that list order is important. The page_list is in
3285 * the order of declining indexes. When we put the pages in
3286 * the rdata->pages, then we want them in increasing order.
3287 */
3288 while (!list_empty(page_list)) {
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003289 unsigned int i;
Jeff Layton690c5e32011-10-19 15:30:16 -04003290 unsigned int bytes = PAGE_CACHE_SIZE;
3291 unsigned int expected_index;
3292 unsigned int nr_pages = 1;
3293 loff_t offset;
3294 struct page *page, *tpage;
3295 struct cifs_readdata *rdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003296
3297 page = list_entry(page_list->prev, struct page, lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003298
Jeff Layton690c5e32011-10-19 15:30:16 -04003299 /*
3300 * Lock the page and put it in the cache. Since no one else
3301 * should have access to this page, we're safe to simply set
3302 * PG_locked without checking it first.
3303 */
3304 __set_page_locked(page);
3305 rc = add_to_page_cache_locked(page, mapping,
3306 page->index, GFP_KERNEL);
3307
3308 /* give up if we can't stick it in the cache */
3309 if (rc) {
3310 __clear_page_locked(page);
3311 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003312 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003313
Jeff Layton690c5e32011-10-19 15:30:16 -04003314 /* move first page to the tmplist */
3315 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3316 list_move_tail(&page->lru, &tmplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003317
Jeff Layton690c5e32011-10-19 15:30:16 -04003318 /* now try and add more pages onto the request */
3319 expected_index = page->index + 1;
3320 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3321 /* discontinuity ? */
3322 if (page->index != expected_index)
3323 break;
3324
3325 /* would this page push the read over the rsize? */
3326 if (bytes + PAGE_CACHE_SIZE > rsize)
3327 break;
3328
3329 __set_page_locked(page);
3330 if (add_to_page_cache_locked(page, mapping,
3331 page->index, GFP_KERNEL)) {
3332 __clear_page_locked(page);
3333 break;
3334 }
3335 list_move_tail(&page->lru, &tmplist);
3336 bytes += PAGE_CACHE_SIZE;
3337 expected_index++;
3338 nr_pages++;
3339 }
3340
Jeff Layton0471ca32012-05-16 07:13:16 -04003341 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
Jeff Layton690c5e32011-10-19 15:30:16 -04003342 if (!rdata) {
3343 /* best to give up if we're out of mem */
3344 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3345 list_del(&page->lru);
3346 lru_cache_add_file(page);
3347 unlock_page(page);
3348 page_cache_release(page);
3349 }
3350 rc = -ENOMEM;
3351 break;
3352 }
3353
Jeff Layton6993f742012-05-16 07:13:17 -04003354 rdata->cfile = cifsFileInfo_get(open_file);
Jeff Layton690c5e32011-10-19 15:30:16 -04003355 rdata->mapping = mapping;
3356 rdata->offset = offset;
3357 rdata->bytes = bytes;
3358 rdata->pid = pid;
Jeff Layton8321fec2012-09-19 06:22:32 -07003359 rdata->pagesz = PAGE_CACHE_SIZE;
3360 rdata->read_into_pages = cifs_readpages_read_into_pages;
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003361
3362 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3363 list_del(&page->lru);
3364 rdata->pages[rdata->nr_pages++] = page;
3365 }
Jeff Layton690c5e32011-10-19 15:30:16 -04003366
Jeff Layton2a1bb132012-05-16 07:13:17 -04003367 rc = cifs_retry_async_readv(rdata);
Jeff Layton690c5e32011-10-19 15:30:16 -04003368 if (rc != 0) {
Jeff Laytonc5fab6f2012-09-19 06:22:30 -07003369 for (i = 0; i < rdata->nr_pages; i++) {
3370 page = rdata->pages[i];
Jeff Layton690c5e32011-10-19 15:30:16 -04003371 lru_cache_add_file(page);
3372 unlock_page(page);
3373 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003374 }
Jeff Layton6993f742012-05-16 07:13:17 -04003375 kref_put(&rdata->refcount, cifs_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003376 break;
3377 }
Jeff Layton6993f742012-05-16 07:13:17 -04003378
3379 kref_put(&rdata->refcount, cifs_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003380 }
3381
David Howells54afa992013-09-04 17:10:39 +00003382 /* Any pages that have been shown to fscache but didn't get added to
3383 * the pagecache must be uncached before they get returned to the
3384 * allocator.
3385 */
3386 cifs_fscache_readpages_cancel(mapping->host, page_list);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003387 return rc;
3388}
3389
Sachin Prabhua9e9b7b2013-09-13 14:11:56 +01003390/*
3391 * cifs_readpage_worker must be called with the page pinned
3392 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07003393static int cifs_readpage_worker(struct file *file, struct page *page,
3394 loff_t *poffset)
3395{
3396 char *read_data;
3397 int rc;
3398
Suresh Jayaraman56698232010-07-05 18:13:25 +05303399 /* Is the page cached? */
Al Viro496ad9a2013-01-23 17:07:38 -05003400 rc = cifs_readpage_from_fscache(file_inode(file), page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05303401 if (rc == 0)
3402 goto read_complete;
3403
Linus Torvalds1da177e2005-04-16 15:20:36 -07003404 read_data = kmap(page);
3405 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003406
Linus Torvalds1da177e2005-04-16 15:20:36 -07003407 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003408
Linus Torvalds1da177e2005-04-16 15:20:36 -07003409 if (rc < 0)
3410 goto io_error;
3411 else
Joe Perchesf96637b2013-05-04 22:12:25 -05003412 cifs_dbg(FYI, "Bytes read %d\n", rc);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003413
Al Viro496ad9a2013-01-23 17:07:38 -05003414 file_inode(file)->i_atime =
3415 current_fs_time(file_inode(file)->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003416
Linus Torvalds1da177e2005-04-16 15:20:36 -07003417 if (PAGE_CACHE_SIZE > rc)
3418 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3419
3420 flush_dcache_page(page);
3421 SetPageUptodate(page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05303422
3423 /* send this page to the cache */
Al Viro496ad9a2013-01-23 17:07:38 -05003424 cifs_readpage_to_fscache(file_inode(file), page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05303425
Linus Torvalds1da177e2005-04-16 15:20:36 -07003426 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003427
Linus Torvalds1da177e2005-04-16 15:20:36 -07003428io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003429 kunmap(page);
Sachin Prabhu466bd312013-09-13 14:11:57 +01003430 unlock_page(page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05303431
3432read_complete:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003433 return rc;
3434}
3435
3436static int cifs_readpage(struct file *file, struct page *page)
3437{
3438 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3439 int rc = -EACCES;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003440 unsigned int xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003441
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003442 xid = get_xid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07003443
3444 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303445 rc = -EBADF;
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003446 free_xid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303447 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003448 }
3449
Joe Perchesf96637b2013-05-04 22:12:25 -05003450 cifs_dbg(FYI, "readpage %p at offset %d 0x%x\n",
Joe Perchesb6b38f72010-04-21 03:50:45 +00003451 page, (int)offset, (int)offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003452
3453 rc = cifs_readpage_worker(file, page, &offset);
3454
Pavel Shilovsky6d5786a2012-06-20 11:21:16 +04003455 free_xid(xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003456 return rc;
3457}
3458
Steve Frencha403a0a2007-07-26 15:54:16 +00003459static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3460{
3461 struct cifsFileInfo *open_file;
3462
Jeff Layton44772882010-10-15 15:34:03 -04003463 spin_lock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003464 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2e396b82010-10-15 15:34:01 -04003465 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Jeff Layton44772882010-10-15 15:34:03 -04003466 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003467 return 1;
3468 }
3469 }
Jeff Layton44772882010-10-15 15:34:03 -04003470 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003471 return 0;
3472}
3473
Linus Torvalds1da177e2005-04-16 15:20:36 -07003474/* We do not want to update the file size from server for inodes
3475 open for write - to avoid races with writepage extending
3476 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003477 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07003478 but this is tricky to do without racing with writebehind
3479 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00003480bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003481{
Steve Frencha403a0a2007-07-26 15:54:16 +00003482 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00003483 return true;
Steve French23e7dd72005-10-20 13:44:56 -07003484
Steve Frencha403a0a2007-07-26 15:54:16 +00003485 if (is_inode_writable(cifsInode)) {
3486 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08003487 struct cifs_sb_info *cifs_sb;
3488
Steve Frenchc32a0b62006-01-12 14:41:28 -08003489 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00003490 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003491 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08003492 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00003493 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08003494 }
3495
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003496 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00003497 return true;
Steve French7ba52632007-02-08 18:14:13 +00003498
Steve French4b18f2a2008-04-29 00:06:05 +00003499 return false;
Steve French23e7dd72005-10-20 13:44:56 -07003500 } else
Steve French4b18f2a2008-04-29 00:06:05 +00003501 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003502}
3503
Nick Piggind9414772008-09-24 11:32:59 -04003504static int cifs_write_begin(struct file *file, struct address_space *mapping,
3505 loff_t pos, unsigned len, unsigned flags,
3506 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003507{
Sachin Prabhu466bd312013-09-13 14:11:57 +01003508 int oncethru = 0;
Nick Piggind9414772008-09-24 11:32:59 -04003509 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3510 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003511 loff_t page_start = pos & PAGE_MASK;
3512 loff_t i_size;
3513 struct page *page;
3514 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003515
Joe Perchesf96637b2013-05-04 22:12:25 -05003516 cifs_dbg(FYI, "write_begin from %lld len %d\n", (long long)pos, len);
Nick Piggind9414772008-09-24 11:32:59 -04003517
Sachin Prabhu466bd312013-09-13 14:11:57 +01003518start:
Nick Piggin54566b22009-01-04 12:00:53 -08003519 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003520 if (!page) {
3521 rc = -ENOMEM;
3522 goto out;
3523 }
Nick Piggind9414772008-09-24 11:32:59 -04003524
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003525 if (PageUptodate(page))
3526 goto out;
Steve French8a236262007-03-06 00:31:00 +00003527
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003528 /*
3529 * If we write a full page it will be up to date, no need to read from
3530 * the server. If the write is short, we'll end up doing a sync write
3531 * instead.
3532 */
3533 if (len == PAGE_CACHE_SIZE)
3534 goto out;
3535
3536 /*
3537 * optimize away the read when we have an oplock, and we're not
3538 * expecting to use any of the data we'd be reading in. That
3539 * is, when the page lies beyond the EOF, or straddles the EOF
3540 * and the write will cover all of the existing data.
3541 */
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003542 if (CIFS_CACHE_READ(CIFS_I(mapping->host))) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003543 i_size = i_size_read(mapping->host);
3544 if (page_start >= i_size ||
3545 (offset == 0 && (pos + len) >= i_size)) {
3546 zero_user_segments(page, 0, offset,
3547 offset + len,
3548 PAGE_CACHE_SIZE);
3549 /*
3550 * PageChecked means that the parts of the page
3551 * to which we're not writing are considered up
3552 * to date. Once the data is copied to the
3553 * page, it can be set uptodate.
3554 */
3555 SetPageChecked(page);
3556 goto out;
3557 }
3558 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003559
Sachin Prabhu466bd312013-09-13 14:11:57 +01003560 if ((file->f_flags & O_ACCMODE) != O_WRONLY && !oncethru) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003561 /*
3562 * might as well read a page, it is fast enough. If we get
3563 * an error, we don't need to return it. cifs_write_end will
3564 * do a sync write instead since PG_uptodate isn't set.
3565 */
3566 cifs_readpage_worker(file, page, &page_start);
Sachin Prabhu466bd312013-09-13 14:11:57 +01003567 page_cache_release(page);
3568 oncethru = 1;
3569 goto start;
Steve French8a236262007-03-06 00:31:00 +00003570 } else {
3571 /* we could try using another file handle if there is one -
3572 but how would we lock it to prevent close of that handle
3573 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04003574 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00003575 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003576out:
3577 *pagep = page;
3578 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003579}
3580
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303581static int cifs_release_page(struct page *page, gfp_t gfp)
3582{
3583 if (PagePrivate(page))
3584 return 0;
3585
3586 return cifs_fscache_release_page(page, gfp);
3587}
3588
Lukas Czernerd47992f2013-05-21 23:17:23 -04003589static void cifs_invalidate_page(struct page *page, unsigned int offset,
3590 unsigned int length)
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303591{
3592 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3593
Lukas Czernerd47992f2013-05-21 23:17:23 -04003594 if (offset == 0 && length == PAGE_CACHE_SIZE)
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303595 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3596}
3597
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003598static int cifs_launder_page(struct page *page)
3599{
3600 int rc = 0;
3601 loff_t range_start = page_offset(page);
3602 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3603 struct writeback_control wbc = {
3604 .sync_mode = WB_SYNC_ALL,
3605 .nr_to_write = 0,
3606 .range_start = range_start,
3607 .range_end = range_end,
3608 };
3609
Joe Perchesf96637b2013-05-04 22:12:25 -05003610 cifs_dbg(FYI, "Launder page: %p\n", page);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003611
3612 if (clear_page_dirty_for_io(page))
3613 rc = cifs_writepage_locked(page, &wbc);
3614
3615 cifs_fscache_invalidate_page(page, page->mapping->host);
3616 return rc;
3617}
3618
Tejun Heo9b646972010-07-20 22:09:02 +02003619void cifs_oplock_break(struct work_struct *work)
Jeff Layton3bc303c2009-09-21 06:47:50 -04003620{
3621 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3622 oplock_break);
Jeff Laytona5e18bc2010-10-11 15:07:18 -04003623 struct inode *inode = cfile->dentry->d_inode;
Jeff Layton3bc303c2009-09-21 06:47:50 -04003624 struct cifsInodeInfo *cinode = CIFS_I(inode);
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -07003625 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04003626 int rc = 0;
Jeff Layton3bc303c2009-09-21 06:47:50 -04003627
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003628 if (!CIFS_CACHE_WRITE(cinode) && CIFS_CACHE_READ(cinode) &&
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04003629 cifs_has_mand_locks(cinode)) {
Joe Perchesf96637b2013-05-04 22:12:25 -05003630 cifs_dbg(FYI, "Reset oplock to None for inode=%p due to mand locks\n",
3631 inode);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003632 cinode->oplock = 0;
Pavel Shilovsky63b7d3a2012-12-24 14:41:19 +04003633 }
3634
Jeff Layton3bc303c2009-09-21 06:47:50 -04003635 if (inode && S_ISREG(inode->i_mode)) {
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003636 if (CIFS_CACHE_READ(cinode))
Al Viro8737c932009-12-24 06:47:55 -05003637 break_lease(inode, O_RDONLY);
Steve Frenchd54ff732010-04-27 04:38:15 +00003638 else
Al Viro8737c932009-12-24 06:47:55 -05003639 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003640 rc = filemap_fdatawrite(inode->i_mapping);
Pavel Shilovsky18cceb62013-09-05 13:01:06 +04003641 if (!CIFS_CACHE_READ(cinode)) {
Jeff Laytoneb4b7562010-10-22 14:52:29 -04003642 rc = filemap_fdatawait(inode->i_mapping);
3643 mapping_set_error(inode->i_mapping, rc);
Pavel Shilovsky03eca702012-12-06 21:24:33 +04003644 cifs_invalidate_mapping(inode);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003645 }
Joe Perchesf96637b2013-05-04 22:12:25 -05003646 cifs_dbg(FYI, "Oplock flush inode %p rc %d\n", inode, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003647 }
3648
Pavel Shilovsky85160e02011-10-22 15:33:29 +04003649 rc = cifs_push_locks(cfile);
3650 if (rc)
Joe Perchesf96637b2013-05-04 22:12:25 -05003651 cifs_dbg(VFS, "Push locks rc = %d\n", rc);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04003652
Jeff Layton3bc303c2009-09-21 06:47:50 -04003653 /*
3654 * releasing stale oplock after recent reconnect of smb session using
3655 * a now incorrect file handle is not a data integrity issue but do
3656 * not bother sending an oplock release if session to server still is
3657 * disconnected since oplock already released by the server
3658 */
Steve Frenchcdff08e2010-10-21 22:46:14 +00003659 if (!cfile->oplock_break_cancelled) {
Pavel Shilovsky95a3f2f2012-09-18 16:20:33 -07003660 rc = tcon->ses->server->ops->oplock_response(tcon, &cfile->fid,
3661 cinode);
Joe Perchesf96637b2013-05-04 22:12:25 -05003662 cifs_dbg(FYI, "Oplock release rc = %d\n", rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003663 }
Jeff Layton3bc303c2009-09-21 06:47:50 -04003664}
3665
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07003666const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003667 .readpage = cifs_readpage,
3668 .readpages = cifs_readpages,
3669 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07003670 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04003671 .write_begin = cifs_write_begin,
3672 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003673 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303674 .releasepage = cifs_release_page,
3675 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003676 .launder_page = cifs_launder_page,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003677};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003678
3679/*
3680 * cifs_readpages requires the server to support a buffer large enough to
3681 * contain the header plus one complete page of data. Otherwise, we need
3682 * to leave cifs_readpages out of the address space operations.
3683 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07003684const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003685 .readpage = cifs_readpage,
3686 .writepage = cifs_writepage,
3687 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04003688 .write_begin = cifs_write_begin,
3689 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003690 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303691 .releasepage = cifs_release_page,
3692 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003693 .launder_page = cifs_launder_page,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003694};