blob: 914b449f202e5dfe7bd6587242e85180cfad64fa [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
2 * fs/cifs/file.c
3 *
4 * vfs operations that deal with files
5 *
6 * Copyright (C) International Business Machines Corp., 2002,2003
7 * 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>
30#include <linux/smp_lock.h>
Steve French37c0eb42005-10-05 14:50:29 -070031#include <linux/writeback.h>
Andrew Morton6f88cc22006-12-10 02:19:44 -080032#include <linux/task_io_accounting_ops.h>
Steve French23e7dd72005-10-20 13:44:56 -070033#include <linux/delay.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070034#include <asm/div64.h>
35#include "cifsfs.h"
36#include "cifspdu.h"
37#include "cifsglob.h"
38#include "cifsproto.h"
39#include "cifs_unicode.h"
40#include "cifs_debug.h"
41#include "cifs_fs_sb.h"
42
43static inline struct cifsFileInfo *cifs_init_private(
44 struct cifsFileInfo *private_data, struct inode *inode,
45 struct file *file, __u16 netfid)
46{
47 memset(private_data, 0, sizeof(struct cifsFileInfo));
48 private_data->netfid = netfid;
49 private_data->pid = current->tgid;
50 init_MUTEX(&private_data->fh_sem);
Jeremy Allison7ee1af72006-08-02 21:56:33 +000051 init_MUTEX(&private_data->lock_sem);
52 INIT_LIST_HEAD(&private_data->llist);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 private_data->pfile = file; /* needed for writepage */
54 private_data->pInode = inode;
55 private_data->invalidHandle = FALSE;
56 private_data->closePend = FALSE;
Steve French23e7dd72005-10-20 13:44:56 -070057 /* we have to track num writers to the inode, since writepages
58 does not tell us which handle the write is for so there can
59 be a close (overlapping with write) of the filehandle that
60 cifs_writepages chose to use */
61 atomic_set(&private_data->wrtPending,0);
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
63 return private_data;
64}
65
66static inline int cifs_convert_flags(unsigned int flags)
67{
68 if ((flags & O_ACCMODE) == O_RDONLY)
69 return GENERIC_READ;
70 else if ((flags & O_ACCMODE) == O_WRONLY)
71 return GENERIC_WRITE;
72 else if ((flags & O_ACCMODE) == O_RDWR) {
73 /* GENERIC_ALL is too much permission to request
74 can cause unnecessary access denied on create */
75 /* return GENERIC_ALL; */
76 return (GENERIC_READ | GENERIC_WRITE);
77 }
78
79 return 0x20197;
80}
81
82static inline int cifs_get_disposition(unsigned int flags)
83{
84 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
85 return FILE_CREATE;
86 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
87 return FILE_OVERWRITE_IF;
88 else if ((flags & O_CREAT) == O_CREAT)
89 return FILE_OPEN_IF;
Steve French55aa2e02006-05-30 18:09:31 +000090 else if ((flags & O_TRUNC) == O_TRUNC)
91 return FILE_OVERWRITE;
Linus Torvalds1da177e2005-04-16 15:20:36 -070092 else
93 return FILE_OPEN;
94}
95
96/* all arguments to this function must be checked for validity in caller */
97static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
98 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
99 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
100 char *full_path, int xid)
101{
102 struct timespec temp;
103 int rc;
104
105 /* want handles we can use to read with first
106 in the list so we do not have to walk the
107 list to search for one in prepare_write */
108 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
109 list_add_tail(&pCifsFile->flist,
110 &pCifsInode->openFileList);
111 } else {
112 list_add(&pCifsFile->flist,
113 &pCifsInode->openFileList);
114 }
115 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700116 if (pCifsInode->clientCanCacheRead) {
117 /* we have the inode open somewhere else
118 no need to discard cache data */
119 goto client_can_cache;
120 }
121
122 /* BB need same check in cifs_create too? */
123 /* if not oplocked, invalidate inode pages if mtime or file
124 size changed */
125 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800126 if (timespec_equal(&file->f_path.dentry->d_inode->i_mtime, &temp) &&
127 (file->f_path.dentry->d_inode->i_size ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128 (loff_t)le64_to_cpu(buf->EndOfFile))) {
129 cFYI(1, ("inode unchanged on server"));
130 } else {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800131 if (file->f_path.dentry->d_inode->i_mapping) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 /* BB no need to lock inode until after invalidate
133 since namei code should already have it locked? */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800134 filemap_write_and_wait(file->f_path.dentry->d_inode->i_mapping);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700135 }
136 cFYI(1, ("invalidating remote inode since open detected it "
137 "changed"));
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800138 invalidate_remote_inode(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 }
140
141client_can_cache:
142 if (pTcon->ses->capabilities & CAP_UNIX)
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800143 rc = cifs_get_inode_info_unix(&file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 full_path, inode->i_sb, xid);
145 else
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800146 rc = cifs_get_inode_info(&file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 full_path, buf, inode->i_sb, xid);
148
149 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
150 pCifsInode->clientCanCacheAll = TRUE;
151 pCifsInode->clientCanCacheRead = TRUE;
152 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800153 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700154 } else if ((*oplock & 0xF) == OPLOCK_READ)
155 pCifsInode->clientCanCacheRead = TRUE;
156
157 return rc;
158}
159
160int cifs_open(struct inode *inode, struct file *file)
161{
162 int rc = -EACCES;
163 int xid, oplock;
164 struct cifs_sb_info *cifs_sb;
165 struct cifsTconInfo *pTcon;
166 struct cifsFileInfo *pCifsFile;
167 struct cifsInodeInfo *pCifsInode;
168 struct list_head *tmp;
169 char *full_path = NULL;
170 int desiredAccess;
171 int disposition;
172 __u16 netfid;
173 FILE_ALL_INFO *buf = NULL;
174
175 xid = GetXid();
176
177 cifs_sb = CIFS_SB(inode->i_sb);
178 pTcon = cifs_sb->tcon;
179
180 if (file->f_flags & O_CREAT) {
181 /* search inode for this file and fill in file->private_data */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800182 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700183 read_lock(&GlobalSMBSeslock);
184 list_for_each(tmp, &pCifsInode->openFileList) {
185 pCifsFile = list_entry(tmp, struct cifsFileInfo,
186 flist);
187 if ((pCifsFile->pfile == NULL) &&
188 (pCifsFile->pid == current->tgid)) {
189 /* mode set in cifs_create */
190
191 /* needed for writepage */
192 pCifsFile->pfile = file;
193
194 file->private_data = pCifsFile;
195 break;
196 }
197 }
198 read_unlock(&GlobalSMBSeslock);
199 if (file->private_data != NULL) {
200 rc = 0;
201 FreeXid(xid);
202 return rc;
203 } else {
204 if (file->f_flags & O_EXCL)
205 cERROR(1, ("could not find file instance for "
Steve French26a21b92006-05-31 18:05:34 +0000206 "new file %p", file));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700207 }
208 }
209
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800210 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700211 if (full_path == NULL) {
212 FreeXid(xid);
213 return -ENOMEM;
214 }
215
216 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
217 inode, file->f_flags, full_path));
218 desiredAccess = cifs_convert_flags(file->f_flags);
219
220/*********************************************************************
221 * open flag mapping table:
222 *
223 * POSIX Flag CIFS Disposition
224 * ---------- ----------------
225 * O_CREAT FILE_OPEN_IF
226 * O_CREAT | O_EXCL FILE_CREATE
227 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
228 * O_TRUNC FILE_OVERWRITE
229 * none of the above FILE_OPEN
230 *
231 * Note that there is not a direct match between disposition
232 * FILE_SUPERSEDE (ie create whether or not file exists although
233 * O_CREAT | O_TRUNC is similar but truncates the existing
234 * file rather than creating a new file as FILE_SUPERSEDE does
235 * (which uses the attributes / metadata passed in on open call)
236 *?
237 *? O_SYNC is a reasonable match to CIFS writethrough flag
238 *? and the read write flags match reasonably. O_LARGEFILE
239 *? is irrelevant because largefile support is always used
240 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
241 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
242 *********************************************************************/
243
244 disposition = cifs_get_disposition(file->f_flags);
245
246 if (oplockEnabled)
247 oplock = REQ_OPLOCK;
248 else
249 oplock = FALSE;
250
251 /* BB pass O_SYNC flag through on file attributes .. BB */
252
253 /* Also refresh inode by passing in file_info buf returned by SMBOpen
254 and calling get_inode_info with returned buf (at least helps
255 non-Unix server case) */
256
257 /* BB we can not do this if this is the second open of a file
258 and the first handle has writebehind data, we might be
259 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
260 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
261 if (!buf) {
262 rc = -ENOMEM;
263 goto out;
264 }
Steve French5bafd762006-06-07 00:18:43 +0000265
266 if (cifs_sb->tcon->ses->capabilities & CAP_NT_SMBS)
267 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition,
268 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
Steve French737b7582005-04-28 22:41:06 -0700269 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
270 & CIFS_MOUNT_MAP_SPECIAL_CHR);
Steve French5bafd762006-06-07 00:18:43 +0000271 else
272 rc = -EIO; /* no NT SMB support fall into legacy open below */
273
Steve Frencha9d02ad2005-08-24 23:06:05 -0700274 if (rc == -EIO) {
275 /* Old server, try legacy style OpenX */
276 rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
277 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
278 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
279 & CIFS_MOUNT_MAP_SPECIAL_CHR);
280 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700281 if (rc) {
Steve French26a21b92006-05-31 18:05:34 +0000282 cFYI(1, ("cifs_open returned 0x%x", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700283 goto out;
284 }
285 file->private_data =
286 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
287 if (file->private_data == NULL) {
288 rc = -ENOMEM;
289 goto out;
290 }
291 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 write_lock(&GlobalSMBSeslock);
293 list_add(&pCifsFile->tlist, &pTcon->openFileList);
294
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800295 pCifsInode = CIFS_I(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 if (pCifsInode) {
297 rc = cifs_open_inode_helper(inode, file, pCifsInode,
298 pCifsFile, pTcon,
299 &oplock, buf, full_path, xid);
300 } else {
301 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302 }
303
304 if (oplock & CIFS_CREATE_ACTION) {
305 /* time to set mode which we can not set earlier due to
306 problems creating new read-only files */
307 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
308 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
309 inode->i_mode,
310 (__u64)-1, (__u64)-1, 0 /* dev */,
Steve French737b7582005-04-28 22:41:06 -0700311 cifs_sb->local_nls,
312 cifs_sb->mnt_cifs_flags &
313 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 } else {
315 /* BB implement via Windows security descriptors eg
316 CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
317 -1, -1, local_nls);
318 in the meantime could set r/o dos attribute when
319 perms are eg: mode & 0222 == 0 */
320 }
321 }
322
323out:
324 kfree(buf);
325 kfree(full_path);
326 FreeXid(xid);
327 return rc;
328}
329
Adrian Bunk04187262006-06-30 18:23:04 +0200330/* Try to reacquire byte range locks that were released when session */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700331/* to server was lost */
332static int cifs_relock_file(struct cifsFileInfo *cifsFile)
333{
334 int rc = 0;
335
336/* BB list all locks open on this file and relock */
337
338 return rc;
339}
340
341static int cifs_reopen_file(struct inode *inode, struct file *file,
342 int can_flush)
343{
344 int rc = -EACCES;
345 int xid, oplock;
346 struct cifs_sb_info *cifs_sb;
347 struct cifsTconInfo *pTcon;
348 struct cifsFileInfo *pCifsFile;
349 struct cifsInodeInfo *pCifsInode;
350 char *full_path = NULL;
351 int desiredAccess;
352 int disposition = FILE_OPEN;
353 __u16 netfid;
354
355 if (inode == NULL)
356 return -EBADF;
357 if (file->private_data) {
358 pCifsFile = (struct cifsFileInfo *)file->private_data;
359 } else
360 return -EBADF;
361
362 xid = GetXid();
363 down(&pCifsFile->fh_sem);
364 if (pCifsFile->invalidHandle == FALSE) {
365 up(&pCifsFile->fh_sem);
366 FreeXid(xid);
367 return 0;
368 }
369
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800370 if (file->f_path.dentry == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700371 up(&pCifsFile->fh_sem);
372 cFYI(1, ("failed file reopen, no valid name if dentry freed"));
373 FreeXid(xid);
374 return -EBADF;
375 }
376 cifs_sb = CIFS_SB(inode->i_sb);
377 pTcon = cifs_sb->tcon;
378/* can not grab rename sem here because various ops, including
379 those that already have the rename sem can end up causing writepage
380 to get called and if the server was down that means we end up here,
381 and we can never tell if the caller already has the rename_sem */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800382 full_path = build_path_from_dentry(file->f_path.dentry);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700383 if (full_path == NULL) {
384 up(&pCifsFile->fh_sem);
385 FreeXid(xid);
386 return -ENOMEM;
387 }
388
389 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
390 inode, file->f_flags,full_path));
391 desiredAccess = cifs_convert_flags(file->f_flags);
392
393 if (oplockEnabled)
394 oplock = REQ_OPLOCK;
395 else
396 oplock = FALSE;
397
398 /* Can not refresh inode by passing in file_info buf to be returned
399 by SMBOpen and then calling get_inode_info with returned buf
400 since file might have write behind data that needs to be flushed
401 and server version of file size can be stale. If we knew for sure
402 that inode was not dirty locally we could do this */
403
404/* buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
405 if (buf == 0) {
406 up(&pCifsFile->fh_sem);
407 kfree(full_path);
408 FreeXid(xid);
409 return -ENOMEM;
410 } */
411 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
412 CREATE_NOT_DIR, &netfid, &oplock, NULL,
Steve French737b7582005-04-28 22:41:06 -0700413 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
414 CIFS_MOUNT_MAP_SPECIAL_CHR);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 if (rc) {
416 up(&pCifsFile->fh_sem);
Steve French26a21b92006-05-31 18:05:34 +0000417 cFYI(1, ("cifs_open returned 0x%x", rc));
418 cFYI(1, ("oplock: %d", oplock));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700419 } else {
420 pCifsFile->netfid = netfid;
421 pCifsFile->invalidHandle = FALSE;
422 up(&pCifsFile->fh_sem);
423 pCifsInode = CIFS_I(inode);
424 if (pCifsInode) {
425 if (can_flush) {
OGAWA Hirofumi28fd1292006-01-08 01:02:14 -0800426 filemap_write_and_wait(inode->i_mapping);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700427 /* temporarily disable caching while we
428 go to server to get inode info */
429 pCifsInode->clientCanCacheAll = FALSE;
430 pCifsInode->clientCanCacheRead = FALSE;
431 if (pTcon->ses->capabilities & CAP_UNIX)
432 rc = cifs_get_inode_info_unix(&inode,
433 full_path, inode->i_sb, xid);
434 else
435 rc = cifs_get_inode_info(&inode,
436 full_path, NULL, inode->i_sb,
437 xid);
438 } /* else we are writing out data to server already
439 and could deadlock if we tried to flush data, and
440 since we do not know if we have data that would
441 invalidate the current end of file on the server
442 we can not go to the server to get the new inod
443 info */
444 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
445 pCifsInode->clientCanCacheAll = TRUE;
446 pCifsInode->clientCanCacheRead = TRUE;
447 cFYI(1, ("Exclusive Oplock granted on inode %p",
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800448 file->f_path.dentry->d_inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 } else if ((oplock & 0xF) == OPLOCK_READ) {
450 pCifsInode->clientCanCacheRead = TRUE;
451 pCifsInode->clientCanCacheAll = FALSE;
452 } else {
453 pCifsInode->clientCanCacheRead = FALSE;
454 pCifsInode->clientCanCacheAll = FALSE;
455 }
456 cifs_relock_file(pCifsFile);
457 }
458 }
459
460 kfree(full_path);
461 FreeXid(xid);
462 return rc;
463}
464
465int cifs_close(struct inode *inode, struct file *file)
466{
467 int rc = 0;
468 int xid;
469 struct cifs_sb_info *cifs_sb;
470 struct cifsTconInfo *pTcon;
471 struct cifsFileInfo *pSMBFile =
472 (struct cifsFileInfo *)file->private_data;
473
474 xid = GetXid();
475
476 cifs_sb = CIFS_SB(inode->i_sb);
477 pTcon = cifs_sb->tcon;
478 if (pSMBFile) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000479 struct cifsLockInfo *li, *tmp;
480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 pSMBFile->closePend = TRUE;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700482 if (pTcon) {
483 /* no sense reconnecting to close a file that is
484 already closed */
485 if (pTcon->tidStatus != CifsNeedReconnect) {
Steve French23e7dd72005-10-20 13:44:56 -0700486 int timeout = 2;
487 while((atomic_read(&pSMBFile->wrtPending) != 0)
488 && (timeout < 1000) ) {
489 /* Give write a better chance to get to
490 server ahead of the close. We do not
491 want to add a wait_q here as it would
492 increase the memory utilization as
493 the struct would be in each open file,
494 but this should give enough time to
495 clear the socket */
Steve French4891d532006-11-07 16:31:16 +0000496#ifdef CONFIG_CIFS_DEBUG2
497 cFYI(1,("close delay, write pending"));
498#endif /* DEBUG2 */
Steve French23e7dd72005-10-20 13:44:56 -0700499 msleep(timeout);
500 timeout *= 4;
Steve French4891d532006-11-07 16:31:16 +0000501 }
Steve Frenchf7b2e8c2006-11-09 21:25:37 +0000502 if(atomic_read(&pSMBFile->wrtPending))
503 cERROR(1,("close with pending writes"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700504 rc = CIFSSMBClose(xid, pTcon,
505 pSMBFile->netfid);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700506 }
507 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000508
509 /* Delete any outstanding lock records.
510 We'll lose them when the file is closed anyway. */
511 down(&pSMBFile->lock_sem);
512 list_for_each_entry_safe(li, tmp, &pSMBFile->llist, llist) {
513 list_del(&li->llist);
514 kfree(li);
515 }
516 up(&pSMBFile->lock_sem);
517
Steve Frenchcbe04762005-04-28 22:41:05 -0700518 write_lock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 list_del(&pSMBFile->flist);
520 list_del(&pSMBFile->tlist);
Steve Frenchcbe04762005-04-28 22:41:05 -0700521 write_unlock(&GlobalSMBSeslock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700522 kfree(pSMBFile->search_resume_name);
523 kfree(file->private_data);
524 file->private_data = NULL;
525 } else
526 rc = -EBADF;
527
528 if (list_empty(&(CIFS_I(inode)->openFileList))) {
529 cFYI(1, ("closing last open instance for inode %p", inode));
530 /* if the file is not open we do not know if we can cache info
531 on this inode, much less write behind and read ahead */
532 CIFS_I(inode)->clientCanCacheRead = FALSE;
533 CIFS_I(inode)->clientCanCacheAll = FALSE;
534 }
535 if ((rc ==0) && CIFS_I(inode)->write_behind_rc)
536 rc = CIFS_I(inode)->write_behind_rc;
537 FreeXid(xid);
538 return rc;
539}
540
541int cifs_closedir(struct inode *inode, struct file *file)
542{
543 int rc = 0;
544 int xid;
545 struct cifsFileInfo *pCFileStruct =
546 (struct cifsFileInfo *)file->private_data;
547 char *ptmp;
548
Steve French26a21b92006-05-31 18:05:34 +0000549 cFYI(1, ("Closedir inode = 0x%p", inode));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700550
551 xid = GetXid();
552
553 if (pCFileStruct) {
554 struct cifsTconInfo *pTcon;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800555 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556
557 pTcon = cifs_sb->tcon;
558
559 cFYI(1, ("Freeing private data in close dir"));
Steve French31ca3bc2005-04-28 22:41:11 -0700560 if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
561 (pCFileStruct->invalidHandle == FALSE)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700562 pCFileStruct->invalidHandle = TRUE;
563 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
564 cFYI(1, ("Closing uncompleted readdir with rc %d",
565 rc));
566 /* not much we can do if it fails anyway, ignore rc */
567 rc = 0;
568 }
569 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
570 if (ptmp) {
Steve Frenchec637e32005-12-12 20:53:18 -0800571 cFYI(1, ("closedir free smb buf in srch struct"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700572 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000573 if(pCFileStruct->srch_inf.smallBuf)
574 cifs_small_buf_release(ptmp);
575 else
576 cifs_buf_release(ptmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700577 }
578 ptmp = pCFileStruct->search_resume_name;
579 if (ptmp) {
Steve Frenchec637e32005-12-12 20:53:18 -0800580 cFYI(1, ("closedir free resume name"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581 pCFileStruct->search_resume_name = NULL;
582 kfree(ptmp);
583 }
584 kfree(file->private_data);
585 file->private_data = NULL;
586 }
587 /* BB can we lock the filestruct while this is going on? */
588 FreeXid(xid);
589 return rc;
590}
591
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000592static int store_file_lock(struct cifsFileInfo *fid, __u64 len,
593 __u64 offset, __u8 lockType)
594{
595 struct cifsLockInfo *li = kmalloc(sizeof(struct cifsLockInfo), GFP_KERNEL);
596 if (li == NULL)
597 return -ENOMEM;
598 li->offset = offset;
599 li->length = len;
600 li->type = lockType;
601 down(&fid->lock_sem);
602 list_add(&li->llist, &fid->llist);
603 up(&fid->lock_sem);
604 return 0;
605}
606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
608{
609 int rc, xid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 __u32 numLock = 0;
611 __u32 numUnlock = 0;
612 __u64 length;
613 int wait_flag = FALSE;
614 struct cifs_sb_info *cifs_sb;
615 struct cifsTconInfo *pTcon;
Steve French08547b02006-02-28 22:39:25 +0000616 __u16 netfid;
617 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000618 int posix_locking;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700619
620 length = 1 + pfLock->fl_end - pfLock->fl_start;
621 rc = -EACCES;
622 xid = GetXid();
623
624 cFYI(1, ("Lock parm: 0x%x flockflags: "
625 "0x%x flocktype: 0x%x start: %lld end: %lld",
626 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
627 pfLock->fl_end));
628
629 if (pfLock->fl_flags & FL_POSIX)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000630 cFYI(1, ("Posix"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631 if (pfLock->fl_flags & FL_FLOCK)
Steve Frenchd47d7c12006-02-28 03:45:48 +0000632 cFYI(1, ("Flock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 if (pfLock->fl_flags & FL_SLEEP) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000634 cFYI(1, ("Blocking lock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700635 wait_flag = TRUE;
636 }
637 if (pfLock->fl_flags & FL_ACCESS)
638 cFYI(1, ("Process suspended by mandatory locking - "
Steve French26a21b92006-05-31 18:05:34 +0000639 "not implemented yet"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 if (pfLock->fl_flags & FL_LEASE)
641 cFYI(1, ("Lease on file - not implemented yet"));
642 if (pfLock->fl_flags &
643 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
644 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
645
646 if (pfLock->fl_type == F_WRLCK) {
647 cFYI(1, ("F_WRLCK "));
648 numLock = 1;
649 } else if (pfLock->fl_type == F_UNLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000650 cFYI(1, ("F_UNLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651 numUnlock = 1;
Steve Frenchd47d7c12006-02-28 03:45:48 +0000652 /* Check if unlock includes more than
653 one lock range */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700654 } else if (pfLock->fl_type == F_RDLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000655 cFYI(1, ("F_RDLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 lockType |= LOCKING_ANDX_SHARED_LOCK;
657 numLock = 1;
658 } else if (pfLock->fl_type == F_EXLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000659 cFYI(1, ("F_EXLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 numLock = 1;
661 } else if (pfLock->fl_type == F_SHLCK) {
Steve Frenchd47d7c12006-02-28 03:45:48 +0000662 cFYI(1, ("F_SHLCK"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700663 lockType |= LOCKING_ANDX_SHARED_LOCK;
664 numLock = 1;
665 } else
Steve Frenchd47d7c12006-02-28 03:45:48 +0000666 cFYI(1, ("Unknown type of lock"));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700667
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800668 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 pTcon = cifs_sb->tcon;
670
671 if (file->private_data == NULL) {
672 FreeXid(xid);
673 return -EBADF;
674 }
Steve French08547b02006-02-28 22:39:25 +0000675 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000677 posix_locking = (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
678 (CIFS_UNIX_FCNTL_CAP & le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability));
Steve French08547b02006-02-28 22:39:25 +0000679
680 /* BB add code here to normalize offset and length to
681 account for negative length which we can not accept over the
682 wire */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700683 if (IS_GETLK(cmd)) {
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000684 if(posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000685 int posix_lock_type;
686 if(lockType & LOCKING_ANDX_SHARED_LOCK)
687 posix_lock_type = CIFS_RDLCK;
688 else
689 posix_lock_type = CIFS_WRLCK;
690 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 1 /* get */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000691 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000692 posix_lock_type, wait_flag);
693 FreeXid(xid);
694 return rc;
695 }
696
697 /* BB we could chain these into one lock request BB */
698 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
699 0, 1, lockType, 0 /* wait flag */ );
Linus Torvalds1da177e2005-04-16 15:20:36 -0700700 if (rc == 0) {
Steve French08547b02006-02-28 22:39:25 +0000701 rc = CIFSSMBLock(xid, pTcon, netfid, length,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 pfLock->fl_start, 1 /* numUnlock */ ,
703 0 /* numLock */ , lockType,
704 0 /* wait flag */ );
705 pfLock->fl_type = F_UNLCK;
706 if (rc != 0)
707 cERROR(1, ("Error unlocking previously locked "
Steve French08547b02006-02-28 22:39:25 +0000708 "range %d during test of lock", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 rc = 0;
710
711 } else {
712 /* if rc == ERR_SHARING_VIOLATION ? */
713 rc = 0; /* do not change lock type to unlock
714 since range in use */
715 }
716
717 FreeXid(xid);
718 return rc;
719 }
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000720
721 if (!numLock && !numUnlock) {
722 /* if no lock or unlock then nothing
723 to do since we do not know what it is */
724 FreeXid(xid);
725 return -EOPNOTSUPP;
726 }
727
728 if (posix_locking) {
Steve French08547b02006-02-28 22:39:25 +0000729 int posix_lock_type;
730 if(lockType & LOCKING_ANDX_SHARED_LOCK)
731 posix_lock_type = CIFS_RDLCK;
732 else
733 posix_lock_type = CIFS_WRLCK;
734
735 if(numUnlock == 1)
Steve Frenchbeb84dc2006-03-03 23:36:34 +0000736 posix_lock_type = CIFS_UNLCK;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000737
Steve French08547b02006-02-28 22:39:25 +0000738 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
Steve Frenchfc94cdb2006-05-30 18:03:32 +0000739 length, pfLock,
Steve French08547b02006-02-28 22:39:25 +0000740 posix_lock_type, wait_flag);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000741 } else {
742 struct cifsFileInfo *fid = (struct cifsFileInfo *)file->private_data;
743
744 if (numLock) {
745 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
746 0, numLock, lockType, wait_flag);
747
748 if (rc == 0) {
749 /* For Windows locks we must store them. */
750 rc = store_file_lock(fid, length,
751 pfLock->fl_start, lockType);
752 }
753 } else if (numUnlock) {
754 /* For each stored lock that this unlock overlaps
755 completely, unlock it. */
756 int stored_rc = 0;
757 struct cifsLockInfo *li, *tmp;
758
Steve French6b70c952006-09-21 07:35:29 +0000759 rc = 0;
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000760 down(&fid->lock_sem);
761 list_for_each_entry_safe(li, tmp, &fid->llist, llist) {
762 if (pfLock->fl_start <= li->offset &&
763 length >= li->length) {
764 stored_rc = CIFSSMBLock(xid, pTcon, netfid,
765 li->length, li->offset,
766 1, 0, li->type, FALSE);
767 if (stored_rc)
768 rc = stored_rc;
769
770 list_del(&li->llist);
771 kfree(li);
772 }
773 }
Steve French6b70c952006-09-21 07:35:29 +0000774 up(&fid->lock_sem);
Jeremy Allison7ee1af72006-08-02 21:56:33 +0000775 }
776 }
777
Steve Frenchd634cc12005-08-26 14:42:59 -0500778 if (pfLock->fl_flags & FL_POSIX)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700779 posix_lock_file_wait(file, pfLock);
780 FreeXid(xid);
781 return rc;
782}
783
784ssize_t cifs_user_write(struct file *file, const char __user *write_data,
785 size_t write_size, loff_t *poffset)
786{
787 int rc = 0;
788 unsigned int bytes_written = 0;
789 unsigned int total_written;
790 struct cifs_sb_info *cifs_sb;
791 struct cifsTconInfo *pTcon;
792 int xid, long_op;
793 struct cifsFileInfo *open_file;
794
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800795 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796
797 pTcon = cifs_sb->tcon;
798
799 /* cFYI(1,
800 (" write %d bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800801 *poffset, file->f_path.dentry->d_name.name)); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700802
803 if (file->private_data == NULL)
804 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000805 open_file = (struct cifsFileInfo *) file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700806
807 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700808
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800809 if (*poffset > file->f_path.dentry->d_inode->i_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700810 long_op = 2; /* writes past end of file can take a long time */
811 else
812 long_op = 1;
813
814 for (total_written = 0; write_size > total_written;
815 total_written += bytes_written) {
816 rc = -EAGAIN;
817 while (rc == -EAGAIN) {
818 if (file->private_data == NULL) {
819 /* file has been closed on us */
820 FreeXid(xid);
821 /* if we have gotten here we have written some data
822 and blocked, and the file has been freed on us while
823 we blocked so return what we managed to write */
824 return total_written;
825 }
826 if (open_file->closePend) {
827 FreeXid(xid);
828 if (total_written)
829 return total_written;
830 else
831 return -EBADF;
832 }
833 if (open_file->invalidHandle) {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800834 if ((file->f_path.dentry == NULL) ||
835 (file->f_path.dentry->d_inode == NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700836 FreeXid(xid);
837 return total_written;
838 }
839 /* we could deadlock if we called
840 filemap_fdatawait from here so tell
841 reopen_file not to flush data to server
842 now */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800843 rc = cifs_reopen_file(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700844 file, FALSE);
845 if (rc != 0)
846 break;
847 }
848
849 rc = CIFSSMBWrite(xid, pTcon,
850 open_file->netfid,
851 min_t(const int, cifs_sb->wsize,
852 write_size - total_written),
853 *poffset, &bytes_written,
854 NULL, write_data + total_written, long_op);
855 }
856 if (rc || (bytes_written == 0)) {
857 if (total_written)
858 break;
859 else {
860 FreeXid(xid);
861 return rc;
862 }
863 } else
864 *poffset += bytes_written;
865 long_op = FALSE; /* subsequent writes fast -
866 15 seconds is plenty */
867 }
868
Steve Frencha4544342005-08-24 13:59:35 -0700869 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700870
871 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +0000872 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
873 struct inode *inode = file->f_path.dentry->d_inode;
874/* Do not update local mtime - server will set its actual value on write
875 * inode->i_ctime = inode->i_mtime =
876 * current_fs_time(inode->i_sb);*/
877 if (total_written > 0) {
878 spin_lock(&inode->i_lock);
879 if (*poffset > file->f_path.dentry->d_inode->i_size)
880 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881 *poffset);
Steve French3677db12007-02-26 16:46:11 +0000882 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700883 }
Steve French3677db12007-02-26 16:46:11 +0000884 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 }
886 FreeXid(xid);
887 return total_written;
888}
889
890static ssize_t cifs_write(struct file *file, const char *write_data,
891 size_t write_size, loff_t *poffset)
892{
893 int rc = 0;
894 unsigned int bytes_written = 0;
895 unsigned int total_written;
896 struct cifs_sb_info *cifs_sb;
897 struct cifsTconInfo *pTcon;
898 int xid, long_op;
899 struct cifsFileInfo *open_file;
900
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800901 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700902
903 pTcon = cifs_sb->tcon;
904
Steve Frenchab2f2182005-09-15 20:44:50 -0700905 cFYI(1,("write %zd bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800906 *poffset, file->f_path.dentry->d_name.name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907
908 if (file->private_data == NULL)
909 return -EBADF;
Christoph Hellwigc33f8d32007-04-02 18:47:20 +0000910 open_file = (struct cifsFileInfo *)file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700911
912 xid = GetXid();
Linus Torvalds1da177e2005-04-16 15:20:36 -0700913
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800914 if (*poffset > file->f_path.dentry->d_inode->i_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 long_op = 2; /* writes past end of file can take a long time */
916 else
917 long_op = 1;
918
919 for (total_written = 0; write_size > total_written;
920 total_written += bytes_written) {
921 rc = -EAGAIN;
922 while (rc == -EAGAIN) {
923 if (file->private_data == NULL) {
924 /* file has been closed on us */
925 FreeXid(xid);
926 /* if we have gotten here we have written some data
927 and blocked, and the file has been freed on us
928 while we blocked so return what we managed to
929 write */
930 return total_written;
931 }
932 if (open_file->closePend) {
933 FreeXid(xid);
934 if (total_written)
935 return total_written;
936 else
937 return -EBADF;
938 }
939 if (open_file->invalidHandle) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700940 /* we could deadlock if we called
941 filemap_fdatawait from here so tell
942 reopen_file not to flush data to
943 server now */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800944 rc = cifs_reopen_file(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700945 file, FALSE);
946 if (rc != 0)
947 break;
948 }
Steve Frenchc01f36a2006-05-30 18:05:10 +0000949 if(experimEnabled || (pTcon->ses->server &&
Steve French08775832006-05-30 18:08:26 +0000950 ((pTcon->ses->server->secMode &
951 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +0000952 == 0))) {
Steve French3e844692005-10-03 13:37:24 -0700953 struct kvec iov[2];
954 unsigned int len;
955
Steve French0ae0efa2005-10-10 10:57:19 -0700956 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -0700957 write_size - total_written);
958 /* iov[0] is reserved for smb header */
959 iov[1].iov_base = (char *)write_data +
960 total_written;
961 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500962 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -0700963 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500964 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -0700965 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500966 } else
Steve French60808232006-04-22 15:53:05 +0000967 rc = CIFSSMBWrite(xid, pTcon,
968 open_file->netfid,
969 min_t(const int, cifs_sb->wsize,
970 write_size - total_written),
971 *poffset, &bytes_written,
972 write_data + total_written,
973 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700974 }
975 if (rc || (bytes_written == 0)) {
976 if (total_written)
977 break;
978 else {
979 FreeXid(xid);
980 return rc;
981 }
982 } else
983 *poffset += bytes_written;
984 long_op = FALSE; /* subsequent writes fast -
985 15 seconds is plenty */
986 }
987
Steve Frencha4544342005-08-24 13:59:35 -0700988 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989
990 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +0000991 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +0000992/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +0000993/* file->f_path.dentry->d_inode->i_ctime =
994 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
995 if (total_written > 0) {
996 spin_lock(&file->f_path.dentry->d_inode->i_lock);
997 if (*poffset > file->f_path.dentry->d_inode->i_size)
998 i_size_write(file->f_path.dentry->d_inode,
999 *poffset);
1000 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001001 }
Steve French3677db12007-02-26 16:46:11 +00001002 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001003 }
1004 FreeXid(xid);
1005 return total_written;
1006}
1007
Steve Frenchdd99cd82005-10-05 19:32:49 -07001008struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
Steve French6148a742005-10-05 12:23:19 -07001009{
1010 struct cifsFileInfo *open_file;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001011 int rc;
Steve French6148a742005-10-05 12:23:19 -07001012
Steve French60808232006-04-22 15:53:05 +00001013 /* Having a null inode here (because mapping->host was set to zero by
1014 the VFS or MM) should not happen but we had reports of on oops (due to
1015 it being zero) during stress testcases so we need to check for it */
1016
1017 if(cifs_inode == NULL) {
1018 cERROR(1,("Null inode passed to cifs_writeable_file"));
1019 dump_stack();
1020 return NULL;
1021 }
1022
Steve French6148a742005-10-05 12:23:19 -07001023 read_lock(&GlobalSMBSeslock);
1024 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1025 if (open_file->closePend)
1026 continue;
1027 if (open_file->pfile &&
1028 ((open_file->pfile->f_flags & O_RDWR) ||
1029 (open_file->pfile->f_flags & O_WRONLY))) {
Steve French23e7dd72005-10-20 13:44:56 -07001030 atomic_inc(&open_file->wrtPending);
Steve French6148a742005-10-05 12:23:19 -07001031 read_unlock(&GlobalSMBSeslock);
Steve French0ae0efa2005-10-10 10:57:19 -07001032 if((open_file->invalidHandle) &&
Steve French23e7dd72005-10-20 13:44:56 -07001033 (!open_file->closePend) /* BB fixme -since the second clause can not be true remove it BB */) {
Steve Frenchdd99cd82005-10-05 19:32:49 -07001034 rc = cifs_reopen_file(&cifs_inode->vfs_inode,
Steve French37c0eb42005-10-05 14:50:29 -07001035 open_file->pfile, FALSE);
1036 /* if it fails, try another handle - might be */
1037 /* dangerous to hold up writepages with retry */
1038 if(rc) {
Steve French4a771182005-10-05 15:14:33 -07001039 cFYI(1,("failed on reopen file in wp"));
Steve French37c0eb42005-10-05 14:50:29 -07001040 read_lock(&GlobalSMBSeslock);
Steve French23e7dd72005-10-20 13:44:56 -07001041 /* can not use this handle, no write
1042 pending on this one after all */
1043 atomic_dec
1044 (&open_file->wrtPending);
Steve French37c0eb42005-10-05 14:50:29 -07001045 continue;
1046 }
1047 }
Steve French6148a742005-10-05 12:23:19 -07001048 return open_file;
1049 }
1050 }
1051 read_unlock(&GlobalSMBSeslock);
1052 return NULL;
1053}
1054
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1056{
1057 struct address_space *mapping = page->mapping;
1058 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1059 char *write_data;
1060 int rc = -EFAULT;
1061 int bytes_written = 0;
1062 struct cifs_sb_info *cifs_sb;
1063 struct cifsTconInfo *pTcon;
1064 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001065 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066
1067 if (!mapping || !mapping->host)
1068 return -EFAULT;
1069
1070 inode = page->mapping->host;
1071 cifs_sb = CIFS_SB(inode->i_sb);
1072 pTcon = cifs_sb->tcon;
1073
1074 offset += (loff_t)from;
1075 write_data = kmap(page);
1076 write_data += from;
1077
1078 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1079 kunmap(page);
1080 return -EIO;
1081 }
1082
1083 /* racing with truncate? */
1084 if (offset > mapping->host->i_size) {
1085 kunmap(page);
1086 return 0; /* don't care */
1087 }
1088
1089 /* check to make sure that we are not extending the file */
1090 if (mapping->host->i_size - offset < (loff_t)to)
1091 to = (unsigned)(mapping->host->i_size - offset);
1092
Steve French6148a742005-10-05 12:23:19 -07001093 open_file = find_writable_file(CIFS_I(mapping->host));
1094 if (open_file) {
1095 bytes_written = cifs_write(open_file->pfile, write_data,
1096 to-from, &offset);
Steve French23e7dd72005-10-20 13:44:56 -07001097 atomic_dec(&open_file->wrtPending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001098 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001099 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1100 if ((bytes_written > 0) && (offset)) {
1101 rc = 0;
1102 } else if (bytes_written < 0) {
1103 if (rc != -EBADF)
1104 rc = bytes_written;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001105 }
Steve French6148a742005-10-05 12:23:19 -07001106 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107 cFYI(1, ("No writeable filehandles for inode"));
1108 rc = -EIO;
1109 }
1110
1111 kunmap(page);
1112 return rc;
1113}
1114
Linus Torvalds1da177e2005-04-16 15:20:36 -07001115static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001116 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001117{
Steve French37c0eb42005-10-05 14:50:29 -07001118 struct backing_dev_info *bdi = mapping->backing_dev_info;
1119 unsigned int bytes_to_write;
1120 unsigned int bytes_written;
1121 struct cifs_sb_info *cifs_sb;
1122 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001123 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001124 pgoff_t index;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001125 int range_whole = 0;
Steve French9a0c8232007-02-02 04:21:57 +00001126 struct kvec * iov;
Steve French84d2f072005-10-12 15:32:05 -07001127 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001128 int n_iov = 0;
1129 pgoff_t next;
1130 int nr_pages;
1131 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001132 struct cifsFileInfo *open_file;
Steve French37c0eb42005-10-05 14:50:29 -07001133 struct page *page;
1134 struct pagevec pvec;
1135 int rc = 0;
1136 int scanned = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001137 int xid;
1138
Steve French37c0eb42005-10-05 14:50:29 -07001139 cifs_sb = CIFS_SB(mapping->host->i_sb);
1140
1141 /*
1142 * If wsize is smaller that the page cache size, default to writing
1143 * one page at a time via cifs_writepage
1144 */
1145 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1146 return generic_writepages(mapping, wbc);
1147
Steve French4a771182005-10-05 15:14:33 -07001148 if((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1149 if(cifs_sb->tcon->ses->server->secMode &
1150 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve French9a0c8232007-02-02 04:21:57 +00001151 if(!experimEnabled)
Steve French60808232006-04-22 15:53:05 +00001152 return generic_writepages(mapping, wbc);
Steve French4a771182005-10-05 15:14:33 -07001153
Steve French9a0c8232007-02-02 04:21:57 +00001154 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1155 if(iov == NULL)
1156 return generic_writepages(mapping, wbc);
1157
1158
Steve French37c0eb42005-10-05 14:50:29 -07001159 /*
1160 * BB: Is this meaningful for a non-block-device file system?
1161 * If it is, we should test it again after we do I/O
1162 */
1163 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1164 wbc->encountered_congestion = 1;
Steve French9a0c8232007-02-02 04:21:57 +00001165 kfree(iov);
Steve French37c0eb42005-10-05 14:50:29 -07001166 return 0;
1167 }
1168
Linus Torvalds1da177e2005-04-16 15:20:36 -07001169 xid = GetXid();
1170
Steve French37c0eb42005-10-05 14:50:29 -07001171 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001172 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001173 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001174 end = -1;
1175 } else {
1176 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1177 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1178 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1179 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001180 scanned = 1;
1181 }
1182retry:
1183 while (!done && (index <= end) &&
1184 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1185 PAGECACHE_TAG_DIRTY,
1186 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1187 int first;
1188 unsigned int i;
1189
Steve French37c0eb42005-10-05 14:50:29 -07001190 first = -1;
1191 next = 0;
1192 n_iov = 0;
1193 bytes_to_write = 0;
1194
1195 for (i = 0; i < nr_pages; i++) {
1196 page = pvec.pages[i];
1197 /*
1198 * At this point we hold neither mapping->tree_lock nor
1199 * lock on the page itself: the page may be truncated or
1200 * invalidated (changing page->mapping to NULL), or even
1201 * swizzled back from swapper_space to tmpfs file
1202 * mapping
1203 */
1204
1205 if (first < 0)
1206 lock_page(page);
1207 else if (TestSetPageLocked(page))
1208 break;
1209
1210 if (unlikely(page->mapping != mapping)) {
1211 unlock_page(page);
1212 break;
1213 }
1214
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001215 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001216 done = 1;
1217 unlock_page(page);
1218 break;
1219 }
1220
1221 if (next && (page->index != next)) {
1222 /* Not next consecutive page */
1223 unlock_page(page);
1224 break;
1225 }
1226
1227 if (wbc->sync_mode != WB_SYNC_NONE)
1228 wait_on_page_writeback(page);
1229
1230 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001231 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001232 unlock_page(page);
1233 break;
1234 }
Steve French84d2f072005-10-12 15:32:05 -07001235
Linus Torvaldscb876f42006-12-23 16:19:07 -08001236 /*
1237 * This actually clears the dirty bit in the radix tree.
1238 * See cifs_writepage() for more commentary.
1239 */
1240 set_page_writeback(page);
1241
Steve French84d2f072005-10-12 15:32:05 -07001242 if (page_offset(page) >= mapping->host->i_size) {
1243 done = 1;
1244 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001245 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001246 break;
1247 }
1248
Steve French37c0eb42005-10-05 14:50:29 -07001249 /*
1250 * BB can we get rid of this? pages are held by pvec
1251 */
1252 page_cache_get(page);
1253
Steve French84d2f072005-10-12 15:32:05 -07001254 len = min(mapping->host->i_size - page_offset(page),
1255 (loff_t)PAGE_CACHE_SIZE);
1256
Steve French37c0eb42005-10-05 14:50:29 -07001257 /* reserve iov[0] for the smb header */
1258 n_iov++;
1259 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001260 iov[n_iov].iov_len = len;
1261 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001262
1263 if (first < 0) {
1264 first = i;
1265 offset = page_offset(page);
1266 }
1267 next = page->index + 1;
1268 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1269 break;
1270 }
1271 if (n_iov) {
Steve French23e7dd72005-10-20 13:44:56 -07001272 /* Search for a writable handle every time we call
1273 * CIFSSMBWrite2. We can't rely on the last handle
1274 * we used to still be valid
1275 */
1276 open_file = find_writable_file(CIFS_I(mapping->host));
1277 if (!open_file) {
1278 cERROR(1, ("No writable handles for inode"));
1279 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001280 } else {
Steve French23e7dd72005-10-20 13:44:56 -07001281 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1282 open_file->netfid,
1283 bytes_to_write, offset,
1284 &bytes_written, iov, n_iov,
1285 1);
1286 atomic_dec(&open_file->wrtPending);
1287 if (rc || bytes_written < bytes_to_write) {
1288 cERROR(1,("Write2 ret %d, written = %d",
1289 rc, bytes_written));
1290 /* BB what if continued retry is
1291 requested via mount flags? */
1292 set_bit(AS_EIO, &mapping->flags);
Steve French23e7dd72005-10-20 13:44:56 -07001293 } else {
1294 cifs_stats_bytes_written(cifs_sb->tcon,
1295 bytes_written);
1296 }
Steve French37c0eb42005-10-05 14:50:29 -07001297 }
1298 for (i = 0; i < n_iov; i++) {
1299 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001300 /* Should we also set page error on
1301 success rc but too little data written? */
1302 /* BB investigate retry logic on temporary
1303 server crash cases and how recovery works
1304 when page marked as error */
1305 if(rc)
1306 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001307 kunmap(page);
1308 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001309 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001310 page_cache_release(page);
1311 }
1312 if ((wbc->nr_to_write -= n_iov) <= 0)
1313 done = 1;
1314 index = next;
1315 }
1316 pagevec_release(&pvec);
1317 }
1318 if (!scanned && !done) {
1319 /*
1320 * We hit the last page and there is more work to be done: wrap
1321 * back to the start of the file
1322 */
1323 scanned = 1;
1324 index = 0;
1325 goto retry;
1326 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001327 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001328 mapping->writeback_index = index;
1329
Linus Torvalds1da177e2005-04-16 15:20:36 -07001330 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001331 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001332 return rc;
1333}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334
1335static int cifs_writepage(struct page* page, struct writeback_control *wbc)
1336{
1337 int rc = -EFAULT;
1338 int xid;
1339
1340 xid = GetXid();
1341/* BB add check for wbc flags */
1342 page_cache_get(page);
1343 if (!PageUptodate(page)) {
1344 cFYI(1, ("ppw - page not up to date"));
1345 }
Linus Torvaldscb876f42006-12-23 16:19:07 -08001346
1347 /*
1348 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1349 *
1350 * A writepage() implementation always needs to do either this,
1351 * or re-dirty the page with "redirty_page_for_writepage()" in
1352 * the case of a failure.
1353 *
1354 * Just unlocking the page will cause the radix tree tag-bits
1355 * to fail to update with the state of the page correctly.
1356 */
1357 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001358 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1359 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1360 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001361 end_page_writeback(page);
1362 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001363 FreeXid(xid);
1364 return rc;
1365}
1366
1367static int cifs_commit_write(struct file *file, struct page *page,
1368 unsigned offset, unsigned to)
1369{
1370 int xid;
1371 int rc = 0;
1372 struct inode *inode = page->mapping->host;
1373 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1374 char *page_data;
1375
1376 xid = GetXid();
1377 cFYI(1, ("commit write for page %p up to position %lld for %d",
1378 page, position, to));
Steve French3677db12007-02-26 16:46:11 +00001379 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001380 if (position > inode->i_size) {
1381 i_size_write(inode, position);
1382 /* if (file->private_data == NULL) {
1383 rc = -EBADF;
1384 } else {
1385 open_file = (struct cifsFileInfo *)file->private_data;
1386 cifs_sb = CIFS_SB(inode->i_sb);
1387 rc = -EAGAIN;
1388 while (rc == -EAGAIN) {
1389 if ((open_file->invalidHandle) &&
1390 (!open_file->closePend)) {
1391 rc = cifs_reopen_file(
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001392 file->f_path.dentry->d_inode, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001393 if (rc != 0)
1394 break;
1395 }
1396 if (!open_file->closePend) {
1397 rc = CIFSSMBSetFileSize(xid,
1398 cifs_sb->tcon, position,
1399 open_file->netfid,
1400 open_file->pid, FALSE);
1401 } else {
1402 rc = -EBADF;
1403 break;
1404 }
1405 }
1406 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1407 } */
1408 }
Steve French3677db12007-02-26 16:46:11 +00001409 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001410 if (!PageUptodate(page)) {
1411 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1412 /* can not rely on (or let) writepage write this data */
1413 if (to < offset) {
1414 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1415 offset, to));
1416 FreeXid(xid);
1417 return rc;
1418 }
1419 /* this is probably better than directly calling
1420 partialpage_write since in this function the file handle is
1421 known which we might as well leverage */
1422 /* BB check if anything else missing out of ppw
1423 such as updating last write time */
1424 page_data = kmap(page);
1425 rc = cifs_write(file, page_data + offset, to-offset,
1426 &position);
1427 if (rc > 0)
1428 rc = 0;
1429 /* else if (rc < 0) should we set writebehind rc? */
1430 kunmap(page);
1431 } else {
1432 set_page_dirty(page);
1433 }
1434
1435 FreeXid(xid);
1436 return rc;
1437}
1438
1439int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1440{
1441 int xid;
1442 int rc = 0;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001443 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001444
1445 xid = GetXid();
1446
Steve French26a21b92006-05-31 18:05:34 +00001447 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001448 dentry->d_name.name, datasync));
1449
1450 rc = filemap_fdatawrite(inode->i_mapping);
1451 if (rc == 0)
1452 CIFS_I(inode)->write_behind_rc = 0;
1453 FreeXid(xid);
1454 return rc;
1455}
1456
NeilBrown3978d712006-03-26 01:37:17 -08001457/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458{
1459 struct address_space *mapping;
1460 struct inode *inode;
1461 unsigned long index = page->index;
1462 unsigned int rpages = 0;
1463 int rc = 0;
1464
1465 cFYI(1, ("sync page %p",page));
1466 mapping = page->mapping;
1467 if (!mapping)
1468 return 0;
1469 inode = mapping->host;
1470 if (!inode)
NeilBrown3978d712006-03-26 01:37:17 -08001471 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472
1473/* fill in rpages then
1474 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1475
Steve French26a21b92006-05-31 18:05:34 +00001476/* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001477
NeilBrown3978d712006-03-26 01:37:17 -08001478#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001479 if (rc < 0)
1480 return rc;
1481 return 0;
NeilBrown3978d712006-03-26 01:37:17 -08001482#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483} */
1484
1485/*
1486 * As file closes, flush all cached write data for this inode checking
1487 * for write behind errors.
1488 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001489int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001491 struct inode * inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001492 int rc = 0;
1493
1494 /* Rather than do the steps manually:
1495 lock the inode for writing
1496 loop through pages looking for write behind data (dirty pages)
1497 coalesce into contiguous 16K (or smaller) chunks to write to server
1498 send to server (prefer in parallel)
1499 deal with writebehind errors
1500 unlock inode for writing
1501 filemapfdatawrite appears easier for the time being */
1502
1503 rc = filemap_fdatawrite(inode->i_mapping);
1504 if (!rc) /* reset wb rc if we were able to write out dirty pages */
1505 CIFS_I(inode)->write_behind_rc = 0;
1506
1507 cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
1508
1509 return rc;
1510}
1511
1512ssize_t cifs_user_read(struct file *file, char __user *read_data,
1513 size_t read_size, loff_t *poffset)
1514{
1515 int rc = -EACCES;
1516 unsigned int bytes_read = 0;
1517 unsigned int total_read = 0;
1518 unsigned int current_read_size;
1519 struct cifs_sb_info *cifs_sb;
1520 struct cifsTconInfo *pTcon;
1521 int xid;
1522 struct cifsFileInfo *open_file;
1523 char *smb_read_data;
1524 char __user *current_offset;
1525 struct smb_com_read_rsp *pSMBr;
1526
1527 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001528 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001529 pTcon = cifs_sb->tcon;
1530
1531 if (file->private_data == NULL) {
1532 FreeXid(xid);
1533 return -EBADF;
1534 }
1535 open_file = (struct cifsFileInfo *)file->private_data;
1536
1537 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1538 cFYI(1, ("attempting read on write only file instance"));
1539 }
1540 for (total_read = 0, current_offset = read_data;
1541 read_size > total_read;
1542 total_read += bytes_read, current_offset += bytes_read) {
1543 current_read_size = min_t(const int, read_size - total_read,
1544 cifs_sb->rsize);
1545 rc = -EAGAIN;
1546 smb_read_data = NULL;
1547 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001548 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001549 if ((open_file->invalidHandle) &&
1550 (!open_file->closePend)) {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001551 rc = cifs_reopen_file(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001552 file, TRUE);
1553 if (rc != 0)
1554 break;
1555 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001556 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001557 open_file->netfid,
1558 current_read_size, *poffset,
1559 &bytes_read, &smb_read_data,
1560 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001562 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001563 if (copy_to_user(current_offset,
1564 smb_read_data +
1565 4 /* RFC1001 length field */ +
1566 le16_to_cpu(pSMBr->DataOffset),
1567 bytes_read)) {
1568 rc = -EFAULT;
1569 }
1570
Steve Frenchec637e32005-12-12 20:53:18 -08001571 if(buf_type == CIFS_SMALL_BUFFER)
1572 cifs_small_buf_release(smb_read_data);
1573 else if(buf_type == CIFS_LARGE_BUFFER)
1574 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001575 smb_read_data = NULL;
1576 }
1577 }
1578 if (rc || (bytes_read == 0)) {
1579 if (total_read) {
1580 break;
1581 } else {
1582 FreeXid(xid);
1583 return rc;
1584 }
1585 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001586 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 *poffset += bytes_read;
1588 }
1589 }
1590 FreeXid(xid);
1591 return total_read;
1592}
1593
1594
1595static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1596 loff_t *poffset)
1597{
1598 int rc = -EACCES;
1599 unsigned int bytes_read = 0;
1600 unsigned int total_read;
1601 unsigned int current_read_size;
1602 struct cifs_sb_info *cifs_sb;
1603 struct cifsTconInfo *pTcon;
1604 int xid;
1605 char *current_offset;
1606 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001607 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608
1609 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001610 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001611 pTcon = cifs_sb->tcon;
1612
1613 if (file->private_data == NULL) {
1614 FreeXid(xid);
1615 return -EBADF;
1616 }
1617 open_file = (struct cifsFileInfo *)file->private_data;
1618
1619 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1620 cFYI(1, ("attempting read on write only file instance"));
1621
1622 for (total_read = 0, current_offset = read_data;
1623 read_size > total_read;
1624 total_read += bytes_read, current_offset += bytes_read) {
1625 current_read_size = min_t(const int, read_size - total_read,
1626 cifs_sb->rsize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001627 /* For windows me and 9x we do not want to request more
1628 than it negotiated since it will refuse the read then */
1629 if((pTcon->ses) &&
1630 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1631 current_read_size = min_t(const int, current_read_size,
1632 pTcon->ses->server->maxBuf - 128);
1633 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001634 rc = -EAGAIN;
1635 while (rc == -EAGAIN) {
1636 if ((open_file->invalidHandle) &&
1637 (!open_file->closePend)) {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001638 rc = cifs_reopen_file(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639 file, TRUE);
1640 if (rc != 0)
1641 break;
1642 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001643 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001644 open_file->netfid,
1645 current_read_size, *poffset,
1646 &bytes_read, &current_offset,
1647 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001648 }
1649 if (rc || (bytes_read == 0)) {
1650 if (total_read) {
1651 break;
1652 } else {
1653 FreeXid(xid);
1654 return rc;
1655 }
1656 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001657 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001658 *poffset += bytes_read;
1659 }
1660 }
1661 FreeXid(xid);
1662 return total_read;
1663}
1664
1665int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1666{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001667 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 int rc, xid;
1669
1670 xid = GetXid();
1671 rc = cifs_revalidate(dentry);
1672 if (rc) {
1673 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1674 FreeXid(xid);
1675 return rc;
1676 }
1677 rc = generic_file_mmap(file, vma);
1678 FreeXid(xid);
1679 return rc;
1680}
1681
1682
1683static void cifs_copy_cache_pages(struct address_space *mapping,
1684 struct list_head *pages, int bytes_read, char *data,
1685 struct pagevec *plru_pvec)
1686{
1687 struct page *page;
1688 char *target;
1689
1690 while (bytes_read > 0) {
1691 if (list_empty(pages))
1692 break;
1693
1694 page = list_entry(pages->prev, struct page, lru);
1695 list_del(&page->lru);
1696
1697 if (add_to_page_cache(page, mapping, page->index,
1698 GFP_KERNEL)) {
1699 page_cache_release(page);
1700 cFYI(1, ("Add page cache failed"));
Steve French3079ca62005-06-09 14:44:07 -07001701 data += PAGE_CACHE_SIZE;
1702 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001703 continue;
1704 }
1705
1706 target = kmap_atomic(page,KM_USER0);
1707
1708 if (PAGE_CACHE_SIZE > bytes_read) {
1709 memcpy(target, data, bytes_read);
1710 /* zero the tail end of this partial page */
1711 memset(target + bytes_read, 0,
1712 PAGE_CACHE_SIZE - bytes_read);
1713 bytes_read = 0;
1714 } else {
1715 memcpy(target, data, PAGE_CACHE_SIZE);
1716 bytes_read -= PAGE_CACHE_SIZE;
1717 }
1718 kunmap_atomic(target, KM_USER0);
1719
1720 flush_dcache_page(page);
1721 SetPageUptodate(page);
1722 unlock_page(page);
1723 if (!pagevec_add(plru_pvec, page))
1724 __pagevec_lru_add(plru_pvec);
1725 data += PAGE_CACHE_SIZE;
1726 }
1727 return;
1728}
1729
1730static int cifs_readpages(struct file *file, struct address_space *mapping,
1731 struct list_head *page_list, unsigned num_pages)
1732{
1733 int rc = -EACCES;
1734 int xid;
1735 loff_t offset;
1736 struct page *page;
1737 struct cifs_sb_info *cifs_sb;
1738 struct cifsTconInfo *pTcon;
1739 int bytes_read = 0;
1740 unsigned int read_size,i;
1741 char *smb_read_data = NULL;
1742 struct smb_com_read_rsp *pSMBr;
1743 struct pagevec lru_pvec;
1744 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001745 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746
1747 xid = GetXid();
1748 if (file->private_data == NULL) {
1749 FreeXid(xid);
1750 return -EBADF;
1751 }
1752 open_file = (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001753 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 pTcon = cifs_sb->tcon;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001755
Linus Torvalds1da177e2005-04-16 15:20:36 -07001756 pagevec_init(&lru_pvec, 0);
1757
1758 for (i = 0; i < num_pages; ) {
1759 unsigned contig_pages;
1760 struct page *tmp_page;
1761 unsigned long expected_index;
1762
1763 if (list_empty(page_list))
1764 break;
1765
1766 page = list_entry(page_list->prev, struct page, lru);
1767 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1768
1769 /* count adjacent pages that we will read into */
1770 contig_pages = 0;
1771 expected_index =
1772 list_entry(page_list->prev, struct page, lru)->index;
1773 list_for_each_entry_reverse(tmp_page,page_list,lru) {
1774 if (tmp_page->index == expected_index) {
1775 contig_pages++;
1776 expected_index++;
1777 } else
1778 break;
1779 }
1780 if (contig_pages + i > num_pages)
1781 contig_pages = num_pages - i;
1782
1783 /* for reads over a certain size could initiate async
1784 read ahead */
1785
1786 read_size = contig_pages * PAGE_CACHE_SIZE;
1787 /* Read size needs to be in multiples of one page */
1788 read_size = min_t(const unsigned int, read_size,
1789 cifs_sb->rsize & PAGE_CACHE_MASK);
1790
1791 rc = -EAGAIN;
1792 while (rc == -EAGAIN) {
1793 if ((open_file->invalidHandle) &&
1794 (!open_file->closePend)) {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001795 rc = cifs_reopen_file(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001796 file, TRUE);
1797 if (rc != 0)
1798 break;
1799 }
1800
Steve Frenchbfa0d752005-08-31 21:50:37 -07001801 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001802 open_file->netfid,
1803 read_size, offset,
1804 &bytes_read, &smb_read_data,
1805 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001806 /* BB more RC checks ? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001807 if (rc== -EAGAIN) {
1808 if (smb_read_data) {
Steve Frenchec637e32005-12-12 20:53:18 -08001809 if(buf_type == CIFS_SMALL_BUFFER)
1810 cifs_small_buf_release(smb_read_data);
1811 else if(buf_type == CIFS_LARGE_BUFFER)
1812 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001813 smb_read_data = NULL;
1814 }
1815 }
1816 }
1817 if ((rc < 0) || (smb_read_data == NULL)) {
1818 cFYI(1, ("Read error in readpages: %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001819 break;
1820 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08001821 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001822 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1823 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1824 smb_read_data + 4 /* RFC1001 hdr */ +
1825 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1826
1827 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07001828 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001829 if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1830 i++; /* account for partial page */
1831
1832 /* server copy of file can have smaller size
1833 than client */
1834 /* BB do we need to verify this common case ?
1835 this case is ok - if we are at server EOF
1836 we will hit it on next read */
1837
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08001838 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 }
1840 } else {
1841 cFYI(1, ("No bytes read (%d) at offset %lld . "
1842 "Cleaning remaining pages from readahead list",
1843 bytes_read, offset));
1844 /* BB turn off caching and do new lookup on
1845 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 break;
1847 }
1848 if (smb_read_data) {
Steve Frenchec637e32005-12-12 20:53:18 -08001849 if(buf_type == CIFS_SMALL_BUFFER)
1850 cifs_small_buf_release(smb_read_data);
1851 else if(buf_type == CIFS_LARGE_BUFFER)
1852 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001853 smb_read_data = NULL;
1854 }
1855 bytes_read = 0;
1856 }
1857
1858 pagevec_lru_add(&lru_pvec);
1859
1860/* need to free smb_read_data buf before exit */
1861 if (smb_read_data) {
Steve French47c886b2006-01-18 14:20:39 -08001862 if(buf_type == CIFS_SMALL_BUFFER)
1863 cifs_small_buf_release(smb_read_data);
1864 else if(buf_type == CIFS_LARGE_BUFFER)
1865 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 smb_read_data = NULL;
1867 }
1868
1869 FreeXid(xid);
1870 return rc;
1871}
1872
1873static int cifs_readpage_worker(struct file *file, struct page *page,
1874 loff_t *poffset)
1875{
1876 char *read_data;
1877 int rc;
1878
1879 page_cache_get(page);
1880 read_data = kmap(page);
1881 /* for reads over a certain size could initiate async read ahead */
1882
1883 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1884
1885 if (rc < 0)
1886 goto io_error;
1887 else
Steve French26a21b92006-05-31 18:05:34 +00001888 cFYI(1, ("Bytes read %d",rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001890 file->f_path.dentry->d_inode->i_atime =
1891 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001892
1893 if (PAGE_CACHE_SIZE > rc)
1894 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1895
1896 flush_dcache_page(page);
1897 SetPageUptodate(page);
1898 rc = 0;
1899
1900io_error:
1901 kunmap(page);
1902 page_cache_release(page);
1903 return rc;
1904}
1905
1906static int cifs_readpage(struct file *file, struct page *page)
1907{
1908 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1909 int rc = -EACCES;
1910 int xid;
1911
1912 xid = GetXid();
1913
1914 if (file->private_data == NULL) {
1915 FreeXid(xid);
1916 return -EBADF;
1917 }
1918
1919 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1920 page, (int)offset, (int)offset));
1921
1922 rc = cifs_readpage_worker(file, page, &offset);
1923
1924 unlock_page(page);
1925
1926 FreeXid(xid);
1927 return rc;
1928}
1929
1930/* We do not want to update the file size from server for inodes
1931 open for write - to avoid races with writepage extending
1932 the file - in the future we could consider allowing
1933 refreshing the inode only on increases in the file size
1934 but this is tricky to do without racing with writebehind
1935 page caching in the current Linux kernel design */
Steve French7ba52632007-02-08 18:14:13 +00001936int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937{
Steve French23e7dd72005-10-20 13:44:56 -07001938 struct cifsFileInfo *open_file = NULL;
1939
1940 if (cifsInode)
1941 open_file = find_writable_file(cifsInode);
1942
1943 if(open_file) {
Steve Frenchc32a0b62006-01-12 14:41:28 -08001944 struct cifs_sb_info *cifs_sb;
1945
Steve French23e7dd72005-10-20 13:44:56 -07001946 /* there is not actually a write pending so let
1947 this handle go free and allow it to
1948 be closable if needed */
1949 atomic_dec(&open_file->wrtPending);
Steve Frenchc32a0b62006-01-12 14:41:28 -08001950
1951 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
1952 if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
1953 /* since no page cache to corrupt on directio
1954 we can change size safely */
1955 return 1;
1956 }
1957
Steve French7ba52632007-02-08 18:14:13 +00001958 if(i_size_read(&cifsInode->vfs_inode) < end_of_file)
1959 return 1;
1960
Steve French6148a742005-10-05 12:23:19 -07001961 return 0;
Steve French23e7dd72005-10-20 13:44:56 -07001962 } else
Steve French6148a742005-10-05 12:23:19 -07001963 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001964}
1965
Linus Torvalds1da177e2005-04-16 15:20:36 -07001966static int cifs_prepare_write(struct file *file, struct page *page,
1967 unsigned from, unsigned to)
1968{
1969 int rc = 0;
Steve French8a236262007-03-06 00:31:00 +00001970 loff_t i_size;
1971 loff_t offset;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001972
Steve French8a236262007-03-06 00:31:00 +00001973 cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
1974 if (PageUptodate(page))
1975 return 0;
1976
1977 /* If we are writing a full page it will be up to date,
1978 no need to read from the server */
1979 if ((to == PAGE_CACHE_SIZE) && (from == 0)) {
1980 SetPageUptodate(page);
1981 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 }
1983
Steve French8a236262007-03-06 00:31:00 +00001984 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1985 i_size = i_size_read(page->mapping->host);
1986
1987 if ((offset >= i_size) ||
1988 ((from == 0) && (offset + to) >= i_size)) {
1989 /*
1990 * We don't need to read data beyond the end of the file.
1991 * zero it, and set the page uptodate
1992 */
1993 void *kaddr = kmap_atomic(page, KM_USER0);
1994
1995 if (from)
1996 memset(kaddr, 0, from);
1997 if (to < PAGE_CACHE_SIZE)
1998 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
1999 flush_dcache_page(page);
2000 kunmap_atomic(kaddr, KM_USER0);
2001 SetPageUptodate(page);
2002 } else if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2003 /* might as well read a page, it is fast enough */
2004 rc = cifs_readpage_worker(file, page, &offset);
2005 } else {
2006 /* we could try using another file handle if there is one -
2007 but how would we lock it to prevent close of that handle
2008 racing with this read? In any case
2009 this will be written out by commit_write so is fine */
2010 }
2011
2012 /* we do not need to pass errors back
2013 e.g. if we do not have read access to the file
2014 because cifs_commit_write will do the right thing. -- shaggy */
2015
Linus Torvalds1da177e2005-04-16 15:20:36 -07002016 return 0;
2017}
2018
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002019const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002020 .readpage = cifs_readpage,
2021 .readpages = cifs_readpages,
2022 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002023 .writepages = cifs_writepages,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002024 .prepare_write = cifs_prepare_write,
2025 .commit_write = cifs_commit_write,
2026 .set_page_dirty = __set_page_dirty_nobuffers,
2027 /* .sync_page = cifs_sync_page, */
2028 /* .direct_IO = */
2029};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002030
2031/*
2032 * cifs_readpages requires the server to support a buffer large enough to
2033 * contain the header plus one complete page of data. Otherwise, we need
2034 * to leave cifs_readpages out of the address space operations.
2035 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002036const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002037 .readpage = cifs_readpage,
2038 .writepage = cifs_writepage,
2039 .writepages = cifs_writepages,
2040 .prepare_write = cifs_prepare_write,
2041 .commit_write = cifs_commit_write,
2042 .set_page_dirty = __set_page_dirty_nobuffers,
2043 /* .sync_page = cifs_sync_page, */
2044 /* .direct_IO = */
2045};