blob: 4dd9283885e745bafdd7dce81e5456f98c5635c9 [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);
267
Jeff Layton44772882010-10-15 15:34:03 -0400268 spin_lock(&cifs_file_list_lock);
Jeff Layton15ecb432010-10-15 15:34:02 -0400269 list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
270 /* if readable file instance put first in list*/
271 if (file->f_mode & FMODE_READ)
272 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
273 else
274 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
Jeff Layton44772882010-10-15 15:34:03 -0400275 spin_unlock(&cifs_file_list_lock);
Jeff Layton15ecb432010-10-15 15:34:02 -0400276
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300277 cifs_set_oplock_level(pCifsInode, oplock);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400278 pCifsInode->can_cache_brlcks = pCifsInode->clientCanCacheAll;
Jeff Layton15ecb432010-10-15 15:34:02 -0400279
280 file->private_data = pCifsFile;
281 return pCifsFile;
282}
283
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400284static void cifs_del_lock_waiters(struct cifsLockInfo *lock);
285
Steve Frenchcdff08e2010-10-21 22:46:14 +0000286/*
287 * Release a reference on the file private data. This may involve closing
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400288 * the filehandle out on the server. Must be called without holding
289 * cifs_file_list_lock.
Steve Frenchcdff08e2010-10-21 22:46:14 +0000290 */
Jeff Laytonb33879a2010-10-15 15:34:04 -0400291void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
292{
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300293 struct inode *inode = cifs_file->dentry->d_inode;
Steve French96daf2b2011-05-27 04:34:02 +0000294 struct cifs_tcon *tcon = tlink_tcon(cifs_file->tlink);
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300295 struct cifsInodeInfo *cifsi = CIFS_I(inode);
Pavel Shilovsky4f8ba8a2010-11-21 22:36:12 +0300296 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000297 struct cifsLockInfo *li, *tmp;
298
299 spin_lock(&cifs_file_list_lock);
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400300 if (--cifs_file->count > 0) {
Steve Frenchcdff08e2010-10-21 22:46:14 +0000301 spin_unlock(&cifs_file_list_lock);
302 return;
Jeff Laytonb33879a2010-10-15 15:34:04 -0400303 }
Steve Frenchcdff08e2010-10-21 22:46:14 +0000304
305 /* remove it from the lists */
306 list_del(&cifs_file->flist);
307 list_del(&cifs_file->tlist);
308
309 if (list_empty(&cifsi->openFileList)) {
310 cFYI(1, "closing last open instance for inode %p",
311 cifs_file->dentry->d_inode);
Pavel Shilovsky4f8ba8a2010-11-21 22:36:12 +0300312
313 /* in strict cache mode we need invalidate mapping on the last
314 close because it may cause a error when we open this file
315 again and get at least level II oplock */
316 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_STRICT_IO)
317 CIFS_I(inode)->invalid_mapping = true;
318
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300319 cifs_set_oplock_level(cifsi, 0);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000320 }
321 spin_unlock(&cifs_file_list_lock);
322
Jeff Laytonad635942011-07-26 12:20:17 -0400323 cancel_work_sync(&cifs_file->oplock_break);
324
Steve Frenchcdff08e2010-10-21 22:46:14 +0000325 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
326 int xid, rc;
327
328 xid = GetXid();
329 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
330 FreeXid(xid);
331 }
332
333 /* Delete any outstanding lock records. We'll lose them when the file
334 * is closed anyway.
335 */
Pavel Shilovskyd59dad22011-09-22 09:53:59 +0400336 mutex_lock(&cifsi->lock_mutex);
337 list_for_each_entry_safe(li, tmp, &cifsi->llist, llist) {
338 if (li->netfid != cifs_file->netfid)
339 continue;
Steve Frenchcdff08e2010-10-21 22:46:14 +0000340 list_del(&li->llist);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400341 cifs_del_lock_waiters(li);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000342 kfree(li);
343 }
Pavel Shilovskyd59dad22011-09-22 09:53:59 +0400344 mutex_unlock(&cifsi->lock_mutex);
Steve Frenchcdff08e2010-10-21 22:46:14 +0000345
346 cifs_put_tlink(cifs_file->tlink);
347 dput(cifs_file->dentry);
348 kfree(cifs_file);
Jeff Laytonb33879a2010-10-15 15:34:04 -0400349}
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351int cifs_open(struct inode *inode, struct file *file)
352{
353 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400354 int xid;
355 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +0000357 struct cifs_tcon *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400358 struct tcon_link *tlink;
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400359 struct cifsFileInfo *pCifsFile = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700360 char *full_path = NULL;
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300361 bool posix_open_ok = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 __u16 netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700363
364 xid = GetXid();
365
366 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400367 tlink = cifs_sb_tlink(cifs_sb);
368 if (IS_ERR(tlink)) {
369 FreeXid(xid);
370 return PTR_ERR(tlink);
371 }
372 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700373
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800374 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700375 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530376 rc = -ENOMEM;
Jeff Layton232341b2010-08-05 13:58:38 -0400377 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700378 }
379
Joe Perchesb6b38f72010-04-21 03:50:45 +0000380 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
381 inode, file->f_flags, full_path);
Steve French276a74a2009-03-03 18:00:34 +0000382
Steve Frenche7504732011-10-12 17:47:03 -0500383 if (enable_oplocks)
Steve French276a74a2009-03-03 18:00:34 +0000384 oplock = REQ_OPLOCK;
385 else
386 oplock = 0;
387
Steve French64cc2c62009-03-04 19:54:08 +0000388 if (!tcon->broken_posix_open && tcon->unix_ext &&
389 (tcon->ses->capabilities & CAP_UNIX) &&
Steve French276a74a2009-03-03 18:00:34 +0000390 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
391 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Steve French276a74a2009-03-03 18:00:34 +0000392 /* can not refresh inode info since size could be stale */
Jeff Layton2422f672010-06-16 13:40:16 -0400393 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000394 cifs_sb->mnt_file_mode /* ignored */,
Jeff Layton608712f2010-10-15 15:33:56 -0400395 file->f_flags, &oplock, &netfid, xid);
Steve French276a74a2009-03-03 18:00:34 +0000396 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000397 cFYI(1, "posix open succeeded");
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300398 posix_open_ok = true;
Steve French64cc2c62009-03-04 19:54:08 +0000399 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
400 if (tcon->ses->serverNOS)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000401 cERROR(1, "server %s of type %s returned"
Steve French64cc2c62009-03-04 19:54:08 +0000402 " unexpected error on SMB posix open"
403 ", disabling posix open support."
404 " Check if server update available.",
405 tcon->ses->serverName,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000406 tcon->ses->serverNOS);
Steve French64cc2c62009-03-04 19:54:08 +0000407 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000408 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
409 (rc != -EOPNOTSUPP)) /* path not found or net err */
410 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000411 /* else fallthrough to retry open the old way on network i/o
412 or DFS errors */
Steve French276a74a2009-03-03 18:00:34 +0000413 }
414
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300415 if (!posix_open_ok) {
416 rc = cifs_nt_open(full_path, inode, cifs_sb, tcon,
417 file->f_flags, &oplock, &netfid, xid);
418 if (rc)
419 goto out;
420 }
Jeff Layton47c78b72010-06-16 13:40:17 -0400421
Jeff Laytonabfe1ee2010-10-15 15:33:58 -0400422 pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400423 if (pCifsFile == NULL) {
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300424 CIFSSMBClose(xid, tcon, netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700425 rc = -ENOMEM;
426 goto out;
427 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530429 cifs_fscache_set_inode_cookie(inode, file);
430
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300431 if ((oplock & CIFS_CREATE_ACTION) && !posix_open_ok && tcon->unix_ext) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700432 /* time to set mode which we can not set earlier due to
433 problems creating new read-only files */
Pavel Shilovsky7e12edd2010-11-25 17:20:20 +0300434 struct cifs_unix_set_info_args args = {
435 .mode = inode->i_mode,
436 .uid = NO_CHANGE_64,
437 .gid = NO_CHANGE_64,
438 .ctime = NO_CHANGE_64,
439 .atime = NO_CHANGE_64,
440 .mtime = NO_CHANGE_64,
441 .device = 0,
442 };
Jeff Laytond44a9fe2011-01-07 11:30:29 -0500443 CIFSSMBUnixSetFileInfo(xid, tcon, &args, netfid,
444 pCifsFile->pid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700445 }
446
447out:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 kfree(full_path);
449 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400450 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451 return rc;
452}
453
Adrian Bunk04187262006-06-30 18:23:04 +0200454/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455/* to server was lost */
456static int cifs_relock_file(struct cifsFileInfo *cifsFile)
457{
458 int rc = 0;
459
460/* BB list all locks open on this file and relock */
461
462 return rc;
463}
464
Jeff Layton15886172010-10-15 15:33:59 -0400465static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466{
467 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400468 int xid;
469 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +0000471 struct cifs_tcon *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700472 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000473 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 char *full_path = NULL;
475 int desiredAccess;
476 int disposition = FILE_OPEN;
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500477 int create_options = CREATE_NOT_DIR;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700478 __u16 netfid;
479
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 xid = GetXid();
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400481 mutex_lock(&pCifsFile->fh_mutex);
Steve French4b18f2a2008-04-29 00:06:05 +0000482 if (!pCifsFile->invalidHandle) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400483 mutex_unlock(&pCifsFile->fh_mutex);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530484 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700485 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530486 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700487 }
488
Jeff Layton15886172010-10-15 15:33:59 -0400489 inode = pCifsFile->dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton13cfb732010-09-29 19:51:11 -0400491 tcon = tlink_tcon(pCifsFile->tlink);
Steve French3a9f4622007-04-04 17:10:24 +0000492
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493/* can not grab rename sem here because various ops, including
494 those that already have the rename sem can end up causing writepage
495 to get called and if the server was down that means we end up here,
496 and we can never tell if the caller already has the rename_sem */
Jeff Layton15886172010-10-15 15:33:59 -0400497 full_path = build_path_from_dentry(pCifsFile->dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000499 rc = -ENOMEM;
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400500 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000502 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700503 }
504
Joe Perchesb6b38f72010-04-21 03:50:45 +0000505 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
Jeff Layton15886172010-10-15 15:33:59 -0400506 inode, pCifsFile->f_flags, full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700507
Steve Frenche7504732011-10-12 17:47:03 -0500508 if (enable_oplocks)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700509 oplock = REQ_OPLOCK;
510 else
Steve French4b18f2a2008-04-29 00:06:05 +0000511 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700512
Steve French7fc8f4e2009-02-23 20:43:11 +0000513 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
514 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
515 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton608712f2010-10-15 15:33:56 -0400516
517 /*
518 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
519 * original open. Must mask them off for a reopen.
520 */
Jeff Layton15886172010-10-15 15:33:59 -0400521 unsigned int oflags = pCifsFile->f_flags &
522 ~(O_CREAT | O_EXCL | O_TRUNC);
Jeff Layton608712f2010-10-15 15:33:56 -0400523
Jeff Layton2422f672010-06-16 13:40:16 -0400524 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000525 cifs_sb->mnt_file_mode /* ignored */,
526 oflags, &oplock, &netfid, xid);
Steve French7fc8f4e2009-02-23 20:43:11 +0000527 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000528 cFYI(1, "posix reopen succeeded");
Steve French7fc8f4e2009-02-23 20:43:11 +0000529 goto reopen_success;
530 }
531 /* fallthrough to retry open the old way on errors, especially
532 in the reconnect path it is important to retry hard */
533 }
534
Jeff Layton15886172010-10-15 15:33:59 -0400535 desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
Steve French7fc8f4e2009-02-23 20:43:11 +0000536
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500537 if (backup_cred(cifs_sb))
538 create_options |= CREATE_OPEN_BACKUP_INTENT;
539
Linus Torvalds1da177e2005-04-16 15:20:36 -0700540 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000541 by SMBOpen and then calling get_inode_info with returned buf
542 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 and server version of file size can be stale. If we knew for sure
544 that inode was not dirty locally we could do this */
545
Steve French7fc8f4e2009-02-23 20:43:11 +0000546 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
Shirish Pargaonkar3d3ea8e2011-09-26 09:56:44 -0500547 create_options, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000548 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700549 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550 if (rc) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400551 mutex_unlock(&pCifsFile->fh_mutex);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000552 cFYI(1, "cifs_open returned 0x%x", rc);
553 cFYI(1, "oplock: %d", oplock);
Jeff Layton15886172010-10-15 15:33:59 -0400554 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700555 }
Jeff Layton15886172010-10-15 15:33:59 -0400556
557reopen_success:
558 pCifsFile->netfid = netfid;
559 pCifsFile->invalidHandle = false;
560 mutex_unlock(&pCifsFile->fh_mutex);
561 pCifsInode = CIFS_I(inode);
562
563 if (can_flush) {
564 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -0400565 mapping_set_error(inode->i_mapping, rc);
Jeff Layton15886172010-10-15 15:33:59 -0400566
Jeff Layton15886172010-10-15 15:33:59 -0400567 if (tcon->unix_ext)
568 rc = cifs_get_inode_info_unix(&inode,
569 full_path, inode->i_sb, xid);
570 else
571 rc = cifs_get_inode_info(&inode,
572 full_path, NULL, inode->i_sb,
573 xid, NULL);
574 } /* else we are writing out data to server already
575 and could deadlock if we tried to flush data, and
576 since we do not know if we have data that would
577 invalidate the current end of file on the server
578 we can not go to the server to get the new inod
579 info */
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300580
Pavel Shilovskyc6723622010-11-03 10:58:57 +0300581 cifs_set_oplock_level(pCifsInode, oplock);
Pavel Shilovskye66673e2010-11-02 12:00:42 +0300582
Jeff Layton15886172010-10-15 15:33:59 -0400583 cifs_relock_file(pCifsFile);
584
585reopen_error_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 kfree(full_path);
587 FreeXid(xid);
588 return rc;
589}
590
591int cifs_close(struct inode *inode, struct file *file)
592{
Jeff Layton77970692011-04-05 16:23:47 -0700593 if (file->private_data != NULL) {
594 cifsFileInfo_put(file->private_data);
595 file->private_data = NULL;
596 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597
Steve Frenchcdff08e2010-10-21 22:46:14 +0000598 /* return code from the ->release op is always ignored */
599 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600}
601
602int cifs_closedir(struct inode *inode, struct file *file)
603{
604 int rc = 0;
605 int xid;
Joe Perchesc21dfb62010-07-12 13:50:14 -0700606 struct cifsFileInfo *pCFileStruct = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 char *ptmp;
608
Joe Perchesb6b38f72010-04-21 03:50:45 +0000609 cFYI(1, "Closedir inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610
611 xid = GetXid();
612
613 if (pCFileStruct) {
Steve French96daf2b2011-05-27 04:34:02 +0000614 struct cifs_tcon *pTcon = tlink_tcon(pCFileStruct->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615
Joe Perchesb6b38f72010-04-21 03:50:45 +0000616 cFYI(1, "Freeing private data in close dir");
Jeff Layton44772882010-10-15 15:34:03 -0400617 spin_lock(&cifs_file_list_lock);
Steve French4b18f2a2008-04-29 00:06:05 +0000618 if (!pCFileStruct->srch_inf.endOfSearch &&
619 !pCFileStruct->invalidHandle) {
620 pCFileStruct->invalidHandle = true;
Jeff Layton44772882010-10-15 15:34:03 -0400621 spin_unlock(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700622 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000623 cFYI(1, "Closing uncompleted readdir with rc %d",
624 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 /* not much we can do if it fails anyway, ignore rc */
626 rc = 0;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000627 } else
Jeff Layton44772882010-10-15 15:34:03 -0400628 spin_unlock(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700629 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
630 if (ptmp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000631 cFYI(1, "closedir free smb buf in srch struct");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700632 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000633 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000634 cifs_small_buf_release(ptmp);
635 else
636 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700637 }
Jeff Layton13cfb732010-09-29 19:51:11 -0400638 cifs_put_tlink(pCFileStruct->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639 kfree(file->private_data);
640 file->private_data = NULL;
641 }
642 /* BB can we lock the filestruct while this is going on? */
643 FreeXid(xid);
644 return rc;
645}
646
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400647static struct cifsLockInfo *
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400648cifs_lock_init(__u64 offset, __u64 length, __u8 type, __u16 netfid)
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000649{
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400650 struct cifsLockInfo *lock =
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000651 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400652 if (!lock)
653 return lock;
654 lock->offset = offset;
655 lock->length = length;
656 lock->type = type;
657 lock->netfid = netfid;
658 lock->pid = current->tgid;
659 INIT_LIST_HEAD(&lock->blist);
660 init_waitqueue_head(&lock->block_q);
661 return lock;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400662}
663
664static void
665cifs_del_lock_waiters(struct cifsLockInfo *lock)
666{
667 struct cifsLockInfo *li, *tmp;
668 list_for_each_entry_safe(li, tmp, &lock->blist, blist) {
669 list_del_init(&li->blist);
670 wake_up(&li->block_q);
671 }
672}
673
674static bool
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400675__cifs_find_lock_conflict(struct cifsInodeInfo *cinode, __u64 offset,
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400676 __u64 length, __u8 type, __u16 netfid,
677 struct cifsLockInfo **conf_lock)
678{
679 struct cifsLockInfo *li, *tmp;
680
681 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
682 if (offset + length <= li->offset ||
683 offset >= li->offset + li->length)
684 continue;
685 else if ((type & LOCKING_ANDX_SHARED_LOCK) &&
686 ((netfid == li->netfid && current->tgid == li->pid) ||
687 type == li->type))
688 continue;
689 else {
690 *conf_lock = li;
691 return true;
692 }
693 }
694 return false;
695}
696
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400697static bool
698cifs_find_lock_conflict(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
699 struct cifsLockInfo **conf_lock)
700{
701 return __cifs_find_lock_conflict(cinode, lock->offset, lock->length,
702 lock->type, lock->netfid, conf_lock);
703}
704
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300705/*
706 * Check if there is another lock that prevents us to set the lock (mandatory
707 * style). If such a lock exists, update the flock structure with its
708 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
709 * or leave it the same if we can't. Returns 0 if we don't need to request to
710 * the server or 1 otherwise.
711 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400712static int
713cifs_lock_test(struct cifsInodeInfo *cinode, __u64 offset, __u64 length,
714 __u8 type, __u16 netfid, struct file_lock *flock)
715{
716 int rc = 0;
717 struct cifsLockInfo *conf_lock;
718 bool exist;
719
720 mutex_lock(&cinode->lock_mutex);
721
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400722 exist = __cifs_find_lock_conflict(cinode, offset, length, type, netfid,
723 &conf_lock);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400724 if (exist) {
725 flock->fl_start = conf_lock->offset;
726 flock->fl_end = conf_lock->offset + conf_lock->length - 1;
727 flock->fl_pid = conf_lock->pid;
728 if (conf_lock->type & LOCKING_ANDX_SHARED_LOCK)
729 flock->fl_type = F_RDLCK;
730 else
731 flock->fl_type = F_WRLCK;
732 } else if (!cinode->can_cache_brlcks)
733 rc = 1;
734 else
735 flock->fl_type = F_UNLCK;
736
737 mutex_unlock(&cinode->lock_mutex);
738 return rc;
739}
740
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400741static void
742cifs_lock_add(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400743{
Pavel Shilovskyd59dad22011-09-22 09:53:59 +0400744 mutex_lock(&cinode->lock_mutex);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400745 list_add_tail(&lock->llist, &cinode->llist);
Pavel Shilovskyd59dad22011-09-22 09:53:59 +0400746 mutex_unlock(&cinode->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000747}
748
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300749/*
750 * Set the byte-range lock (mandatory style). Returns:
751 * 1) 0, if we set the lock and don't need to request to the server;
752 * 2) 1, if no locks prevent us but we need to request to the server;
753 * 3) -EACCESS, if there is a lock that prevents us and wait is false.
754 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400755static int
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400756cifs_lock_add_if(struct cifsInodeInfo *cinode, struct cifsLockInfo *lock,
757 bool wait)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400758{
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400759 struct cifsLockInfo *conf_lock;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400760 bool exist;
761 int rc = 0;
762
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400763try_again:
764 exist = false;
765 mutex_lock(&cinode->lock_mutex);
766
Pavel Shilovsky161ebf92011-10-29 17:17:58 +0400767 exist = cifs_find_lock_conflict(cinode, lock, &conf_lock);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400768 if (!exist && cinode->can_cache_brlcks) {
769 list_add_tail(&lock->llist, &cinode->llist);
770 mutex_unlock(&cinode->lock_mutex);
771 return rc;
772 }
773
774 if (!exist)
775 rc = 1;
776 else if (!wait)
777 rc = -EACCES;
778 else {
779 list_add_tail(&lock->blist, &conf_lock->blist);
780 mutex_unlock(&cinode->lock_mutex);
781 rc = wait_event_interruptible(lock->block_q,
782 (lock->blist.prev == &lock->blist) &&
783 (lock->blist.next == &lock->blist));
784 if (!rc)
785 goto try_again;
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400786 mutex_lock(&cinode->lock_mutex);
787 list_del_init(&lock->blist);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400788 }
789
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400790 mutex_unlock(&cinode->lock_mutex);
791 return rc;
792}
793
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300794/*
795 * Check if there is another lock that prevents us to set the lock (posix
796 * style). If such a lock exists, update the flock structure with its
797 * properties. Otherwise, set the flock type to F_UNLCK if we can cache brlocks
798 * or leave it the same if we can't. Returns 0 if we don't need to request to
799 * the server or 1 otherwise.
800 */
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400801static int
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400802cifs_posix_lock_test(struct file *file, struct file_lock *flock)
803{
804 int rc = 0;
805 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
806 unsigned char saved_type = flock->fl_type;
807
Pavel Shilovsky50792762011-10-29 17:17:57 +0400808 if ((flock->fl_flags & FL_POSIX) == 0)
809 return 1;
810
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400811 mutex_lock(&cinode->lock_mutex);
812 posix_test_lock(file, flock);
813
814 if (flock->fl_type == F_UNLCK && !cinode->can_cache_brlcks) {
815 flock->fl_type = saved_type;
816 rc = 1;
817 }
818
819 mutex_unlock(&cinode->lock_mutex);
820 return rc;
821}
822
Pavel Shilovsky9a5101c2011-11-07 16:11:24 +0300823/*
824 * Set the byte-range lock (posix style). Returns:
825 * 1) 0, if we set the lock and don't need to request to the server;
826 * 2) 1, if we need to request to the server;
827 * 3) <0, if the error occurs while setting the lock.
828 */
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400829static int
830cifs_posix_lock_set(struct file *file, struct file_lock *flock)
831{
832 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
Pavel Shilovsky50792762011-10-29 17:17:57 +0400833 int rc = 1;
834
835 if ((flock->fl_flags & FL_POSIX) == 0)
836 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400837
838 mutex_lock(&cinode->lock_mutex);
839 if (!cinode->can_cache_brlcks) {
840 mutex_unlock(&cinode->lock_mutex);
Pavel Shilovsky50792762011-10-29 17:17:57 +0400841 return rc;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400842 }
843 rc = posix_lock_file_wait(file, flock);
844 mutex_unlock(&cinode->lock_mutex);
845 return rc;
846}
847
848static int
849cifs_push_mandatory_locks(struct cifsFileInfo *cfile)
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400850{
851 int xid, rc = 0, stored_rc;
852 struct cifsLockInfo *li, *tmp;
853 struct cifs_tcon *tcon;
854 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +0400855 unsigned int num, max_num;
856 LOCKING_ANDX_RANGE *buf, *cur;
857 int types[] = {LOCKING_ANDX_LARGE_FILES,
858 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
859 int i;
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400860
861 xid = GetXid();
862 tcon = tlink_tcon(cfile->tlink);
863
864 mutex_lock(&cinode->lock_mutex);
865 if (!cinode->can_cache_brlcks) {
866 mutex_unlock(&cinode->lock_mutex);
867 FreeXid(xid);
868 return rc;
869 }
870
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +0400871 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
872 sizeof(LOCKING_ANDX_RANGE);
873 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
874 if (!buf) {
875 mutex_unlock(&cinode->lock_mutex);
876 FreeXid(xid);
877 return rc;
878 }
879
880 for (i = 0; i < 2; i++) {
881 cur = buf;
882 num = 0;
883 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
884 if (li->type != types[i])
885 continue;
886 cur->Pid = cpu_to_le16(li->pid);
887 cur->LengthLow = cpu_to_le32((u32)li->length);
888 cur->LengthHigh = cpu_to_le32((u32)(li->length>>32));
889 cur->OffsetLow = cpu_to_le32((u32)li->offset);
890 cur->OffsetHigh = cpu_to_le32((u32)(li->offset>>32));
891 if (++num == max_num) {
892 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
893 li->type, 0, num, buf);
894 if (stored_rc)
895 rc = stored_rc;
896 cur = buf;
897 num = 0;
898 } else
899 cur++;
900 }
901
902 if (num) {
903 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
904 types[i], 0, num, buf);
905 if (stored_rc)
906 rc = stored_rc;
907 }
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400908 }
909
910 cinode->can_cache_brlcks = false;
911 mutex_unlock(&cinode->lock_mutex);
912
Pavel Shilovsky32b9aaf2011-10-22 15:33:32 +0400913 kfree(buf);
Pavel Shilovsky85160e02011-10-22 15:33:29 +0400914 FreeXid(xid);
915 return rc;
916}
917
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400918/* copied from fs/locks.c with a name change */
919#define cifs_for_each_lock(inode, lockp) \
920 for (lockp = &inode->i_flock; *lockp != NULL; \
921 lockp = &(*lockp)->fl_next)
922
923static int
924cifs_push_posix_locks(struct cifsFileInfo *cfile)
925{
926 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
927 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
928 struct file_lock *flock, **before;
929 struct cifsLockInfo *lck, *tmp;
930 int rc = 0, xid, type;
931 __u64 length;
932 struct list_head locks_to_send;
933
934 xid = GetXid();
935
936 mutex_lock(&cinode->lock_mutex);
937 if (!cinode->can_cache_brlcks) {
938 mutex_unlock(&cinode->lock_mutex);
939 FreeXid(xid);
940 return rc;
941 }
942
943 INIT_LIST_HEAD(&locks_to_send);
944
945 lock_flocks();
946 cifs_for_each_lock(cfile->dentry->d_inode, before) {
947 flock = *before;
948 length = 1 + flock->fl_end - flock->fl_start;
949 if (flock->fl_type == F_RDLCK || flock->fl_type == F_SHLCK)
950 type = CIFS_RDLCK;
951 else
952 type = CIFS_WRLCK;
953
Pavel Shilovskya88b4702011-10-29 17:17:59 +0400954 lck = cifs_lock_init(flock->fl_start, length, type,
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +0400955 cfile->netfid);
956 if (!lck) {
957 rc = -ENOMEM;
958 goto send_locks;
959 }
960 lck->pid = flock->fl_pid;
961
962 list_add_tail(&lck->llist, &locks_to_send);
963 }
964
965send_locks:
966 unlock_flocks();
967
968 list_for_each_entry_safe(lck, tmp, &locks_to_send, llist) {
969 struct file_lock tmp_lock;
970 int stored_rc;
971
972 tmp_lock.fl_start = lck->offset;
973 stored_rc = CIFSSMBPosixLock(xid, tcon, lck->netfid, lck->pid,
974 0, lck->length, &tmp_lock,
975 lck->type, 0);
976 if (stored_rc)
977 rc = stored_rc;
978 list_del(&lck->llist);
979 kfree(lck);
980 }
981
982 cinode->can_cache_brlcks = false;
983 mutex_unlock(&cinode->lock_mutex);
984
985 FreeXid(xid);
986 return rc;
987}
988
989static int
990cifs_push_locks(struct cifsFileInfo *cfile)
991{
992 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
993 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
994
995 if ((tcon->ses->capabilities & CAP_UNIX) &&
996 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
997 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
998 return cifs_push_posix_locks(cfile);
999
1000 return cifs_push_mandatory_locks(cfile);
1001}
1002
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001003static void
1004cifs_read_flock(struct file_lock *flock, __u8 *type, int *lock, int *unlock,
1005 bool *wait_flag)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001006{
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001007 if (flock->fl_flags & FL_POSIX)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001008 cFYI(1, "Posix");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001009 if (flock->fl_flags & FL_FLOCK)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001010 cFYI(1, "Flock");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001011 if (flock->fl_flags & FL_SLEEP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001012 cFYI(1, "Blocking lock");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001013 *wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014 }
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001015 if (flock->fl_flags & FL_ACCESS)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001016 cFYI(1, "Process suspended by mandatory locking - "
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001017 "not implemented yet");
1018 if (flock->fl_flags & FL_LEASE)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001019 cFYI(1, "Lease on file - not implemented yet");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001020 if (flock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -07001021 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001022 cFYI(1, "Unknown lock flags 0x%x", flock->fl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001023
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001024 *type = LOCKING_ANDX_LARGE_FILES;
1025 if (flock->fl_type == F_WRLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001026 cFYI(1, "F_WRLCK ");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001027 *lock = 1;
1028 } else if (flock->fl_type == F_UNLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001029 cFYI(1, "F_UNLCK");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001030 *unlock = 1;
1031 /* Check if unlock includes more than one lock range */
1032 } else if (flock->fl_type == F_RDLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001033 cFYI(1, "F_RDLCK");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001034 *type |= LOCKING_ANDX_SHARED_LOCK;
1035 *lock = 1;
1036 } else if (flock->fl_type == F_EXLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001037 cFYI(1, "F_EXLCK");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001038 *lock = 1;
1039 } else if (flock->fl_type == F_SHLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001040 cFYI(1, "F_SHLCK");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001041 *type |= LOCKING_ANDX_SHARED_LOCK;
1042 *lock = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +00001044 cFYI(1, "Unknown type of lock");
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001045}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001047static int
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001048cifs_getlk(struct file *file, struct file_lock *flock, __u8 type,
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001049 bool wait_flag, bool posix_lck, int xid)
1050{
1051 int rc = 0;
1052 __u64 length = 1 + flock->fl_end - flock->fl_start;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001053 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1054 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001055 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001056 __u16 netfid = cfile->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001058 if (posix_lck) {
1059 int posix_lock_type;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001060
1061 rc = cifs_posix_lock_test(file, flock);
1062 if (!rc)
1063 return rc;
1064
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001065 if (type & LOCKING_ANDX_SHARED_LOCK)
1066 posix_lock_type = CIFS_RDLCK;
1067 else
1068 posix_lock_type = CIFS_WRLCK;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001069 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1070 1 /* get */, length, flock,
1071 posix_lock_type, wait_flag);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072 return rc;
1073 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001074
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001075 rc = cifs_lock_test(cinode, flock->fl_start, length, type, netfid,
1076 flock);
1077 if (!rc)
1078 return rc;
1079
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001080 /* BB we could chain these into one lock request BB */
1081 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1082 flock->fl_start, 0, 1, type, 0, 0);
1083 if (rc == 0) {
1084 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1085 length, flock->fl_start, 1, 0,
1086 type, 0, 0);
1087 flock->fl_type = F_UNLCK;
1088 if (rc != 0)
1089 cERROR(1, "Error unlocking previously locked "
1090 "range %d during test of lock", rc);
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001091 return 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001092 }
1093
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001094 if (type & LOCKING_ANDX_SHARED_LOCK) {
1095 flock->fl_type = F_WRLCK;
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001096 return 0;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001097 }
1098
1099 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
1100 flock->fl_start, 0, 1,
1101 type | LOCKING_ANDX_SHARED_LOCK, 0, 0);
1102 if (rc == 0) {
1103 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid,
1104 length, flock->fl_start, 1, 0,
1105 type | LOCKING_ANDX_SHARED_LOCK,
1106 0, 0);
1107 flock->fl_type = F_RDLCK;
1108 if (rc != 0)
1109 cERROR(1, "Error unlocking previously locked "
1110 "range %d during test of lock", rc);
1111 } else
1112 flock->fl_type = F_WRLCK;
1113
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001114 return 0;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001115}
1116
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001117static void
1118cifs_move_llist(struct list_head *source, struct list_head *dest)
1119{
1120 struct list_head *li, *tmp;
1121 list_for_each_safe(li, tmp, source)
1122 list_move(li, dest);
1123}
1124
1125static void
1126cifs_free_llist(struct list_head *llist)
1127{
1128 struct cifsLockInfo *li, *tmp;
1129 list_for_each_entry_safe(li, tmp, llist, llist) {
1130 cifs_del_lock_waiters(li);
1131 list_del(&li->llist);
1132 kfree(li);
1133 }
1134}
1135
1136static int
1137cifs_unlock_range(struct cifsFileInfo *cfile, struct file_lock *flock, int xid)
1138{
1139 int rc = 0, stored_rc;
1140 int types[] = {LOCKING_ANDX_LARGE_FILES,
1141 LOCKING_ANDX_SHARED_LOCK | LOCKING_ANDX_LARGE_FILES};
1142 unsigned int i;
1143 unsigned int max_num, num;
1144 LOCKING_ANDX_RANGE *buf, *cur;
1145 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
1146 struct cifsInodeInfo *cinode = CIFS_I(cfile->dentry->d_inode);
1147 struct cifsLockInfo *li, *tmp;
1148 __u64 length = 1 + flock->fl_end - flock->fl_start;
1149 struct list_head tmp_llist;
1150
1151 INIT_LIST_HEAD(&tmp_llist);
1152
1153 max_num = (tcon->ses->server->maxBuf - sizeof(struct smb_hdr)) /
1154 sizeof(LOCKING_ANDX_RANGE);
1155 buf = kzalloc(max_num * sizeof(LOCKING_ANDX_RANGE), GFP_KERNEL);
1156 if (!buf)
1157 return -ENOMEM;
1158
1159 mutex_lock(&cinode->lock_mutex);
1160 for (i = 0; i < 2; i++) {
1161 cur = buf;
1162 num = 0;
1163 list_for_each_entry_safe(li, tmp, &cinode->llist, llist) {
1164 if (flock->fl_start > li->offset ||
1165 (flock->fl_start + length) <
1166 (li->offset + li->length))
1167 continue;
1168 if (current->tgid != li->pid)
1169 continue;
1170 if (cfile->netfid != li->netfid)
1171 continue;
1172 if (types[i] != li->type)
1173 continue;
1174 if (!cinode->can_cache_brlcks) {
1175 cur->Pid = cpu_to_le16(li->pid);
1176 cur->LengthLow = cpu_to_le32((u32)li->length);
1177 cur->LengthHigh =
1178 cpu_to_le32((u32)(li->length>>32));
1179 cur->OffsetLow = cpu_to_le32((u32)li->offset);
1180 cur->OffsetHigh =
1181 cpu_to_le32((u32)(li->offset>>32));
1182 /*
1183 * We need to save a lock here to let us add
1184 * it again to the inode list if the unlock
1185 * range request fails on the server.
1186 */
1187 list_move(&li->llist, &tmp_llist);
1188 if (++num == max_num) {
1189 stored_rc = cifs_lockv(xid, tcon,
1190 cfile->netfid,
1191 li->type, num,
1192 0, buf);
1193 if (stored_rc) {
1194 /*
1195 * We failed on the unlock range
1196 * request - add all locks from
1197 * the tmp list to the head of
1198 * the inode list.
1199 */
1200 cifs_move_llist(&tmp_llist,
1201 &cinode->llist);
1202 rc = stored_rc;
1203 } else
1204 /*
1205 * The unlock range request
1206 * succeed - free the tmp list.
1207 */
1208 cifs_free_llist(&tmp_llist);
1209 cur = buf;
1210 num = 0;
1211 } else
1212 cur++;
1213 } else {
1214 /*
1215 * We can cache brlock requests - simply remove
1216 * a lock from the inode list.
1217 */
1218 list_del(&li->llist);
1219 cifs_del_lock_waiters(li);
1220 kfree(li);
1221 }
1222 }
1223 if (num) {
1224 stored_rc = cifs_lockv(xid, tcon, cfile->netfid,
1225 types[i], num, 0, buf);
1226 if (stored_rc) {
1227 cifs_move_llist(&tmp_llist, &cinode->llist);
1228 rc = stored_rc;
1229 } else
1230 cifs_free_llist(&tmp_llist);
1231 }
1232 }
1233
1234 mutex_unlock(&cinode->lock_mutex);
1235 kfree(buf);
1236 return rc;
1237}
1238
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001239static int
1240cifs_setlk(struct file *file, struct file_lock *flock, __u8 type,
1241 bool wait_flag, bool posix_lck, int lock, int unlock, int xid)
1242{
1243 int rc = 0;
1244 __u64 length = 1 + flock->fl_end - flock->fl_start;
1245 struct cifsFileInfo *cfile = (struct cifsFileInfo *)file->private_data;
1246 struct cifs_tcon *tcon = tlink_tcon(cfile->tlink);
Pavel Shilovskyd59dad22011-09-22 09:53:59 +04001247 struct cifsInodeInfo *cinode = CIFS_I(file->f_path.dentry->d_inode);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001248 __u16 netfid = cfile->netfid;
1249
1250 if (posix_lck) {
Steve French08547b02006-02-28 22:39:25 +00001251 int posix_lock_type;
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001252
1253 rc = cifs_posix_lock_set(file, flock);
1254 if (!rc || rc < 0)
1255 return rc;
1256
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001257 if (type & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +00001258 posix_lock_type = CIFS_RDLCK;
1259 else
1260 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +00001261
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001262 if (unlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +00001263 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001264
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001265 rc = CIFSSMBPosixLock(xid, tcon, netfid, current->tgid,
1266 0 /* set */, length, flock,
1267 posix_lock_type, wait_flag);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001268 goto out;
Jeremy Allison7ee1af72006-08-02 21:56:33 +00001269 }
1270
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001271 if (lock) {
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001272 struct cifsLockInfo *lock;
1273
Pavel Shilovskya88b4702011-10-29 17:17:59 +04001274 lock = cifs_lock_init(flock->fl_start, length, type, netfid);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001275 if (!lock)
1276 return -ENOMEM;
1277
1278 rc = cifs_lock_add_if(cinode, lock, wait_flag);
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001279 if (rc < 0)
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001280 kfree(lock);
1281 if (rc <= 0)
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001282 goto out;
1283
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001284 rc = CIFSSMBLock(xid, tcon, netfid, current->tgid, length,
Pavel Shilovsky85160e02011-10-22 15:33:29 +04001285 flock->fl_start, 0, 1, type, wait_flag, 0);
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001286 if (rc) {
1287 kfree(lock);
1288 goto out;
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001289 }
Pavel Shilovsky161ebf92011-10-29 17:17:58 +04001290
1291 cifs_lock_add(cinode, lock);
Pavel Shilovsky9ee305b2011-10-22 15:33:31 +04001292 } else if (unlock)
1293 rc = cifs_unlock_range(cfile, flock, xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001294
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001295out:
1296 if (flock->fl_flags & FL_POSIX)
1297 posix_lock_file_wait(file, flock);
1298 return rc;
1299}
1300
1301int cifs_lock(struct file *file, int cmd, struct file_lock *flock)
1302{
1303 int rc, xid;
1304 int lock = 0, unlock = 0;
1305 bool wait_flag = false;
1306 bool posix_lck = false;
1307 struct cifs_sb_info *cifs_sb;
1308 struct cifs_tcon *tcon;
1309 struct cifsInodeInfo *cinode;
1310 struct cifsFileInfo *cfile;
1311 __u16 netfid;
1312 __u8 type;
1313
1314 rc = -EACCES;
1315 xid = GetXid();
1316
1317 cFYI(1, "Lock parm: 0x%x flockflags: 0x%x flocktype: 0x%x start: %lld "
1318 "end: %lld", cmd, flock->fl_flags, flock->fl_type,
1319 flock->fl_start, flock->fl_end);
1320
1321 cifs_read_flock(flock, &type, &lock, &unlock, &wait_flag);
1322
1323 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
1324 cfile = (struct cifsFileInfo *)file->private_data;
1325 tcon = tlink_tcon(cfile->tlink);
1326 netfid = cfile->netfid;
1327 cinode = CIFS_I(file->f_path.dentry->d_inode);
1328
1329 if ((tcon->ses->capabilities & CAP_UNIX) &&
1330 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
1331 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
1332 posix_lck = true;
1333 /*
1334 * BB add code here to normalize offset and length to account for
1335 * negative length which we can not accept over the wire.
1336 */
1337 if (IS_GETLK(cmd)) {
Pavel Shilovsky4f6bcec2011-10-22 15:33:30 +04001338 rc = cifs_getlk(file, flock, type, wait_flag, posix_lck, xid);
Pavel Shilovsky03776f42010-08-17 11:26:00 +04001339 FreeXid(xid);
1340 return rc;
1341 }
1342
1343 if (!lock && !unlock) {
1344 /*
1345 * if no lock or unlock then nothing to do since we do not
1346 * know what it is
1347 */
1348 FreeXid(xid);
1349 return -EOPNOTSUPP;
1350 }
1351
1352 rc = cifs_setlk(file, flock, type, wait_flag, posix_lck, lock, unlock,
1353 xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001354 FreeXid(xid);
1355 return rc;
1356}
1357
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001358/* update the file size (if needed) after a write */
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05001359void
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001360cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
1361 unsigned int bytes_written)
1362{
1363 loff_t end_of_write = offset + bytes_written;
1364
1365 if (end_of_write > cifsi->server_eof)
1366 cifsi->server_eof = end_of_write;
1367}
1368
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001369static ssize_t cifs_write(struct cifsFileInfo *open_file, __u32 pid,
Jeff Layton7da4b492010-10-15 15:34:00 -04001370 const char *write_data, size_t write_size,
1371 loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001372{
1373 int rc = 0;
1374 unsigned int bytes_written = 0;
1375 unsigned int total_written;
1376 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +00001377 struct cifs_tcon *pTcon;
Jeff Layton77499812011-01-11 07:24:23 -05001378 int xid;
Jeff Layton7da4b492010-10-15 15:34:00 -04001379 struct dentry *dentry = open_file->dentry;
1380 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001381 struct cifs_io_parms io_parms;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382
Jeff Layton7da4b492010-10-15 15:34:00 -04001383 cifs_sb = CIFS_SB(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001384
Joe Perchesb6b38f72010-04-21 03:50:45 +00001385 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
Jeff Layton7da4b492010-10-15 15:34:00 -04001386 *poffset, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001387
Jeff Layton13cfb732010-09-29 19:51:11 -04001388 pTcon = tlink_tcon(open_file->tlink);
Steve French50c2f752007-07-13 00:33:32 +00001389
Linus Torvalds1da177e2005-04-16 15:20:36 -07001390 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001391
Linus Torvalds1da177e2005-04-16 15:20:36 -07001392 for (total_written = 0; write_size > total_written;
1393 total_written += bytes_written) {
1394 rc = -EAGAIN;
1395 while (rc == -EAGAIN) {
Jeff Laytonca83ce32011-04-12 09:13:44 -04001396 struct kvec iov[2];
1397 unsigned int len;
1398
Linus Torvalds1da177e2005-04-16 15:20:36 -07001399 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 /* we could deadlock if we called
1401 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001402 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 server now */
Jeff Layton15886172010-10-15 15:33:59 -04001404 rc = cifs_reopen_file(open_file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 if (rc != 0)
1406 break;
1407 }
Steve French3e844692005-10-03 13:37:24 -07001408
Jeff Laytonca83ce32011-04-12 09:13:44 -04001409 len = min((size_t)cifs_sb->wsize,
1410 write_size - total_written);
1411 /* iov[0] is reserved for smb header */
1412 iov[1].iov_base = (char *)write_data + total_written;
1413 iov[1].iov_len = len;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001414 io_parms.netfid = open_file->netfid;
1415 io_parms.pid = pid;
1416 io_parms.tcon = pTcon;
1417 io_parms.offset = *poffset;
1418 io_parms.length = len;
1419 rc = CIFSSMBWrite2(xid, &io_parms, &bytes_written, iov,
1420 1, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001421 }
1422 if (rc || (bytes_written == 0)) {
1423 if (total_written)
1424 break;
1425 else {
1426 FreeXid(xid);
1427 return rc;
1428 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001429 } else {
1430 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001431 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001432 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001433 }
1434
Steve Frencha4544342005-08-24 13:59:35 -07001435 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436
Jeff Layton7da4b492010-10-15 15:34:00 -04001437 if (total_written > 0) {
1438 spin_lock(&dentry->d_inode->i_lock);
1439 if (*poffset > dentry->d_inode->i_size)
1440 i_size_write(dentry->d_inode, *poffset);
1441 spin_unlock(&dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001442 }
Jeff Layton7da4b492010-10-15 15:34:00 -04001443 mark_inode_dirty_sync(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444 FreeXid(xid);
1445 return total_written;
1446}
1447
Jeff Layton6508d902010-09-29 19:51:11 -04001448struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1449 bool fsuid_only)
Steve French630f3f02007-10-25 21:17:17 +00001450{
1451 struct cifsFileInfo *open_file = NULL;
Jeff Layton6508d902010-09-29 19:51:11 -04001452 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1453
1454 /* only filter by fsuid on multiuser mounts */
1455 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1456 fsuid_only = false;
Steve French630f3f02007-10-25 21:17:17 +00001457
Jeff Layton44772882010-10-15 15:34:03 -04001458 spin_lock(&cifs_file_list_lock);
Steve French630f3f02007-10-25 21:17:17 +00001459 /* we could simply get the first_list_entry since write-only entries
1460 are always at the end of the list but since the first entry might
1461 have a close pending, we go through the whole list */
1462 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton6508d902010-09-29 19:51:11 -04001463 if (fsuid_only && open_file->uid != current_fsuid())
1464 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001465 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
Steve French630f3f02007-10-25 21:17:17 +00001466 if (!open_file->invalidHandle) {
1467 /* found a good file */
1468 /* lock it so it will not be closed on us */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001469 cifsFileInfo_get(open_file);
Jeff Layton44772882010-10-15 15:34:03 -04001470 spin_unlock(&cifs_file_list_lock);
Steve French630f3f02007-10-25 21:17:17 +00001471 return open_file;
1472 } /* else might as well continue, and look for
1473 another, or simply have the caller reopen it
1474 again rather than trying to fix this handle */
1475 } else /* write only file */
1476 break; /* write only files are last so must be done */
1477 }
Jeff Layton44772882010-10-15 15:34:03 -04001478 spin_unlock(&cifs_file_list_lock);
Steve French630f3f02007-10-25 21:17:17 +00001479 return NULL;
1480}
Steve French630f3f02007-10-25 21:17:17 +00001481
Jeff Layton6508d902010-09-29 19:51:11 -04001482struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1483 bool fsuid_only)
Steve French6148a742005-10-05 12:23:19 -07001484{
1485 struct cifsFileInfo *open_file;
Jeff Laytond3892292010-11-02 16:22:50 -04001486 struct cifs_sb_info *cifs_sb;
Jeff Layton2846d382008-09-22 21:33:33 -04001487 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001488 int rc;
Steve French6148a742005-10-05 12:23:19 -07001489
Steve French60808232006-04-22 15:53:05 +00001490 /* Having a null inode here (because mapping->host was set to zero by
1491 the VFS or MM) should not happen but we had reports of on oops (due to
1492 it being zero) during stress testcases so we need to check for it */
1493
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001494 if (cifs_inode == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001495 cERROR(1, "Null inode passed to cifs_writeable_file");
Steve French60808232006-04-22 15:53:05 +00001496 dump_stack();
1497 return NULL;
1498 }
1499
Jeff Laytond3892292010-11-02 16:22:50 -04001500 cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1501
Jeff Layton6508d902010-09-29 19:51:11 -04001502 /* only filter by fsuid on multiuser mounts */
1503 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1504 fsuid_only = false;
1505
Jeff Layton44772882010-10-15 15:34:03 -04001506 spin_lock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001507refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001508 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton6508d902010-09-29 19:51:11 -04001509 if (!any_available && open_file->pid != current->tgid)
1510 continue;
1511 if (fsuid_only && open_file->uid != current_fsuid())
1512 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001513 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001514 cifsFileInfo_get(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001515
1516 if (!open_file->invalidHandle) {
1517 /* found a good writable file */
Jeff Layton44772882010-10-15 15:34:03 -04001518 spin_unlock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001519 return open_file;
1520 }
Steve French8840dee2007-11-16 23:05:52 +00001521
Jeff Layton44772882010-10-15 15:34:03 -04001522 spin_unlock(&cifs_file_list_lock);
Steve Frenchcdff08e2010-10-21 22:46:14 +00001523
Steve French9b22b0b2007-10-02 01:11:08 +00001524 /* Had to unlock since following call can block */
Jeff Layton15886172010-10-15 15:33:59 -04001525 rc = cifs_reopen_file(open_file, false);
Steve Frenchcdff08e2010-10-21 22:46:14 +00001526 if (!rc)
1527 return open_file;
Steve French9b22b0b2007-10-02 01:11:08 +00001528
Steve Frenchcdff08e2010-10-21 22:46:14 +00001529 /* if it fails, try another handle if possible */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001530 cFYI(1, "wp failed on reopen file");
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001531 cifsFileInfo_put(open_file);
Steve French8840dee2007-11-16 23:05:52 +00001532
Steve Frenchcdff08e2010-10-21 22:46:14 +00001533 spin_lock(&cifs_file_list_lock);
1534
Steve French9b22b0b2007-10-02 01:11:08 +00001535 /* else we simply continue to the next entry. Thus
1536 we do not loop on reopen errors. If we
1537 can not reopen the file, for example if we
1538 reconnected to a server with another client
1539 racing to delete or lock the file we would not
1540 make progress if we restarted before the beginning
1541 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001542 }
1543 }
Jeff Layton2846d382008-09-22 21:33:33 -04001544 /* couldn't find useable FH with same pid, try any available */
1545 if (!any_available) {
1546 any_available = true;
1547 goto refind_writable;
1548 }
Jeff Layton44772882010-10-15 15:34:03 -04001549 spin_unlock(&cifs_file_list_lock);
Steve French6148a742005-10-05 12:23:19 -07001550 return NULL;
1551}
1552
Linus Torvalds1da177e2005-04-16 15:20:36 -07001553static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1554{
1555 struct address_space *mapping = page->mapping;
1556 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1557 char *write_data;
1558 int rc = -EFAULT;
1559 int bytes_written = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001560 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001561 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562
1563 if (!mapping || !mapping->host)
1564 return -EFAULT;
1565
1566 inode = page->mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001567
1568 offset += (loff_t)from;
1569 write_data = kmap(page);
1570 write_data += from;
1571
1572 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1573 kunmap(page);
1574 return -EIO;
1575 }
1576
1577 /* racing with truncate? */
1578 if (offset > mapping->host->i_size) {
1579 kunmap(page);
1580 return 0; /* don't care */
1581 }
1582
1583 /* check to make sure that we are not extending the file */
1584 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001585 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586
Jeff Layton6508d902010-09-29 19:51:11 -04001587 open_file = find_writable_file(CIFS_I(mapping->host), false);
Steve French6148a742005-10-05 12:23:19 -07001588 if (open_file) {
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04001589 bytes_written = cifs_write(open_file, open_file->pid,
1590 write_data, to - from, &offset);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001591 cifsFileInfo_put(open_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001592 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001593 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001594 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001595 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001596 else if (bytes_written < 0)
1597 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001598 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001599 cFYI(1, "No writeable filehandles for inode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 rc = -EIO;
1601 }
1602
1603 kunmap(page);
1604 return rc;
1605}
1606
Linus Torvalds1da177e2005-04-16 15:20:36 -07001607static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001608 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001609{
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001610 struct cifs_sb_info *cifs_sb = CIFS_SB(mapping->host->i_sb);
1611 bool done = false, scanned = false, range_whole = false;
1612 pgoff_t end, index;
1613 struct cifs_writedata *wdata;
Steve French37c0eb42005-10-05 14:50:29 -07001614 struct page *page;
Steve French37c0eb42005-10-05 14:50:29 -07001615 int rc = 0;
Steve French50c2f752007-07-13 00:33:32 +00001616
Steve French37c0eb42005-10-05 14:50:29 -07001617 /*
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001618 * If wsize is smaller than the page cache size, default to writing
Steve French37c0eb42005-10-05 14:50:29 -07001619 * one page at a time via cifs_writepage
1620 */
1621 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1622 return generic_writepages(mapping, wbc);
1623
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001624 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001625 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001626 end = -1;
1627 } else {
1628 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1629 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1630 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001631 range_whole = true;
1632 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07001633 }
1634retry:
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001635 while (!done && index <= end) {
1636 unsigned int i, nr_pages, found_pages;
1637 pgoff_t next = 0, tofind;
1638 struct page **pages;
Steve French37c0eb42005-10-05 14:50:29 -07001639
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001640 tofind = min((cifs_sb->wsize / PAGE_CACHE_SIZE) - 1,
1641 end - index) + 1;
Steve French37c0eb42005-10-05 14:50:29 -07001642
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001643 wdata = cifs_writedata_alloc((unsigned int)tofind);
1644 if (!wdata) {
1645 rc = -ENOMEM;
1646 break;
1647 }
1648
1649 /*
1650 * find_get_pages_tag seems to return a max of 256 on each
1651 * iteration, so we must call it several times in order to
1652 * fill the array or the wsize is effectively limited to
1653 * 256 * PAGE_CACHE_SIZE.
1654 */
1655 found_pages = 0;
1656 pages = wdata->pages;
1657 do {
1658 nr_pages = find_get_pages_tag(mapping, &index,
1659 PAGECACHE_TAG_DIRTY,
1660 tofind, pages);
1661 found_pages += nr_pages;
1662 tofind -= nr_pages;
1663 pages += nr_pages;
1664 } while (nr_pages && tofind && index <= end);
1665
1666 if (found_pages == 0) {
1667 kref_put(&wdata->refcount, cifs_writedata_release);
1668 break;
1669 }
1670
1671 nr_pages = 0;
1672 for (i = 0; i < found_pages; i++) {
1673 page = wdata->pages[i];
Steve French37c0eb42005-10-05 14:50:29 -07001674 /*
1675 * At this point we hold neither mapping->tree_lock nor
1676 * lock on the page itself: the page may be truncated or
1677 * invalidated (changing page->mapping to NULL), or even
1678 * swizzled back from swapper_space to tmpfs file
1679 * mapping
1680 */
1681
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001682 if (nr_pages == 0)
Steve French37c0eb42005-10-05 14:50:29 -07001683 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001684 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001685 break;
1686
1687 if (unlikely(page->mapping != mapping)) {
1688 unlock_page(page);
1689 break;
1690 }
1691
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001692 if (!wbc->range_cyclic && page->index > end) {
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001693 done = true;
Steve French37c0eb42005-10-05 14:50:29 -07001694 unlock_page(page);
1695 break;
1696 }
1697
1698 if (next && (page->index != next)) {
1699 /* Not next consecutive page */
1700 unlock_page(page);
1701 break;
1702 }
1703
1704 if (wbc->sync_mode != WB_SYNC_NONE)
1705 wait_on_page_writeback(page);
1706
1707 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001708 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001709 unlock_page(page);
1710 break;
1711 }
Steve French84d2f072005-10-12 15:32:05 -07001712
Linus Torvaldscb876f42006-12-23 16:19:07 -08001713 /*
1714 * This actually clears the dirty bit in the radix tree.
1715 * See cifs_writepage() for more commentary.
1716 */
1717 set_page_writeback(page);
1718
Steve French84d2f072005-10-12 15:32:05 -07001719 if (page_offset(page) >= mapping->host->i_size) {
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001720 done = true;
Steve French84d2f072005-10-12 15:32:05 -07001721 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001722 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001723 break;
1724 }
1725
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001726 wdata->pages[i] = page;
Steve French37c0eb42005-10-05 14:50:29 -07001727 next = page->index + 1;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001728 ++nr_pages;
Steve French37c0eb42005-10-05 14:50:29 -07001729 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001730
1731 /* reset index to refind any pages skipped */
1732 if (nr_pages == 0)
1733 index = wdata->pages[0]->index + 1;
1734
1735 /* put any pages we aren't going to use */
1736 for (i = nr_pages; i < found_pages; i++) {
1737 page_cache_release(wdata->pages[i]);
1738 wdata->pages[i] = NULL;
1739 }
1740
1741 /* nothing to write? */
1742 if (nr_pages == 0) {
1743 kref_put(&wdata->refcount, cifs_writedata_release);
1744 continue;
1745 }
1746
1747 wdata->sync_mode = wbc->sync_mode;
1748 wdata->nr_pages = nr_pages;
1749 wdata->offset = page_offset(wdata->pages[0]);
1750
1751 do {
1752 if (wdata->cfile != NULL)
1753 cifsFileInfo_put(wdata->cfile);
1754 wdata->cfile = find_writable_file(CIFS_I(mapping->host),
1755 false);
1756 if (!wdata->cfile) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001757 cERROR(1, "No writable handles for inode");
Steve French23e7dd72005-10-20 13:44:56 -07001758 rc = -EBADF;
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001759 break;
Steve French37c0eb42005-10-05 14:50:29 -07001760 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001761 rc = cifs_async_writev(wdata);
1762 } while (wbc->sync_mode == WB_SYNC_ALL && rc == -EAGAIN);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001763
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001764 for (i = 0; i < nr_pages; ++i)
1765 unlock_page(wdata->pages[i]);
Jeff Layton941b8532011-01-11 07:24:01 -05001766
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001767 /* send failure -- clean up the mess */
1768 if (rc != 0) {
1769 for (i = 0; i < nr_pages; ++i) {
Jeff Layton941b8532011-01-11 07:24:01 -05001770 if (rc == -EAGAIN)
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001771 redirty_page_for_writepage(wbc,
1772 wdata->pages[i]);
1773 else
1774 SetPageError(wdata->pages[i]);
1775 end_page_writeback(wdata->pages[i]);
1776 page_cache_release(wdata->pages[i]);
Steve French37c0eb42005-10-05 14:50:29 -07001777 }
Jeff Layton941b8532011-01-11 07:24:01 -05001778 if (rc != -EAGAIN)
1779 mapping_set_error(mapping, rc);
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001780 }
1781 kref_put(&wdata->refcount, cifs_writedata_release);
Jeff Layton941b8532011-01-11 07:24:01 -05001782
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001783 wbc->nr_to_write -= nr_pages;
1784 if (wbc->nr_to_write <= 0)
1785 done = true;
Dave Kleikampb066a482008-11-18 03:49:05 +00001786
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001787 index = next;
Steve French37c0eb42005-10-05 14:50:29 -07001788 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001789
Steve French37c0eb42005-10-05 14:50:29 -07001790 if (!scanned && !done) {
1791 /*
1792 * We hit the last page and there is more work to be done: wrap
1793 * back to the start of the file
1794 */
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001795 scanned = true;
Steve French37c0eb42005-10-05 14:50:29 -07001796 index = 0;
1797 goto retry;
1798 }
Jeff Laytonc3d17b62011-05-19 16:22:57 -04001799
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001800 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001801 mapping->writeback_index = index;
1802
Linus Torvalds1da177e2005-04-16 15:20:36 -07001803 return rc;
1804}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04001806static int
1807cifs_writepage_locked(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808{
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04001809 int rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810 int xid;
1811
1812 xid = GetXid();
1813/* BB add check for wbc flags */
1814 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001815 if (!PageUptodate(page))
Joe Perchesb6b38f72010-04-21 03:50:45 +00001816 cFYI(1, "ppw - page not up to date");
Linus Torvaldscb876f42006-12-23 16:19:07 -08001817
1818 /*
1819 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1820 *
1821 * A writepage() implementation always needs to do either this,
1822 * or re-dirty the page with "redirty_page_for_writepage()" in
1823 * the case of a failure.
1824 *
1825 * Just unlocking the page will cause the radix tree tag-bits
1826 * to fail to update with the state of the page correctly.
1827 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001828 set_page_writeback(page);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04001829retry_write:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001830 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04001831 if (rc == -EAGAIN && wbc->sync_mode == WB_SYNC_ALL)
1832 goto retry_write;
1833 else if (rc == -EAGAIN)
1834 redirty_page_for_writepage(wbc, page);
1835 else if (rc != 0)
1836 SetPageError(page);
1837 else
1838 SetPageUptodate(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001839 end_page_writeback(page);
1840 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841 FreeXid(xid);
1842 return rc;
1843}
1844
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04001845static int cifs_writepage(struct page *page, struct writeback_control *wbc)
1846{
1847 int rc = cifs_writepage_locked(page, wbc);
1848 unlock_page(page);
1849 return rc;
1850}
1851
Nick Piggind9414772008-09-24 11:32:59 -04001852static int cifs_write_end(struct file *file, struct address_space *mapping,
1853 loff_t pos, unsigned len, unsigned copied,
1854 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001855{
Nick Piggind9414772008-09-24 11:32:59 -04001856 int rc;
1857 struct inode *inode = mapping->host;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001858 struct cifsFileInfo *cfile = file->private_data;
1859 struct cifs_sb_info *cifs_sb = CIFS_SB(cfile->dentry->d_sb);
1860 __u32 pid;
1861
1862 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
1863 pid = cfile->pid;
1864 else
1865 pid = current->tgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866
Joe Perchesb6b38f72010-04-21 03:50:45 +00001867 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1868 page, pos, copied);
Steve Frenchad7a2922008-02-07 23:25:02 +00001869
Jeff Laytona98ee8c2008-11-26 19:32:33 +00001870 if (PageChecked(page)) {
1871 if (copied == len)
1872 SetPageUptodate(page);
1873 ClearPageChecked(page);
1874 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04001875 SetPageUptodate(page);
1876
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04001878 char *page_data;
1879 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1880 int xid;
1881
1882 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883 /* this is probably better than directly calling
1884 partialpage_write since in this function the file handle is
1885 known which we might as well leverage */
1886 /* BB check if anything else missing out of ppw
1887 such as updating last write time */
1888 page_data = kmap(page);
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00001889 rc = cifs_write(cfile, pid, page_data + offset, copied, &pos);
Nick Piggind9414772008-09-24 11:32:59 -04001890 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001892
1893 FreeXid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001894 } else {
Nick Piggind9414772008-09-24 11:32:59 -04001895 rc = copied;
1896 pos += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001897 set_page_dirty(page);
1898 }
1899
Nick Piggind9414772008-09-24 11:32:59 -04001900 if (rc > 0) {
1901 spin_lock(&inode->i_lock);
1902 if (pos > inode->i_size)
1903 i_size_write(inode, pos);
1904 spin_unlock(&inode->i_lock);
1905 }
1906
1907 unlock_page(page);
1908 page_cache_release(page);
1909
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 return rc;
1911}
1912
Josef Bacik02c24a82011-07-16 20:44:56 -04001913int cifs_strict_fsync(struct file *file, loff_t start, loff_t end,
1914 int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001915{
1916 int xid;
1917 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00001918 struct cifs_tcon *tcon;
Joe Perchesc21dfb62010-07-12 13:50:14 -07001919 struct cifsFileInfo *smbfile = file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001920 struct inode *inode = file->f_path.dentry->d_inode;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001921 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922
Josef Bacik02c24a82011-07-16 20:44:56 -04001923 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1924 if (rc)
1925 return rc;
1926 mutex_lock(&inode->i_mutex);
1927
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 xid = GetXid();
1929
Joe Perchesb6b38f72010-04-21 03:50:45 +00001930 cFYI(1, "Sync file - name: %s datasync: 0x%x",
Christoph Hellwig7ea80852010-05-26 17:53:25 +02001931 file->f_path.dentry->d_name.name, datasync);
Steve French50c2f752007-07-13 00:33:32 +00001932
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04001933 if (!CIFS_I(inode)->clientCanCacheRead) {
1934 rc = cifs_invalidate_mapping(inode);
1935 if (rc) {
1936 cFYI(1, "rc: %d during invalidate phase", rc);
1937 rc = 0; /* don't care about it in fsync */
1938 }
1939 }
Jeff Laytoneb4b7562010-10-22 14:52:29 -04001940
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001941 tcon = tlink_tcon(smbfile->tlink);
1942 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1943 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
1944
1945 FreeXid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04001946 mutex_unlock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001947 return rc;
1948}
1949
Josef Bacik02c24a82011-07-16 20:44:56 -04001950int cifs_fsync(struct file *file, loff_t start, loff_t end, int datasync)
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001951{
1952 int xid;
1953 int rc = 0;
Steve French96daf2b2011-05-27 04:34:02 +00001954 struct cifs_tcon *tcon;
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001955 struct cifsFileInfo *smbfile = file->private_data;
1956 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Josef Bacik02c24a82011-07-16 20:44:56 -04001957 struct inode *inode = file->f_mapping->host;
1958
1959 rc = filemap_write_and_wait_range(inode->i_mapping, start, end);
1960 if (rc)
1961 return rc;
1962 mutex_lock(&inode->i_mutex);
Pavel Shilovsky8be7e6b2010-12-12 13:11:13 +03001963
1964 xid = GetXid();
1965
1966 cFYI(1, "Sync file - name: %s datasync: 0x%x",
1967 file->f_path.dentry->d_name.name, datasync);
1968
1969 tcon = tlink_tcon(smbfile->tlink);
1970 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
1971 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
Steve Frenchb298f222009-02-21 21:17:43 +00001972
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 FreeXid(xid);
Josef Bacik02c24a82011-07-16 20:44:56 -04001974 mutex_unlock(&inode->i_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001975 return rc;
1976}
1977
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978/*
1979 * As file closes, flush all cached write data for this inode checking
1980 * for write behind errors.
1981 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001982int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001983{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001984 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001985 int rc = 0;
1986
Jeff Laytoneb4b7562010-10-22 14:52:29 -04001987 if (file->f_mode & FMODE_WRITE)
Jeff Laytond3f13222010-10-15 15:34:07 -04001988 rc = filemap_write_and_wait(inode->i_mapping);
Steve French50c2f752007-07-13 00:33:32 +00001989
Joe Perchesb6b38f72010-04-21 03:50:45 +00001990 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991
1992 return rc;
1993}
1994
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05001995static int
1996cifs_write_allocate_pages(struct page **pages, unsigned long num_pages)
1997{
1998 int rc = 0;
1999 unsigned long i;
2000
2001 for (i = 0; i < num_pages; i++) {
2002 pages[i] = alloc_page(__GFP_HIGHMEM);
2003 if (!pages[i]) {
2004 /*
2005 * save number of pages we have already allocated and
2006 * return with ENOMEM error
2007 */
2008 num_pages = i;
2009 rc = -ENOMEM;
2010 goto error;
2011 }
2012 }
2013
2014 return rc;
2015
2016error:
2017 for (i = 0; i < num_pages; i++)
2018 put_page(pages[i]);
2019 return rc;
2020}
2021
2022static inline
2023size_t get_numpages(const size_t wsize, const size_t len, size_t *cur_len)
2024{
2025 size_t num_pages;
2026 size_t clen;
2027
2028 clen = min_t(const size_t, len, wsize);
2029 num_pages = clen / PAGE_CACHE_SIZE;
2030 if (clen % PAGE_CACHE_SIZE)
2031 num_pages++;
2032
2033 if (cur_len)
2034 *cur_len = clen;
2035
2036 return num_pages;
2037}
2038
2039static ssize_t
2040cifs_iovec_write(struct file *file, const struct iovec *iov,
2041 unsigned long nr_segs, loff_t *poffset)
2042{
Pavel Shilovsky76429c12011-01-31 16:03:08 +03002043 unsigned int written;
2044 unsigned long num_pages, npages, i;
2045 size_t copied, len, cur_len;
2046 ssize_t total_written = 0;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002047 struct kvec *to_send;
2048 struct page **pages;
2049 struct iov_iter it;
2050 struct inode *inode;
2051 struct cifsFileInfo *open_file;
Steve French96daf2b2011-05-27 04:34:02 +00002052 struct cifs_tcon *pTcon;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002053 struct cifs_sb_info *cifs_sb;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002054 struct cifs_io_parms io_parms;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002055 int xid, rc;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002056 __u32 pid;
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002057
2058 len = iov_length(iov, nr_segs);
2059 if (!len)
2060 return 0;
2061
2062 rc = generic_write_checks(file, poffset, &len, 0);
2063 if (rc)
2064 return rc;
2065
2066 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2067 num_pages = get_numpages(cifs_sb->wsize, len, &cur_len);
2068
2069 pages = kmalloc(sizeof(struct pages *)*num_pages, GFP_KERNEL);
2070 if (!pages)
2071 return -ENOMEM;
2072
2073 to_send = kmalloc(sizeof(struct kvec)*(num_pages + 1), GFP_KERNEL);
2074 if (!to_send) {
2075 kfree(pages);
2076 return -ENOMEM;
2077 }
2078
2079 rc = cifs_write_allocate_pages(pages, num_pages);
2080 if (rc) {
2081 kfree(pages);
2082 kfree(to_send);
2083 return rc;
2084 }
2085
2086 xid = GetXid();
2087 open_file = file->private_data;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002088
2089 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2090 pid = open_file->pid;
2091 else
2092 pid = current->tgid;
2093
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002094 pTcon = tlink_tcon(open_file->tlink);
2095 inode = file->f_path.dentry->d_inode;
2096
2097 iov_iter_init(&it, iov, nr_segs, len, 0);
2098 npages = num_pages;
2099
2100 do {
2101 size_t save_len = cur_len;
2102 for (i = 0; i < npages; i++) {
2103 copied = min_t(const size_t, cur_len, PAGE_CACHE_SIZE);
2104 copied = iov_iter_copy_from_user(pages[i], &it, 0,
2105 copied);
2106 cur_len -= copied;
2107 iov_iter_advance(&it, copied);
2108 to_send[i+1].iov_base = kmap(pages[i]);
2109 to_send[i+1].iov_len = copied;
2110 }
2111
2112 cur_len = save_len - cur_len;
2113
2114 do {
2115 if (open_file->invalidHandle) {
2116 rc = cifs_reopen_file(open_file, false);
2117 if (rc != 0)
2118 break;
2119 }
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002120 io_parms.netfid = open_file->netfid;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002121 io_parms.pid = pid;
Pavel Shilovskyfa2989f2011-05-26 10:01:59 +04002122 io_parms.tcon = pTcon;
2123 io_parms.offset = *poffset;
2124 io_parms.length = cur_len;
2125 rc = CIFSSMBWrite2(xid, &io_parms, &written, to_send,
2126 npages, 0);
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002127 } while (rc == -EAGAIN);
2128
2129 for (i = 0; i < npages; i++)
2130 kunmap(pages[i]);
2131
2132 if (written) {
2133 len -= written;
2134 total_written += written;
2135 cifs_update_eof(CIFS_I(inode), *poffset, written);
2136 *poffset += written;
2137 } else if (rc < 0) {
2138 if (!total_written)
2139 total_written = rc;
2140 break;
2141 }
2142
2143 /* get length and number of kvecs of the next write */
2144 npages = get_numpages(cifs_sb->wsize, len, &cur_len);
2145 } while (len > 0);
2146
2147 if (total_written > 0) {
2148 spin_lock(&inode->i_lock);
2149 if (*poffset > inode->i_size)
2150 i_size_write(inode, *poffset);
2151 spin_unlock(&inode->i_lock);
2152 }
2153
2154 cifs_stats_bytes_written(pTcon, total_written);
2155 mark_inode_dirty_sync(inode);
2156
2157 for (i = 0; i < num_pages; i++)
2158 put_page(pages[i]);
2159 kfree(to_send);
2160 kfree(pages);
2161 FreeXid(xid);
2162 return total_written;
2163}
2164
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +03002165ssize_t cifs_user_writev(struct kiocb *iocb, const struct iovec *iov,
Pavel Shilovsky72432ff2011-01-24 14:16:35 -05002166 unsigned long nr_segs, loff_t pos)
2167{
2168 ssize_t written;
2169 struct inode *inode;
2170
2171 inode = iocb->ki_filp->f_path.dentry->d_inode;
2172
2173 /*
2174 * BB - optimize the way when signing is disabled. We can drop this
2175 * extra memory-to-memory copying and use iovec buffers for constructing
2176 * write request.
2177 */
2178
2179 written = cifs_iovec_write(iocb->ki_filp, iov, nr_segs, &pos);
2180 if (written > 0) {
2181 CIFS_I(inode)->invalid_mapping = true;
2182 iocb->ki_pos = pos;
2183 }
2184
2185 return written;
2186}
2187
2188ssize_t cifs_strict_writev(struct kiocb *iocb, const struct iovec *iov,
2189 unsigned long nr_segs, loff_t pos)
2190{
2191 struct inode *inode;
2192
2193 inode = iocb->ki_filp->f_path.dentry->d_inode;
2194
2195 if (CIFS_I(inode)->clientCanCacheAll)
2196 return generic_file_aio_write(iocb, iov, nr_segs, pos);
2197
2198 /*
2199 * In strict cache mode we need to write the data to the server exactly
2200 * from the pos to pos+len-1 rather than flush all affected pages
2201 * because it may cause a error with mandatory locks on these pages but
2202 * not on the region from pos to ppos+len-1.
2203 */
2204
2205 return cifs_user_writev(iocb, iov, nr_segs, pos);
2206}
2207
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002208static ssize_t
2209cifs_iovec_read(struct file *file, const struct iovec *iov,
2210 unsigned long nr_segs, loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211{
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002212 int rc;
2213 int xid;
Pavel Shilovsky76429c12011-01-31 16:03:08 +03002214 ssize_t total_read;
2215 unsigned int bytes_read = 0;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002216 size_t len, cur_len;
2217 int iov_offset = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002218 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +00002219 struct cifs_tcon *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002221 struct smb_com_read_rsp *pSMBr;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002222 struct cifs_io_parms io_parms;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002223 char *read_data;
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002224 unsigned int rsize;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002225 __u32 pid;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002226
2227 if (!nr_segs)
2228 return 0;
2229
2230 len = iov_length(iov, nr_segs);
2231 if (!len)
2232 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233
2234 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002235 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002236
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002237 /* FIXME: set up handlers for larger reads and/or convert to async */
2238 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2239
Joe Perchesc21dfb62010-07-12 13:50:14 -07002240 open_file = file->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -04002241 pTcon = tlink_tcon(open_file->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002242
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002243 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2244 pid = open_file->pid;
2245 else
2246 pid = current->tgid;
2247
Steve Frenchad7a2922008-02-07 23:25:02 +00002248 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002249 cFYI(1, "attempting read on write only file instance");
Steve Frenchad7a2922008-02-07 23:25:02 +00002250
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002251 for (total_read = 0; total_read < len; total_read += bytes_read) {
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002252 cur_len = min_t(const size_t, len - total_read, rsize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 rc = -EAGAIN;
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002254 read_data = NULL;
2255
Linus Torvalds1da177e2005-04-16 15:20:36 -07002256 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08002257 int buf_type = CIFS_NO_BUFFER;
Steve Frenchcdff08e2010-10-21 22:46:14 +00002258 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04002259 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 if (rc != 0)
2261 break;
2262 }
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002263 io_parms.netfid = open_file->netfid;
2264 io_parms.pid = pid;
2265 io_parms.tcon = pTcon;
2266 io_parms.offset = *poffset;
Pavel Shilovsky2cebaa52011-07-20 18:24:09 +04002267 io_parms.length = cur_len;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002268 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002269 &read_data, &buf_type);
2270 pSMBr = (struct smb_com_read_rsp *)read_data;
2271 if (read_data) {
2272 char *data_offset = read_data + 4 +
2273 le16_to_cpu(pSMBr->DataOffset);
2274 if (memcpy_toiovecend(iov, data_offset,
2275 iov_offset, bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06002276 rc = -EFAULT;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002277 if (buf_type == CIFS_SMALL_BUFFER)
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002278 cifs_small_buf_release(read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002279 else if (buf_type == CIFS_LARGE_BUFFER)
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002280 cifs_buf_release(read_data);
2281 read_data = NULL;
2282 iov_offset += bytes_read;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283 }
2284 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002285
Linus Torvalds1da177e2005-04-16 15:20:36 -07002286 if (rc || (bytes_read == 0)) {
2287 if (total_read) {
2288 break;
2289 } else {
2290 FreeXid(xid);
2291 return rc;
2292 }
2293 } else {
Steve Frencha4544342005-08-24 13:59:35 -07002294 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002295 *poffset += bytes_read;
2296 }
2297 }
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002298
Linus Torvalds1da177e2005-04-16 15:20:36 -07002299 FreeXid(xid);
2300 return total_read;
2301}
2302
Pavel Shilovsky0b81c1c2011-03-10 10:11:05 +03002303ssize_t cifs_user_readv(struct kiocb *iocb, const struct iovec *iov,
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002304 unsigned long nr_segs, loff_t pos)
2305{
2306 ssize_t read;
2307
2308 read = cifs_iovec_read(iocb->ki_filp, iov, nr_segs, &pos);
2309 if (read > 0)
2310 iocb->ki_pos = pos;
2311
2312 return read;
2313}
2314
2315ssize_t cifs_strict_readv(struct kiocb *iocb, const struct iovec *iov,
2316 unsigned long nr_segs, loff_t pos)
2317{
2318 struct inode *inode;
2319
2320 inode = iocb->ki_filp->f_path.dentry->d_inode;
2321
2322 if (CIFS_I(inode)->clientCanCacheRead)
2323 return generic_file_aio_read(iocb, iov, nr_segs, pos);
2324
2325 /*
2326 * In strict cache mode we need to read from the server all the time
2327 * if we don't have level II oplock because the server can delay mtime
2328 * change - so we can't make a decision about inode invalidating.
2329 * And we can also fail with pagereading if there are mandatory locks
2330 * on pages affected by this read but not on the region from pos to
2331 * pos+len-1.
2332 */
2333
2334 return cifs_user_readv(iocb, iov, nr_segs, pos);
2335}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002336
2337static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
Pavel Shilovskya70307e2010-12-14 11:50:41 +03002338 loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002339{
2340 int rc = -EACCES;
2341 unsigned int bytes_read = 0;
2342 unsigned int total_read;
2343 unsigned int current_read_size;
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002344 unsigned int rsize;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002345 struct cifs_sb_info *cifs_sb;
Steve French96daf2b2011-05-27 04:34:02 +00002346 struct cifs_tcon *pTcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002347 int xid;
2348 char *current_offset;
2349 struct cifsFileInfo *open_file;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002350 struct cifs_io_parms io_parms;
Steve Frenchec637e32005-12-12 20:53:18 -08002351 int buf_type = CIFS_NO_BUFFER;
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002352 __u32 pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002353
2354 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002355 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002356
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002357 /* FIXME: set up handlers for larger reads and/or convert to async */
2358 rsize = min_t(unsigned int, cifs_sb->rsize, CIFSMaxBufSize);
2359
Linus Torvalds1da177e2005-04-16 15:20:36 -07002360 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302361 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302363 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002364 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07002365 open_file = file->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -04002366 pTcon = tlink_tcon(open_file->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002367
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002368 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2369 pid = open_file->pid;
2370 else
2371 pid = current->tgid;
2372
Linus Torvalds1da177e2005-04-16 15:20:36 -07002373 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00002374 cFYI(1, "attempting read on write only file instance");
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002376 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002377 read_size > total_read;
2378 total_read += bytes_read, current_offset += bytes_read) {
Jeff Layton5eba8ab2011-10-19 15:30:26 -04002379 current_read_size = min_t(uint, read_size - total_read, rsize);
2380
Steve Frenchf9f5c812005-09-15 23:06:38 -07002381 /* For windows me and 9x we do not want to request more
2382 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002383 if ((pTcon->ses) &&
Steve Frenchf9f5c812005-09-15 23:06:38 -07002384 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
Dan Carpenter7748dd62011-10-18 12:41:35 +03002385 current_read_size = min_t(uint, current_read_size,
Jeff Laytonc974bef2011-10-11 06:41:32 -04002386 CIFSMaxBufSize);
Steve Frenchf9f5c812005-09-15 23:06:38 -07002387 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002388 rc = -EAGAIN;
2389 while (rc == -EAGAIN) {
Steve Frenchcdff08e2010-10-21 22:46:14 +00002390 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04002391 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002392 if (rc != 0)
2393 break;
2394 }
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002395 io_parms.netfid = open_file->netfid;
2396 io_parms.pid = pid;
2397 io_parms.tcon = pTcon;
2398 io_parms.offset = *poffset;
2399 io_parms.length = current_read_size;
2400 rc = CIFSSMBRead(xid, &io_parms, &bytes_read,
2401 &current_offset, &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002402 }
2403 if (rc || (bytes_read == 0)) {
2404 if (total_read) {
2405 break;
2406 } else {
2407 FreeXid(xid);
2408 return rc;
2409 }
2410 } else {
Steve Frencha4544342005-08-24 13:59:35 -07002411 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002412 *poffset += bytes_read;
2413 }
2414 }
2415 FreeXid(xid);
2416 return total_read;
2417}
2418
Jeff Laytonca83ce32011-04-12 09:13:44 -04002419/*
2420 * If the page is mmap'ed into a process' page tables, then we need to make
2421 * sure that it doesn't change while being written back.
2422 */
2423static int
2424cifs_page_mkwrite(struct vm_area_struct *vma, struct vm_fault *vmf)
2425{
2426 struct page *page = vmf->page;
2427
2428 lock_page(page);
2429 return VM_FAULT_LOCKED;
2430}
2431
2432static struct vm_operations_struct cifs_file_vm_ops = {
2433 .fault = filemap_fault,
2434 .page_mkwrite = cifs_page_mkwrite,
2435};
2436
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03002437int cifs_file_strict_mmap(struct file *file, struct vm_area_struct *vma)
2438{
2439 int rc, xid;
2440 struct inode *inode = file->f_path.dentry->d_inode;
2441
2442 xid = GetXid();
2443
Pavel Shilovsky6feb9892011-04-07 18:18:11 +04002444 if (!CIFS_I(inode)->clientCanCacheRead) {
2445 rc = cifs_invalidate_mapping(inode);
2446 if (rc)
2447 return rc;
2448 }
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03002449
2450 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04002451 if (rc == 0)
2452 vma->vm_ops = &cifs_file_vm_ops;
Pavel Shilovsky7a6a19b2010-12-14 11:29:51 +03002453 FreeXid(xid);
2454 return rc;
2455}
2456
Linus Torvalds1da177e2005-04-16 15:20:36 -07002457int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
2458{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002459 int rc, xid;
2460
2461 xid = GetXid();
Jeff Laytonabab0952010-02-12 07:44:18 -05002462 rc = cifs_revalidate_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002463 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002464 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002465 FreeXid(xid);
2466 return rc;
2467 }
2468 rc = generic_file_mmap(file, vma);
Jeff Laytonca83ce32011-04-12 09:13:44 -04002469 if (rc == 0)
2470 vma->vm_ops = &cifs_file_vm_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002471 FreeXid(xid);
2472 return rc;
2473}
2474
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475static int cifs_readpages(struct file *file, struct address_space *mapping,
2476 struct list_head *page_list, unsigned num_pages)
2477{
Jeff Layton690c5e32011-10-19 15:30:16 -04002478 int rc;
2479 struct list_head tmplist;
2480 struct cifsFileInfo *open_file = file->private_data;
2481 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
2482 unsigned int rsize = cifs_sb->rsize;
2483 pid_t pid;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002484
Jeff Layton690c5e32011-10-19 15:30:16 -04002485 /*
2486 * Give up immediately if rsize is too small to read an entire page.
2487 * The VFS will fall back to readpage. We should never reach this
2488 * point however since we set ra_pages to 0 when the rsize is smaller
2489 * than a cache page.
2490 */
2491 if (unlikely(rsize < PAGE_CACHE_SIZE))
2492 return 0;
Steve Frenchbfa0d752005-08-31 21:50:37 -07002493
Suresh Jayaraman56698232010-07-05 18:13:25 +05302494 /*
2495 * Reads as many pages as possible from fscache. Returns -ENOBUFS
2496 * immediately if the cookie is negative
2497 */
2498 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
2499 &num_pages);
2500 if (rc == 0)
Jeff Layton690c5e32011-10-19 15:30:16 -04002501 return rc;
Suresh Jayaraman56698232010-07-05 18:13:25 +05302502
Pavel Shilovskyd4ffff12011-05-26 06:02:00 +00002503 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_RWPIDFORWARD)
2504 pid = open_file->pid;
2505 else
2506 pid = current->tgid;
2507
Jeff Layton690c5e32011-10-19 15:30:16 -04002508 rc = 0;
2509 INIT_LIST_HEAD(&tmplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002510
Jeff Layton690c5e32011-10-19 15:30:16 -04002511 cFYI(1, "%s: file=%p mapping=%p num_pages=%u", __func__, file,
2512 mapping, num_pages);
2513
2514 /*
2515 * Start with the page at end of list and move it to private
2516 * list. Do the same with any following pages until we hit
2517 * the rsize limit, hit an index discontinuity, or run out of
2518 * pages. Issue the async read and then start the loop again
2519 * until the list is empty.
2520 *
2521 * Note that list order is important. The page_list is in
2522 * the order of declining indexes. When we put the pages in
2523 * the rdata->pages, then we want them in increasing order.
2524 */
2525 while (!list_empty(page_list)) {
2526 unsigned int bytes = PAGE_CACHE_SIZE;
2527 unsigned int expected_index;
2528 unsigned int nr_pages = 1;
2529 loff_t offset;
2530 struct page *page, *tpage;
2531 struct cifs_readdata *rdata;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002532
2533 page = list_entry(page_list->prev, struct page, lru);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002534
Jeff Layton690c5e32011-10-19 15:30:16 -04002535 /*
2536 * Lock the page and put it in the cache. Since no one else
2537 * should have access to this page, we're safe to simply set
2538 * PG_locked without checking it first.
2539 */
2540 __set_page_locked(page);
2541 rc = add_to_page_cache_locked(page, mapping,
2542 page->index, GFP_KERNEL);
2543
2544 /* give up if we can't stick it in the cache */
2545 if (rc) {
2546 __clear_page_locked(page);
2547 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002548 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002549
Jeff Layton690c5e32011-10-19 15:30:16 -04002550 /* move first page to the tmplist */
2551 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2552 list_move_tail(&page->lru, &tmplist);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002553
Jeff Layton690c5e32011-10-19 15:30:16 -04002554 /* now try and add more pages onto the request */
2555 expected_index = page->index + 1;
2556 list_for_each_entry_safe_reverse(page, tpage, page_list, lru) {
2557 /* discontinuity ? */
2558 if (page->index != expected_index)
2559 break;
2560
2561 /* would this page push the read over the rsize? */
2562 if (bytes + PAGE_CACHE_SIZE > rsize)
2563 break;
2564
2565 __set_page_locked(page);
2566 if (add_to_page_cache_locked(page, mapping,
2567 page->index, GFP_KERNEL)) {
2568 __clear_page_locked(page);
2569 break;
2570 }
2571 list_move_tail(&page->lru, &tmplist);
2572 bytes += PAGE_CACHE_SIZE;
2573 expected_index++;
2574 nr_pages++;
2575 }
2576
2577 rdata = cifs_readdata_alloc(nr_pages);
2578 if (!rdata) {
2579 /* best to give up if we're out of mem */
2580 list_for_each_entry_safe(page, tpage, &tmplist, lru) {
2581 list_del(&page->lru);
2582 lru_cache_add_file(page);
2583 unlock_page(page);
2584 page_cache_release(page);
2585 }
2586 rc = -ENOMEM;
2587 break;
2588 }
2589
2590 spin_lock(&cifs_file_list_lock);
2591 cifsFileInfo_get(open_file);
2592 spin_unlock(&cifs_file_list_lock);
2593 rdata->cfile = open_file;
2594 rdata->mapping = mapping;
2595 rdata->offset = offset;
2596 rdata->bytes = bytes;
2597 rdata->pid = pid;
2598 list_splice_init(&tmplist, &rdata->pages);
2599
2600 do {
Steve Frenchcdff08e2010-10-21 22:46:14 +00002601 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04002602 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002603 if (rc != 0)
Jeff Layton690c5e32011-10-19 15:30:16 -04002604 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002605 }
Jeff Layton690c5e32011-10-19 15:30:16 -04002606 rc = cifs_async_readv(rdata);
2607 } while (rc == -EAGAIN);
2608
2609 if (rc != 0) {
2610 list_for_each_entry_safe(page, tpage, &rdata->pages,
2611 lru) {
2612 list_del(&page->lru);
2613 lru_cache_add_file(page);
2614 unlock_page(page);
2615 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002616 }
Jeff Layton690c5e32011-10-19 15:30:16 -04002617 cifs_readdata_free(rdata);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002618 break;
2619 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002620 }
2621
Linus Torvalds1da177e2005-04-16 15:20:36 -07002622 return rc;
2623}
2624
2625static int cifs_readpage_worker(struct file *file, struct page *page,
2626 loff_t *poffset)
2627{
2628 char *read_data;
2629 int rc;
2630
Suresh Jayaraman56698232010-07-05 18:13:25 +05302631 /* Is the page cached? */
2632 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2633 if (rc == 0)
2634 goto read_complete;
2635
Linus Torvalds1da177e2005-04-16 15:20:36 -07002636 page_cache_get(page);
2637 read_data = kmap(page);
2638 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002639
Linus Torvalds1da177e2005-04-16 15:20:36 -07002640 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002641
Linus Torvalds1da177e2005-04-16 15:20:36 -07002642 if (rc < 0)
2643 goto io_error;
2644 else
Joe Perchesb6b38f72010-04-21 03:50:45 +00002645 cFYI(1, "Bytes read %d", rc);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002646
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002647 file->f_path.dentry->d_inode->i_atime =
2648 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002649
Linus Torvalds1da177e2005-04-16 15:20:36 -07002650 if (PAGE_CACHE_SIZE > rc)
2651 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2652
2653 flush_dcache_page(page);
2654 SetPageUptodate(page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05302655
2656 /* send this page to the cache */
2657 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2658
Linus Torvalds1da177e2005-04-16 15:20:36 -07002659 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002660
Linus Torvalds1da177e2005-04-16 15:20:36 -07002661io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002662 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002663 page_cache_release(page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05302664
2665read_complete:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002666 return rc;
2667}
2668
2669static int cifs_readpage(struct file *file, struct page *page)
2670{
2671 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2672 int rc = -EACCES;
2673 int xid;
2674
2675 xid = GetXid();
2676
2677 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302678 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002679 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302680 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002681 }
2682
Joe Perchesb6b38f72010-04-21 03:50:45 +00002683 cFYI(1, "readpage %p at offset %d 0x%x\n",
2684 page, (int)offset, (int)offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002685
2686 rc = cifs_readpage_worker(file, page, &offset);
2687
2688 unlock_page(page);
2689
2690 FreeXid(xid);
2691 return rc;
2692}
2693
Steve Frencha403a0a2007-07-26 15:54:16 +00002694static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2695{
2696 struct cifsFileInfo *open_file;
2697
Jeff Layton44772882010-10-15 15:34:03 -04002698 spin_lock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00002699 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2e396b82010-10-15 15:34:01 -04002700 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Jeff Layton44772882010-10-15 15:34:03 -04002701 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00002702 return 1;
2703 }
2704 }
Jeff Layton44772882010-10-15 15:34:03 -04002705 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00002706 return 0;
2707}
2708
Linus Torvalds1da177e2005-04-16 15:20:36 -07002709/* We do not want to update the file size from server for inodes
2710 open for write - to avoid races with writepage extending
2711 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002712 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002713 but this is tricky to do without racing with writebehind
2714 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00002715bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002716{
Steve Frencha403a0a2007-07-26 15:54:16 +00002717 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00002718 return true;
Steve French23e7dd72005-10-20 13:44:56 -07002719
Steve Frencha403a0a2007-07-26 15:54:16 +00002720 if (is_inode_writable(cifsInode)) {
2721 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002722 struct cifs_sb_info *cifs_sb;
2723
Steve Frenchc32a0b62006-01-12 14:41:28 -08002724 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002725 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002726 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002727 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00002728 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08002729 }
2730
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002731 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00002732 return true;
Steve French7ba52632007-02-08 18:14:13 +00002733
Steve French4b18f2a2008-04-29 00:06:05 +00002734 return false;
Steve French23e7dd72005-10-20 13:44:56 -07002735 } else
Steve French4b18f2a2008-04-29 00:06:05 +00002736 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002737}
2738
Nick Piggind9414772008-09-24 11:32:59 -04002739static int cifs_write_begin(struct file *file, struct address_space *mapping,
2740 loff_t pos, unsigned len, unsigned flags,
2741 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002742{
Nick Piggind9414772008-09-24 11:32:59 -04002743 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2744 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002745 loff_t page_start = pos & PAGE_MASK;
2746 loff_t i_size;
2747 struct page *page;
2748 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002749
Joe Perchesb6b38f72010-04-21 03:50:45 +00002750 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
Nick Piggind9414772008-09-24 11:32:59 -04002751
Nick Piggin54566b22009-01-04 12:00:53 -08002752 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002753 if (!page) {
2754 rc = -ENOMEM;
2755 goto out;
2756 }
Nick Piggind9414772008-09-24 11:32:59 -04002757
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002758 if (PageUptodate(page))
2759 goto out;
Steve French8a236262007-03-06 00:31:00 +00002760
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002761 /*
2762 * If we write a full page it will be up to date, no need to read from
2763 * the server. If the write is short, we'll end up doing a sync write
2764 * instead.
2765 */
2766 if (len == PAGE_CACHE_SIZE)
2767 goto out;
2768
2769 /*
2770 * optimize away the read when we have an oplock, and we're not
2771 * expecting to use any of the data we'd be reading in. That
2772 * is, when the page lies beyond the EOF, or straddles the EOF
2773 * and the write will cover all of the existing data.
2774 */
2775 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2776 i_size = i_size_read(mapping->host);
2777 if (page_start >= i_size ||
2778 (offset == 0 && (pos + len) >= i_size)) {
2779 zero_user_segments(page, 0, offset,
2780 offset + len,
2781 PAGE_CACHE_SIZE);
2782 /*
2783 * PageChecked means that the parts of the page
2784 * to which we're not writing are considered up
2785 * to date. Once the data is copied to the
2786 * page, it can be set uptodate.
2787 */
2788 SetPageChecked(page);
2789 goto out;
2790 }
2791 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002792
Nick Piggind9414772008-09-24 11:32:59 -04002793 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002794 /*
2795 * might as well read a page, it is fast enough. If we get
2796 * an error, we don't need to return it. cifs_write_end will
2797 * do a sync write instead since PG_uptodate isn't set.
2798 */
2799 cifs_readpage_worker(file, page, &page_start);
Steve French8a236262007-03-06 00:31:00 +00002800 } else {
2801 /* we could try using another file handle if there is one -
2802 but how would we lock it to prevent close of that handle
2803 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04002804 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00002805 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002806out:
2807 *pagep = page;
2808 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002809}
2810
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05302811static int cifs_release_page(struct page *page, gfp_t gfp)
2812{
2813 if (PagePrivate(page))
2814 return 0;
2815
2816 return cifs_fscache_release_page(page, gfp);
2817}
2818
2819static void cifs_invalidate_page(struct page *page, unsigned long offset)
2820{
2821 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2822
2823 if (offset == 0)
2824 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2825}
2826
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002827static int cifs_launder_page(struct page *page)
2828{
2829 int rc = 0;
2830 loff_t range_start = page_offset(page);
2831 loff_t range_end = range_start + (loff_t)(PAGE_CACHE_SIZE - 1);
2832 struct writeback_control wbc = {
2833 .sync_mode = WB_SYNC_ALL,
2834 .nr_to_write = 0,
2835 .range_start = range_start,
2836 .range_end = range_end,
2837 };
2838
2839 cFYI(1, "Launder page: %p", page);
2840
2841 if (clear_page_dirty_for_io(page))
2842 rc = cifs_writepage_locked(page, &wbc);
2843
2844 cifs_fscache_invalidate_page(page, page->mapping->host);
2845 return rc;
2846}
2847
Tejun Heo9b646972010-07-20 22:09:02 +02002848void cifs_oplock_break(struct work_struct *work)
Jeff Layton3bc303c2009-09-21 06:47:50 -04002849{
2850 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2851 oplock_break);
Jeff Laytona5e18bc2010-10-11 15:07:18 -04002852 struct inode *inode = cfile->dentry->d_inode;
Jeff Layton3bc303c2009-09-21 06:47:50 -04002853 struct cifsInodeInfo *cinode = CIFS_I(inode);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002854 int rc = 0;
Jeff Layton3bc303c2009-09-21 06:47:50 -04002855
2856 if (inode && S_ISREG(inode->i_mode)) {
Steve Frenchd54ff732010-04-27 04:38:15 +00002857 if (cinode->clientCanCacheRead)
Al Viro8737c932009-12-24 06:47:55 -05002858 break_lease(inode, O_RDONLY);
Steve Frenchd54ff732010-04-27 04:38:15 +00002859 else
Al Viro8737c932009-12-24 06:47:55 -05002860 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002861 rc = filemap_fdatawrite(inode->i_mapping);
2862 if (cinode->clientCanCacheRead == 0) {
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002863 rc = filemap_fdatawait(inode->i_mapping);
2864 mapping_set_error(inode->i_mapping, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002865 invalidate_remote_inode(inode);
2866 }
Joe Perchesb6b38f72010-04-21 03:50:45 +00002867 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002868 }
2869
Pavel Shilovsky85160e02011-10-22 15:33:29 +04002870 rc = cifs_push_locks(cfile);
2871 if (rc)
2872 cERROR(1, "Push locks rc = %d", rc);
2873
Jeff Layton3bc303c2009-09-21 06:47:50 -04002874 /*
2875 * releasing stale oplock after recent reconnect of smb session using
2876 * a now incorrect file handle is not a data integrity issue but do
2877 * not bother sending an oplock release if session to server still is
2878 * disconnected since oplock already released by the server
2879 */
Steve Frenchcdff08e2010-10-21 22:46:14 +00002880 if (!cfile->oplock_break_cancelled) {
Pavel Shilovsky03776f42010-08-17 11:26:00 +04002881 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid,
2882 current->tgid, 0, 0, 0, 0,
2883 LOCKING_ANDX_OPLOCK_RELEASE, false,
Pavel Shilovsky12fed002011-01-17 20:15:44 +03002884 cinode->clientCanCacheRead ? 1 : 0);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002885 cFYI(1, "Oplock release rc = %d", rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002886 }
Jeff Layton3bc303c2009-09-21 06:47:50 -04002887}
2888
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002889const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002890 .readpage = cifs_readpage,
2891 .readpages = cifs_readpages,
2892 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002893 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002894 .write_begin = cifs_write_begin,
2895 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002896 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05302897 .releasepage = cifs_release_page,
2898 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002899 .launder_page = cifs_launder_page,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002900};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002901
2902/*
2903 * cifs_readpages requires the server to support a buffer large enough to
2904 * contain the header plus one complete page of data. Otherwise, we need
2905 * to leave cifs_readpages out of the address space operations.
2906 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002907const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002908 .readpage = cifs_readpage,
2909 .writepage = cifs_writepage,
2910 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002911 .write_begin = cifs_write_begin,
2912 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002913 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05302914 .releasepage = cifs_release_page,
2915 .invalidatepage = cifs_invalidate_page,
Pavel Shilovsky9ad15062011-04-08 05:29:10 +04002916 .launder_page = cifs_launder_page,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002917};