blob: b691b893a848a8d4d74c1e0ecce800d561b99b67 [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 *
6 * Copyright (C) International Business Machines Corp., 2002,2007
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>
Linus Torvalds1da177e2005-04-16 15:20:36 -070033#include <asm/div64.h>
34#include "cifsfs.h"
35#include "cifspdu.h"
36#include "cifsglob.h"
37#include "cifsproto.h"
38#include "cifs_unicode.h"
39#include "cifs_debug.h"
40#include "cifs_fs_sb.h"
41
42static inline struct cifsFileInfo *cifs_init_private(
43 struct cifsFileInfo *private_data, struct inode *inode,
44 struct file *file, __u16 netfid)
45{
46 memset(private_data, 0, sizeof(struct cifsFileInfo));
47 private_data->netfid = netfid;
Steve Frenchfb8c4b12007-07-10 01:16:18 +000048 private_data->pid = current->tgid;
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 init_MUTEX(&private_data->fh_sem);
Roland Dreier796e5662007-05-03 04:33:45 +000050 mutex_init(&private_data->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +000051 INIT_LIST_HEAD(&private_data->llist);
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 private_data->pfile = file; /* needed for writepage */
53 private_data->pInode = inode;
Steve French4b18f2a2008-04-29 00:06:05 +000054 private_data->invalidHandle = false;
55 private_data->closePend = false;
Steve French23e7dd72005-10-20 13:44:56 -070056 /* we have to track num writers to the inode, since writepages
57 does not tell us which handle the write is for so there can
58 be a close (overlapping with write) of the filehandle that
59 cifs_writepages chose to use */
Steve Frenchfb8c4b12007-07-10 01:16:18 +000060 atomic_set(&private_data->wrtPending, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070061
62 return private_data;
63}
64
65static inline int cifs_convert_flags(unsigned int flags)
66{
67 if ((flags & O_ACCMODE) == O_RDONLY)
68 return GENERIC_READ;
69 else if ((flags & O_ACCMODE) == O_WRONLY)
70 return GENERIC_WRITE;
71 else if ((flags & O_ACCMODE) == O_RDWR) {
72 /* GENERIC_ALL is too much permission to request
73 can cause unnecessary access denied on create */
74 /* return GENERIC_ALL; */
75 return (GENERIC_READ | GENERIC_WRITE);
76 }
77
Jeff Laytone10f7b52008-05-14 10:21:33 -070078 return (READ_CONTROL | FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES |
79 FILE_WRITE_EA | FILE_APPEND_DATA | FILE_WRITE_DATA |
80 FILE_READ_DATA);
81
82
Linus Torvalds1da177e2005-04-16 15:20:36 -070083}
84
85static inline int cifs_get_disposition(unsigned int flags)
86{
87 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
88 return FILE_CREATE;
89 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
90 return FILE_OVERWRITE_IF;
91 else if ((flags & O_CREAT) == O_CREAT)
92 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +000093 else if ((flags & O_TRUNC) == O_TRUNC)
94 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070095 else
96 return FILE_OPEN;
97}
98
99/* all arguments to this function must be checked for validity in caller */
100static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
101 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
102 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
103 char *full_path, int xid)
104{
105 struct timespec temp;
106 int rc;
107
108 /* want handles we can use to read with first
109 in the list so we do not have to walk the
Nick Piggind9414772008-09-24 11:32:59 -0400110 list to search for one in write_begin */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000112 list_add_tail(&pCifsFile->flist,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 &pCifsInode->openFileList);
114 } else {
115 list_add(&pCifsFile->flist,
116 &pCifsInode->openFileList);
117 }
118 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119 if (pCifsInode->clientCanCacheRead) {
120 /* we have the inode open somewhere else
121 no need to discard cache data */
122 goto client_can_cache;
123 }
124
125 /* BB need same check in cifs_create too? */
126 /* if not oplocked, invalidate inode pages if mtime or file
127 size changed */
128 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800129 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
130 (file->f_path.dentry->d_inode->i_size ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 (loff_t)le64_to_cpu(buf->EndOfFile))) {
132 cFYI(1, ("inode unchanged on server"));
133 } else {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800134 if (file->f_path.dentry->d_inode->i_mapping) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 /* BB no need to lock inode until after invalidate
136 since namei code should already have it locked? */
Jeff Laytoncea21802007-11-20 23:19:03 +0000137 rc = filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
138 if (rc != 0)
139 CIFS_I(file->f_path.dentry->d_inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700140 }
141 cFYI(1, ("invalidating remote inode since open detected it "
142 "changed"));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800143 invalidate_remote_inode(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 }
145
146client_can_cache:
Steve Frenchc18c8422007-07-18 23:21:09 +0000147 if (pTcon->unix_ext)
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800148 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700149 full_path, inode->i_sb, xid);
150 else
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800151 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
Steve French8b1327f2008-03-14 22:37:16 +0000152 full_path, buf, inode->i_sb, xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700153
154 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000155 pCifsInode->clientCanCacheAll = true;
156 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800158 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159 } else if ((*oplock & 0xF) == OPLOCK_READ)
Steve French4b18f2a2008-04-29 00:06:05 +0000160 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161
162 return rc;
163}
164
165int cifs_open(struct inode *inode, struct file *file)
166{
167 int rc = -EACCES;
168 int xid, oplock;
169 struct cifs_sb_info *cifs_sb;
170 struct cifsTconInfo *pTcon;
171 struct cifsFileInfo *pCifsFile;
172 struct cifsInodeInfo *pCifsInode;
173 struct list_head *tmp;
174 char *full_path = NULL;
175 int desiredAccess;
176 int disposition;
177 __u16 netfid;
178 FILE_ALL_INFO *buf = NULL;
179
180 xid = GetXid();
181
182 cifs_sb = CIFS_SB(inode->i_sb);
183 pTcon = cifs_sb->tcon;
184
185 if (file->f_flags & O_CREAT) {
186 /* search inode for this file and fill in file->private_data */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800187 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 read_lock(&GlobalSMBSeslock);
189 list_for_each(tmp, &pCifsInode->openFileList) {
190 pCifsFile = list_entry(tmp, struct cifsFileInfo,
191 flist);
192 if ((pCifsFile->pfile == NULL) &&
193 (pCifsFile->pid == current->tgid)) {
194 /* mode set in cifs_create */
195
196 /* needed for writepage */
197 pCifsFile->pfile = file;
Steve French50c2f752007-07-13 00:33:32 +0000198
Linus Torvalds1da177e2005-04-16 15:20:36 -0700199 file->private_data = pCifsFile;
200 break;
201 }
202 }
203 read_unlock(&GlobalSMBSeslock);
204 if (file->private_data != NULL) {
205 rc = 0;
206 FreeXid(xid);
207 return rc;
208 } else {
209 if (file->f_flags & O_EXCL)
210 cERROR(1, ("could not find file instance for "
Steve French26a21b92006-05-31 18:05:34 +0000211 "new file %p", file));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 }
213 }
214
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800215 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700216 if (full_path == NULL) {
217 FreeXid(xid);
218 return -ENOMEM;
219 }
220
Steve French7521a3c2007-07-11 18:30:34 +0000221 cFYI(1, ("inode = 0x%p file flags are 0x%x for %s",
Linus Torvalds1da177e2005-04-16 15:20:36 -0700222 inode, file->f_flags, full_path));
223 desiredAccess = cifs_convert_flags(file->f_flags);
224
225/*********************************************************************
226 * open flag mapping table:
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000227 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700228 * POSIX Flag CIFS Disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000229 * ---------- ----------------
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230 * O_CREAT FILE_OPEN_IF
231 * O_CREAT | O_EXCL FILE_CREATE
232 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
233 * O_TRUNC FILE_OVERWRITE
234 * none of the above FILE_OPEN
235 *
236 * Note that there is not a direct match between disposition
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000237 * FILE_SUPERSEDE (ie create whether or not file exists although
Linus Torvalds1da177e2005-04-16 15:20:36 -0700238 * O_CREAT | O_TRUNC is similar but truncates the existing
239 * file rather than creating a new file as FILE_SUPERSEDE does
240 * (which uses the attributes / metadata passed in on open call)
241 *?
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000242 *? O_SYNC is a reasonable match to CIFS writethrough flag
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 *? and the read write flags match reasonably. O_LARGEFILE
244 *? is irrelevant because largefile support is always used
245 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
246 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
247 *********************************************************************/
248
249 disposition = cifs_get_disposition(file->f_flags);
250
251 if (oplockEnabled)
252 oplock = REQ_OPLOCK;
253 else
Steve French4b18f2a2008-04-29 00:06:05 +0000254 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255
256 /* BB pass O_SYNC flag through on file attributes .. BB */
257
258 /* Also refresh inode by passing in file_info buf returned by SMBOpen
259 and calling get_inode_info with returned buf (at least helps
260 non-Unix server case) */
261
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000262 /* BB we can not do this if this is the second open of a file
263 and the first handle has writebehind data, we might be
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
265 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
266 if (!buf) {
267 rc = -ENOMEM;
268 goto out;
269 }
Steve French5bafd762006-06-07 00:18:43 +0000270
271 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000272 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
Steve French5bafd762006-06-07 00:18:43 +0000273 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
Steve French737b7582005-04-28 22:41:06 -0700274 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
275 & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000276 else
277 rc = -EIO; /* no NT SMB support fall into legacy open below */
278
Steve Frencha9d02ad2005-08-24 23:06:05 -0700279 if (rc == -EIO) {
280 /* Old server, try legacy style OpenX */
281 rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
282 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
283 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
284 & CIFS_MOUNT_MAP_SPECIAL_CHR);
285 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700286 if (rc) {
Steve French26a21b92006-05-31 18:05:34 +0000287 cFYI(1, ("cifs_open returned 0x%x", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 goto out;
289 }
290 file->private_data =
291 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
292 if (file->private_data == NULL) {
293 rc = -ENOMEM;
294 goto out;
295 }
296 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700297 write_lock(&GlobalSMBSeslock);
298 list_add(&pCifsFile->tlist, &pTcon->openFileList);
299
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800300 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301 if (pCifsInode) {
302 rc = cifs_open_inode_helper(inode, file, pCifsInode,
303 pCifsFile, pTcon,
304 &oplock, buf, full_path, xid);
305 } else {
306 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700307 }
308
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000309 if (oplock & CIFS_CREATE_ACTION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700310 /* time to set mode which we can not set earlier due to
311 problems creating new read-only files */
Steve Frenchc18c8422007-07-18 23:21:09 +0000312 if (pTcon->unix_ext) {
Jeff Layton4e1e7fb2008-08-02 07:26:12 -0400313 struct cifs_unix_set_info_args args = {
314 .mode = inode->i_mode,
315 .uid = NO_CHANGE_64,
316 .gid = NO_CHANGE_64,
317 .ctime = NO_CHANGE_64,
318 .atime = NO_CHANGE_64,
319 .mtime = NO_CHANGE_64,
320 .device = 0,
321 };
322 CIFSSMBUnixSetInfo(xid, pTcon, full_path, &args,
Steve French737b7582005-04-28 22:41:06 -0700323 cifs_sb->local_nls,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000324 cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700325 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700326 }
327 }
328
329out:
330 kfree(buf);
331 kfree(full_path);
332 FreeXid(xid);
333 return rc;
334}
335
Adrian Bunk04187262006-06-30 18:23:04 +0200336/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700337/* to server was lost */
338static int cifs_relock_file(struct cifsFileInfo *cifsFile)
339{
340 int rc = 0;
341
342/* BB list all locks open on this file and relock */
343
344 return rc;
345}
346
Steve French4b18f2a2008-04-29 00:06:05 +0000347static int cifs_reopen_file(struct file *file, bool can_flush)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348{
349 int rc = -EACCES;
350 int xid, oplock;
351 struct cifs_sb_info *cifs_sb;
352 struct cifsTconInfo *pTcon;
353 struct cifsFileInfo *pCifsFile;
354 struct cifsInodeInfo *pCifsInode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000355 struct inode *inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356 char *full_path = NULL;
357 int desiredAccess;
358 int disposition = FILE_OPEN;
359 __u16 netfid;
360
Steve Frenchad7a2922008-02-07 23:25:02 +0000361 if (file->private_data)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700362 pCifsFile = (struct cifsFileInfo *)file->private_data;
Steve Frenchad7a2922008-02-07 23:25:02 +0000363 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364 return -EBADF;
365
366 xid = GetXid();
367 down(&pCifsFile->fh_sem);
Steve French4b18f2a2008-04-29 00:06:05 +0000368 if (!pCifsFile->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 up(&pCifsFile->fh_sem);
370 FreeXid(xid);
371 return 0;
372 }
373
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800374 if (file->f_path.dentry == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000375 cERROR(1, ("no valid name if dentry freed"));
376 dump_stack();
377 rc = -EBADF;
378 goto reopen_error_exit;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700379 }
Steve French3a9f4622007-04-04 17:10:24 +0000380
381 inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000382 if (inode == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000383 cERROR(1, ("inode not valid"));
384 dump_stack();
385 rc = -EBADF;
386 goto reopen_error_exit;
387 }
Steve French50c2f752007-07-13 00:33:32 +0000388
Linus Torvalds1da177e2005-04-16 15:20:36 -0700389 cifs_sb = CIFS_SB(inode->i_sb);
390 pTcon = cifs_sb->tcon;
Steve French3a9f4622007-04-04 17:10:24 +0000391
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392/* can not grab rename sem here because various ops, including
393 those that already have the rename sem can end up causing writepage
394 to get called and if the server was down that means we end up here,
395 and we can never tell if the caller already has the rename_sem */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800396 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700397 if (full_path == NULL) {
Steve French3a9f4622007-04-04 17:10:24 +0000398 rc = -ENOMEM;
399reopen_error_exit:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 up(&pCifsFile->fh_sem);
401 FreeXid(xid);
Steve French3a9f4622007-04-04 17:10:24 +0000402 return rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403 }
404
Steve French3a9f4622007-04-04 17:10:24 +0000405 cFYI(1, ("inode = 0x%p file flags 0x%x for %s",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000406 inode, file->f_flags, full_path));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700407 desiredAccess = cifs_convert_flags(file->f_flags);
408
409 if (oplockEnabled)
410 oplock = REQ_OPLOCK;
411 else
Steve French4b18f2a2008-04-29 00:06:05 +0000412 oplock = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700413
414 /* Can not refresh inode by passing in file_info buf to be returned
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000415 by SMBOpen and then calling get_inode_info with returned buf
416 since file might have write behind data that needs to be flushed
Linus Torvalds1da177e2005-04-16 15:20:36 -0700417 and server version of file size can be stale. If we knew for sure
418 that inode was not dirty locally we could do this */
419
Linus Torvalds1da177e2005-04-16 15:20:36 -0700420 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
421 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000422 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
Steve French737b7582005-04-28 22:41:06 -0700423 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700424 if (rc) {
425 up(&pCifsFile->fh_sem);
Steve French26a21b92006-05-31 18:05:34 +0000426 cFYI(1, ("cifs_open returned 0x%x", rc));
427 cFYI(1, ("oplock: %d", oplock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700428 } else {
429 pCifsFile->netfid = netfid;
Steve French4b18f2a2008-04-29 00:06:05 +0000430 pCifsFile->invalidHandle = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700431 up(&pCifsFile->fh_sem);
432 pCifsInode = CIFS_I(inode);
433 if (pCifsInode) {
434 if (can_flush) {
Jeff Laytoncea21802007-11-20 23:19:03 +0000435 rc = filemap_write_and_wait(inode->i_mapping);
436 if (rc != 0)
437 CIFS_I(inode)->write_behind_rc = rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438 /* temporarily disable caching while we
439 go to server to get inode info */
Steve French4b18f2a2008-04-29 00:06:05 +0000440 pCifsInode->clientCanCacheAll = false;
441 pCifsInode->clientCanCacheRead = false;
Steve Frenchc18c8422007-07-18 23:21:09 +0000442 if (pTcon->unix_ext)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 rc = cifs_get_inode_info_unix(&inode,
444 full_path, inode->i_sb, xid);
445 else
446 rc = cifs_get_inode_info(&inode,
447 full_path, NULL, inode->i_sb,
Steve French8b1327f2008-03-14 22:37:16 +0000448 xid, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 } /* else we are writing out data to server already
450 and could deadlock if we tried to flush data, and
451 since we do not know if we have data that would
452 invalidate the current end of file on the server
453 we can not go to the server to get the new inod
454 info */
455 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
Steve French4b18f2a2008-04-29 00:06:05 +0000456 pCifsInode->clientCanCacheAll = true;
457 pCifsInode->clientCanCacheRead = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700458 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800459 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700460 } else if ((oplock & 0xF) == OPLOCK_READ) {
Steve French4b18f2a2008-04-29 00:06:05 +0000461 pCifsInode->clientCanCacheRead = true;
462 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 } else {
Steve French4b18f2a2008-04-29 00:06:05 +0000464 pCifsInode->clientCanCacheRead = false;
465 pCifsInode->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466 }
467 cifs_relock_file(pCifsFile);
468 }
469 }
470
471 kfree(full_path);
472 FreeXid(xid);
473 return rc;
474}
475
476int cifs_close(struct inode *inode, struct file *file)
477{
478 int rc = 0;
Steve French15745322007-09-07 22:23:48 +0000479 int xid, timeout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700480 struct cifs_sb_info *cifs_sb;
481 struct cifsTconInfo *pTcon;
482 struct cifsFileInfo *pSMBFile =
483 (struct cifsFileInfo *)file->private_data;
484
485 xid = GetXid();
486
487 cifs_sb = CIFS_SB(inode->i_sb);
488 pTcon = cifs_sb->tcon;
489 if (pSMBFile) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000490 struct cifsLockInfo *li, *tmp;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000491 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000492 pSMBFile->closePend = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 if (pTcon) {
494 /* no sense reconnecting to close a file that is
495 already closed */
Steve French3b795212008-11-13 19:45:32 +0000496 if (!pTcon->need_reconnect) {
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000497 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000498 timeout = 2;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000499 while ((atomic_read(&pSMBFile->wrtPending) != 0)
Steve French15745322007-09-07 22:23:48 +0000500 && (timeout <= 2048)) {
Steve French23e7dd72005-10-20 13:44:56 -0700501 /* Give write a better chance to get to
502 server ahead of the close. We do not
503 want to add a wait_q here as it would
504 increase the memory utilization as
505 the struct would be in each open file,
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000506 but this should give enough time to
Steve French23e7dd72005-10-20 13:44:56 -0700507 clear the socket */
Steve French90c81e02008-02-12 20:32:36 +0000508 cFYI(DBG2,
509 ("close delay, write pending"));
Steve French23e7dd72005-10-20 13:44:56 -0700510 msleep(timeout);
511 timeout *= 4;
Steve French4891d532006-11-07 16:31:16 +0000512 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000513 if (atomic_read(&pSMBFile->wrtPending))
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000514 cERROR(1, ("close with pending write"));
515 if (!pTcon->need_reconnect &&
516 !pSMBFile->invalidHandle)
517 rc = CIFSSMBClose(xid, pTcon,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700518 pSMBFile->netfid);
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000519 } else
520 write_unlock(&GlobalSMBSeslock);
521 } else
522 write_unlock(&GlobalSMBSeslock);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000523
524 /* Delete any outstanding lock records.
525 We'll lose them when the file is closed anyway. */
Roland Dreier796e5662007-05-03 04:33:45 +0000526 mutex_lock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000527 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
528 list_del(&li->llist);
529 kfree(li);
530 }
Roland Dreier796e5662007-05-03 04:33:45 +0000531 mutex_unlock(&pSMBFile->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000532
Steve Frenchcbe04762005-04-28 22:41:05 -0700533 write_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700534 list_del(&pSMBFile->flist);
535 list_del(&pSMBFile->tlist);
Steve Frenchcbe04762005-04-28 22:41:05 -0700536 write_unlock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +0000537 timeout = 10;
538 /* We waited above to give the SMBWrite a chance to issue
539 on the wire (so we do not get SMBWrite returning EBADF
540 if writepages is racing with close. Note that writepages
541 does not specify a file handle, so it is possible for a file
542 to be opened twice, and the application close the "wrong"
543 file handle - in these cases we delay long enough to allow
544 the SMBWrite to get on the wire before the SMB Close.
545 We allow total wait here over 45 seconds, more than
546 oplock break time, and more than enough to allow any write
547 to complete on the server, or to time out on the client */
548 while ((atomic_read(&pSMBFile->wrtPending) != 0)
549 && (timeout <= 50000)) {
550 cERROR(1, ("writes pending, delay free of handle"));
551 msleep(timeout);
552 timeout *= 8;
553 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700554 kfree(file->private_data);
555 file->private_data = NULL;
556 } else
557 rc = -EBADF;
558
Steve French4efa53f2007-09-11 05:50:53 +0000559 read_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700560 if (list_empty(&(CIFS_I(inode)->openFileList))) {
561 cFYI(1, ("closing last open instance for inode %p", inode));
562 /* if the file is not open we do not know if we can cache info
563 on this inode, much less write behind and read ahead */
Steve French4b18f2a2008-04-29 00:06:05 +0000564 CIFS_I(inode)->clientCanCacheRead = false;
565 CIFS_I(inode)->clientCanCacheAll = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566 }
Steve French4efa53f2007-09-11 05:50:53 +0000567 read_unlock(&GlobalSMBSeslock);
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000568 if ((rc == 0) && CIFS_I(inode)->write_behind_rc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700569 rc = CIFS_I(inode)->write_behind_rc;
570 FreeXid(xid);
571 return rc;
572}
573
574int cifs_closedir(struct inode *inode, struct file *file)
575{
576 int rc = 0;
577 int xid;
578 struct cifsFileInfo *pCFileStruct =
579 (struct cifsFileInfo *)file->private_data;
580 char *ptmp;
581
Steve French26a21b92006-05-31 18:05:34 +0000582 cFYI(1, ("Closedir inode = 0x%p", inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700583
584 xid = GetXid();
585
586 if (pCFileStruct) {
587 struct cifsTconInfo *pTcon;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000588 struct cifs_sb_info *cifs_sb =
589 CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590
591 pTcon = cifs_sb->tcon;
592
593 cFYI(1, ("Freeing private data in close dir"));
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000594 write_lock(&GlobalSMBSeslock);
Steve French4b18f2a2008-04-29 00:06:05 +0000595 if (!pCFileStruct->srch_inf.endOfSearch &&
596 !pCFileStruct->invalidHandle) {
597 pCFileStruct->invalidHandle = true;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000598 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700599 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
600 cFYI(1, ("Closing uncompleted readdir with rc %d",
601 rc));
602 /* not much we can do if it fails anyway, ignore rc */
603 rc = 0;
Steve Frenchddb4cbf2008-11-20 20:00:44 +0000604 } else
605 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
607 if (ptmp) {
Steve Frenchec637e32005-12-12 20:53:18 -0800608 cFYI(1, ("closedir free smb buf in srch struct"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000610 if (pCFileStruct->srch_inf.smallBuf)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000611 cifs_small_buf_release(ptmp);
612 else
613 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700614 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700615 kfree(file->private_data);
616 file->private_data = NULL;
617 }
618 /* BB can we lock the filestruct while this is going on? */
619 FreeXid(xid);
620 return rc;
621}
622
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000623static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
624 __u64 offset, __u8 lockType)
625{
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000626 struct cifsLockInfo *li =
627 kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000628 if (li == NULL)
629 return -ENOMEM;
630 li->offset = offset;
631 li->length = len;
632 li->type = lockType;
Roland Dreier796e5662007-05-03 04:33:45 +0000633 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000634 list_add(&li->llist, &fid->llist);
Roland Dreier796e5662007-05-03 04:33:45 +0000635 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000636 return 0;
637}
638
Linus Torvalds1da177e2005-04-16 15:20:36 -0700639int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
640{
641 int rc, xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700642 __u32 numLock = 0;
643 __u32 numUnlock = 0;
644 __u64 length;
Steve French4b18f2a2008-04-29 00:06:05 +0000645 bool wait_flag = false;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 struct cifs_sb_info *cifs_sb;
647 struct cifsTconInfo *pTcon;
Steve French08547b02006-02-28 22:39:25 +0000648 __u16 netfid;
649 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
Steve French4b18f2a2008-04-29 00:06:05 +0000650 bool posix_locking;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
652 length = 1 + pfLock->fl_end - pfLock->fl_start;
653 rc = -EACCES;
654 xid = GetXid();
655
656 cFYI(1, ("Lock parm: 0x%x flockflags: "
657 "0x%x flocktype: 0x%x start: %lld end: %lld",
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000658 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
659 pfLock->fl_end));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660
661 if (pfLock->fl_flags & FL_POSIX)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000662 cFYI(1, ("Posix"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 if (pfLock->fl_flags & FL_FLOCK)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000664 cFYI(1, ("Flock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700665 if (pfLock->fl_flags & FL_SLEEP) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000666 cFYI(1, ("Blocking lock"));
Steve French4b18f2a2008-04-29 00:06:05 +0000667 wait_flag = true;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700668 }
669 if (pfLock->fl_flags & FL_ACCESS)
670 cFYI(1, ("Process suspended by mandatory locking - "
Steve French26a21b92006-05-31 18:05:34 +0000671 "not implemented yet"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700672 if (pfLock->fl_flags & FL_LEASE)
673 cFYI(1, ("Lease on file - not implemented yet"));
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000674 if (pfLock->fl_flags &
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
676 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
677
678 if (pfLock->fl_type == F_WRLCK) {
679 cFYI(1, ("F_WRLCK "));
680 numLock = 1;
681 } else if (pfLock->fl_type == F_UNLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000682 cFYI(1, ("F_UNLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 numUnlock = 1;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000684 /* Check if unlock includes more than
685 one lock range */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700686 } else if (pfLock->fl_type == F_RDLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000687 cFYI(1, ("F_RDLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700688 lockType |= LOCKING_ANDX_SHARED_LOCK;
689 numLock = 1;
690 } else if (pfLock->fl_type == F_EXLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000691 cFYI(1, ("F_EXLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700692 numLock = 1;
693 } else if (pfLock->fl_type == F_SHLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000694 cFYI(1, ("F_SHLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700695 lockType |= LOCKING_ANDX_SHARED_LOCK;
696 numLock = 1;
697 } else
Steve Frenchd47d7c12006-02-28 03:45:48 +0000698 cFYI(1, ("Unknown type of lock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700699
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800700 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 pTcon = cifs_sb->tcon;
702
703 if (file->private_data == NULL) {
704 FreeXid(xid);
705 return -EBADF;
706 }
Steve French08547b02006-02-28 22:39:25 +0000707 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000709 posix_locking = (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
710 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability));
Steve French08547b02006-02-28 22:39:25 +0000711
712 /* BB add code here to normalize offset and length to
713 account for negative length which we can not accept over the
714 wire */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700715 if (IS_GETLK(cmd)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000716 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000717 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000718 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000719 posix_lock_type = CIFS_RDLCK;
720 else
721 posix_lock_type = CIFS_WRLCK;
722 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 1 /* get */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000723 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000724 posix_lock_type, wait_flag);
725 FreeXid(xid);
726 return rc;
727 }
728
729 /* BB we could chain these into one lock request BB */
730 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
731 0, 1, lockType, 0 /* wait flag */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 if (rc == 0) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000733 rc = CIFSSMBLock(xid, pTcon, netfid, length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700734 pfLock->fl_start, 1 /* numUnlock */ ,
735 0 /* numLock */ , lockType,
736 0 /* wait flag */ );
737 pfLock->fl_type = F_UNLCK;
738 if (rc != 0)
739 cERROR(1, ("Error unlocking previously locked "
Steve French08547b02006-02-28 22:39:25 +0000740 "range %d during test of lock", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 rc = 0;
742
743 } else {
744 /* if rc == ERR_SHARING_VIOLATION ? */
745 rc = 0; /* do not change lock type to unlock
746 since range in use */
747 }
748
749 FreeXid(xid);
750 return rc;
751 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000752
753 if (!numLock && !numUnlock) {
754 /* if no lock or unlock then nothing
755 to do since we do not know what it is */
756 FreeXid(xid);
757 return -EOPNOTSUPP;
758 }
759
760 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000761 int posix_lock_type;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000762 if (lockType & LOCKING_ANDX_SHARED_LOCK)
Steve French08547b02006-02-28 22:39:25 +0000763 posix_lock_type = CIFS_RDLCK;
764 else
765 posix_lock_type = CIFS_WRLCK;
Steve French50c2f752007-07-13 00:33:32 +0000766
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000767 if (numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000768 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000769
Steve French08547b02006-02-28 22:39:25 +0000770 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000771 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000772 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000773 } else {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000774 struct cifsFileInfo *fid =
775 (struct cifsFileInfo *)file->private_data;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000776
777 if (numLock) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000778 rc = CIFSSMBLock(xid, pTcon, netfid, length,
779 pfLock->fl_start,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000780 0, numLock, lockType, wait_flag);
781
782 if (rc == 0) {
783 /* For Windows locks we must store them. */
784 rc = store_file_lock(fid, length,
785 pfLock->fl_start, lockType);
786 }
787 } else if (numUnlock) {
788 /* For each stored lock that this unlock overlaps
789 completely, unlock it. */
790 int stored_rc = 0;
791 struct cifsLockInfo *li, *tmp;
792
Steve French6b70c952006-09-21 07:35:29 +0000793 rc = 0;
Roland Dreier796e5662007-05-03 04:33:45 +0000794 mutex_lock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000795 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
796 if (pfLock->fl_start <= li->offset &&
Steve Frenchc19eb712007-08-24 03:22:48 +0000797 (pfLock->fl_start + length) >=
Jeff Layton39db8102007-08-24 03:16:51 +0000798 (li->offset + li->length)) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000799 stored_rc = CIFSSMBLock(xid, pTcon,
800 netfid,
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000801 li->length, li->offset,
Steve French4b18f2a2008-04-29 00:06:05 +0000802 1, 0, li->type, false);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000803 if (stored_rc)
804 rc = stored_rc;
805
806 list_del(&li->llist);
807 kfree(li);
808 }
809 }
Roland Dreier796e5662007-05-03 04:33:45 +0000810 mutex_unlock(&fid->lock_mutex);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000811 }
812 }
813
Steve Frenchd634cc12005-08-26 14:42:59 -0500814 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 posix_lock_file_wait(file, pfLock);
816 FreeXid(xid);
817 return rc;
818}
819
820ssize_t cifs_user_write(struct file *file, const char __user *write_data,
821 size_t write_size, loff_t *poffset)
822{
823 int rc = 0;
824 unsigned int bytes_written = 0;
825 unsigned int total_written;
826 struct cifs_sb_info *cifs_sb;
827 struct cifsTconInfo *pTcon;
828 int xid, long_op;
829 struct cifsFileInfo *open_file;
830
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800831 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
833 pTcon = cifs_sb->tcon;
834
835 /* cFYI(1,
836 (" write %d bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800837 *poffset, file->f_path.dentry->d_name.name)); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838
839 if (file->private_data == NULL)
840 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000841 open_file = (struct cifsFileInfo *) file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000842
Jeff Layton838726c2008-08-28 07:54:59 -0400843 rc = generic_write_checks(file, poffset, &write_size, 0);
844 if (rc)
845 return rc;
846
Linus Torvalds1da177e2005-04-16 15:20:36 -0700847 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700848
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800849 if (*poffset > file->f_path.dentry->d_inode->i_size)
Steve French133672e2007-11-13 22:41:37 +0000850 long_op = CIFS_VLONG_OP; /* writes past EOF take long time */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851 else
Steve French133672e2007-11-13 22:41:37 +0000852 long_op = CIFS_LONG_OP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
854 for (total_written = 0; write_size > total_written;
855 total_written += bytes_written) {
856 rc = -EAGAIN;
857 while (rc == -EAGAIN) {
858 if (file->private_data == NULL) {
859 /* file has been closed on us */
860 FreeXid(xid);
861 /* if we have gotten here we have written some data
862 and blocked, and the file has been freed on us while
863 we blocked so return what we managed to write */
864 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000865 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 if (open_file->closePend) {
867 FreeXid(xid);
868 if (total_written)
869 return total_written;
870 else
871 return -EBADF;
872 }
873 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 /* we could deadlock if we called
875 filemap_fdatawait from here so tell
876 reopen_file not to flush data to server
877 now */
Steve French4b18f2a2008-04-29 00:06:05 +0000878 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700879 if (rc != 0)
880 break;
881 }
882
883 rc = CIFSSMBWrite(xid, pTcon,
884 open_file->netfid,
885 min_t(const int, cifs_sb->wsize,
886 write_size - total_written),
887 *poffset, &bytes_written,
888 NULL, write_data + total_written, long_op);
889 }
890 if (rc || (bytes_written == 0)) {
891 if (total_written)
892 break;
893 else {
894 FreeXid(xid);
895 return rc;
896 }
897 } else
898 *poffset += bytes_written;
Steve French133672e2007-11-13 22:41:37 +0000899 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -0700900 15 seconds is plenty */
901 }
902
Steve Frencha4544342005-08-24 13:59:35 -0700903 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700904
905 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +0000906 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
907 struct inode *inode = file->f_path.dentry->d_inode;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000908/* Do not update local mtime - server will set its actual value on write
909 * inode->i_ctime = inode->i_mtime =
Steve French3677db12007-02-26 16:46:11 +0000910 * current_fs_time(inode->i_sb);*/
911 if (total_written > 0) {
912 spin_lock(&inode->i_lock);
913 if (*poffset > file->f_path.dentry->d_inode->i_size)
914 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 *poffset);
Steve French3677db12007-02-26 16:46:11 +0000916 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700917 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000918 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700919 }
920 FreeXid(xid);
921 return total_written;
922}
923
924static ssize_t cifs_write(struct file *file, const char *write_data,
Nick Piggind9414772008-09-24 11:32:59 -0400925 size_t write_size, loff_t *poffset)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700926{
927 int rc = 0;
928 unsigned int bytes_written = 0;
929 unsigned int total_written;
930 struct cifs_sb_info *cifs_sb;
931 struct cifsTconInfo *pTcon;
932 int xid, long_op;
933 struct cifsFileInfo *open_file;
934
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800935 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700936
937 pTcon = cifs_sb->tcon;
938
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000939 cFYI(1, ("write %zd bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800940 *poffset, file->f_path.dentry->d_name.name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700941
942 if (file->private_data == NULL)
943 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000944 open_file = (struct cifsFileInfo *)file->private_data;
Steve French50c2f752007-07-13 00:33:32 +0000945
Linus Torvalds1da177e2005-04-16 15:20:36 -0700946 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700947
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800948 if (*poffset > file->f_path.dentry->d_inode->i_size)
Steve French133672e2007-11-13 22:41:37 +0000949 long_op = CIFS_VLONG_OP; /* writes past EOF can be slow */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700950 else
Steve French133672e2007-11-13 22:41:37 +0000951 long_op = CIFS_LONG_OP;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700952
953 for (total_written = 0; write_size > total_written;
954 total_written += bytes_written) {
955 rc = -EAGAIN;
956 while (rc == -EAGAIN) {
957 if (file->private_data == NULL) {
958 /* file has been closed on us */
959 FreeXid(xid);
960 /* if we have gotten here we have written some data
961 and blocked, and the file has been freed on us
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000962 while we blocked so return what we managed to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700963 write */
964 return total_written;
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000965 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700966 if (open_file->closePend) {
967 FreeXid(xid);
968 if (total_written)
969 return total_written;
970 else
971 return -EBADF;
972 }
973 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 /* we could deadlock if we called
975 filemap_fdatawait from here so tell
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000976 reopen_file not to flush data to
Linus Torvalds1da177e2005-04-16 15:20:36 -0700977 server now */
Steve French4b18f2a2008-04-29 00:06:05 +0000978 rc = cifs_reopen_file(file, false);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700979 if (rc != 0)
980 break;
981 }
Steve Frenchfb8c4b12007-07-10 01:16:18 +0000982 if (experimEnabled || (pTcon->ses->server &&
983 ((pTcon->ses->server->secMode &
Steve French08775832006-05-30 18:08:26 +0000984 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +0000985 == 0))) {
Steve French3e844692005-10-03 13:37:24 -0700986 struct kvec iov[2];
987 unsigned int len;
988
Steve French0ae0efa2005-10-10 10:57:19 -0700989 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -0700990 write_size - total_written);
991 /* iov[0] is reserved for smb header */
992 iov[1].iov_base = (char *)write_data +
993 total_written;
994 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500995 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -0700996 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500997 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -0700998 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500999 } else
Steve French60808232006-04-22 15:53:05 +00001000 rc = CIFSSMBWrite(xid, pTcon,
1001 open_file->netfid,
1002 min_t(const int, cifs_sb->wsize,
1003 write_size - total_written),
1004 *poffset, &bytes_written,
1005 write_data + total_written,
1006 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001007 }
1008 if (rc || (bytes_written == 0)) {
1009 if (total_written)
1010 break;
1011 else {
1012 FreeXid(xid);
1013 return rc;
1014 }
1015 } else
1016 *poffset += bytes_written;
Steve French133672e2007-11-13 22:41:37 +00001017 long_op = CIFS_STD_OP; /* subsequent writes fast -
Linus Torvalds1da177e2005-04-16 15:20:36 -07001018 15 seconds is plenty */
1019 }
1020
Steve Frencha4544342005-08-24 13:59:35 -07001021 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022
1023 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001024 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +00001025/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +00001026/* file->f_path.dentry->d_inode->i_ctime =
1027 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1028 if (total_written > 0) {
1029 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1030 if (*poffset > file->f_path.dentry->d_inode->i_size)
1031 i_size_write(file->f_path.dentry->d_inode,
1032 *poffset);
1033 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001034 }
Steve French3677db12007-02-26 16:46:11 +00001035 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036 }
1037 FreeXid(xid);
1038 return total_written;
1039}
1040
Steve French630f3f0c2007-10-25 21:17:17 +00001041#ifdef CONFIG_CIFS_EXPERIMENTAL
1042struct cifsFileInfo *find_readable_file(struct cifsInodeInfo *cifs_inode)
1043{
1044 struct cifsFileInfo *open_file = NULL;
1045
1046 read_lock(&GlobalSMBSeslock);
1047 /* we could simply get the first_list_entry since write-only entries
1048 are always at the end of the list but since the first entry might
1049 have a close pending, we go through the whole list */
1050 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1051 if (open_file->closePend)
1052 continue;
1053 if (open_file->pfile && ((open_file->pfile->f_flags & O_RDWR) ||
1054 (open_file->pfile->f_flags & O_RDONLY))) {
1055 if (!open_file->invalidHandle) {
1056 /* found a good file */
1057 /* lock it so it will not be closed on us */
1058 atomic_inc(&open_file->wrtPending);
1059 read_unlock(&GlobalSMBSeslock);
1060 return open_file;
1061 } /* else might as well continue, and look for
1062 another, or simply have the caller reopen it
1063 again rather than trying to fix this handle */
1064 } else /* write only file */
1065 break; /* write only files are last so must be done */
1066 }
1067 read_unlock(&GlobalSMBSeslock);
1068 return NULL;
1069}
1070#endif
1071
Steve Frenchdd99cd82005-10-05 19:32:49 -07001072struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
Steve French6148a742005-10-05 12:23:19 -07001073{
1074 struct cifsFileInfo *open_file;
Jeff Layton2846d382008-09-22 21:33:33 -04001075 bool any_available = false;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001076 int rc;
Steve French6148a742005-10-05 12:23:19 -07001077
Steve French60808232006-04-22 15:53:05 +00001078 /* Having a null inode here (because mapping->host was set to zero by
1079 the VFS or MM) should not happen but we had reports of on oops (due to
1080 it being zero) during stress testcases so we need to check for it */
1081
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001082 if (cifs_inode == NULL) {
1083 cERROR(1, ("Null inode passed to cifs_writeable_file"));
Steve French60808232006-04-22 15:53:05 +00001084 dump_stack();
1085 return NULL;
1086 }
1087
Steve French6148a742005-10-05 12:23:19 -07001088 read_lock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001089refind_writable:
Steve French6148a742005-10-05 12:23:19 -07001090 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
Jeff Layton2846d382008-09-22 21:33:33 -04001091 if (open_file->closePend ||
1092 (!any_available && open_file->pid != current->tgid))
Steve French6148a742005-10-05 12:23:19 -07001093 continue;
Jeff Layton2846d382008-09-22 21:33:33 -04001094
Steve French6148a742005-10-05 12:23:19 -07001095 if (open_file->pfile &&
1096 ((open_file->pfile->f_flags & O_RDWR) ||
1097 (open_file->pfile->f_flags & O_WRONLY))) {
Steve French23e7dd72005-10-20 13:44:56 -07001098 atomic_inc(&open_file->wrtPending);
Steve French9b22b0b2007-10-02 01:11:08 +00001099
1100 if (!open_file->invalidHandle) {
1101 /* found a good writable file */
1102 read_unlock(&GlobalSMBSeslock);
1103 return open_file;
1104 }
Steve French8840dee2007-11-16 23:05:52 +00001105
Steve French6148a742005-10-05 12:23:19 -07001106 read_unlock(&GlobalSMBSeslock);
Steve French9b22b0b2007-10-02 01:11:08 +00001107 /* Had to unlock since following call can block */
Steve French4b18f2a2008-04-29 00:06:05 +00001108 rc = cifs_reopen_file(open_file->pfile, false);
Steve French8840dee2007-11-16 23:05:52 +00001109 if (!rc) {
Steve French9b22b0b2007-10-02 01:11:08 +00001110 if (!open_file->closePend)
1111 return open_file;
1112 else { /* start over in case this was deleted */
1113 /* since the list could be modified */
Steve French37c0eb42005-10-05 14:50:29 -07001114 read_lock(&GlobalSMBSeslock);
Steve French15745322007-09-07 22:23:48 +00001115 atomic_dec(&open_file->wrtPending);
Steve French9b22b0b2007-10-02 01:11:08 +00001116 goto refind_writable;
Steve French37c0eb42005-10-05 14:50:29 -07001117 }
1118 }
Steve French9b22b0b2007-10-02 01:11:08 +00001119
1120 /* if it fails, try another handle if possible -
1121 (we can not do this if closePending since
1122 loop could be modified - in which case we
1123 have to start at the beginning of the list
1124 again. Note that it would be bad
1125 to hold up writepages here (rather than
1126 in caller) with continuous retries */
1127 cFYI(1, ("wp failed on reopen file"));
1128 read_lock(&GlobalSMBSeslock);
1129 /* can not use this handle, no write
1130 pending on this one after all */
1131 atomic_dec(&open_file->wrtPending);
Steve French8840dee2007-11-16 23:05:52 +00001132
Steve French9b22b0b2007-10-02 01:11:08 +00001133 if (open_file->closePend) /* list could have changed */
1134 goto refind_writable;
1135 /* else we simply continue to the next entry. Thus
1136 we do not loop on reopen errors. If we
1137 can not reopen the file, for example if we
1138 reconnected to a server with another client
1139 racing to delete or lock the file we would not
1140 make progress if we restarted before the beginning
1141 of the loop here. */
Steve French6148a742005-10-05 12:23:19 -07001142 }
1143 }
Jeff Layton2846d382008-09-22 21:33:33 -04001144 /* couldn't find useable FH with same pid, try any available */
1145 if (!any_available) {
1146 any_available = true;
1147 goto refind_writable;
1148 }
Steve French6148a742005-10-05 12:23:19 -07001149 read_unlock(&GlobalSMBSeslock);
1150 return NULL;
1151}
1152
Linus Torvalds1da177e2005-04-16 15:20:36 -07001153static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1154{
1155 struct address_space *mapping = page->mapping;
1156 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1157 char *write_data;
1158 int rc = -EFAULT;
1159 int bytes_written = 0;
1160 struct cifs_sb_info *cifs_sb;
1161 struct cifsTconInfo *pTcon;
1162 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001163 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001164
1165 if (!mapping || !mapping->host)
1166 return -EFAULT;
1167
1168 inode = page->mapping->host;
1169 cifs_sb = CIFS_SB(inode->i_sb);
1170 pTcon = cifs_sb->tcon;
1171
1172 offset += (loff_t)from;
1173 write_data = kmap(page);
1174 write_data += from;
1175
1176 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1177 kunmap(page);
1178 return -EIO;
1179 }
1180
1181 /* racing with truncate? */
1182 if (offset > mapping->host->i_size) {
1183 kunmap(page);
1184 return 0; /* don't care */
1185 }
1186
1187 /* check to make sure that we are not extending the file */
1188 if (mapping->host->i_size - offset < (loff_t)to)
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001189 to = (unsigned)(mapping->host->i_size - offset);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001190
Steve French6148a742005-10-05 12:23:19 -07001191 open_file = find_writable_file(CIFS_I(mapping->host));
1192 if (open_file) {
1193 bytes_written = cifs_write(open_file->pfile, write_data,
1194 to-from, &offset);
Steve French23e7dd72005-10-20 13:44:56 -07001195 atomic_dec(&open_file->wrtPending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001197 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001198 if ((bytes_written > 0) && (offset))
Steve French6148a742005-10-05 12:23:19 -07001199 rc = 0;
Steve Frenchbb5a9a02007-12-31 04:21:29 +00001200 else if (bytes_written < 0)
1201 rc = bytes_written;
Steve French6148a742005-10-05 12:23:19 -07001202 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001203 cFYI(1, ("No writeable filehandles for inode"));
1204 rc = -EIO;
1205 }
1206
1207 kunmap(page);
1208 return rc;
1209}
1210
Linus Torvalds1da177e2005-04-16 15:20:36 -07001211static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001212 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001213{
Steve French37c0eb42005-10-05 14:50:29 -07001214 struct backing_dev_info *bdi = mapping->backing_dev_info;
1215 unsigned int bytes_to_write;
1216 unsigned int bytes_written;
1217 struct cifs_sb_info *cifs_sb;
1218 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001219 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001220 pgoff_t index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001221 int range_whole = 0;
1222 struct kvec *iov;
Steve French84d2f072005-10-12 15:32:05 -07001223 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001224 int n_iov = 0;
1225 pgoff_t next;
1226 int nr_pages;
1227 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001228 struct cifsFileInfo *open_file;
Steve French37c0eb42005-10-05 14:50:29 -07001229 struct page *page;
1230 struct pagevec pvec;
1231 int rc = 0;
1232 int scanned = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001233 int xid;
1234
Steve French37c0eb42005-10-05 14:50:29 -07001235 cifs_sb = CIFS_SB(mapping->host->i_sb);
Steve French50c2f752007-07-13 00:33:32 +00001236
Steve French37c0eb42005-10-05 14:50:29 -07001237 /*
1238 * If wsize is smaller that the page cache size, default to writing
1239 * one page at a time via cifs_writepage
1240 */
1241 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1242 return generic_writepages(mapping, wbc);
1243
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001244 if ((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1245 if (cifs_sb->tcon->ses->server->secMode &
1246 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1247 if (!experimEnabled)
Steve French60808232006-04-22 15:53:05 +00001248 return generic_writepages(mapping, wbc);
Steve French4a771182005-10-05 15:14:33 -07001249
Steve French9a0c8232007-02-02 04:21:57 +00001250 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001251 if (iov == NULL)
Steve French9a0c8232007-02-02 04:21:57 +00001252 return generic_writepages(mapping, wbc);
1253
1254
Steve French37c0eb42005-10-05 14:50:29 -07001255 /*
1256 * BB: Is this meaningful for a non-block-device file system?
1257 * If it is, we should test it again after we do I/O
1258 */
1259 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1260 wbc->encountered_congestion = 1;
Steve French9a0c8232007-02-02 04:21:57 +00001261 kfree(iov);
Steve French37c0eb42005-10-05 14:50:29 -07001262 return 0;
1263 }
1264
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 xid = GetXid();
1266
Steve French37c0eb42005-10-05 14:50:29 -07001267 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001268 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001269 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001270 end = -1;
1271 } else {
1272 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1273 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1274 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1275 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001276 scanned = 1;
1277 }
1278retry:
1279 while (!done && (index <= end) &&
1280 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1281 PAGECACHE_TAG_DIRTY,
1282 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1283 int first;
1284 unsigned int i;
1285
Steve French37c0eb42005-10-05 14:50:29 -07001286 first = -1;
1287 next = 0;
1288 n_iov = 0;
1289 bytes_to_write = 0;
1290
1291 for (i = 0; i < nr_pages; i++) {
1292 page = pvec.pages[i];
1293 /*
1294 * At this point we hold neither mapping->tree_lock nor
1295 * lock on the page itself: the page may be truncated or
1296 * invalidated (changing page->mapping to NULL), or even
1297 * swizzled back from swapper_space to tmpfs file
1298 * mapping
1299 */
1300
1301 if (first < 0)
1302 lock_page(page);
Nick Piggin529ae9a2008-08-02 12:01:03 +02001303 else if (!trylock_page(page))
Steve French37c0eb42005-10-05 14:50:29 -07001304 break;
1305
1306 if (unlikely(page->mapping != mapping)) {
1307 unlock_page(page);
1308 break;
1309 }
1310
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001311 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001312 done = 1;
1313 unlock_page(page);
1314 break;
1315 }
1316
1317 if (next && (page->index != next)) {
1318 /* Not next consecutive page */
1319 unlock_page(page);
1320 break;
1321 }
1322
1323 if (wbc->sync_mode != WB_SYNC_NONE)
1324 wait_on_page_writeback(page);
1325
1326 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001327 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001328 unlock_page(page);
1329 break;
1330 }
Steve French84d2f072005-10-12 15:32:05 -07001331
Linus Torvaldscb876f42006-12-23 16:19:07 -08001332 /*
1333 * This actually clears the dirty bit in the radix tree.
1334 * See cifs_writepage() for more commentary.
1335 */
1336 set_page_writeback(page);
1337
Steve French84d2f072005-10-12 15:32:05 -07001338 if (page_offset(page) >= mapping->host->i_size) {
1339 done = 1;
1340 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001341 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001342 break;
1343 }
1344
Steve French37c0eb42005-10-05 14:50:29 -07001345 /*
1346 * BB can we get rid of this? pages are held by pvec
1347 */
1348 page_cache_get(page);
1349
Steve French84d2f072005-10-12 15:32:05 -07001350 len = min(mapping->host->i_size - page_offset(page),
1351 (loff_t)PAGE_CACHE_SIZE);
1352
Steve French37c0eb42005-10-05 14:50:29 -07001353 /* reserve iov[0] for the smb header */
1354 n_iov++;
1355 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001356 iov[n_iov].iov_len = len;
1357 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001358
1359 if (first < 0) {
1360 first = i;
1361 offset = page_offset(page);
1362 }
1363 next = page->index + 1;
1364 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1365 break;
1366 }
1367 if (n_iov) {
Steve French23e7dd72005-10-20 13:44:56 -07001368 /* Search for a writable handle every time we call
1369 * CIFSSMBWrite2. We can't rely on the last handle
1370 * we used to still be valid
1371 */
1372 open_file = find_writable_file(CIFS_I(mapping->host));
1373 if (!open_file) {
1374 cERROR(1, ("No writable handles for inode"));
1375 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001376 } else {
Steve French23e7dd72005-10-20 13:44:56 -07001377 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1378 open_file->netfid,
1379 bytes_to_write, offset,
1380 &bytes_written, iov, n_iov,
Steve French133672e2007-11-13 22:41:37 +00001381 CIFS_LONG_OP);
Steve French23e7dd72005-10-20 13:44:56 -07001382 atomic_dec(&open_file->wrtPending);
1383 if (rc || bytes_written < bytes_to_write) {
Steve French63135e02007-07-17 17:34:02 +00001384 cERROR(1, ("Write2 ret %d, wrote %d",
Steve French23e7dd72005-10-20 13:44:56 -07001385 rc, bytes_written));
1386 /* BB what if continued retry is
1387 requested via mount flags? */
Jeff Laytoncea21802007-11-20 23:19:03 +00001388 if (rc == -ENOSPC)
1389 set_bit(AS_ENOSPC, &mapping->flags);
1390 else
1391 set_bit(AS_EIO, &mapping->flags);
Steve French23e7dd72005-10-20 13:44:56 -07001392 } else {
1393 cifs_stats_bytes_written(cifs_sb->tcon,
1394 bytes_written);
1395 }
Steve French37c0eb42005-10-05 14:50:29 -07001396 }
1397 for (i = 0; i < n_iov; i++) {
1398 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001399 /* Should we also set page error on
1400 success rc but too little data written? */
1401 /* BB investigate retry logic on temporary
1402 server crash cases and how recovery works
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001403 when page marked as error */
1404 if (rc)
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001405 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001406 kunmap(page);
1407 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001408 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001409 page_cache_release(page);
1410 }
1411 if ((wbc->nr_to_write -= n_iov) <= 0)
1412 done = 1;
1413 index = next;
Dave Kleikampb066a482008-11-18 03:49:05 +00001414 } else
1415 /* Need to re-find the pages we skipped */
1416 index = pvec.pages[0]->index + 1;
1417
Steve French37c0eb42005-10-05 14:50:29 -07001418 pagevec_release(&pvec);
1419 }
1420 if (!scanned && !done) {
1421 /*
1422 * We hit the last page and there is more work to be done: wrap
1423 * back to the start of the file
1424 */
1425 scanned = 1;
1426 index = 0;
1427 goto retry;
1428 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001429 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001430 mapping->writeback_index = index;
1431
Linus Torvalds1da177e2005-04-16 15:20:36 -07001432 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001433 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001434 return rc;
1435}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001436
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001437static int cifs_writepage(struct page *page, struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438{
1439 int rc = -EFAULT;
1440 int xid;
1441
1442 xid = GetXid();
1443/* BB add check for wbc flags */
1444 page_cache_get(page);
Steve Frenchad7a2922008-02-07 23:25:02 +00001445 if (!PageUptodate(page))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 cFYI(1, ("ppw - page not up to date"));
Linus Torvaldscb876f42006-12-23 16:19:07 -08001447
1448 /*
1449 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1450 *
1451 * A writepage() implementation always needs to do either this,
1452 * or re-dirty the page with "redirty_page_for_writepage()" in
1453 * the case of a failure.
1454 *
1455 * Just unlocking the page will cause the radix tree tag-bits
1456 * to fail to update with the state of the page correctly.
1457 */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001458 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1460 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1461 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001462 end_page_writeback(page);
1463 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001464 FreeXid(xid);
1465 return rc;
1466}
1467
Nick Piggind9414772008-09-24 11:32:59 -04001468static int cifs_write_end(struct file *file, struct address_space *mapping,
1469 loff_t pos, unsigned len, unsigned copied,
1470 struct page *page, void *fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001471{
Nick Piggind9414772008-09-24 11:32:59 -04001472 int rc;
1473 struct inode *inode = mapping->host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001474
Nick Piggind9414772008-09-24 11:32:59 -04001475 cFYI(1, ("write_end for page %p from pos %lld with %d bytes",
1476 page, pos, copied));
Steve Frenchad7a2922008-02-07 23:25:02 +00001477
Nick Piggind9414772008-09-24 11:32:59 -04001478 if (!PageUptodate(page) && copied == PAGE_CACHE_SIZE)
1479 SetPageUptodate(page);
1480
Linus Torvalds1da177e2005-04-16 15:20:36 -07001481 if (!PageUptodate(page)) {
Nick Piggind9414772008-09-24 11:32:59 -04001482 char *page_data;
1483 unsigned offset = pos & (PAGE_CACHE_SIZE - 1);
1484 int xid;
1485
1486 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001487 /* this is probably better than directly calling
1488 partialpage_write since in this function the file handle is
1489 known which we might as well leverage */
1490 /* BB check if anything else missing out of ppw
1491 such as updating last write time */
1492 page_data = kmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001493 rc = cifs_write(file, page_data + offset, copied, &pos);
1494 /* if (rc < 0) should we set writebehind rc? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001495 kunmap(page);
Nick Piggind9414772008-09-24 11:32:59 -04001496
1497 FreeXid(xid);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001498 } else {
Nick Piggind9414772008-09-24 11:32:59 -04001499 rc = copied;
1500 pos += copied;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001501 set_page_dirty(page);
1502 }
1503
Nick Piggind9414772008-09-24 11:32:59 -04001504 if (rc > 0) {
1505 spin_lock(&inode->i_lock);
1506 if (pos > inode->i_size)
1507 i_size_write(inode, pos);
1508 spin_unlock(&inode->i_lock);
1509 }
1510
1511 unlock_page(page);
1512 page_cache_release(page);
1513
Linus Torvalds1da177e2005-04-16 15:20:36 -07001514 return rc;
1515}
1516
1517int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1518{
1519 int xid;
1520 int rc = 0;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001521 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001522
1523 xid = GetXid();
1524
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001525 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001526 dentry->d_name.name, datasync));
Steve French50c2f752007-07-13 00:33:32 +00001527
Jeff Laytoncea21802007-11-20 23:19:03 +00001528 rc = filemap_write_and_wait(inode->i_mapping);
1529 if (rc == 0) {
1530 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001531 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001532 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001533 FreeXid(xid);
1534 return rc;
1535}
1536
NeilBrown3978d7172006-03-26 01:37:17 -08001537/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001538{
1539 struct address_space *mapping;
1540 struct inode *inode;
1541 unsigned long index = page->index;
1542 unsigned int rpages = 0;
1543 int rc = 0;
1544
1545 cFYI(1, ("sync page %p",page));
1546 mapping = page->mapping;
1547 if (!mapping)
1548 return 0;
1549 inode = mapping->host;
1550 if (!inode)
NeilBrown3978d7172006-03-26 01:37:17 -08001551 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001553/* fill in rpages then
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1555
Steve French26a21b92006-05-31 18:05:34 +00001556/* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001557
NeilBrown3978d7172006-03-26 01:37:17 -08001558#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001559 if (rc < 0)
1560 return rc;
1561 return 0;
NeilBrown3978d7172006-03-26 01:37:17 -08001562#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001563} */
1564
1565/*
1566 * As file closes, flush all cached write data for this inode checking
1567 * for write behind errors.
1568 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001569int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001570{
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001571 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001572 int rc = 0;
1573
1574 /* Rather than do the steps manually:
1575 lock the inode for writing
1576 loop through pages looking for write behind data (dirty pages)
1577 coalesce into contiguous 16K (or smaller) chunks to write to server
1578 send to server (prefer in parallel)
1579 deal with writebehind errors
1580 unlock inode for writing
1581 filemapfdatawrite appears easier for the time being */
1582
1583 rc = filemap_fdatawrite(inode->i_mapping);
Jeff Laytoncea21802007-11-20 23:19:03 +00001584 /* reset wb rc if we were able to write out dirty pages */
1585 if (!rc) {
1586 rc = CIFS_I(inode)->write_behind_rc;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 CIFS_I(inode)->write_behind_rc = 0;
Jeff Laytoncea21802007-11-20 23:19:03 +00001588 }
Steve French50c2f752007-07-13 00:33:32 +00001589
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001590 cFYI(1, ("Flush inode %p file %p rc %d", inode, file, rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591
1592 return rc;
1593}
1594
1595ssize_t cifs_user_read(struct file *file, char __user *read_data,
1596 size_t read_size, loff_t *poffset)
1597{
1598 int rc = -EACCES;
1599 unsigned int bytes_read = 0;
1600 unsigned int total_read = 0;
1601 unsigned int current_read_size;
1602 struct cifs_sb_info *cifs_sb;
1603 struct cifsTconInfo *pTcon;
1604 int xid;
1605 struct cifsFileInfo *open_file;
1606 char *smb_read_data;
1607 char __user *current_offset;
1608 struct smb_com_read_rsp *pSMBr;
1609
1610 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001611 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 pTcon = cifs_sb->tcon;
1613
1614 if (file->private_data == NULL) {
1615 FreeXid(xid);
1616 return -EBADF;
1617 }
1618 open_file = (struct cifsFileInfo *)file->private_data;
1619
Steve Frenchad7a2922008-02-07 23:25:02 +00001620 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621 cFYI(1, ("attempting read on write only file instance"));
Steve Frenchad7a2922008-02-07 23:25:02 +00001622
Linus Torvalds1da177e2005-04-16 15:20:36 -07001623 for (total_read = 0, current_offset = read_data;
1624 read_size > total_read;
1625 total_read += bytes_read, current_offset += bytes_read) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001626 current_read_size = min_t(const int, read_size - total_read,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627 cifs_sb->rsize);
1628 rc = -EAGAIN;
1629 smb_read_data = NULL;
1630 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001631 int buf_type = CIFS_NO_BUFFER;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001632 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001634 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635 if (rc != 0)
1636 break;
1637 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001638 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001639 open_file->netfid,
1640 current_read_size, *poffset,
1641 &bytes_read, &smb_read_data,
1642 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001643 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001644 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001645 if (copy_to_user(current_offset,
1646 smb_read_data +
1647 4 /* RFC1001 length field */ +
1648 le16_to_cpu(pSMBr->DataOffset),
Steve Frenchad7a2922008-02-07 23:25:02 +00001649 bytes_read))
Steve French93544cc2006-02-14 22:30:52 -06001650 rc = -EFAULT;
Steve French93544cc2006-02-14 22:30:52 -06001651
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001652 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001653 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001654 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001655 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001656 smb_read_data = NULL;
1657 }
1658 }
1659 if (rc || (bytes_read == 0)) {
1660 if (total_read) {
1661 break;
1662 } else {
1663 FreeXid(xid);
1664 return rc;
1665 }
1666 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001667 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 *poffset += bytes_read;
1669 }
1670 }
1671 FreeXid(xid);
1672 return total_read;
1673}
1674
1675
1676static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1677 loff_t *poffset)
1678{
1679 int rc = -EACCES;
1680 unsigned int bytes_read = 0;
1681 unsigned int total_read;
1682 unsigned int current_read_size;
1683 struct cifs_sb_info *cifs_sb;
1684 struct cifsTconInfo *pTcon;
1685 int xid;
1686 char *current_offset;
1687 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001688 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001689
1690 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001691 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001692 pTcon = cifs_sb->tcon;
1693
1694 if (file->private_data == NULL) {
1695 FreeXid(xid);
1696 return -EBADF;
1697 }
1698 open_file = (struct cifsFileInfo *)file->private_data;
1699
1700 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1701 cFYI(1, ("attempting read on write only file instance"));
1702
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001703 for (total_read = 0, current_offset = read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704 read_size > total_read;
1705 total_read += bytes_read, current_offset += bytes_read) {
1706 current_read_size = min_t(const int, read_size - total_read,
1707 cifs_sb->rsize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001708 /* For windows me and 9x we do not want to request more
1709 than it negotiated since it will refuse the read then */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001710 if ((pTcon->ses) &&
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001711 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1712 current_read_size = min_t(const int, current_read_size,
1713 pTcon->ses->server->maxBuf - 128);
1714 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 rc = -EAGAIN;
1716 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001717 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001719 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001720 if (rc != 0)
1721 break;
1722 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001723 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001724 open_file->netfid,
1725 current_read_size, *poffset,
1726 &bytes_read, &current_offset,
1727 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 }
1729 if (rc || (bytes_read == 0)) {
1730 if (total_read) {
1731 break;
1732 } else {
1733 FreeXid(xid);
1734 return rc;
1735 }
1736 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001737 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001738 *poffset += bytes_read;
1739 }
1740 }
1741 FreeXid(xid);
1742 return total_read;
1743}
1744
1745int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1746{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001747 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001748 int rc, xid;
1749
1750 xid = GetXid();
1751 rc = cifs_revalidate(dentry);
1752 if (rc) {
1753 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1754 FreeXid(xid);
1755 return rc;
1756 }
1757 rc = generic_file_mmap(file, vma);
1758 FreeXid(xid);
1759 return rc;
1760}
1761
1762
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001763static void cifs_copy_cache_pages(struct address_space *mapping,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001764 struct list_head *pages, int bytes_read, char *data,
1765 struct pagevec *plru_pvec)
1766{
1767 struct page *page;
1768 char *target;
1769
1770 while (bytes_read > 0) {
1771 if (list_empty(pages))
1772 break;
1773
1774 page = list_entry(pages->prev, struct page, lru);
1775 list_del(&page->lru);
1776
1777 if (add_to_page_cache(page, mapping, page->index,
1778 GFP_KERNEL)) {
1779 page_cache_release(page);
1780 cFYI(1, ("Add page cache failed"));
Steve French3079ca62005-06-09 14:44:07 -07001781 data += PAGE_CACHE_SIZE;
1782 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001783 continue;
1784 }
1785
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001786 target = kmap_atomic(page, KM_USER0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001787
1788 if (PAGE_CACHE_SIZE > bytes_read) {
1789 memcpy(target, data, bytes_read);
1790 /* zero the tail end of this partial page */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001791 memset(target + bytes_read, 0,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 PAGE_CACHE_SIZE - bytes_read);
1793 bytes_read = 0;
1794 } else {
1795 memcpy(target, data, PAGE_CACHE_SIZE);
1796 bytes_read -= PAGE_CACHE_SIZE;
1797 }
1798 kunmap_atomic(target, KM_USER0);
1799
1800 flush_dcache_page(page);
1801 SetPageUptodate(page);
1802 unlock_page(page);
1803 if (!pagevec_add(plru_pvec, page))
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001804 __pagevec_lru_add_file(plru_pvec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001805 data += PAGE_CACHE_SIZE;
1806 }
1807 return;
1808}
1809
1810static int cifs_readpages(struct file *file, struct address_space *mapping,
1811 struct list_head *page_list, unsigned num_pages)
1812{
1813 int rc = -EACCES;
1814 int xid;
1815 loff_t offset;
1816 struct page *page;
1817 struct cifs_sb_info *cifs_sb;
1818 struct cifsTconInfo *pTcon;
Steve French2c2130e2007-10-12 19:10:28 +00001819 unsigned int bytes_read = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001820 unsigned int read_size, i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 char *smb_read_data = NULL;
1822 struct smb_com_read_rsp *pSMBr;
1823 struct pagevec lru_pvec;
1824 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001825 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001826
1827 xid = GetXid();
1828 if (file->private_data == NULL) {
1829 FreeXid(xid);
1830 return -EBADF;
1831 }
1832 open_file = (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001833 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834 pTcon = cifs_sb->tcon;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001835
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 pagevec_init(&lru_pvec, 0);
Steve French61de8002008-10-30 20:15:22 +00001837 cFYI(DBG2, ("rpages: num pages %d", num_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 for (i = 0; i < num_pages; ) {
1839 unsigned contig_pages;
1840 struct page *tmp_page;
1841 unsigned long expected_index;
1842
1843 if (list_empty(page_list))
1844 break;
1845
1846 page = list_entry(page_list->prev, struct page, lru);
1847 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1848
1849 /* count adjacent pages that we will read into */
1850 contig_pages = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001851 expected_index =
Linus Torvalds1da177e2005-04-16 15:20:36 -07001852 list_entry(page_list->prev, struct page, lru)->index;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001853 list_for_each_entry_reverse(tmp_page, page_list, lru) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 if (tmp_page->index == expected_index) {
1855 contig_pages++;
1856 expected_index++;
1857 } else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001858 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859 }
1860 if (contig_pages + i > num_pages)
1861 contig_pages = num_pages - i;
1862
1863 /* for reads over a certain size could initiate async
1864 read ahead */
1865
1866 read_size = contig_pages * PAGE_CACHE_SIZE;
1867 /* Read size needs to be in multiples of one page */
1868 read_size = min_t(const unsigned int, read_size,
1869 cifs_sb->rsize & PAGE_CACHE_MASK);
Steve French90c81e02008-02-12 20:32:36 +00001870 cFYI(DBG2, ("rpages: read size 0x%x contiguous pages %d",
Steve French75865f8c2007-06-24 18:30:48 +00001871 read_size, contig_pages));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 rc = -EAGAIN;
1873 while (rc == -EAGAIN) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001874 if ((open_file->invalidHandle) &&
Linus Torvalds1da177e2005-04-16 15:20:36 -07001875 (!open_file->closePend)) {
Steve French4b18f2a2008-04-29 00:06:05 +00001876 rc = cifs_reopen_file(file, true);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 if (rc != 0)
1878 break;
1879 }
1880
Steve Frenchbfa0d752005-08-31 21:50:37 -07001881 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001882 open_file->netfid,
1883 read_size, offset,
1884 &bytes_read, &smb_read_data,
1885 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001886 /* BB more RC checks ? */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001887 if (rc == -EAGAIN) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001888 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001889 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001890 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001891 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001892 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893 smb_read_data = NULL;
1894 }
1895 }
1896 }
1897 if ((rc < 0) || (smb_read_data == NULL)) {
1898 cFYI(1, ("Read error in readpages: %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001899 break;
1900 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08001901 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001902 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1903 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1904 smb_read_data + 4 /* RFC1001 hdr */ +
1905 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1906
1907 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07001908 cifs_stats_bytes_read(pTcon, bytes_read);
Steve French2c2130e2007-10-12 19:10:28 +00001909 if ((bytes_read & PAGE_CACHE_MASK) != bytes_read) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001910 i++; /* account for partial page */
1911
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001912 /* server copy of file can have smaller size
Linus Torvalds1da177e2005-04-16 15:20:36 -07001913 than client */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001914 /* BB do we need to verify this common case ?
1915 this case is ok - if we are at server EOF
Linus Torvalds1da177e2005-04-16 15:20:36 -07001916 we will hit it on next read */
1917
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08001918 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001919 }
1920 } else {
1921 cFYI(1, ("No bytes read (%d) at offset %lld . "
1922 "Cleaning remaining pages from readahead list",
1923 bytes_read, offset));
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001924 /* BB turn off caching and do new lookup on
Linus Torvalds1da177e2005-04-16 15:20:36 -07001925 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 break;
1927 }
1928 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001929 if (buf_type == CIFS_SMALL_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001930 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001931 else if (buf_type == CIFS_LARGE_BUFFER)
Steve Frenchec637e32005-12-12 20:53:18 -08001932 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001933 smb_read_data = NULL;
1934 }
1935 bytes_read = 0;
1936 }
1937
Rik van Riel4f98a2f2008-10-18 20:26:32 -07001938 pagevec_lru_add_file(&lru_pvec);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001939
1940/* need to free smb_read_data buf before exit */
1941 if (smb_read_data) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001942 if (buf_type == CIFS_SMALL_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08001943 cifs_small_buf_release(smb_read_data);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001944 else if (buf_type == CIFS_LARGE_BUFFER)
Steve French47c886b2006-01-18 14:20:39 -08001945 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001946 smb_read_data = NULL;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001947 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001948
1949 FreeXid(xid);
1950 return rc;
1951}
1952
1953static int cifs_readpage_worker(struct file *file, struct page *page,
1954 loff_t *poffset)
1955{
1956 char *read_data;
1957 int rc;
1958
1959 page_cache_get(page);
1960 read_data = kmap(page);
1961 /* for reads over a certain size could initiate async read ahead */
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001962
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001964
Linus Torvalds1da177e2005-04-16 15:20:36 -07001965 if (rc < 0)
1966 goto io_error;
1967 else
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001968 cFYI(1, ("Bytes read %d", rc));
1969
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001970 file->f_path.dentry->d_inode->i_atime =
1971 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001972
Linus Torvalds1da177e2005-04-16 15:20:36 -07001973 if (PAGE_CACHE_SIZE > rc)
1974 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1975
1976 flush_dcache_page(page);
1977 SetPageUptodate(page);
1978 rc = 0;
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001979
Linus Torvalds1da177e2005-04-16 15:20:36 -07001980io_error:
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001981 kunmap(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 page_cache_release(page);
1983 return rc;
1984}
1985
1986static int cifs_readpage(struct file *file, struct page *page)
1987{
1988 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1989 int rc = -EACCES;
1990 int xid;
1991
1992 xid = GetXid();
1993
1994 if (file->private_data == NULL) {
1995 FreeXid(xid);
1996 return -EBADF;
1997 }
1998
Steve Frenchfb8c4b12007-07-10 01:16:18 +00001999 cFYI(1, ("readpage %p at offset %d 0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002000 page, (int)offset, (int)offset));
2001
2002 rc = cifs_readpage_worker(file, page, &offset);
2003
2004 unlock_page(page);
2005
2006 FreeXid(xid);
2007 return rc;
2008}
2009
Steve Frencha403a0a2007-07-26 15:54:16 +00002010static int is_inode_writable(struct cifsInodeInfo *cifs_inode)
2011{
2012 struct cifsFileInfo *open_file;
2013
2014 read_lock(&GlobalSMBSeslock);
2015 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
2016 if (open_file->closePend)
2017 continue;
2018 if (open_file->pfile &&
2019 ((open_file->pfile->f_flags & O_RDWR) ||
2020 (open_file->pfile->f_flags & O_WRONLY))) {
2021 read_unlock(&GlobalSMBSeslock);
2022 return 1;
2023 }
2024 }
2025 read_unlock(&GlobalSMBSeslock);
2026 return 0;
2027}
2028
Linus Torvalds1da177e2005-04-16 15:20:36 -07002029/* We do not want to update the file size from server for inodes
2030 open for write - to avoid races with writepage extending
2031 the file - in the future we could consider allowing
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002032 refreshing the inode only on increases in the file size
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 but this is tricky to do without racing with writebehind
2034 page caching in the current Linux kernel design */
Steve French4b18f2a2008-04-29 00:06:05 +00002035bool is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002036{
Steve Frencha403a0a2007-07-26 15:54:16 +00002037 if (!cifsInode)
Steve French4b18f2a2008-04-29 00:06:05 +00002038 return true;
Steve French23e7dd72005-10-20 13:44:56 -07002039
Steve Frencha403a0a2007-07-26 15:54:16 +00002040 if (is_inode_writable(cifsInode)) {
2041 /* This inode is open for write at least once */
Steve Frenchc32a0b62006-01-12 14:41:28 -08002042 struct cifs_sb_info *cifs_sb;
2043
Steve Frenchc32a0b62006-01-12 14:41:28 -08002044 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
Steve Frenchad7a2922008-02-07 23:25:02 +00002045 if (cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO) {
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002046 /* since no page cache to corrupt on directio
Steve Frenchc32a0b62006-01-12 14:41:28 -08002047 we can change size safely */
Steve French4b18f2a2008-04-29 00:06:05 +00002048 return true;
Steve Frenchc32a0b62006-01-12 14:41:28 -08002049 }
2050
Steve Frenchfb8c4b12007-07-10 01:16:18 +00002051 if (i_size_read(&cifsInode->vfs_inode) < end_of_file)
Steve French4b18f2a2008-04-29 00:06:05 +00002052 return true;
Steve French7ba52632007-02-08 18:14:13 +00002053
Steve French4b18f2a2008-04-29 00:06:05 +00002054 return false;
Steve French23e7dd72005-10-20 13:44:56 -07002055 } else
Steve French4b18f2a2008-04-29 00:06:05 +00002056 return true;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002057}
2058
Nick Piggind9414772008-09-24 11:32:59 -04002059static int cifs_write_begin(struct file *file, struct address_space *mapping,
2060 loff_t pos, unsigned len, unsigned flags,
2061 struct page **pagep, void **fsdata)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002062{
Nick Piggind9414772008-09-24 11:32:59 -04002063 pgoff_t index = pos >> PAGE_CACHE_SHIFT;
2064 loff_t offset = pos & (PAGE_CACHE_SIZE - 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002065
Nick Piggind9414772008-09-24 11:32:59 -04002066 cFYI(1, ("write_begin from %lld len %d", (long long)pos, len));
2067
2068 *pagep = __grab_cache_page(mapping, index);
2069 if (!*pagep)
2070 return -ENOMEM;
2071
2072 if (PageUptodate(*pagep))
Steve French8a236262007-03-06 00:31:00 +00002073 return 0;
2074
2075 /* If we are writing a full page it will be up to date,
2076 no need to read from the server */
Nick Piggind9414772008-09-24 11:32:59 -04002077 if (len == PAGE_CACHE_SIZE && flags & AOP_FLAG_UNINTERRUPTIBLE)
Steve French8a236262007-03-06 00:31:00 +00002078 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002079
Nick Piggind9414772008-09-24 11:32:59 -04002080 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2081 int rc;
Steve French8a236262007-03-06 00:31:00 +00002082
Steve French8a236262007-03-06 00:31:00 +00002083 /* might as well read a page, it is fast enough */
Nick Piggind9414772008-09-24 11:32:59 -04002084 rc = cifs_readpage_worker(file, *pagep, &offset);
2085
2086 /* we do not need to pass errors back
2087 e.g. if we do not have read access to the file
2088 because cifs_write_end will attempt synchronous writes
2089 -- shaggy */
Steve French8a236262007-03-06 00:31:00 +00002090 } else {
2091 /* we could try using another file handle if there is one -
2092 but how would we lock it to prevent close of that handle
2093 racing with this read? In any case
Nick Piggind9414772008-09-24 11:32:59 -04002094 this will be written out by write_end so is fine */
Steve French8a236262007-03-06 00:31:00 +00002095 }
2096
Linus Torvalds1da177e2005-04-16 15:20:36 -07002097 return 0;
2098}
2099
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002100const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002101 .readpage = cifs_readpage,
2102 .readpages = cifs_readpages,
2103 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002104 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002105 .write_begin = cifs_write_begin,
2106 .write_end = cifs_write_end,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002107 .set_page_dirty = __set_page_dirty_nobuffers,
2108 /* .sync_page = cifs_sync_page, */
2109 /* .direct_IO = */
2110};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002111
2112/*
2113 * cifs_readpages requires the server to support a buffer large enough to
2114 * contain the header plus one complete page of data. Otherwise, we need
2115 * to leave cifs_readpages out of the address space operations.
2116 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002117const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002118 .readpage = cifs_readpage,
2119 .writepage = cifs_writepage,
2120 .writepages = cifs_writepages,
Nick Piggind9414772008-09-24 11:32:59 -04002121 .write_begin = cifs_write_begin,
2122 .write_end = cifs_write_end,
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002123 .set_page_dirty = __set_page_dirty_nobuffers,
2124 /* .sync_page = cifs_sync_page, */
2125 /* .direct_IO = */
2126};