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