blob: 398a15a99a1b61e67995a6768eab9f2a21ce079d [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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070035#include <asm/div64.h>
36#include "cifsfs.h"
37#include "cifspdu.h"
38#include "cifsglob.h"
39#include "cifsproto.h"
40#include "cifs_unicode.h"
41#include "cifs_debug.h"
42#include "cifs_fs_sb.h"
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +053043#include "fscache.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070044
Linus Torvalds1da177e2005-04-16 15:20:36 -070045static inline int cifs_convert_flags(unsigned int flags)
46{
47 if ((flags & O_ACCMODE) == O_RDONLY)
48 return GENERIC_READ;
49 else if ((flags & O_ACCMODE) == O_WRONLY)
50 return GENERIC_WRITE;
51 else if ((flags & O_ACCMODE) == O_RDWR) {
52 /* GENERIC_ALL is too much permission to request
53 can cause unnecessary access denied on create */
54 /* return GENERIC_ALL; */
55 return (GENERIC_READ | GENERIC_WRITE);
56 }
57
Jeff Laytone10f7b52008-05-14 10:21:33 -070058 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
59 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
60 FILE_READ_DATA);
Steve French7fc8f4e2009-02-23 20:43:11 +000061}
Jeff Laytone10f7b52008-05-14 10:21:33 -070062
Jeff Layton608712f2010-10-15 15:33:56 -040063static u32 cifs_posix_convert_flags(unsigned int flags)
Steve French7fc8f4e2009-02-23 20:43:11 +000064{
Jeff Layton608712f2010-10-15 15:33:56 -040065 u32 posix_flags = 0;
Jeff Laytone10f7b52008-05-14 10:21:33 -070066
Steve French7fc8f4e2009-02-23 20:43:11 +000067 if ((flags & O_ACCMODE) == O_RDONLY)
Jeff Layton608712f2010-10-15 15:33:56 -040068 posix_flags = SMB_O_RDONLY;
Steve French7fc8f4e2009-02-23 20:43:11 +000069 else if ((flags & O_ACCMODE) == O_WRONLY)
Jeff Layton608712f2010-10-15 15:33:56 -040070 posix_flags = SMB_O_WRONLY;
71 else if ((flags & O_ACCMODE) == O_RDWR)
72 posix_flags = SMB_O_RDWR;
73
74 if (flags & O_CREAT)
75 posix_flags |= SMB_O_CREAT;
76 if (flags & O_EXCL)
77 posix_flags |= SMB_O_EXCL;
78 if (flags & O_TRUNC)
79 posix_flags |= SMB_O_TRUNC;
80 /* be safe and imply O_SYNC for O_DSYNC */
Christoph Hellwig6b2f3d12009-10-27 11:05:28 +010081 if (flags & O_DSYNC)
Jeff Layton608712f2010-10-15 15:33:56 -040082 posix_flags |= SMB_O_SYNC;
Steve French7fc8f4e2009-02-23 20:43:11 +000083 if (flags & O_DIRECTORY)
Jeff Layton608712f2010-10-15 15:33:56 -040084 posix_flags |= SMB_O_DIRECTORY;
Steve French7fc8f4e2009-02-23 20:43:11 +000085 if (flags & O_NOFOLLOW)
Jeff Layton608712f2010-10-15 15:33:56 -040086 posix_flags |= SMB_O_NOFOLLOW;
Steve French7fc8f4e2009-02-23 20:43:11 +000087 if (flags & O_DIRECT)
Jeff Layton608712f2010-10-15 15:33:56 -040088 posix_flags |= SMB_O_DIRECT;
Steve French7fc8f4e2009-02-23 20:43:11 +000089
90 return posix_flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091}
92
93static inline int cifs_get_disposition(unsigned int flags)
94{
95 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
96 return FILE_CREATE;
97 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
98 return FILE_OVERWRITE_IF;
99 else if ((flags & O_CREAT) == O_CREAT)
100 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +0000101 else if ((flags & O_TRUNC) == O_TRUNC)
102 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700103 else
104 return FILE_OPEN;
105}
106
Jeff Laytondb460242010-06-16 13:40:17 -0400107static inline int cifs_open_inode_helper(struct inode *inode,
Suresh Jayaramana347ecb2010-09-17 19:43:10 +0530108 struct cifsTconInfo *pTcon, __u32 oplock, FILE_ALL_INFO *buf,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700109 char *full_path, int xid)
110{
Jeff Laytondb460242010-06-16 13:40:17 -0400111 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700112 struct timespec temp;
113 int rc;
114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 if (pCifsInode->clientCanCacheRead) {
116 /* we have the inode open somewhere else
117 no need to discard cache data */
118 goto client_can_cache;
119 }
120
121 /* BB need same check in cifs_create too? */
122 /* if not oplocked, invalidate inode pages if mtime or file
123 size changed */
Jeff Layton07119a42009-05-27 09:37:33 -0400124 temp = cifs_NTtimeToUnix(buf->LastWriteTime);
Jeff Laytondb460242010-06-16 13:40:17 -0400125 if (timespec_equal(&inode->i_mtime, &temp) &&
126 (inode->i_size ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700127 (loff_t)le64_to_cpu(buf->EndOfFile))) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000128 cFYI(1, "inode unchanged on server");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 } else {
Jeff Laytondb460242010-06-16 13:40:17 -0400130 if (inode->i_mapping) {
Steve Frenchff2157132010-03-09 20:30:42 +0000131 /* BB no need to lock inode until after invalidate
132 since namei code should already have it locked? */
Jeff Laytondb460242010-06-16 13:40:17 -0400133 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -0400134 mapping_set_error(inode->i_mapping, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 }
Joe Perchesb6b38f72010-04-21 03:50:45 +0000136 cFYI(1, "invalidating remote inode since open detected it "
137 "changed");
Jeff Laytondb460242010-06-16 13:40:17 -0400138 invalidate_remote_inode(inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 }
140
141client_can_cache:
Steve Frenchc18c8422007-07-18 23:21:09 +0000142 if (pTcon->unix_ext)
Jeff Laytondb460242010-06-16 13:40:17 -0400143 rc = cifs_get_inode_info_unix(&inode, full_path, inode->i_sb,
144 xid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 else
Jeff Laytondb460242010-06-16 13:40:17 -0400146 rc = cifs_get_inode_info(&inode, full_path, buf, inode->i_sb,
147 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700148
Suresh Jayaramana347ecb2010-09-17 19:43:10 +0530149 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000150 pCifsInode->clientCanCacheAll = true;
151 pCifsInode->clientCanCacheRead = true;
Jeff Laytondb460242010-06-16 13:40:17 -0400152 cFYI(1, "Exclusive Oplock granted on inode %p", inode);
Suresh Jayaramana347ecb2010-09-17 19:43:10 +0530153 } else if ((oplock & 0xF) == OPLOCK_READ)
Steve French4b18f2a2008-04-29 00:06:05 +0000154 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700155
156 return rc;
157}
158
Jeff Layton608712f2010-10-15 15:33:56 -0400159int cifs_posix_open(char *full_path, struct inode **pinode,
160 struct super_block *sb, int mode, unsigned int f_flags,
161 __u32 *poplock, __u16 *pnetfid, int xid)
162{
163 int rc;
164 FILE_UNIX_BASIC_INFO *presp_data;
165 __u32 posix_flags = 0;
166 struct cifs_sb_info *cifs_sb = CIFS_SB(sb);
167 struct cifs_fattr fattr;
168 struct tcon_link *tlink;
169 struct cifsTconInfo *tcon;
170
171 cFYI(1, "posix open %s", full_path);
172
173 presp_data = kzalloc(sizeof(FILE_UNIX_BASIC_INFO), GFP_KERNEL);
174 if (presp_data == NULL)
175 return -ENOMEM;
176
177 tlink = cifs_sb_tlink(cifs_sb);
178 if (IS_ERR(tlink)) {
179 rc = PTR_ERR(tlink);
180 goto posix_open_ret;
181 }
182
183 tcon = tlink_tcon(tlink);
184 mode &= ~current_umask();
185
186 posix_flags = cifs_posix_convert_flags(f_flags);
187 rc = CIFSPOSIXCreate(xid, tcon, posix_flags, mode, pnetfid, presp_data,
188 poplock, full_path, cifs_sb->local_nls,
189 cifs_sb->mnt_cifs_flags &
190 CIFS_MOUNT_MAP_SPECIAL_CHR);
191 cifs_put_tlink(tlink);
192
193 if (rc)
194 goto posix_open_ret;
195
196 if (presp_data->Type == cpu_to_le32(-1))
197 goto posix_open_ret; /* open ok, caller does qpathinfo */
198
199 if (!pinode)
200 goto posix_open_ret; /* caller does not need info */
201
202 cifs_unix_basic_to_fattr(&fattr, presp_data, cifs_sb);
203
204 /* get new inode and set it up */
205 if (*pinode == NULL) {
206 cifs_fill_uniqueid(sb, &fattr);
207 *pinode = cifs_iget(sb, &fattr);
208 if (!*pinode) {
209 rc = -ENOMEM;
210 goto posix_open_ret;
211 }
212 } else {
213 cifs_fattr_to_inode(*pinode, &fattr);
214 }
215
216posix_open_ret:
217 kfree(presp_data);
218 return rc;
219}
220
Jeff Layton15ecb432010-10-15 15:34:02 -0400221struct cifsFileInfo *
222cifs_new_fileinfo(__u16 fileHandle, struct file *file,
223 struct tcon_link *tlink, __u32 oplock)
224{
225 struct dentry *dentry = file->f_path.dentry;
226 struct inode *inode = dentry->d_inode;
227 struct cifsInodeInfo *pCifsInode = CIFS_I(inode);
228 struct cifsFileInfo *pCifsFile;
229
230 pCifsFile = kzalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
231 if (pCifsFile == NULL)
232 return pCifsFile;
233
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400234 pCifsFile->count = 1;
Jeff Layton15ecb432010-10-15 15:34:02 -0400235 pCifsFile->netfid = fileHandle;
236 pCifsFile->pid = current->tgid;
237 pCifsFile->uid = current_fsuid();
238 pCifsFile->dentry = dget(dentry);
239 pCifsFile->f_flags = file->f_flags;
240 pCifsFile->invalidHandle = false;
Jeff Layton15ecb432010-10-15 15:34:02 -0400241 pCifsFile->tlink = cifs_get_tlink(tlink);
242 mutex_init(&pCifsFile->fh_mutex);
243 mutex_init(&pCifsFile->lock_mutex);
244 INIT_LIST_HEAD(&pCifsFile->llist);
Jeff Layton15ecb432010-10-15 15:34:02 -0400245 INIT_WORK(&pCifsFile->oplock_break, cifs_oplock_break);
246
Jeff Layton44772882010-10-15 15:34:03 -0400247 spin_lock(&cifs_file_list_lock);
Jeff Layton15ecb432010-10-15 15:34:02 -0400248 list_add(&pCifsFile->tlist, &(tlink_tcon(tlink)->openFileList));
249 /* if readable file instance put first in list*/
250 if (file->f_mode & FMODE_READ)
251 list_add(&pCifsFile->flist, &pCifsInode->openFileList);
252 else
253 list_add_tail(&pCifsFile->flist, &pCifsInode->openFileList);
Jeff Layton44772882010-10-15 15:34:03 -0400254 spin_unlock(&cifs_file_list_lock);
Jeff Layton15ecb432010-10-15 15:34:02 -0400255
256 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
257 pCifsInode->clientCanCacheAll = true;
258 pCifsInode->clientCanCacheRead = true;
259 cFYI(1, "Exclusive Oplock inode %p", inode);
260 } else if ((oplock & 0xF) == OPLOCK_READ)
261 pCifsInode->clientCanCacheRead = true;
262
263 file->private_data = pCifsFile;
264 return pCifsFile;
265}
266
Steve Frenchcdff08e2010-10-21 22:46:14 +0000267/*
268 * Release a reference on the file private data. This may involve closing
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400269 * the filehandle out on the server. Must be called without holding
270 * cifs_file_list_lock.
Steve Frenchcdff08e2010-10-21 22:46:14 +0000271 */
Jeff Laytonb33879a2010-10-15 15:34:04 -0400272void cifsFileInfo_put(struct cifsFileInfo *cifs_file)
273{
Steve Frenchcdff08e2010-10-21 22:46:14 +0000274 struct cifsTconInfo *tcon = tlink_tcon(cifs_file->tlink);
275 struct cifsInodeInfo *cifsi = CIFS_I(cifs_file->dentry->d_inode);
276 struct cifsLockInfo *li, *tmp;
277
278 spin_lock(&cifs_file_list_lock);
Jeff Layton5f6dbc92010-10-15 15:34:06 -0400279 if (--cifs_file->count > 0) {
Steve Frenchcdff08e2010-10-21 22:46:14 +0000280 spin_unlock(&cifs_file_list_lock);
281 return;
Jeff Laytonb33879a2010-10-15 15:34:04 -0400282 }
Steve Frenchcdff08e2010-10-21 22:46:14 +0000283
284 /* remove it from the lists */
285 list_del(&cifs_file->flist);
286 list_del(&cifs_file->tlist);
287
288 if (list_empty(&cifsi->openFileList)) {
289 cFYI(1, "closing last open instance for inode %p",
290 cifs_file->dentry->d_inode);
291 cifsi->clientCanCacheRead = false;
292 cifsi->clientCanCacheAll = false;
293 }
294 spin_unlock(&cifs_file_list_lock);
295
296 if (!tcon->need_reconnect && !cifs_file->invalidHandle) {
297 int xid, rc;
298
299 xid = GetXid();
300 rc = CIFSSMBClose(xid, tcon, cifs_file->netfid);
301 FreeXid(xid);
302 }
303
304 /* Delete any outstanding lock records. We'll lose them when the file
305 * is closed anyway.
306 */
307 mutex_lock(&cifs_file->lock_mutex);
308 list_for_each_entry_safe(li, tmp, &cifs_file->llist, llist) {
309 list_del(&li->llist);
310 kfree(li);
311 }
312 mutex_unlock(&cifs_file->lock_mutex);
313
314 cifs_put_tlink(cifs_file->tlink);
315 dput(cifs_file->dentry);
316 kfree(cifs_file);
Jeff Laytonb33879a2010-10-15 15:34:04 -0400317}
318
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319int cifs_open(struct inode *inode, struct file *file)
320{
321 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400322 int xid;
323 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324 struct cifs_sb_info *cifs_sb;
Steve French276a74a2009-03-03 18:00:34 +0000325 struct cifsTconInfo *tcon;
Jeff Layton7ffec372010-09-29 19:51:11 -0400326 struct tcon_link *tlink;
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400327 struct cifsFileInfo *pCifsFile = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700328 struct cifsInodeInfo *pCifsInode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700329 char *full_path = NULL;
330 int desiredAccess;
331 int disposition;
332 __u16 netfid;
333 FILE_ALL_INFO *buf = NULL;
334
335 xid = GetXid();
336
337 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton7ffec372010-09-29 19:51:11 -0400338 tlink = cifs_sb_tlink(cifs_sb);
339 if (IS_ERR(tlink)) {
340 FreeXid(xid);
341 return PTR_ERR(tlink);
342 }
343 tcon = tlink_tcon(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344
Steve Frencha6ce4932009-04-09 01:14:32 +0000345 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800347 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348 if (full_path == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530349 rc = -ENOMEM;
Jeff Layton232341b2010-08-05 13:58:38 -0400350 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351 }
352
Joe Perchesb6b38f72010-04-21 03:50:45 +0000353 cFYI(1, "inode = 0x%p file flags are 0x%x for %s",
354 inode, file->f_flags, full_path);
Steve French276a74a2009-03-03 18:00:34 +0000355
356 if (oplockEnabled)
357 oplock = REQ_OPLOCK;
358 else
359 oplock = 0;
360
Steve French64cc2c62009-03-04 19:54:08 +0000361 if (!tcon->broken_posix_open && tcon->unix_ext &&
362 (tcon->ses->capabilities & CAP_UNIX) &&
Steve French276a74a2009-03-03 18:00:34 +0000363 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
364 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Steve French276a74a2009-03-03 18:00:34 +0000365 /* can not refresh inode info since size could be stale */
Jeff Layton2422f672010-06-16 13:40:16 -0400366 rc = cifs_posix_open(full_path, &inode, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000367 cifs_sb->mnt_file_mode /* ignored */,
Jeff Layton608712f2010-10-15 15:33:56 -0400368 file->f_flags, &oplock, &netfid, xid);
Steve French276a74a2009-03-03 18:00:34 +0000369 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000370 cFYI(1, "posix open succeeded");
Jeff Layton47c78b72010-06-16 13:40:17 -0400371
Jeff Laytonabfe1ee2010-10-15 15:33:58 -0400372 pCifsFile = cifs_new_fileinfo(netfid, file, tlink,
373 oplock);
Jeff Layton2422f672010-06-16 13:40:16 -0400374 if (pCifsFile == NULL) {
375 CIFSSMBClose(xid, tcon, netfid);
376 rc = -ENOMEM;
Jeff Layton2422f672010-06-16 13:40:16 -0400377 }
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530378
379 cifs_fscache_set_inode_cookie(inode, file);
380
Steve French276a74a2009-03-03 18:00:34 +0000381 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000382 } else if ((rc == -EINVAL) || (rc == -EOPNOTSUPP)) {
383 if (tcon->ses->serverNOS)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000384 cERROR(1, "server %s of type %s returned"
Steve French64cc2c62009-03-04 19:54:08 +0000385 " unexpected error on SMB posix open"
386 ", disabling posix open support."
387 " Check if server update available.",
388 tcon->ses->serverName,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000389 tcon->ses->serverNOS);
Steve French64cc2c62009-03-04 19:54:08 +0000390 tcon->broken_posix_open = true;
Steve French276a74a2009-03-03 18:00:34 +0000391 } else if ((rc != -EIO) && (rc != -EREMOTE) &&
392 (rc != -EOPNOTSUPP)) /* path not found or net err */
393 goto out;
Steve French64cc2c62009-03-04 19:54:08 +0000394 /* else fallthrough to retry open the old way on network i/o
395 or DFS errors */
Steve French276a74a2009-03-03 18:00:34 +0000396 }
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 desiredAccess = cifs_convert_flags(file->f_flags);
399
400/*********************************************************************
401 * open flag mapping table:
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000402 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 * POSIX Flag CIFS Disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000404 * ---------- ----------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700405 * O_CREAT FILE_OPEN_IF
406 * O_CREAT | O_EXCL FILE_CREATE
407 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
408 * O_TRUNC FILE_OVERWRITE
409 * none of the above FILE_OPEN
410 *
411 * Note that there is not a direct match between disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000412 * FILE_SUPERSEDE (ie create whether or not file exists although
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413 * O_CREAT | O_TRUNC is similar but truncates the existing
414 * file rather than creating a new file as FILE_SUPERSEDE does
415 * (which uses the attributes / metadata passed in on open call)
416 *?
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000417 *? O_SYNC is a reasonable match to CIFS writethrough flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700418 *? and the read write flags match reasonably. O_LARGEFILE
419 *? is irrelevant because largefile support is always used
420 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
421 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
422 *********************************************************************/
423
424 disposition = cifs_get_disposition(file->f_flags);
425
Linus Torvalds1da177e2005-04-16 15:20:36 -0700426 /* BB pass O_SYNC flag through on file attributes .. BB */
427
428 /* Also refresh inode by passing in file_info buf returned by SMBOpen
429 and calling get_inode_info with returned buf (at least helps
430 non-Unix server case) */
431
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000432 /* BB we can not do this if this is the second open of a file
433 and the first handle has writebehind data, we might be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
435 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
436 if (!buf) {
437 rc = -ENOMEM;
438 goto out;
439 }
Steve French5bafd762006-06-07 00:18:43 +0000440
Jeff Laytona6e8a842010-09-20 16:01:33 -0700441 if (tcon->ses->capabilities & CAP_NT_SMBS)
Steve French276a74a2009-03-03 18:00:34 +0000442 rc = CIFSSMBOpen(xid, tcon, full_path, disposition,
Steve French5bafd762006-06-07 00:18:43 +0000443 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
Steve French737b7582005-04-28 22:41:06 -0700444 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
445 & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000446 else
447 rc = -EIO; /* no NT SMB support fall into legacy open below */
448
Steve Frencha9d02ad2005-08-24 23:06:05 -0700449 if (rc == -EIO) {
450 /* Old server, try legacy style OpenX */
Steve French276a74a2009-03-03 18:00:34 +0000451 rc = SMBLegacyOpen(xid, tcon, full_path, disposition,
Steve Frencha9d02ad2005-08-24 23:06:05 -0700452 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
453 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
454 & CIFS_MOUNT_MAP_SPECIAL_CHR);
455 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000457 cFYI(1, "cifs_open returned 0x%x", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 goto out;
459 }
Jeff Layton3321b792009-09-25 09:53:37 -0400460
Suresh Jayaramana347ecb2010-09-17 19:43:10 +0530461 rc = cifs_open_inode_helper(inode, tcon, oplock, buf, full_path, xid);
Jeff Layton47c78b72010-06-16 13:40:17 -0400462 if (rc != 0)
463 goto out;
464
Jeff Laytonabfe1ee2010-10-15 15:33:58 -0400465 pCifsFile = cifs_new_fileinfo(netfid, file, tlink, oplock);
Jeff Layton6ca9f3b2010-06-16 13:40:16 -0400466 if (pCifsFile == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 rc = -ENOMEM;
468 goto out;
469 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700470
Suresh Jayaraman9451a9a2010-07-05 18:12:45 +0530471 cifs_fscache_set_inode_cookie(inode, file);
472
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000473 if (oplock & CIFS_CREATE_ACTION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700474 /* time to set mode which we can not set earlier due to
475 problems creating new read-only files */
Steve French276a74a2009-03-03 18:00:34 +0000476 if (tcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400477 struct cifs_unix_set_info_args args = {
478 .mode = inode->i_mode,
479 .uid = NO_CHANGE_64,
480 .gid = NO_CHANGE_64,
481 .ctime = NO_CHANGE_64,
482 .atime = NO_CHANGE_64,
483 .mtime = NO_CHANGE_64,
484 .device = 0,
485 };
Jeff Layton01ea95e2009-07-09 20:02:49 -0400486 CIFSSMBUnixSetPathInfo(xid, tcon, full_path, &args,
487 cifs_sb->local_nls,
488 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700489 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700490 }
491 }
492
493out:
494 kfree(buf);
495 kfree(full_path);
496 FreeXid(xid);
Jeff Layton7ffec372010-09-29 19:51:11 -0400497 cifs_put_tlink(tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700498 return rc;
499}
500
Adrian Bunk04187262006-06-30 18:23:04 +0200501/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700502/* to server was lost */
503static int cifs_relock_file(struct cifsFileInfo *cifsFile)
504{
505 int rc = 0;
506
507/* BB list all locks open on this file and relock */
508
509 return rc;
510}
511
Jeff Layton15886172010-10-15 15:33:59 -0400512static int cifs_reopen_file(struct cifsFileInfo *pCifsFile, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700513{
514 int rc = -EACCES;
Jeff Layton590a3fe2009-09-12 11:54:28 -0400515 int xid;
516 __u32 oplock;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517 struct cifs_sb_info *cifs_sb;
Steve French7fc8f4e2009-02-23 20:43:11 +0000518 struct cifsTconInfo *tcon;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000520 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 char *full_path = NULL;
522 int desiredAccess;
523 int disposition = FILE_OPEN;
524 __u16 netfid;
525
Linus Torvalds1da177e2005-04-16 15:20:36 -0700526 xid = GetXid();
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400527 mutex_lock(&pCifsFile->fh_mutex);
Steve French4b18f2a2008-04-29 00:06:05 +0000528 if (!pCifsFile->invalidHandle) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400529 mutex_unlock(&pCifsFile->fh_mutex);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530530 rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700531 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530532 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 }
534
Jeff Layton15886172010-10-15 15:33:59 -0400535 inode = pCifsFile->dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 cifs_sb = CIFS_SB(inode->i_sb);
Jeff Layton13cfb732010-09-29 19:51:11 -0400537 tcon = tlink_tcon(pCifsFile->tlink);
Steve French3a9f4622007-04-04 17:10:24 +0000538
Linus Torvalds1da177e2005-04-16 15:20:36 -0700539/* can not grab rename sem here because various ops, including
540 those that already have the rename sem can end up causing writepage
541 to get called and if the server was down that means we end up here,
542 and we can never tell if the caller already has the rename_sem */
Jeff Layton15886172010-10-15 15:33:59 -0400543 full_path = build_path_from_dentry(pCifsFile->dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000545 rc = -ENOMEM;
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400546 mutex_unlock(&pCifsFile->fh_mutex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000548 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 }
550
Joe Perchesb6b38f72010-04-21 03:50:45 +0000551 cFYI(1, "inode = 0x%p file flags 0x%x for %s",
Jeff Layton15886172010-10-15 15:33:59 -0400552 inode, pCifsFile->f_flags, full_path);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553
554 if (oplockEnabled)
555 oplock = REQ_OPLOCK;
556 else
Steve French4b18f2a2008-04-29 00:06:05 +0000557 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700558
Steve French7fc8f4e2009-02-23 20:43:11 +0000559 if (tcon->unix_ext && (tcon->ses->capabilities & CAP_UNIX) &&
560 (CIFS_UNIX_POSIX_PATH_OPS_CAP &
561 le64_to_cpu(tcon->fsUnixInfo.Capability))) {
Jeff Layton608712f2010-10-15 15:33:56 -0400562
563 /*
564 * O_CREAT, O_EXCL and O_TRUNC already had their effect on the
565 * original open. Must mask them off for a reopen.
566 */
Jeff Layton15886172010-10-15 15:33:59 -0400567 unsigned int oflags = pCifsFile->f_flags &
568 ~(O_CREAT | O_EXCL | O_TRUNC);
Jeff Layton608712f2010-10-15 15:33:56 -0400569
Jeff Layton2422f672010-06-16 13:40:16 -0400570 rc = cifs_posix_open(full_path, NULL, inode->i_sb,
Steve Frenchfa588e02010-04-22 19:21:55 +0000571 cifs_sb->mnt_file_mode /* ignored */,
572 oflags, &oplock, &netfid, xid);
Steve French7fc8f4e2009-02-23 20:43:11 +0000573 if (rc == 0) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000574 cFYI(1, "posix reopen succeeded");
Steve French7fc8f4e2009-02-23 20:43:11 +0000575 goto reopen_success;
576 }
577 /* fallthrough to retry open the old way on errors, especially
578 in the reconnect path it is important to retry hard */
579 }
580
Jeff Layton15886172010-10-15 15:33:59 -0400581 desiredAccess = cifs_convert_flags(pCifsFile->f_flags);
Steve French7fc8f4e2009-02-23 20:43:11 +0000582
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000584 by SMBOpen and then calling get_inode_info with returned buf
585 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 and server version of file size can be stale. If we knew for sure
587 that inode was not dirty locally we could do this */
588
Steve French7fc8f4e2009-02-23 20:43:11 +0000589 rc = CIFSSMBOpen(xid, tcon, full_path, disposition, desiredAccess,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000591 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700592 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700593 if (rc) {
Jeff Laytonf0a71eb2009-06-27 07:04:55 -0400594 mutex_unlock(&pCifsFile->fh_mutex);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000595 cFYI(1, "cifs_open returned 0x%x", rc);
596 cFYI(1, "oplock: %d", oplock);
Jeff Layton15886172010-10-15 15:33:59 -0400597 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700598 }
Jeff Layton15886172010-10-15 15:33:59 -0400599
600reopen_success:
601 pCifsFile->netfid = netfid;
602 pCifsFile->invalidHandle = false;
603 mutex_unlock(&pCifsFile->fh_mutex);
604 pCifsInode = CIFS_I(inode);
605
606 if (can_flush) {
607 rc = filemap_write_and_wait(inode->i_mapping);
Jeff Laytoneb4b7562010-10-22 14:52:29 -0400608 mapping_set_error(inode->i_mapping, rc);
Jeff Layton15886172010-10-15 15:33:59 -0400609
610 pCifsInode->clientCanCacheAll = false;
611 pCifsInode->clientCanCacheRead = false;
612 if (tcon->unix_ext)
613 rc = cifs_get_inode_info_unix(&inode,
614 full_path, inode->i_sb, xid);
615 else
616 rc = cifs_get_inode_info(&inode,
617 full_path, NULL, inode->i_sb,
618 xid, NULL);
619 } /* else we are writing out data to server already
620 and could deadlock if we tried to flush data, and
621 since we do not know if we have data that would
622 invalidate the current end of file on the server
623 we can not go to the server to get the new inod
624 info */
625 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
626 pCifsInode->clientCanCacheAll = true;
627 pCifsInode->clientCanCacheRead = true;
628 cFYI(1, "Exclusive Oplock granted on inode %p",
629 pCifsFile->dentry->d_inode);
630 } else if ((oplock & 0xF) == OPLOCK_READ) {
631 pCifsInode->clientCanCacheRead = true;
632 pCifsInode->clientCanCacheAll = false;
633 } else {
634 pCifsInode->clientCanCacheRead = false;
635 pCifsInode->clientCanCacheAll = false;
636 }
637 cifs_relock_file(pCifsFile);
638
639reopen_error_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 kfree(full_path);
641 FreeXid(xid);
642 return rc;
643}
644
645int cifs_close(struct inode *inode, struct file *file)
646{
Steve Frenchcdff08e2010-10-21 22:46:14 +0000647 cifsFileInfo_put(file->private_data);
648 file->private_data = NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649
Steve Frenchcdff08e2010-10-21 22:46:14 +0000650 /* return code from the ->release op is always ignored */
651 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652}
653
654int cifs_closedir(struct inode *inode, struct file *file)
655{
656 int rc = 0;
657 int xid;
Joe Perchesc21dfb62010-07-12 13:50:14 -0700658 struct cifsFileInfo *pCFileStruct = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 char *ptmp;
660
Joe Perchesb6b38f72010-04-21 03:50:45 +0000661 cFYI(1, "Closedir inode = 0x%p", inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700662
663 xid = GetXid();
664
665 if (pCFileStruct) {
Jeff Layton13cfb732010-09-29 19:51:11 -0400666 struct cifsTconInfo *pTcon = tlink_tcon(pCFileStruct->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
Joe Perchesb6b38f72010-04-21 03:50:45 +0000668 cFYI(1, "Freeing private data in close dir");
Jeff Layton44772882010-10-15 15:34:03 -0400669 spin_lock(&cifs_file_list_lock);
Steve French4b18f2a2008-04-29 00:06:05 +0000670 if (!pCFileStruct->srch_inf.endOfSearch &&
671 !pCFileStruct->invalidHandle) {
672 pCFileStruct->invalidHandle = true;
Jeff Layton44772882010-10-15 15:34:03 -0400673 spin_unlock(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700674 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
Joe Perchesb6b38f72010-04-21 03:50:45 +0000675 cFYI(1, "Closing uncompleted readdir with rc %d",
676 rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677 /* not much we can do if it fails anyway, ignore rc */
678 rc = 0;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000679 } else
Jeff Layton44772882010-10-15 15:34:03 -0400680 spin_unlock(&cifs_file_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
682 if (ptmp) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000683 cFYI(1, "closedir free smb buf in srch struct");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700684 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000685 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000686 cifs_small_buf_release(ptmp);
687 else
688 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 }
Jeff Layton13cfb732010-09-29 19:51:11 -0400690 cifs_put_tlink(pCFileStruct->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700691 kfree(file->private_data);
692 file->private_data = NULL;
693 }
694 /* BB can we lock the filestruct while this is going on? */
695 FreeXid(xid);
696 return rc;
697}
698
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000699static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
700 __u64 offset, __u8 lockType)
701{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000702 struct cifsLockInfo *li =
703 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000704 if (li == NULL)
705 return -ENOMEM;
706 li->offset = offset;
707 li->length = len;
708 li->type = lockType;
Roland Dreier796e5662007-05-03 04:33:45 +0000709 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000710 list_add(&li->llist, &fid->llist);
Roland Dreier796e5662007-05-03 04:33:45 +0000711 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000712 return 0;
713}
714
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
716{
717 int rc, xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700718 __u32 numLock = 0;
719 __u32 numUnlock = 0;
720 __u64 length;
Steve French4b18f2a2008-04-29 00:06:05 +0000721 bool wait_flag = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 struct cifs_sb_info *cifs_sb;
Steve French13a6e422008-12-02 17:24:33 +0000723 struct cifsTconInfo *tcon;
Steve French08547b02006-02-28 22:39:25 +0000724 __u16 netfid;
725 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
Steve French13a6e422008-12-02 17:24:33 +0000726 bool posix_locking = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727
728 length = 1 + pfLock->fl_end - pfLock->fl_start;
729 rc = -EACCES;
730 xid = GetXid();
731
Joe Perchesb6b38f72010-04-21 03:50:45 +0000732 cFYI(1, "Lock parm: 0x%x flockflags: "
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 "0x%x flocktype: 0x%x start: %lld end: %lld",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000734 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
Joe Perchesb6b38f72010-04-21 03:50:45 +0000735 pfLock->fl_end);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700736
737 if (pfLock->fl_flags & FL_POSIX)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000738 cFYI(1, "Posix");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700739 if (pfLock->fl_flags & FL_FLOCK)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000740 cFYI(1, "Flock");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 if (pfLock->fl_flags & FL_SLEEP) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000742 cFYI(1, "Blocking lock");
Steve French4b18f2a2008-04-29 00:06:05 +0000743 wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700744 }
745 if (pfLock->fl_flags & FL_ACCESS)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000746 cFYI(1, "Process suspended by mandatory locking - "
747 "not implemented yet");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748 if (pfLock->fl_flags & FL_LEASE)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000749 cFYI(1, "Lease on file - not implemented yet");
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000750 if (pfLock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
Joe Perchesb6b38f72010-04-21 03:50:45 +0000752 cFYI(1, "Unknown lock flags 0x%x", pfLock->fl_flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753
754 if (pfLock->fl_type == F_WRLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000755 cFYI(1, "F_WRLCK ");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756 numLock = 1;
757 } else if (pfLock->fl_type == F_UNLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000758 cFYI(1, "F_UNLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 numUnlock = 1;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000760 /* Check if unlock includes more than
761 one lock range */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762 } else if (pfLock->fl_type == F_RDLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000763 cFYI(1, "F_RDLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764 lockType |= LOCKING_ANDX_SHARED_LOCK;
765 numLock = 1;
766 } else if (pfLock->fl_type == F_EXLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000767 cFYI(1, "F_EXLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768 numLock = 1;
769 } else if (pfLock->fl_type == F_SHLCK) {
Joe Perchesb6b38f72010-04-21 03:50:45 +0000770 cFYI(1, "F_SHLCK");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771 lockType |= LOCKING_ANDX_SHARED_LOCK;
772 numLock = 1;
773 } else
Joe Perchesb6b38f72010-04-21 03:50:45 +0000774 cFYI(1, "Unknown type of lock");
Linus Torvalds1da177e2005-04-16 15:20:36 -0700775
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800776 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Jeff Layton13cfb732010-09-29 19:51:11 -0400777 tcon = tlink_tcon(((struct cifsFileInfo *)file->private_data)->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700778
779 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530780 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700781 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +0530782 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700783 }
Steve French08547b02006-02-28 22:39:25 +0000784 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700785
Steve French13a6e422008-12-02 17:24:33 +0000786 if ((tcon->ses->capabilities & CAP_UNIX) &&
787 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(tcon->fsUnixInfo.Capability)) &&
Steve Frenchacc18aa2008-12-02 18:53:55 +0000788 ((cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOPOSIXBRL) == 0))
Steve French13a6e422008-12-02 17:24:33 +0000789 posix_locking = 1;
Steve French08547b02006-02-28 22:39:25 +0000790 /* BB add code here to normalize offset and length to
791 account for negative length which we can not accept over the
792 wire */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700793 if (IS_GETLK(cmd)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000794 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000795 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000796 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000797 posix_lock_type = CIFS_RDLCK;
798 else
799 posix_lock_type = CIFS_WRLCK;
Steve French13a6e422008-12-02 17:24:33 +0000800 rc = CIFSSMBPosixLock(xid, tcon, netfid, 1 /* get */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000801 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000802 posix_lock_type, wait_flag);
803 FreeXid(xid);
804 return rc;
805 }
806
807 /* BB we could chain these into one lock request BB */
Steve French13a6e422008-12-02 17:24:33 +0000808 rc = CIFSSMBLock(xid, tcon, netfid, length, pfLock->fl_start,
Steve French08547b02006-02-28 22:39:25 +0000809 0, 1, lockType, 0 /* wait flag */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 if (rc == 0) {
Steve French13a6e422008-12-02 17:24:33 +0000811 rc = CIFSSMBLock(xid, tcon, netfid, length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700812 pfLock->fl_start, 1 /* numUnlock */ ,
813 0 /* numLock */ , lockType,
814 0 /* wait flag */ );
815 pfLock->fl_type = F_UNLCK;
816 if (rc != 0)
Joe Perchesb6b38f72010-04-21 03:50:45 +0000817 cERROR(1, "Error unlocking previously locked "
818 "range %d during test of lock", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700819 rc = 0;
820
821 } else {
822 /* if rc == ERR_SHARING_VIOLATION ? */
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400823 rc = 0;
824
825 if (lockType & LOCKING_ANDX_SHARED_LOCK) {
826 pfLock->fl_type = F_WRLCK;
827 } else {
828 rc = CIFSSMBLock(xid, tcon, netfid, length,
829 pfLock->fl_start, 0, 1,
830 lockType | LOCKING_ANDX_SHARED_LOCK,
831 0 /* wait flag */);
832 if (rc == 0) {
833 rc = CIFSSMBLock(xid, tcon, netfid,
834 length, pfLock->fl_start, 1, 0,
835 lockType |
836 LOCKING_ANDX_SHARED_LOCK,
837 0 /* wait flag */);
838 pfLock->fl_type = F_RDLCK;
839 if (rc != 0)
Steve Frenchf19159d2010-04-21 04:12:10 +0000840 cERROR(1, "Error unlocking "
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400841 "previously locked range %d "
Steve Frenchf19159d2010-04-21 04:12:10 +0000842 "during test of lock", rc);
Pavel Shilovskyf05337c2010-04-05 09:59:14 +0400843 rc = 0;
844 } else {
845 pfLock->fl_type = F_WRLCK;
846 rc = 0;
847 }
848 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700849 }
850
851 FreeXid(xid);
852 return rc;
853 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000854
855 if (!numLock && !numUnlock) {
856 /* if no lock or unlock then nothing
857 to do since we do not know what it is */
858 FreeXid(xid);
859 return -EOPNOTSUPP;
860 }
861
862 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000863 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000864 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000865 posix_lock_type = CIFS_RDLCK;
866 else
867 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +0000868
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000869 if (numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000870 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000871
Steve French13a6e422008-12-02 17:24:33 +0000872 rc = CIFSSMBPosixLock(xid, tcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000873 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000874 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000875 } else {
Joe Perchesc21dfb62010-07-12 13:50:14 -0700876 struct cifsFileInfo *fid = file->private_data;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000877
878 if (numLock) {
Steve French13a6e422008-12-02 17:24:33 +0000879 rc = CIFSSMBLock(xid, tcon, netfid, length,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000880 pfLock->fl_start,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000881 0, numLock, lockType, wait_flag);
882
883 if (rc == 0) {
884 /* For Windows locks we must store them. */
885 rc = store_file_lock(fid, length,
886 pfLock->fl_start, lockType);
887 }
888 } else if (numUnlock) {
889 /* For each stored lock that this unlock overlaps
890 completely, unlock it. */
891 int stored_rc = 0;
892 struct cifsLockInfo *li, *tmp;
893
Steve French6b70c952006-09-21 07:35:29 +0000894 rc = 0;
Roland Dreier796e5662007-05-03 04:33:45 +0000895 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000896 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
897 if (pfLock->fl_start <= li->offset &&
Steve Frenchc19eb712007-08-24 03:22:48 +0000898 (pfLock->fl_start + length) >=
Jeff Layton39db8102007-08-24 03:16:51 +0000899 (li->offset + li->length)) {
Steve French13a6e422008-12-02 17:24:33 +0000900 stored_rc = CIFSSMBLock(xid, tcon,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000901 netfid,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000902 li->length, li->offset,
Steve French4b18f2a2008-04-29 00:06:05 +0000903 1, 0, li->type, false);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000904 if (stored_rc)
905 rc = stored_rc;
Pavel Shilovsky2c964d12010-04-21 19:44:24 +0000906 else {
907 list_del(&li->llist);
908 kfree(li);
909 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000910 }
911 }
Roland Dreier796e5662007-05-03 04:33:45 +0000912 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000913 }
914 }
915
Steve Frenchd634cc12005-08-26 14:42:59 -0500916 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 posix_lock_file_wait(file, pfLock);
918 FreeXid(xid);
919 return rc;
920}
921
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400922/*
923 * Set the timeout on write requests past EOF. For some servers (Windows)
924 * these calls can be very long.
925 *
926 * If we're writing >10M past the EOF we give a 180s timeout. Anything less
927 * than that gets a 45s timeout. Writes not past EOF get 15s timeouts.
928 * The 10M cutoff is totally arbitrary. A better scheme for this would be
929 * welcome if someone wants to suggest one.
930 *
931 * We may be able to do a better job with this if there were some way to
932 * declare that a file should be sparse.
933 */
934static int
935cifs_write_timeout(struct cifsInodeInfo *cifsi, loff_t offset)
936{
937 if (offset <= cifsi->server_eof)
938 return CIFS_STD_OP;
939 else if (offset > (cifsi->server_eof + (10 * 1024 * 1024)))
940 return CIFS_VLONG_OP;
941 else
942 return CIFS_LONG_OP;
943}
944
945/* update the file size (if needed) after a write */
946static void
947cifs_update_eof(struct cifsInodeInfo *cifsi, loff_t offset,
948 unsigned int bytes_written)
949{
950 loff_t end_of_write = offset + bytes_written;
951
952 if (end_of_write > cifsi->server_eof)
953 cifsi->server_eof = end_of_write;
954}
955
Linus Torvalds1da177e2005-04-16 15:20:36 -0700956ssize_t cifs_user_write(struct file *file, const char __user *write_data,
957 size_t write_size, loff_t *poffset)
958{
959 int rc = 0;
960 unsigned int bytes_written = 0;
961 unsigned int total_written;
962 struct cifs_sb_info *cifs_sb;
963 struct cifsTconInfo *pTcon;
964 int xid, long_op;
965 struct cifsFileInfo *open_file;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400966 struct cifsInodeInfo *cifsi = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700967
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800968 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700969
Joe Perchesb6b38f72010-04-21 03:50:45 +0000970 /* cFYI(1, " write %d bytes to offset %lld of %s", write_size,
971 *poffset, file->f_path.dentry->d_name.name); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700972
973 if (file->private_data == NULL)
974 return -EBADF;
Jeff Laytonba00ba62010-09-20 16:01:31 -0700975
Joe Perchesc21dfb62010-07-12 13:50:14 -0700976 open_file = file->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -0400977 pTcon = tlink_tcon(open_file->tlink);
Steve French50c2f752007-07-13 00:33:32 +0000978
Jeff Layton838726c2008-08-28 07:54:59 -0400979 rc = generic_write_checks(file, poffset, &write_size, 0);
980 if (rc)
981 return rc;
982
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700984
Jeff Laytonfbec9ab2009-04-03 13:44:00 -0400985 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700986 for (total_written = 0; write_size > total_written;
987 total_written += bytes_written) {
988 rc = -EAGAIN;
989 while (rc == -EAGAIN) {
990 if (file->private_data == NULL) {
991 /* file has been closed on us */
992 FreeXid(xid);
993 /* if we have gotten here we have written some data
994 and blocked, and the file has been freed on us while
995 we blocked so return what we managed to write */
996 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000997 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700998 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 /* we could deadlock if we called
1000 filemap_fdatawait from here so tell
1001 reopen_file not to flush data to server
1002 now */
Jeff Layton15886172010-10-15 15:33:59 -04001003 rc = cifs_reopen_file(open_file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001004 if (rc != 0)
1005 break;
1006 }
1007
1008 rc = CIFSSMBWrite(xid, pTcon,
1009 open_file->netfid,
1010 min_t(const int, cifs_sb->wsize,
1011 write_size - total_written),
1012 *poffset, &bytes_written,
1013 NULL, write_data + total_written, long_op);
1014 }
1015 if (rc || (bytes_written == 0)) {
1016 if (total_written)
1017 break;
1018 else {
1019 FreeXid(xid);
1020 return rc;
1021 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001022 } else {
1023 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001024 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001025 }
Steve French133672e2007-11-13 22:41:37 +00001026 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027 15 seconds is plenty */
1028 }
1029
Steve Frencha4544342005-08-24 13:59:35 -07001030 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001031
1032 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001033 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
1034 struct inode *inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001035/* Do not update local mtime - server will set its actual value on write
1036 * inode->i_ctime = inode->i_mtime =
Steve French3677db12007-02-26 16:46:11 +00001037 * current_fs_time(inode->i_sb);*/
1038 if (total_written > 0) {
1039 spin_lock(&inode->i_lock);
1040 if (*poffset > file->f_path.dentry->d_inode->i_size)
1041 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001042 *poffset);
Steve French3677db12007-02-26 16:46:11 +00001043 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001044 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001045 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001046 }
1047 FreeXid(xid);
1048 return total_written;
1049}
1050
Jeff Layton7da4b492010-10-15 15:34:00 -04001051static ssize_t cifs_write(struct cifsFileInfo *open_file,
1052 const char *write_data, size_t write_size,
1053 loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001054{
1055 int rc = 0;
1056 unsigned int bytes_written = 0;
1057 unsigned int total_written;
1058 struct cifs_sb_info *cifs_sb;
1059 struct cifsTconInfo *pTcon;
1060 int xid, long_op;
Jeff Layton7da4b492010-10-15 15:34:00 -04001061 struct dentry *dentry = open_file->dentry;
1062 struct cifsInodeInfo *cifsi = CIFS_I(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
Jeff Layton7da4b492010-10-15 15:34:00 -04001064 cifs_sb = CIFS_SB(dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065
Joe Perchesb6b38f72010-04-21 03:50:45 +00001066 cFYI(1, "write %zd bytes to offset %lld of %s", write_size,
Jeff Layton7da4b492010-10-15 15:34:00 -04001067 *poffset, dentry->d_name.name);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001068
Jeff Layton13cfb732010-09-29 19:51:11 -04001069 pTcon = tlink_tcon(open_file->tlink);
Steve French50c2f752007-07-13 00:33:32 +00001070
Linus Torvalds1da177e2005-04-16 15:20:36 -07001071 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001072
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001073 long_op = cifs_write_timeout(cifsi, *poffset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001074 for (total_written = 0; write_size > total_written;
1075 total_written += bytes_written) {
1076 rc = -EAGAIN;
1077 while (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001078 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079 /* we could deadlock if we called
1080 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001081 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -07001082 server now */
Jeff Layton15886172010-10-15 15:33:59 -04001083 rc = cifs_reopen_file(open_file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001084 if (rc != 0)
1085 break;
1086 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001087 if (experimEnabled || (pTcon->ses->server &&
1088 ((pTcon->ses->server->secMode &
Steve French08775832006-05-30 18:08:26 +00001089 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +00001090 == 0))) {
Steve French3e844692005-10-03 13:37:24 -07001091 struct kvec iov[2];
1092 unsigned int len;
1093
Steve French0ae0efa2005-10-10 10:57:19 -07001094 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -07001095 write_size - total_written);
1096 /* iov[0] is reserved for smb header */
1097 iov[1].iov_base = (char *)write_data +
1098 total_written;
1099 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001100 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -07001101 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001102 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -07001103 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -05001104 } else
Steve French60808232006-04-22 15:53:05 +00001105 rc = CIFSSMBWrite(xid, pTcon,
1106 open_file->netfid,
1107 min_t(const int, cifs_sb->wsize,
1108 write_size - total_written),
1109 *poffset, &bytes_written,
1110 write_data + total_written,
1111 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001112 }
1113 if (rc || (bytes_written == 0)) {
1114 if (total_written)
1115 break;
1116 else {
1117 FreeXid(xid);
1118 return rc;
1119 }
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001120 } else {
1121 cifs_update_eof(cifsi, *poffset, bytes_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001122 *poffset += bytes_written;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001123 }
Steve French133672e2007-11-13 22:41:37 +00001124 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001125 15 seconds is plenty */
1126 }
1127
Steve Frencha4544342005-08-24 13:59:35 -07001128 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
Jeff Layton7da4b492010-10-15 15:34:00 -04001130 if (total_written > 0) {
1131 spin_lock(&dentry->d_inode->i_lock);
1132 if (*poffset > dentry->d_inode->i_size)
1133 i_size_write(dentry->d_inode, *poffset);
1134 spin_unlock(&dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001135 }
Jeff Layton7da4b492010-10-15 15:34:00 -04001136 mark_inode_dirty_sync(dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 FreeXid(xid);
1138 return total_written;
1139}
1140
Steve French630f3f0c2007-10-25 21:17:17 +00001141#ifdef CONFIG_CIFS_EXPERIMENTAL
Jeff Layton6508d902010-09-29 19:51:11 -04001142struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode,
1143 bool fsuid_only)
Steve French630f3f0c2007-10-25 21:17:17 +00001144{
1145 struct cifsFileInfo *open_file = NULL;
Jeff Layton6508d902010-09-29 19:51:11 -04001146 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
1147
1148 /* only filter by fsuid on multiuser mounts */
1149 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1150 fsuid_only = false;
Steve French630f3f0c2007-10-25 21:17:17 +00001151
Jeff Layton44772882010-10-15 15:34:03 -04001152 spin_lock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001153 /* we could simply get the first_list_entry since write-only entries
1154 are always at the end of the list but since the first entry might
1155 have a close pending, we go through the whole list */
1156 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton6508d902010-09-29 19:51:11 -04001157 if (fsuid_only && open_file->uid != current_fsuid())
1158 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001159 if (OPEN_FMODE(open_file->f_flags) & FMODE_READ) {
Steve French630f3f0c2007-10-25 21:17:17 +00001160 if (!open_file->invalidHandle) {
1161 /* found a good file */
1162 /* lock it so it will not be closed on us */
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001163 cifsFileInfo_get(open_file);
Jeff Layton44772882010-10-15 15:34:03 -04001164 spin_unlock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001165 return open_file;
1166 } /* else might as well continue, and look for
1167 another, or simply have the caller reopen it
1168 again rather than trying to fix this handle */
1169 } else /* write only file */
1170 break; /* write only files are last so must be done */
1171 }
Jeff Layton44772882010-10-15 15:34:03 -04001172 spin_unlock(&cifs_file_list_lock);
Steve French630f3f0c2007-10-25 21:17:17 +00001173 return NULL;
1174}
1175#endif
1176
Jeff Layton6508d902010-09-29 19:51:11 -04001177struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode,
1178 bool fsuid_only)
Steve French6148a742005-10-05 12:23:19 -07001179{
1180 struct cifsFileInfo *open_file;
Jeff Layton6508d902010-09-29 19:51:11 -04001181 struct cifs_sb_info *cifs_sb = CIFS_SB(cifs_inode->vfs_inode.i_sb);
Jeff Layton2846d382008-09-22 21:33:33 -04001182 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001183 int rc;
Steve French6148a742005-10-05 12:23:19 -07001184
Steve French60808232006-04-22 15:53:05 +00001185 /* Having a null inode here (because mapping->host was set to zero by
1186 the VFS or MM) should not happen but we had reports of on oops (due to
1187 it being zero) during stress testcases so we need to check for it */
1188
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001189 if (cifs_inode == NULL) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001190 cERROR(1, "Null inode passed to cifs_writeable_file");
Steve French60808232006-04-22 15:53:05 +00001191 dump_stack();
1192 return NULL;
1193 }
1194
Jeff Layton6508d902010-09-29 19:51:11 -04001195 /* only filter by fsuid on multiuser mounts */
1196 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_MULTIUSER))
1197 fsuid_only = false;
1198
Jeff Layton44772882010-10-15 15:34:03 -04001199 spin_lock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001200refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001201 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton6508d902010-09-29 19:51:11 -04001202 if (!any_available && open_file->pid != current->tgid)
1203 continue;
1204 if (fsuid_only && open_file->uid != current_fsuid())
1205 continue;
Jeff Layton2e396b82010-10-15 15:34:01 -04001206 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001207 cifsFileInfo_get(open_file);
Steve French9b22b0b2007-10-02 01:11:08 +00001208
1209 if (!open_file->invalidHandle) {
1210 /* found a good writable file */
Jeff Layton44772882010-10-15 15:34:03 -04001211 spin_unlock(&cifs_file_list_lock);
Steve French9b22b0b2007-10-02 01:11:08 +00001212 return open_file;
1213 }
Steve French8840dee2007-11-16 23:05:52 +00001214
Jeff Layton44772882010-10-15 15:34:03 -04001215 spin_unlock(&cifs_file_list_lock);
Steve Frenchcdff08e2010-10-21 22:46:14 +00001216
Steve French9b22b0b2007-10-02 01:11:08 +00001217 /* Had to unlock since following call can block */
Jeff Layton15886172010-10-15 15:33:59 -04001218 rc = cifs_reopen_file(open_file, false);
Steve Frenchcdff08e2010-10-21 22:46:14 +00001219 if (!rc)
1220 return open_file;
Steve French9b22b0b2007-10-02 01:11:08 +00001221
Steve Frenchcdff08e2010-10-21 22:46:14 +00001222 /* if it fails, try another handle if possible */
Joe Perchesb6b38f72010-04-21 03:50:45 +00001223 cFYI(1, "wp failed on reopen file");
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001224 cifsFileInfo_put(open_file);
Steve French8840dee2007-11-16 23:05:52 +00001225
Steve Frenchcdff08e2010-10-21 22:46:14 +00001226 spin_lock(&cifs_file_list_lock);
1227
Steve French9b22b0b2007-10-02 01:11:08 +00001228 /* else we simply continue to the next entry. Thus
1229 we do not loop on reopen errors. If we
1230 can not reopen the file, for example if we
1231 reconnected to a server with another client
1232 racing to delete or lock the file we would not
1233 make progress if we restarted before the beginning
1234 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001235 }
1236 }
Jeff Layton2846d382008-09-22 21:33:33 -04001237 /* couldn't find useable FH with same pid, try any available */
1238 if (!any_available) {
1239 any_available = true;
1240 goto refind_writable;
1241 }
Jeff Layton44772882010-10-15 15:34:03 -04001242 spin_unlock(&cifs_file_list_lock);
Steve French6148a742005-10-05 12:23:19 -07001243 return NULL;
1244}
1245
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1247{
1248 struct address_space *mapping = page->mapping;
1249 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1250 char *write_data;
1251 int rc = -EFAULT;
1252 int bytes_written = 0;
1253 struct cifs_sb_info *cifs_sb;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001255 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
1257 if (!mapping || !mapping->host)
1258 return -EFAULT;
1259
1260 inode = page->mapping->host;
1261 cifs_sb = CIFS_SB(inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001262
1263 offset += (loff_t)from;
1264 write_data = kmap(page);
1265 write_data += from;
1266
1267 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1268 kunmap(page);
1269 return -EIO;
1270 }
1271
1272 /* racing with truncate? */
1273 if (offset > mapping->host->i_size) {
1274 kunmap(page);
1275 return 0; /* don't care */
1276 }
1277
1278 /* check to make sure that we are not extending the file */
1279 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001280 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001281
Jeff Layton6508d902010-09-29 19:51:11 -04001282 open_file = find_writable_file(CIFS_I(mapping->host), false);
Steve French6148a742005-10-05 12:23:19 -07001283 if (open_file) {
Jeff Layton7da4b492010-10-15 15:34:00 -04001284 bytes_written = cifs_write(open_file, write_data,
1285 to - from, &offset);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001286 cifsFileInfo_put(open_file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001287 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001288 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001289 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001290 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001291 else if (bytes_written < 0)
1292 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001293 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001294 cFYI(1, "No writeable filehandles for inode");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001295 rc = -EIO;
1296 }
1297
1298 kunmap(page);
1299 return rc;
1300}
1301
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001303 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001304{
Steve French37c0eb42005-10-05 14:50:29 -07001305 struct backing_dev_info *bdi = mapping->backing_dev_info;
1306 unsigned int bytes_to_write;
1307 unsigned int bytes_written;
1308 struct cifs_sb_info *cifs_sb;
1309 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001310 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001311 pgoff_t index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001312 int range_whole = 0;
1313 struct kvec *iov;
Steve French84d2f072005-10-12 15:32:05 -07001314 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001315 int n_iov = 0;
1316 pgoff_t next;
1317 int nr_pages;
1318 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001319 struct cifsFileInfo *open_file;
Jeff Laytonba00ba62010-09-20 16:01:31 -07001320 struct cifsTconInfo *tcon;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001321 struct cifsInodeInfo *cifsi = CIFS_I(mapping->host);
Steve French37c0eb42005-10-05 14:50:29 -07001322 struct page *page;
1323 struct pagevec pvec;
1324 int rc = 0;
1325 int scanned = 0;
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001326 int xid, long_op;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001327
Jeff Laytonf3983c22010-09-22 16:17:40 -07001328 /*
1329 * BB: Is this meaningful for a non-block-device file system?
1330 * If it is, we should test it again after we do I/O
1331 */
1332 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1333 wbc->encountered_congestion = 1;
1334 return 0;
1335 }
1336
Steve French37c0eb42005-10-05 14:50:29 -07001337 cifs_sb = CIFS_SB(mapping->host->i_sb);
Steve French50c2f752007-07-13 00:33:32 +00001338
Steve French37c0eb42005-10-05 14:50:29 -07001339 /*
1340 * If wsize is smaller that the page cache size, default to writing
1341 * one page at a time via cifs_writepage
1342 */
1343 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1344 return generic_writepages(mapping, wbc);
1345
Steve French9a0c8232007-02-02 04:21:57 +00001346 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001347 if (iov == NULL)
Steve French9a0c8232007-02-02 04:21:57 +00001348 return generic_writepages(mapping, wbc);
1349
Steve French37c0eb42005-10-05 14:50:29 -07001350 /*
Jeff Laytonf3983c22010-09-22 16:17:40 -07001351 * if there's no open file, then this is likely to fail too,
1352 * but it'll at least handle the return. Maybe it should be
1353 * a BUG() instead?
Steve French37c0eb42005-10-05 14:50:29 -07001354 */
Jeff Layton6508d902010-09-29 19:51:11 -04001355 open_file = find_writable_file(CIFS_I(mapping->host), false);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001356 if (!open_file) {
Steve French9a0c8232007-02-02 04:21:57 +00001357 kfree(iov);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001358 return generic_writepages(mapping, wbc);
Steve French37c0eb42005-10-05 14:50:29 -07001359 }
1360
Jeff Layton13cfb732010-09-29 19:51:11 -04001361 tcon = tlink_tcon(open_file->tlink);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001362 if (!experimEnabled && tcon->ses->server->secMode &
1363 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) {
1364 cifsFileInfo_put(open_file);
Dan Carpenter6b035902010-10-27 23:19:32 +02001365 kfree(iov);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001366 return generic_writepages(mapping, wbc);
1367 }
1368 cifsFileInfo_put(open_file);
1369
Linus Torvalds1da177e2005-04-16 15:20:36 -07001370 xid = GetXid();
1371
Steve French37c0eb42005-10-05 14:50:29 -07001372 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001373 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001374 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001375 end = -1;
1376 } else {
1377 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1378 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1379 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1380 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001381 scanned = 1;
1382 }
1383retry:
1384 while (!done && (index <= end) &&
1385 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1386 PAGECACHE_TAG_DIRTY,
1387 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1388 int first;
1389 unsigned int i;
1390
Steve French37c0eb42005-10-05 14:50:29 -07001391 first = -1;
1392 next = 0;
1393 n_iov = 0;
1394 bytes_to_write = 0;
1395
1396 for (i = 0; i < nr_pages; i++) {
1397 page = pvec.pages[i];
1398 /*
1399 * At this point we hold neither mapping->tree_lock nor
1400 * lock on the page itself: the page may be truncated or
1401 * invalidated (changing page->mapping to NULL), or even
1402 * swizzled back from swapper_space to tmpfs file
1403 * mapping
1404 */
1405
1406 if (first < 0)
1407 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001408 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001409 break;
1410
1411 if (unlikely(page->mapping != mapping)) {
1412 unlock_page(page);
1413 break;
1414 }
1415
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001416 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001417 done = 1;
1418 unlock_page(page);
1419 break;
1420 }
1421
1422 if (next && (page->index != next)) {
1423 /* Not next consecutive page */
1424 unlock_page(page);
1425 break;
1426 }
1427
1428 if (wbc->sync_mode != WB_SYNC_NONE)
1429 wait_on_page_writeback(page);
1430
1431 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001432 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001433 unlock_page(page);
1434 break;
1435 }
Steve French84d2f072005-10-12 15:32:05 -07001436
Linus Torvaldscb876f42006-12-23 16:19:07 -08001437 /*
1438 * This actually clears the dirty bit in the radix tree.
1439 * See cifs_writepage() for more commentary.
1440 */
1441 set_page_writeback(page);
1442
Steve French84d2f072005-10-12 15:32:05 -07001443 if (page_offset(page) >= mapping->host->i_size) {
1444 done = 1;
1445 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001446 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001447 break;
1448 }
1449
Steve French37c0eb42005-10-05 14:50:29 -07001450 /*
1451 * BB can we get rid of this? pages are held by pvec
1452 */
1453 page_cache_get(page);
1454
Steve French84d2f072005-10-12 15:32:05 -07001455 len = min(mapping->host->i_size - page_offset(page),
1456 (loff_t)PAGE_CACHE_SIZE);
1457
Steve French37c0eb42005-10-05 14:50:29 -07001458 /* reserve iov[0] for the smb header */
1459 n_iov++;
1460 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001461 iov[n_iov].iov_len = len;
1462 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001463
1464 if (first < 0) {
1465 first = i;
1466 offset = page_offset(page);
1467 }
1468 next = page->index + 1;
1469 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1470 break;
1471 }
1472 if (n_iov) {
Jeff Layton6508d902010-09-29 19:51:11 -04001473 open_file = find_writable_file(CIFS_I(mapping->host),
1474 false);
Steve French23e7dd72005-10-20 13:44:56 -07001475 if (!open_file) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001476 cERROR(1, "No writable handles for inode");
Steve French23e7dd72005-10-20 13:44:56 -07001477 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001478 } else {
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001479 long_op = cifs_write_timeout(cifsi, offset);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001480 rc = CIFSSMBWrite2(xid, tcon, open_file->netfid,
Steve French23e7dd72005-10-20 13:44:56 -07001481 bytes_to_write, offset,
1482 &bytes_written, iov, n_iov,
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001483 long_op);
Dave Kleikamp6ab409b2009-08-31 11:07:12 -04001484 cifsFileInfo_put(open_file);
Jeff Laytonfbec9ab2009-04-03 13:44:00 -04001485 cifs_update_eof(cifsi, offset, bytes_written);
Steve French37c0eb42005-10-05 14:50:29 -07001486 }
Jeff Laytonf3983c22010-09-22 16:17:40 -07001487
1488 if (rc || bytes_written < bytes_to_write) {
1489 cERROR(1, "Write2 ret %d, wrote %d",
1490 rc, bytes_written);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04001491 mapping_set_error(mapping, rc);
Jeff Laytonf3983c22010-09-22 16:17:40 -07001492 } else {
1493 cifs_stats_bytes_written(tcon, bytes_written);
1494 }
1495
Steve French37c0eb42005-10-05 14:50:29 -07001496 for (i = 0; i < n_iov; i++) {
1497 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001498 /* Should we also set page error on
1499 success rc but too little data written? */
1500 /* BB investigate retry logic on temporary
1501 server crash cases and how recovery works
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001502 when page marked as error */
1503 if (rc)
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001504 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001505 kunmap(page);
1506 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001507 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001508 page_cache_release(page);
1509 }
1510 if ((wbc->nr_to_write -= n_iov) <= 0)
1511 done = 1;
1512 index = next;
Dave Kleikampb066a482008-11-18 03:49:05 +00001513 } else
1514 /* Need to re-find the pages we skipped */
1515 index = pvec.pages[0]->index + 1;
1516
Steve French37c0eb42005-10-05 14:50:29 -07001517 pagevec_release(&pvec);
1518 }
1519 if (!scanned && !done) {
1520 /*
1521 * We hit the last page and there is more work to be done: wrap
1522 * back to the start of the file
1523 */
1524 scanned = 1;
1525 index = 0;
1526 goto retry;
1527 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001528 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001529 mapping->writeback_index = index;
1530
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001532 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 return rc;
1534}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001535
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001536static int cifs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001537{
1538 int rc = -EFAULT;
1539 int xid;
1540
1541 xid = GetXid();
1542/* BB add check for wbc flags */
1543 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001544 if (!PageUptodate(page))
Joe Perchesb6b38f72010-04-21 03:50:45 +00001545 cFYI(1, "ppw - page not up to date");
Linus Torvaldscb876f42006-12-23 16:19:07 -08001546
1547 /*
1548 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1549 *
1550 * A writepage() implementation always needs to do either this,
1551 * or re-dirty the page with "redirty_page_for_writepage()" in
1552 * the case of a failure.
1553 *
1554 * Just unlocking the page will cause the radix tree tag-bits
1555 * to fail to update with the state of the page correctly.
1556 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001557 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001558 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1559 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1560 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001561 end_page_writeback(page);
1562 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563 FreeXid(xid);
1564 return rc;
1565}
1566
Nick Piggind9414772008-09-24 11:32:59 -04001567static int cifs_write_end(struct file *file, struct address_space *mapping,
1568 loff_t pos, unsigned len, unsigned copied,
1569 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570{
Nick Piggind9414772008-09-24 11:32:59 -04001571 int rc;
1572 struct inode *inode = mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001573
Joe Perchesb6b38f72010-04-21 03:50:45 +00001574 cFYI(1, "write_end for page %p from pos %lld with %d bytes",
1575 page, pos, copied);
Steve Frenchad7a2922008-02-07 23:25:02 +00001576
Jeff Laytona98ee8c2008-11-26 19:32:33 +00001577 if (PageChecked(page)) {
1578 if (copied == len)
1579 SetPageUptodate(page);
1580 ClearPageChecked(page);
1581 } else if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
Nick Piggind9414772008-09-24 11:32:59 -04001582 SetPageUptodate(page);
1583
Linus Torvalds1da177e2005-04-16 15:20:36 -07001584 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04001585 char *page_data;
1586 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1587 int xid;
1588
1589 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001590 /* this is probably better than directly calling
1591 partialpage_write since in this function the file handle is
1592 known which we might as well leverage */
1593 /* BB check if anything else missing out of ppw
1594 such as updating last write time */
1595 page_data = kmap(page);
Jeff Layton7da4b492010-10-15 15:34:00 -04001596 rc = cifs_write(file->private_data, page_data + offset,
1597 copied, &pos);
Nick Piggind9414772008-09-24 11:32:59 -04001598 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001600
1601 FreeXid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001602 } else {
Nick Piggind9414772008-09-24 11:32:59 -04001603 rc = copied;
1604 pos += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001605 set_page_dirty(page);
1606 }
1607
Nick Piggind9414772008-09-24 11:32:59 -04001608 if (rc > 0) {
1609 spin_lock(&inode->i_lock);
1610 if (pos > inode->i_size)
1611 i_size_write(inode, pos);
1612 spin_unlock(&inode->i_lock);
1613 }
1614
1615 unlock_page(page);
1616 page_cache_release(page);
1617
Linus Torvalds1da177e2005-04-16 15:20:36 -07001618 return rc;
1619}
1620
Christoph Hellwig7ea80852010-05-26 17:53:25 +02001621int cifs_fsync(struct file *file, int datasync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001622{
1623 int xid;
1624 int rc = 0;
Steve Frenchb298f222009-02-21 21:17:43 +00001625 struct cifsTconInfo *tcon;
Joe Perchesc21dfb62010-07-12 13:50:14 -07001626 struct cifsFileInfo *smbfile = file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001627 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001628
1629 xid = GetXid();
1630
Joe Perchesb6b38f72010-04-21 03:50:45 +00001631 cFYI(1, "Sync file - name: %s datasync: 0x%x",
Christoph Hellwig7ea80852010-05-26 17:53:25 +02001632 file->f_path.dentry->d_name.name, datasync);
Steve French50c2f752007-07-13 00:33:32 +00001633
Jeff Laytoncea21802007-11-20 23:19:03 +00001634 rc = filemap_write_and_wait(inode->i_mapping);
1635 if (rc == 0) {
Jeff Laytoneb4b7562010-10-22 14:52:29 -04001636 struct cifs_sb_info *cifs_sb = CIFS_SB(inode->i_sb);
1637
Jeff Layton13cfb732010-09-29 19:51:11 -04001638 tcon = tlink_tcon(smbfile->tlink);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04001639 if (!(cifs_sb->mnt_cifs_flags & CIFS_MOUNT_NOSSYNC))
Steve Frenchb298f222009-02-21 21:17:43 +00001640 rc = CIFSSMBFlush(xid, tcon, smbfile->netfid);
Jeff Laytoncea21802007-11-20 23:19:03 +00001641 }
Steve Frenchb298f222009-02-21 21:17:43 +00001642
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 FreeXid(xid);
1644 return rc;
1645}
1646
NeilBrown3978d7172006-03-26 01:37:17 -08001647/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648{
1649 struct address_space *mapping;
1650 struct inode *inode;
1651 unsigned long index = page->index;
1652 unsigned int rpages = 0;
1653 int rc = 0;
1654
Steve Frenchf19159d2010-04-21 04:12:10 +00001655 cFYI(1, "sync page %p", page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 mapping = page->mapping;
1657 if (!mapping)
1658 return 0;
1659 inode = mapping->host;
1660 if (!inode)
NeilBrown3978d7172006-03-26 01:37:17 -08001661 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001662
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001663/* fill in rpages then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1665
Joe Perchesb6b38f72010-04-21 03:50:45 +00001666/* cFYI(1, "rpages is %d for sync page of Index %ld", rpages, index);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667
NeilBrown3978d7172006-03-26 01:37:17 -08001668#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001669 if (rc < 0)
1670 return rc;
1671 return 0;
NeilBrown3978d7172006-03-26 01:37:17 -08001672#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673} */
1674
1675/*
1676 * As file closes, flush all cached write data for this inode checking
1677 * for write behind errors.
1678 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001679int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001680{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001681 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001682 int rc = 0;
1683
Jeff Laytoneb4b7562010-10-22 14:52:29 -04001684 if (file->f_mode & FMODE_WRITE)
Jeff Laytond3f13222010-10-15 15:34:07 -04001685 rc = filemap_write_and_wait(inode->i_mapping);
Steve French50c2f752007-07-13 00:33:32 +00001686
Joe Perchesb6b38f72010-04-21 03:50:45 +00001687 cFYI(1, "Flush inode %p file %p rc %d", inode, file, rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688
1689 return rc;
1690}
1691
1692ssize_t cifs_user_read(struct file *file, char __user *read_data,
1693 size_t read_size, loff_t *poffset)
1694{
1695 int rc = -EACCES;
1696 unsigned int bytes_read = 0;
1697 unsigned int total_read = 0;
1698 unsigned int current_read_size;
1699 struct cifs_sb_info *cifs_sb;
1700 struct cifsTconInfo *pTcon;
1701 int xid;
1702 struct cifsFileInfo *open_file;
1703 char *smb_read_data;
1704 char __user *current_offset;
1705 struct smb_com_read_rsp *pSMBr;
1706
1707 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001708 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001709
1710 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301711 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301713 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07001715 open_file = file->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -04001716 pTcon = tlink_tcon(open_file->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
Steve Frenchad7a2922008-02-07 23:25:02 +00001718 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001719 cFYI(1, "attempting read on write only file instance");
Steve Frenchad7a2922008-02-07 23:25:02 +00001720
Linus Torvalds1da177e2005-04-16 15:20:36 -07001721 for (total_read = 0, current_offset = read_data;
1722 read_size > total_read;
1723 total_read += bytes_read, current_offset += bytes_read) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001724 current_read_size = min_t(const int, read_size - total_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 cifs_sb->rsize);
1726 rc = -EAGAIN;
1727 smb_read_data = NULL;
1728 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001729 int buf_type = CIFS_NO_BUFFER;
Steve Frenchcdff08e2010-10-21 22:46:14 +00001730 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04001731 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732 if (rc != 0)
1733 break;
1734 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001735 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001736 open_file->netfid,
1737 current_read_size, *poffset,
1738 &bytes_read, &smb_read_data,
1739 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001741 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001742 if (copy_to_user(current_offset,
1743 smb_read_data +
1744 4 /* RFC1001 length field */ +
1745 le16_to_cpu(pSMBr->DataOffset),
Steve Frenchad7a2922008-02-07 23:25:02 +00001746 bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06001747 rc = -EFAULT;
Steve French93544cc2006-02-14 22:30:52 -06001748
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001749 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001750 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001751 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001752 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001753 smb_read_data = NULL;
1754 }
1755 }
1756 if (rc || (bytes_read == 0)) {
1757 if (total_read) {
1758 break;
1759 } else {
1760 FreeXid(xid);
1761 return rc;
1762 }
1763 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001764 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 *poffset += bytes_read;
1766 }
1767 }
1768 FreeXid(xid);
1769 return total_read;
1770}
1771
1772
1773static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1774 loff_t *poffset)
1775{
1776 int rc = -EACCES;
1777 unsigned int bytes_read = 0;
1778 unsigned int total_read;
1779 unsigned int current_read_size;
1780 struct cifs_sb_info *cifs_sb;
1781 struct cifsTconInfo *pTcon;
1782 int xid;
1783 char *current_offset;
1784 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001785 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786
1787 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001788 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
1790 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301791 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301793 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07001795 open_file = file->private_data;
Jeff Layton13cfb732010-09-29 19:51:11 -04001796 pTcon = tlink_tcon(open_file->tlink);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001797
1798 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Joe Perchesb6b38f72010-04-21 03:50:45 +00001799 cFYI(1, "attempting read on write only file instance");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001800
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001801 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001802 read_size > total_read;
1803 total_read += bytes_read, current_offset += bytes_read) {
1804 current_read_size = min_t(const int, read_size - total_read,
1805 cifs_sb->rsize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001806 /* For windows me and 9x we do not want to request more
1807 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001808 if ((pTcon->ses) &&
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001809 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1810 current_read_size = min_t(const int, current_read_size,
1811 pTcon->ses->server->maxBuf - 128);
1812 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 rc = -EAGAIN;
1814 while (rc == -EAGAIN) {
Steve Frenchcdff08e2010-10-21 22:46:14 +00001815 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04001816 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817 if (rc != 0)
1818 break;
1819 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001820 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001821 open_file->netfid,
1822 current_read_size, *poffset,
1823 &bytes_read, &current_offset,
1824 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825 }
1826 if (rc || (bytes_read == 0)) {
1827 if (total_read) {
1828 break;
1829 } else {
1830 FreeXid(xid);
1831 return rc;
1832 }
1833 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001834 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001835 *poffset += bytes_read;
1836 }
1837 }
1838 FreeXid(xid);
1839 return total_read;
1840}
1841
1842int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1843{
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 int rc, xid;
1845
1846 xid = GetXid();
Jeff Laytonabab0952010-02-12 07:44:18 -05001847 rc = cifs_revalidate_file(file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 if (rc) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00001849 cFYI(1, "Validation prior to mmap failed, error=%d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 FreeXid(xid);
1851 return rc;
1852 }
1853 rc = generic_file_mmap(file, vma);
1854 FreeXid(xid);
1855 return rc;
1856}
1857
1858
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001859static void cifs_copy_cache_pages(struct address_space *mapping,
Nick Piggin315e9952010-04-21 03:18:28 +00001860 struct list_head *pages, int bytes_read, char *data)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001861{
1862 struct page *page;
1863 char *target;
1864
1865 while (bytes_read > 0) {
1866 if (list_empty(pages))
1867 break;
1868
1869 page = list_entry(pages->prev, struct page, lru);
1870 list_del(&page->lru);
1871
Nick Piggin315e9952010-04-21 03:18:28 +00001872 if (add_to_page_cache_lru(page, mapping, page->index,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873 GFP_KERNEL)) {
1874 page_cache_release(page);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001875 cFYI(1, "Add page cache failed");
Steve French3079ca62005-06-09 14:44:07 -07001876 data += PAGE_CACHE_SIZE;
1877 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 continue;
1879 }
Jeff Layton06b43672010-06-01 10:54:45 -04001880 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001881
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001882 target = kmap_atomic(page, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001883
1884 if (PAGE_CACHE_SIZE > bytes_read) {
1885 memcpy(target, data, bytes_read);
1886 /* zero the tail end of this partial page */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001887 memset(target + bytes_read, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 PAGE_CACHE_SIZE - bytes_read);
1889 bytes_read = 0;
1890 } else {
1891 memcpy(target, data, PAGE_CACHE_SIZE);
1892 bytes_read -= PAGE_CACHE_SIZE;
1893 }
1894 kunmap_atomic(target, KM_USER0);
1895
1896 flush_dcache_page(page);
1897 SetPageUptodate(page);
1898 unlock_page(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 data += PAGE_CACHE_SIZE;
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05301900
1901 /* add page to FS-Cache */
1902 cifs_readpage_to_fscache(mapping->host, page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903 }
1904 return;
1905}
1906
1907static int cifs_readpages(struct file *file, struct address_space *mapping,
1908 struct list_head *page_list, unsigned num_pages)
1909{
1910 int rc = -EACCES;
1911 int xid;
1912 loff_t offset;
1913 struct page *page;
1914 struct cifs_sb_info *cifs_sb;
1915 struct cifsTconInfo *pTcon;
Steve French2c2130e2007-10-12 19:10:28 +00001916 unsigned int bytes_read = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001917 unsigned int read_size, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001918 char *smb_read_data = NULL;
1919 struct smb_com_read_rsp *pSMBr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001921 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922
1923 xid = GetXid();
1924 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301925 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05301927 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001928 }
Joe Perchesc21dfb62010-07-12 13:50:14 -07001929 open_file = file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001930 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Jeff Layton13cfb732010-09-29 19:51:11 -04001931 pTcon = tlink_tcon(open_file->tlink);
Steve Frenchbfa0d752005-08-31 21:50:37 -07001932
Suresh Jayaraman56698232010-07-05 18:13:25 +05301933 /*
1934 * Reads as many pages as possible from fscache. Returns -ENOBUFS
1935 * immediately if the cookie is negative
1936 */
1937 rc = cifs_readpages_from_fscache(mapping->host, mapping, page_list,
1938 &num_pages);
1939 if (rc == 0)
1940 goto read_complete;
1941
Steve Frenchf19159d2010-04-21 04:12:10 +00001942 cFYI(DBG2, "rpages: num pages %d", num_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001943 for (i = 0; i < num_pages; ) {
1944 unsigned contig_pages;
1945 struct page *tmp_page;
1946 unsigned long expected_index;
1947
1948 if (list_empty(page_list))
1949 break;
1950
1951 page = list_entry(page_list->prev, struct page, lru);
1952 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1953
1954 /* count adjacent pages that we will read into */
1955 contig_pages = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001956 expected_index =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001957 list_entry(page_list->prev, struct page, lru)->index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001958 list_for_each_entry_reverse(tmp_page, page_list, lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001959 if (tmp_page->index == expected_index) {
1960 contig_pages++;
1961 expected_index++;
1962 } else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001963 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964 }
1965 if (contig_pages + i > num_pages)
1966 contig_pages = num_pages - i;
1967
1968 /* for reads over a certain size could initiate async
1969 read ahead */
1970
1971 read_size = contig_pages * PAGE_CACHE_SIZE;
1972 /* Read size needs to be in multiples of one page */
1973 read_size = min_t(const unsigned int, read_size,
1974 cifs_sb->rsize & PAGE_CACHE_MASK);
Joe Perchesb6b38f72010-04-21 03:50:45 +00001975 cFYI(DBG2, "rpages: read size 0x%x contiguous pages %d",
1976 read_size, contig_pages);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001977 rc = -EAGAIN;
1978 while (rc == -EAGAIN) {
Steve Frenchcdff08e2010-10-21 22:46:14 +00001979 if (open_file->invalidHandle) {
Jeff Layton15886172010-10-15 15:33:59 -04001980 rc = cifs_reopen_file(open_file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001981 if (rc != 0)
1982 break;
1983 }
1984
Steve Frenchbfa0d752005-08-31 21:50:37 -07001985 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001986 open_file->netfid,
1987 read_size, offset,
1988 &bytes_read, &smb_read_data,
1989 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001990 /* BB more RC checks ? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001991 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001992 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001993 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001994 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001995 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001996 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001997 smb_read_data = NULL;
1998 }
1999 }
2000 }
2001 if ((rc < 0) || (smb_read_data == NULL)) {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002002 cFYI(1, "Read error in readpages: %d", rc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002003 break;
2004 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08002005 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002006 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
2007 cifs_copy_cache_pages(mapping, page_list, bytes_read,
2008 smb_read_data + 4 /* RFC1001 hdr */ +
Nick Piggin315e9952010-04-21 03:18:28 +00002009 le16_to_cpu(pSMBr->DataOffset));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002010
2011 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07002012 cifs_stats_bytes_read(pTcon, bytes_read);
Steve French2c2130e2007-10-12 19:10:28 +00002013 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002014 i++; /* account for partial page */
2015
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002016 /* server copy of file can have smaller size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002017 than client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002018 /* BB do we need to verify this common case ?
2019 this case is ok - if we are at server EOF
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 we will hit it on next read */
2021
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08002022 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002023 }
2024 } else {
Joe Perchesb6b38f72010-04-21 03:50:45 +00002025 cFYI(1, "No bytes read (%d) at offset %lld . "
Steve Frenchf19159d2010-04-21 04:12:10 +00002026 "Cleaning remaining pages from readahead list",
Joe Perchesb6b38f72010-04-21 03:50:45 +00002027 bytes_read, offset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002028 /* BB turn off caching and do new lookup on
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030 break;
2031 }
2032 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002033 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002034 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002035 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08002036 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037 smb_read_data = NULL;
2038 }
2039 bytes_read = 0;
2040 }
2041
Linus Torvalds1da177e2005-04-16 15:20:36 -07002042/* need to free smb_read_data buf before exit */
2043 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002044 if (buf_type == CIFS_SMALL_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002045 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002046 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08002047 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002048 smb_read_data = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002049 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002050
Suresh Jayaraman56698232010-07-05 18:13:25 +05302051read_complete:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002052 FreeXid(xid);
2053 return rc;
2054}
2055
2056static int cifs_readpage_worker(struct file *file, struct page *page,
2057 loff_t *poffset)
2058{
2059 char *read_data;
2060 int rc;
2061
Suresh Jayaraman56698232010-07-05 18:13:25 +05302062 /* Is the page cached? */
2063 rc = cifs_readpage_from_fscache(file->f_path.dentry->d_inode, page);
2064 if (rc == 0)
2065 goto read_complete;
2066
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067 page_cache_get(page);
2068 read_data = kmap(page);
2069 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002070
Linus Torvalds1da177e2005-04-16 15:20:36 -07002071 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002072
Linus Torvalds1da177e2005-04-16 15:20:36 -07002073 if (rc < 0)
2074 goto io_error;
2075 else
Joe Perchesb6b38f72010-04-21 03:50:45 +00002076 cFYI(1, "Bytes read %d", rc);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002077
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08002078 file->f_path.dentry->d_inode->i_atime =
2079 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002080
Linus Torvalds1da177e2005-04-16 15:20:36 -07002081 if (PAGE_CACHE_SIZE > rc)
2082 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
2083
2084 flush_dcache_page(page);
2085 SetPageUptodate(page);
Suresh Jayaraman9dc06552010-07-05 18:13:11 +05302086
2087 /* send this page to the cache */
2088 cifs_readpage_to_fscache(file->f_path.dentry->d_inode, page);
2089
Linus Torvalds1da177e2005-04-16 15:20:36 -07002090 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002091
Linus Torvalds1da177e2005-04-16 15:20:36 -07002092io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002093 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002094 page_cache_release(page);
Suresh Jayaraman56698232010-07-05 18:13:25 +05302095
2096read_complete:
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 return rc;
2098}
2099
2100static int cifs_readpage(struct file *file, struct page *page)
2101{
2102 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
2103 int rc = -EACCES;
2104 int xid;
2105
2106 xid = GetXid();
2107
2108 if (file->private_data == NULL) {
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302109 rc = -EBADF;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002110 FreeXid(xid);
Suresh Jayaraman0f3bc092009-06-25 18:12:34 +05302111 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002112 }
2113
Joe Perchesb6b38f72010-04-21 03:50:45 +00002114 cFYI(1, "readpage %p at offset %d 0x%x\n",
2115 page, (int)offset, (int)offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002116
2117 rc = cifs_readpage_worker(file, page, &offset);
2118
2119 unlock_page(page);
2120
2121 FreeXid(xid);
2122 return rc;
2123}
2124
Steve Frencha403a0a2007-07-26 15:54:16 +00002125static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2126{
2127 struct cifsFileInfo *open_file;
2128
Jeff Layton44772882010-10-15 15:34:03 -04002129 spin_lock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00002130 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2e396b82010-10-15 15:34:01 -04002131 if (OPEN_FMODE(open_file->f_flags) & FMODE_WRITE) {
Jeff Layton44772882010-10-15 15:34:03 -04002132 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00002133 return 1;
2134 }
2135 }
Jeff Layton44772882010-10-15 15:34:03 -04002136 spin_unlock(&cifs_file_list_lock);
Steve Frencha403a0a2007-07-26 15:54:16 +00002137 return 0;
2138}
2139
Linus Torvalds1da177e2005-04-16 15:20:36 -07002140/* We do not want to update the file size from server for inodes
2141 open for write - to avoid races with writepage extending
2142 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002143 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002144 but this is tricky to do without racing with writebehind
2145 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00002146bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002147{
Steve Frencha403a0a2007-07-26 15:54:16 +00002148 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00002149 return true;
Steve French23e7dd72005-10-20 13:44:56 -07002150
Steve Frencha403a0a2007-07-26 15:54:16 +00002151 if (is_inode_writable(cifsInode)) {
2152 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002153 struct cifs_sb_info *cifs_sb;
2154
Steve Frenchc32a0b62006-01-12 14:41:28 -08002155 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002156 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002157 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002158 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00002159 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08002160 }
2161
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002162 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00002163 return true;
Steve French7ba52632007-02-08 18:14:13 +00002164
Steve French4b18f2a2008-04-29 00:06:05 +00002165 return false;
Steve French23e7dd72005-10-20 13:44:56 -07002166 } else
Steve French4b18f2a2008-04-29 00:06:05 +00002167 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002168}
2169
Nick Piggind9414772008-09-24 11:32:59 -04002170static int cifs_write_begin(struct file *file, struct address_space *mapping,
2171 loff_t pos, unsigned len, unsigned flags,
2172 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002173{
Nick Piggind9414772008-09-24 11:32:59 -04002174 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2175 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002176 loff_t page_start = pos & PAGE_MASK;
2177 loff_t i_size;
2178 struct page *page;
2179 int rc = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002180
Joe Perchesb6b38f72010-04-21 03:50:45 +00002181 cFYI(1, "write_begin from %lld len %d", (long long)pos, len);
Nick Piggind9414772008-09-24 11:32:59 -04002182
Nick Piggin54566b22009-01-04 12:00:53 -08002183 page = grab_cache_page_write_begin(mapping, index, flags);
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002184 if (!page) {
2185 rc = -ENOMEM;
2186 goto out;
2187 }
Nick Piggind9414772008-09-24 11:32:59 -04002188
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002189 if (PageUptodate(page))
2190 goto out;
Steve French8a236262007-03-06 00:31:00 +00002191
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002192 /*
2193 * If we write a full page it will be up to date, no need to read from
2194 * the server. If the write is short, we'll end up doing a sync write
2195 * instead.
2196 */
2197 if (len == PAGE_CACHE_SIZE)
2198 goto out;
2199
2200 /*
2201 * optimize away the read when we have an oplock, and we're not
2202 * expecting to use any of the data we'd be reading in. That
2203 * is, when the page lies beyond the EOF, or straddles the EOF
2204 * and the write will cover all of the existing data.
2205 */
2206 if (CIFS_I(mapping->host)->clientCanCacheRead) {
2207 i_size = i_size_read(mapping->host);
2208 if (page_start >= i_size ||
2209 (offset == 0 && (pos + len) >= i_size)) {
2210 zero_user_segments(page, 0, offset,
2211 offset + len,
2212 PAGE_CACHE_SIZE);
2213 /*
2214 * PageChecked means that the parts of the page
2215 * to which we're not writing are considered up
2216 * to date. Once the data is copied to the
2217 * page, it can be set uptodate.
2218 */
2219 SetPageChecked(page);
2220 goto out;
2221 }
2222 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223
Nick Piggind9414772008-09-24 11:32:59 -04002224 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002225 /*
2226 * might as well read a page, it is fast enough. If we get
2227 * an error, we don't need to return it. cifs_write_end will
2228 * do a sync write instead since PG_uptodate isn't set.
2229 */
2230 cifs_readpage_worker(file, page, &page_start);
Steve French8a236262007-03-06 00:31:00 +00002231 } else {
2232 /* we could try using another file handle if there is one -
2233 but how would we lock it to prevent close of that handle
2234 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04002235 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00002236 }
Jeff Laytona98ee8c2008-11-26 19:32:33 +00002237out:
2238 *pagep = page;
2239 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240}
2241
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05302242static int cifs_release_page(struct page *page, gfp_t gfp)
2243{
2244 if (PagePrivate(page))
2245 return 0;
2246
2247 return cifs_fscache_release_page(page, gfp);
2248}
2249
2250static void cifs_invalidate_page(struct page *page, unsigned long offset)
2251{
2252 struct cifsInodeInfo *cifsi = CIFS_I(page->mapping->host);
2253
2254 if (offset == 0)
2255 cifs_fscache_invalidate_page(page, &cifsi->vfs_inode);
2256}
2257
Tejun Heo9b646972010-07-20 22:09:02 +02002258void cifs_oplock_break(struct work_struct *work)
Jeff Layton3bc303c2009-09-21 06:47:50 -04002259{
2260 struct cifsFileInfo *cfile = container_of(work, struct cifsFileInfo,
2261 oplock_break);
Jeff Laytona5e18bc2010-10-11 15:07:18 -04002262 struct inode *inode = cfile->dentry->d_inode;
Jeff Layton3bc303c2009-09-21 06:47:50 -04002263 struct cifsInodeInfo *cinode = CIFS_I(inode);
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002264 int rc = 0;
Jeff Layton3bc303c2009-09-21 06:47:50 -04002265
2266 if (inode && S_ISREG(inode->i_mode)) {
Steve Frenchd54ff732010-04-27 04:38:15 +00002267 if (cinode->clientCanCacheRead)
Al Viro8737c932009-12-24 06:47:55 -05002268 break_lease(inode, O_RDONLY);
Steve Frenchd54ff732010-04-27 04:38:15 +00002269 else
Al Viro8737c932009-12-24 06:47:55 -05002270 break_lease(inode, O_WRONLY);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002271 rc = filemap_fdatawrite(inode->i_mapping);
2272 if (cinode->clientCanCacheRead == 0) {
Jeff Laytoneb4b7562010-10-22 14:52:29 -04002273 rc = filemap_fdatawait(inode->i_mapping);
2274 mapping_set_error(inode->i_mapping, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002275 invalidate_remote_inode(inode);
2276 }
Joe Perchesb6b38f72010-04-21 03:50:45 +00002277 cFYI(1, "Oplock flush inode %p rc %d", inode, rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002278 }
2279
2280 /*
2281 * releasing stale oplock after recent reconnect of smb session using
2282 * a now incorrect file handle is not a data integrity issue but do
2283 * not bother sending an oplock release if session to server still is
2284 * disconnected since oplock already released by the server
2285 */
Steve Frenchcdff08e2010-10-21 22:46:14 +00002286 if (!cfile->oplock_break_cancelled) {
Jeff Layton13cfb732010-09-29 19:51:11 -04002287 rc = CIFSSMBLock(0, tlink_tcon(cfile->tlink), cfile->netfid, 0,
2288 0, 0, 0, LOCKING_ANDX_OPLOCK_RELEASE, false);
Joe Perchesb6b38f72010-04-21 03:50:45 +00002289 cFYI(1, "Oplock release rc = %d", rc);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002290 }
Tejun Heo9b646972010-07-20 22:09:02 +02002291
2292 /*
2293 * We might have kicked in before is_valid_oplock_break()
2294 * finished grabbing reference for us. Make sure it's done by
Suresh Jayaraman6573e9b2010-10-18 23:52:18 +05302295 * waiting for cifs_file_list_lock.
Tejun Heo9b646972010-07-20 22:09:02 +02002296 */
Jeff Layton44772882010-10-15 15:34:03 -04002297 spin_lock(&cifs_file_list_lock);
2298 spin_unlock(&cifs_file_list_lock);
Tejun Heo9b646972010-07-20 22:09:02 +02002299
2300 cifs_oplock_break_put(cfile);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002301}
2302
Jeff Layton5f6dbc92010-10-15 15:34:06 -04002303/* must be called while holding cifs_file_list_lock */
Tejun Heo9b646972010-07-20 22:09:02 +02002304void cifs_oplock_break_get(struct cifsFileInfo *cfile)
Jeff Layton3bc303c2009-09-21 06:47:50 -04002305{
Jeff Laytond7c86ff2010-10-11 15:07:19 -04002306 cifs_sb_active(cfile->dentry->d_sb);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002307 cifsFileInfo_get(cfile);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002308}
2309
Tejun Heo9b646972010-07-20 22:09:02 +02002310void cifs_oplock_break_put(struct cifsFileInfo *cfile)
Jeff Layton3bc303c2009-09-21 06:47:50 -04002311{
Jeff Layton3bc303c2009-09-21 06:47:50 -04002312 cifsFileInfo_put(cfile);
Jeff Laytond7c86ff2010-10-11 15:07:19 -04002313 cifs_sb_deactive(cfile->dentry->d_sb);
Jeff Layton3bc303c2009-09-21 06:47:50 -04002314}
2315
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002316const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317 .readpage = cifs_readpage,
2318 .readpages = cifs_readpages,
2319 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002320 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002321 .write_begin = cifs_write_begin,
2322 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002323 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05302324 .releasepage = cifs_release_page,
2325 .invalidatepage = cifs_invalidate_page,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002326 /* .sync_page = cifs_sync_page, */
2327 /* .direct_IO = */
2328};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002329
2330/*
2331 * cifs_readpages requires the server to support a buffer large enough to
2332 * contain the header plus one complete page of data. Otherwise, we need
2333 * to leave cifs_readpages out of the address space operations.
2334 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002335const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002336 .readpage = cifs_readpage,
2337 .writepage = cifs_writepage,
2338 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002339 .write_begin = cifs_write_begin,
2340 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002341 .set_page_dirty = __set_page_dirty_nobuffers,
Suresh Jayaraman85f2d6b2010-07-05 18:13:00 +05302342 .releasepage = cifs_release_page,
2343 .invalidatepage = cifs_invalidate_page,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002344 /* .sync_page = cifs_sync_page, */
2345 /* .direct_IO = */
2346};