projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[CIFS] Move noisy debug message (triggerred by some older servers) from
[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;
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
206 down(&inode->i_sb->s_vfs_rename_sem);
7f57356b 207 full_path = build_path_from_dentry(file->f_dentry);
1da177e4
LT		 208 up(&inode->i_sb->s_vfs_rename_sem);
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
SF		 651 if(experimEnabled &&
652 (cifs_sb->tcon->ses->capabilities & CAP_UNIX)) {
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 */,
659 length, pfLock->fl_start,
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
SF		 688 if (experimEnabled &&
689 (cifs_sb->tcon->ses->capabilities & CAP_UNIX)) {
690 int posix_lock_type;
691 if(lockType & LOCKING_ANDX_SHARED_LOCK)
692 posix_lock_type = CIFS_RDLCK;
693 else
694 posix_lock_type = CIFS_WRLCK;
695
696 if(numUnlock == 1)
697 posix_lock_type |= CIFS_UNLCK;
698 else if(numLock == 0) {
699 /* if no lock or unlock then nothing
700 to do since we do not know what it is */
701 FreeXid(xid);
702 return -EOPNOTSUPP;
703 }
704 rc = CIFSSMBPosixLock(xid, pTcon, netfid, 0 /* set */,
705 length, pfLock->fl_start,
706 posix_lock_type, wait_flag);
707 } else
708 rc = CIFSSMBLock(xid, pTcon, netfid, length, pfLock->fl_start,
709 numUnlock, numLock, lockType, wait_flag);
d634cc15 710 if (pfLock->fl_flags & FL_POSIX)
1da177e4
LT		 711 posix_lock_file_wait(file, pfLock);
712 FreeXid(xid);
713 return rc;
714}
715
716ssize_t cifs_user_write(struct file *file, const char __user *write_data,
717 size_t write_size, loff_t *poffset)
718{
719 int rc = 0;
720 unsigned int bytes_written = 0;
721 unsigned int total_written;
722 struct cifs_sb_info *cifs_sb;
723 struct cifsTconInfo *pTcon;
724 int xid, long_op;
725 struct cifsFileInfo *open_file;
726
727 if (file->f_dentry == NULL)
728 return -EBADF;
729
730 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
731 if (cifs_sb == NULL)
732 return -EBADF;
733
734 pTcon = cifs_sb->tcon;
735
736 /* cFYI(1,
737 (" write %d bytes to offset %lld of %s", write_size,
738 *poffset, file->f_dentry->d_name.name)); */
739
740 if (file->private_data == NULL)
741 return -EBADF;
742 else
743 open_file = (struct cifsFileInfo *) file->private_data;
744
745 xid = GetXid();
746 if (file->f_dentry->d_inode == NULL) {
747 FreeXid(xid);
748 return -EBADF;
749 }
750
751 if (*poffset > file->f_dentry->d_inode->i_size)
752 long_op = 2; /* writes past end of file can take a long time */
753 else
754 long_op = 1;
755
756 for (total_written = 0; write_size > total_written;
757 total_written += bytes_written) {
758 rc = -EAGAIN;
759 while (rc == -EAGAIN) {
760 if (file->private_data == NULL) {
761 /* file has been closed on us */
762 FreeXid(xid);
763 /* if we have gotten here we have written some data
764 and blocked, and the file has been freed on us while
765 we blocked so return what we managed to write */
766 return total_written;
767 }
768 if (open_file->closePend) {
769 FreeXid(xid);
770 if (total_written)
771 return total_written;
772 else
773 return -EBADF;
774 }
775 if (open_file->invalidHandle) {
776 if ((file->f_dentry == NULL) ||
777 (file->f_dentry->d_inode == NULL)) {
778 FreeXid(xid);
779 return total_written;
780 }
781 /* we could deadlock if we called
782 filemap_fdatawait from here so tell
783 reopen_file not to flush data to server
784 now */
785 rc = cifs_reopen_file(file->f_dentry->d_inode,
786 file, FALSE);
787 if (rc != 0)
788 break;
789 }
790
791 rc = CIFSSMBWrite(xid, pTcon,
792 open_file->netfid,
793 min_t(const int, cifs_sb->wsize,
794 write_size - total_written),
795 *poffset, &bytes_written,
796 NULL, write_data + total_written, long_op);
797 }
798 if (rc || (bytes_written == 0)) {
799 if (total_written)
800 break;
801 else {
802 FreeXid(xid);
803 return rc;
804 }
805 } else
806 *poffset += bytes_written;
807 long_op = FALSE; /* subsequent writes fast -
808 15 seconds is plenty */
809 }
810
a4544347 811 cifs_stats_bytes_written(pTcon, total_written);
1da177e4
LT		 812
813 /* since the write may have blocked check these pointers again */
814 if (file->f_dentry) {
815 if (file->f_dentry->d_inode) {
816 struct inode *inode = file->f_dentry->d_inode;
817 inode->i_ctime = inode->i_mtime =
818 current_fs_time(inode->i_sb);
819 if (total_written > 0) {
820 if (*poffset > file->f_dentry->d_inode->i_size)
821 i_size_write(file->f_dentry->d_inode,
822 *poffset);
823 }
824 mark_inode_dirty_sync(file->f_dentry->d_inode);
825 }
826 }
827 FreeXid(xid);
828 return total_written;
829}
830
831static ssize_t cifs_write(struct file *file, const char *write_data,
832 size_t write_size, loff_t *poffset)
833{
834 int rc = 0;
835 unsigned int bytes_written = 0;
836 unsigned int total_written;
837 struct cifs_sb_info *cifs_sb;
838 struct cifsTconInfo *pTcon;
839 int xid, long_op;
840 struct cifsFileInfo *open_file;
841
842 if (file->f_dentry == NULL)
843 return -EBADF;
844
845 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
846 if (cifs_sb == NULL)
847 return -EBADF;
848
849 pTcon = cifs_sb->tcon;
850
ab2f218f
SF		 851 cFYI(1,("write %zd bytes to offset %lld of %s", write_size,
852 *poffset, file->f_dentry->d_name.name));
1da177e4
LT		 853
854 if (file->private_data == NULL)
855 return -EBADF;
856 else
857 open_file = (struct cifsFileInfo *)file->private_data;
858
859 xid = GetXid();
860 if (file->f_dentry->d_inode == NULL) {
861 FreeXid(xid);
862 return -EBADF;
863 }
864
865 if (*poffset > file->f_dentry->d_inode->i_size)
866 long_op = 2; /* writes past end of file can take a long time */
867 else
868 long_op = 1;
869
870 for (total_written = 0; write_size > total_written;
871 total_written += bytes_written) {
872 rc = -EAGAIN;
873 while (rc == -EAGAIN) {
874 if (file->private_data == NULL) {
875 /* file has been closed on us */
876 FreeXid(xid);
877 /* if we have gotten here we have written some data
878 and blocked, and the file has been freed on us
879 while we blocked so return what we managed to
880 write */
881 return total_written;
882 }
883 if (open_file->closePend) {
884 FreeXid(xid);
885 if (total_written)
886 return total_written;
887 else
888 return -EBADF;
889 }
890 if (open_file->invalidHandle) {
891 if ((file->f_dentry == NULL) ||
892 (file->f_dentry->d_inode == NULL)) {
893 FreeXid(xid);
894 return total_written;
895 }
896 /* we could deadlock if we called
897 filemap_fdatawait from here so tell
898 reopen_file not to flush data to
899 server now */
900 rc = cifs_reopen_file(file->f_dentry->d_inode,
901 file, FALSE);
902 if (rc != 0)
903 break;
904 }
d6e04ae6 905 /* BB FIXME We can not sign across two buffers yet */
ec637e3f
SF		 906 if((pTcon->ses->server->secMode &
907 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED)) == 0) {
3e84469d
SF		 908 struct kvec iov[2];
909 unsigned int len;
910
0ae0efad 911 len = min((size_t)cifs_sb->wsize,
3e84469d
SF		 912 write_size - total_written);
913 /* iov[0] is reserved for smb header */
914 iov[1].iov_base = (char *)write_data +
915 total_written;
916 iov[1].iov_len = len;
d6e04ae6 917 rc = CIFSSMBWrite2(xid, pTcon,
3e84469d 918 open_file->netfid, len,
d6e04ae6 919 *poffset, &bytes_written,
3e84469d 920 iov, 1, long_op);
d6e04ae6
SF		 921 } else
922 /* BB FIXME fixup indentation of line below */
1da177e4
LT		 923 rc = CIFSSMBWrite(xid, pTcon,
924 open_file->netfid,
925 min_t(const int, cifs_sb->wsize,
926 write_size - total_written),
927 *poffset, &bytes_written,
928 write_data + total_written, NULL, long_op);
929 }
930 if (rc || (bytes_written == 0)) {
931 if (total_written)
932 break;
933 else {
934 FreeXid(xid);
935 return rc;
936 }
937 } else
938 *poffset += bytes_written;
939 long_op = FALSE; /* subsequent writes fast -
940 15 seconds is plenty */
941 }
942
a4544347 943 cifs_stats_bytes_written(pTcon, total_written);
1da177e4
LT		 944
945 /* since the write may have blocked check these pointers again */
946 if (file->f_dentry) {
947 if (file->f_dentry->d_inode) {
948 file->f_dentry->d_inode->i_ctime =
949 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
950 if (total_written > 0) {
951 if (*poffset > file->f_dentry->d_inode->i_size)
952 i_size_write(file->f_dentry->d_inode,
953 *poffset);
954 }
955 mark_inode_dirty_sync(file->f_dentry->d_inode);
956 }
957 }
958 FreeXid(xid);
959 return total_written;
960}
961
dd99cd80 962struct cifsFileInfo *find_writable_file(struct cifsInodeInfo *cifs_inode)
6148a742
SF		 963{
964 struct cifsFileInfo *open_file;
dd99cd80 965 int rc;
6148a742
SF		 966
967 read_lock(&GlobalSMBSeslock);
968 list_for_each_entry(open_file, &cifs_inode->openFileList, flist) {
969 if (open_file->closePend)
970 continue;
971 if (open_file->pfile &&
972 ((open_file->pfile->f_flags & O_RDWR) ||
973 (open_file->pfile->f_flags & O_WRONLY))) {
23e7dd7d 974 atomic_inc(&open_file->wrtPending);
6148a742 975 read_unlock(&GlobalSMBSeslock);
0ae0efad 976 if((open_file->invalidHandle) &&
23e7dd7d 977 (!open_file->closePend) /* BB fixme -since the second clause can not be true remove it BB */) {
dd99cd80 978 rc = cifs_reopen_file(&cifs_inode->vfs_inode,
37c0eb46
SF		 979 open_file->pfile, FALSE);
980 /* if it fails, try another handle - might be */
981 /* dangerous to hold up writepages with retry */
982 if(rc) {
4a77118c 983 cFYI(1,("failed on reopen file in wp"));
37c0eb46 984 read_lock(&GlobalSMBSeslock);
23e7dd7d
SF		 985 /* can not use this handle, no write
986 pending on this one after all */
987 atomic_dec
988 (&open_file->wrtPending);
37c0eb46
SF		 989 continue;
990 }
991 }
6148a742
SF		 992 return open_file;
993 }
994 }
995 read_unlock(&GlobalSMBSeslock);
996 return NULL;
997}
998
1da177e4
LT		 999static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
1000{
1001 struct address_space *mapping = page->mapping;
1002 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1003 char *write_data;
1004 int rc = -EFAULT;
1005 int bytes_written = 0;
1006 struct cifs_sb_info *cifs_sb;
1007 struct cifsTconInfo *pTcon;
1008 struct inode *inode;
6148a742 1009 struct cifsFileInfo *open_file;
1da177e4
LT		 1010
1011 if (!mapping || !mapping->host)
1012 return -EFAULT;
1013
1014 inode = page->mapping->host;
1015 cifs_sb = CIFS_SB(inode->i_sb);
1016 pTcon = cifs_sb->tcon;
1017
1018 offset += (loff_t)from;
1019 write_data = kmap(page);
1020 write_data += from;
1021
1022 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
1023 kunmap(page);
1024 return -EIO;
1025 }
1026
1027 /* racing with truncate? */
1028 if (offset > mapping->host->i_size) {
1029 kunmap(page);
1030 return 0; /* don't care */
1031 }
1032
1033 /* check to make sure that we are not extending the file */
1034 if (mapping->host->i_size - offset < (loff_t)to)
1035 to = (unsigned)(mapping->host->i_size - offset);
1036
6148a742
SF		 1037 open_file = find_writable_file(CIFS_I(mapping->host));
1038 if (open_file) {
1039 bytes_written = cifs_write(open_file->pfile, write_data,
1040 to-from, &offset);
23e7dd7d 1041 atomic_dec(&open_file->wrtPending);
1da177e4 1042 /* Does mm or vfs already set times? */
6148a742
SF		 1043 inode->i_atime = inode->i_mtime = current_fs_time(inode->i_sb);
1044 if ((bytes_written > 0) && (offset)) {
1045 rc = 0;
1046 } else if (bytes_written < 0) {
1047 if (rc != -EBADF)
1048 rc = bytes_written;
1da177e4 1049 }
6148a742 1050 } else {
1da177e4
LT		 1051 cFYI(1, ("No writeable filehandles for inode"));
1052 rc = -EIO;
1053 }
1054
1055 kunmap(page);
1056 return rc;
1057}
1058
1da177e4 1059static int cifs_writepages(struct address_space *mapping,
37c0eb46 1060 struct writeback_control *wbc)
1da177e4 1061{
37c0eb46
SF		 1062 struct backing_dev_info *bdi = mapping->backing_dev_info;
1063 unsigned int bytes_to_write;
1064 unsigned int bytes_written;
1065 struct cifs_sb_info *cifs_sb;
1066 int done = 0;
1067 pgoff_t end = -1;
1068 pgoff_t index;
1069 int is_range = 0;
1070 struct kvec iov[32];
84d2f07e 1071 int len;
37c0eb46
SF		 1072 int n_iov = 0;
1073 pgoff_t next;
1074 int nr_pages;
1075 __u64 offset = 0;
23e7dd7d 1076 struct cifsFileInfo *open_file;
37c0eb46
SF		 1077 struct page *page;
1078 struct pagevec pvec;
1079 int rc = 0;
1080 int scanned = 0;
1da177e4
LT		 1081 int xid;
1082
37c0eb46
SF		 1083 cifs_sb = CIFS_SB(mapping->host->i_sb);
1084
1085 /*
1086 * If wsize is smaller that the page cache size, default to writing
1087 * one page at a time via cifs_writepage
1088 */
1089 if (cifs_sb->wsize < PAGE_CACHE_SIZE)
1090 return generic_writepages(mapping, wbc);
1091
4a77118c
SF		 1092 /* BB FIXME we do not have code to sign across multiple buffers yet,
1093 so go to older writepage style write which we can sign if needed */
1094 if((cifs_sb->tcon->ses) && (cifs_sb->tcon->ses->server))
1095 if(cifs_sb->tcon->ses->server->secMode &
1096 (SECMODE_SIGN_REQUIRED | SECMODE_SIGN_ENABLED))
1097 return generic_writepages(mapping, wbc);
1098
37c0eb46
SF		 1099 /*
1100 * BB: Is this meaningful for a non-block-device file system?
1101 * If it is, we should test it again after we do I/O
1102 */
1103 if (wbc->nonblocking && bdi_write_congested(bdi)) {
1104 wbc->encountered_congestion = 1;
1105 return 0;
1106 }
1107
1da177e4
LT		 1108 xid = GetXid();
1109
37c0eb46
SF		 1110 pagevec_init(&pvec, 0);
1111 if (wbc->sync_mode == WB_SYNC_NONE)
1112 index = mapping->writeback_index; /* Start from prev offset */
1113 else {
1114 index = 0;
1115 scanned = 1;
1116 }
1117 if (wbc->start || wbc->end) {
1118 index = wbc->start >> PAGE_CACHE_SHIFT;
1119 end = wbc->end >> PAGE_CACHE_SHIFT;
1120 is_range = 1;
1121 scanned = 1;
1122 }
1123retry:
1124 while (!done && (index <= end) &&
1125 (nr_pages = pagevec_lookup_tag(&pvec, mapping, &index,
1126 PAGECACHE_TAG_DIRTY,
1127 min(end - index, (pgoff_t)PAGEVEC_SIZE - 1) + 1))) {
1128 int first;
1129 unsigned int i;
1130
37c0eb46
SF		 1131 first = -1;
1132 next = 0;
1133 n_iov = 0;
1134 bytes_to_write = 0;
1135
1136 for (i = 0; i < nr_pages; i++) {
1137 page = pvec.pages[i];
1138 /*
1139 * At this point we hold neither mapping->tree_lock nor
1140 * lock on the page itself: the page may be truncated or
1141 * invalidated (changing page->mapping to NULL), or even
1142 * swizzled back from swapper_space to tmpfs file
1143 * mapping
1144 */
1145
1146 if (first < 0)
1147 lock_page(page);
1148 else if (TestSetPageLocked(page))
1149 break;
1150
1151 if (unlikely(page->mapping != mapping)) {
1152 unlock_page(page);
1153 break;
1154 }
1155
1156 if (unlikely(is_range) && (page->index > end)) {
1157 done = 1;
1158 unlock_page(page);
1159 break;
1160 }
1161
1162 if (next && (page->index != next)) {
1163 /* Not next consecutive page */
1164 unlock_page(page);
1165 break;
1166 }
1167
1168 if (wbc->sync_mode != WB_SYNC_NONE)
1169 wait_on_page_writeback(page);
1170
1171 if (PageWriteback(page) ||
1172 !test_clear_page_dirty(page)) {
1173 unlock_page(page);
1174 break;
1175 }
84d2f07e
SF		 1176
1177 if (page_offset(page) >= mapping->host->i_size) {
1178 done = 1;
1179 unlock_page(page);
1180 break;
1181 }
1182
37c0eb46
SF		 1183 /*
1184 * BB can we get rid of this? pages are held by pvec
1185 */
1186 page_cache_get(page);
1187
84d2f07e
SF		 1188 len = min(mapping->host->i_size - page_offset(page),
1189 (loff_t)PAGE_CACHE_SIZE);
1190
37c0eb46
SF		 1191 /* reserve iov[0] for the smb header */
1192 n_iov++;
1193 iov[n_iov].iov_base = kmap(page);
84d2f07e
SF		 1194 iov[n_iov].iov_len = len;
1195 bytes_to_write += len;
37c0eb46
SF		 1196
1197 if (first < 0) {
1198 first = i;
1199 offset = page_offset(page);
1200 }
1201 next = page->index + 1;
1202 if (bytes_to_write + PAGE_CACHE_SIZE > cifs_sb->wsize)
1203 break;
1204 }
1205 if (n_iov) {
23e7dd7d
SF		 1206 /* Search for a writable handle every time we call
1207 * CIFSSMBWrite2. We can't rely on the last handle
1208 * we used to still be valid
1209 */
1210 open_file = find_writable_file(CIFS_I(mapping->host));
1211 if (!open_file) {
1212 cERROR(1, ("No writable handles for inode"));
1213 rc = -EBADF;
1047abc1 1214 } else {
23e7dd7d
SF		 1215 rc = CIFSSMBWrite2(xid, cifs_sb->tcon,
1216 open_file->netfid,
1217 bytes_to_write, offset,
1218 &bytes_written, iov, n_iov,
1219 1);
1220 atomic_dec(&open_file->wrtPending);
1221 if (rc || bytes_written < bytes_to_write) {
1222 cERROR(1,("Write2 ret %d, written = %d",
1223 rc, bytes_written));
1224 /* BB what if continued retry is
1225 requested via mount flags? */
1226 set_bit(AS_EIO, &mapping->flags);
23e7dd7d
SF		 1227 } else {
1228 cifs_stats_bytes_written(cifs_sb->tcon,
1229 bytes_written);
1230 }
37c0eb46
SF		 1231 }
1232 for (i = 0; i < n_iov; i++) {
1233 page = pvec.pages[first + i];
eb9bdaa3
SF		 1234 /* Should we also set page error on
1235 success rc but too little data written? */
1236 /* BB investigate retry logic on temporary
1237 server crash cases and how recovery works
1238 when page marked as error */
1239 if(rc)
1240 SetPageError(page);
37c0eb46
SF		 1241 kunmap(page);
1242 unlock_page(page);
1243 page_cache_release(page);
1244 }
1245 if ((wbc->nr_to_write -= n_iov) <= 0)
1246 done = 1;
1247 index = next;
1248 }
1249 pagevec_release(&pvec);
1250 }
1251 if (!scanned && !done) {
1252 /*
1253 * We hit the last page and there is more work to be done: wrap
1254 * back to the start of the file
1255 */
1256 scanned = 1;
1257 index = 0;
1258 goto retry;
1259 }
1260 if (!is_range)
1261 mapping->writeback_index = index;
1262
1da177e4 1263 FreeXid(xid);
37c0eb46 1264
1da177e4
LT		 1265 return rc;
1266}
1da177e4
LT		 1267
1268static int cifs_writepage(struct page* page, struct writeback_control *wbc)
1269{
1270 int rc = -EFAULT;
1271 int xid;
1272
1273 xid = GetXid();
1274/* BB add check for wbc flags */
1275 page_cache_get(page);
1276 if (!PageUptodate(page)) {
1277 cFYI(1, ("ppw - page not up to date"));
1278 }
1279
1280 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1281 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1282 unlock_page(page);
1283 page_cache_release(page);
1284 FreeXid(xid);
1285 return rc;
1286}
1287
1288static int cifs_commit_write(struct file *file, struct page *page,
1289 unsigned offset, unsigned to)
1290{
1291 int xid;
1292 int rc = 0;
1293 struct inode *inode = page->mapping->host;
1294 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1295 char *page_data;
1296
1297 xid = GetXid();
1298 cFYI(1, ("commit write for page %p up to position %lld for %d",
1299 page, position, to));
1300 if (position > inode->i_size) {
1301 i_size_write(inode, position);
1302 /* if (file->private_data == NULL) {
1303 rc = -EBADF;
1304 } else {
1305 open_file = (struct cifsFileInfo *)file->private_data;
1306 cifs_sb = CIFS_SB(inode->i_sb);
1307 rc = -EAGAIN;
1308 while (rc == -EAGAIN) {
1309 if ((open_file->invalidHandle) &&
1310 (!open_file->closePend)) {
1311 rc = cifs_reopen_file(
1312 file->f_dentry->d_inode, file);
1313 if (rc != 0)
1314 break;
1315 }
1316 if (!open_file->closePend) {
1317 rc = CIFSSMBSetFileSize(xid,
1318 cifs_sb->tcon, position,
1319 open_file->netfid,
1320 open_file->pid, FALSE);
1321 } else {
1322 rc = -EBADF;
1323 break;
1324 }
1325 }
1326 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1327 } */
1328 }
1329 if (!PageUptodate(page)) {
1330 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1331 /* can not rely on (or let) writepage write this data */
1332 if (to < offset) {
1333 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1334 offset, to));
1335 FreeXid(xid);
1336 return rc;
1337 }
1338 /* this is probably better than directly calling
1339 partialpage_write since in this function the file handle is
1340 known which we might as well leverage */
1341 /* BB check if anything else missing out of ppw
1342 such as updating last write time */
1343 page_data = kmap(page);
1344 rc = cifs_write(file, page_data + offset, to-offset,
1345 &position);
1346 if (rc > 0)
1347 rc = 0;
1348 /* else if (rc < 0) should we set writebehind rc? */
1349 kunmap(page);
1350 } else {
1351 set_page_dirty(page);
1352 }
1353
1354 FreeXid(xid);
1355 return rc;
1356}
1357
1358int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1359{
1360 int xid;
1361 int rc = 0;
1362 struct inode *inode = file->f_dentry->d_inode;
1363
1364 xid = GetXid();
1365
1366 cFYI(1, ("Sync file - name: %s datasync: 0x%x ",
1367 dentry->d_name.name, datasync));
1368
1369 rc = filemap_fdatawrite(inode->i_mapping);
1370 if (rc == 0)
1371 CIFS_I(inode)->write_behind_rc = 0;
1372 FreeXid(xid);
1373 return rc;
1374}
1375
1376/* static int cifs_sync_page(struct page *page)
1377{
1378 struct address_space *mapping;
1379 struct inode *inode;
1380 unsigned long index = page->index;
1381 unsigned int rpages = 0;
1382 int rc = 0;
1383
1384 cFYI(1, ("sync page %p",page));
1385 mapping = page->mapping;
1386 if (!mapping)
1387 return 0;
1388 inode = mapping->host;
1389 if (!inode)
1390 return 0; */
1391
1392/* fill in rpages then
1393 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1394
1395/* cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
1396
1397 if (rc < 0)
1398 return rc;
1399 return 0;
1400} */
1401
1402/*
1403 * As file closes, flush all cached write data for this inode checking
1404 * for write behind errors.
1405 */
1406int cifs_flush(struct file *file)
1407{
1408 struct inode * inode = file->f_dentry->d_inode;
1409 int rc = 0;
1410
1411 /* Rather than do the steps manually:
1412 lock the inode for writing
1413 loop through pages looking for write behind data (dirty pages)
1414 coalesce into contiguous 16K (or smaller) chunks to write to server
1415 send to server (prefer in parallel)
1416 deal with writebehind errors
1417 unlock inode for writing
1418 filemapfdatawrite appears easier for the time being */
1419
1420 rc = filemap_fdatawrite(inode->i_mapping);
1421 if (!rc) /* reset wb rc if we were able to write out dirty pages */
1422 CIFS_I(inode)->write_behind_rc = 0;
1423
1424 cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
1425
1426 return rc;
1427}
1428
1429ssize_t cifs_user_read(struct file *file, char __user *read_data,
1430 size_t read_size, loff_t *poffset)
1431{
1432 int rc = -EACCES;
1433 unsigned int bytes_read = 0;
1434 unsigned int total_read = 0;
1435 unsigned int current_read_size;
1436 struct cifs_sb_info *cifs_sb;
1437 struct cifsTconInfo *pTcon;
1438 int xid;
1439 struct cifsFileInfo *open_file;
1440 char *smb_read_data;
1441 char __user *current_offset;
1442 struct smb_com_read_rsp *pSMBr;
1443
1444 xid = GetXid();
1445 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1446 pTcon = cifs_sb->tcon;
1447
1448 if (file->private_data == NULL) {
1449 FreeXid(xid);
1450 return -EBADF;
1451 }
1452 open_file = (struct cifsFileInfo *)file->private_data;
1453
1454 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1455 cFYI(1, ("attempting read on write only file instance"));
1456 }
1457 for (total_read = 0, current_offset = read_data;
1458 read_size > total_read;
1459 total_read += bytes_read, current_offset += bytes_read) {
1460 current_read_size = min_t(const int, read_size - total_read,
1461 cifs_sb->rsize);
1462 rc = -EAGAIN;
1463 smb_read_data = NULL;
1464 while (rc == -EAGAIN) {
ec637e3f 1465 int buf_type = CIFS_NO_BUFFER;
1da177e4
LT		 1466 if ((open_file->invalidHandle) &&
1467 (!open_file->closePend)) {
1468 rc = cifs_reopen_file(file->f_dentry->d_inode,
1469 file, TRUE);
1470 if (rc != 0)
1471 break;
1472 }
bfa0d75a 1473 rc = CIFSSMBRead(xid, pTcon,
ec637e3f
SF		 1474 open_file->netfid,
1475 current_read_size, *poffset,
1476 &bytes_read, &smb_read_data,
1477 &buf_type);
1da177e4 1478 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1da177e4 1479 if (smb_read_data) {
93544cc6
SF		 1480 if (copy_to_user(current_offset,
1481 smb_read_data +
1482 4 /* RFC1001 length field */ +
1483 le16_to_cpu(pSMBr->DataOffset),
1484 bytes_read)) {
1485 rc = -EFAULT;
1486 }
1487
ec637e3f
SF		 1488 if(buf_type == CIFS_SMALL_BUFFER)
1489 cifs_small_buf_release(smb_read_data);
1490 else if(buf_type == CIFS_LARGE_BUFFER)
1491 cifs_buf_release(smb_read_data);
1da177e4
LT		 1492 smb_read_data = NULL;
1493 }
1494 }
1495 if (rc || (bytes_read == 0)) {
1496 if (total_read) {
1497 break;
1498 } else {
1499 FreeXid(xid);
1500 return rc;
1501 }
1502 } else {
a4544347 1503 cifs_stats_bytes_read(pTcon, bytes_read);
1da177e4
LT		 1504 *poffset += bytes_read;
1505 }
1506 }
1507 FreeXid(xid);
1508 return total_read;
1509}
1510
1511
1512static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1513 loff_t *poffset)
1514{
1515 int rc = -EACCES;
1516 unsigned int bytes_read = 0;
1517 unsigned int total_read;
1518 unsigned int current_read_size;
1519 struct cifs_sb_info *cifs_sb;
1520 struct cifsTconInfo *pTcon;
1521 int xid;
1522 char *current_offset;
1523 struct cifsFileInfo *open_file;
ec637e3f 1524 int buf_type = CIFS_NO_BUFFER;
1da177e4
LT		 1525
1526 xid = GetXid();
1527 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1528 pTcon = cifs_sb->tcon;
1529
1530 if (file->private_data == NULL) {
1531 FreeXid(xid);
1532 return -EBADF;
1533 }
1534 open_file = (struct cifsFileInfo *)file->private_data;
1535
1536 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1537 cFYI(1, ("attempting read on write only file instance"));
1538
1539 for (total_read = 0, current_offset = read_data;
1540 read_size > total_read;
1541 total_read += bytes_read, current_offset += bytes_read) {
1542 current_read_size = min_t(const int, read_size - total_read,
1543 cifs_sb->rsize);
f9f5c817
SF		 1544 /* For windows me and 9x we do not want to request more
1545 than it negotiated since it will refuse the read then */
1546 if((pTcon->ses) &&
1547 !(pTcon->ses->capabilities & CAP_LARGE_FILES)) {
1548 current_read_size = min_t(const int, current_read_size,
1549 pTcon->ses->server->maxBuf - 128);
1550 }
1da177e4
LT		 1551 rc = -EAGAIN;
1552 while (rc == -EAGAIN) {
1553 if ((open_file->invalidHandle) &&
1554 (!open_file->closePend)) {
1555 rc = cifs_reopen_file(file->f_dentry->d_inode,
1556 file, TRUE);
1557 if (rc != 0)
1558 break;
1559 }
bfa0d75a 1560 rc = CIFSSMBRead(xid, pTcon,
ec637e3f
SF		 1561 open_file->netfid,
1562 current_read_size, *poffset,
1563 &bytes_read, &current_offset,
1564 &buf_type);
1da177e4
LT		 1565 }
1566 if (rc || (bytes_read == 0)) {
1567 if (total_read) {
1568 break;
1569 } else {
1570 FreeXid(xid);
1571 return rc;
1572 }
1573 } else {
a4544347 1574 cifs_stats_bytes_read(pTcon, total_read);
1da177e4
LT		 1575 *poffset += bytes_read;
1576 }
1577 }
1578 FreeXid(xid);
1579 return total_read;
1580}
1581
1582int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1583{
1584 struct dentry *dentry = file->f_dentry;
1585 int rc, xid;
1586
1587 xid = GetXid();
1588 rc = cifs_revalidate(dentry);
1589 if (rc) {
1590 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1591 FreeXid(xid);
1592 return rc;
1593 }
1594 rc = generic_file_mmap(file, vma);
1595 FreeXid(xid);
1596 return rc;
1597}
1598
1599
1600static void cifs_copy_cache_pages(struct address_space *mapping,
1601 struct list_head *pages, int bytes_read, char *data,
1602 struct pagevec *plru_pvec)
1603{
1604 struct page *page;
1605 char *target;
1606
1607 while (bytes_read > 0) {
1608 if (list_empty(pages))
1609 break;
1610
1611 page = list_entry(pages->prev, struct page, lru);
1612 list_del(&page->lru);
1613
1614 if (add_to_page_cache(page, mapping, page->index,
1615 GFP_KERNEL)) {
1616 page_cache_release(page);
1617 cFYI(1, ("Add page cache failed"));
3079ca62
SF		 1618 data += PAGE_CACHE_SIZE;
1619 bytes_read -= PAGE_CACHE_SIZE;
1da177e4
LT		 1620 continue;
1621 }
1622
1623 target = kmap_atomic(page,KM_USER0);
1624
1625 if (PAGE_CACHE_SIZE > bytes_read) {
1626 memcpy(target, data, bytes_read);
1627 /* zero the tail end of this partial page */
1628 memset(target + bytes_read, 0,
1629 PAGE_CACHE_SIZE - bytes_read);
1630 bytes_read = 0;
1631 } else {
1632 memcpy(target, data, PAGE_CACHE_SIZE);
1633 bytes_read -= PAGE_CACHE_SIZE;
1634 }
1635 kunmap_atomic(target, KM_USER0);
1636
1637 flush_dcache_page(page);
1638 SetPageUptodate(page);
1639 unlock_page(page);
1640 if (!pagevec_add(plru_pvec, page))
1641 __pagevec_lru_add(plru_pvec);
1642 data += PAGE_CACHE_SIZE;
1643 }
1644 return;
1645}
1646
1647static int cifs_readpages(struct file *file, struct address_space *mapping,
1648 struct list_head *page_list, unsigned num_pages)
1649{
1650 int rc = -EACCES;
1651 int xid;
1652 loff_t offset;
1653 struct page *page;
1654 struct cifs_sb_info *cifs_sb;
1655 struct cifsTconInfo *pTcon;
1656 int bytes_read = 0;
1657 unsigned int read_size,i;
1658 char *smb_read_data = NULL;
1659 struct smb_com_read_rsp *pSMBr;
1660 struct pagevec lru_pvec;
1661 struct cifsFileInfo *open_file;
ec637e3f 1662 int buf_type = CIFS_NO_BUFFER;
1da177e4
LT		 1663
1664 xid = GetXid();
1665 if (file->private_data == NULL) {
1666 FreeXid(xid);
1667 return -EBADF;
1668 }
1669 open_file = (struct cifsFileInfo *)file->private_data;
1670 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1671 pTcon = cifs_sb->tcon;
bfa0d75a 1672
1da177e4
LT		 1673 pagevec_init(&lru_pvec, 0);
1674
1675 for (i = 0; i < num_pages; ) {
1676 unsigned contig_pages;
1677 struct page *tmp_page;
1678 unsigned long expected_index;
1679
1680 if (list_empty(page_list))
1681 break;
1682
1683 page = list_entry(page_list->prev, struct page, lru);
1684 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1685
1686 /* count adjacent pages that we will read into */
1687 contig_pages = 0;
1688 expected_index =
1689 list_entry(page_list->prev, struct page, lru)->index;
1690 list_for_each_entry_reverse(tmp_page,page_list,lru) {
1691 if (tmp_page->index == expected_index) {
1692 contig_pages++;
1693 expected_index++;
1694 } else
1695 break;
1696 }
1697 if (contig_pages + i > num_pages)
1698 contig_pages = num_pages - i;
1699
1700 /* for reads over a certain size could initiate async
1701 read ahead */
1702
1703 read_size = contig_pages * PAGE_CACHE_SIZE;
1704 /* Read size needs to be in multiples of one page */
1705 read_size = min_t(const unsigned int, read_size,
1706 cifs_sb->rsize & PAGE_CACHE_MASK);
1707
1708 rc = -EAGAIN;
1709 while (rc == -EAGAIN) {
1710 if ((open_file->invalidHandle) &&
1711 (!open_file->closePend)) {
1712 rc = cifs_reopen_file(file->f_dentry->d_inode,
1713 file, TRUE);
1714 if (rc != 0)
1715 break;
1716 }
1717
bfa0d75a 1718 rc = CIFSSMBRead(xid, pTcon,
ec637e3f
SF		 1719 open_file->netfid,
1720 read_size, offset,
1721 &bytes_read, &smb_read_data,
1722 &buf_type);
a9d02ad4 1723 /* BB more RC checks ? */
1da177e4
LT		 1724 if (rc== -EAGAIN) {
1725 if (smb_read_data) {
ec637e3f
SF		 1726 if(buf_type == CIFS_SMALL_BUFFER)
1727 cifs_small_buf_release(smb_read_data);
1728 else if(buf_type == CIFS_LARGE_BUFFER)
1729 cifs_buf_release(smb_read_data);
1da177e4
LT		 1730 smb_read_data = NULL;
1731 }
1732 }
1733 }
1734 if ((rc < 0) || (smb_read_data == NULL)) {
1735 cFYI(1, ("Read error in readpages: %d", rc));
1736 /* clean up remaing pages off list */
1737 while (!list_empty(page_list) && (i < num_pages)) {
1738 page = list_entry(page_list->prev, struct page,
1739 lru);
1740 list_del(&page->lru);
1741 page_cache_release(page);
1742 }
1743 break;
1744 } else if (bytes_read > 0) {
1745 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1746 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1747 smb_read_data + 4 /* RFC1001 hdr */ +
1748 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1749
1750 i += bytes_read >> PAGE_CACHE_SHIFT;
a4544347 1751 cifs_stats_bytes_read(pTcon, bytes_read);
1da177e4
LT		 1752 if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1753 i++; /* account for partial page */
1754
1755 /* server copy of file can have smaller size
1756 than client */
1757 /* BB do we need to verify this common case ?
1758 this case is ok - if we are at server EOF
1759 we will hit it on next read */
1760
1761 /* while (!list_empty(page_list) && (i < num_pages)) {
1762 page = list_entry(page_list->prev,
1763 struct page, list);
1764 list_del(&page->list);
1765 page_cache_release(page);
1766 }
1767 break; */
1768 }
1769 } else {
1770 cFYI(1, ("No bytes read (%d) at offset %lld . "
1771 "Cleaning remaining pages from readahead list",
1772 bytes_read, offset));
1773 /* BB turn off caching and do new lookup on
1774 file size at server? */
1775 while (!list_empty(page_list) && (i < num_pages)) {
1776 page = list_entry(page_list->prev, struct page,
1777 lru);
1778 list_del(&page->lru);
1779
1780 /* BB removeme - replace with zero of page? */
1781 page_cache_release(page);
1782 }
1783 break;
1784 }
1785 if (smb_read_data) {
ec637e3f
SF		 1786 if(buf_type == CIFS_SMALL_BUFFER)
1787 cifs_small_buf_release(smb_read_data);
1788 else if(buf_type == CIFS_LARGE_BUFFER)
1789 cifs_buf_release(smb_read_data);
1da177e4
LT		 1790 smb_read_data = NULL;
1791 }
1792 bytes_read = 0;
1793 }
1794
1795 pagevec_lru_add(&lru_pvec);
1796
1797/* need to free smb_read_data buf before exit */
1798 if (smb_read_data) {
47c886b3
SF		 1799 if(buf_type == CIFS_SMALL_BUFFER)
1800 cifs_small_buf_release(smb_read_data);
1801 else if(buf_type == CIFS_LARGE_BUFFER)
1802 cifs_buf_release(smb_read_data);
1da177e4
LT		 1803 smb_read_data = NULL;
1804 }
1805
1806 FreeXid(xid);
1807 return rc;
1808}
1809
1810static int cifs_readpage_worker(struct file *file, struct page *page,
1811 loff_t *poffset)
1812{
1813 char *read_data;
1814 int rc;
1815
1816 page_cache_get(page);
1817 read_data = kmap(page);
1818 /* for reads over a certain size could initiate async read ahead */
1819
1820 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1821
1822 if (rc < 0)
1823 goto io_error;
1824 else
1825 cFYI(1, ("Bytes read %d ",rc));
1826
1827 file->f_dentry->d_inode->i_atime =
1828 current_fs_time(file->f_dentry->d_inode->i_sb);
1829
1830 if (PAGE_CACHE_SIZE > rc)
1831 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1832
1833 flush_dcache_page(page);
1834 SetPageUptodate(page);
1835 rc = 0;
1836
1837io_error:
1838 kunmap(page);
1839 page_cache_release(page);
1840 return rc;
1841}
1842
1843static int cifs_readpage(struct file *file, struct page *page)
1844{
1845 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1846 int rc = -EACCES;
1847 int xid;
1848
1849 xid = GetXid();
1850
1851 if (file->private_data == NULL) {
1852 FreeXid(xid);
1853 return -EBADF;
1854 }
1855
1856 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1857 page, (int)offset, (int)offset));
1858
1859 rc = cifs_readpage_worker(file, page, &offset);
1860
1861 unlock_page(page);
1862
1863 FreeXid(xid);
1864 return rc;
1865}
1866
1867/* We do not want to update the file size from server for inodes
1868 open for write - to avoid races with writepage extending
1869 the file - in the future we could consider allowing
1870 refreshing the inode only on increases in the file size
1871 but this is tricky to do without racing with writebehind
1872 page caching in the current Linux kernel design */
1873int is_size_safe_to_change(struct cifsInodeInfo *cifsInode)
1874{
23e7dd7d
SF		 1875 struct cifsFileInfo *open_file = NULL;
1876
1877 if (cifsInode)
1878 open_file = find_writable_file(cifsInode);
1879
1880 if(open_file) {
c32a0b68
SF		 1881 struct cifs_sb_info *cifs_sb;
1882
23e7dd7d
SF		 1883 /* there is not actually a write pending so let
1884 this handle go free and allow it to
1885 be closable if needed */
1886 atomic_dec(&open_file->wrtPending);
c32a0b68
SF		 1887
1888 cifs_sb = CIFS_SB(cifsInode->vfs_inode.i_sb);
1889 if ( cifs_sb->mnt_cifs_flags & CIFS_MOUNT_DIRECT_IO ) {
1890 /* since no page cache to corrupt on directio
1891 we can change size safely */
1892 return 1;
1893 }
1894
6148a742 1895 return 0;
23e7dd7d 1896 } else
6148a742 1897 return 1;
1da177e4
LT		 1898}
1899
1da177e4
LT		 1900static int cifs_prepare_write(struct file *file, struct page *page,
1901 unsigned from, unsigned to)
1902{
1903 int rc = 0;
1904 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1905 cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
1906 if (!PageUptodate(page)) {
1907 /* if (to - from != PAGE_CACHE_SIZE) {
1908 void *kaddr = kmap_atomic(page, KM_USER0);
1909 memset(kaddr, 0, from);
1910 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
1911 flush_dcache_page(page);
1912 kunmap_atomic(kaddr, KM_USER0);
1913 } */
1914 /* If we are writing a full page it will be up to date,
1915 no need to read from the server */
1916 if ((to == PAGE_CACHE_SIZE) && (from == 0))
1917 SetPageUptodate(page);
1918
1919 /* might as well read a page, it is fast enough */
1920 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
1921 rc = cifs_readpage_worker(file, page, &offset);
1922 } else {
1923 /* should we try using another file handle if there is one -
1924 how would we lock it to prevent close of that handle
1925 racing with this read?
1926 In any case this will be written out by commit_write */
1927 }
1928 }
1929
1930 /* BB should we pass any errors back?
1931 e.g. if we do not have read access to the file */
1932 return 0;
1933}
1934
1935struct address_space_operations cifs_addr_ops = {
1936 .readpage = cifs_readpage,
1937 .readpages = cifs_readpages,
1938 .writepage = cifs_writepage,
37c0eb46 1939 .writepages = cifs_writepages,
1da177e4
LT		 1940 .prepare_write = cifs_prepare_write,
1941 .commit_write = cifs_commit_write,
1942 .set_page_dirty = __set_page_dirty_nobuffers,
1943 /* .sync_page = cifs_sync_page, */
1944 /* .direct_IO = */
1945};
Linux kernel - Deliverables
This page took 0.384219 seconds and 5 git commands to generate.