]> bbs.cooldavid.org Git - net-next-2.6.git/blame - fs/cifs/file.c
git://bbs.cooldavid.org / net-next-2.6.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] buglet in radix_tree_tag_set
[net-next-2.6.git] / fs / cifs / file.c
CommitLineData
1da177e4
LT		 1/*
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)
8 *
9 * This library is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU Lesser General Public License as published
11 * by the Free Software Foundation; either version 2.1 of the License, or
12 * (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See
17 * the GNU Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public License
20 * along with this library; if not, write to the Free Software
21 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 */
23#include <linux/fs.h>
37c0eb46 24#include <linux/backing-dev.h>
1da177e4
LT		 25#include <linux/stat.h>
26#include <linux/fcntl.h>
37c0eb46 27#include <linux/mpage.h>
1da177e4
LT		 28#include <linux/pagemap.h>
29#include <linux/pagevec.h>
30#include <linux/smp_lock.h>
37c0eb46 31#include <linux/writeback.h>
23e7dd7d 32#include <linux/delay.h>
1da177e4
LT		 33#include <asm/div64.h>
34#include "cifsfs.h"
35#include "cifspdu.h"
36#include "cifsglob.h"
37#include "cifsproto.h"
38#include "cifs_unicode.h"
39#include "cifs_debug.h"
40#include "cifs_fs_sb.h"
41
42static inline struct cifsFileInfo *cifs_init_private(
43 struct cifsFileInfo *private_data, struct inode *inode,
44 struct file *file, __u16 netfid)
45{
46 memset(private_data, 0, sizeof(struct cifsFileInfo));
47 private_data->netfid = netfid;
48 private_data->pid = current->tgid;
49 init_MUTEX(&private_data->fh_sem);
50 private_data->pfile = file; /* needed for writepage */
51 private_data->pInode = inode;
52 private_data->invalidHandle = FALSE;
53 private_data->closePend = FALSE;
23e7dd7d
SF		 54 /* we have to track num writers to the inode, since writepages
55 does not tell us which handle the write is for so there can
56 be a close (overlapping with write) of the filehandle that
57 cifs_writepages chose to use */
58 atomic_set(&private_data->wrtPending,0);
1da177e4
LT		 59
60 return private_data;
61}
62
63static inline int cifs_convert_flags(unsigned int flags)
64{
65 if ((flags & O_ACCMODE) == O_RDONLY)
66 return GENERIC_READ;
67 else if ((flags & O_ACCMODE) == O_WRONLY)
68 return GENERIC_WRITE;
69 else if ((flags & O_ACCMODE) == O_RDWR) {
70 /* GENERIC_ALL is too much permission to request
71 can cause unnecessary access denied on create */
72 /* return GENERIC_ALL; */
73 return (GENERIC_READ | GENERIC_WRITE);
74 }
75
76 return 0x20197;
77}
78
79static inline int cifs_get_disposition(unsigned int flags)
80{
81 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
82 return FILE_CREATE;
83 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
84 return FILE_OVERWRITE_IF;
85 else if ((flags & O_CREAT) == O_CREAT)
86 return FILE_OPEN_IF;
55aa2e09
SF		 87 else if ((flags & O_TRUNC) == O_TRUNC)
88 return FILE_OVERWRITE;
1da177e4
LT		 89 else
90 return FILE_OPEN;
91}
92
93/* all arguments to this function must be checked for validity in caller */
94static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
95 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
96 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
97 char *full_path, int xid)
98{
99 struct timespec temp;
100 int rc;
101
102 /* want handles we can use to read with first
103 in the list so we do not have to walk the
104 list to search for one in prepare_write */
105 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
106 list_add_tail(&pCifsFile->flist,
107 &pCifsInode->openFileList);
108 } else {
109 list_add(&pCifsFile->flist,
110 &pCifsInode->openFileList);
111 }
112 write_unlock(&GlobalSMBSeslock);
113 write_unlock(&file->f_owner.lock);
114 if (pCifsInode->clientCanCacheRead) {
115 /* we have the inode open somewhere else
116 no need to discard cache data */
117 goto client_can_cache;
118 }
119
120 /* BB need same check in cifs_create too? */
121 /* if not oplocked, invalidate inode pages if mtime or file
122 size changed */
123 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
124 if (timespec_equal(&file->f_dentry->d_inode->i_mtime, &temp) &&
125 (file->f_dentry->d_inode->i_size ==
126 (loff_t)le64_to_cpu(buf->EndOfFile))) {
127 cFYI(1, ("inode unchanged on server"));
128 } else {
129 if (file->f_dentry->d_inode->i_mapping) {
130 /* BB no need to lock inode until after invalidate
131 since namei code should already have it locked? */
28fd1298 132 filemap_write_and_wait(file->f_dentry->d_inode->i_mapping);
1da177e4
LT		 133 }
134 cFYI(1, ("invalidating remote inode since open detected it "
135 "changed"));
136 invalidate_remote_inode(file->f_dentry->d_inode);
137 }
138
139client_can_cache:
140 if (pTcon->ses->capabilities & CAP_UNIX)
141 rc = cifs_get_inode_info_unix(&file->f_dentry->d_inode,
142 full_path, inode->i_sb, xid);
143 else
144 rc = cifs_get_inode_info(&file->f_dentry->d_inode,
145 full_path, buf, inode->i_sb, xid);
146
147 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
148 pCifsInode->clientCanCacheAll = TRUE;
149 pCifsInode->clientCanCacheRead = TRUE;
150 cFYI(1, ("Exclusive Oplock granted on inode %p",
151 file->f_dentry->d_inode));
152 } else if ((*oplock & 0xF) == OPLOCK_READ)
153 pCifsInode->clientCanCacheRead = TRUE;
154
155 return rc;
156}
157
158int cifs_open(struct inode *inode, struct file *file)
159{
160 int rc = -EACCES;
161 int xid, oplock;
162 struct cifs_sb_info *cifs_sb;
163 struct cifsTconInfo *pTcon;
164 struct cifsFileInfo *pCifsFile;
165 struct cifsInodeInfo *pCifsInode;
166 struct list_head *tmp;
167 char *full_path = NULL;
168 int desiredAccess;
169 int disposition;
170 __u16 netfid;
171 FILE_ALL_INFO *buf = NULL;
172
173 xid = GetXid();
174
175 cifs_sb = CIFS_SB(inode->i_sb);
176 pTcon = cifs_sb->tcon;
177
178 if (file->f_flags & O_CREAT) {
179 /* search inode for this file and fill in file->private_data */
180 pCifsInode = CIFS_I(file->f_dentry->d_inode);
181 read_lock(&GlobalSMBSeslock);
182 list_for_each(tmp, &pCifsInode->openFileList) {
183 pCifsFile = list_entry(tmp, struct cifsFileInfo,
184 flist);
185 if ((pCifsFile->pfile == NULL) &&
186 (pCifsFile->pid == current->tgid)) {
187 /* mode set in cifs_create */
188
189 /* needed for writepage */
190 pCifsFile->pfile = file;
191
192 file->private_data = pCifsFile;
193 break;
194 }
195 }
196 read_unlock(&GlobalSMBSeslock);
197 if (file->private_data != NULL) {
198 rc = 0;
199 FreeXid(xid);
200 return rc;
201 } else {
202 if (file->f_flags & O_EXCL)
203 cERROR(1, ("could not find file instance for "
204 "new file %p ", file));
205 }
206 }
207
7f57356b 208 full_path = build_path_from_dentry(file->f_dentry);
1da177e4
LT		 209 if (full_path == NULL) {
210 FreeXid(xid);
211 return -ENOMEM;
212 }
213
214 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
215 inode, file->f_flags, full_path));
216 desiredAccess = cifs_convert_flags(file->f_flags);
217
218/*********************************************************************
219 * open flag mapping table:
220 *
221 * POSIX Flag CIFS Disposition
222 * ---------- ----------------
223 * O_CREAT FILE_OPEN_IF
224 * O_CREAT | O_EXCL FILE_CREATE
225 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
226 * O_TRUNC FILE_OVERWRITE
227 * none of the above FILE_OPEN
228 *
229 * Note that there is not a direct match between disposition
230 * FILE_SUPERSEDE (ie create whether or not file exists although
231 * O_CREAT | O_TRUNC is similar but truncates the existing
232 * file rather than creating a new file as FILE_SUPERSEDE does
233 * (which uses the attributes / metadata passed in on open call)
234 *?
235 *? O_SYNC is a reasonable match to CIFS writethrough flag
236 *? and the read write flags match reasonably. O_LARGEFILE
237 *? is irrelevant because largefile support is always used
238 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
239 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
240 *********************************************************************/
241
242 disposition = cifs_get_disposition(file->f_flags);
243
244 if (oplockEnabled)
245 oplock = REQ_OPLOCK;
246 else
247 oplock = FALSE;
248
249 /* BB pass O_SYNC flag through on file attributes .. BB */
250
251 /* Also refresh inode by passing in file_info buf returned by SMBOpen
252 and calling get_inode_info with returned buf (at least helps
253 non-Unix server case) */
254
255 /* BB we can not do this if this is the second open of a file
256 and the first handle has writebehind data, we might be
257 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
258 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
259 if (!buf) {
260 rc = -ENOMEM;
261 goto out;
262 }
263 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
264 CREATE_NOT_DIR, &netfid, &oplock, buf,
737b758c
SF		 265 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
266 & CIFS_MOUNT_MAP_SPECIAL_CHR);
a9d02ad4
SF		 267 if (rc == -EIO) {
268 /* Old server, try legacy style OpenX */
269 rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
270 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
271 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
272 & CIFS_MOUNT_MAP_SPECIAL_CHR);
273 }
1da177e4
LT		 274 if (rc) {
275 cFYI(1, ("cifs_open returned 0x%x ", rc));
276 goto out;
277 }
278 file->private_data =
279 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
280 if (file->private_data == NULL) {
281 rc = -ENOMEM;
282 goto out;
283 }
284 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
285 write_lock(&file->f_owner.lock);
286 write_lock(&GlobalSMBSeslock);
287 list_add(&pCifsFile->tlist, &pTcon->openFileList);
288
289 pCifsInode = CIFS_I(file->f_dentry->d_inode);
290 if (pCifsInode) {
291 rc = cifs_open_inode_helper(inode, file, pCifsInode,
292 pCifsFile, pTcon,
293 &oplock, buf, full_path, xid);
294 } else {
295 write_unlock(&GlobalSMBSeslock);
296 write_unlock(&file->f_owner.lock);
297 }
298
299 if (oplock & CIFS_CREATE_ACTION) {
300 /* time to set mode which we can not set earlier due to
301 problems creating new read-only files */
302 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
303 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
304 inode->i_mode,
305 (__u64)-1, (__u64)-1, 0 /* dev */,
737b758c
SF		 306 cifs_sb->local_nls,
307 cifs_sb->mnt_cifs_flags &
308 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 309 } else {
310 /* BB implement via Windows security descriptors eg
311 CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
312 -1, -1, local_nls);
313 in the meantime could set r/o dos attribute when
314 perms are eg: mode & 0222 == 0 */
315 }
316 }
317
318out:
319 kfree(buf);
320 kfree(full_path);
321 FreeXid(xid);
322 return rc;
323}
324
325/* Try to reaquire byte range locks that were released when session */
326/* to server was lost */
327static int cifs_relock_file(struct cifsFileInfo *cifsFile)
328{
329 int rc = 0;
330
331/* BB list all locks open on this file and relock */
332
333 return rc;
334}
335
336static int cifs_reopen_file(struct inode *inode, struct file *file,
337 int can_flush)
338{
339 int rc = -EACCES;
340 int xid, oplock;
341 struct cifs_sb_info *cifs_sb;
342 struct cifsTconInfo *pTcon;
343 struct cifsFileInfo *pCifsFile;
344 struct cifsInodeInfo *pCifsInode;
345 char *full_path = NULL;
346 int desiredAccess;
347 int disposition = FILE_OPEN;
348 __u16 netfid;
349
350 if (inode == NULL)
351 return -EBADF;
352 if (file->private_data) {
353 pCifsFile = (struct cifsFileInfo *)file->private_data;
354 } else
355 return -EBADF;
356
357 xid = GetXid();
358 down(&pCifsFile->fh_sem);
359 if (pCifsFile->invalidHandle == FALSE) {
360 up(&pCifsFile->fh_sem);
361 FreeXid(xid);
362 return 0;
363 }
364
365 if (file->f_dentry == NULL) {
366 up(&pCifsFile->fh_sem);
367 cFYI(1, ("failed file reopen, no valid name if dentry freed"));
368 FreeXid(xid);
369 return -EBADF;
370 }
371 cifs_sb = CIFS_SB(inode->i_sb);
372 pTcon = cifs_sb->tcon;
373/* can not grab rename sem here because various ops, including
374 those that already have the rename sem can end up causing writepage
375 to get called and if the server was down that means we end up here,
376 and we can never tell if the caller already has the rename_sem */
7f57356b 377 full_path = build_path_from_dentry(file->f_dentry);
1da177e4
LT		 378 if (full_path == NULL) {
379 up(&pCifsFile->fh_sem);
380 FreeXid(xid);
381 return -ENOMEM;
382 }
383
384 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
385 inode, file->f_flags,full_path));
386 desiredAccess = cifs_convert_flags(file->f_flags);
387
388 if (oplockEnabled)
389 oplock = REQ_OPLOCK;
390 else
391 oplock = FALSE;
392
393 /* Can not refresh inode by passing in file_info buf to be returned
394 by SMBOpen and then calling get_inode_info with returned buf
395 since file might have write behind data that needs to be flushed
396 and server version of file size can be stale. If we knew for sure
397 that inode was not dirty locally we could do this */
398
399/* buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
400 if (buf == 0) {
401 up(&pCifsFile->fh_sem);
402 kfree(full_path);
403 FreeXid(xid);
404 return -ENOMEM;
405 } */
406 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
407 CREATE_NOT_DIR, &netfid, &oplock, NULL,
737b758c
SF		 408 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
409 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 410 if (rc) {
411 up(&pCifsFile->fh_sem);
412 cFYI(1, ("cifs_open returned 0x%x ", rc));
413 cFYI(1, ("oplock: %d ", oplock));
414 } else {
415 pCifsFile->netfid = netfid;
416 pCifsFile->invalidHandle = FALSE;
417 up(&pCifsFile->fh_sem);
418 pCifsInode = CIFS_I(inode);
419 if (pCifsInode) {
420 if (can_flush) {
28fd1298 421 filemap_write_and_wait(inode->i_mapping);
1da177e4
LT		 422 /* temporarily disable caching while we
423 go to server to get inode info */
424 pCifsInode->clientCanCacheAll = FALSE;
425 pCifsInode->clientCanCacheRead = FALSE;
426 if (pTcon->ses->capabilities & CAP_UNIX)
427 rc = cifs_get_inode_info_unix(&inode,
428 full_path, inode->i_sb, xid);
429 else
430 rc = cifs_get_inode_info(&inode,
431 full_path, NULL, inode->i_sb,
432 xid);
433 } /* else we are writing out data to server already
434 and could deadlock if we tried to flush data, and
435 since we do not know if we have data that would
436 invalidate the current end of file on the server
437 we can not go to the server to get the new inod
438 info */
439 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
440 pCifsInode->clientCanCacheAll = TRUE;
441 pCifsInode->clientCanCacheRead = TRUE;
442 cFYI(1, ("Exclusive Oplock granted on inode %p",
443 file->f_dentry->d_inode));
444 } else if ((oplock & 0xF) == OPLOCK_READ) {
445 pCifsInode->clientCanCacheRead = TRUE;
446 pCifsInode->clientCanCacheAll = FALSE;
447 } else {
448 pCifsInode->clientCanCacheRead = FALSE;
449 pCifsInode->clientCanCacheAll = FALSE;
450 }
451 cifs_relock_file(pCifsFile);
452 }
453 }
454
455 kfree(full_path);
456 FreeXid(xid);
457 return rc;
458}
459
460int cifs_close(struct inode *inode, struct file *file)
461{
462 int rc = 0;
463 int xid;
464 struct cifs_sb_info *cifs_sb;
465 struct cifsTconInfo *pTcon;
466 struct cifsFileInfo *pSMBFile =
467 (struct cifsFileInfo *)file->private_data;
468
469 xid = GetXid();
470
471 cifs_sb = CIFS_SB(inode->i_sb);
472 pTcon = cifs_sb->tcon;
473 if (pSMBFile) {
474 pSMBFile->closePend = TRUE;
475 write_lock(&file->f_owner.lock);
476 if (pTcon) {
477 /* no sense reconnecting to close a file that is
478 already closed */
479 if (pTcon->tidStatus != CifsNeedReconnect) {
23e7dd7d
SF		 480 int timeout = 2;
481 while((atomic_read(&pSMBFile->wrtPending) != 0)
482 && (timeout < 1000) ) {
483 /* Give write a better chance to get to
484 server ahead of the close. We do not
485 want to add a wait_q here as it would
486 increase the memory utilization as
487 the struct would be in each open file,
488 but this should give enough time to
489 clear the socket */
c119b87d 490 write_unlock(&file->f_owner.lock);
23e7dd7d
SF		 491 cERROR(1,("close with pending writes"));
492 msleep(timeout);
c119b87d 493 write_lock(&file->f_owner.lock);
23e7dd7d
SF		 494 timeout *= 4;
495 }
1da177e4
LT		 496 write_unlock(&file->f_owner.lock);
497 rc = CIFSSMBClose(xid, pTcon,
498 pSMBFile->netfid);
499 write_lock(&file->f_owner.lock);
500 }
501 }
cbe0476f 502 write_lock(&GlobalSMBSeslock);
1da177e4
LT		 503 list_del(&pSMBFile->flist);
504 list_del(&pSMBFile->tlist);
cbe0476f 505 write_unlock(&GlobalSMBSeslock);
1da177e4
LT		 506 write_unlock(&file->f_owner.lock);
507 kfree(pSMBFile->search_resume_name);
508 kfree(file->private_data);
509 file->private_data = NULL;
510 } else
511 rc = -EBADF;
512
513 if (list_empty(&(CIFS_I(inode)->openFileList))) {
514 cFYI(1, ("closing last open instance for inode %p", inode));
515 /* if the file is not open we do not know if we can cache info
516 on this inode, much less write behind and read ahead */
517 CIFS_I(inode)->clientCanCacheRead = FALSE;
518 CIFS_I(inode)->clientCanCacheAll = FALSE;
519 }
520 if ((rc ==0) && CIFS_I(inode)->write_behind_rc)
521 rc = CIFS_I(inode)->write_behind_rc;
522 FreeXid(xid);
523 return rc;
524}
525
526int cifs_closedir(struct inode *inode, struct file *file)
527{
528 int rc = 0;
529 int xid;
530 struct cifsFileInfo *pCFileStruct =
531 (struct cifsFileInfo *)file->private_data;
532 char *ptmp;
533
534 cFYI(1, ("Closedir inode = 0x%p with ", inode));
535
536 xid = GetXid();
537
538 if (pCFileStruct) {
539 struct cifsTconInfo *pTcon;
540 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_dentry->d_sb);
541
542 pTcon = cifs_sb->tcon;
543
544 cFYI(1, ("Freeing private data in close dir"));
31ca3bc3
SF		 545 if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
546 (pCFileStruct->invalidHandle == FALSE)) {
1da177e4
LT		 547 pCFileStruct->invalidHandle = TRUE;
548 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
549 cFYI(1, ("Closing uncompleted readdir with rc %d",
550 rc));
551 /* not much we can do if it fails anyway, ignore rc */
552 rc = 0;
553 }
554 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
555 if (ptmp) {
ec637e3f 556 cFYI(1, ("closedir free smb buf in srch struct"));
1da177e4 557 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
d47d7c1a
SF		 558 if(pCFileStruct->srch_inf.smallBuf)
559 cifs_small_buf_release(ptmp);
560 else
561 cifs_buf_release(ptmp);
1da177e4
LT		 562 }
563 ptmp = pCFileStruct->search_resume_name;
564 if (ptmp) {
ec637e3f 565 cFYI(1, ("closedir free resume name"));
1da177e4
LT		 566 pCFileStruct->search_resume_name = NULL;
567 kfree(ptmp);
568 }
569 kfree(file->private_data);
570 file->private_data = NULL;
571 }
572 /* BB can we lock the filestruct while this is going on? */
573 FreeXid(xid);
574 return rc;
575}
576
577int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
578{
579 int rc, xid;
1da177e4
LT		 580 __u32 numLock = 0;
581 __u32 numUnlock = 0;
582 __u64 length;
583 int wait_flag = FALSE;
584 struct cifs_sb_info *cifs_sb;
585 struct cifsTconInfo *pTcon;
08547b03
SF		 586 __u16 netfid;
587 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
1da177e4
LT		 588
589 length = 1 + pfLock->fl_end - pfLock->fl_start;
590 rc = -EACCES;
591 xid = GetXid();
592
593 cFYI(1, ("Lock parm: 0x%x flockflags: "
594 "0x%x flocktype: 0x%x start: %lld end: %lld",
595 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
596 pfLock->fl_end));
597
598 if (pfLock->fl_flags & FL_POSIX)
d47d7c1a 599 cFYI(1, ("Posix"));
1da177e4 600 if (pfLock->fl_flags & FL_FLOCK)
d47d7c1a 601 cFYI(1, ("Flock"));
1da177e4 602 if (pfLock->fl_flags & FL_SLEEP) {
d47d7c1a 603 cFYI(1, ("Blocking lock"));
1da177e4
LT		 604 wait_flag = TRUE;
605 }
606 if (pfLock->fl_flags & FL_ACCESS)
607 cFYI(1, ("Process suspended by mandatory locking - "
608 "not implemented yet "));
609 if (pfLock->fl_flags & FL_LEASE)
610 cFYI(1, ("Lease on file - not implemented yet"));
611 if (pfLock->fl_flags &
612 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
613 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
614
615 if (pfLock->fl_type == F_WRLCK) {
616 cFYI(1, ("F_WRLCK "));
617 numLock = 1;
618 } else if (pfLock->fl_type == F_UNLCK) {
d47d7c1a 619 cFYI(1, ("F_UNLCK"));
1da177e4 620 numUnlock = 1;
d47d7c1a
SF		 621 /* Check if unlock includes more than
622 one lock range */
1da177e4 623 } else if (pfLock->fl_type == F_RDLCK) {
d47d7c1a 624 cFYI(1, ("F_RDLCK"));
1da177e4
LT		 625 lockType |= LOCKING_ANDX_SHARED_LOCK;
626 numLock = 1;
627 } else if (pfLock->fl_type == F_EXLCK) {
d47d7c1a 628 cFYI(1, ("F_EXLCK"));
1da177e4
LT		 629 numLock = 1;
630 } else if (pfLock->fl_type == F_SHLCK) {
d47d7c1a 631 cFYI(1, ("F_SHLCK"));
1da177e4
LT		 632 lockType |= LOCKING_ANDX_SHARED_LOCK;
633 numLock = 1;
634 } else
d47d7c1a 635 cFYI(1, ("Unknown type of lock"));
1da177e4
LT		 636
637 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
638 pTcon = cifs_sb->tcon;
639
640 if (file->private_data == NULL) {
641 FreeXid(xid);
642 return -EBADF;
643 }
08547b03
SF		 644 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
645
1da177e4 646
08547b03
SF		 647 /* BB add code here to normalize offset and length to
648 account for negative length which we can not accept over the
649 wire */
1da177e4 650 if (IS_GETLK(cmd)) {
08547b03 651 if(experimEnabled &&
82940a46
SF		 652 (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
653 (CIFS_UNIX_FCNTL_CAP &
654 le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability))) {
08547b03
SF		 655 int posix_lock_type;
656 if(lockType & LOCKING_ANDX_SHARED_LOCK)
657 posix_lock_type = CIFS_RDLCK;
658 else
659 posix_lock_type = CIFS_WRLCK;
660 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 1 /* get */,
fc94cdb9 661 length, pfLock,
08547b03
SF		 662 posix_lock_type, wait_flag);
663 FreeXid(xid);
664 return rc;
665 }
666
667 /* BB we could chain these into one lock request BB */
668 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
669 0, 1, lockType, 0 /* wait flag */ );
1da177e4 670 if (rc == 0) {
08547b03 671 rc = CIFSSMBLock(xid, pTcon, netfid, length,
1da177e4
LT		 672 pfLock->fl_start, 1 /* numUnlock */ ,
673 0 /* numLock */ , lockType,
674 0 /* wait flag */ );
675 pfLock->fl_type = F_UNLCK;
676 if (rc != 0)
677 cERROR(1, ("Error unlocking previously locked "
08547b03 678 "range %d during test of lock", rc));
1da177e4
LT		 679 rc = 0;
680
681 } else {
682 /* if rc == ERR_SHARING_VIOLATION ? */
683 rc = 0; /* do not change lock type to unlock
684 since range in use */
685 }
686
687 FreeXid(xid);
688 return rc;
689 }
08547b03 690 if (experimEnabled &&
82940a46
SF		 691 (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
692 (CIFS_UNIX_FCNTL_CAP &
693 le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability))) {
08547b03
SF		 694 int posix_lock_type;
695 if(lockType & LOCKING_ANDX_SHARED_LOCK)
696 posix_lock_type = CIFS_RDLCK;
697 else
698 posix_lock_type = CIFS_WRLCK;
699
700 if(numUnlock == 1)
beb84dc8 701 posix_lock_type = CIFS_UNLCK;
08547b03
SF		 702 else if(numLock == 0) {
703 /* if no lock or unlock then nothing
704 to do since we do not know what it is */
705 FreeXid(xid);
706 return -EOPNOTSUPP;
707 }
708 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
fc94cdb9 709 length, pfLock,
08547b03
SF		 710 posix_lock_type, wait_flag);
711 } else
712 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
713 numUnlock, numLock, lockType, wait_flag);
d634cc15 714 if (pfLock->fl_flags & FL_POSIX)
1da177e4
LT		 715 posix_lock_file_wait(file, pfLock);
716 FreeXid(xid);
717 return rc;
718}
719
720ssize_t cifs_user_write(struct file *file, const char __user *write_data,
721 size_t write_size, loff_t *poffset)
722{
723 int rc = 0;
724 unsigned int bytes_written = 0;
725 unsigned int total_written;
726 struct cifs_sb_info *cifs_sb;
727 struct cifsTconInfo *pTcon;
728 int xid, long_op;
729 struct cifsFileInfo *open_file;
730
731 if (file->f_dentry == NULL)
732 return -EBADF;
733
734 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
735 if (cifs_sb == NULL)
736 return -EBADF;
737
738 pTcon = cifs_sb->tcon;
739
740 /* cFYI(1,
741 (" write %d bytes to offset %lld of %s", write_size,
742 *poffset, file->f_dentry->d_name.name)); */
743
744 if (file->private_data == NULL)
745 return -EBADF;
746 else
747 open_file = (struct cifsFileInfo *) file->private_data;
748
749 xid = GetXid();
750 if (file->f_dentry->d_inode == NULL) {
751 FreeXid(xid);
752 return -EBADF;
753 }
754
755 if (*poffset > file->f_dentry->d_inode->i_size)
756 long_op = 2; /* writes past end of file can take a long time */
757 else
758 long_op = 1;
759
760 for (total_written = 0; write_size > total_written;
761 total_written += bytes_written) {
762 rc = -EAGAIN;
763 while (rc == -EAGAIN) {
764 if (file->private_data == NULL) {
765 /* file has been closed on us */
766 FreeXid(xid);
767 /* if we have gotten here we have written some data
768 and blocked, and the file has been freed on us while
769 we blocked so return what we managed to write */
770 return total_written;
771 }
772 if (open_file->closePend) {
773 FreeXid(xid);
774 if (total_written)
775 return total_written;
776 else
777 return -EBADF;
778 }
779 if (open_file->invalidHandle) {
780 if ((file->f_dentry == NULL) ||
781 (file->f_dentry->d_inode == NULL)) {
782 FreeXid(xid);
783 return total_written;
784 }
785 /* we could deadlock if we called
786 filemap_fdatawait from here so tell
787 reopen_file not to flush data to server
788 now */
789 rc = cifs_reopen_file(file->f_dentry->d_inode,
790 file, FALSE);
791 if (rc != 0)
792 break;
793 }
794
795 rc = CIFSSMBWrite(xid, pTcon,
796 open_file->netfid,
797 min_t(const int, cifs_sb->wsize,
798 write_size - total_written),
799 *poffset, &bytes_written,
800 NULL, write_data + total_written, long_op);
801 }
802 if (rc || (bytes_written == 0)) {
803 if (total_written)
804 break;
805 else {
806 FreeXid(xid);
807 return rc;
808 }
809 } else
810 *poffset += bytes_written;
811 long_op = FALSE; /* subsequent writes fast -
812 15 seconds is plenty */
813 }
814
a4544347 815 cifs_stats_bytes_written(pTcon, total_written);
1da177e4
LT		 816
817 /* since the write may have blocked check these pointers again */
818 if (file->f_dentry) {
819 if (file->f_dentry->d_inode) {
820 struct inode *inode = file->f_dentry->d_inode;
821 inode->i_ctime = inode->i_mtime =
822 current_fs_time(inode->i_sb);
823 if (total_written > 0) {
824 if (*poffset > file->f_dentry->d_inode->i_size)
825 i_size_write(file->f_dentry->d_inode,
826 *poffset);
827 }
828 mark_inode_dirty_sync(file->f_dentry->d_inode);
829 }
830 }
831 FreeXid(xid);
832 return total_written;
833}
834
835static ssize_t cifs_write(struct file *file, const char *write_data,
836 size_t write_size, loff_t *poffset)
837{
838 int rc = 0;
839 unsigned int bytes_written = 0;
840 unsigned int total_written;
841 struct cifs_sb_info *cifs_sb;
842 struct cifsTconInfo *pTcon;
843 int xid, long_op;
844 struct cifsFileInfo *open_file;
845
846 if (file->f_dentry == NULL)
847 return -EBADF;
848
849 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
850 if (cifs_sb == NULL)
851 return -EBADF;
852
853 pTcon = cifs_sb->tcon;
854
ab2f218f
SF		 855 cFYI(1,("write %zd bytes to offset %lld of %s", write_size,
856 *poffset, file->f_dentry->d_name.name));
1da177e4
LT		 857
858 if (file->private_data == NULL)
859 return -EBADF;
860 else
861 open_file = (struct cifsFileInfo *)file->private_data;
862
863 xid = GetXid();
864 if (file->f_dentry->d_inode == NULL) {
865 FreeXid(xid);
866 return -EBADF;
867 }
868
869 if (*poffset > file->f_dentry->d_inode->i_size)
870 long_op = 2; /* writes past end of file can take a long time */
871 else
872 long_op = 1;
873
874 for (total_written = 0; write_size > total_written;
875 total_written += bytes_written) {
876 rc = -EAGAIN;
877 while (rc == -EAGAIN) {
878 if (file->private_data == NULL) {
879 /* file has been closed on us */
880 FreeXid(xid);
881 /* if we have gotten here we have written some data
882 and blocked, and the file has been freed on us
883 while we blocked so return what we managed to
884 write */
885 return total_written;
886 }
887 if (open_file->closePend) {
888 FreeXid(xid);
889 if (total_written)
890 return total_written;
891 else
892 return -EBADF;
893 }
894 if (open_file->invalidHandle) {
895 if ((file->f_dentry == NULL) ||
896 (file->f_dentry->d_inode == NULL)) {
897 FreeXid(xid);
898 return total_written;
899 }
900 /* we could deadlock if we called
901 filemap_fdatawait from here so tell
902 reopen_file not to flush data to
903 server now */
904 rc = cifs_reopen_file(file->f_dentry->d_inode,
905 file, FALSE);
906 if (rc != 0)
907 break;
908 }
c01f36a8 909 if(experimEnabled || (pTcon->ses->server &&
08775834
SF		 910 ((pTcon->ses->server->secMode &
911 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
c01f36a8 912 == 0))) {
3e84469d
SF		 913 struct kvec iov[2];
914 unsigned int len;
915
0ae0efad 916 len = min((size_t)cifs_sb->wsize,
3e84469d
SF		 917 write_size - total_written);
918 /* iov[0] is reserved for smb header */
919 iov[1].iov_base = (char *)write_data +
920 total_written;
921 iov[1].iov_len = len;
d6e04ae6 922 rc = CIFSSMBWrite2(xid, pTcon,
3e84469d 923 open_file->netfid, len,
d6e04ae6 924 *poffset, &bytes_written,
3e84469d 925 iov, 1, long_op);
d6e04ae6 926 } else
60808233
SF		 927 rc = CIFSSMBWrite(xid, pTcon,
928 open_file->netfid,
929 min_t(const int, cifs_sb->wsize,
930 write_size - total_written),
931 *poffset, &bytes_written,
932 write_data + total_written,
933 NULL, long_op);
1da177e4
LT		 934 }
935 if (rc || (bytes_written == 0)) {
936 if (total_written)
937 break;
938 else {
939 FreeXid(xid);
940 return rc;
941 }
942 } else
943 *poffset += bytes_written;
944 long_op = FALSE; /* subsequent writes fast -
945 15 seconds is plenty */
946 }
947
a4544347 948 cifs_stats_bytes_written(pTcon, total_written);
1da177e4
LT		 949
950 /* since the write may have blocked check these pointers again */
951 if (file->f_dentry) {
952 if (file->f_dentry->d_inode) {
953 file->f_dentry->d_inode->i_ctime =
954 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
955 if (total_written > 0) {
956 if (*poffset > file->f_dentry->d_inode->i_size)
957 i_size_write(file->f_dentry->d_inode,
958 *poffset);
959 }
960 mark_inode_dirty_sync(file->f_dentry->d_inode);
961 }
962 }
963 FreeXid(xid);
964 return total_written;
965}
966
dd99cd80 967struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
6148a742
SF		 968{
969 struct cifsFileInfo *open_file;
dd99cd80 970 int rc;
6148a742 971
60808233
SF		 972 /* Having a null inode here (because mapping->host was set to zero by
973 the VFS or MM) should not happen but we had reports of on oops (due to
974 it being zero) during stress testcases so we need to check for it */
975
976 if(cifs_inode == NULL) {
977 cERROR(1,("Null inode passed to cifs_writeable_file"));
978 dump_stack();
979 return NULL;
980 }
981
6148a742
SF		 982 read_lock(&GlobalSMBSeslock);
983 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
984 if (open_file->closePend)
985 continue;
986 if (open_file->pfile &&
987 ((open_file->pfile->f_flags & O_RDWR) ||
988 (open_file->pfile->f_flags & O_WRONLY))) {
23e7dd7d 989 atomic_inc(&open_file->wrtPending);
6148a742 990 read_unlock(&GlobalSMBSeslock);
0ae0efad 991 if((open_file->invalidHandle) &&
23e7dd7d 992 (!open_file->closePend) /* BB fixme -since the second clause can not be true remove it BB */) {
dd99cd80 993 rc = cifs_reopen_file(&cifs_inode->vfs_inode,
37c0eb46
SF		 994 open_file->pfile, FALSE);
995 /* if it fails, try another handle - might be */
996 /* dangerous to hold up writepages with retry */
997 if(rc) {
4a77118c 998 cFYI(1,("failed on reopen file in wp"));
37c0eb46 999 read_lock(&GlobalSMBSeslock);
23e7dd7d
SF		 1000 /* can not use this handle, no write
1001 pending on this one after all */
1002 atomic_dec
1003 (&open_file->wrtPending);
37c0eb46
SF		 1004 continue;
1005 }
1006 }
6148a742
SF		 1007 return open_file;
1008 }
1009 }
1010 read_unlock(&GlobalSMBSeslock);
1011 return NULL;
1012}
1013
1da177e4
LT		 1014static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1015{
1016 struct address_space *mapping = page->mapping;
1017 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1018 char *write_data;
1019 int rc = -EFAULT;
1020 int bytes_written = 0;
1021 struct cifs_sb_info *cifs_sb;
1022 struct cifsTconInfo *pTcon;
1023 struct inode *inode;
6148a742 1024 struct cifsFileInfo *open_file;
1da177e4
LT		 1025
1026 if (!mapping || !mapping->host)
1027 return -EFAULT;
1028
1029 inode = page->mapping->host;
1030 cifs_sb = CIFS_SB(inode->i_sb);
1031 pTcon = cifs_sb->tcon;
1032
1033 offset += (loff_t)from;
1034 write_data = kmap(page);
1035 write_data += from;
1036
1037 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1038 kunmap(page);
1039 return -EIO;
1040 }
1041
1042 /* racing with truncate? */
1043 if (offset > mapping->host->i_size) {
1044 kunmap(page);
1045 return 0; /* don't care */
1046 }
1047
1048 /* check to make sure that we are not extending the file */
1049 if (mapping->host->i_size - offset < (loff_t)to)
1050 to = (unsigned)(mapping->host->i_size - offset);
1051
6148a742
SF		 1052 open_file = find_writable_file(CIFS_I(mapping->host));
1053 if (open_file) {
1054 bytes_written = cifs_write(open_file->pfile, write_data,
1055 to-from, &offset);
23e7dd7d 1056 atomic_dec(&open_file->wrtPending);
1da177e4 1057 /* Does mm or vfs already set times? */
6148a742
SF		 1058 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1059 if ((bytes_written > 0) && (offset)) {
1060 rc = 0;
1061 } else if (bytes_written < 0) {
1062 if (rc != -EBADF)
1063 rc = bytes_written;
1da177e4 1064 }
6148a742 1065 } else {
1da177e4
LT		 1066 cFYI(1, ("No writeable filehandles for inode"));
1067 rc = -EIO;
1068 }
1069
1070 kunmap(page);
1071 return rc;
1072}
1073
1da177e4 1074static int cifs_writepages(struct address_space *mapping,
37c0eb46 1075 struct writeback_control *wbc)
1da177e4 1076{
37c0eb46
SF		 1077 struct backing_dev_info *bdi = mapping->backing_dev_info;
1078 unsigned int bytes_to_write;
1079 unsigned int bytes_written;
1080 struct cifs_sb_info *cifs_sb;
1081 int done = 0;
1082 pgoff_t end = -1;
1083 pgoff_t index;
1084 int is_range = 0;
1085 struct kvec iov[32];
84d2f07e 1086 int len;
37c0eb46
SF		 1087 int n_iov = 0;
1088 pgoff_t next;
1089 int nr_pages;
1090 __u64 offset = 0;
23e7dd7d 1091 struct cifsFileInfo *open_file;
37c0eb46
SF		 1092 struct page *page;
1093 struct pagevec pvec;
1094 int rc = 0;
1095 int scanned = 0;
1da177e4
LT		 1096 int xid;
1097
37c0eb46
SF		 1098 cifs_sb = CIFS_SB(mapping->host->i_sb);
1099
1100 /*
1101 * If wsize is smaller that the page cache size, default to writing
1102 * one page at a time via cifs_writepage
1103 */
1104 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1105 return generic_writepages(mapping, wbc);
1106
4a77118c
SF		 1107 if((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1108 if(cifs_sb->tcon->ses->server->secMode &
1109 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
60808233
SF		 1110 if(!experimEnabled)
1111 return generic_writepages(mapping, wbc);
4a77118c 1112
37c0eb46
SF		 1113 /*
1114 * BB: Is this meaningful for a non-block-device file system?
1115 * If it is, we should test it again after we do I/O
1116 */
1117 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1118 wbc->encountered_congestion = 1;
1119 return 0;
1120 }
1121
1da177e4
LT		 1122 xid = GetXid();
1123
37c0eb46
SF		 1124 pagevec_init(&pvec, 0);
1125 if (wbc->sync_mode == WB_SYNC_NONE)
1126 index = mapping->writeback_index; /* Start from prev offset */
1127 else {
1128 index = 0;
1129 scanned = 1;
1130 }
1131 if (wbc->start || wbc->end) {
1132 index = wbc->start >> PAGE_CACHE_SHIFT;
1133 end = wbc->end >> PAGE_CACHE_SHIFT;
1134 is_range = 1;
1135 scanned = 1;
1136 }
1137retry:
1138 while (!done && (index <= end) &&
1139 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1140 PAGECACHE_TAG_DIRTY,
1141 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1142 int first;
1143 unsigned int i;
1144
37c0eb46
SF		 1145 first = -1;
1146 next = 0;
1147 n_iov = 0;
1148 bytes_to_write = 0;
1149
1150 for (i = 0; i < nr_pages; i++) {
1151 page = pvec.pages[i];
1152 /*
1153 * At this point we hold neither mapping->tree_lock nor
1154 * lock on the page itself: the page may be truncated or
1155 * invalidated (changing page->mapping to NULL), or even
1156 * swizzled back from swapper_space to tmpfs file
1157 * mapping
1158 */
1159
1160 if (first < 0)
1161 lock_page(page);
1162 else if (TestSetPageLocked(page))
1163 break;
1164
1165 if (unlikely(page->mapping != mapping)) {
1166 unlock_page(page);
1167 break;
1168 }
1169
1170 if (unlikely(is_range) && (page->index > end)) {
1171 done = 1;
1172 unlock_page(page);
1173 break;
1174 }
1175
1176 if (next && (page->index != next)) {
1177 /* Not next consecutive page */
1178 unlock_page(page);
1179 break;
1180 }
1181
1182 if (wbc->sync_mode != WB_SYNC_NONE)
1183 wait_on_page_writeback(page);
1184
1185 if (PageWriteback(page) ||
1186 !test_clear_page_dirty(page)) {
1187 unlock_page(page);
1188 break;
1189 }
84d2f07e
SF		 1190
1191 if (page_offset(page) >= mapping->host->i_size) {
1192 done = 1;
1193 unlock_page(page);
1194 break;
1195 }
1196
37c0eb46
SF		 1197 /*
1198 * BB can we get rid of this? pages are held by pvec
1199 */
1200 page_cache_get(page);
1201
84d2f07e
SF		 1202 len = min(mapping->host->i_size - page_offset(page),
1203 (loff_t)PAGE_CACHE_SIZE);
1204
37c0eb46
SF		 1205 /* reserve iov[0] for the smb header */
1206 n_iov++;
1207 iov[n_iov].iov_base = kmap(page);
84d2f07e
SF		 1208 iov[n_iov].iov_len = len;
1209 bytes_to_write += len;
37c0eb46
SF		 1210
1211 if (first < 0) {
1212 first = i;
1213 offset = page_offset(page);
1214 }
1215 next = page->index + 1;
1216 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1217 break;
1218 }
1219 if (n_iov) {
23e7dd7d
SF		 1220 /* Search for a writable handle every time we call
1221 * CIFSSMBWrite2. We can't rely on the last handle
1222 * we used to still be valid
1223 */
1224 open_file = find_writable_file(CIFS_I(mapping->host));
1225 if (!open_file) {
1226 cERROR(1, ("No writable handles for inode"));
1227 rc = -EBADF;
1047abc1 1228 } else {
23e7dd7d
SF		 1229 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1230 open_file->netfid,
1231 bytes_to_write, offset,
1232 &bytes_written, iov, n_iov,
1233 1);
1234 atomic_dec(&open_file->wrtPending);
1235 if (rc || bytes_written < bytes_to_write) {
1236 cERROR(1,("Write2 ret %d, written = %d",
1237 rc, bytes_written));
1238 /* BB what if continued retry is
1239 requested via mount flags? */
1240 set_bit(AS_EIO, &mapping->flags);
23e7dd7d
SF		 1241 } else {
1242 cifs_stats_bytes_written(cifs_sb->tcon,
1243 bytes_written);
1244 }
37c0eb46
SF		 1245 }
1246 for (i = 0; i < n_iov; i++) {
1247 page = pvec.pages[first + i];
eb9bdaa3
SF		 1248 /* Should we also set page error on
1249 success rc but too little data written? */
1250 /* BB investigate retry logic on temporary
1251 server crash cases and how recovery works
1252 when page marked as error */
1253 if(rc)
1254 SetPageError(page);
37c0eb46
SF		 1255 kunmap(page);
1256 unlock_page(page);
1257 page_cache_release(page);
1258 }
1259 if ((wbc->nr_to_write -= n_iov) <= 0)
1260 done = 1;
1261 index = next;
1262 }
1263 pagevec_release(&pvec);
1264 }
1265 if (!scanned && !done) {
1266 /*
1267 * We hit the last page and there is more work to be done: wrap
1268 * back to the start of the file
1269 */
1270 scanned = 1;
1271 index = 0;
1272 goto retry;
1273 }
1274 if (!is_range)
1275 mapping->writeback_index = index;
1276
1da177e4 1277 FreeXid(xid);
37c0eb46 1278
1da177e4
LT		 1279 return rc;
1280}
1da177e4
LT		 1281
1282static int cifs_writepage(struct page* page, struct writeback_control *wbc)
1283{
1284 int rc = -EFAULT;
1285 int xid;
1286
1287 xid = GetXid();
1288/* BB add check for wbc flags */
1289 page_cache_get(page);
1290 if (!PageUptodate(page)) {
1291 cFYI(1, ("ppw - page not up to date"));
1292 }
1293
1294 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1295 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1296 unlock_page(page);
1297 page_cache_release(page);
1298 FreeXid(xid);
1299 return rc;
1300}
1301
1302static int cifs_commit_write(struct file *file, struct page *page,
1303 unsigned offset, unsigned to)
1304{
1305 int xid;
1306 int rc = 0;
1307 struct inode *inode = page->mapping->host;
1308 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1309 char *page_data;
1310
1311 xid = GetXid();
1312 cFYI(1, ("commit write for page %p up to position %lld for %d",
1313 page, position, to));
1314 if (position > inode->i_size) {
1315 i_size_write(inode, position);
1316 /* if (file->private_data == NULL) {
1317 rc = -EBADF;
1318 } else {
1319 open_file = (struct cifsFileInfo *)file->private_data;
1320 cifs_sb = CIFS_SB(inode->i_sb);
1321 rc = -EAGAIN;
1322 while (rc == -EAGAIN) {
1323 if ((open_file->invalidHandle) &&
1324 (!open_file->closePend)) {
1325 rc = cifs_reopen_file(
1326 file->f_dentry->d_inode, file);
1327 if (rc != 0)
1328 break;
1329 }
1330 if (!open_file->closePend) {
1331 rc = CIFSSMBSetFileSize(xid,
1332 cifs_sb->tcon, position,
1333 open_file->netfid,
1334 open_file->pid, FALSE);
1335 } else {
1336 rc = -EBADF;
1337 break;
1338 }
1339 }
1340 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1341 } */
1342 }
1343 if (!PageUptodate(page)) {
1344 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1345 /* can not rely on (or let) writepage write this data */
1346 if (to < offset) {
1347 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1348 offset, to));
1349 FreeXid(xid);
1350 return rc;
1351 }
1352 /* this is probably better than directly calling
1353 partialpage_write since in this function the file handle is
1354 known which we might as well leverage */
1355 /* BB check if anything else missing out of ppw
1356 such as updating last write time */
1357 page_data = kmap(page);
1358 rc = cifs_write(file, page_data + offset, to-offset,
1359 &position);
1360 if (rc > 0)
1361 rc = 0;
1362 /* else if (rc < 0) should we set writebehind rc? */
1363 kunmap(page);
1364 } else {
1365 set_page_dirty(page);
1366 }
1367
1368 FreeXid(xid);
1369 return rc;
1370}
1371
1372int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1373{
1374 int xid;
1375 int rc = 0;
1376 struct inode *inode = file->f_dentry->d_inode;
1377
1378 xid = GetXid();
1379
1380 cFYI(1, ("Sync file - name: %s datasync: 0x%x ",
1381 dentry->d_name.name, datasync));
1382
1383 rc = filemap_fdatawrite(inode->i_mapping);
1384 if (rc == 0)
1385 CIFS_I(inode)->write_behind_rc = 0;
1386 FreeXid(xid);
1387 return rc;
1388}
1389
3978d717 1390/* static void cifs_sync_page(struct page *page)
1da177e4
LT		 1391{
1392 struct address_space *mapping;
1393 struct inode *inode;
1394 unsigned long index = page->index;
1395 unsigned int rpages = 0;
1396 int rc = 0;
1397
1398 cFYI(1, ("sync page %p",page));
1399 mapping = page->mapping;
1400 if (!mapping)
1401 return 0;
1402 inode = mapping->host;
1403 if (!inode)
3978d717 1404 return; */
1da177e4
LT		 1405
1406/* fill in rpages then
1407 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1408
1409/* cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
1410
3978d717 1411#if 0
1da177e4
LT		 1412 if (rc < 0)
1413 return rc;
1414 return 0;
3978d717 1415#endif
1da177e4
LT		 1416} */
1417
1418/*
1419 * As file closes, flush all cached write data for this inode checking
1420 * for write behind errors.
1421 */
1422int cifs_flush(struct file *file)
1423{
1424 struct inode * inode = file->f_dentry->d_inode;
1425 int rc = 0;
1426
1427 /* Rather than do the steps manually:
1428 lock the inode for writing
1429 loop through pages looking for write behind data (dirty pages)
1430 coalesce into contiguous 16K (or smaller) chunks to write to server
1431 send to server (prefer in parallel)
1432 deal with writebehind errors
1433 unlock inode for writing
1434 filemapfdatawrite appears easier for the time being */
1435
1436 rc = filemap_fdatawrite(inode->i_mapping);
1437 if (!rc) /* reset wb rc if we were able to write out dirty pages */
1438 CIFS_I(inode)->write_behind_rc = 0;
1439
1440 cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
1441
1442 return rc;
1443}
1444
1445ssize_t cifs_user_read(struct file *file, char __user *read_data,
1446 size_t read_size, loff_t *poffset)
1447{
1448 int rc = -EACCES;
1449 unsigned int bytes_read = 0;
1450 unsigned int total_read = 0;
1451 unsigned int current_read_size;
1452 struct cifs_sb_info *cifs_sb;
1453 struct cifsTconInfo *pTcon;
1454 int xid;
1455 struct cifsFileInfo *open_file;
1456 char *smb_read_data;
1457 char __user *current_offset;
1458 struct smb_com_read_rsp *pSMBr;
1459
1460 xid = GetXid();
1461 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1462 pTcon = cifs_sb->tcon;
1463
1464 if (file->private_data == NULL) {
1465 FreeXid(xid);
1466 return -EBADF;
1467 }
1468 open_file = (struct cifsFileInfo *)file->private_data;
1469
1470 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1471 cFYI(1, ("attempting read on write only file instance"));
1472 }
1473 for (total_read = 0, current_offset = read_data;
1474 read_size > total_read;
1475 total_read += bytes_read, current_offset += bytes_read) {
1476 current_read_size = min_t(const int, read_size - total_read,
1477 cifs_sb->rsize);
1478 rc = -EAGAIN;
1479 smb_read_data = NULL;
1480 while (rc == -EAGAIN) {
ec637e3f 1481 int buf_type = CIFS_NO_BUFFER;
1da177e4
LT		 1482 if ((open_file->invalidHandle) &&
1483 (!open_file->closePend)) {
1484 rc = cifs_reopen_file(file->f_dentry->d_inode,
1485 file, TRUE);
1486 if (rc != 0)
1487 break;
1488 }
bfa0d75a 1489 rc = CIFSSMBRead(xid, pTcon,
ec637e3f
SF		 1490 open_file->netfid,
1491 current_read_size, *poffset,
1492 &bytes_read, &smb_read_data,
1493 &buf_type);
1da177e4 1494 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1da177e4 1495 if (smb_read_data) {
93544cc6
SF		 1496 if (copy_to_user(current_offset,
1497 smb_read_data +
1498 4 /* RFC1001 length field */ +
1499 le16_to_cpu(pSMBr->DataOffset),
1500 bytes_read)) {
1501 rc = -EFAULT;
1502 }
1503
ec637e3f
SF		 1504 if(buf_type == CIFS_SMALL_BUFFER)
1505 cifs_small_buf_release(smb_read_data);
1506 else if(buf_type == CIFS_LARGE_BUFFER)
1507 cifs_buf_release(smb_read_data);
1da177e4
LT		 1508 smb_read_data = NULL;
1509 }
1510 }
1511 if (rc || (bytes_read == 0)) {
1512 if (total_read) {
1513 break;
1514 } else {
1515 FreeXid(xid);
1516 return rc;
1517 }
1518 } else {
a4544347 1519 cifs_stats_bytes_read(pTcon, bytes_read);
1da177e4
LT		 1520 *poffset += bytes_read;
1521 }
1522 }
1523 FreeXid(xid);
1524 return total_read;
1525}
1526
1527
1528static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1529 loff_t *poffset)
1530{
1531 int rc = -EACCES;
1532 unsigned int bytes_read = 0;
1533 unsigned int total_read;
1534 unsigned int current_read_size;
1535 struct cifs_sb_info *cifs_sb;
1536 struct cifsTconInfo *pTcon;
1537 int xid;
1538 char *current_offset;
1539 struct cifsFileInfo *open_file;
ec637e3f 1540 int buf_type = CIFS_NO_BUFFER;
1da177e4
LT		 1541
1542 xid = GetXid();
1543 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1544 pTcon = cifs_sb->tcon;
1545
1546 if (file->private_data == NULL) {
1547 FreeXid(xid);
1548 return -EBADF;
1549 }
1550 open_file = (struct cifsFileInfo *)file->private_data;
1551
1552 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1553 cFYI(1, ("attempting read on write only file instance"));
1554
1555 for (total_read = 0, current_offset = read_data;
1556 read_size > total_read;
1557 total_read += bytes_read, current_offset += bytes_read) {
1558 current_read_size = min_t(const int, read_size - total_read,
1559 cifs_sb->rsize);
f9f5c817
SF		 1560 /* For windows me and 9x we do not want to request more
1561 than it negotiated since it will refuse the read then */
1562 if((pTcon->ses) &&
1563 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1564 current_read_size = min_t(const int, current_read_size,
1565 pTcon->ses->server->maxBuf - 128);
1566 }
1da177e4
LT		 1567 rc = -EAGAIN;
1568 while (rc == -EAGAIN) {
1569 if ((open_file->invalidHandle) &&
1570 (!open_file->closePend)) {
1571 rc = cifs_reopen_file(file->f_dentry->d_inode,
1572 file, TRUE);
1573 if (rc != 0)
1574 break;
1575 }
bfa0d75a 1576 rc = CIFSSMBRead(xid, pTcon,
ec637e3f
SF		 1577 open_file->netfid,
1578 current_read_size, *poffset,
1579 &bytes_read, &current_offset,
1580 &buf_type);
1da177e4
LT		 1581 }
1582 if (rc || (bytes_read == 0)) {
1583 if (total_read) {
1584 break;
1585 } else {
1586 FreeXid(xid);
1587 return rc;
1588 }
1589 } else {
a4544347 1590 cifs_stats_bytes_read(pTcon, total_read);
1da177e4
LT		 1591 *poffset += bytes_read;
1592 }
1593 }
1594 FreeXid(xid);
1595 return total_read;
1596}
1597
1598int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1599{
1600 struct dentry *dentry = file->f_dentry;
1601 int rc, xid;
1602
1603 xid = GetXid();
1604 rc = cifs_revalidate(dentry);
1605 if (rc) {
1606 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1607 FreeXid(xid);
1608 return rc;
1609 }
1610 rc = generic_file_mmap(file, vma);
1611 FreeXid(xid);
1612 return rc;
1613}
1614
1615
1616static void cifs_copy_cache_pages(struct address_space *mapping,
1617 struct list_head *pages, int bytes_read, char *data,
1618 struct pagevec *plru_pvec)
1619{
1620 struct page *page;
1621 char *target;
1622
1623 while (bytes_read > 0) {
1624 if (list_empty(pages))
1625 break;
1626
1627 page = list_entry(pages->prev, struct page, lru);
1628 list_del(&page->lru);
1629
1630 if (add_to_page_cache(page, mapping, page->index,
1631 GFP_KERNEL)) {
1632 page_cache_release(page);
1633 cFYI(1, ("Add page cache failed"));
3079ca62
SF		 1634 data += PAGE_CACHE_SIZE;
1635 bytes_read -= PAGE_CACHE_SIZE;
1da177e4
LT		 1636 continue;
1637 }
1638
1639 target = kmap_atomic(page,KM_USER0);
1640
1641 if (PAGE_CACHE_SIZE > bytes_read) {
1642 memcpy(target, data, bytes_read);
1643 /* zero the tail end of this partial page */
1644 memset(target + bytes_read, 0,
1645 PAGE_CACHE_SIZE - bytes_read);
1646 bytes_read = 0;
1647 } else {
1648 memcpy(target, data, PAGE_CACHE_SIZE);
1649 bytes_read -= PAGE_CACHE_SIZE;
1650 }
1651 kunmap_atomic(target, KM_USER0);
1652
1653 flush_dcache_page(page);
1654 SetPageUptodate(page);
1655 unlock_page(page);
1656 if (!pagevec_add(plru_pvec, page))
1657 __pagevec_lru_add(plru_pvec);
1658 data += PAGE_CACHE_SIZE;
1659 }
1660 return;
1661}
1662
1663static int cifs_readpages(struct file *file, struct address_space *mapping,
1664 struct list_head *page_list, unsigned num_pages)
1665{
1666 int rc = -EACCES;
1667 int xid;
1668 loff_t offset;
1669 struct page *page;
1670 struct cifs_sb_info *cifs_sb;
1671 struct cifsTconInfo *pTcon;
1672 int bytes_read = 0;
1673 unsigned int read_size,i;
1674 char *smb_read_data = NULL;
1675 struct smb_com_read_rsp *pSMBr;
1676 struct pagevec lru_pvec;
1677 struct cifsFileInfo *open_file;
ec637e3f 1678 int buf_type = CIFS_NO_BUFFER;
1da177e4
LT		 1679
1680 xid = GetXid();
1681 if (file->private_data == NULL) {
1682 FreeXid(xid);
1683 return -EBADF;
1684 }
1685 open_file = (struct cifsFileInfo *)file->private_data;
1686 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1687 pTcon = cifs_sb->tcon;
bfa0d75a 1688
1da177e4
LT		 1689 pagevec_init(&lru_pvec, 0);
1690
1691 for (i = 0; i < num_pages; ) {
1692 unsigned contig_pages;
1693 struct page *tmp_page;
1694 unsigned long expected_index;
1695
1696 if (list_empty(page_list))
1697 break;
1698
1699 page = list_entry(page_list->prev, struct page, lru);
1700 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1701
1702 /* count adjacent pages that we will read into */
1703 contig_pages = 0;
1704 expected_index =
1705 list_entry(page_list->prev, struct page, lru)->index;
1706 list_for_each_entry_reverse(tmp_page,page_list,lru) {
1707 if (tmp_page->index == expected_index) {
1708 contig_pages++;
1709 expected_index++;
1710 } else
1711 break;
1712 }
1713 if (contig_pages + i > num_pages)
1714 contig_pages = num_pages - i;
1715
1716 /* for reads over a certain size could initiate async
1717 read ahead */
1718
1719 read_size = contig_pages * PAGE_CACHE_SIZE;
1720 /* Read size needs to be in multiples of one page */
1721 read_size = min_t(const unsigned int, read_size,
1722 cifs_sb->rsize & PAGE_CACHE_MASK);
1723
1724 rc = -EAGAIN;
1725 while (rc == -EAGAIN) {
1726 if ((open_file->invalidHandle) &&
1727 (!open_file->closePend)) {
1728 rc = cifs_reopen_file(file->f_dentry->d_inode,
1729 file, TRUE);
1730 if (rc != 0)
1731 break;
1732 }
1733
bfa0d75a 1734 rc = CIFSSMBRead(xid, pTcon,
ec637e3f
SF		 1735 open_file->netfid,
1736 read_size, offset,
1737 &bytes_read, &smb_read_data,
1738 &buf_type);
a9d02ad4 1739 /* BB more RC checks ? */
1da177e4
LT		 1740 if (rc== -EAGAIN) {
1741 if (smb_read_data) {
ec637e3f
SF		 1742 if(buf_type == CIFS_SMALL_BUFFER)
1743 cifs_small_buf_release(smb_read_data);
1744 else if(buf_type == CIFS_LARGE_BUFFER)
1745 cifs_buf_release(smb_read_data);
1da177e4
LT		 1746 smb_read_data = NULL;
1747 }
1748 }
1749 }
1750 if ((rc < 0) || (smb_read_data == NULL)) {
1751 cFYI(1, ("Read error in readpages: %d", rc));
1752 /* clean up remaing pages off list */
1753 while (!list_empty(page_list) && (i < num_pages)) {
1754 page = list_entry(page_list->prev, struct page,
1755 lru);
1756 list_del(&page->lru);
1757 page_cache_release(page);
1758 }
1759 break;
1760 } else if (bytes_read > 0) {
1761 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1762 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1763 smb_read_data + 4 /* RFC1001 hdr */ +
1764 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1765
1766 i += bytes_read >> PAGE_CACHE_SHIFT;
a4544347 1767 cifs_stats_bytes_read(pTcon, bytes_read);
1da177e4
LT		 1768 if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1769 i++; /* account for partial page */
1770
1771 /* server copy of file can have smaller size
1772 than client */
1773 /* BB do we need to verify this common case ?
1774 this case is ok - if we are at server EOF
1775 we will hit it on next read */
1776
1777 /* while (!list_empty(page_list) && (i < num_pages)) {
1778 page = list_entry(page_list->prev,
1779 struct page, list);
1780 list_del(&page->list);
1781 page_cache_release(page);
1782 }
1783 break; */
1784 }
1785 } else {
1786 cFYI(1, ("No bytes read (%d) at offset %lld . "
1787 "Cleaning remaining pages from readahead list",
1788 bytes_read, offset));
1789 /* BB turn off caching and do new lookup on
1790 file size at server? */
1791 while (!list_empty(page_list) && (i < num_pages)) {
1792 page = list_entry(page_list->prev, struct page,
1793 lru);
1794 list_del(&page->lru);
1795
1796 /* BB removeme - replace with zero of page? */
1797 page_cache_release(page);
1798 }
1799 break;
1800 }
1801 if (smb_read_data) {
ec637e3f
SF		 1802 if(buf_type == CIFS_SMALL_BUFFER)
1803 cifs_small_buf_release(smb_read_data);
1804 else if(buf_type == CIFS_LARGE_BUFFER)
1805 cifs_buf_release(smb_read_data);
1da177e4
LT		 1806 smb_read_data = NULL;
1807 }
1808 bytes_read = 0;
1809 }
1810
1811 pagevec_lru_add(&lru_pvec);
1812
1813/* need to free smb_read_data buf before exit */
1814 if (smb_read_data) {
47c886b3
SF		 1815 if(buf_type == CIFS_SMALL_BUFFER)
1816 cifs_small_buf_release(smb_read_data);
1817 else if(buf_type == CIFS_LARGE_BUFFER)
1818 cifs_buf_release(smb_read_data);
1da177e4
LT		 1819 smb_read_data = NULL;
1820 }
1821
1822 FreeXid(xid);
1823 return rc;
1824}
1825
1826static int cifs_readpage_worker(struct file *file, struct page *page,
1827 loff_t *poffset)
1828{
1829 char *read_data;
1830 int rc;
1831
1832 page_cache_get(page);
1833 read_data = kmap(page);
1834 /* for reads over a certain size could initiate async read ahead */
1835
1836 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1837
1838 if (rc < 0)
1839 goto io_error;
1840 else
1841 cFYI(1, ("Bytes read %d ",rc));
1842
1843 file->f_dentry->d_inode->i_atime =
1844 current_fs_time(file->f_dentry->d_inode->i_sb);
1845
1846 if (PAGE_CACHE_SIZE > rc)
1847 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1848
1849 flush_dcache_page(page);
1850 SetPageUptodate(page);
1851 rc = 0;
1852
1853io_error:
1854 kunmap(page);
1855 page_cache_release(page);
1856 return rc;
1857}
1858
1859static int cifs_readpage(struct file *file, struct page *page)
1860{
1861 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1862 int rc = -EACCES;
1863 int xid;
1864
1865 xid = GetXid();
1866
1867 if (file->private_data == NULL) {
1868 FreeXid(xid);
1869 return -EBADF;
1870 }
1871
1872 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1873 page, (int)offset, (int)offset));
1874
1875 rc = cifs_readpage_worker(file, page, &offset);
1876
1877 unlock_page(page);
1878
1879 FreeXid(xid);
1880 return rc;
1881}
1882
1883/* We do not want to update the file size from server for inodes
1884 open for write - to avoid races with writepage extending
1885 the file - in the future we could consider allowing
1886 refreshing the inode only on increases in the file size
1887 but this is tricky to do without racing with writebehind
1888 page caching in the current Linux kernel design */
1889int is_size_safe_to_change(struct cifsInodeInfo *cifsInode)
1890{
23e7dd7d
SF		 1891 struct cifsFileInfo *open_file = NULL;
1892
1893 if (cifsInode)
1894 open_file = find_writable_file(cifsInode);
1895
1896 if(open_file) {
c32a0b68
SF		 1897 struct cifs_sb_info *cifs_sb;
1898
23e7dd7d
SF		 1899 /* there is not actually a write pending so let
1900 this handle go free and allow it to
1901 be closable if needed */
1902 atomic_dec(&open_file->wrtPending);
c32a0b68
SF		 1903
1904 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
1905 if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
1906 /* since no page cache to corrupt on directio
1907 we can change size safely */
1908 return 1;
1909 }
1910
6148a742 1911 return 0;
23e7dd7d 1912 } else
6148a742 1913 return 1;
1da177e4
LT		 1914}
1915
1da177e4
LT		 1916static int cifs_prepare_write(struct file *file, struct page *page,
1917 unsigned from, unsigned to)
1918{
1919 int rc = 0;
1920 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1921 cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
1922 if (!PageUptodate(page)) {
1923 /* if (to - from != PAGE_CACHE_SIZE) {
1924 void *kaddr = kmap_atomic(page, KM_USER0);
1925 memset(kaddr, 0, from);
1926 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
1927 flush_dcache_page(page);
1928 kunmap_atomic(kaddr, KM_USER0);
1929 } */
1930 /* If we are writing a full page it will be up to date,
1931 no need to read from the server */
1932 if ((to == PAGE_CACHE_SIZE) && (from == 0))
1933 SetPageUptodate(page);
1934
1935 /* might as well read a page, it is fast enough */
1936 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
1937 rc = cifs_readpage_worker(file, page, &offset);
1938 } else {
1939 /* should we try using another file handle if there is one -
1940 how would we lock it to prevent close of that handle
1941 racing with this read?
1942 In any case this will be written out by commit_write */
1943 }
1944 }
1945
1946 /* BB should we pass any errors back?
1947 e.g. if we do not have read access to the file */
1948 return 0;
1949}
1950
1951struct address_space_operations cifs_addr_ops = {
1952 .readpage = cifs_readpage,
1953 .readpages = cifs_readpages,
1954 .writepage = cifs_writepage,
37c0eb46 1955 .writepages = cifs_writepages,
1da177e4
LT		 1956 .prepare_write = cifs_prepare_write,
1957 .commit_write = cifs_commit_write,
1958 .set_page_dirty = __set_page_dirty_nobuffers,
1959 /* .sync_page = cifs_sync_page, */
1960 /* .direct_IO = */
1961};
Clone of davem's net-next-2.6 tree