blob: c07ff8317a8b051c4d636cac9d25c49f15bdd5c2 [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 if (file->f_path.dentry == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700796 return -EBADF;
797
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800798 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700799 if (cifs_sb == NULL)
800 return -EBADF;
801
802 pTcon = cifs_sb->tcon;
803
804 /* cFYI(1,
805 (" write %d bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800806 *poffset, file->f_path.dentry->d_name.name)); */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700807
808 if (file->private_data == NULL)
809 return -EBADF;
810 else
811 open_file = (struct cifsFileInfo *) file->private_data;
812
813 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800814 if (file->f_path.dentry->d_inode == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700815 FreeXid(xid);
816 return -EBADF;
817 }
818
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800819 if (*poffset > file->f_path.dentry->d_inode->i_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 long_op = 2; /* writes past end of file can take a long time */
821 else
822 long_op = 1;
823
824 for (total_written = 0; write_size > total_written;
825 total_written += bytes_written) {
826 rc = -EAGAIN;
827 while (rc == -EAGAIN) {
828 if (file->private_data == NULL) {
829 /* file has been closed on us */
830 FreeXid(xid);
831 /* if we have gotten here we have written some data
832 and blocked, and the file has been freed on us while
833 we blocked so return what we managed to write */
834 return total_written;
835 }
836 if (open_file->closePend) {
837 FreeXid(xid);
838 if (total_written)
839 return total_written;
840 else
841 return -EBADF;
842 }
843 if (open_file->invalidHandle) {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800844 if ((file->f_path.dentry == NULL) ||
845 (file->f_path.dentry->d_inode == NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700846 FreeXid(xid);
847 return total_written;
848 }
849 /* we could deadlock if we called
850 filemap_fdatawait from here so tell
851 reopen_file not to flush data to server
852 now */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800853 rc = cifs_reopen_file(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700854 file, FALSE);
855 if (rc != 0)
856 break;
857 }
858
859 rc = CIFSSMBWrite(xid, pTcon,
860 open_file->netfid,
861 min_t(const int, cifs_sb->wsize,
862 write_size - total_written),
863 *poffset, &bytes_written,
864 NULL, write_data + total_written, long_op);
865 }
866 if (rc || (bytes_written == 0)) {
867 if (total_written)
868 break;
869 else {
870 FreeXid(xid);
871 return rc;
872 }
873 } else
874 *poffset += bytes_written;
875 long_op = FALSE; /* subsequent writes fast -
876 15 seconds is plenty */
877 }
878
Steve Frencha4544342005-08-24 13:59:35 -0700879 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880
881 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +0000882 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
883 struct inode *inode = file->f_path.dentry->d_inode;
884/* Do not update local mtime - server will set its actual value on write
885 * inode->i_ctime = inode->i_mtime =
886 * current_fs_time(inode->i_sb);*/
887 if (total_written > 0) {
888 spin_lock(&inode->i_lock);
889 if (*poffset > file->f_path.dentry->d_inode->i_size)
890 i_size_write(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700891 *poffset);
Steve French3677db12007-02-26 16:46:11 +0000892 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700893 }
Steve French3677db12007-02-26 16:46:11 +0000894 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700895 }
896 FreeXid(xid);
897 return total_written;
898}
899
900static ssize_t cifs_write(struct file *file, const char *write_data,
901 size_t write_size, loff_t *poffset)
902{
903 int rc = 0;
904 unsigned int bytes_written = 0;
905 unsigned int total_written;
906 struct cifs_sb_info *cifs_sb;
907 struct cifsTconInfo *pTcon;
908 int xid, long_op;
909 struct cifsFileInfo *open_file;
910
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800911 if (file->f_path.dentry == NULL)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700912 return -EBADF;
913
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800914 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915 if (cifs_sb == NULL)
916 return -EBADF;
917
918 pTcon = cifs_sb->tcon;
919
Steve Frenchab2f2182005-09-15 20:44:50 -0700920 cFYI(1,("write %zd bytes to offset %lld of %s", write_size,
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800921 *poffset, file->f_path.dentry->d_name.name));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700922
923 if (file->private_data == NULL)
924 return -EBADF;
925 else
926 open_file = (struct cifsFileInfo *)file->private_data;
927
928 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800929 if (file->f_path.dentry->d_inode == NULL) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700930 FreeXid(xid);
931 return -EBADF;
932 }
933
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800934 if (*poffset > file->f_path.dentry->d_inode->i_size)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700935 long_op = 2; /* writes past end of file can take a long time */
936 else
937 long_op = 1;
938
939 for (total_written = 0; write_size > total_written;
940 total_written += bytes_written) {
941 rc = -EAGAIN;
942 while (rc == -EAGAIN) {
943 if (file->private_data == NULL) {
944 /* file has been closed on us */
945 FreeXid(xid);
946 /* if we have gotten here we have written some data
947 and blocked, and the file has been freed on us
948 while we blocked so return what we managed to
949 write */
950 return total_written;
951 }
952 if (open_file->closePend) {
953 FreeXid(xid);
954 if (total_written)
955 return total_written;
956 else
957 return -EBADF;
958 }
959 if (open_file->invalidHandle) {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800960 if ((file->f_path.dentry == NULL) ||
961 (file->f_path.dentry->d_inode == NULL)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700962 FreeXid(xid);
963 return total_written;
964 }
965 /* we could deadlock if we called
966 filemap_fdatawait from here so tell
967 reopen_file not to flush data to
968 server now */
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -0800969 rc = cifs_reopen_file(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700970 file, FALSE);
971 if (rc != 0)
972 break;
973 }
Steve Frenchc01f36a2006-05-30 18:05:10 +0000974 if(experimEnabled || (pTcon->ses->server &&
Steve French08775832006-05-30 18:08:26 +0000975 ((pTcon->ses->server->secMode &
976 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve Frenchc01f36a2006-05-30 18:05:10 +0000977 == 0))) {
Steve French3e844692005-10-03 13:37:24 -0700978 struct kvec iov[2];
979 unsigned int len;
980
Steve French0ae0efa2005-10-10 10:57:19 -0700981 len = min((size_t)cifs_sb->wsize,
Steve French3e844692005-10-03 13:37:24 -0700982 write_size - total_written);
983 /* iov[0] is reserved for smb header */
984 iov[1].iov_base = (char *)write_data +
985 total_written;
986 iov[1].iov_len = len;
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500987 rc = CIFSSMBWrite2(xid, pTcon,
Steve French3e844692005-10-03 13:37:24 -0700988 open_file->netfid, len,
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500989 *poffset, &bytes_written,
Steve French3e844692005-10-03 13:37:24 -0700990 iov, 1, long_op);
Steve Frenchd6e04ae2005-06-13 13:24:43 -0500991 } else
Steve French60808232006-04-22 15:53:05 +0000992 rc = CIFSSMBWrite(xid, pTcon,
993 open_file->netfid,
994 min_t(const int, cifs_sb->wsize,
995 write_size - total_written),
996 *poffset, &bytes_written,
997 write_data + total_written,
998 NULL, long_op);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700999 }
1000 if (rc || (bytes_written == 0)) {
1001 if (total_written)
1002 break;
1003 else {
1004 FreeXid(xid);
1005 return rc;
1006 }
1007 } else
1008 *poffset += bytes_written;
1009 long_op = FALSE; /* subsequent writes fast -
1010 15 seconds is plenty */
1011 }
1012
Steve Frencha4544342005-08-24 13:59:35 -07001013 cifs_stats_bytes_written(pTcon, total_written);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014
1015 /* since the write may have blocked check these pointers again */
Steve French3677db12007-02-26 16:46:11 +00001016 if ((file->f_path.dentry) && (file->f_path.dentry->d_inode)) {
Steve French004c46b2007-02-17 04:34:13 +00001017/*BB We could make this contingent on superblock ATIME flag too */
Steve French3677db12007-02-26 16:46:11 +00001018/* file->f_path.dentry->d_inode->i_ctime =
1019 file->f_path.dentry->d_inode->i_mtime = CURRENT_TIME;*/
1020 if (total_written > 0) {
1021 spin_lock(&file->f_path.dentry->d_inode->i_lock);
1022 if (*poffset > file->f_path.dentry->d_inode->i_size)
1023 i_size_write(file->f_path.dentry->d_inode,
1024 *poffset);
1025 spin_unlock(&file->f_path.dentry->d_inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026 }
Steve French3677db12007-02-26 16:46:11 +00001027 mark_inode_dirty_sync(file->f_path.dentry->d_inode);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001028 }
1029 FreeXid(xid);
1030 return total_written;
1031}
1032
Steve Frenchdd99cd82005-10-05 19:32:49 -07001033struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
Steve French6148a742005-10-05 12:23:19 -07001034{
1035 struct cifsFileInfo *open_file;
Steve Frenchdd99cd82005-10-05 19:32:49 -07001036 int rc;
Steve French6148a742005-10-05 12:23:19 -07001037
Steve French60808232006-04-22 15:53:05 +00001038 /* Having a null inode here (because mapping->host was set to zero by
1039 the VFS or MM) should not happen but we had reports of on oops (due to
1040 it being zero) during stress testcases so we need to check for it */
1041
1042 if(cifs_inode == NULL) {
1043 cERROR(1,("Null inode passed to cifs_writeable_file"));
1044 dump_stack();
1045 return NULL;
1046 }
1047
Steve French6148a742005-10-05 12:23:19 -07001048 read_lock(&GlobalSMBSeslock);
1049 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
1050 if (open_file->closePend)
1051 continue;
1052 if (open_file->pfile &&
1053 ((open_file->pfile->f_flags & O_RDWR) ||
1054 (open_file->pfile->f_flags & O_WRONLY))) {
Steve French23e7dd72005-10-20 13:44:56 -07001055 atomic_inc(&open_file->wrtPending);
Steve French6148a742005-10-05 12:23:19 -07001056 read_unlock(&GlobalSMBSeslock);
Steve French0ae0efa2005-10-10 10:57:19 -07001057 if((open_file->invalidHandle) &&
Steve French23e7dd72005-10-20 13:44:56 -07001058 (!open_file->closePend) /* BB fixme -since the second clause can not be true remove it BB */) {
Steve Frenchdd99cd82005-10-05 19:32:49 -07001059 rc = cifs_reopen_file(&cifs_inode->vfs_inode,
Steve French37c0eb42005-10-05 14:50:29 -07001060 open_file->pfile, FALSE);
1061 /* if it fails, try another handle - might be */
1062 /* dangerous to hold up writepages with retry */
1063 if(rc) {
Steve French4a771182005-10-05 15:14:33 -07001064 cFYI(1,("failed on reopen file in wp"));
Steve French37c0eb42005-10-05 14:50:29 -07001065 read_lock(&GlobalSMBSeslock);
Steve French23e7dd72005-10-20 13:44:56 -07001066 /* can not use this handle, no write
1067 pending on this one after all */
1068 atomic_dec
1069 (&open_file->wrtPending);
Steve French37c0eb42005-10-05 14:50:29 -07001070 continue;
1071 }
1072 }
Steve French6148a742005-10-05 12:23:19 -07001073 return open_file;
1074 }
1075 }
1076 read_unlock(&GlobalSMBSeslock);
1077 return NULL;
1078}
1079
Linus Torvalds1da177e2005-04-16 15:20:36 -07001080static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1081{
1082 struct address_space *mapping = page->mapping;
1083 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1084 char *write_data;
1085 int rc = -EFAULT;
1086 int bytes_written = 0;
1087 struct cifs_sb_info *cifs_sb;
1088 struct cifsTconInfo *pTcon;
1089 struct inode *inode;
Steve French6148a742005-10-05 12:23:19 -07001090 struct cifsFileInfo *open_file;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001091
1092 if (!mapping || !mapping->host)
1093 return -EFAULT;
1094
1095 inode = page->mapping->host;
1096 cifs_sb = CIFS_SB(inode->i_sb);
1097 pTcon = cifs_sb->tcon;
1098
1099 offset += (loff_t)from;
1100 write_data = kmap(page);
1101 write_data += from;
1102
1103 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1104 kunmap(page);
1105 return -EIO;
1106 }
1107
1108 /* racing with truncate? */
1109 if (offset > mapping->host->i_size) {
1110 kunmap(page);
1111 return 0; /* don't care */
1112 }
1113
1114 /* check to make sure that we are not extending the file */
1115 if (mapping->host->i_size - offset < (loff_t)to)
1116 to = (unsigned)(mapping->host->i_size - offset);
1117
Steve French6148a742005-10-05 12:23:19 -07001118 open_file = find_writable_file(CIFS_I(mapping->host));
1119 if (open_file) {
1120 bytes_written = cifs_write(open_file->pfile, write_data,
1121 to-from, &offset);
Steve French23e7dd72005-10-20 13:44:56 -07001122 atomic_dec(&open_file->wrtPending);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001123 /* Does mm or vfs already set times? */
Steve French6148a742005-10-05 12:23:19 -07001124 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1125 if ((bytes_written > 0) && (offset)) {
1126 rc = 0;
1127 } else if (bytes_written < 0) {
1128 if (rc != -EBADF)
1129 rc = bytes_written;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001130 }
Steve French6148a742005-10-05 12:23:19 -07001131 } else {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001132 cFYI(1, ("No writeable filehandles for inode"));
1133 rc = -EIO;
1134 }
1135
1136 kunmap(page);
1137 return rc;
1138}
1139
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140static int cifs_writepages(struct address_space *mapping,
Steve French37c0eb42005-10-05 14:50:29 -07001141 struct writeback_control *wbc)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142{
Steve French37c0eb42005-10-05 14:50:29 -07001143 struct backing_dev_info *bdi = mapping->backing_dev_info;
1144 unsigned int bytes_to_write;
1145 unsigned int bytes_written;
1146 struct cifs_sb_info *cifs_sb;
1147 int done = 0;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001148 pgoff_t end;
Steve French37c0eb42005-10-05 14:50:29 -07001149 pgoff_t index;
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001150 int range_whole = 0;
Steve French9a0c8232007-02-02 04:21:57 +00001151 struct kvec * iov;
Steve French84d2f072005-10-12 15:32:05 -07001152 int len;
Steve French37c0eb42005-10-05 14:50:29 -07001153 int n_iov = 0;
1154 pgoff_t next;
1155 int nr_pages;
1156 __u64 offset = 0;
Steve French23e7dd72005-10-20 13:44:56 -07001157 struct cifsFileInfo *open_file;
Steve French37c0eb42005-10-05 14:50:29 -07001158 struct page *page;
1159 struct pagevec pvec;
1160 int rc = 0;
1161 int scanned = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001162 int xid;
1163
Steve French37c0eb42005-10-05 14:50:29 -07001164 cifs_sb = CIFS_SB(mapping->host->i_sb);
1165
1166 /*
1167 * If wsize is smaller that the page cache size, default to writing
1168 * one page at a time via cifs_writepage
1169 */
1170 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1171 return generic_writepages(mapping, wbc);
1172
Steve French4a771182005-10-05 15:14:33 -07001173 if((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1174 if(cifs_sb->tcon->ses->server->secMode &
1175 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
Steve French9a0c8232007-02-02 04:21:57 +00001176 if(!experimEnabled)
Steve French60808232006-04-22 15:53:05 +00001177 return generic_writepages(mapping, wbc);
Steve French4a771182005-10-05 15:14:33 -07001178
Steve French9a0c8232007-02-02 04:21:57 +00001179 iov = kmalloc(32 * sizeof(struct kvec), GFP_KERNEL);
1180 if(iov == NULL)
1181 return generic_writepages(mapping, wbc);
1182
1183
Steve French37c0eb42005-10-05 14:50:29 -07001184 /*
1185 * BB: Is this meaningful for a non-block-device file system?
1186 * If it is, we should test it again after we do I/O
1187 */
1188 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1189 wbc->encountered_congestion = 1;
Steve French9a0c8232007-02-02 04:21:57 +00001190 kfree(iov);
Steve French37c0eb42005-10-05 14:50:29 -07001191 return 0;
1192 }
1193
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194 xid = GetXid();
1195
Steve French37c0eb42005-10-05 14:50:29 -07001196 pagevec_init(&pvec, 0);
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001197 if (wbc->range_cyclic) {
Steve French37c0eb42005-10-05 14:50:29 -07001198 index = mapping->writeback_index; /* Start from prev offset */
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001199 end = -1;
1200 } else {
1201 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1202 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1203 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1204 range_whole = 1;
Steve French37c0eb42005-10-05 14:50:29 -07001205 scanned = 1;
1206 }
1207retry:
1208 while (!done && (index <= end) &&
1209 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1210 PAGECACHE_TAG_DIRTY,
1211 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1212 int first;
1213 unsigned int i;
1214
Steve French37c0eb42005-10-05 14:50:29 -07001215 first = -1;
1216 next = 0;
1217 n_iov = 0;
1218 bytes_to_write = 0;
1219
1220 for (i = 0; i < nr_pages; i++) {
1221 page = pvec.pages[i];
1222 /*
1223 * At this point we hold neither mapping->tree_lock nor
1224 * lock on the page itself: the page may be truncated or
1225 * invalidated (changing page->mapping to NULL), or even
1226 * swizzled back from swapper_space to tmpfs file
1227 * mapping
1228 */
1229
1230 if (first < 0)
1231 lock_page(page);
1232 else if (TestSetPageLocked(page))
1233 break;
1234
1235 if (unlikely(page->mapping != mapping)) {
1236 unlock_page(page);
1237 break;
1238 }
1239
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001240 if (!wbc->range_cyclic && page->index > end) {
Steve French37c0eb42005-10-05 14:50:29 -07001241 done = 1;
1242 unlock_page(page);
1243 break;
1244 }
1245
1246 if (next && (page->index != next)) {
1247 /* Not next consecutive page */
1248 unlock_page(page);
1249 break;
1250 }
1251
1252 if (wbc->sync_mode != WB_SYNC_NONE)
1253 wait_on_page_writeback(page);
1254
1255 if (PageWriteback(page) ||
Linus Torvaldscb876f42006-12-23 16:19:07 -08001256 !clear_page_dirty_for_io(page)) {
Steve French37c0eb42005-10-05 14:50:29 -07001257 unlock_page(page);
1258 break;
1259 }
Steve French84d2f072005-10-12 15:32:05 -07001260
Linus Torvaldscb876f42006-12-23 16:19:07 -08001261 /*
1262 * This actually clears the dirty bit in the radix tree.
1263 * See cifs_writepage() for more commentary.
1264 */
1265 set_page_writeback(page);
1266
Steve French84d2f072005-10-12 15:32:05 -07001267 if (page_offset(page) >= mapping->host->i_size) {
1268 done = 1;
1269 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001270 end_page_writeback(page);
Steve French84d2f072005-10-12 15:32:05 -07001271 break;
1272 }
1273
Steve French37c0eb42005-10-05 14:50:29 -07001274 /*
1275 * BB can we get rid of this? pages are held by pvec
1276 */
1277 page_cache_get(page);
1278
Steve French84d2f072005-10-12 15:32:05 -07001279 len = min(mapping->host->i_size - page_offset(page),
1280 (loff_t)PAGE_CACHE_SIZE);
1281
Steve French37c0eb42005-10-05 14:50:29 -07001282 /* reserve iov[0] for the smb header */
1283 n_iov++;
1284 iov[n_iov].iov_base = kmap(page);
Steve French84d2f072005-10-12 15:32:05 -07001285 iov[n_iov].iov_len = len;
1286 bytes_to_write += len;
Steve French37c0eb42005-10-05 14:50:29 -07001287
1288 if (first < 0) {
1289 first = i;
1290 offset = page_offset(page);
1291 }
1292 next = page->index + 1;
1293 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1294 break;
1295 }
1296 if (n_iov) {
Steve French23e7dd72005-10-20 13:44:56 -07001297 /* Search for a writable handle every time we call
1298 * CIFSSMBWrite2. We can't rely on the last handle
1299 * we used to still be valid
1300 */
1301 open_file = find_writable_file(CIFS_I(mapping->host));
1302 if (!open_file) {
1303 cERROR(1, ("No writable handles for inode"));
1304 rc = -EBADF;
Steve French1047abc2005-10-11 19:58:06 -07001305 } else {
Steve French23e7dd72005-10-20 13:44:56 -07001306 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1307 open_file->netfid,
1308 bytes_to_write, offset,
1309 &bytes_written, iov, n_iov,
1310 1);
1311 atomic_dec(&open_file->wrtPending);
1312 if (rc || bytes_written < bytes_to_write) {
1313 cERROR(1,("Write2 ret %d, written = %d",
1314 rc, bytes_written));
1315 /* BB what if continued retry is
1316 requested via mount flags? */
1317 set_bit(AS_EIO, &mapping->flags);
Steve French23e7dd72005-10-20 13:44:56 -07001318 } else {
1319 cifs_stats_bytes_written(cifs_sb->tcon,
1320 bytes_written);
1321 }
Steve French37c0eb42005-10-05 14:50:29 -07001322 }
1323 for (i = 0; i < n_iov; i++) {
1324 page = pvec.pages[first + i];
Steve Frencheb9bdaa2006-01-27 15:11:47 -08001325 /* Should we also set page error on
1326 success rc but too little data written? */
1327 /* BB investigate retry logic on temporary
1328 server crash cases and how recovery works
1329 when page marked as error */
1330 if(rc)
1331 SetPageError(page);
Steve French37c0eb42005-10-05 14:50:29 -07001332 kunmap(page);
1333 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001334 end_page_writeback(page);
Steve French37c0eb42005-10-05 14:50:29 -07001335 page_cache_release(page);
1336 }
1337 if ((wbc->nr_to_write -= n_iov) <= 0)
1338 done = 1;
1339 index = next;
1340 }
1341 pagevec_release(&pvec);
1342 }
1343 if (!scanned && !done) {
1344 /*
1345 * We hit the last page and there is more work to be done: wrap
1346 * back to the start of the file
1347 */
1348 scanned = 1;
1349 index = 0;
1350 goto retry;
1351 }
OGAWA Hirofumi111ebb62006-06-23 02:03:26 -07001352 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
Steve French37c0eb42005-10-05 14:50:29 -07001353 mapping->writeback_index = index;
1354
Linus Torvalds1da177e2005-04-16 15:20:36 -07001355 FreeXid(xid);
Steve French9a0c8232007-02-02 04:21:57 +00001356 kfree(iov);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001357 return rc;
1358}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001359
1360static int cifs_writepage(struct page* page, struct writeback_control *wbc)
1361{
1362 int rc = -EFAULT;
1363 int xid;
1364
1365 xid = GetXid();
1366/* BB add check for wbc flags */
1367 page_cache_get(page);
1368 if (!PageUptodate(page)) {
1369 cFYI(1, ("ppw - page not up to date"));
1370 }
Linus Torvaldscb876f42006-12-23 16:19:07 -08001371
1372 /*
1373 * Set the "writeback" flag, and clear "dirty" in the radix tree.
1374 *
1375 * A writepage() implementation always needs to do either this,
1376 * or re-dirty the page with "redirty_page_for_writepage()" in
1377 * the case of a failure.
1378 *
1379 * Just unlocking the page will cause the radix tree tag-bits
1380 * to fail to update with the state of the page correctly.
1381 */
1382 set_page_writeback(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001383 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1384 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1385 unlock_page(page);
Linus Torvaldscb876f42006-12-23 16:19:07 -08001386 end_page_writeback(page);
1387 page_cache_release(page);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001388 FreeXid(xid);
1389 return rc;
1390}
1391
1392static int cifs_commit_write(struct file *file, struct page *page,
1393 unsigned offset, unsigned to)
1394{
1395 int xid;
1396 int rc = 0;
1397 struct inode *inode = page->mapping->host;
1398 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1399 char *page_data;
1400
1401 xid = GetXid();
1402 cFYI(1, ("commit write for page %p up to position %lld for %d",
1403 page, position, to));
Steve French3677db12007-02-26 16:46:11 +00001404 spin_lock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001405 if (position > inode->i_size) {
1406 i_size_write(inode, position);
1407 /* if (file->private_data == NULL) {
1408 rc = -EBADF;
1409 } else {
1410 open_file = (struct cifsFileInfo *)file->private_data;
1411 cifs_sb = CIFS_SB(inode->i_sb);
1412 rc = -EAGAIN;
1413 while (rc == -EAGAIN) {
1414 if ((open_file->invalidHandle) &&
1415 (!open_file->closePend)) {
1416 rc = cifs_reopen_file(
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001417 file->f_path.dentry->d_inode, file);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001418 if (rc != 0)
1419 break;
1420 }
1421 if (!open_file->closePend) {
1422 rc = CIFSSMBSetFileSize(xid,
1423 cifs_sb->tcon, position,
1424 open_file->netfid,
1425 open_file->pid, FALSE);
1426 } else {
1427 rc = -EBADF;
1428 break;
1429 }
1430 }
1431 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1432 } */
1433 }
Steve French3677db12007-02-26 16:46:11 +00001434 spin_unlock(&inode->i_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001435 if (!PageUptodate(page)) {
1436 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1437 /* can not rely on (or let) writepage write this data */
1438 if (to < offset) {
1439 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1440 offset, to));
1441 FreeXid(xid);
1442 return rc;
1443 }
1444 /* this is probably better than directly calling
1445 partialpage_write since in this function the file handle is
1446 known which we might as well leverage */
1447 /* BB check if anything else missing out of ppw
1448 such as updating last write time */
1449 page_data = kmap(page);
1450 rc = cifs_write(file, page_data + offset, to-offset,
1451 &position);
1452 if (rc > 0)
1453 rc = 0;
1454 /* else if (rc < 0) should we set writebehind rc? */
1455 kunmap(page);
1456 } else {
1457 set_page_dirty(page);
1458 }
1459
1460 FreeXid(xid);
1461 return rc;
1462}
1463
1464int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1465{
1466 int xid;
1467 int rc = 0;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001468 struct inode *inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001469
1470 xid = GetXid();
1471
Steve French26a21b92006-05-31 18:05:34 +00001472 cFYI(1, ("Sync file - name: %s datasync: 0x%x",
Linus Torvalds1da177e2005-04-16 15:20:36 -07001473 dentry->d_name.name, datasync));
1474
1475 rc = filemap_fdatawrite(inode->i_mapping);
1476 if (rc == 0)
1477 CIFS_I(inode)->write_behind_rc = 0;
1478 FreeXid(xid);
1479 return rc;
1480}
1481
NeilBrown3978d7172006-03-26 01:37:17 -08001482/* static void cifs_sync_page(struct page *page)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001483{
1484 struct address_space *mapping;
1485 struct inode *inode;
1486 unsigned long index = page->index;
1487 unsigned int rpages = 0;
1488 int rc = 0;
1489
1490 cFYI(1, ("sync page %p",page));
1491 mapping = page->mapping;
1492 if (!mapping)
1493 return 0;
1494 inode = mapping->host;
1495 if (!inode)
NeilBrown3978d7172006-03-26 01:37:17 -08001496 return; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001497
1498/* fill in rpages then
1499 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1500
Steve French26a21b92006-05-31 18:05:34 +00001501/* cFYI(1, ("rpages is %d for sync page of Index %ld", rpages, index));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001502
NeilBrown3978d7172006-03-26 01:37:17 -08001503#if 0
Linus Torvalds1da177e2005-04-16 15:20:36 -07001504 if (rc < 0)
1505 return rc;
1506 return 0;
NeilBrown3978d7172006-03-26 01:37:17 -08001507#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001508} */
1509
1510/*
1511 * As file closes, flush all cached write data for this inode checking
1512 * for write behind errors.
1513 */
Miklos Szeredi75e1fcc2006-06-23 02:05:12 -07001514int cifs_flush(struct file *file, fl_owner_t id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001515{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001516 struct inode * inode = file->f_path.dentry->d_inode;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001517 int rc = 0;
1518
1519 /* Rather than do the steps manually:
1520 lock the inode for writing
1521 loop through pages looking for write behind data (dirty pages)
1522 coalesce into contiguous 16K (or smaller) chunks to write to server
1523 send to server (prefer in parallel)
1524 deal with writebehind errors
1525 unlock inode for writing
1526 filemapfdatawrite appears easier for the time being */
1527
1528 rc = filemap_fdatawrite(inode->i_mapping);
1529 if (!rc) /* reset wb rc if we were able to write out dirty pages */
1530 CIFS_I(inode)->write_behind_rc = 0;
1531
1532 cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
1533
1534 return rc;
1535}
1536
1537ssize_t cifs_user_read(struct file *file, char __user *read_data,
1538 size_t read_size, loff_t *poffset)
1539{
1540 int rc = -EACCES;
1541 unsigned int bytes_read = 0;
1542 unsigned int total_read = 0;
1543 unsigned int current_read_size;
1544 struct cifs_sb_info *cifs_sb;
1545 struct cifsTconInfo *pTcon;
1546 int xid;
1547 struct cifsFileInfo *open_file;
1548 char *smb_read_data;
1549 char __user *current_offset;
1550 struct smb_com_read_rsp *pSMBr;
1551
1552 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001553 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 pTcon = cifs_sb->tcon;
1555
1556 if (file->private_data == NULL) {
1557 FreeXid(xid);
1558 return -EBADF;
1559 }
1560 open_file = (struct cifsFileInfo *)file->private_data;
1561
1562 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1563 cFYI(1, ("attempting read on write only file instance"));
1564 }
1565 for (total_read = 0, current_offset = read_data;
1566 read_size > total_read;
1567 total_read += bytes_read, current_offset += bytes_read) {
1568 current_read_size = min_t(const int, read_size - total_read,
1569 cifs_sb->rsize);
1570 rc = -EAGAIN;
1571 smb_read_data = NULL;
1572 while (rc == -EAGAIN) {
Steve Frenchec637e32005-12-12 20:53:18 -08001573 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001574 if ((open_file->invalidHandle) &&
1575 (!open_file->closePend)) {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001576 rc = cifs_reopen_file(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577 file, TRUE);
1578 if (rc != 0)
1579 break;
1580 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001581 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001582 open_file->netfid,
1583 current_read_size, *poffset,
1584 &bytes_read, &smb_read_data,
1585 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001586 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001587 if (smb_read_data) {
Steve French93544cc2006-02-14 22:30:52 -06001588 if (copy_to_user(current_offset,
1589 smb_read_data +
1590 4 /* RFC1001 length field */ +
1591 le16_to_cpu(pSMBr->DataOffset),
1592 bytes_read)) {
1593 rc = -EFAULT;
1594 }
1595
Steve Frenchec637e32005-12-12 20:53:18 -08001596 if(buf_type == CIFS_SMALL_BUFFER)
1597 cifs_small_buf_release(smb_read_data);
1598 else if(buf_type == CIFS_LARGE_BUFFER)
1599 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001600 smb_read_data = NULL;
1601 }
1602 }
1603 if (rc || (bytes_read == 0)) {
1604 if (total_read) {
1605 break;
1606 } else {
1607 FreeXid(xid);
1608 return rc;
1609 }
1610 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001611 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001612 *poffset += bytes_read;
1613 }
1614 }
1615 FreeXid(xid);
1616 return total_read;
1617}
1618
1619
1620static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1621 loff_t *poffset)
1622{
1623 int rc = -EACCES;
1624 unsigned int bytes_read = 0;
1625 unsigned int total_read;
1626 unsigned int current_read_size;
1627 struct cifs_sb_info *cifs_sb;
1628 struct cifsTconInfo *pTcon;
1629 int xid;
1630 char *current_offset;
1631 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001632 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
1634 xid = GetXid();
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001635 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001636 pTcon = cifs_sb->tcon;
1637
1638 if (file->private_data == NULL) {
1639 FreeXid(xid);
1640 return -EBADF;
1641 }
1642 open_file = (struct cifsFileInfo *)file->private_data;
1643
1644 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1645 cFYI(1, ("attempting read on write only file instance"));
1646
1647 for (total_read = 0, current_offset = read_data;
1648 read_size > total_read;
1649 total_read += bytes_read, current_offset += bytes_read) {
1650 current_read_size = min_t(const int, read_size - total_read,
1651 cifs_sb->rsize);
Steve Frenchf9f5c8172005-09-15 23:06:38 -07001652 /* For windows me and 9x we do not want to request more
1653 than it negotiated since it will refuse the read then */
1654 if((pTcon->ses) &&
1655 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1656 current_read_size = min_t(const int, current_read_size,
1657 pTcon->ses->server->maxBuf - 128);
1658 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001659 rc = -EAGAIN;
1660 while (rc == -EAGAIN) {
1661 if ((open_file->invalidHandle) &&
1662 (!open_file->closePend)) {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001663 rc = cifs_reopen_file(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001664 file, TRUE);
1665 if (rc != 0)
1666 break;
1667 }
Steve Frenchbfa0d752005-08-31 21:50:37 -07001668 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001669 open_file->netfid,
1670 current_read_size, *poffset,
1671 &bytes_read, &current_offset,
1672 &buf_type);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673 }
1674 if (rc || (bytes_read == 0)) {
1675 if (total_read) {
1676 break;
1677 } else {
1678 FreeXid(xid);
1679 return rc;
1680 }
1681 } else {
Steve Frencha4544342005-08-24 13:59:35 -07001682 cifs_stats_bytes_read(pTcon, total_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001683 *poffset += bytes_read;
1684 }
1685 }
1686 FreeXid(xid);
1687 return total_read;
1688}
1689
1690int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1691{
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001692 struct dentry *dentry = file->f_path.dentry;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001693 int rc, xid;
1694
1695 xid = GetXid();
1696 rc = cifs_revalidate(dentry);
1697 if (rc) {
1698 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1699 FreeXid(xid);
1700 return rc;
1701 }
1702 rc = generic_file_mmap(file, vma);
1703 FreeXid(xid);
1704 return rc;
1705}
1706
1707
1708static void cifs_copy_cache_pages(struct address_space *mapping,
1709 struct list_head *pages, int bytes_read, char *data,
1710 struct pagevec *plru_pvec)
1711{
1712 struct page *page;
1713 char *target;
1714
1715 while (bytes_read > 0) {
1716 if (list_empty(pages))
1717 break;
1718
1719 page = list_entry(pages->prev, struct page, lru);
1720 list_del(&page->lru);
1721
1722 if (add_to_page_cache(page, mapping, page->index,
1723 GFP_KERNEL)) {
1724 page_cache_release(page);
1725 cFYI(1, ("Add page cache failed"));
Steve French3079ca62005-06-09 14:44:07 -07001726 data += PAGE_CACHE_SIZE;
1727 bytes_read -= PAGE_CACHE_SIZE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 continue;
1729 }
1730
1731 target = kmap_atomic(page,KM_USER0);
1732
1733 if (PAGE_CACHE_SIZE > bytes_read) {
1734 memcpy(target, data, bytes_read);
1735 /* zero the tail end of this partial page */
1736 memset(target + bytes_read, 0,
1737 PAGE_CACHE_SIZE - bytes_read);
1738 bytes_read = 0;
1739 } else {
1740 memcpy(target, data, PAGE_CACHE_SIZE);
1741 bytes_read -= PAGE_CACHE_SIZE;
1742 }
1743 kunmap_atomic(target, KM_USER0);
1744
1745 flush_dcache_page(page);
1746 SetPageUptodate(page);
1747 unlock_page(page);
1748 if (!pagevec_add(plru_pvec, page))
1749 __pagevec_lru_add(plru_pvec);
1750 data += PAGE_CACHE_SIZE;
1751 }
1752 return;
1753}
1754
1755static int cifs_readpages(struct file *file, struct address_space *mapping,
1756 struct list_head *page_list, unsigned num_pages)
1757{
1758 int rc = -EACCES;
1759 int xid;
1760 loff_t offset;
1761 struct page *page;
1762 struct cifs_sb_info *cifs_sb;
1763 struct cifsTconInfo *pTcon;
1764 int bytes_read = 0;
1765 unsigned int read_size,i;
1766 char *smb_read_data = NULL;
1767 struct smb_com_read_rsp *pSMBr;
1768 struct pagevec lru_pvec;
1769 struct cifsFileInfo *open_file;
Steve Frenchec637e32005-12-12 20:53:18 -08001770 int buf_type = CIFS_NO_BUFFER;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001771
1772 xid = GetXid();
1773 if (file->private_data == NULL) {
1774 FreeXid(xid);
1775 return -EBADF;
1776 }
1777 open_file = (struct cifsFileInfo *)file->private_data;
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001778 cifs_sb = CIFS_SB(file->f_path.dentry->d_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779 pTcon = cifs_sb->tcon;
Steve Frenchbfa0d752005-08-31 21:50:37 -07001780
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 pagevec_init(&lru_pvec, 0);
1782
1783 for (i = 0; i < num_pages; ) {
1784 unsigned contig_pages;
1785 struct page *tmp_page;
1786 unsigned long expected_index;
1787
1788 if (list_empty(page_list))
1789 break;
1790
1791 page = list_entry(page_list->prev, struct page, lru);
1792 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1793
1794 /* count adjacent pages that we will read into */
1795 contig_pages = 0;
1796 expected_index =
1797 list_entry(page_list->prev, struct page, lru)->index;
1798 list_for_each_entry_reverse(tmp_page,page_list,lru) {
1799 if (tmp_page->index == expected_index) {
1800 contig_pages++;
1801 expected_index++;
1802 } else
1803 break;
1804 }
1805 if (contig_pages + i > num_pages)
1806 contig_pages = num_pages - i;
1807
1808 /* for reads over a certain size could initiate async
1809 read ahead */
1810
1811 read_size = contig_pages * PAGE_CACHE_SIZE;
1812 /* Read size needs to be in multiples of one page */
1813 read_size = min_t(const unsigned int, read_size,
1814 cifs_sb->rsize & PAGE_CACHE_MASK);
1815
1816 rc = -EAGAIN;
1817 while (rc == -EAGAIN) {
1818 if ((open_file->invalidHandle) &&
1819 (!open_file->closePend)) {
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001820 rc = cifs_reopen_file(file->f_path.dentry->d_inode,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001821 file, TRUE);
1822 if (rc != 0)
1823 break;
1824 }
1825
Steve Frenchbfa0d752005-08-31 21:50:37 -07001826 rc = CIFSSMBRead(xid, pTcon,
Steve Frenchec637e32005-12-12 20:53:18 -08001827 open_file->netfid,
1828 read_size, offset,
1829 &bytes_read, &smb_read_data,
1830 &buf_type);
Steve Frencha9d02ad2005-08-24 23:06:05 -07001831 /* BB more RC checks ? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001832 if (rc== -EAGAIN) {
1833 if (smb_read_data) {
Steve Frenchec637e32005-12-12 20:53:18 -08001834 if(buf_type == CIFS_SMALL_BUFFER)
1835 cifs_small_buf_release(smb_read_data);
1836 else if(buf_type == CIFS_LARGE_BUFFER)
1837 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 smb_read_data = NULL;
1839 }
1840 }
1841 }
1842 if ((rc < 0) || (smb_read_data == NULL)) {
1843 cFYI(1, ("Read error in readpages: %d", rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844 break;
1845 } else if (bytes_read > 0) {
Andrew Morton6f88cc22006-12-10 02:19:44 -08001846 task_io_account_read(bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001847 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1848 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1849 smb_read_data + 4 /* RFC1001 hdr */ +
1850 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1851
1852 i += bytes_read >> PAGE_CACHE_SHIFT;
Steve Frencha4544342005-08-24 13:59:35 -07001853 cifs_stats_bytes_read(pTcon, bytes_read);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001854 if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1855 i++; /* account for partial page */
1856
1857 /* server copy of file can have smaller size
1858 than client */
1859 /* BB do we need to verify this common case ?
1860 this case is ok - if we are at server EOF
1861 we will hit it on next read */
1862
OGAWA Hirofumi05ac9d42006-11-02 22:07:08 -08001863 /* break; */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864 }
1865 } else {
1866 cFYI(1, ("No bytes read (%d) at offset %lld . "
1867 "Cleaning remaining pages from readahead list",
1868 bytes_read, offset));
1869 /* BB turn off caching and do new lookup on
1870 file size at server? */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001871 break;
1872 }
1873 if (smb_read_data) {
Steve Frenchec637e32005-12-12 20:53:18 -08001874 if(buf_type == CIFS_SMALL_BUFFER)
1875 cifs_small_buf_release(smb_read_data);
1876 else if(buf_type == CIFS_LARGE_BUFFER)
1877 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878 smb_read_data = NULL;
1879 }
1880 bytes_read = 0;
1881 }
1882
1883 pagevec_lru_add(&lru_pvec);
1884
1885/* need to free smb_read_data buf before exit */
1886 if (smb_read_data) {
Steve French47c886b2006-01-18 14:20:39 -08001887 if(buf_type == CIFS_SMALL_BUFFER)
1888 cifs_small_buf_release(smb_read_data);
1889 else if(buf_type == CIFS_LARGE_BUFFER)
1890 cifs_buf_release(smb_read_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891 smb_read_data = NULL;
1892 }
1893
1894 FreeXid(xid);
1895 return rc;
1896}
1897
1898static int cifs_readpage_worker(struct file *file, struct page *page,
1899 loff_t *poffset)
1900{
1901 char *read_data;
1902 int rc;
1903
1904 page_cache_get(page);
1905 read_data = kmap(page);
1906 /* for reads over a certain size could initiate async read ahead */
1907
1908 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1909
1910 if (rc < 0)
1911 goto io_error;
1912 else
Steve French26a21b92006-05-31 18:05:34 +00001913 cFYI(1, ("Bytes read %d",rc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914
Josef "Jeff" Sipeke6a00292006-12-08 02:36:48 -08001915 file->f_path.dentry->d_inode->i_atime =
1916 current_fs_time(file->f_path.dentry->d_inode->i_sb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001917
1918 if (PAGE_CACHE_SIZE > rc)
1919 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1920
1921 flush_dcache_page(page);
1922 SetPageUptodate(page);
1923 rc = 0;
1924
1925io_error:
1926 kunmap(page);
1927 page_cache_release(page);
1928 return rc;
1929}
1930
1931static int cifs_readpage(struct file *file, struct page *page)
1932{
1933 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1934 int rc = -EACCES;
1935 int xid;
1936
1937 xid = GetXid();
1938
1939 if (file->private_data == NULL) {
1940 FreeXid(xid);
1941 return -EBADF;
1942 }
1943
1944 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1945 page, (int)offset, (int)offset));
1946
1947 rc = cifs_readpage_worker(file, page, &offset);
1948
1949 unlock_page(page);
1950
1951 FreeXid(xid);
1952 return rc;
1953}
1954
1955/* We do not want to update the file size from server for inodes
1956 open for write - to avoid races with writepage extending
1957 the file - in the future we could consider allowing
1958 refreshing the inode only on increases in the file size
1959 but this is tricky to do without racing with writebehind
1960 page caching in the current Linux kernel design */
Steve French7ba52632007-02-08 18:14:13 +00001961int is_size_safe_to_change(struct cifsInodeInfo *cifsInode, __u64 end_of_file)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001962{
Steve French23e7dd72005-10-20 13:44:56 -07001963 struct cifsFileInfo *open_file = NULL;
1964
1965 if (cifsInode)
1966 open_file = find_writable_file(cifsInode);
1967
1968 if(open_file) {
Steve Frenchc32a0b62006-01-12 14:41:28 -08001969 struct cifs_sb_info *cifs_sb;
1970
Steve French23e7dd72005-10-20 13:44:56 -07001971 /* there is not actually a write pending so let
1972 this handle go free and allow it to
1973 be closable if needed */
1974 atomic_dec(&open_file->wrtPending);
Steve Frenchc32a0b62006-01-12 14:41:28 -08001975
1976 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
1977 if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
1978 /* since no page cache to corrupt on directio
1979 we can change size safely */
1980 return 1;
1981 }
1982
Steve French7ba52632007-02-08 18:14:13 +00001983 if(i_size_read(&cifsInode->vfs_inode) < end_of_file)
1984 return 1;
1985
Steve French6148a742005-10-05 12:23:19 -07001986 return 0;
Steve French23e7dd72005-10-20 13:44:56 -07001987 } else
Steve French6148a742005-10-05 12:23:19 -07001988 return 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001989}
1990
Linus Torvalds1da177e2005-04-16 15:20:36 -07001991static int cifs_prepare_write(struct file *file, struct page *page,
1992 unsigned from, unsigned to)
1993{
1994 int rc = 0;
1995 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1996 cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
1997 if (!PageUptodate(page)) {
1998 /* if (to - from != PAGE_CACHE_SIZE) {
1999 void *kaddr = kmap_atomic(page, KM_USER0);
2000 memset(kaddr, 0, from);
2001 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
2002 flush_dcache_page(page);
2003 kunmap_atomic(kaddr, KM_USER0);
2004 } */
2005 /* If we are writing a full page it will be up to date,
2006 no need to read from the server */
2007 if ((to == PAGE_CACHE_SIZE) && (from == 0))
2008 SetPageUptodate(page);
2009
2010 /* might as well read a page, it is fast enough */
2011 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
2012 rc = cifs_readpage_worker(file, page, &offset);
2013 } else {
2014 /* should we try using another file handle if there is one -
2015 how would we lock it to prevent close of that handle
2016 racing with this read?
2017 In any case this will be written out by commit_write */
2018 }
2019 }
2020
2021 /* BB should we pass any errors back?
2022 e.g. if we do not have read access to the file */
2023 return 0;
2024}
2025
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002026const struct address_space_operations cifs_addr_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027 .readpage = cifs_readpage,
2028 .readpages = cifs_readpages,
2029 .writepage = cifs_writepage,
Steve French37c0eb42005-10-05 14:50:29 -07002030 .writepages = cifs_writepages,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002031 .prepare_write = cifs_prepare_write,
2032 .commit_write = cifs_commit_write,
2033 .set_page_dirty = __set_page_dirty_nobuffers,
2034 /* .sync_page = cifs_sync_page, */
2035 /* .direct_IO = */
2036};
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002037
2038/*
2039 * cifs_readpages requires the server to support a buffer large enough to
2040 * contain the header plus one complete page of data. Otherwise, we need
2041 * to leave cifs_readpages out of the address space operations.
2042 */
Christoph Hellwigf5e54d62006-06-28 04:26:44 -07002043const struct address_space_operations cifs_addr_ops_smallbuf = {
Dave Kleikamp273d81d2006-06-01 19:41:23 +00002044 .readpage = cifs_readpage,
2045 .writepage = cifs_writepage,
2046 .writepages = cifs_writepages,
2047 .prepare_write = cifs_prepare_write,
2048 .commit_write = cifs_commit_write,
2049 .set_page_dirty = __set_page_dirty_nobuffers,
2050 /* .sync_page = cifs_sync_page, */
2051 /* .direct_IO = */
2052};