blob: ac71f85cff723e53f1df86597a15bf488d2687d9 [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
Linus Torvalds1da177e2005-04-16 15:20:36 -070046static inline int cifs_convert_flags(unsigned int flags)
47{
48 if ((flags & O_ACCMODE) == O_RDONLY)
49 return GENERIC_READ;
50 else if ((flags & O_ACCMODE) == O_WRONLY)
51 return GENERIC_WRITE;
52 else if ((flags & O_ACCMODE) == O_RDWR) {
53 /* GENERIC_ALL is too much permission to request
54 can cause unnecessary access denied on create */
55 /* return GENERIC_ALL; */
56 return (GENERIC_READ | GENERIC_WRITE);
57 }
58
Jeff Laytone10f7b52008-05-14 10:21:33 -070059 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
60 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
61 FILE_READ_DATA);
Steve French7fc8f4e2009-02-23 20:43:11 +000062}
Jeff Laytone10f7b52008-05-14 10:21:33 -070063
Jeff Layton608712f2010-10-15 15:33:56 -040064static u32 cifs_posix_convert_flags(unsigned int flags)
Steve French7fc8f4e2009-02-23 20:43:11 +000065{
Jeff Layton608712f2010-10-15 15:33:56 -040066 u32 posix_flags = 0;
Jeff Laytone10f7b52008-05-14 10:21:33 -070067
Steve French7fc8f4e2009-02-23 20:43:11 +000068 if ((flags & O_ACCMODE) == O_RDONLY)
Jeff Layton608712f2010-10-15 15:33:56 -040069 posix_flags = SMB_O_RDONLY;
Steve French7fc8f4e2009-02-23 20:43:11 +000070 else if ((flags & O_ACCMODE) == O_WRONLY)
Jeff Layton608712f2010-10-15 15:33:56 -040071 posix_flags = SMB_O_WRONLY;
72 else if ((flags & O_ACCMODE) == O_RDWR)
73 posix_flags = SMB_O_RDWR;
74
75 if (flags & O_CREAT)
76 posix_flags |= SMB_O_CREAT;
77 if (flags & O_EXCL)
78 posix_flags |= SMB_O_EXCL;
79 if (flags & O_TRUNC)
80 posix_flags |= SMB_O_TRUNC;
81 /* be safe and imply O_SYNC for O_DSYNC */
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +010082 if (flags & O_DSYNC)
Jeff Layton608712f2010-10-15 15:33:56 -040083 posix_flags |= SMB_O_SYNC;
Steve French7fc8f4e2009-02-23 20:43:11 +000084 if (flags & O_DIRECTORY)
Jeff Layton608712f2010-10-15 15:33:56 -040085 posix_flags |= SMB_O_DIRECTORY;
Steve French7fc8f4e2009-02-23 20:43:11 +000086 if (flags & O_NOFOLLOW)
Jeff Layton608712f2010-10-15 15:33:56 -040087 posix_flags |= SMB_O_NOFOLLOW;
Steve French7fc8f4e2009-02-23 20:43:11 +000088 if (flags & O_DIRECT)
Jeff Layton608712f2010-10-15 15:33:56 -040089 posix_flags |= SMB_O_DIRECT;
Steve French7fc8f4e2009-02-23 20:43:11 +000090
91 return posix_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092}
93
94static inline int cifs_get_disposition(unsigned int flags)
95{
96 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
97 return FILE_CREATE;
98 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
99 return FILE_OVERWRITE_IF;
100 else if ((flags & O_CREAT) == O_CREAT)
101 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +0000102 else if ((flags & O_TRUNC) == O_TRUNC)
103 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700104 else
105 return FILE_OPEN;
106}
107
Jeff Layton608712f2010-10-15 15:33:56 -0400108int cifs_posix_open(char *full_path, struct inode **pinode,
109 struct super_block *sb, int mode, unsigned int f_flags,
110 __u32 *poplock, __u16 *pnetfid, int xid)
111{
112 int rc;
113 FILE_UNIX_BASIC_INFO *presp_data;
114 __u32 posix_flags = 0;
115 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
116 struct cifs_fattr fattr;
117 struct tcon_link *tlink;
Steve French96daf2b2011-05-27 04:34:02 +0000118 struct cifs_tcon *tcon;
Jeff Layton608712f2010-10-15 15:33:56 -0400119
120 cFYI(1, "posix open %s", full_path);
121
122 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
123 if (presp_data == NULL)
124 return -ENOMEM;
125
126 tlink = cifs_sb_tlink(cifs_sb);
127 if (IS_ERR(tlink)) {
128 rc = PTR_ERR(tlink);
129 goto posix_open_ret;
130 }
131
132 tcon = tlink_tcon(tlink);
133 mode &= ~current_umask();
134
135 posix_flags = cifs_posix_convert_flags(f_flags);
136 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
137 poplock, full_path, cifs_sb->local_nls,
138 cifs_sb->mnt_cifs_flags &
139 CIFS_MOUNT_MAP_SPECIAL_CHR);
140 cifs_put_tlink(tlink);
141
142 if (rc)
143 goto posix_open_ret;
144
145 if (presp_data->Type == cpu_to_le32(-1))
146 goto posix_open_ret; /* open ok, caller does qpathinfo */
147
148 if (!pinode)
149 goto posix_open_ret; /* caller does not need info */
150
151 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
152
153 /* get new inode and set it up */
154 if (*pinode == NULL) {
155 cifs_fill_uniqueid(sb, &fattr);
156 *pinode = cifs_iget(sb, &fattr);
157 if (!*pinode) {
158 rc = -ENOMEM;
159 goto posix_open_ret;
160 }
161 } else {
162 cifs_fattr_to_inode(*pinode, &fattr);
163 }
164
165posix_open_ret:
166 kfree(presp_data);
167 return rc;
168}
169
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300170static int
171cifs_nt_open(char *full_path, struct inode *inode, struct cifs_sb_info *cifs_sb,
Steve French96daf2b2011-05-27 04:34:02 +0000172 struct cifs_tcon *tcon, unsigned int f_flags, __u32 *poplock,
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300173 __u16 *pnetfid, int xid)
174{
175 int rc;
176 int desiredAccess;
177 int disposition;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500178 int create_options = CREATE_NOT_DIR;
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300179 FILE_ALL_INFO *buf;
180
181 desiredAccess = cifs_convert_flags(f_flags);
182
183/*********************************************************************
184 * open flag mapping table:
185 *
186 * POSIX Flag CIFS Disposition
187 * ---------- ----------------
188 * O_CREAT FILE_OPEN_IF
189 * O_CREAT | O_EXCL FILE_CREATE
190 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
191 * O_TRUNC FILE_OVERWRITE
192 * none of the above FILE_OPEN
193 *
194 * Note that there is not a direct match between disposition
195 * FILE_SUPERSEDE (ie create whether or not file exists although
196 * O_CREAT | O_TRUNC is similar but truncates the existing
197 * file rather than creating a new file as FILE_SUPERSEDE does
198 * (which uses the attributes / metadata passed in on open call)
199 *?
200 *? O_SYNC is a reasonable match to CIFS writethrough flag
201 *? and the read write flags match reasonably. O_LARGEFILE
202 *? is irrelevant because largefile support is always used
203 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
204 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
205 *********************************************************************/
206
207 disposition = cifs_get_disposition(f_flags);
208
209 /* BB pass O_SYNC flag through on file attributes .. BB */
210
211 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
212 if (!buf)
213 return -ENOMEM;
214
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500215 if (backup_cred(cifs_sb))
216 create_options |= CREATE_OPEN_BACKUP_INTENT;
217
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300218 if (tcon->ses->capabilities & CAP_NT_SMBS)
219 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500220 desiredAccess, create_options, pnetfid, poplock, buf,
Pavel Shilovskyeeb910a2010-11-25 15:12:39 +0300221 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
222 & CIFS_MOUNT_MAP_SPECIAL_CHR);
223 else
224 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
225 desiredAccess, CREATE_NOT_DIR, pnetfid, poplock, buf,
226 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
227 & CIFS_MOUNT_MAP_SPECIAL_CHR);
228
229 if (rc)
230 goto out;
231
232 if (tcon->unix_ext)
233 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
234 xid);
235 else
236 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
237 xid, pnetfid);
238
239out:
240 kfree(buf);
241 return rc;
242}
243
Jeff Layton15ecb432010-10-15 15:34:02 -0400244struct cifsFileInfo *
245cifs_new_fileinfo(__u16 fileHandle, struct file *file,
246 struct tcon_link *tlink, __u32 oplock)
247{
248 struct dentry *dentry = file->f_path.dentry;
249 struct inode *inode = dentry->d_inode;
250 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
251 struct cifsFileInfo *pCifsFile;
252
253 pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
254 if (pCifsFile == NULL)
255 return pCifsFile;
256
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400257 pCifsFile->count = 1;
Jeff Layton15ecb432010-10-15 15:34:02 -0400258 pCifsFile->netfid = fileHandle;
259 pCifsFile->pid = current->tgid;
260 pCifsFile->uid = current_fsuid();
261 pCifsFile->dentry = dget(dentry);
262 pCifsFile->f_flags = file->f_flags;
263 pCifsFile->invalidHandle = false;
Jeff Layton15ecb432010-10-15 15:34:02 -0400264 pCifsFile->tlink = cifs_get_tlink(tlink);
265 mutex_init(&pCifsFile->fh_mutex);
Jeff Layton15ecb432010-10-15 15:34:02 -0400266 INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300267 INIT_LIST_HEAD(&pCifsFile->llist);
Jeff Layton15ecb432010-10-15 15:34:02 -0400268
Jeff Layton44772882010-10-15 15:34:03 -0400269 spin_lock(&cifs_file_list_lock);
Jeff Layton15ecb432010-10-15 15:34:02 -0400270 list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
271 /* if readable file instance put first in list*/
272 if (file->f_mode & FMODE_READ)
273 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
274 else
275 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
Jeff Layton44772882010-10-15 15:34:03 -0400276 spin_unlock(&cifs_file_list_lock);
Jeff Layton15ecb432010-10-15 15:34:02 -0400277
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300278 cifs_set_oplock_level(pCifsInode, oplock);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400279 pCifsInode->can_cache_brlcks = pCifsInode->clientCanCacheAll;
Jeff Layton15ecb432010-10-15 15:34:02 -0400280
281 file->private_data = pCifsFile;
282 return pCifsFile;
283}
284
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400285static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
286
Steve Frenchcdff08e2010-10-21 22:46:14 +0000287/*
288 * Release a reference on the file private data. This may involve closing
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400289 * the filehandle out on the server. Must be called without holding
290 * cifs_file_list_lock.
Steve Frenchcdff08e2010-10-21 22:46:14 +0000291 */
Jeff Laytonb33879a2010-10-15 15:34:04 -0400292void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
293{
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300294 struct inode *inode = cifs_file->dentry->d_inode;
Steve French96daf2b2011-05-27 04:34:02 +0000295 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300296 struct cifsInodeInfo *cifsi = CIFS_I(inode);
Pavel Shilovsky4f8ba8a2010-11-21 22:36:12 +0300297 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000298 struct cifsLockInfo *li, *tmp;
299
300 spin_lock(&cifs_file_list_lock);
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400301 if (--cifs_file->count > 0) {
Steve Frenchcdff08e2010-10-21 22:46:14 +0000302 spin_unlock(&cifs_file_list_lock);
303 return;
Jeff Laytonb33879a2010-10-15 15:34:04 -0400304 }
Steve Frenchcdff08e2010-10-21 22:46:14 +0000305
306 /* remove it from the lists */
307 list_del(&cifs_file->flist);
308 list_del(&cifs_file->tlist);
309
310 if (list_empty(&cifsi->openFileList)) {
311 cFYI(1, "closing last open instance for inode %p",
312 cifs_file->dentry->d_inode);
Pavel Shilovsky4f8ba8a2010-11-21 22:36:12 +0300313
314 /* in strict cache mode we need invalidate mapping on the last
315 close because it may cause a error when we open this file
316 again and get at least level II oplock */
317 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
318 CIFS_I(inode)->invalid_mapping = true;
319
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300320 cifs_set_oplock_level(cifsi, 0);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000321 }
322 spin_unlock(&cifs_file_list_lock);
323
Jeff Laytonad635942011-07-26 12:20:17 -0400324 cancel_work_sync(&cifs_file->oplock_break);
325
Steve Frenchcdff08e2010-10-21 22:46:14 +0000326 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
327 int xid, rc;
328
329 xid = GetXid();
330 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
331 FreeXid(xid);
332 }
333
334 /* Delete any outstanding lock records. We'll lose them when the file
335 * is closed anyway.
336 */
Pavel Shilovskyd59dad22011-09-22 09:53:59 +0400337 mutex_lock(&cifsi->lock_mutex);
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300338 list_for_each_entry_safe(li, tmp, &cifs_file->llist, llist) {
Steve Frenchcdff08e2010-10-21 22:46:14 +0000339 list_del(&li->llist);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400340 cifs_del_lock_waiters(li);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000341 kfree(li);
342 }
Pavel Shilovskyd59dad22011-09-22 09:53:59 +0400343 mutex_unlock(&cifsi->lock_mutex);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000344
345 cifs_put_tlink(cifs_file->tlink);
346 dput(cifs_file->dentry);
347 kfree(cifs_file);
Jeff Laytonb33879a2010-10-15 15:34:04 -0400348}
349
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350int cifs_open(struct inode *inode, struct file *file)
351{
352 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400353 int xid;
354 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700355 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +0000356 struct cifs_tcon *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400357 struct tcon_link *tlink;
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400358 struct cifsFileInfo *pCifsFile = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359 char *full_path = NULL;
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300360 bool posix_open_ok = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700361 __u16 netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362
363 xid = GetXid();
364
365 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400366 tlink = cifs_sb_tlink(cifs_sb);
367 if (IS_ERR(tlink)) {
368 FreeXid(xid);
369 return PTR_ERR(tlink);
370 }
371 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700372
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800373 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530375 rc = -ENOMEM;
Jeff Layton232341b2010-08-05 13:58:38 -0400376 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700377 }
378
Joe Perchesb6b38f72010-04-21 03:50:45 +0000379 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
380 inode, file->f_flags, full_path);
Steve French276a74a2009-03-03 18:00:34 +0000381
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300382 if (tcon->ses->server->oplocks)
Steve French276a74a2009-03-03 18:00:34 +0000383 oplock = REQ_OPLOCK;
384 else
385 oplock = 0;
386
Steve French64cc2c62009-03-04 19:54:08 +0000387 if (!tcon->broken_posix_open && tcon->unix_ext &&
388 (tcon->ses->capabilities & CAP_UNIX) &&
Steve French276a74a2009-03-03 18:00:34 +0000389 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
390 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Steve French276a74a2009-03-03 18:00:34 +0000391 /* can not refresh inode info since size could be stale */
Jeff Layton2422f672010-06-16 13:40:16 -0400392 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000393 cifs_sb->mnt_file_mode /* ignored */,
Jeff Layton608712f2010-10-15 15:33:56 -0400394 file->f_flags, &oplock, &netfid, xid);
Steve French276a74a2009-03-03 18:00:34 +0000395 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000396 cFYI(1, "posix open succeeded");
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300397 posix_open_ok = true;
Steve French64cc2c62009-03-04 19:54:08 +0000398 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
399 if (tcon->ses->serverNOS)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000400 cERROR(1, "server %s of type %s returned"
Steve French64cc2c62009-03-04 19:54:08 +0000401 " unexpected error on SMB posix open"
402 ", disabling posix open support."
403 " Check if server update available.",
404 tcon->ses->serverName,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000405 tcon->ses->serverNOS);
Steve French64cc2c62009-03-04 19:54:08 +0000406 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000407 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
408 (rc != -EOPNOTSUPP)) /* path not found or net err */
409 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000410 /* else fallthrough to retry open the old way on network i/o
411 or DFS errors */
Steve French276a74a2009-03-03 18:00:34 +0000412 }
413
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300414 if (!posix_open_ok) {
415 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
416 file->f_flags, &oplock, &netfid, xid);
417 if (rc)
418 goto out;
419 }
Jeff Layton47c78b72010-06-16 13:40:17 -0400420
Jeff Laytonabfe1ee2010-10-15 15:33:58 -0400421 pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400422 if (pCifsFile == NULL) {
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300423 CIFSSMBClose(xid, tcon, netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 rc = -ENOMEM;
425 goto out;
426 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530428 cifs_fscache_set_inode_cookie(inode, file);
429
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300430 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 /* time to set mode which we can not set earlier due to
432 problems creating new read-only files */
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300433 struct cifs_unix_set_info_args args = {
434 .mode = inode->i_mode,
435 .uid = NO_CHANGE_64,
436 .gid = NO_CHANGE_64,
437 .ctime = NO_CHANGE_64,
438 .atime = NO_CHANGE_64,
439 .mtime = NO_CHANGE_64,
440 .device = 0,
441 };
Jeff Laytond44a9fe2011-01-07 11:30:29 -0500442 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
443 pCifsFile->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444 }
445
446out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 kfree(full_path);
448 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400449 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700450 return rc;
451}
452
Adrian Bunk04187262006-06-30 18:23:04 +0200453/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454/* to server was lost */
455static int cifs_relock_file(struct cifsFileInfo *cifsFile)
456{
457 int rc = 0;
458
459/* BB list all locks open on this file and relock */
460
461 return rc;
462}
463
Jeff Layton15886172010-10-15 15:33:59 -0400464static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700465{
466 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400467 int xid;
468 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700469 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +0000470 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000472 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700473 char *full_path = NULL;
474 int desiredAccess;
475 int disposition = FILE_OPEN;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500476 int create_options = CREATE_NOT_DIR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700477 __u16 netfid;
478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 xid = GetXid();
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400480 mutex_lock(&pCifsFile->fh_mutex);
Steve French4b18f2a2008-04-29 00:06:05 +0000481 if (!pCifsFile->invalidHandle) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400482 mutex_unlock(&pCifsFile->fh_mutex);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530483 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700484 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530485 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700486 }
487
Jeff Layton15886172010-10-15 15:33:59 -0400488 inode = pCifsFile->dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton13cfb732010-09-29 19:51:11 -0400490 tcon = tlink_tcon(pCifsFile->tlink);
Steve French3a9f4622007-04-04 17:10:24 +0000491
Linus Torvalds1da177e2005-04-16 15:20:36 -0700492/* can not grab rename sem here because various ops, including
493 those that already have the rename sem can end up causing writepage
494 to get called and if the server was down that means we end up here,
495 and we can never tell if the caller already has the rename_sem */
Jeff Layton15886172010-10-15 15:33:59 -0400496 full_path = build_path_from_dentry(pCifsFile->dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700497 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000498 rc = -ENOMEM;
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400499 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700500 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000501 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502 }
503
Joe Perchesb6b38f72010-04-21 03:50:45 +0000504 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
Jeff Layton15886172010-10-15 15:33:59 -0400505 inode, pCifsFile->f_flags, full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506
Pavel Shilovsky10b9b982012-03-20 12:55:09 +0300507 if (tcon->ses->server->oplocks)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508 oplock = REQ_OPLOCK;
509 else
Steve French4b18f2a2008-04-29 00:06:05 +0000510 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700511
Steve French7fc8f4e2009-02-23 20:43:11 +0000512 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
513 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
514 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton608712f2010-10-15 15:33:56 -0400515
516 /*
517 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
518 * original open. Must mask them off for a reopen.
519 */
Jeff Layton15886172010-10-15 15:33:59 -0400520 unsigned int oflags = pCifsFile->f_flags &
521 ~(O_CREAT | O_EXCL | O_TRUNC);
Jeff Layton608712f2010-10-15 15:33:56 -0400522
Jeff Layton2422f672010-06-16 13:40:16 -0400523 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000524 cifs_sb->mnt_file_mode /* ignored */,
525 oflags, &oplock, &netfid, xid);
Steve French7fc8f4e2009-02-23 20:43:11 +0000526 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000527 cFYI(1, "posix reopen succeeded");
Steve French7fc8f4e2009-02-23 20:43:11 +0000528 goto reopen_success;
529 }
530 /* fallthrough to retry open the old way on errors, especially
531 in the reconnect path it is important to retry hard */
532 }
533
Jeff Layton15886172010-10-15 15:33:59 -0400534 desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
Steve French7fc8f4e2009-02-23 20:43:11 +0000535
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500536 if (backup_cred(cifs_sb))
537 create_options |= CREATE_OPEN_BACKUP_INTENT;
538
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000540 by SMBOpen and then calling get_inode_info with returned buf
541 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 and server version of file size can be stale. If we knew for sure
543 that inode was not dirty locally we could do this */
544
Steve French7fc8f4e2009-02-23 20:43:11 +0000545 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500546 create_options, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000547 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700548 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 if (rc) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400550 mutex_unlock(&pCifsFile->fh_mutex);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000551 cFYI(1, "cifs_open returned 0x%x", rc);
552 cFYI(1, "oplock: %d", oplock);
Jeff Layton15886172010-10-15 15:33:59 -0400553 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 }
Jeff Layton15886172010-10-15 15:33:59 -0400555
556reopen_success:
557 pCifsFile->netfid = netfid;
558 pCifsFile->invalidHandle = false;
559 mutex_unlock(&pCifsFile->fh_mutex);
560 pCifsInode = CIFS_I(inode);
561
562 if (can_flush) {
563 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -0400564 mapping_set_error(inode->i_mapping, rc);
Jeff Layton15886172010-10-15 15:33:59 -0400565
Jeff Layton15886172010-10-15 15:33:59 -0400566 if (tcon->unix_ext)
567 rc = cifs_get_inode_info_unix(&inode,
568 full_path, inode->i_sb, xid);
569 else
570 rc = cifs_get_inode_info(&inode,
571 full_path, NULL, inode->i_sb,
572 xid, NULL);
573 } /* else we are writing out data to server already
574 and could deadlock if we tried to flush data, and
575 since we do not know if we have data that would
576 invalidate the current end of file on the server
577 we can not go to the server to get the new inod
578 info */
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300579
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300580 cifs_set_oplock_level(pCifsInode, oplock);
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300581
Jeff Layton15886172010-10-15 15:33:59 -0400582 cifs_relock_file(pCifsFile);
583
584reopen_error_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700585 kfree(full_path);
586 FreeXid(xid);
587 return rc;
588}
589
590int cifs_close(struct inode *inode, struct file *file)
591{
Jeff Layton77970692011-04-05 16:23:47 -0700592 if (file->private_data != NULL) {
593 cifsFileInfo_put(file->private_data);
594 file->private_data = NULL;
595 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596
Steve Frenchcdff08e2010-10-21 22:46:14 +0000597 /* return code from the ->release op is always ignored */
598 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599}
600
601int cifs_closedir(struct inode *inode, struct file *file)
602{
603 int rc = 0;
604 int xid;
Joe Perchesc21dfb62010-07-12 13:50:14 -0700605 struct cifsFileInfo *pCFileStruct = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 char *ptmp;
607
Joe Perchesb6b38f72010-04-21 03:50:45 +0000608 cFYI(1, "Closedir inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609
610 xid = GetXid();
611
612 if (pCFileStruct) {
Steve French96daf2b2011-05-27 04:34:02 +0000613 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614
Joe Perchesb6b38f72010-04-21 03:50:45 +0000615 cFYI(1, "Freeing private data in close dir");
Jeff Layton44772882010-10-15 15:34:03 -0400616 spin_lock(&cifs_file_list_lock);
Steve French4b18f2a2008-04-29 00:06:05 +0000617 if (!pCFileStruct->srch_inf.endOfSearch &&
618 !pCFileStruct->invalidHandle) {
619 pCFileStruct->invalidHandle = true;
Jeff Layton44772882010-10-15 15:34:03 -0400620 spin_unlock(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700621 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000622 cFYI(1, "Closing uncompleted readdir with rc %d",
623 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700624 /* not much we can do if it fails anyway, ignore rc */
625 rc = 0;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000626 } else
Jeff Layton44772882010-10-15 15:34:03 -0400627 spin_unlock(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700628 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
629 if (ptmp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000630 cFYI(1, "closedir free smb buf in srch struct");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000632 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000633 cifs_small_buf_release(ptmp);
634 else
635 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700636 }
Jeff Layton13cfb732010-09-29 19:51:11 -0400637 cifs_put_tlink(pCFileStruct->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700638 kfree(file->private_data);
639 file->private_data = NULL;
640 }
641 /* BB can we lock the filestruct while this is going on? */
642 FreeXid(xid);
643 return rc;
644}
645
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400646static struct cifsLockInfo *
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300647cifs_lock_init(__u64 offset, __u64 length, __u8 type)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000648{
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400649 struct cifsLockInfo *lock =
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000650 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400651 if (!lock)
652 return lock;
653 lock->offset = offset;
654 lock->length = length;
655 lock->type = type;
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400656 lock->pid = current->tgid;
657 INIT_LIST_HEAD(&lock->blist);
658 init_waitqueue_head(&lock->block_q);
659 return lock;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400660}
661
662static void
663cifs_del_lock_waiters(struct cifsLockInfo *lock)
664{
665 struct cifsLockInfo *li, *tmp;
666 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
667 list_del_init(&li->blist);
668 wake_up(&li->block_q);
669 }
670}
671
672static bool
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300673cifs_find_fid_lock_conflict(struct cifsFileInfo *cfile, __u64 offset,
674 __u64 length, __u8 type, __u16 netfid,
675 struct cifsLockInfo **conf_lock)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400676{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300677 struct cifsLockInfo *li;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300678 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400679
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300680 list_for_each_entry(li, &cfile->llist, llist) {
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400681 if (offset + length <= li->offset ||
682 offset >= li->offset + li->length)
683 continue;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300684 else if ((type & server->vals->shared_lock_type) &&
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300685 ((netfid == cfile->netfid && current->tgid == li->pid)
686 || type == li->type))
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400687 continue;
688 else {
689 *conf_lock = li;
690 return true;
691 }
692 }
693 return false;
694}
695
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400696static bool
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300697cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
698 __u64 length, __u8 type, __u16 netfid,
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400699 struct cifsLockInfo **conf_lock)
700{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300701 bool rc = false;
702 struct cifsFileInfo *fid, *tmp;
703
704 spin_lock(&cifs_file_list_lock);
705 list_for_each_entry_safe(fid, tmp, &cinode->openFileList, flist) {
706 rc = cifs_find_fid_lock_conflict(fid, offset, length, type,
707 netfid, conf_lock);
708 if (rc)
709 break;
710 }
711 spin_unlock(&cifs_file_list_lock);
712
713 return rc;
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400714}
715
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300716/*
717 * Check if there is another lock that prevents us to set the lock (mandatory
718 * style). If such a lock exists, update the flock structure with its
719 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
720 * or leave it the same if we can't. Returns 0 if we don't need to request to
721 * the server or 1 otherwise.
722 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400723static int
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300724cifs_lock_test(struct cifsFileInfo *cfile, __u64 offset, __u64 length,
725 __u8 type, struct file_lock *flock)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400726{
727 int rc = 0;
728 struct cifsLockInfo *conf_lock;
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300729 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300730 struct TCP_Server_Info *server = tlink_tcon(cfile->tlink)->ses->server;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400731 bool exist;
732
733 mutex_lock(&cinode->lock_mutex);
734
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300735 exist = cifs_find_lock_conflict(cinode, offset, length, type,
736 cfile->netfid, &conf_lock);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400737 if (exist) {
738 flock->fl_start = conf_lock->offset;
739 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
740 flock->fl_pid = conf_lock->pid;
Pavel Shilovsky106dc532012-02-28 14:23:34 +0300741 if (conf_lock->type & server->vals->shared_lock_type)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400742 flock->fl_type = F_RDLCK;
743 else
744 flock->fl_type = F_WRLCK;
745 } else if (!cinode->can_cache_brlcks)
746 rc = 1;
747 else
748 flock->fl_type = F_UNLCK;
749
750 mutex_unlock(&cinode->lock_mutex);
751 return rc;
752}
753
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400754static void
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300755cifs_lock_add(struct cifsFileInfo *cfile, struct cifsLockInfo *lock)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400756{
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300757 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovskyd59dad22011-09-22 09:53:59 +0400758 mutex_lock(&cinode->lock_mutex);
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300759 list_add_tail(&lock->llist, &cfile->llist);
Pavel Shilovskyd59dad22011-09-22 09:53:59 +0400760 mutex_unlock(&cinode->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000761}
762
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300763/*
764 * Set the byte-range lock (mandatory style). Returns:
765 * 1) 0, if we set the lock and don't need to request to the server;
766 * 2) 1, if no locks prevent us but we need to request to the server;
767 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
768 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400769static int
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300770cifs_lock_add_if(struct cifsFileInfo *cfile, struct cifsLockInfo *lock,
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400771 bool wait)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400772{
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400773 struct cifsLockInfo *conf_lock;
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300774 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400775 bool exist;
776 int rc = 0;
777
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400778try_again:
779 exist = false;
780 mutex_lock(&cinode->lock_mutex);
781
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300782 exist = cifs_find_lock_conflict(cinode, lock->offset, lock->length,
783 lock->type, cfile->netfid, &conf_lock);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400784 if (!exist && cinode->can_cache_brlcks) {
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300785 list_add_tail(&lock->llist, &cfile->llist);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400786 mutex_unlock(&cinode->lock_mutex);
787 return rc;
788 }
789
790 if (!exist)
791 rc = 1;
792 else if (!wait)
793 rc = -EACCES;
794 else {
795 list_add_tail(&lock->blist, &conf_lock->blist);
796 mutex_unlock(&cinode->lock_mutex);
797 rc = wait_event_interruptible(lock->block_q,
798 (lock->blist.prev == &lock->blist) &&
799 (lock->blist.next == &lock->blist));
800 if (!rc)
801 goto try_again;
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400802 mutex_lock(&cinode->lock_mutex);
803 list_del_init(&lock->blist);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400804 }
805
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400806 mutex_unlock(&cinode->lock_mutex);
807 return rc;
808}
809
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300810/*
811 * Check if there is another lock that prevents us to set the lock (posix
812 * style). If such a lock exists, update the flock structure with its
813 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
814 * or leave it the same if we can't. Returns 0 if we don't need to request to
815 * the server or 1 otherwise.
816 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400817static int
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400818cifs_posix_lock_test(struct file *file, struct file_lock *flock)
819{
820 int rc = 0;
821 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
822 unsigned char saved_type = flock->fl_type;
823
Pavel Shilovsky50792762011-10-29 17:17:57 +0400824 if ((flock->fl_flags & FL_POSIX) == 0)
825 return 1;
826
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400827 mutex_lock(&cinode->lock_mutex);
828 posix_test_lock(file, flock);
829
830 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
831 flock->fl_type = saved_type;
832 rc = 1;
833 }
834
835 mutex_unlock(&cinode->lock_mutex);
836 return rc;
837}
838
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300839/*
840 * Set the byte-range lock (posix style). Returns:
841 * 1) 0, if we set the lock and don't need to request to the server;
842 * 2) 1, if we need to request to the server;
843 * 3) <0, if the error occurs while setting the lock.
844 */
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400845static int
846cifs_posix_lock_set(struct file *file, struct file_lock *flock)
847{
848 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
Pavel Shilovsky50792762011-10-29 17:17:57 +0400849 int rc = 1;
850
851 if ((flock->fl_flags & FL_POSIX) == 0)
852 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400853
Pavel Shilovsky66189be2012-03-28 21:56:19 +0400854try_again:
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400855 mutex_lock(&cinode->lock_mutex);
856 if (!cinode->can_cache_brlcks) {
857 mutex_unlock(&cinode->lock_mutex);
Pavel Shilovsky50792762011-10-29 17:17:57 +0400858 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400859 }
Pavel Shilovsky66189be2012-03-28 21:56:19 +0400860
861 rc = posix_lock_file(file, flock, NULL);
Steve French9ebb3892012-04-01 13:52:54 -0500862 mutex_unlock(&cinode->lock_mutex);
Pavel Shilovsky66189be2012-03-28 21:56:19 +0400863 if (rc == FILE_LOCK_DEFERRED) {
864 rc = wait_event_interruptible(flock->fl_wait, !flock->fl_next);
865 if (!rc)
866 goto try_again;
867 locks_delete_block(flock);
868 }
Steve French9ebb3892012-04-01 13:52:54 -0500869 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400870}
871
872static int
873cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400874{
875 int xid, rc = 0, stored_rc;
876 struct cifsLockInfo *li, *tmp;
877 struct cifs_tcon *tcon;
878 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +0400879 unsigned int num, max_num;
880 LOCKING_ANDX_RANGE *buf, *cur;
881 int types[] = {LOCKING_ANDX_LARGE_FILES,
882 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
883 int i;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400884
885 xid = GetXid();
886 tcon = tlink_tcon(cfile->tlink);
887
888 mutex_lock(&cinode->lock_mutex);
889 if (!cinode->can_cache_brlcks) {
890 mutex_unlock(&cinode->lock_mutex);
891 FreeXid(xid);
892 return rc;
893 }
894
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +0400895 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
896 sizeof(LOCKING_ANDX_RANGE);
897 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
898 if (!buf) {
899 mutex_unlock(&cinode->lock_mutex);
900 FreeXid(xid);
901 return rc;
902 }
903
904 for (i = 0; i < 2; i++) {
905 cur = buf;
906 num = 0;
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +0300907 list_for_each_entry_safe(li, tmp, &cfile->llist, llist) {
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +0400908 if (li->type != types[i])
909 continue;
910 cur->Pid = cpu_to_le16(li->pid);
911 cur->LengthLow = cpu_to_le32((u32)li->length);
912 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
913 cur->OffsetLow = cpu_to_le32((u32)li->offset);
914 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
915 if (++num == max_num) {
916 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +0300917 (__u8)li->type, 0, num,
918 buf);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +0400919 if (stored_rc)
920 rc = stored_rc;
921 cur = buf;
922 num = 0;
923 } else
924 cur++;
925 }
926
927 if (num) {
928 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +0300929 (__u8)types[i], 0, num, buf);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +0400930 if (stored_rc)
931 rc = stored_rc;
932 }
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400933 }
934
935 cinode->can_cache_brlcks = false;
936 mutex_unlock(&cinode->lock_mutex);
937
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +0400938 kfree(buf);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400939 FreeXid(xid);
940 return rc;
941}
942
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400943/* copied from fs/locks.c with a name change */
944#define cifs_for_each_lock(inode, lockp) \
945 for (lockp = &inode->i_flock; *lockp != NULL; \
946 lockp = &(*lockp)->fl_next)
947
Pavel Shilovskyd5751462012-03-05 09:39:20 +0300948struct lock_to_push {
949 struct list_head llist;
950 __u64 offset;
951 __u64 length;
952 __u32 pid;
953 __u16 netfid;
954 __u8 type;
955};
956
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400957static int
958cifs_push_posix_locks(struct cifsFileInfo *cfile)
959{
960 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
961 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
962 struct file_lock *flock, **before;
Pavel Shilovskyd5751462012-03-05 09:39:20 +0300963 unsigned int count = 0, i = 0;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400964 int rc = 0, xid, type;
Pavel Shilovskyd5751462012-03-05 09:39:20 +0300965 struct list_head locks_to_send, *el;
966 struct lock_to_push *lck, *tmp;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400967 __u64 length;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400968
969 xid = GetXid();
970
971 mutex_lock(&cinode->lock_mutex);
972 if (!cinode->can_cache_brlcks) {
973 mutex_unlock(&cinode->lock_mutex);
974 FreeXid(xid);
975 return rc;
976 }
977
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400978 lock_flocks();
979 cifs_for_each_lock(cfile->dentry->d_inode, before) {
Pavel Shilovskyd5751462012-03-05 09:39:20 +0300980 if ((*before)->fl_flags & FL_POSIX)
981 count++;
982 }
983 unlock_flocks();
984
985 INIT_LIST_HEAD(&locks_to_send);
986
987 /*
Pavel Shilovskyce858522012-03-17 09:46:55 +0300988 * Allocating count locks is enough because no FL_POSIX locks can be
989 * added to the list while we are holding cinode->lock_mutex that
990 * protects locking operations of this inode.
Pavel Shilovskyd5751462012-03-05 09:39:20 +0300991 */
992 for (; i < count; i++) {
993 lck = kmalloc(sizeof(struct lock_to_push), GFP_KERNEL);
994 if (!lck) {
995 rc = -ENOMEM;
996 goto err_out;
997 }
998 list_add_tail(&lck->llist, &locks_to_send);
999 }
1000
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001001 el = locks_to_send.next;
1002 lock_flocks();
1003 cifs_for_each_lock(cfile->dentry->d_inode, before) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001004 flock = *before;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001005 if ((flock->fl_flags & FL_POSIX) == 0)
1006 continue;
Pavel Shilovskyce858522012-03-17 09:46:55 +03001007 if (el == &locks_to_send) {
1008 /*
1009 * The list ended. We don't have enough allocated
1010 * structures - something is really wrong.
1011 */
1012 cERROR(1, "Can't push all brlocks!");
1013 break;
1014 }
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001015 length = 1 + flock->fl_end - flock->fl_start;
1016 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
1017 type = CIFS_RDLCK;
1018 else
1019 type = CIFS_WRLCK;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001020 lck = list_entry(el, struct lock_to_push, llist);
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001021 lck->pid = flock->fl_pid;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001022 lck->netfid = cfile->netfid;
1023 lck->length = length;
1024 lck->type = type;
1025 lck->offset = flock->fl_start;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001026 el = el->next;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001027 }
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001028 unlock_flocks();
1029
1030 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1031 struct file_lock tmp_lock;
1032 int stored_rc;
1033
1034 tmp_lock.fl_start = lck->offset;
1035 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
1036 0, lck->length, &tmp_lock,
1037 lck->type, 0);
1038 if (stored_rc)
1039 rc = stored_rc;
1040 list_del(&lck->llist);
1041 kfree(lck);
1042 }
1043
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001044out:
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001045 cinode->can_cache_brlcks = false;
1046 mutex_unlock(&cinode->lock_mutex);
1047
1048 FreeXid(xid);
1049 return rc;
Pavel Shilovskyd5751462012-03-05 09:39:20 +03001050err_out:
1051 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
1052 list_del(&lck->llist);
1053 kfree(lck);
1054 }
1055 goto out;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001056}
1057
1058static int
1059cifs_push_locks(struct cifsFileInfo *cfile)
1060{
1061 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1062 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1063
1064 if ((tcon->ses->capabilities & CAP_UNIX) &&
1065 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1066 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1067 return cifs_push_posix_locks(cfile);
1068
1069 return cifs_push_mandatory_locks(cfile);
1070}
1071
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001072static void
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001073cifs_read_flock(struct file_lock *flock, __u32 *type, int *lock, int *unlock,
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001074 bool *wait_flag, struct TCP_Server_Info *server)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001075{
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001076 if (flock->fl_flags & FL_POSIX)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001077 cFYI(1, "Posix");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001078 if (flock->fl_flags & FL_FLOCK)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001079 cFYI(1, "Flock");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001080 if (flock->fl_flags & FL_SLEEP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001081 cFYI(1, "Blocking lock");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001082 *wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001083 }
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001084 if (flock->fl_flags & FL_ACCESS)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001085 cFYI(1, "Process suspended by mandatory locking - "
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001086 "not implemented yet");
1087 if (flock->fl_flags & FL_LEASE)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001088 cFYI(1, "Lease on file - not implemented yet");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001089 if (flock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -07001090 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001091 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001092
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001093 *type = server->vals->large_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001094 if (flock->fl_type == F_WRLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001095 cFYI(1, "F_WRLCK ");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001096 *type |= server->vals->exclusive_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001097 *lock = 1;
1098 } else if (flock->fl_type == F_UNLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001099 cFYI(1, "F_UNLCK");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001100 *type |= server->vals->unlock_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001101 *unlock = 1;
1102 /* Check if unlock includes more than one lock range */
1103 } else if (flock->fl_type == F_RDLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001104 cFYI(1, "F_RDLCK");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001105 *type |= server->vals->shared_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001106 *lock = 1;
1107 } else if (flock->fl_type == F_EXLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001108 cFYI(1, "F_EXLCK");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001109 *type |= server->vals->exclusive_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001110 *lock = 1;
1111 } else if (flock->fl_type == F_SHLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001112 cFYI(1, "F_SHLCK");
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001113 *type |= server->vals->shared_lock_type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001114 *lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00001116 cFYI(1, "Unknown type of lock");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001117}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001118
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001119static int
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001120cifs_getlk(struct file *file, struct file_lock *flock, __u32 type,
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001121 bool wait_flag, bool posix_lck, int xid)
1122{
1123 int rc = 0;
1124 __u64 length = 1 + flock->fl_end - flock->fl_start;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001125 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1126 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001127 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001128 __u16 netfid = cfile->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001130 if (posix_lck) {
1131 int posix_lock_type;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001132
1133 rc = cifs_posix_lock_test(file, flock);
1134 if (!rc)
1135 return rc;
1136
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001137 if (type & server->vals->shared_lock_type)
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001138 posix_lock_type = CIFS_RDLCK;
1139 else
1140 posix_lock_type = CIFS_WRLCK;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001141 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1142 1 /* get */, length, flock,
1143 posix_lock_type, wait_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001144 return rc;
1145 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001146
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001147 rc = cifs_lock_test(cfile, flock->fl_start, length, type, flock);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001148 if (!rc)
1149 return rc;
1150
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001151 /* BB we could chain these into one lock request BB */
1152 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1153 flock->fl_start, 0, 1, type, 0, 0);
1154 if (rc == 0) {
1155 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1156 length, flock->fl_start, 1, 0,
1157 type, 0, 0);
1158 flock->fl_type = F_UNLCK;
1159 if (rc != 0)
1160 cERROR(1, "Error unlocking previously locked "
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001161 "range %d during test of lock", rc);
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001162 return 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001163 }
1164
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001165 if (type & server->vals->shared_lock_type) {
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001166 flock->fl_type = F_WRLCK;
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001167 return 0;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001168 }
1169
1170 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1171 flock->fl_start, 0, 1,
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001172 type | server->vals->shared_lock_type, 0, 0);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001173 if (rc == 0) {
1174 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1175 length, flock->fl_start, 1, 0,
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001176 type | server->vals->shared_lock_type, 0, 0);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001177 flock->fl_type = F_RDLCK;
1178 if (rc != 0)
1179 cERROR(1, "Error unlocking previously locked "
1180 "range %d during test of lock", rc);
1181 } else
1182 flock->fl_type = F_WRLCK;
1183
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001184 return 0;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001185}
1186
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001187static void
1188cifs_move_llist(struct list_head *source, struct list_head *dest)
1189{
1190 struct list_head *li, *tmp;
1191 list_for_each_safe(li, tmp, source)
1192 list_move(li, dest);
1193}
1194
1195static void
1196cifs_free_llist(struct list_head *llist)
1197{
1198 struct cifsLockInfo *li, *tmp;
1199 list_for_each_entry_safe(li, tmp, llist, llist) {
1200 cifs_del_lock_waiters(li);
1201 list_del(&li->llist);
1202 kfree(li);
1203 }
1204}
1205
1206static int
1207cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1208{
1209 int rc = 0, stored_rc;
1210 int types[] = {LOCKING_ANDX_LARGE_FILES,
1211 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1212 unsigned int i;
1213 unsigned int max_num, num;
1214 LOCKING_ANDX_RANGE *buf, *cur;
1215 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1216 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1217 struct cifsLockInfo *li, *tmp;
1218 __u64 length = 1 + flock->fl_end - flock->fl_start;
1219 struct list_head tmp_llist;
1220
1221 INIT_LIST_HEAD(&tmp_llist);
1222
1223 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1224 sizeof(LOCKING_ANDX_RANGE);
1225 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1226 if (!buf)
1227 return -ENOMEM;
1228
1229 mutex_lock(&cinode->lock_mutex);
1230 for (i = 0; i < 2; i++) {
1231 cur = buf;
1232 num = 0;
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001233 list_for_each_entry_safe(li, tmp, &cfile->llist, llist) {
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001234 if (flock->fl_start > li->offset ||
1235 (flock->fl_start + length) <
1236 (li->offset + li->length))
1237 continue;
1238 if (current->tgid != li->pid)
1239 continue;
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001240 if (types[i] != li->type)
1241 continue;
1242 if (!cinode->can_cache_brlcks) {
1243 cur->Pid = cpu_to_le16(li->pid);
1244 cur->LengthLow = cpu_to_le32((u32)li->length);
1245 cur->LengthHigh =
1246 cpu_to_le32((u32)(li->length>>32));
1247 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1248 cur->OffsetHigh =
1249 cpu_to_le32((u32)(li->offset>>32));
1250 /*
1251 * We need to save a lock here to let us add
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001252 * it again to the file's list if the unlock
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001253 * range request fails on the server.
1254 */
1255 list_move(&li->llist, &tmp_llist);
1256 if (++num == max_num) {
1257 stored_rc = cifs_lockv(xid, tcon,
1258 cfile->netfid,
1259 li->type, num,
1260 0, buf);
1261 if (stored_rc) {
1262 /*
1263 * We failed on the unlock range
1264 * request - add all locks from
1265 * the tmp list to the head of
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001266 * the file's list.
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001267 */
1268 cifs_move_llist(&tmp_llist,
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001269 &cfile->llist);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001270 rc = stored_rc;
1271 } else
1272 /*
1273 * The unlock range request
1274 * succeed - free the tmp list.
1275 */
1276 cifs_free_llist(&tmp_llist);
1277 cur = buf;
1278 num = 0;
1279 } else
1280 cur++;
1281 } else {
1282 /*
1283 * We can cache brlock requests - simply remove
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001284 * a lock from the file's list.
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001285 */
1286 list_del(&li->llist);
1287 cifs_del_lock_waiters(li);
1288 kfree(li);
1289 }
1290 }
1291 if (num) {
1292 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1293 types[i], num, 0, buf);
1294 if (stored_rc) {
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001295 cifs_move_llist(&tmp_llist, &cfile->llist);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001296 rc = stored_rc;
1297 } else
1298 cifs_free_llist(&tmp_llist);
1299 }
1300 }
1301
1302 mutex_unlock(&cinode->lock_mutex);
1303 kfree(buf);
1304 return rc;
1305}
1306
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001307static int
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001308cifs_setlk(struct file *file, struct file_lock *flock, __u32 type,
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001309 bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1310{
1311 int rc = 0;
1312 __u64 length = 1 + flock->fl_end - flock->fl_start;
1313 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1314 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001315 struct TCP_Server_Info *server = tcon->ses->server;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001316 __u16 netfid = cfile->netfid;
1317
1318 if (posix_lck) {
Steve French08547b02006-02-28 22:39:25 +00001319 int posix_lock_type;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001320
1321 rc = cifs_posix_lock_set(file, flock);
1322 if (!rc || rc < 0)
1323 return rc;
1324
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001325 if (type & server->vals->shared_lock_type)
Steve French08547b02006-02-28 22:39:25 +00001326 posix_lock_type = CIFS_RDLCK;
1327 else
1328 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +00001329
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001330 if (unlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +00001331 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001332
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001333 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1334 0 /* set */, length, flock,
1335 posix_lock_type, wait_flag);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001336 goto out;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001337 }
1338
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001339 if (lock) {
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001340 struct cifsLockInfo *lock;
1341
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001342 lock = cifs_lock_init(flock->fl_start, length, type);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001343 if (!lock)
1344 return -ENOMEM;
1345
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001346 rc = cifs_lock_add_if(cfile, lock, wait_flag);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001347 if (rc < 0)
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001348 kfree(lock);
1349 if (rc <= 0)
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001350 goto out;
1351
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001352 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001353 flock->fl_start, 0, 1, type, wait_flag, 0);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001354 if (rc) {
1355 kfree(lock);
1356 goto out;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001357 }
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001358
Pavel Shilovskyfbd35ac2012-02-24 15:41:06 +03001359 cifs_lock_add(cfile, lock);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001360 } else if (unlock)
1361 rc = cifs_unlock_range(cfile, flock, xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001362
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001363out:
1364 if (flock->fl_flags & FL_POSIX)
Steve French9ebb3892012-04-01 13:52:54 -05001365 posix_lock_file_wait(file, flock);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001366 return rc;
1367}
1368
1369int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1370{
1371 int rc, xid;
1372 int lock = 0, unlock = 0;
1373 bool wait_flag = false;
1374 bool posix_lck = false;
1375 struct cifs_sb_info *cifs_sb;
1376 struct cifs_tcon *tcon;
1377 struct cifsInodeInfo *cinode;
1378 struct cifsFileInfo *cfile;
1379 __u16 netfid;
Pavel Shilovsky04a6aa82012-02-28 14:16:55 +03001380 __u32 type;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001381
1382 rc = -EACCES;
1383 xid = GetXid();
1384
1385 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1386 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1387 flock->fl_start, flock->fl_end);
1388
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001389 cfile = (struct cifsFileInfo *)file->private_data;
1390 tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky106dc532012-02-28 14:23:34 +03001391
1392 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag,
1393 tcon->ses->server);
1394
1395 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001396 netfid = cfile->netfid;
1397 cinode = CIFS_I(file->f_path.dentry->d_inode);
1398
1399 if ((tcon->ses->capabilities & CAP_UNIX) &&
1400 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1401 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1402 posix_lck = true;
1403 /*
1404 * BB add code here to normalize offset and length to account for
1405 * negative length which we can not accept over the wire.
1406 */
1407 if (IS_GETLK(cmd)) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001408 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001409 FreeXid(xid);
1410 return rc;
1411 }
1412
1413 if (!lock && !unlock) {
1414 /*
1415 * if no lock or unlock then nothing to do since we do not
1416 * know what it is
1417 */
1418 FreeXid(xid);
1419 return -EOPNOTSUPP;
1420 }
1421
1422 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1423 xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001424 FreeXid(xid);
1425 return rc;
1426}
1427
Jeff Layton597b0272012-03-23 14:40:56 -04001428/*
1429 * update the file size (if needed) after a write. Should be called with
1430 * the inode->i_lock held
1431 */
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05001432void
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001433cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1434 unsigned int bytes_written)
1435{
1436 loff_t end_of_write = offset + bytes_written;
1437
1438 if (end_of_write > cifsi->server_eof)
1439 cifsi->server_eof = end_of_write;
1440}
1441
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001442static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
Jeff Layton7da4b492010-10-15 15:34:00 -04001443 const char *write_data, size_t write_size,
1444 loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001445{
1446 int rc = 0;
1447 unsigned int bytes_written = 0;
1448 unsigned int total_written;
1449 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +00001450 struct cifs_tcon *pTcon;
Jeff Layton77499812011-01-11 07:24:23 -05001451 int xid;
Jeff Layton7da4b492010-10-15 15:34:00 -04001452 struct dentry *dentry = open_file->dentry;
1453 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001454 struct cifs_io_parms io_parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455
Jeff Layton7da4b492010-10-15 15:34:00 -04001456 cifs_sb = CIFS_SB(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001457
Joe Perchesb6b38f72010-04-21 03:50:45 +00001458 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
Jeff Layton7da4b492010-10-15 15:34:00 -04001459 *poffset, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460
Jeff Layton13cfb732010-09-29 19:51:11 -04001461 pTcon = tlink_tcon(open_file->tlink);
Steve French50c2f752007-07-13 00:33:32 +00001462
Linus Torvalds1da177e2005-04-16 15:20:36 -07001463 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464
Linus Torvalds1da177e2005-04-16 15:20:36 -07001465 for (total_written = 0; write_size > total_written;
1466 total_written += bytes_written) {
1467 rc = -EAGAIN;
1468 while (rc == -EAGAIN) {
Jeff Laytonca83ce32011-04-12 09:13:44 -04001469 struct kvec iov[2];
1470 unsigned int len;
1471
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 /* we could deadlock if we called
1474 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001475 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476 server now */
Jeff Layton15886172010-10-15 15:33:59 -04001477 rc = cifs_reopen_file(open_file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 if (rc != 0)
1479 break;
1480 }
Steve French3e844692005-10-03 13:37:24 -07001481
Jeff Laytonca83ce32011-04-12 09:13:44 -04001482 len = min((size_t)cifs_sb->wsize,
1483 write_size - total_written);
1484 /* iov[0] is reserved for smb header */
1485 iov[1].iov_base = (char *)write_data + total_written;
1486 iov[1].iov_len = len;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001487 io_parms.netfid = open_file->netfid;
1488 io_parms.pid = pid;
1489 io_parms.tcon = pTcon;
1490 io_parms.offset = *poffset;
1491 io_parms.length = len;
1492 rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1493 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001494 }
1495 if (rc || (bytes_written == 0)) {
1496 if (total_written)
1497 break;
1498 else {
1499 FreeXid(xid);
1500 return rc;
1501 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001502 } else {
Jeff Layton597b0272012-03-23 14:40:56 -04001503 spin_lock(&dentry->d_inode->i_lock);
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001504 cifs_update_eof(cifsi, *poffset, bytes_written);
Jeff Layton597b0272012-03-23 14:40:56 -04001505 spin_unlock(&dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001506 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001507 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508 }
1509
Steve Frencha4544342005-08-24 13:59:35 -07001510 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001511
Jeff Layton7da4b492010-10-15 15:34:00 -04001512 if (total_written > 0) {
1513 spin_lock(&dentry->d_inode->i_lock);
1514 if (*poffset > dentry->d_inode->i_size)
1515 i_size_write(dentry->d_inode, *poffset);
1516 spin_unlock(&dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 }
Jeff Layton7da4b492010-10-15 15:34:00 -04001518 mark_inode_dirty_sync(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001519 FreeXid(xid);
1520 return total_written;
1521}
1522
Jeff Layton6508d902010-09-29 19:51:11 -04001523struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1524 bool fsuid_only)
Steve French630f3f0c2007-10-25 21:17:17 +00001525{
1526 struct cifsFileInfo *open_file = NULL;
Jeff Layton6508d902010-09-29 19:51:11 -04001527 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1528
1529 /* only filter by fsuid on multiuser mounts */
1530 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1531 fsuid_only = false;
Steve French630f3f0c2007-10-25 21:17:17 +00001532
Jeff Layton44772882010-10-15 15:34:03 -04001533 spin_lock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001534 /* we could simply get the first_list_entry since write-only entries
1535 are always at the end of the list but since the first entry might
1536 have a close pending, we go through the whole list */
1537 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton6508d902010-09-29 19:51:11 -04001538 if (fsuid_only && open_file->uid != current_fsuid())
1539 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001540 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
Steve French630f3f0c2007-10-25 21:17:17 +00001541 if (!open_file->invalidHandle) {
1542 /* found a good file */
1543 /* lock it so it will not be closed on us */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001544 cifsFileInfo_get(open_file);
Jeff Layton44772882010-10-15 15:34:03 -04001545 spin_unlock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001546 return open_file;
1547 } /* else might as well continue, and look for
1548 another, or simply have the caller reopen it
1549 again rather than trying to fix this handle */
1550 } else /* write only file */
1551 break; /* write only files are last so must be done */
1552 }
Jeff Layton44772882010-10-15 15:34:03 -04001553 spin_unlock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001554 return NULL;
1555}
Steve French630f3f0c2007-10-25 21:17:17 +00001556
Jeff Layton6508d902010-09-29 19:51:11 -04001557struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1558 bool fsuid_only)
Steve French6148a742005-10-05 12:23:19 -07001559{
1560 struct cifsFileInfo *open_file;
Jeff Laytond3892292010-11-02 16:22:50 -04001561 struct cifs_sb_info *cifs_sb;
Jeff Layton2846d382008-09-22 21:33:33 -04001562 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001563 int rc;
Steve French6148a742005-10-05 12:23:19 -07001564
Steve French60808232006-04-22 15:53:05 +00001565 /* Having a null inode here (because mapping->host was set to zero by
1566 the VFS or MM) should not happen but we had reports of on oops (due to
1567 it being zero) during stress testcases so we need to check for it */
1568
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001569 if (cifs_inode == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001570 cERROR(1, "Null inode passed to cifs_writeable_file");
Steve French60808232006-04-22 15:53:05 +00001571 dump_stack();
1572 return NULL;
1573 }
1574
Jeff Laytond3892292010-11-02 16:22:50 -04001575 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1576
Jeff Layton6508d902010-09-29 19:51:11 -04001577 /* only filter by fsuid on multiuser mounts */
1578 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1579 fsuid_only = false;
1580
Jeff Layton44772882010-10-15 15:34:03 -04001581 spin_lock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001582refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001583 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton6508d902010-09-29 19:51:11 -04001584 if (!any_available && open_file->pid != current->tgid)
1585 continue;
1586 if (fsuid_only && open_file->uid != current_fsuid())
1587 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001588 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001589 cifsFileInfo_get(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001590
1591 if (!open_file->invalidHandle) {
1592 /* found a good writable file */
Jeff Layton44772882010-10-15 15:34:03 -04001593 spin_unlock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001594 return open_file;
1595 }
Steve French8840dee2007-11-16 23:05:52 +00001596
Jeff Layton44772882010-10-15 15:34:03 -04001597 spin_unlock(&cifs_file_list_lock);
Steve Frenchcdff08e2010-10-21 22:46:14 +00001598
Steve French9b22b0b2007-10-02 01:11:08 +00001599 /* Had to unlock since following call can block */
Jeff Layton15886172010-10-15 15:33:59 -04001600 rc = cifs_reopen_file(open_file, false);
Steve Frenchcdff08e2010-10-21 22:46:14 +00001601 if (!rc)
1602 return open_file;
Steve French9b22b0b2007-10-02 01:11:08 +00001603
Steve Frenchcdff08e2010-10-21 22:46:14 +00001604 /* if it fails, try another handle if possible */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001605 cFYI(1, "wp failed on reopen file");
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001606 cifsFileInfo_put(open_file);
Steve French8840dee2007-11-16 23:05:52 +00001607
Steve Frenchcdff08e2010-10-21 22:46:14 +00001608 spin_lock(&cifs_file_list_lock);
1609
Steve French9b22b0b2007-10-02 01:11:08 +00001610 /* else we simply continue to the next entry. Thus
1611 we do not loop on reopen errors. If we
1612 can not reopen the file, for example if we
1613 reconnected to a server with another client
1614 racing to delete or lock the file we would not
1615 make progress if we restarted before the beginning
1616 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001617 }
1618 }
Jeff Layton2846d382008-09-22 21:33:33 -04001619 /* couldn't find useable FH with same pid, try any available */
1620 if (!any_available) {
1621 any_available = true;
1622 goto refind_writable;
1623 }
Jeff Layton44772882010-10-15 15:34:03 -04001624 spin_unlock(&cifs_file_list_lock);
Steve French6148a742005-10-05 12:23:19 -07001625 return NULL;
1626}
1627
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1629{
1630 struct address_space *mapping = page->mapping;
1631 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1632 char *write_data;
1633 int rc = -EFAULT;
1634 int bytes_written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001636 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001637
1638 if (!mapping || !mapping->host)
1639 return -EFAULT;
1640
1641 inode = page->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001642
1643 offset += (loff_t)from;
1644 write_data = kmap(page);
1645 write_data += from;
1646
1647 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1648 kunmap(page);
1649 return -EIO;
1650 }
1651
1652 /* racing with truncate? */
1653 if (offset > mapping->host->i_size) {
1654 kunmap(page);
1655 return 0; /* don't care */
1656 }
1657
1658 /* check to make sure that we are not extending the file */
1659 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001660 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001661
Jeff Layton6508d902010-09-29 19:51:11 -04001662 open_file = find_writable_file(CIFS_I(mapping->host), false);
Steve French6148a742005-10-05 12:23:19 -07001663 if (open_file) {
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001664 bytes_written = cifs_write(open_file, open_file->pid,
1665 write_data, to - from, &offset);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001666 cifsFileInfo_put(open_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001668 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001669 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001670 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001671 else if (bytes_written < 0)
1672 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001673 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001674 cFYI(1, "No writeable filehandles for inode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675 rc = -EIO;
1676 }
1677
1678 kunmap(page);
1679 return rc;
1680}
1681
Jeff Laytone9492872012-03-23 14:40:56 -04001682/*
1683 * Marshal up the iov array, reserving the first one for the header. Also,
1684 * set wdata->bytes.
1685 */
1686static void
1687cifs_writepages_marshal_iov(struct kvec *iov, struct cifs_writedata *wdata)
1688{
1689 int i;
1690 struct inode *inode = wdata->cfile->dentry->d_inode;
1691 loff_t size = i_size_read(inode);
1692
1693 /* marshal up the pages into iov array */
1694 wdata->bytes = 0;
1695 for (i = 0; i < wdata->nr_pages; i++) {
1696 iov[i + 1].iov_len = min(size - page_offset(wdata->pages[i]),
1697 (loff_t)PAGE_CACHE_SIZE);
1698 iov[i + 1].iov_base = kmap(wdata->pages[i]);
1699 wdata->bytes += iov[i + 1].iov_len;
1700 }
1701}
1702
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001704 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001705{
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001706 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1707 bool done = false, scanned = false, range_whole = false;
1708 pgoff_t end, index;
1709 struct cifs_writedata *wdata;
Steve French37c0eb42005-10-05 14:50:29 -07001710 struct page *page;
Steve French37c0eb42005-10-05 14:50:29 -07001711 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00001712
Steve French37c0eb42005-10-05 14:50:29 -07001713 /*
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001714 * If wsize is smaller than the page cache size, default to writing
Steve French37c0eb42005-10-05 14:50:29 -07001715 * one page at a time via cifs_writepage
1716 */
1717 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1718 return generic_writepages(mapping, wbc);
1719
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001720 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001721 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001722 end = -1;
1723 } else {
1724 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1725 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1726 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001727 range_whole = true;
1728 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07001729 }
1730retry:
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001731 while (!done && index <= end) {
1732 unsigned int i, nr_pages, found_pages;
1733 pgoff_t next = 0, tofind;
1734 struct page **pages;
Steve French37c0eb42005-10-05 14:50:29 -07001735
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001736 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1737 end - index) + 1;
Steve French37c0eb42005-10-05 14:50:29 -07001738
Jeff Laytonc2e87642012-03-23 14:40:55 -04001739 wdata = cifs_writedata_alloc((unsigned int)tofind,
1740 cifs_writev_complete);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001741 if (!wdata) {
1742 rc = -ENOMEM;
1743 break;
1744 }
1745
1746 /*
1747 * find_get_pages_tag seems to return a max of 256 on each
1748 * iteration, so we must call it several times in order to
1749 * fill the array or the wsize is effectively limited to
1750 * 256 * PAGE_CACHE_SIZE.
1751 */
1752 found_pages = 0;
1753 pages = wdata->pages;
1754 do {
1755 nr_pages = find_get_pages_tag(mapping, &index,
1756 PAGECACHE_TAG_DIRTY,
1757 tofind, pages);
1758 found_pages += nr_pages;
1759 tofind -= nr_pages;
1760 pages += nr_pages;
1761 } while (nr_pages && tofind && index <= end);
1762
1763 if (found_pages == 0) {
1764 kref_put(&wdata->refcount, cifs_writedata_release);
1765 break;
1766 }
1767
1768 nr_pages = 0;
1769 for (i = 0; i < found_pages; i++) {
1770 page = wdata->pages[i];
Steve French37c0eb42005-10-05 14:50:29 -07001771 /*
1772 * At this point we hold neither mapping->tree_lock nor
1773 * lock on the page itself: the page may be truncated or
1774 * invalidated (changing page->mapping to NULL), or even
1775 * swizzled back from swapper_space to tmpfs file
1776 * mapping
1777 */
1778
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001779 if (nr_pages == 0)
Steve French37c0eb42005-10-05 14:50:29 -07001780 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001781 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001782 break;
1783
1784 if (unlikely(page->mapping != mapping)) {
1785 unlock_page(page);
1786 break;
1787 }
1788
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001789 if (!wbc->range_cyclic && page->index > end) {
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001790 done = true;
Steve French37c0eb42005-10-05 14:50:29 -07001791 unlock_page(page);
1792 break;
1793 }
1794
1795 if (next && (page->index != next)) {
1796 /* Not next consecutive page */
1797 unlock_page(page);
1798 break;
1799 }
1800
1801 if (wbc->sync_mode != WB_SYNC_NONE)
1802 wait_on_page_writeback(page);
1803
1804 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001805 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001806 unlock_page(page);
1807 break;
1808 }
Steve French84d2f072005-10-12 15:32:05 -07001809
Linus Torvaldscb876f42006-12-23 16:19:07 -08001810 /*
1811 * This actually clears the dirty bit in the radix tree.
1812 * See cifs_writepage() for more commentary.
1813 */
1814 set_page_writeback(page);
1815
Steve French84d2f072005-10-12 15:32:05 -07001816 if (page_offset(page) >= mapping->host->i_size) {
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001817 done = true;
Steve French84d2f072005-10-12 15:32:05 -07001818 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001819 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001820 break;
1821 }
1822
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001823 wdata->pages[i] = page;
Steve French37c0eb42005-10-05 14:50:29 -07001824 next = page->index + 1;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001825 ++nr_pages;
Steve French37c0eb42005-10-05 14:50:29 -07001826 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001827
1828 /* reset index to refind any pages skipped */
1829 if (nr_pages == 0)
1830 index = wdata->pages[0]->index + 1;
1831
1832 /* put any pages we aren't going to use */
1833 for (i = nr_pages; i < found_pages; i++) {
1834 page_cache_release(wdata->pages[i]);
1835 wdata->pages[i] = NULL;
1836 }
1837
1838 /* nothing to write? */
1839 if (nr_pages == 0) {
1840 kref_put(&wdata->refcount, cifs_writedata_release);
1841 continue;
1842 }
1843
1844 wdata->sync_mode = wbc->sync_mode;
1845 wdata->nr_pages = nr_pages;
1846 wdata->offset = page_offset(wdata->pages[0]);
Jeff Laytone9492872012-03-23 14:40:56 -04001847 wdata->marshal_iov = cifs_writepages_marshal_iov;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001848
1849 do {
1850 if (wdata->cfile != NULL)
1851 cifsFileInfo_put(wdata->cfile);
1852 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1853 false);
1854 if (!wdata->cfile) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001855 cERROR(1, "No writable handles for inode");
Steve French23e7dd72005-10-20 13:44:56 -07001856 rc = -EBADF;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001857 break;
Steve French37c0eb42005-10-05 14:50:29 -07001858 }
Jeff Laytonfe5f5d22012-03-23 14:40:55 -04001859 wdata->pid = wdata->cfile->pid;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001860 rc = cifs_async_writev(wdata);
1861 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001862
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001863 for (i = 0; i < nr_pages; ++i)
1864 unlock_page(wdata->pages[i]);
Jeff Layton941b8532011-01-11 07:24:01 -05001865
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001866 /* send failure -- clean up the mess */
1867 if (rc != 0) {
1868 for (i = 0; i < nr_pages; ++i) {
Jeff Layton941b8532011-01-11 07:24:01 -05001869 if (rc == -EAGAIN)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001870 redirty_page_for_writepage(wbc,
1871 wdata->pages[i]);
1872 else
1873 SetPageError(wdata->pages[i]);
1874 end_page_writeback(wdata->pages[i]);
1875 page_cache_release(wdata->pages[i]);
Steve French37c0eb42005-10-05 14:50:29 -07001876 }
Jeff Layton941b8532011-01-11 07:24:01 -05001877 if (rc != -EAGAIN)
1878 mapping_set_error(mapping, rc);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001879 }
1880 kref_put(&wdata->refcount, cifs_writedata_release);
Jeff Layton941b8532011-01-11 07:24:01 -05001881
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001882 wbc->nr_to_write -= nr_pages;
1883 if (wbc->nr_to_write <= 0)
1884 done = true;
Dave Kleikampb066a482008-11-18 03:49:05 +00001885
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001886 index = next;
Steve French37c0eb42005-10-05 14:50:29 -07001887 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001888
Steve French37c0eb42005-10-05 14:50:29 -07001889 if (!scanned && !done) {
1890 /*
1891 * We hit the last page and there is more work to be done: wrap
1892 * back to the start of the file
1893 */
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001894 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07001895 index = 0;
1896 goto retry;
1897 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001898
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001899 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001900 mapping->writeback_index = index;
1901
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 return rc;
1903}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001904
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04001905static int
1906cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907{
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04001908 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909 int xid;
1910
1911 xid = GetXid();
1912/* BB add check for wbc flags */
1913 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001914 if (!PageUptodate(page))
Joe Perchesb6b38f72010-04-21 03:50:45 +00001915 cFYI(1, "ppw - page not up to date");
Linus Torvaldscb876f42006-12-23 16:19:07 -08001916
1917 /*
1918 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1919 *
1920 * A writepage() implementation always needs to do either this,
1921 * or re-dirty the page with "redirty_page_for_writepage()" in
1922 * the case of a failure.
1923 *
1924 * Just unlocking the page will cause the radix tree tag-bits
1925 * to fail to update with the state of the page correctly.
1926 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001927 set_page_writeback(page);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04001928retry_write:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001929 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04001930 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1931 goto retry_write;
1932 else if (rc == -EAGAIN)
1933 redirty_page_for_writepage(wbc, page);
1934 else if (rc != 0)
1935 SetPageError(page);
1936 else
1937 SetPageUptodate(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001938 end_page_writeback(page);
1939 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001940 FreeXid(xid);
1941 return rc;
1942}
1943
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04001944static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1945{
1946 int rc = cifs_writepage_locked(page, wbc);
1947 unlock_page(page);
1948 return rc;
1949}
1950
Nick Piggind9414772008-09-24 11:32:59 -04001951static int cifs_write_end(struct file *file, struct address_space *mapping,
1952 loff_t pos, unsigned len, unsigned copied,
1953 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001954{
Nick Piggind9414772008-09-24 11:32:59 -04001955 int rc;
1956 struct inode *inode = mapping->host;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001957 struct cifsFileInfo *cfile = file->private_data;
1958 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1959 __u32 pid;
1960
1961 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1962 pid = cfile->pid;
1963 else
1964 pid = current->tgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965
Joe Perchesb6b38f72010-04-21 03:50:45 +00001966 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1967 page, pos, copied);
Steve Frenchad7a2922008-02-07 23:25:02 +00001968
Jeff Laytona98ee8c2008-11-26 19:32:33 +00001969 if (PageChecked(page)) {
1970 if (copied == len)
1971 SetPageUptodate(page);
1972 ClearPageChecked(page);
1973 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04001974 SetPageUptodate(page);
1975
Linus Torvalds1da177e2005-04-16 15:20:36 -07001976 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04001977 char *page_data;
1978 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1979 int xid;
1980
1981 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 /* this is probably better than directly calling
1983 partialpage_write since in this function the file handle is
1984 known which we might as well leverage */
1985 /* BB check if anything else missing out of ppw
1986 such as updating last write time */
1987 page_data = kmap(page);
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001988 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
Nick Piggind9414772008-09-24 11:32:59 -04001989 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001990 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001991
1992 FreeXid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001993 } else {
Nick Piggind9414772008-09-24 11:32:59 -04001994 rc = copied;
1995 pos += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001996 set_page_dirty(page);
1997 }
1998
Nick Piggind9414772008-09-24 11:32:59 -04001999 if (rc > 0) {
2000 spin_lock(&inode->i_lock);
2001 if (pos > inode->i_size)
2002 i_size_write(inode, pos);
2003 spin_unlock(&inode->i_lock);
2004 }
2005
2006 unlock_page(page);
2007 page_cache_release(page);
2008
Linus Torvalds1da177e2005-04-16 15:20:36 -07002009 return rc;
2010}
2011
Josef Bacik02c24a82011-07-16 20:44:56 -04002012int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
2013 int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014{
2015 int xid;
2016 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00002017 struct cifs_tcon *tcon;
Joe Perchesc21dfb62010-07-12 13:50:14 -07002018 struct cifsFileInfo *smbfile = file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002019 struct inode *inode = file->f_path.dentry->d_inode;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002020 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002021
Josef Bacik02c24a82011-07-16 20:44:56 -04002022 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2023 if (rc)
2024 return rc;
2025 mutex_lock(&inode->i_mutex);
2026
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 xid = GetXid();
2028
Joe Perchesb6b38f72010-04-21 03:50:45 +00002029 cFYI(1, "Sync file - name: %s datasync: 0x%x",
Christoph Hellwig7ea80852010-05-26 17:53:25 +02002030 file->f_path.dentry->d_name.name, datasync);
Steve French50c2f752007-07-13 00:33:32 +00002031
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002032 if (!CIFS_I(inode)->clientCanCacheRead) {
2033 rc = cifs_invalidate_mapping(inode);
2034 if (rc) {
2035 cFYI(1, "rc: %d during invalidate phase", rc);
2036 rc = 0; /* don't care about it in fsync */
2037 }
2038 }
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002039
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002040 tcon = tlink_tcon(smbfile->tlink);
2041 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2042 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
2043
2044 FreeXid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04002045 mutex_unlock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002046 return rc;
2047}
2048
Josef Bacik02c24a82011-07-16 20:44:56 -04002049int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002050{
2051 int xid;
2052 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00002053 struct cifs_tcon *tcon;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002054 struct cifsFileInfo *smbfile = file->private_data;
2055 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Josef Bacik02c24a82011-07-16 20:44:56 -04002056 struct inode *inode = file->f_mapping->host;
2057
2058 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
2059 if (rc)
2060 return rc;
2061 mutex_lock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03002062
2063 xid = GetXid();
2064
2065 cFYI(1, "Sync file - name: %s datasync: 0x%x",
2066 file->f_path.dentry->d_name.name, datasync);
2067
2068 tcon = tlink_tcon(smbfile->tlink);
2069 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
2070 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
Steve Frenchb298f222009-02-21 21:17:43 +00002071
Linus Torvalds1da177e2005-04-16 15:20:36 -07002072 FreeXid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04002073 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002074 return rc;
2075}
2076
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077/*
2078 * As file closes, flush all cached write data for this inode checking
2079 * for write behind errors.
2080 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07002081int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002083 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002084 int rc = 0;
2085
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002086 if (file->f_mode & FMODE_WRITE)
Jeff Laytond3f13222010-10-15 15:34:07 -04002087 rc = filemap_write_and_wait(inode->i_mapping);
Steve French50c2f752007-07-13 00:33:32 +00002088
Joe Perchesb6b38f72010-04-21 03:50:45 +00002089 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090
2091 return rc;
2092}
2093
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002094static int
2095cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
2096{
2097 int rc = 0;
2098 unsigned long i;
2099
2100 for (i = 0; i < num_pages; i++) {
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002101 pages[i] = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002102 if (!pages[i]) {
2103 /*
2104 * save number of pages we have already allocated and
2105 * return with ENOMEM error
2106 */
2107 num_pages = i;
2108 rc = -ENOMEM;
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002109 break;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002110 }
2111 }
2112
Jeff Laytone94f7ba2012-03-23 14:40:56 -04002113 if (rc) {
2114 for (i = 0; i < num_pages; i++)
2115 put_page(pages[i]);
2116 }
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002117 return rc;
2118}
2119
2120static inline
2121size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2122{
2123 size_t num_pages;
2124 size_t clen;
2125
2126 clen = min_t(const size_t, len, wsize);
Jeff Laytona7103b92012-03-23 14:40:56 -04002127 num_pages = DIV_ROUND_UP(clen, PAGE_SIZE);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002128
2129 if (cur_len)
2130 *cur_len = clen;
2131
2132 return num_pages;
2133}
2134
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002135static void
2136cifs_uncached_marshal_iov(struct kvec *iov, struct cifs_writedata *wdata)
2137{
2138 int i;
2139 size_t bytes = wdata->bytes;
2140
2141 /* marshal up the pages into iov array */
2142 for (i = 0; i < wdata->nr_pages; i++) {
Steve Frenchc7ad42b2012-03-23 16:30:56 -05002143 iov[i + 1].iov_len = min_t(size_t, bytes, PAGE_SIZE);
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002144 iov[i + 1].iov_base = kmap(wdata->pages[i]);
2145 bytes -= iov[i + 1].iov_len;
2146 }
2147}
2148
2149static void
2150cifs_uncached_writev_complete(struct work_struct *work)
2151{
2152 int i;
2153 struct cifs_writedata *wdata = container_of(work,
2154 struct cifs_writedata, work);
2155 struct inode *inode = wdata->cfile->dentry->d_inode;
2156 struct cifsInodeInfo *cifsi = CIFS_I(inode);
2157
2158 spin_lock(&inode->i_lock);
2159 cifs_update_eof(cifsi, wdata->offset, wdata->bytes);
2160 if (cifsi->server_eof > inode->i_size)
2161 i_size_write(inode, cifsi->server_eof);
2162 spin_unlock(&inode->i_lock);
2163
2164 complete(&wdata->done);
2165
2166 if (wdata->result != -EAGAIN) {
2167 for (i = 0; i < wdata->nr_pages; i++)
2168 put_page(wdata->pages[i]);
2169 }
2170
2171 kref_put(&wdata->refcount, cifs_writedata_release);
2172}
2173
2174/* attempt to send write to server, retry on any -EAGAIN errors */
2175static int
2176cifs_uncached_retry_writev(struct cifs_writedata *wdata)
2177{
2178 int rc;
2179
2180 do {
2181 if (wdata->cfile->invalidHandle) {
2182 rc = cifs_reopen_file(wdata->cfile, false);
2183 if (rc != 0)
2184 continue;
2185 }
2186 rc = cifs_async_writev(wdata);
2187 } while (rc == -EAGAIN);
2188
2189 return rc;
2190}
2191
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002192static ssize_t
2193cifs_iovec_write(struct file *file, const struct iovec *iov,
2194 unsigned long nr_segs, loff_t *poffset)
2195{
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002196 unsigned long nr_pages, i;
Pavel Shilovsky76429c12011-01-31 16:03:08 +03002197 size_t copied, len, cur_len;
2198 ssize_t total_written = 0;
Jeff Layton3af9d8f2012-04-13 17:16:59 -04002199 loff_t offset;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002200 struct iov_iter it;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002201 struct cifsFileInfo *open_file;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002202 struct cifs_tcon *tcon;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002203 struct cifs_sb_info *cifs_sb;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002204 struct cifs_writedata *wdata, *tmp;
2205 struct list_head wdata_list;
2206 int rc;
2207 pid_t pid;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002208
2209 len = iov_length(iov, nr_segs);
2210 if (!len)
2211 return 0;
2212
2213 rc = generic_write_checks(file, poffset, &len, 0);
2214 if (rc)
2215 return rc;
2216
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002217 INIT_LIST_HEAD(&wdata_list);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002218 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002219 open_file = file->private_data;
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002220 tcon = tlink_tcon(open_file->tlink);
Jeff Layton3af9d8f2012-04-13 17:16:59 -04002221 offset = *poffset;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002222
2223 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2224 pid = open_file->pid;
2225 else
2226 pid = current->tgid;
2227
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002228 iov_iter_init(&it, iov, nr_segs, len, 0);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002229 do {
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002230 size_t save_len;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002231
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002232 nr_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2233 wdata = cifs_writedata_alloc(nr_pages,
2234 cifs_uncached_writev_complete);
2235 if (!wdata) {
2236 rc = -ENOMEM;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002237 break;
2238 }
2239
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002240 rc = cifs_write_allocate_pages(wdata->pages, nr_pages);
2241 if (rc) {
2242 kfree(wdata);
2243 break;
2244 }
2245
2246 save_len = cur_len;
2247 for (i = 0; i < nr_pages; i++) {
2248 copied = min_t(const size_t, cur_len, PAGE_SIZE);
2249 copied = iov_iter_copy_from_user(wdata->pages[i], &it,
2250 0, copied);
2251 cur_len -= copied;
2252 iov_iter_advance(&it, copied);
2253 }
2254 cur_len = save_len - cur_len;
2255
2256 wdata->sync_mode = WB_SYNC_ALL;
2257 wdata->nr_pages = nr_pages;
2258 wdata->offset = (__u64)offset;
2259 wdata->cfile = cifsFileInfo_get(open_file);
2260 wdata->pid = pid;
2261 wdata->bytes = cur_len;
2262 wdata->marshal_iov = cifs_uncached_marshal_iov;
2263 rc = cifs_uncached_retry_writev(wdata);
2264 if (rc) {
2265 kref_put(&wdata->refcount, cifs_writedata_release);
2266 break;
2267 }
2268
2269 list_add_tail(&wdata->list, &wdata_list);
2270 offset += cur_len;
2271 len -= cur_len;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002272 } while (len > 0);
2273
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002274 /*
2275 * If at least one write was successfully sent, then discard any rc
2276 * value from the later writes. If the other write succeeds, then
2277 * we'll end up returning whatever was written. If it fails, then
2278 * we'll get a new rc value from that.
2279 */
2280 if (!list_empty(&wdata_list))
2281 rc = 0;
2282
2283 /*
2284 * Wait for and collect replies for any successful sends in order of
2285 * increasing offset. Once an error is hit or we get a fatal signal
2286 * while waiting, then return without waiting for any more replies.
2287 */
2288restart_loop:
2289 list_for_each_entry_safe(wdata, tmp, &wdata_list, list) {
2290 if (!rc) {
2291 /* FIXME: freezable too? */
2292 rc = wait_for_completion_killable(&wdata->done);
2293 if (rc)
2294 rc = -EINTR;
2295 else if (wdata->result)
2296 rc = wdata->result;
2297 else
2298 total_written += wdata->bytes;
2299
2300 /* resend call if it's a retryable error */
2301 if (rc == -EAGAIN) {
2302 rc = cifs_uncached_retry_writev(wdata);
2303 goto restart_loop;
2304 }
2305 }
2306 list_del_init(&wdata->list);
2307 kref_put(&wdata->refcount, cifs_writedata_release);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002308 }
2309
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002310 if (total_written > 0)
2311 *poffset += total_written;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002312
Jeff Laytonda82f7e2012-03-23 14:40:56 -04002313 cifs_stats_bytes_written(tcon, total_written);
2314 return total_written ? total_written : (ssize_t)rc;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002315}
2316
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +03002317ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002318 unsigned long nr_segs, loff_t pos)
2319{
2320 ssize_t written;
2321 struct inode *inode;
2322
2323 inode = iocb->ki_filp->f_path.dentry->d_inode;
2324
2325 /*
2326 * BB - optimize the way when signing is disabled. We can drop this
2327 * extra memory-to-memory copying and use iovec buffers for constructing
2328 * write request.
2329 */
2330
2331 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2332 if (written > 0) {
2333 CIFS_I(inode)->invalid_mapping = true;
2334 iocb->ki_pos = pos;
2335 }
2336
2337 return written;
2338}
2339
2340ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2341 unsigned long nr_segs, loff_t pos)
2342{
2343 struct inode *inode;
2344
2345 inode = iocb->ki_filp->f_path.dentry->d_inode;
2346
2347 if (CIFS_I(inode)->clientCanCacheAll)
2348 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2349
2350 /*
2351 * In strict cache mode we need to write the data to the server exactly
2352 * from the pos to pos+len-1 rather than flush all affected pages
2353 * because it may cause a error with mandatory locks on these pages but
2354 * not on the region from pos to ppos+len-1.
2355 */
2356
2357 return cifs_user_writev(iocb, iov, nr_segs, pos);
2358}
2359
Jeff Layton0471ca32012-05-16 07:13:16 -04002360static struct cifs_readdata *
2361cifs_readdata_alloc(unsigned int nr_vecs, work_func_t complete)
2362{
2363 struct cifs_readdata *rdata;
2364
2365 rdata = kzalloc(sizeof(*rdata) +
2366 sizeof(struct kvec) * nr_vecs, GFP_KERNEL);
2367 if (rdata != NULL) {
Jeff Layton6993f742012-05-16 07:13:17 -04002368 kref_init(&rdata->refcount);
Jeff Layton1c892542012-05-16 07:13:17 -04002369 INIT_LIST_HEAD(&rdata->list);
2370 init_completion(&rdata->done);
Jeff Layton0471ca32012-05-16 07:13:16 -04002371 INIT_WORK(&rdata->work, complete);
2372 INIT_LIST_HEAD(&rdata->pages);
2373 }
2374 return rdata;
2375}
2376
Jeff Layton6993f742012-05-16 07:13:17 -04002377void
2378cifs_readdata_release(struct kref *refcount)
Jeff Layton0471ca32012-05-16 07:13:16 -04002379{
Jeff Layton6993f742012-05-16 07:13:17 -04002380 struct cifs_readdata *rdata = container_of(refcount,
2381 struct cifs_readdata, refcount);
2382
2383 if (rdata->cfile)
2384 cifsFileInfo_put(rdata->cfile);
2385
Jeff Layton0471ca32012-05-16 07:13:16 -04002386 kfree(rdata);
2387}
2388
Jeff Layton2a1bb132012-05-16 07:13:17 -04002389static int
Jeff Layton1c892542012-05-16 07:13:17 -04002390cifs_read_allocate_pages(struct list_head *list, unsigned int npages)
2391{
2392 int rc = 0;
2393 struct page *page, *tpage;
2394 unsigned int i;
2395
2396 for (i = 0; i < npages; i++) {
2397 page = alloc_page(GFP_KERNEL|__GFP_HIGHMEM);
2398 if (!page) {
2399 rc = -ENOMEM;
2400 break;
2401 }
2402 list_add(&page->lru, list);
2403 }
2404
2405 if (rc) {
2406 list_for_each_entry_safe(page, tpage, list, lru) {
2407 list_del(&page->lru);
2408 put_page(page);
2409 }
2410 }
2411 return rc;
2412}
2413
2414static void
2415cifs_uncached_readdata_release(struct kref *refcount)
2416{
2417 struct page *page, *tpage;
2418 struct cifs_readdata *rdata = container_of(refcount,
2419 struct cifs_readdata, refcount);
2420
2421 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2422 list_del(&page->lru);
2423 put_page(page);
2424 }
2425 cifs_readdata_release(refcount);
2426}
2427
2428static int
Jeff Layton2a1bb132012-05-16 07:13:17 -04002429cifs_retry_async_readv(struct cifs_readdata *rdata)
2430{
2431 int rc;
2432
2433 do {
2434 if (rdata->cfile->invalidHandle) {
2435 rc = cifs_reopen_file(rdata->cfile, true);
2436 if (rc != 0)
2437 continue;
2438 }
2439 rc = cifs_async_readv(rdata);
2440 } while (rc == -EAGAIN);
2441
2442 return rc;
2443}
2444
Jeff Layton1c892542012-05-16 07:13:17 -04002445/**
2446 * cifs_readdata_to_iov - copy data from pages in response to an iovec
2447 * @rdata: the readdata response with list of pages holding data
2448 * @iov: vector in which we should copy the data
2449 * @nr_segs: number of segments in vector
2450 * @offset: offset into file of the first iovec
2451 * @copied: used to return the amount of data copied to the iov
2452 *
2453 * This function copies data from a list of pages in a readdata response into
2454 * an array of iovecs. It will first calculate where the data should go
2455 * based on the info in the readdata and then copy the data into that spot.
2456 */
2457static ssize_t
2458cifs_readdata_to_iov(struct cifs_readdata *rdata, const struct iovec *iov,
2459 unsigned long nr_segs, loff_t offset, ssize_t *copied)
2460{
2461 int rc = 0;
2462 struct iov_iter ii;
2463 size_t pos = rdata->offset - offset;
2464 struct page *page, *tpage;
2465 ssize_t remaining = rdata->bytes;
2466 unsigned char *pdata;
2467
2468 /* set up iov_iter and advance to the correct offset */
2469 iov_iter_init(&ii, iov, nr_segs, iov_length(iov, nr_segs), 0);
2470 iov_iter_advance(&ii, pos);
2471
2472 *copied = 0;
2473 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2474 ssize_t copy;
2475
2476 /* copy a whole page or whatever's left */
2477 copy = min_t(ssize_t, remaining, PAGE_SIZE);
2478
2479 /* ...but limit it to whatever space is left in the iov */
2480 copy = min_t(ssize_t, copy, iov_iter_count(&ii));
2481
2482 /* go while there's data to be copied and no errors */
2483 if (copy && !rc) {
2484 pdata = kmap(page);
2485 rc = memcpy_toiovecend(ii.iov, pdata, ii.iov_offset,
2486 (int)copy);
2487 kunmap(page);
2488 if (!rc) {
2489 *copied += copy;
2490 remaining -= copy;
2491 iov_iter_advance(&ii, copy);
2492 }
2493 }
2494
2495 list_del(&page->lru);
2496 put_page(page);
2497 }
2498
2499 return rc;
2500}
2501
2502static void
2503cifs_uncached_readv_complete(struct work_struct *work)
2504{
2505 struct cifs_readdata *rdata = container_of(work,
2506 struct cifs_readdata, work);
2507
2508 /* if the result is non-zero then the pages weren't kmapped */
2509 if (rdata->result == 0) {
2510 struct page *page;
2511
2512 list_for_each_entry(page, &rdata->pages, lru)
2513 kunmap(page);
2514 }
2515
2516 complete(&rdata->done);
2517 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
2518}
2519
2520static int
2521cifs_uncached_read_marshal_iov(struct cifs_readdata *rdata,
2522 unsigned int remaining)
2523{
2524 int len = 0;
2525 struct page *page, *tpage;
2526
2527 rdata->nr_iov = 1;
2528 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2529 if (remaining >= PAGE_SIZE) {
2530 /* enough data to fill the page */
2531 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
2532 rdata->iov[rdata->nr_iov].iov_len = PAGE_SIZE;
2533 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2534 rdata->nr_iov, page->index,
2535 rdata->iov[rdata->nr_iov].iov_base,
2536 rdata->iov[rdata->nr_iov].iov_len);
2537 ++rdata->nr_iov;
2538 len += PAGE_SIZE;
2539 remaining -= PAGE_SIZE;
2540 } else if (remaining > 0) {
2541 /* enough for partial page, fill and zero the rest */
2542 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
2543 rdata->iov[rdata->nr_iov].iov_len = remaining;
2544 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2545 rdata->nr_iov, page->index,
2546 rdata->iov[rdata->nr_iov].iov_base,
2547 rdata->iov[rdata->nr_iov].iov_len);
2548 memset(rdata->iov[rdata->nr_iov].iov_base + remaining,
2549 '\0', PAGE_SIZE - remaining);
2550 ++rdata->nr_iov;
2551 len += remaining;
2552 remaining = 0;
2553 } else {
2554 /* no need to hold page hostage */
2555 list_del(&page->lru);
2556 put_page(page);
2557 }
2558 }
2559
2560 return len;
2561}
2562
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002563static ssize_t
2564cifs_iovec_read(struct file *file, const struct iovec *iov,
2565 unsigned long nr_segs, loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002566{
Jeff Layton1c892542012-05-16 07:13:17 -04002567 ssize_t rc;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002568 size_t len, cur_len;
Jeff Layton1c892542012-05-16 07:13:17 -04002569 ssize_t total_read = 0;
2570 loff_t offset = *poffset;
2571 unsigned int npages;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002572 struct cifs_sb_info *cifs_sb;
Jeff Layton1c892542012-05-16 07:13:17 -04002573 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002574 struct cifsFileInfo *open_file;
Jeff Layton1c892542012-05-16 07:13:17 -04002575 struct cifs_readdata *rdata, *tmp;
2576 struct list_head rdata_list;
2577 pid_t pid;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002578
2579 if (!nr_segs)
2580 return 0;
2581
2582 len = iov_length(iov, nr_segs);
2583 if (!len)
2584 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002585
Jeff Layton1c892542012-05-16 07:13:17 -04002586 INIT_LIST_HEAD(&rdata_list);
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002587 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Joe Perchesc21dfb62010-07-12 13:50:14 -07002588 open_file = file->private_data;
Jeff Layton1c892542012-05-16 07:13:17 -04002589 tcon = tlink_tcon(open_file->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002590
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002591 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2592 pid = open_file->pid;
2593 else
2594 pid = current->tgid;
2595
Steve Frenchad7a2922008-02-07 23:25:02 +00002596 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002597 cFYI(1, "attempting read on write only file instance");
Steve Frenchad7a2922008-02-07 23:25:02 +00002598
Jeff Layton1c892542012-05-16 07:13:17 -04002599 do {
2600 cur_len = min_t(const size_t, len - total_read, cifs_sb->rsize);
2601 npages = DIV_ROUND_UP(cur_len, PAGE_SIZE);
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002602
Jeff Layton1c892542012-05-16 07:13:17 -04002603 /* allocate a readdata struct */
2604 rdata = cifs_readdata_alloc(npages,
2605 cifs_uncached_readv_complete);
2606 if (!rdata) {
2607 rc = -ENOMEM;
2608 goto error;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002609 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002610
Jeff Layton1c892542012-05-16 07:13:17 -04002611 rc = cifs_read_allocate_pages(&rdata->pages, npages);
2612 if (rc)
2613 goto error;
2614
2615 rdata->cfile = cifsFileInfo_get(open_file);
2616 rdata->offset = offset;
2617 rdata->bytes = cur_len;
2618 rdata->pid = pid;
2619 rdata->marshal_iov = cifs_uncached_read_marshal_iov;
2620
2621 rc = cifs_retry_async_readv(rdata);
2622error:
2623 if (rc) {
2624 kref_put(&rdata->refcount,
2625 cifs_uncached_readdata_release);
2626 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002627 }
Jeff Layton1c892542012-05-16 07:13:17 -04002628
2629 list_add_tail(&rdata->list, &rdata_list);
2630 offset += cur_len;
2631 len -= cur_len;
2632 } while (len > 0);
2633
2634 /* if at least one read request send succeeded, then reset rc */
2635 if (!list_empty(&rdata_list))
2636 rc = 0;
2637
2638 /* the loop below should proceed in the order of increasing offsets */
2639restart_loop:
2640 list_for_each_entry_safe(rdata, tmp, &rdata_list, list) {
2641 if (!rc) {
2642 ssize_t copied;
2643
2644 /* FIXME: freezable sleep too? */
2645 rc = wait_for_completion_killable(&rdata->done);
2646 if (rc)
2647 rc = -EINTR;
2648 else if (rdata->result)
2649 rc = rdata->result;
2650 else {
2651 rc = cifs_readdata_to_iov(rdata, iov,
2652 nr_segs, *poffset,
2653 &copied);
2654 total_read += copied;
2655 }
2656
2657 /* resend call if it's a retryable error */
2658 if (rc == -EAGAIN) {
2659 rc = cifs_retry_async_readv(rdata);
2660 goto restart_loop;
2661 }
2662 }
2663 list_del_init(&rdata->list);
2664 kref_put(&rdata->refcount, cifs_uncached_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002665 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002666
Jeff Layton1c892542012-05-16 07:13:17 -04002667 cifs_stats_bytes_read(tcon, total_read);
2668 *poffset += total_read;
2669
2670 return total_read ? total_read : rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002671}
2672
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +03002673ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002674 unsigned long nr_segs, loff_t pos)
2675{
2676 ssize_t read;
2677
2678 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2679 if (read > 0)
2680 iocb->ki_pos = pos;
2681
2682 return read;
2683}
2684
2685ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2686 unsigned long nr_segs, loff_t pos)
2687{
2688 struct inode *inode;
2689
2690 inode = iocb->ki_filp->f_path.dentry->d_inode;
2691
2692 if (CIFS_I(inode)->clientCanCacheRead)
2693 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2694
2695 /*
2696 * In strict cache mode we need to read from the server all the time
2697 * if we don't have level II oplock because the server can delay mtime
2698 * change - so we can't make a decision about inode invalidating.
2699 * And we can also fail with pagereading if there are mandatory locks
2700 * on pages affected by this read but not on the region from pos to
2701 * pos+len-1.
2702 */
2703
2704 return cifs_user_readv(iocb, iov, nr_segs, pos);
2705}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002706
2707static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002708 loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709{
2710 int rc = -EACCES;
2711 unsigned int bytes_read = 0;
2712 unsigned int total_read;
2713 unsigned int current_read_size;
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002714 unsigned int rsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002715 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +00002716 struct cifs_tcon *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002717 int xid;
2718 char *current_offset;
2719 struct cifsFileInfo *open_file;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002720 struct cifs_io_parms io_parms;
Steve Frenchec637e32005-12-12 20:53:18 -08002721 int buf_type = CIFS_NO_BUFFER;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002722 __u32 pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002723
2724 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002725 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002726
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002727 /* FIXME: set up handlers for larger reads and/or convert to async */
2728 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2729
Linus Torvalds1da177e2005-04-16 15:20:36 -07002730 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302731 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002732 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302733 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002734 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07002735 open_file = file->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -04002736 pTcon = tlink_tcon(open_file->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002738 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2739 pid = open_file->pid;
2740 else
2741 pid = current->tgid;
2742
Linus Torvalds1da177e2005-04-16 15:20:36 -07002743 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002744 cFYI(1, "attempting read on write only file instance");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002745
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002746 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002747 read_size > total_read;
2748 total_read += bytes_read, current_offset += bytes_read) {
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002749 current_read_size = min_t(uint, read_size - total_read, rsize);
2750
Steve Frenchf9f5c8172005-09-15 23:06:38 -07002751 /* For windows me and 9x we do not want to request more
2752 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002753 if ((pTcon->ses) &&
Steve Frenchf9f5c8172005-09-15 23:06:38 -07002754 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
Dan Carpenter7748dd62011-10-18 12:41:35 +03002755 current_read_size = min_t(uint, current_read_size,
Jeff Laytonc974bef2011-10-11 06:41:32 -04002756 CIFSMaxBufSize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07002757 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002758 rc = -EAGAIN;
2759 while (rc == -EAGAIN) {
Steve Frenchcdff08e2010-10-21 22:46:14 +00002760 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04002761 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002762 if (rc != 0)
2763 break;
2764 }
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002765 io_parms.netfid = open_file->netfid;
2766 io_parms.pid = pid;
2767 io_parms.tcon = pTcon;
2768 io_parms.offset = *poffset;
2769 io_parms.length = current_read_size;
2770 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2771 &current_offset, &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002772 }
2773 if (rc || (bytes_read == 0)) {
2774 if (total_read) {
2775 break;
2776 } else {
2777 FreeXid(xid);
2778 return rc;
2779 }
2780 } else {
Steve Frencha4544342005-08-24 13:59:35 -07002781 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002782 *poffset += bytes_read;
2783 }
2784 }
2785 FreeXid(xid);
2786 return total_read;
2787}
2788
Jeff Laytonca83ce32011-04-12 09:13:44 -04002789/*
2790 * If the page is mmap'ed into a process' page tables, then we need to make
2791 * sure that it doesn't change while being written back.
2792 */
2793static int
2794cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2795{
2796 struct page *page = vmf->page;
2797
2798 lock_page(page);
2799 return VM_FAULT_LOCKED;
2800}
2801
2802static struct vm_operations_struct cifs_file_vm_ops = {
2803 .fault = filemap_fault,
2804 .page_mkwrite = cifs_page_mkwrite,
2805};
2806
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03002807int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2808{
2809 int rc, xid;
2810 struct inode *inode = file->f_path.dentry->d_inode;
2811
2812 xid = GetXid();
2813
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002814 if (!CIFS_I(inode)->clientCanCacheRead) {
2815 rc = cifs_invalidate_mapping(inode);
2816 if (rc)
2817 return rc;
2818 }
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03002819
2820 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04002821 if (rc == 0)
2822 vma->vm_ops = &cifs_file_vm_ops;
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03002823 FreeXid(xid);
2824 return rc;
2825}
2826
Linus Torvalds1da177e2005-04-16 15:20:36 -07002827int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2828{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002829 int rc, xid;
2830
2831 xid = GetXid();
Jeff Laytonabab0952010-02-12 07:44:18 -05002832 rc = cifs_revalidate_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002833 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002834 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835 FreeXid(xid);
2836 return rc;
2837 }
2838 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04002839 if (rc == 0)
2840 vma->vm_ops = &cifs_file_vm_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002841 FreeXid(xid);
2842 return rc;
2843}
2844
Jeff Layton0471ca32012-05-16 07:13:16 -04002845static void
2846cifs_readv_complete(struct work_struct *work)
2847{
2848 struct cifs_readdata *rdata = container_of(work,
2849 struct cifs_readdata, work);
2850 struct page *page, *tpage;
2851
2852 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2853 list_del(&page->lru);
2854 lru_cache_add_file(page);
2855
2856 if (rdata->result == 0) {
2857 kunmap(page);
2858 flush_dcache_page(page);
2859 SetPageUptodate(page);
2860 }
2861
2862 unlock_page(page);
2863
2864 if (rdata->result == 0)
2865 cifs_readpage_to_fscache(rdata->mapping->host, page);
2866
2867 page_cache_release(page);
2868 }
Jeff Layton6993f742012-05-16 07:13:17 -04002869 kref_put(&rdata->refcount, cifs_readdata_release);
Jeff Layton0471ca32012-05-16 07:13:16 -04002870}
2871
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04002872static int
2873cifs_readpages_marshal_iov(struct cifs_readdata *rdata, unsigned int remaining)
2874{
2875 int len = 0;
2876 struct page *page, *tpage;
2877 u64 eof;
2878 pgoff_t eof_index;
2879
2880 /* determine the eof that the server (probably) has */
2881 eof = CIFS_I(rdata->mapping->host)->server_eof;
2882 eof_index = eof ? (eof - 1) >> PAGE_CACHE_SHIFT : 0;
2883 cFYI(1, "eof=%llu eof_index=%lu", eof, eof_index);
2884
2885 rdata->nr_iov = 1;
2886 list_for_each_entry_safe(page, tpage, &rdata->pages, lru) {
2887 if (remaining >= PAGE_CACHE_SIZE) {
2888 /* enough data to fill the page */
2889 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
2890 rdata->iov[rdata->nr_iov].iov_len = PAGE_CACHE_SIZE;
2891 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2892 rdata->nr_iov, page->index,
2893 rdata->iov[rdata->nr_iov].iov_base,
2894 rdata->iov[rdata->nr_iov].iov_len);
2895 ++rdata->nr_iov;
2896 len += PAGE_CACHE_SIZE;
2897 remaining -= PAGE_CACHE_SIZE;
2898 } else if (remaining > 0) {
2899 /* enough for partial page, fill and zero the rest */
2900 rdata->iov[rdata->nr_iov].iov_base = kmap(page);
2901 rdata->iov[rdata->nr_iov].iov_len = remaining;
2902 cFYI(1, "%u: idx=%lu iov_base=%p iov_len=%zu",
2903 rdata->nr_iov, page->index,
2904 rdata->iov[rdata->nr_iov].iov_base,
2905 rdata->iov[rdata->nr_iov].iov_len);
2906 memset(rdata->iov[rdata->nr_iov].iov_base + remaining,
2907 '\0', PAGE_CACHE_SIZE - remaining);
2908 ++rdata->nr_iov;
2909 len += remaining;
2910 remaining = 0;
2911 } else if (page->index > eof_index) {
2912 /*
2913 * The VFS will not try to do readahead past the
2914 * i_size, but it's possible that we have outstanding
2915 * writes with gaps in the middle and the i_size hasn't
2916 * caught up yet. Populate those with zeroed out pages
2917 * to prevent the VFS from repeatedly attempting to
2918 * fill them until the writes are flushed.
2919 */
2920 zero_user(page, 0, PAGE_CACHE_SIZE);
2921 list_del(&page->lru);
2922 lru_cache_add_file(page);
2923 flush_dcache_page(page);
2924 SetPageUptodate(page);
2925 unlock_page(page);
2926 page_cache_release(page);
2927 } else {
2928 /* no need to hold page hostage */
2929 list_del(&page->lru);
2930 lru_cache_add_file(page);
2931 unlock_page(page);
2932 page_cache_release(page);
2933 }
2934 }
2935
2936 return len;
2937}
2938
Linus Torvalds1da177e2005-04-16 15:20:36 -07002939static int cifs_readpages(struct file *file, struct address_space *mapping,
2940 struct list_head *page_list, unsigned num_pages)
2941{
Jeff Layton690c5e32011-10-19 15:30:16 -04002942 int rc;
2943 struct list_head tmplist;
2944 struct cifsFileInfo *open_file = file->private_data;
2945 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2946 unsigned int rsize = cifs_sb->rsize;
2947 pid_t pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002948
Jeff Layton690c5e32011-10-19 15:30:16 -04002949 /*
2950 * Give up immediately if rsize is too small to read an entire page.
2951 * The VFS will fall back to readpage. We should never reach this
2952 * point however since we set ra_pages to 0 when the rsize is smaller
2953 * than a cache page.
2954 */
2955 if (unlikely(rsize < PAGE_CACHE_SIZE))
2956 return 0;
Steve Frenchbfa0d752005-08-31 21:50:37 -07002957
Suresh Jayaraman56698232010-07-05 18:13:25 +05302958 /*
2959 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2960 * immediately if the cookie is negative
2961 */
2962 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2963 &num_pages);
2964 if (rc == 0)
Jeff Layton690c5e32011-10-19 15:30:16 -04002965 return rc;
Suresh Jayaraman56698232010-07-05 18:13:25 +05302966
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002967 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2968 pid = open_file->pid;
2969 else
2970 pid = current->tgid;
2971
Jeff Layton690c5e32011-10-19 15:30:16 -04002972 rc = 0;
2973 INIT_LIST_HEAD(&tmplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002974
Jeff Layton690c5e32011-10-19 15:30:16 -04002975 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2976 mapping, num_pages);
2977
2978 /*
2979 * Start with the page at end of list and move it to private
2980 * list. Do the same with any following pages until we hit
2981 * the rsize limit, hit an index discontinuity, or run out of
2982 * pages. Issue the async read and then start the loop again
2983 * until the list is empty.
2984 *
2985 * Note that list order is important. The page_list is in
2986 * the order of declining indexes. When we put the pages in
2987 * the rdata->pages, then we want them in increasing order.
2988 */
2989 while (!list_empty(page_list)) {
2990 unsigned int bytes = PAGE_CACHE_SIZE;
2991 unsigned int expected_index;
2992 unsigned int nr_pages = 1;
2993 loff_t offset;
2994 struct page *page, *tpage;
2995 struct cifs_readdata *rdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996
2997 page = list_entry(page_list->prev, struct page, lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002998
Jeff Layton690c5e32011-10-19 15:30:16 -04002999 /*
3000 * Lock the page and put it in the cache. Since no one else
3001 * should have access to this page, we're safe to simply set
3002 * PG_locked without checking it first.
3003 */
3004 __set_page_locked(page);
3005 rc = add_to_page_cache_locked(page, mapping,
3006 page->index, GFP_KERNEL);
3007
3008 /* give up if we can't stick it in the cache */
3009 if (rc) {
3010 __clear_page_locked(page);
3011 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003012 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003013
Jeff Layton690c5e32011-10-19 15:30:16 -04003014 /* move first page to the tmplist */
3015 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3016 list_move_tail(&page->lru, &tmplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003017
Jeff Layton690c5e32011-10-19 15:30:16 -04003018 /* now try and add more pages onto the request */
3019 expected_index = page->index + 1;
3020 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
3021 /* discontinuity ? */
3022 if (page->index != expected_index)
3023 break;
3024
3025 /* would this page push the read over the rsize? */
3026 if (bytes + PAGE_CACHE_SIZE > rsize)
3027 break;
3028
3029 __set_page_locked(page);
3030 if (add_to_page_cache_locked(page, mapping,
3031 page->index, GFP_KERNEL)) {
3032 __clear_page_locked(page);
3033 break;
3034 }
3035 list_move_tail(&page->lru, &tmplist);
3036 bytes += PAGE_CACHE_SIZE;
3037 expected_index++;
3038 nr_pages++;
3039 }
3040
Jeff Layton0471ca32012-05-16 07:13:16 -04003041 rdata = cifs_readdata_alloc(nr_pages, cifs_readv_complete);
Jeff Layton690c5e32011-10-19 15:30:16 -04003042 if (!rdata) {
3043 /* best to give up if we're out of mem */
3044 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
3045 list_del(&page->lru);
3046 lru_cache_add_file(page);
3047 unlock_page(page);
3048 page_cache_release(page);
3049 }
3050 rc = -ENOMEM;
3051 break;
3052 }
3053
3054 spin_lock(&cifs_file_list_lock);
Jeff Layton690c5e32011-10-19 15:30:16 -04003055 spin_unlock(&cifs_file_list_lock);
Jeff Layton6993f742012-05-16 07:13:17 -04003056 rdata->cfile = cifsFileInfo_get(open_file);
Jeff Layton690c5e32011-10-19 15:30:16 -04003057 rdata->mapping = mapping;
3058 rdata->offset = offset;
3059 rdata->bytes = bytes;
3060 rdata->pid = pid;
Jeff Layton8d5ce4d2012-05-16 07:13:16 -04003061 rdata->marshal_iov = cifs_readpages_marshal_iov;
Jeff Layton690c5e32011-10-19 15:30:16 -04003062 list_splice_init(&tmplist, &rdata->pages);
3063
Jeff Layton2a1bb132012-05-16 07:13:17 -04003064 rc = cifs_retry_async_readv(rdata);
Jeff Layton690c5e32011-10-19 15:30:16 -04003065 if (rc != 0) {
3066 list_for_each_entry_safe(page, tpage, &rdata->pages,
3067 lru) {
3068 list_del(&page->lru);
3069 lru_cache_add_file(page);
3070 unlock_page(page);
3071 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003072 }
Jeff Layton6993f742012-05-16 07:13:17 -04003073 kref_put(&rdata->refcount, cifs_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003074 break;
3075 }
Jeff Layton6993f742012-05-16 07:13:17 -04003076
3077 kref_put(&rdata->refcount, cifs_readdata_release);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003078 }
3079
Linus Torvalds1da177e2005-04-16 15:20:36 -07003080 return rc;
3081}
3082
3083static int cifs_readpage_worker(struct file *file, struct page *page,
3084 loff_t *poffset)
3085{
3086 char *read_data;
3087 int rc;
3088
Suresh Jayaraman56698232010-07-05 18:13:25 +05303089 /* Is the page cached? */
3090 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
3091 if (rc == 0)
3092 goto read_complete;
3093
Linus Torvalds1da177e2005-04-16 15:20:36 -07003094 page_cache_get(page);
3095 read_data = kmap(page);
3096 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003097
Linus Torvalds1da177e2005-04-16 15:20:36 -07003098 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003099
Linus Torvalds1da177e2005-04-16 15:20:36 -07003100 if (rc < 0)
3101 goto io_error;
3102 else
Joe Perchesb6b38f72010-04-21 03:50:45 +00003103 cFYI(1, "Bytes read %d", rc);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003104
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08003105 file->f_path.dentry->d_inode->i_atime =
3106 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003107
Linus Torvalds1da177e2005-04-16 15:20:36 -07003108 if (PAGE_CACHE_SIZE > rc)
3109 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
3110
3111 flush_dcache_page(page);
3112 SetPageUptodate(page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05303113
3114 /* send this page to the cache */
3115 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
3116
Linus Torvalds1da177e2005-04-16 15:20:36 -07003117 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003118
Linus Torvalds1da177e2005-04-16 15:20:36 -07003119io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003120 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003121 page_cache_release(page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05303122
3123read_complete:
Linus Torvalds1da177e2005-04-16 15:20:36 -07003124 return rc;
3125}
3126
3127static int cifs_readpage(struct file *file, struct page *page)
3128{
3129 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
3130 int rc = -EACCES;
3131 int xid;
3132
3133 xid = GetXid();
3134
3135 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303136 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003137 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05303138 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003139 }
3140
Joe Perchesb6b38f72010-04-21 03:50:45 +00003141 cFYI(1, "readpage %p at offset %d 0x%x\n",
3142 page, (int)offset, (int)offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003143
3144 rc = cifs_readpage_worker(file, page, &offset);
3145
3146 unlock_page(page);
3147
3148 FreeXid(xid);
3149 return rc;
3150}
3151
Steve Frencha403a0a2007-07-26 15:54:16 +00003152static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
3153{
3154 struct cifsFileInfo *open_file;
3155
Jeff Layton44772882010-10-15 15:34:03 -04003156 spin_lock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003157 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2e396b82010-10-15 15:34:01 -04003158 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Jeff Layton44772882010-10-15 15:34:03 -04003159 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003160 return 1;
3161 }
3162 }
Jeff Layton44772882010-10-15 15:34:03 -04003163 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00003164 return 0;
3165}
3166
Linus Torvalds1da177e2005-04-16 15:20:36 -07003167/* We do not want to update the file size from server for inodes
3168 open for write - to avoid races with writepage extending
3169 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003170 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07003171 but this is tricky to do without racing with writebehind
3172 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00003173bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003174{
Steve Frencha403a0a2007-07-26 15:54:16 +00003175 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00003176 return true;
Steve French23e7dd72005-10-20 13:44:56 -07003177
Steve Frencha403a0a2007-07-26 15:54:16 +00003178 if (is_inode_writable(cifsInode)) {
3179 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08003180 struct cifs_sb_info *cifs_sb;
3181
Steve Frenchc32a0b62006-01-12 14:41:28 -08003182 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00003183 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003184 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08003185 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00003186 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08003187 }
3188
Steve Frenchfb8c4b12007-07-10 01:16:18 +00003189 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00003190 return true;
Steve French7ba52632007-02-08 18:14:13 +00003191
Steve French4b18f2a2008-04-29 00:06:05 +00003192 return false;
Steve French23e7dd72005-10-20 13:44:56 -07003193 } else
Steve French4b18f2a2008-04-29 00:06:05 +00003194 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003195}
3196
Nick Piggind9414772008-09-24 11:32:59 -04003197static int cifs_write_begin(struct file *file, struct address_space *mapping,
3198 loff_t pos, unsigned len, unsigned flags,
3199 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003200{
Nick Piggind9414772008-09-24 11:32:59 -04003201 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
3202 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003203 loff_t page_start = pos & PAGE_MASK;
3204 loff_t i_size;
3205 struct page *page;
3206 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003207
Joe Perchesb6b38f72010-04-21 03:50:45 +00003208 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
Nick Piggind9414772008-09-24 11:32:59 -04003209
Nick Piggin54566b22009-01-04 12:00:53 -08003210 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003211 if (!page) {
3212 rc = -ENOMEM;
3213 goto out;
3214 }
Nick Piggind9414772008-09-24 11:32:59 -04003215
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003216 if (PageUptodate(page))
3217 goto out;
Steve French8a236262007-03-06 00:31:00 +00003218
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003219 /*
3220 * If we write a full page it will be up to date, no need to read from
3221 * the server. If the write is short, we'll end up doing a sync write
3222 * instead.
3223 */
3224 if (len == PAGE_CACHE_SIZE)
3225 goto out;
3226
3227 /*
3228 * optimize away the read when we have an oplock, and we're not
3229 * expecting to use any of the data we'd be reading in. That
3230 * is, when the page lies beyond the EOF, or straddles the EOF
3231 * and the write will cover all of the existing data.
3232 */
3233 if (CIFS_I(mapping->host)->clientCanCacheRead) {
3234 i_size = i_size_read(mapping->host);
3235 if (page_start >= i_size ||
3236 (offset == 0 && (pos + len) >= i_size)) {
3237 zero_user_segments(page, 0, offset,
3238 offset + len,
3239 PAGE_CACHE_SIZE);
3240 /*
3241 * PageChecked means that the parts of the page
3242 * to which we're not writing are considered up
3243 * to date. Once the data is copied to the
3244 * page, it can be set uptodate.
3245 */
3246 SetPageChecked(page);
3247 goto out;
3248 }
3249 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07003250
Nick Piggind9414772008-09-24 11:32:59 -04003251 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003252 /*
3253 * might as well read a page, it is fast enough. If we get
3254 * an error, we don't need to return it. cifs_write_end will
3255 * do a sync write instead since PG_uptodate isn't set.
3256 */
3257 cifs_readpage_worker(file, page, &page_start);
Steve French8a236262007-03-06 00:31:00 +00003258 } else {
3259 /* we could try using another file handle if there is one -
3260 but how would we lock it to prevent close of that handle
3261 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04003262 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00003263 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00003264out:
3265 *pagep = page;
3266 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003267}
3268
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303269static int cifs_release_page(struct page *page, gfp_t gfp)
3270{
3271 if (PagePrivate(page))
3272 return 0;
3273
3274 return cifs_fscache_release_page(page, gfp);
3275}
3276
3277static void cifs_invalidate_page(struct page *page, unsigned long offset)
3278{
3279 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
3280
3281 if (offset == 0)
3282 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
3283}
3284
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003285static int cifs_launder_page(struct page *page)
3286{
3287 int rc = 0;
3288 loff_t range_start = page_offset(page);
3289 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
3290 struct writeback_control wbc = {
3291 .sync_mode = WB_SYNC_ALL,
3292 .nr_to_write = 0,
3293 .range_start = range_start,
3294 .range_end = range_end,
3295 };
3296
3297 cFYI(1, "Launder page: %p", page);
3298
3299 if (clear_page_dirty_for_io(page))
3300 rc = cifs_writepage_locked(page, &wbc);
3301
3302 cifs_fscache_invalidate_page(page, page->mapping->host);
3303 return rc;
3304}
3305
Tejun Heo9b646972010-07-20 22:09:02 +02003306void cifs_oplock_break(struct work_struct *work)
Jeff Layton3bc303c2009-09-21 06:47:50 -04003307{
3308 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
3309 oplock_break);
Jeff Laytona5e18bc2010-10-11 15:07:18 -04003310 struct inode *inode = cfile->dentry->d_inode;
Jeff Layton3bc303c2009-09-21 06:47:50 -04003311 struct cifsInodeInfo *cinode = CIFS_I(inode);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04003312 int rc = 0;
Jeff Layton3bc303c2009-09-21 06:47:50 -04003313
3314 if (inode && S_ISREG(inode->i_mode)) {
Steve Frenchd54ff732010-04-27 04:38:15 +00003315 if (cinode->clientCanCacheRead)
Al Viro8737c932009-12-24 06:47:55 -05003316 break_lease(inode, O_RDONLY);
Steve Frenchd54ff732010-04-27 04:38:15 +00003317 else
Al Viro8737c932009-12-24 06:47:55 -05003318 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003319 rc = filemap_fdatawrite(inode->i_mapping);
3320 if (cinode->clientCanCacheRead == 0) {
Jeff Laytoneb4b7562010-10-22 14:52:29 -04003321 rc = filemap_fdatawait(inode->i_mapping);
3322 mapping_set_error(inode->i_mapping, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003323 invalidate_remote_inode(inode);
3324 }
Joe Perchesb6b38f72010-04-21 03:50:45 +00003325 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003326 }
3327
Pavel Shilovsky85160e02011-10-22 15:33:29 +04003328 rc = cifs_push_locks(cfile);
3329 if (rc)
3330 cERROR(1, "Push locks rc = %d", rc);
3331
Jeff Layton3bc303c2009-09-21 06:47:50 -04003332 /*
3333 * releasing stale oplock after recent reconnect of smb session using
3334 * a now incorrect file handle is not a data integrity issue but do
3335 * not bother sending an oplock release if session to server still is
3336 * disconnected since oplock already released by the server
3337 */
Steve Frenchcdff08e2010-10-21 22:46:14 +00003338 if (!cfile->oplock_break_cancelled) {
Pavel Shilovsky03776f42010-08-17 11:26:00 +04003339 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
3340 current->tgid, 0, 0, 0, 0,
3341 LOCKING_ANDX_OPLOCK_RELEASE, false,
Pavel Shilovsky12fed002011-01-17 20:15:44 +03003342 cinode->clientCanCacheRead ? 1 : 0);
Joe Perchesb6b38f72010-04-21 03:50:45 +00003343 cFYI(1, "Oplock release rc = %d", rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04003344 }
Jeff Layton3bc303c2009-09-21 06:47:50 -04003345}
3346
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07003347const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003348 .readpage = cifs_readpage,
3349 .readpages = cifs_readpages,
3350 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07003351 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04003352 .write_begin = cifs_write_begin,
3353 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003354 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303355 .releasepage = cifs_release_page,
3356 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003357 .launder_page = cifs_launder_page,
Linus Torvalds1da177e2005-04-16 15:20:36 -07003358};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003359
3360/*
3361 * cifs_readpages requires the server to support a buffer large enough to
3362 * contain the header plus one complete page of data. Otherwise, we need
3363 * to leave cifs_readpages out of the address space operations.
3364 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07003365const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003366 .readpage = cifs_readpage,
3367 .writepage = cifs_writepage,
3368 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04003369 .write_begin = cifs_write_begin,
3370 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003371 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05303372 .releasepage = cifs_release_page,
3373 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04003374 .launder_page = cifs_launder_page,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00003375};