projects / linux-2.6-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[CIFS] Fix typos in previous fix
[linux-2.6-block.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;
87 else
88 return FILE_OPEN;
89}
90
91/* all arguments to this function must be checked for validity in caller */
92static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
93 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
94 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
95 char *full_path, int xid)
96{
97 struct timespec temp;
98 int rc;
99
100 /* want handles we can use to read with first
101 in the list so we do not have to walk the
102 list to search for one in prepare_write */
103 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
104 list_add_tail(&pCifsFile->flist,
105 &pCifsInode->openFileList);
106 } else {
107 list_add(&pCifsFile->flist,
108 &pCifsInode->openFileList);
109 }
110 write_unlock(&GlobalSMBSeslock);
111 write_unlock(&file->f_owner.lock);
112 if (pCifsInode->clientCanCacheRead) {
113 /* we have the inode open somewhere else
114 no need to discard cache data */
115 goto client_can_cache;
116 }
117
118 /* BB need same check in cifs_create too? */
119 /* if not oplocked, invalidate inode pages if mtime or file
120 size changed */
121 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
122 if (timespec_equal(&file->f_dentry->d_inode->i_mtime, &temp) &&
123 (file->f_dentry->d_inode->i_size ==
124 (loff_t)le64_to_cpu(buf->EndOfFile))) {
125 cFYI(1, ("inode unchanged on server"));
126 } else {
127 if (file->f_dentry->d_inode->i_mapping) {
128 /* BB no need to lock inode until after invalidate
129 since namei code should already have it locked? */
28fd1298 130 filemap_write_and_wait(file->f_dentry->d_inode->i_mapping);
1da177e4
LT		 131 }
132 cFYI(1, ("invalidating remote inode since open detected it "
133 "changed"));
134 invalidate_remote_inode(file->f_dentry->d_inode);
135 }
136
137client_can_cache:
138 if (pTcon->ses->capabilities & CAP_UNIX)
139 rc = cifs_get_inode_info_unix(&file->f_dentry->d_inode,
140 full_path, inode->i_sb, xid);
141 else
142 rc = cifs_get_inode_info(&file->f_dentry->d_inode,
143 full_path, buf, inode->i_sb, xid);
144
145 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
146 pCifsInode->clientCanCacheAll = TRUE;
147 pCifsInode->clientCanCacheRead = TRUE;
148 cFYI(1, ("Exclusive Oplock granted on inode %p",
149 file->f_dentry->d_inode));
150 } else if ((*oplock & 0xF) == OPLOCK_READ)
151 pCifsInode->clientCanCacheRead = TRUE;
152
153 return rc;
154}
155
156int cifs_open(struct inode *inode, struct file *file)
157{
158 int rc = -EACCES;
159 int xid, oplock;
160 struct cifs_sb_info *cifs_sb;
161 struct cifsTconInfo *pTcon;
162 struct cifsFileInfo *pCifsFile;
163 struct cifsInodeInfo *pCifsInode;
164 struct list_head *tmp;
165 char *full_path = NULL;
166 int desiredAccess;
167 int disposition;
168 __u16 netfid;
169 FILE_ALL_INFO *buf = NULL;
170
171 xid = GetXid();
172
173 cifs_sb = CIFS_SB(inode->i_sb);
174 pTcon = cifs_sb->tcon;
175
176 if (file->f_flags & O_CREAT) {
177 /* search inode for this file and fill in file->private_data */
178 pCifsInode = CIFS_I(file->f_dentry->d_inode);
179 read_lock(&GlobalSMBSeslock);
180 list_for_each(tmp, &pCifsInode->openFileList) {
181 pCifsFile = list_entry(tmp, struct cifsFileInfo,
182 flist);
183 if ((pCifsFile->pfile == NULL) &&
184 (pCifsFile->pid == current->tgid)) {
185 /* mode set in cifs_create */
186
187 /* needed for writepage */
188 pCifsFile->pfile = file;
189
190 file->private_data = pCifsFile;
191 break;
192 }
193 }
194 read_unlock(&GlobalSMBSeslock);
195 if (file->private_data != NULL) {
196 rc = 0;
197 FreeXid(xid);
198 return rc;
199 } else {
200 if (file->f_flags & O_EXCL)
201 cERROR(1, ("could not find file instance for "
202 "new file %p ", file));
203 }
204 }
205
7f57356b 206 full_path = build_path_from_dentry(file->f_dentry);
1da177e4
LT		 207 if (full_path == NULL) {
208 FreeXid(xid);
209 return -ENOMEM;
210 }
211
212 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
213 inode, file->f_flags, full_path));
214 desiredAccess = cifs_convert_flags(file->f_flags);
215
216/*********************************************************************
217 * open flag mapping table:
218 *
219 * POSIX Flag CIFS Disposition
220 * ---------- ----------------
221 * O_CREAT FILE_OPEN_IF
222 * O_CREAT | O_EXCL FILE_CREATE
223 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
224 * O_TRUNC FILE_OVERWRITE
225 * none of the above FILE_OPEN
226 *
227 * Note that there is not a direct match between disposition
228 * FILE_SUPERSEDE (ie create whether or not file exists although
229 * O_CREAT | O_TRUNC is similar but truncates the existing
230 * file rather than creating a new file as FILE_SUPERSEDE does
231 * (which uses the attributes / metadata passed in on open call)
232 *?
233 *? O_SYNC is a reasonable match to CIFS writethrough flag
234 *? and the read write flags match reasonably. O_LARGEFILE
235 *? is irrelevant because largefile support is always used
236 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
237 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
238 *********************************************************************/
239
240 disposition = cifs_get_disposition(file->f_flags);
241
242 if (oplockEnabled)
243 oplock = REQ_OPLOCK;
244 else
245 oplock = FALSE;
246
247 /* BB pass O_SYNC flag through on file attributes .. BB */
248
249 /* Also refresh inode by passing in file_info buf returned by SMBOpen
250 and calling get_inode_info with returned buf (at least helps
251 non-Unix server case) */
252
253 /* BB we can not do this if this is the second open of a file
254 and the first handle has writebehind data, we might be
255 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
256 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
257 if (!buf) {
258 rc = -ENOMEM;
259 goto out;
260 }
261 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
262 CREATE_NOT_DIR, &netfid, &oplock, buf,
737b758c
SF		 263 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
264 & CIFS_MOUNT_MAP_SPECIAL_CHR);
a9d02ad4
SF		 265 if (rc == -EIO) {
266 /* Old server, try legacy style OpenX */
267 rc = SMBLegacyOpen(xid, pTcon, full_path, disposition,
268 desiredAccess, CREATE_NOT_DIR, &netfid, &oplock, buf,
269 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
270 & CIFS_MOUNT_MAP_SPECIAL_CHR);
271 }
1da177e4
LT		 272 if (rc) {
273 cFYI(1, ("cifs_open returned 0x%x ", rc));
274 goto out;
275 }
276 file->private_data =
277 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
278 if (file->private_data == NULL) {
279 rc = -ENOMEM;
280 goto out;
281 }
282 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
283 write_lock(&file->f_owner.lock);
284 write_lock(&GlobalSMBSeslock);
285 list_add(&pCifsFile->tlist, &pTcon->openFileList);
286
287 pCifsInode = CIFS_I(file->f_dentry->d_inode);
288 if (pCifsInode) {
289 rc = cifs_open_inode_helper(inode, file, pCifsInode,
290 pCifsFile, pTcon,
291 &oplock, buf, full_path, xid);
292 } else {
293 write_unlock(&GlobalSMBSeslock);
294 write_unlock(&file->f_owner.lock);
295 }
296
297 if (oplock & CIFS_CREATE_ACTION) {
298 /* time to set mode which we can not set earlier due to
299 problems creating new read-only files */
300 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
301 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
302 inode->i_mode,
303 (__u64)-1, (__u64)-1, 0 /* dev */,
737b758c
SF		 304 cifs_sb->local_nls,
305 cifs_sb->mnt_cifs_flags &
306 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 307 } else {
308 /* BB implement via Windows security descriptors eg
309 CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
310 -1, -1, local_nls);
311 in the meantime could set r/o dos attribute when
312 perms are eg: mode & 0222 == 0 */
313 }
314 }
315
316out:
317 kfree(buf);
318 kfree(full_path);
319 FreeXid(xid);
320 return rc;
321}
322
323/* Try to reaquire byte range locks that were released when session */
324/* to server was lost */
325static int cifs_relock_file(struct cifsFileInfo *cifsFile)
326{
327 int rc = 0;
328
329/* BB list all locks open on this file and relock */
330
331 return rc;
332}
333
334static int cifs_reopen_file(struct inode *inode, struct file *file,
335 int can_flush)
336{
337 int rc = -EACCES;
338 int xid, oplock;
339 struct cifs_sb_info *cifs_sb;
340 struct cifsTconInfo *pTcon;
341 struct cifsFileInfo *pCifsFile;
342 struct cifsInodeInfo *pCifsInode;
343 char *full_path = NULL;
344 int desiredAccess;
345 int disposition = FILE_OPEN;
346 __u16 netfid;
347
348 if (inode == NULL)
349 return -EBADF;
350 if (file->private_data) {
351 pCifsFile = (struct cifsFileInfo *)file->private_data;
352 } else
353 return -EBADF;
354
355 xid = GetXid();
356 down(&pCifsFile->fh_sem);
357 if (pCifsFile->invalidHandle == FALSE) {
358 up(&pCifsFile->fh_sem);
359 FreeXid(xid);
360 return 0;
361 }
362
363 if (file->f_dentry == NULL) {
364 up(&pCifsFile->fh_sem);
365 cFYI(1, ("failed file reopen, no valid name if dentry freed"));
366 FreeXid(xid);
367 return -EBADF;
368 }
369 cifs_sb = CIFS_SB(inode->i_sb);
370 pTcon = cifs_sb->tcon;
371/* can not grab rename sem here because various ops, including
372 those that already have the rename sem can end up causing writepage
373 to get called and if the server was down that means we end up here,
374 and we can never tell if the caller already has the rename_sem */
7f57356b 375 full_path = build_path_from_dentry(file->f_dentry);
1da177e4
LT		 376 if (full_path == NULL) {
377 up(&pCifsFile->fh_sem);
378 FreeXid(xid);
379 return -ENOMEM;
380 }
381
382 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
383 inode, file->f_flags,full_path));
384 desiredAccess = cifs_convert_flags(file->f_flags);
385
386 if (oplockEnabled)
387 oplock = REQ_OPLOCK;
388 else
389 oplock = FALSE;
390
391 /* Can not refresh inode by passing in file_info buf to be returned
392 by SMBOpen and then calling get_inode_info with returned buf
393 since file might have write behind data that needs to be flushed
394 and server version of file size can be stale. If we knew for sure
395 that inode was not dirty locally we could do this */
396
397/* buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
398 if (buf == 0) {
399 up(&pCifsFile->fh_sem);
400 kfree(full_path);
401 FreeXid(xid);
402 return -ENOMEM;
403 } */
404 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
405 CREATE_NOT_DIR, &netfid, &oplock, NULL,
737b758c
SF		 406 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
407 CIFS_MOUNT_MAP_SPECIAL_CHR);
1da177e4
LT		 408 if (rc) {
409 up(&pCifsFile->fh_sem);
410 cFYI(1, ("cifs_open returned 0x%x ", rc));
411 cFYI(1, ("oplock: %d ", oplock));
412 } else {
413 pCifsFile->netfid = netfid;
414 pCifsFile->invalidHandle = FALSE;
415 up(&pCifsFile->fh_sem);
416 pCifsInode = CIFS_I(inode);
417 if (pCifsInode) {
418 if (can_flush) {
28fd1298 419 filemap_write_and_wait(inode->i_mapping);
1da177e4
LT		 420 /* temporarily disable caching while we
421 go to server to get inode info */
422 pCifsInode->clientCanCacheAll = FALSE;
423 pCifsInode->clientCanCacheRead = FALSE;
424 if (pTcon->ses->capabilities & CAP_UNIX)
425 rc = cifs_get_inode_info_unix(&inode,
426 full_path, inode->i_sb, xid);
427 else
428 rc = cifs_get_inode_info(&inode,
429 full_path, NULL, inode->i_sb,
430 xid);
431 } /* else we are writing out data to server already
432 and could deadlock if we tried to flush data, and
433 since we do not know if we have data that would
434 invalidate the current end of file on the server
435 we can not go to the server to get the new inod
436 info */
437 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
438 pCifsInode->clientCanCacheAll = TRUE;
439 pCifsInode->clientCanCacheRead = TRUE;
440 cFYI(1, ("Exclusive Oplock granted on inode %p",
441 file->f_dentry->d_inode));
442 } else if ((oplock & 0xF) == OPLOCK_READ) {
443 pCifsInode->clientCanCacheRead = TRUE;
444 pCifsInode->clientCanCacheAll = FALSE;
445 } else {
446 pCifsInode->clientCanCacheRead = FALSE;
447 pCifsInode->clientCanCacheAll = FALSE;
448 }
449 cifs_relock_file(pCifsFile);
450 }
451 }
452
453 kfree(full_path);
454 FreeXid(xid);
455 return rc;
456}
457
458int cifs_close(struct inode *inode, struct file *file)
459{
460 int rc = 0;
461 int xid;
462 struct cifs_sb_info *cifs_sb;
463 struct cifsTconInfo *pTcon;
464 struct cifsFileInfo *pSMBFile =
465 (struct cifsFileInfo *)file->private_data;
466
467 xid = GetXid();
468
469 cifs_sb = CIFS_SB(inode->i_sb);
470 pTcon = cifs_sb->tcon;
471 if (pSMBFile) {
472 pSMBFile->closePend = TRUE;
473 write_lock(&file->f_owner.lock);
474 if (pTcon) {
475 /* no sense reconnecting to close a file that is
476 already closed */
477 if (pTcon->tidStatus != CifsNeedReconnect) {
23e7dd7d
SF		 478 int timeout = 2;
479 while((atomic_read(&pSMBFile->wrtPending) != 0)
480 && (timeout < 1000) ) {
481 /* Give write a better chance to get to
482 server ahead of the close. We do not
483 want to add a wait_q here as it would
484 increase the memory utilization as
485 the struct would be in each open file,
486 but this should give enough time to
487 clear the socket */
c119b87d 488 write_unlock(&file->f_owner.lock);
23e7dd7d
SF		 489 cERROR(1,("close with pending writes"));
490 msleep(timeout);
c119b87d 491 write_lock(&file->f_owner.lock);
23e7dd7d
SF		 492 timeout *= 4;
493 }
1da177e4
LT		 494 write_unlock(&file->f_owner.lock);
495 rc = CIFSSMBClose(xid, pTcon,
496 pSMBFile->netfid);
497 write_lock(&file->f_owner.lock);
498 }
499 }
cbe0476f 500 write_lock(&GlobalSMBSeslock);
1da177e4
LT		 501 list_del(&pSMBFile->flist);
502 list_del(&pSMBFile->tlist);
cbe0476f 503 write_unlock(&GlobalSMBSeslock);
1da177e4
LT		 504 write_unlock(&file->f_owner.lock);
505 kfree(pSMBFile->search_resume_name);
506 kfree(file->private_data);
507 file->private_data = NULL;
508 } else
509 rc = -EBADF;
510
511 if (list_empty(&(CIFS_I(inode)->openFileList))) {
512 cFYI(1, ("closing last open instance for inode %p", inode));
513 /* if the file is not open we do not know if we can cache info
514 on this inode, much less write behind and read ahead */
515 CIFS_I(inode)->clientCanCacheRead = FALSE;
516 CIFS_I(inode)->clientCanCacheAll = FALSE;
517 }
518 if ((rc ==0) && CIFS_I(inode)->write_behind_rc)
519 rc = CIFS_I(inode)->write_behind_rc;
520 FreeXid(xid);
521 return rc;
522}
523
524int cifs_closedir(struct inode *inode, struct file *file)
525{
526 int rc = 0;
527 int xid;
528 struct cifsFileInfo *pCFileStruct =
529 (struct cifsFileInfo *)file->private_data;
530 char *ptmp;
531
532 cFYI(1, ("Closedir inode = 0x%p with ", inode));
533
534 xid = GetXid();
535
536 if (pCFileStruct) {
537 struct cifsTconInfo *pTcon;
538 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_dentry->d_sb);
539
540 pTcon = cifs_sb->tcon;
541
542 cFYI(1, ("Freeing private data in close dir"));
31ca3bc3
SF		 543 if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
544 (pCFileStruct->invalidHandle == FALSE)) {
1da177e4
LT		 545 pCFileStruct->invalidHandle = TRUE;
546 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
547 cFYI(1, ("Closing uncompleted readdir with rc %d",
548 rc));
549 /* not much we can do if it fails anyway, ignore rc */
550 rc = 0;
551 }
552 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
553 if (ptmp) {
ec637e3f 554 cFYI(1, ("closedir free smb buf in srch struct"));
1da177e4 555 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
d47d7c1a
SF		 556 if(pCFileStruct->srch_inf.smallBuf)
557 cifs_small_buf_release(ptmp);
558 else
559 cifs_buf_release(ptmp);
1da177e4
LT		 560 }
561 ptmp = pCFileStruct->search_resume_name;
562 if (ptmp) {
ec637e3f 563 cFYI(1, ("closedir free resume name"));
1da177e4
LT		 564 pCFileStruct->search_resume_name = NULL;
565 kfree(ptmp);
566 }
567 kfree(file->private_data);
568 file->private_data = NULL;
569 }
570 /* BB can we lock the filestruct while this is going on? */
571 FreeXid(xid);
572 return rc;
573}
574
575int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
576{
577 int rc, xid;
1da177e4
LT		 578 __u32 numLock = 0;
579 __u32 numUnlock = 0;
580 __u64 length;
581 int wait_flag = FALSE;
582 struct cifs_sb_info *cifs_sb;
583 struct cifsTconInfo *pTcon;
08547b03
SF		 584 __u16 netfid;
585 __u8 lockType = LOCKING_ANDX_LARGE_FILES;
1da177e4
LT		 586
587 length = 1 + pfLock->fl_end - pfLock->fl_start;
588 rc = -EACCES;
589 xid = GetXid();
590
591 cFYI(1, ("Lock parm: 0x%x flockflags: "
592 "0x%x flocktype: 0x%x start: %lld end: %lld",
593 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
594 pfLock->fl_end));
595
596 if (pfLock->fl_flags & FL_POSIX)
d47d7c1a 597 cFYI(1, ("Posix"));
1da177e4 598 if (pfLock->fl_flags & FL_FLOCK)
d47d7c1a 599 cFYI(1, ("Flock"));
1da177e4 600 if (pfLock->fl_flags & FL_SLEEP) {
d47d7c1a 601 cFYI(1, ("Blocking lock"));
1da177e4
LT		 602 wait_flag = TRUE;
603 }
604 if (pfLock->fl_flags & FL_ACCESS)
605 cFYI(1, ("Process suspended by mandatory locking - "
606 "not implemented yet "));
607 if (pfLock->fl_flags & FL_LEASE)
608 cFYI(1, ("Lease on file - not implemented yet"));
609 if (pfLock->fl_flags &
610 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
611 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
612
613 if (pfLock->fl_type == F_WRLCK) {
614 cFYI(1, ("F_WRLCK "));
615 numLock = 1;
616 } else if (pfLock->fl_type == F_UNLCK) {
d47d7c1a 617 cFYI(1, ("F_UNLCK"));
1da177e4 618 numUnlock = 1;
d47d7c1a
SF		 619 /* Check if unlock includes more than
620 one lock range */
1da177e4 621 } else if (pfLock->fl_type == F_RDLCK) {
d47d7c1a 622 cFYI(1, ("F_RDLCK"));
1da177e4
LT		 623 lockType |= LOCKING_ANDX_SHARED_LOCK;
624 numLock = 1;
625 } else if (pfLock->fl_type == F_EXLCK) {
d47d7c1a 626 cFYI(1, ("F_EXLCK"));
1da177e4
LT		 627 numLock = 1;
628 } else if (pfLock->fl_type == F_SHLCK) {
d47d7c1a 629 cFYI(1, ("F_SHLCK"));
1da177e4
LT		 630 lockType |= LOCKING_ANDX_SHARED_LOCK;
631 numLock = 1;
632 } else
d47d7c1a 633 cFYI(1, ("Unknown type of lock"));
1da177e4
LT		 634
635 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
636 pTcon = cifs_sb->tcon;
637
638 if (file->private_data == NULL) {
639 FreeXid(xid);
640 return -EBADF;
641 }
08547b03
SF		 642 netfid = ((struct cifsFileInfo *)file->private_data)->netfid;
643
1da177e4 644
08547b03
SF		 645 /* BB add code here to normalize offset and length to
646 account for negative length which we can not accept over the
647 wire */
1da177e4 648 if (IS_GETLK(cmd)) {
08547b03 649 if(experimEnabled &&
82940a46
SF		 650 (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
651 (CIFS_UNIX_FCNTL_CAP &
652 le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability))) {
08547b03
SF		 653 int posix_lock_type;
654 if(lockType & LOCKING_ANDX_SHARED_LOCK)
655 posix_lock_type = CIFS_RDLCK;
656 else
657 posix_lock_type = CIFS_WRLCK;
658 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 1 /* get */,
fc94cdb9 659 length, pfLock,
08547b03
SF		 660 posix_lock_type, wait_flag);
661 FreeXid(xid);
662 return rc;
663 }
664
665 /* BB we could chain these into one lock request BB */
666 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
667 0, 1, lockType, 0 /* wait flag */ );
1da177e4 668 if (rc == 0) {
08547b03 669 rc = CIFSSMBLock(xid, pTcon, netfid, length,
1da177e4
LT		 670 pfLock->fl_start, 1 /* numUnlock */ ,
671 0 /* numLock */ , lockType,
672 0 /* wait flag */ );
673 pfLock->fl_type = F_UNLCK;
674 if (rc != 0)
675 cERROR(1, ("Error unlocking previously locked "
08547b03 676 "range %d during test of lock", rc));
1da177e4
LT		 677 rc = 0;
678
679 } else {
680 /* if rc == ERR_SHARING_VIOLATION ? */
681 rc = 0; /* do not change lock type to unlock
682 since range in use */
683 }
684
685 FreeXid(xid);
686 return rc;
687 }
08547b03 688 if (experimEnabled &&
82940a46
SF		 689 (cifs_sb->tcon->ses->capabilities & CAP_UNIX) &&
690 (CIFS_UNIX_FCNTL_CAP &
691 le64_to_cpu(cifs_sb->tcon->fsUnixInfo.Capability))) {
08547b03
SF		 692 int posix_lock_type;
693 if(lockType & LOCKING_ANDX_SHARED_LOCK)
694 posix_lock_type = CIFS_RDLCK;
695 else
696 posix_lock_type = CIFS_WRLCK;
697
698 if(numUnlock == 1)
beb84dc8 699 posix_lock_type = CIFS_UNLCK;
08547b03
SF		 700 else if(numLock == 0) {
701 /* if no lock or unlock then nothing
702 to do since we do not know what it is */
703 FreeXid(xid);
704 return -EOPNOTSUPP;
705 }
706 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
fc94cdb9 707 length, pfLock,
08547b03
SF		 708 posix_lock_type, wait_flag);
709 } else
710 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
711 numUnlock, numLock, lockType, wait_flag);
d634cc15 712 if (pfLock->fl_flags & FL_POSIX)
1da177e4
LT		 713 posix_lock_file_wait(file, pfLock);
714 FreeXid(xid);
715 return rc;
716}
717
718ssize_t cifs_user_write(struct file *file, const char __user *write_data,
719 size_t write_size, loff_t *poffset)
720{
721 int rc = 0;
722 unsigned int bytes_written = 0;
723 unsigned int total_written;
724 struct cifs_sb_info *cifs_sb;
725 struct cifsTconInfo *pTcon;
726 int xid, long_op;
727 struct cifsFileInfo *open_file;
728
729 if (file->f_dentry == NULL)
730 return -EBADF;
731
732 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
733 if (cifs_sb == NULL)
734 return -EBADF;
735
736 pTcon = cifs_sb->tcon;
737
738 /* cFYI(1,
739 (" write %d bytes to offset %lld of %s", write_size,
740 *poffset, file->f_dentry->d_name.name)); */
741
742 if (file->private_data == NULL)
743 return -EBADF;
744 else
745 open_file = (struct cifsFileInfo *) file->private_data;
746
747 xid = GetXid();
748 if (file->f_dentry->d_inode == NULL) {
749 FreeXid(xid);
750 return -EBADF;
751 }
752
753 if (*poffset > file->f_dentry->d_inode->i_size)
754 long_op = 2; /* writes past end of file can take a long time */
755 else
756 long_op = 1;
757
758 for (total_written = 0; write_size > total_written;
759 total_written += bytes_written) {
760 rc = -EAGAIN;
761 while (rc == -EAGAIN) {
762 if (file->private_data == NULL) {
763 /* file has been closed on us */
764 FreeXid(xid);
765 /* if we have gotten here we have written some data
766 and blocked, and the file has been freed on us while
767 we blocked so return what we managed to write */
768 return total_written;
769 }
770 if (open_file->closePend) {
771 FreeXid(xid);
772 if (total_written)
773 return total_written;
774 else
775 return -EBADF;
776 }
777 if (open_file->invalidHandle) {
778 if ((file->f_dentry == NULL) ||
779 (file->f_dentry->d_inode == NULL)) {
780 FreeXid(xid);
781 return total_written;
782 }
783 /* we could deadlock if we called
784 filemap_fdatawait from here so tell
785 reopen_file not to flush data to server
786 now */
787 rc = cifs_reopen_file(file->f_dentry->d_inode,
788 file, FALSE);
789 if (rc != 0)
790 break;
791 }
792
793 rc = CIFSSMBWrite(xid, pTcon,
794 open_file->netfid,
795 min_t(const int, cifs_sb->wsize,
796 write_size - total_written),
797 *poffset, &bytes_written,
798 NULL, write_data + total_written, long_op);
799 }
800 if (rc || (bytes_written == 0)) {
801 if (total_written)
802 break;
803 else {
804 FreeXid(xid);
805 return rc;
806 }
807 } else
808 *poffset += bytes_written;
809 long_op = FALSE; /* subsequent writes fast -
810 15 seconds is plenty */
811 }
812
a4544347 813 cifs_stats_bytes_written(pTcon, total_written);
1da177e4
LT		 814
815 /* since the write may have blocked check these pointers again */
816 if (file->f_dentry) {
817 if (file->f_dentry->d_inode) {
818 struct inode *inode = file->f_dentry->d_inode;
819 inode->i_ctime = inode->i_mtime =
820 current_fs_time(inode->i_sb);
821 if (total_written > 0) {
822 if (*poffset > file->f_dentry->d_inode->i_size)
823 i_size_write(file->f_dentry->d_inode,
824 *poffset);
825 }
826 mark_inode_dirty_sync(file->f_dentry->d_inode);
827 }
828 }
829 FreeXid(xid);
830 return total_written;
831}
832
833static ssize_t cifs_write(struct file *file, const char *write_data,
834 size_t write_size, loff_t *poffset)
835{
836 int rc = 0;
837 unsigned int bytes_written = 0;
838 unsigned int total_written;
839 struct cifs_sb_info *cifs_sb;
840 struct cifsTconInfo *pTcon;
841 int xid, long_op;
842 struct cifsFileInfo *open_file;
843
844 if (file->f_dentry == NULL)
845 return -EBADF;
846
847 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
848 if (cifs_sb == NULL)
849 return -EBADF;
850
851 pTcon = cifs_sb->tcon;
852
ab2f218f
SF		 853 cFYI(1,("write %zd bytes to offset %lld of %s", write_size,
854 *poffset, file->f_dentry->d_name.name));
1da177e4
LT		 855
856 if (file->private_data == NULL)
857 return -EBADF;
858 else
859 open_file = (struct cifsFileInfo *)file->private_data;
860
861 xid = GetXid();
862 if (file->f_dentry->d_inode == NULL) {
863 FreeXid(xid);
864 return -EBADF;
865 }
866
867 if (*poffset > file->f_dentry->d_inode->i_size)
868 long_op = 2; /* writes past end of file can take a long time */
869 else
870 long_op = 1;
871
872 for (total_written = 0; write_size > total_written;
873 total_written += bytes_written) {
874 rc = -EAGAIN;
875 while (rc == -EAGAIN) {
876 if (file->private_data == NULL) {
877 /* file has been closed on us */
878 FreeXid(xid);
879 /* if we have gotten here we have written some data
880 and blocked, and the file has been freed on us
881 while we blocked so return what we managed to
882 write */
883 return total_written;
884 }
885 if (open_file->closePend) {
886 FreeXid(xid);
887 if (total_written)
888 return total_written;
889 else
890 return -EBADF;
891 }
892 if (open_file->invalidHandle) {
893 if ((file->f_dentry == NULL) ||
894 (file->f_dentry->d_inode == NULL)) {
895 FreeXid(xid);
896 return total_written;
897 }
898 /* we could deadlock if we called
899 filemap_fdatawait from here so tell
900 reopen_file not to flush data to
901 server now */
902 rc = cifs_reopen_file(file->f_dentry->d_inode,
903 file, FALSE);
904 if (rc != 0)
905 break;
906 }
c01f36a8 907 if(experimEnabled || (pTcon->ses->server &&
08775834
SF		 908 ((pTcon->ses->server->secMode &
909 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
c01f36a8 910 == 0))) {
3e84469d
SF		 911 struct kvec iov[2];
912 unsigned int len;
913
0ae0efad 914 len = min((size_t)cifs_sb->wsize,
3e84469d
SF		 915 write_size - total_written);
916 /* iov[0] is reserved for smb header */
917 iov[1].iov_base = (char *)write_data +
918 total_written;
919 iov[1].iov_len = len;
d6e04ae6 920 rc = CIFSSMBWrite2(xid, pTcon,
3e84469d 921 open_file->netfid, len,
d6e04ae6 922 *poffset, &bytes_written,
3e84469d 923 iov, 1, long_op);
d6e04ae6 924 } else
60808233
SF		 925 rc = CIFSSMBWrite(xid, pTcon,
926 open_file->netfid,
927 min_t(const int, cifs_sb->wsize,
928 write_size - total_written),
929 *poffset, &bytes_written,
930 write_data + total_written,
931 NULL, long_op);
1da177e4
LT		 932 }
933 if (rc || (bytes_written == 0)) {
934 if (total_written)
935 break;
936 else {
937 FreeXid(xid);
938 return rc;
939 }
940 } else
941 *poffset += bytes_written;
942 long_op = FALSE; /* subsequent writes fast -
943 15 seconds is plenty */
944 }
945
a4544347 946 cifs_stats_bytes_written(pTcon, total_written);
1da177e4
LT		 947
948 /* since the write may have blocked check these pointers again */
949 if (file->f_dentry) {
950 if (file->f_dentry->d_inode) {
951 file->f_dentry->d_inode->i_ctime =
952 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
953 if (total_written > 0) {
954 if (*poffset > file->f_dentry->d_inode->i_size)
955 i_size_write(file->f_dentry->d_inode,
956 *poffset);
957 }
958 mark_inode_dirty_sync(file->f_dentry->d_inode);
959 }
960 }
961 FreeXid(xid);
962 return total_written;
963}
964
dd99cd80 965struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
6148a742
SF		 966{
967 struct cifsFileInfo *open_file;
dd99cd80 968 int rc;
6148a742 969
60808233
SF		 970 /* Having a null inode here (because mapping->host was set to zero by
971 the VFS or MM) should not happen but we had reports of on oops (due to
972 it being zero) during stress testcases so we need to check for it */
973
974 if(cifs_inode == NULL) {
975 cERROR(1,("Null inode passed to cifs_writeable_file"));
976 dump_stack();
977 return NULL;
978 }
979
6148a742
SF		 980 read_lock(&GlobalSMBSeslock);
981 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
982 if (open_file->closePend)
983 continue;
984 if (open_file->pfile &&
985 ((open_file->pfile->f_flags & O_RDWR) ||
986 (open_file->pfile->f_flags & O_WRONLY))) {
23e7dd7d 987 atomic_inc(&open_file->wrtPending);
6148a742 988 read_unlock(&GlobalSMBSeslock);
0ae0efad 989 if((open_file->invalidHandle) &&
23e7dd7d 990 (!open_file->closePend) /* BB fixme -since the second clause can not be true remove it BB */) {
dd99cd80 991 rc = cifs_reopen_file(&cifs_inode->vfs_inode,
37c0eb46
SF		 992 open_file->pfile, FALSE);
993 /* if it fails, try another handle - might be */
994 /* dangerous to hold up writepages with retry */
995 if(rc) {
4a77118c 996 cFYI(1,("failed on reopen file in wp"));
37c0eb46 997 read_lock(&GlobalSMBSeslock);
23e7dd7d
SF		 998 /* can not use this handle, no write
999 pending on this one after all */
1000 atomic_dec
1001 (&open_file->wrtPending);
37c0eb46
SF		 1002 continue;
1003 }
1004 }
6148a742
SF		 1005 return open_file;
1006 }
1007 }
1008 read_unlock(&GlobalSMBSeslock);
1009 return NULL;
1010}
1011
1da177e4
LT		 1012static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1013{
1014 struct address_space *mapping = page->mapping;
1015 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1016 char *write_data;
1017 int rc = -EFAULT;
1018 int bytes_written = 0;
1019 struct cifs_sb_info *cifs_sb;
1020 struct cifsTconInfo *pTcon;
1021 struct inode *inode;
6148a742 1022 struct cifsFileInfo *open_file;
1da177e4
LT		 1023
1024 if (!mapping || !mapping->host)
1025 return -EFAULT;
1026
1027 inode = page->mapping->host;
1028 cifs_sb = CIFS_SB(inode->i_sb);
1029 pTcon = cifs_sb->tcon;
1030
1031 offset += (loff_t)from;
1032 write_data = kmap(page);
1033 write_data += from;
1034
1035 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1036 kunmap(page);
1037 return -EIO;
1038 }
1039
1040 /* racing with truncate? */
1041 if (offset > mapping->host->i_size) {
1042 kunmap(page);
1043 return 0; /* don't care */
1044 }
1045
1046 /* check to make sure that we are not extending the file */
1047 if (mapping->host->i_size - offset < (loff_t)to)
1048 to = (unsigned)(mapping->host->i_size - offset);
1049
6148a742
SF		 1050 open_file = find_writable_file(CIFS_I(mapping->host));
1051 if (open_file) {
1052 bytes_written = cifs_write(open_file->pfile, write_data,
1053 to-from, &offset);
23e7dd7d 1054 atomic_dec(&open_file->wrtPending);
1da177e4 1055 /* Does mm or vfs already set times? */
6148a742
SF		 1056 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1057 if ((bytes_written > 0) && (offset)) {
1058 rc = 0;
1059 } else if (bytes_written < 0) {
1060 if (rc != -EBADF)
1061 rc = bytes_written;
1da177e4 1062 }
6148a742 1063 } else {
1da177e4
LT		 1064 cFYI(1, ("No writeable filehandles for inode"));
1065 rc = -EIO;
1066 }
1067
1068 kunmap(page);
1069 return rc;
1070}
1071
1da177e4 1072static int cifs_writepages(struct address_space *mapping,
37c0eb46 1073 struct writeback_control *wbc)
1da177e4 1074{
37c0eb46
SF		 1075 struct backing_dev_info *bdi = mapping->backing_dev_info;
1076 unsigned int bytes_to_write;
1077 unsigned int bytes_written;
1078 struct cifs_sb_info *cifs_sb;
1079 int done = 0;
1080 pgoff_t end = -1;
1081 pgoff_t index;
1082 int is_range = 0;
1083 struct kvec iov[32];
84d2f07e 1084 int len;
37c0eb46
SF		 1085 int n_iov = 0;
1086 pgoff_t next;
1087 int nr_pages;
1088 __u64 offset = 0;
23e7dd7d 1089 struct cifsFileInfo *open_file;
37c0eb46
SF		 1090 struct page *page;
1091 struct pagevec pvec;
1092 int rc = 0;
1093 int scanned = 0;
1da177e4
LT		 1094 int xid;
1095
37c0eb46
SF		 1096 cifs_sb = CIFS_SB(mapping->host->i_sb);
1097
1098 /*
1099 * If wsize is smaller that the page cache size, default to writing
1100 * one page at a time via cifs_writepage
1101 */
1102 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1103 return generic_writepages(mapping, wbc);
1104
4a77118c
SF		 1105 if((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1106 if(cifs_sb->tcon->ses->server->secMode &
1107 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
60808233
SF		 1108 if(!experimEnabled)
1109 return generic_writepages(mapping, wbc);
4a77118c 1110
37c0eb46
SF		 1111 /*
1112 * BB: Is this meaningful for a non-block-device file system?
1113 * If it is, we should test it again after we do I/O
1114 */
1115 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1116 wbc->encountered_congestion = 1;
1117 return 0;
1118 }
1119
1da177e4
LT		 1120 xid = GetXid();
1121
37c0eb46
SF		 1122 pagevec_init(&pvec, 0);
1123 if (wbc->sync_mode == WB_SYNC_NONE)
1124 index = mapping->writeback_index; /* Start from prev offset */
1125 else {
1126 index = 0;
1127 scanned = 1;
1128 }
1129 if (wbc->start || wbc->end) {
1130 index = wbc->start >> PAGE_CACHE_SHIFT;
1131 end = wbc->end >> PAGE_CACHE_SHIFT;
1132 is_range = 1;
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
1168 if (unlikely(is_range) && (page->index > end)) {
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 }
1272 if (!is_range)
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 6.x block layer and io_uring tree(s)