projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[PATCH] locks: clean up locks_remove_posix()
[deliverable/linux.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;
111ebb6e 1082 pgoff_t end;
37c0eb46 1083 pgoff_t index;
111ebb6e 1084 int range_whole = 0;
37c0eb46 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 1124 pagevec_init(&pvec, 0);
111ebb6e 1125 if (wbc->range_cyclic) {
37c0eb46 1126 index = mapping->writeback_index; /* Start from prev offset */
111ebb6e
OH		 1127 end = -1;
1128 } else {
1129 index = wbc->range_start >> PAGE_CACHE_SHIFT;
1130 end = wbc->range_end >> PAGE_CACHE_SHIFT;
1131 if (wbc->range_start == 0 && wbc->range_end == LLONG_MAX)
1132 range_whole = 1;
37c0eb46
SF		 1133 scanned = 1;
1134 }
1135retry:
1136 while (!done && (index <= end) &&
1137 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1138 PAGECACHE_TAG_DIRTY,
1139 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1140 int first;
1141 unsigned int i;
1142
37c0eb46
SF		 1143 first = -1;
1144 next = 0;
1145 n_iov = 0;
1146 bytes_to_write = 0;
1147
1148 for (i = 0; i < nr_pages; i++) {
1149 page = pvec.pages[i];
1150 /*
1151 * At this point we hold neither mapping->tree_lock nor
1152 * lock on the page itself: the page may be truncated or
1153 * invalidated (changing page->mapping to NULL), or even
1154 * swizzled back from swapper_space to tmpfs file
1155 * mapping
1156 */
1157
1158 if (first < 0)
1159 lock_page(page);
1160 else if (TestSetPageLocked(page))
1161 break;
1162
1163 if (unlikely(page->mapping != mapping)) {
1164 unlock_page(page);
1165 break;
1166 }
1167
111ebb6e 1168 if (!wbc->range_cyclic && page->index > end) {
37c0eb46
SF		 1169 done = 1;
1170 unlock_page(page);
1171 break;
1172 }
1173
1174 if (next && (page->index != next)) {
1175 /* Not next consecutive page */
1176 unlock_page(page);
1177 break;
1178 }
1179
1180 if (wbc->sync_mode != WB_SYNC_NONE)
1181 wait_on_page_writeback(page);
1182
1183 if (PageWriteback(page) ||
1184 !test_clear_page_dirty(page)) {
1185 unlock_page(page);
1186 break;
1187 }
84d2f07e
SF		 1188
1189 if (page_offset(page) >= mapping->host->i_size) {
1190 done = 1;
1191 unlock_page(page);
1192 break;
1193 }
1194
37c0eb46
SF		 1195 /*
1196 * BB can we get rid of this? pages are held by pvec
1197 */
1198 page_cache_get(page);
1199
84d2f07e
SF		 1200 len = min(mapping->host->i_size - page_offset(page),
1201 (loff_t)PAGE_CACHE_SIZE);
1202
37c0eb46
SF		 1203 /* reserve iov[0] for the smb header */
1204 n_iov++;
1205 iov[n_iov].iov_base = kmap(page);
84d2f07e
SF		 1206 iov[n_iov].iov_len = len;
1207 bytes_to_write += len;
37c0eb46
SF		 1208
1209 if (first < 0) {
1210 first = i;
1211 offset = page_offset(page);
1212 }
1213 next = page->index + 1;
1214 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1215 break;
1216 }
1217 if (n_iov) {
23e7dd7d
SF		 1218 /* Search for a writable handle every time we call
1219 * CIFSSMBWrite2. We can't rely on the last handle
1220 * we used to still be valid
1221 */
1222 open_file = find_writable_file(CIFS_I(mapping->host));
1223 if (!open_file) {
1224 cERROR(1, ("No writable handles for inode"));
1225 rc = -EBADF;
1047abc1 1226 } else {
23e7dd7d
SF		 1227 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1228 open_file->netfid,
1229 bytes_to_write, offset,
1230 &bytes_written, iov, n_iov,
1231 1);
1232 atomic_dec(&open_file->wrtPending);
1233 if (rc || bytes_written < bytes_to_write) {
1234 cERROR(1,("Write2 ret %d, written = %d",
1235 rc, bytes_written));
1236 /* BB what if continued retry is
1237 requested via mount flags? */
1238 set_bit(AS_EIO, &mapping->flags);
23e7dd7d
SF		 1239 } else {
1240 cifs_stats_bytes_written(cifs_sb->tcon,
1241 bytes_written);
1242 }
37c0eb46
SF		 1243 }
1244 for (i = 0; i < n_iov; i++) {
1245 page = pvec.pages[first + i];
eb9bdaa3
SF		 1246 /* Should we also set page error on
1247 success rc but too little data written? */
1248 /* BB investigate retry logic on temporary
1249 server crash cases and how recovery works
1250 when page marked as error */
1251 if(rc)
1252 SetPageError(page);
37c0eb46
SF		 1253 kunmap(page);
1254 unlock_page(page);
1255 page_cache_release(page);
1256 }
1257 if ((wbc->nr_to_write -= n_iov) <= 0)
1258 done = 1;
1259 index = next;
1260 }
1261 pagevec_release(&pvec);
1262 }
1263 if (!scanned && !done) {
1264 /*
1265 * We hit the last page and there is more work to be done: wrap
1266 * back to the start of the file
1267 */
1268 scanned = 1;
1269 index = 0;
1270 goto retry;
1271 }
111ebb6e 1272 if (wbc->range_cyclic || (range_whole && wbc->nr_to_write > 0))
37c0eb46
SF		 1273 mapping->writeback_index = index;
1274
1da177e4 1275 FreeXid(xid);
37c0eb46 1276
1da177e4
LT		 1277 return rc;
1278}
1da177e4
LT		 1279
1280static int cifs_writepage(struct page* page, struct writeback_control *wbc)
1281{
1282 int rc = -EFAULT;
1283 int xid;
1284
1285 xid = GetXid();
1286/* BB add check for wbc flags */
1287 page_cache_get(page);
1288 if (!PageUptodate(page)) {
1289 cFYI(1, ("ppw - page not up to date"));
1290 }
1291
1292 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1293 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1294 unlock_page(page);
1295 page_cache_release(page);
1296 FreeXid(xid);
1297 return rc;
1298}
1299
1300static int cifs_commit_write(struct file *file, struct page *page,
1301 unsigned offset, unsigned to)
1302{
1303 int xid;
1304 int rc = 0;
1305 struct inode *inode = page->mapping->host;
1306 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1307 char *page_data;
1308
1309 xid = GetXid();
1310 cFYI(1, ("commit write for page %p up to position %lld for %d",
1311 page, position, to));
1312 if (position > inode->i_size) {
1313 i_size_write(inode, position);
1314 /* if (file->private_data == NULL) {
1315 rc = -EBADF;
1316 } else {
1317 open_file = (struct cifsFileInfo *)file->private_data;
1318 cifs_sb = CIFS_SB(inode->i_sb);
1319 rc = -EAGAIN;
1320 while (rc == -EAGAIN) {
1321 if ((open_file->invalidHandle) &&
1322 (!open_file->closePend)) {
1323 rc = cifs_reopen_file(
1324 file->f_dentry->d_inode, file);
1325 if (rc != 0)
1326 break;
1327 }
1328 if (!open_file->closePend) {
1329 rc = CIFSSMBSetFileSize(xid,
1330 cifs_sb->tcon, position,
1331 open_file->netfid,
1332 open_file->pid, FALSE);
1333 } else {
1334 rc = -EBADF;
1335 break;
1336 }
1337 }
1338 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1339 } */
1340 }
1341 if (!PageUptodate(page)) {
1342 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1343 /* can not rely on (or let) writepage write this data */
1344 if (to < offset) {
1345 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1346 offset, to));
1347 FreeXid(xid);
1348 return rc;
1349 }
1350 /* this is probably better than directly calling
1351 partialpage_write since in this function the file handle is
1352 known which we might as well leverage */
1353 /* BB check if anything else missing out of ppw
1354 such as updating last write time */
1355 page_data = kmap(page);
1356 rc = cifs_write(file, page_data + offset, to-offset,
1357 &position);
1358 if (rc > 0)
1359 rc = 0;
1360 /* else if (rc < 0) should we set writebehind rc? */
1361 kunmap(page);
1362 } else {
1363 set_page_dirty(page);
1364 }
1365
1366 FreeXid(xid);
1367 return rc;
1368}
1369
1370int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1371{
1372 int xid;
1373 int rc = 0;
1374 struct inode *inode = file->f_dentry->d_inode;
1375
1376 xid = GetXid();
1377
1378 cFYI(1, ("Sync file - name: %s datasync: 0x%x ",
1379 dentry->d_name.name, datasync));
1380
1381 rc = filemap_fdatawrite(inode->i_mapping);
1382 if (rc == 0)
1383 CIFS_I(inode)->write_behind_rc = 0;
1384 FreeXid(xid);
1385 return rc;
1386}
1387
3978d717 1388/* static void cifs_sync_page(struct page *page)
1da177e4
LT		 1389{
1390 struct address_space *mapping;
1391 struct inode *inode;
1392 unsigned long index = page->index;
1393 unsigned int rpages = 0;
1394 int rc = 0;
1395
1396 cFYI(1, ("sync page %p",page));
1397 mapping = page->mapping;
1398 if (!mapping)
1399 return 0;
1400 inode = mapping->host;
1401 if (!inode)
3978d717 1402 return; */
1da177e4
LT		 1403
1404/* fill in rpages then
1405 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1406
1407/* cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
1408
3978d717 1409#if 0
1da177e4
LT		 1410 if (rc < 0)
1411 return rc;
1412 return 0;
3978d717 1413#endif
1da177e4
LT		 1414} */
1415
1416/*
1417 * As file closes, flush all cached write data for this inode checking
1418 * for write behind errors.
1419 */
1420int cifs_flush(struct file *file)
1421{
1422 struct inode * inode = file->f_dentry->d_inode;
1423 int rc = 0;
1424
1425 /* Rather than do the steps manually:
1426 lock the inode for writing
1427 loop through pages looking for write behind data (dirty pages)
1428 coalesce into contiguous 16K (or smaller) chunks to write to server
1429 send to server (prefer in parallel)
1430 deal with writebehind errors
1431 unlock inode for writing
1432 filemapfdatawrite appears easier for the time being */
1433
1434 rc = filemap_fdatawrite(inode->i_mapping);
1435 if (!rc) /* reset wb rc if we were able to write out dirty pages */
1436 CIFS_I(inode)->write_behind_rc = 0;
1437
1438 cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
1439
1440 return rc;
1441}
1442
1443ssize_t cifs_user_read(struct file *file, char __user *read_data,
1444 size_t read_size, loff_t *poffset)
1445{
1446 int rc = -EACCES;
1447 unsigned int bytes_read = 0;
1448 unsigned int total_read = 0;
1449 unsigned int current_read_size;
1450 struct cifs_sb_info *cifs_sb;
1451 struct cifsTconInfo *pTcon;
1452 int xid;
1453 struct cifsFileInfo *open_file;
1454 char *smb_read_data;
1455 char __user *current_offset;
1456 struct smb_com_read_rsp *pSMBr;
1457
1458 xid = GetXid();
1459 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1460 pTcon = cifs_sb->tcon;
1461
1462 if (file->private_data == NULL) {
1463 FreeXid(xid);
1464 return -EBADF;
1465 }
1466 open_file = (struct cifsFileInfo *)file->private_data;
1467
1468 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1469 cFYI(1, ("attempting read on write only file instance"));
1470 }
1471 for (total_read = 0, current_offset = read_data;
1472 read_size > total_read;
1473 total_read += bytes_read, current_offset += bytes_read) {
1474 current_read_size = min_t(const int, read_size - total_read,
1475 cifs_sb->rsize);
1476 rc = -EAGAIN;
1477 smb_read_data = NULL;
1478 while (rc == -EAGAIN) {
ec637e3f 1479 int buf_type = CIFS_NO_BUFFER;
1da177e4
LT		 1480 if ((open_file->invalidHandle) &&
1481 (!open_file->closePend)) {
1482 rc = cifs_reopen_file(file->f_dentry->d_inode,
1483 file, TRUE);
1484 if (rc != 0)
1485 break;
1486 }
bfa0d75a 1487 rc = CIFSSMBRead(xid, pTcon,
ec637e3f
SF		 1488 open_file->netfid,
1489 current_read_size, *poffset,
1490 &bytes_read, &smb_read_data,
1491 &buf_type);
1da177e4 1492 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1da177e4 1493 if (smb_read_data) {
93544cc6
SF		 1494 if (copy_to_user(current_offset,
1495 smb_read_data +
1496 4 /* RFC1001 length field */ +
1497 le16_to_cpu(pSMBr->DataOffset),
1498 bytes_read)) {
1499 rc = -EFAULT;
1500 }
1501
ec637e3f
SF		 1502 if(buf_type == CIFS_SMALL_BUFFER)
1503 cifs_small_buf_release(smb_read_data);
1504 else if(buf_type == CIFS_LARGE_BUFFER)
1505 cifs_buf_release(smb_read_data);
1da177e4
LT		 1506 smb_read_data = NULL;
1507 }
1508 }
1509 if (rc || (bytes_read == 0)) {
1510 if (total_read) {
1511 break;
1512 } else {
1513 FreeXid(xid);
1514 return rc;
1515 }
1516 } else {
a4544347 1517 cifs_stats_bytes_read(pTcon, bytes_read);
1da177e4
LT		 1518 *poffset += bytes_read;
1519 }
1520 }
1521 FreeXid(xid);
1522 return total_read;
1523}
1524
1525
1526static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1527 loff_t *poffset)
1528{
1529 int rc = -EACCES;
1530 unsigned int bytes_read = 0;
1531 unsigned int total_read;
1532 unsigned int current_read_size;
1533 struct cifs_sb_info *cifs_sb;
1534 struct cifsTconInfo *pTcon;
1535 int xid;
1536 char *current_offset;
1537 struct cifsFileInfo *open_file;
ec637e3f 1538 int buf_type = CIFS_NO_BUFFER;
1da177e4
LT		 1539
1540 xid = GetXid();
1541 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1542 pTcon = cifs_sb->tcon;
1543
1544 if (file->private_data == NULL) {
1545 FreeXid(xid);
1546 return -EBADF;
1547 }
1548 open_file = (struct cifsFileInfo *)file->private_data;
1549
1550 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1551 cFYI(1, ("attempting read on write only file instance"));
1552
1553 for (total_read = 0, current_offset = read_data;
1554 read_size > total_read;
1555 total_read += bytes_read, current_offset += bytes_read) {
1556 current_read_size = min_t(const int, read_size - total_read,
1557 cifs_sb->rsize);
f9f5c817
SF		 1558 /* For windows me and 9x we do not want to request more
1559 than it negotiated since it will refuse the read then */
1560 if((pTcon->ses) &&
1561 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1562 current_read_size = min_t(const int, current_read_size,
1563 pTcon->ses->server->maxBuf - 128);
1564 }
1da177e4
LT		 1565 rc = -EAGAIN;
1566 while (rc == -EAGAIN) {
1567 if ((open_file->invalidHandle) &&
1568 (!open_file->closePend)) {
1569 rc = cifs_reopen_file(file->f_dentry->d_inode,
1570 file, TRUE);
1571 if (rc != 0)
1572 break;
1573 }
bfa0d75a 1574 rc = CIFSSMBRead(xid, pTcon,
ec637e3f
SF		 1575 open_file->netfid,
1576 current_read_size, *poffset,
1577 &bytes_read, &current_offset,
1578 &buf_type);
1da177e4
LT		 1579 }
1580 if (rc || (bytes_read == 0)) {
1581 if (total_read) {
1582 break;
1583 } else {
1584 FreeXid(xid);
1585 return rc;
1586 }
1587 } else {
a4544347 1588 cifs_stats_bytes_read(pTcon, total_read);
1da177e4
LT		 1589 *poffset += bytes_read;
1590 }
1591 }
1592 FreeXid(xid);
1593 return total_read;
1594}
1595
1596int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1597{
1598 struct dentry *dentry = file->f_dentry;
1599 int rc, xid;
1600
1601 xid = GetXid();
1602 rc = cifs_revalidate(dentry);
1603 if (rc) {
1604 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1605 FreeXid(xid);
1606 return rc;
1607 }
1608 rc = generic_file_mmap(file, vma);
1609 FreeXid(xid);
1610 return rc;
1611}
1612
1613
1614static void cifs_copy_cache_pages(struct address_space *mapping,
1615 struct list_head *pages, int bytes_read, char *data,
1616 struct pagevec *plru_pvec)
1617{
1618 struct page *page;
1619 char *target;
1620
1621 while (bytes_read > 0) {
1622 if (list_empty(pages))
1623 break;
1624
1625 page = list_entry(pages->prev, struct page, lru);
1626 list_del(&page->lru);
1627
1628 if (add_to_page_cache(page, mapping, page->index,
1629 GFP_KERNEL)) {
1630 page_cache_release(page);
1631 cFYI(1, ("Add page cache failed"));
3079ca62
SF		 1632 data += PAGE_CACHE_SIZE;
1633 bytes_read -= PAGE_CACHE_SIZE;
1da177e4
LT		 1634 continue;
1635 }
1636
1637 target = kmap_atomic(page,KM_USER0);
1638
1639 if (PAGE_CACHE_SIZE > bytes_read) {
1640 memcpy(target, data, bytes_read);
1641 /* zero the tail end of this partial page */
1642 memset(target + bytes_read, 0,
1643 PAGE_CACHE_SIZE - bytes_read);
1644 bytes_read = 0;
1645 } else {
1646 memcpy(target, data, PAGE_CACHE_SIZE);
1647 bytes_read -= PAGE_CACHE_SIZE;
1648 }
1649 kunmap_atomic(target, KM_USER0);
1650
1651 flush_dcache_page(page);
1652 SetPageUptodate(page);
1653 unlock_page(page);
1654 if (!pagevec_add(plru_pvec, page))
1655 __pagevec_lru_add(plru_pvec);
1656 data += PAGE_CACHE_SIZE;
1657 }
1658 return;
1659}
1660
1661static int cifs_readpages(struct file *file, struct address_space *mapping,
1662 struct list_head *page_list, unsigned num_pages)
1663{
1664 int rc = -EACCES;
1665 int xid;
1666 loff_t offset;
1667 struct page *page;
1668 struct cifs_sb_info *cifs_sb;
1669 struct cifsTconInfo *pTcon;
1670 int bytes_read = 0;
1671 unsigned int read_size,i;
1672 char *smb_read_data = NULL;
1673 struct smb_com_read_rsp *pSMBr;
1674 struct pagevec lru_pvec;
1675 struct cifsFileInfo *open_file;
ec637e3f 1676 int buf_type = CIFS_NO_BUFFER;
1da177e4
LT		 1677
1678 xid = GetXid();
1679 if (file->private_data == NULL) {
1680 FreeXid(xid);
1681 return -EBADF;
1682 }
1683 open_file = (struct cifsFileInfo *)file->private_data;
1684 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1685 pTcon = cifs_sb->tcon;
bfa0d75a 1686
1da177e4
LT		 1687 pagevec_init(&lru_pvec, 0);
1688
1689 for (i = 0; i < num_pages; ) {
1690 unsigned contig_pages;
1691 struct page *tmp_page;
1692 unsigned long expected_index;
1693
1694 if (list_empty(page_list))
1695 break;
1696
1697 page = list_entry(page_list->prev, struct page, lru);
1698 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1699
1700 /* count adjacent pages that we will read into */
1701 contig_pages = 0;
1702 expected_index =
1703 list_entry(page_list->prev, struct page, lru)->index;
1704 list_for_each_entry_reverse(tmp_page,page_list,lru) {
1705 if (tmp_page->index == expected_index) {
1706 contig_pages++;
1707 expected_index++;
1708 } else
1709 break;
1710 }
1711 if (contig_pages + i > num_pages)
1712 contig_pages = num_pages - i;
1713
1714 /* for reads over a certain size could initiate async
1715 read ahead */
1716
1717 read_size = contig_pages * PAGE_CACHE_SIZE;
1718 /* Read size needs to be in multiples of one page */
1719 read_size = min_t(const unsigned int, read_size,
1720 cifs_sb->rsize & PAGE_CACHE_MASK);
1721
1722 rc = -EAGAIN;
1723 while (rc == -EAGAIN) {
1724 if ((open_file->invalidHandle) &&
1725 (!open_file->closePend)) {
1726 rc = cifs_reopen_file(file->f_dentry->d_inode,
1727 file, TRUE);
1728 if (rc != 0)
1729 break;
1730 }
1731
bfa0d75a 1732 rc = CIFSSMBRead(xid, pTcon,
ec637e3f
SF		 1733 open_file->netfid,
1734 read_size, offset,
1735 &bytes_read, &smb_read_data,
1736 &buf_type);
a9d02ad4 1737 /* BB more RC checks ? */
1da177e4
LT		 1738 if (rc== -EAGAIN) {
1739 if (smb_read_data) {
ec637e3f
SF		 1740 if(buf_type == CIFS_SMALL_BUFFER)
1741 cifs_small_buf_release(smb_read_data);
1742 else if(buf_type == CIFS_LARGE_BUFFER)
1743 cifs_buf_release(smb_read_data);
1da177e4
LT		 1744 smb_read_data = NULL;
1745 }
1746 }
1747 }
1748 if ((rc < 0) || (smb_read_data == NULL)) {
1749 cFYI(1, ("Read error in readpages: %d", rc));
1750 /* clean up remaing pages off list */
1751 while (!list_empty(page_list) && (i < num_pages)) {
1752 page = list_entry(page_list->prev, struct page,
1753 lru);
1754 list_del(&page->lru);
1755 page_cache_release(page);
1756 }
1757 break;
1758 } else if (bytes_read > 0) {
1759 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1760 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1761 smb_read_data + 4 /* RFC1001 hdr */ +
1762 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1763
1764 i += bytes_read >> PAGE_CACHE_SHIFT;
a4544347 1765 cifs_stats_bytes_read(pTcon, bytes_read);
1da177e4
LT		 1766 if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1767 i++; /* account for partial page */
1768
1769 /* server copy of file can have smaller size
1770 than client */
1771 /* BB do we need to verify this common case ?
1772 this case is ok - if we are at server EOF
1773 we will hit it on next read */
1774
1775 /* while (!list_empty(page_list) && (i < num_pages)) {
1776 page = list_entry(page_list->prev,
1777 struct page, list);
1778 list_del(&page->list);
1779 page_cache_release(page);
1780 }
1781 break; */
1782 }
1783 } else {
1784 cFYI(1, ("No bytes read (%d) at offset %lld . "
1785 "Cleaning remaining pages from readahead list",
1786 bytes_read, offset));
1787 /* BB turn off caching and do new lookup on
1788 file size at server? */
1789 while (!list_empty(page_list) && (i < num_pages)) {
1790 page = list_entry(page_list->prev, struct page,
1791 lru);
1792 list_del(&page->lru);
1793
1794 /* BB removeme - replace with zero of page? */
1795 page_cache_release(page);
1796 }
1797 break;
1798 }
1799 if (smb_read_data) {
ec637e3f
SF		 1800 if(buf_type == CIFS_SMALL_BUFFER)
1801 cifs_small_buf_release(smb_read_data);
1802 else if(buf_type == CIFS_LARGE_BUFFER)
1803 cifs_buf_release(smb_read_data);
1da177e4
LT		 1804 smb_read_data = NULL;
1805 }
1806 bytes_read = 0;
1807 }
1808
1809 pagevec_lru_add(&lru_pvec);
1810
1811/* need to free smb_read_data buf before exit */
1812 if (smb_read_data) {
47c886b3
SF		 1813 if(buf_type == CIFS_SMALL_BUFFER)
1814 cifs_small_buf_release(smb_read_data);
1815 else if(buf_type == CIFS_LARGE_BUFFER)
1816 cifs_buf_release(smb_read_data);
1da177e4
LT		 1817 smb_read_data = NULL;
1818 }
1819
1820 FreeXid(xid);
1821 return rc;
1822}
1823
1824static int cifs_readpage_worker(struct file *file, struct page *page,
1825 loff_t *poffset)
1826{
1827 char *read_data;
1828 int rc;
1829
1830 page_cache_get(page);
1831 read_data = kmap(page);
1832 /* for reads over a certain size could initiate async read ahead */
1833
1834 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1835
1836 if (rc < 0)
1837 goto io_error;
1838 else
1839 cFYI(1, ("Bytes read %d ",rc));
1840
1841 file->f_dentry->d_inode->i_atime =
1842 current_fs_time(file->f_dentry->d_inode->i_sb);
1843
1844 if (PAGE_CACHE_SIZE > rc)
1845 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1846
1847 flush_dcache_page(page);
1848 SetPageUptodate(page);
1849 rc = 0;
1850
1851io_error:
1852 kunmap(page);
1853 page_cache_release(page);
1854 return rc;
1855}
1856
1857static int cifs_readpage(struct file *file, struct page *page)
1858{
1859 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1860 int rc = -EACCES;
1861 int xid;
1862
1863 xid = GetXid();
1864
1865 if (file->private_data == NULL) {
1866 FreeXid(xid);
1867 return -EBADF;
1868 }
1869
1870 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1871 page, (int)offset, (int)offset));
1872
1873 rc = cifs_readpage_worker(file, page, &offset);
1874
1875 unlock_page(page);
1876
1877 FreeXid(xid);
1878 return rc;
1879}
1880
1881/* We do not want to update the file size from server for inodes
1882 open for write - to avoid races with writepage extending
1883 the file - in the future we could consider allowing
1884 refreshing the inode only on increases in the file size
1885 but this is tricky to do without racing with writebehind
1886 page caching in the current Linux kernel design */
1887int is_size_safe_to_change(struct cifsInodeInfo *cifsInode)
1888{
23e7dd7d
SF		 1889 struct cifsFileInfo *open_file = NULL;
1890
1891 if (cifsInode)
1892 open_file = find_writable_file(cifsInode);
1893
1894 if(open_file) {
c32a0b68
SF		 1895 struct cifs_sb_info *cifs_sb;
1896
23e7dd7d
SF		 1897 /* there is not actually a write pending so let
1898 this handle go free and allow it to
1899 be closable if needed */
1900 atomic_dec(&open_file->wrtPending);
c32a0b68
SF		 1901
1902 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
1903 if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
1904 /* since no page cache to corrupt on directio
1905 we can change size safely */
1906 return 1;
1907 }
1908
6148a742 1909 return 0;
23e7dd7d 1910 } else
6148a742 1911 return 1;
1da177e4
LT		 1912}
1913
1da177e4
LT		 1914static int cifs_prepare_write(struct file *file, struct page *page,
1915 unsigned from, unsigned to)
1916{
1917 int rc = 0;
1918 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1919 cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
1920 if (!PageUptodate(page)) {
1921 /* if (to - from != PAGE_CACHE_SIZE) {
1922 void *kaddr = kmap_atomic(page, KM_USER0);
1923 memset(kaddr, 0, from);
1924 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
1925 flush_dcache_page(page);
1926 kunmap_atomic(kaddr, KM_USER0);
1927 } */
1928 /* If we are writing a full page it will be up to date,
1929 no need to read from the server */
1930 if ((to == PAGE_CACHE_SIZE) && (from == 0))
1931 SetPageUptodate(page);
1932
1933 /* might as well read a page, it is fast enough */
1934 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
1935 rc = cifs_readpage_worker(file, page, &offset);
1936 } else {
1937 /* should we try using another file handle if there is one -
1938 how would we lock it to prevent close of that handle
1939 racing with this read?
1940 In any case this will be written out by commit_write */
1941 }
1942 }
1943
1944 /* BB should we pass any errors back?
1945 e.g. if we do not have read access to the file */
1946 return 0;
1947}
1948
1949struct address_space_operations cifs_addr_ops = {
1950 .readpage = cifs_readpage,
1951 .readpages = cifs_readpages,
1952 .writepage = cifs_writepage,
37c0eb46 1953 .writepages = cifs_writepages,
1da177e4
LT		 1954 .prepare_write = cifs_prepare_write,
1955 .commit_write = cifs_commit_write,
1956 .set_page_dirty = __set_page_dirty_nobuffers,
1957 /* .sync_page = cifs_sync_page, */
1958 /* .direct_IO = */
1959};
Linux kernel - Deliverables
This page took 0.217895 seconds and 5 git commands to generate.