?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Automatic merge of rsync://rsync.kernel.org/pub/scm/linux/kernel/git/gregkh/driver...
[linux-2.6/verdex.git] / fs / cifs / file.c
blobdde2d251fc3d6b0d387559bf5c590ede89bcf80a
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/stat.h>
25 #include <linux/fcntl.h>
26 #include <linux/pagemap.h>
27 #include <linux/pagevec.h>
28 #include <linux/smp_lock.h>
29 #include <asm/div64.h>
30 #include "cifsfs.h"
31 #include "cifspdu.h"
32 #include "cifsglob.h"
33 #include "cifsproto.h"
34 #include "cifs_unicode.h"
35 #include "cifs_debug.h"
36 #include "cifs_fs_sb.h"
37
38 static inline struct cifsFileInfo *cifs_init_private(
39 struct cifsFileInfo *private_data, struct inode *inode,
40 struct file *file, __u16 netfid)
41 {
42 memset(private_data, 0, sizeof(struct cifsFileInfo));
43 private_data->netfid = netfid;
44 private_data->pid = current->tgid;
45 init_MUTEX(&private_data->fh_sem);
46 private_data->pfile = file; /* needed for writepage */
47 private_data->pInode = inode;
48 private_data->invalidHandle = FALSE;
49 private_data->closePend = FALSE;
50
51 return private_data;
52 }
53
54 static inline int cifs_convert_flags(unsigned int flags)
55 {
56 if ((flags & O_ACCMODE) == O_RDONLY)
57 return GENERIC_READ;
58 else if ((flags & O_ACCMODE) == O_WRONLY)
59 return GENERIC_WRITE;
60 else if ((flags & O_ACCMODE) == O_RDWR) {
61 /* GENERIC_ALL is too much permission to request
62 can cause unnecessary access denied on create */
63 /* return GENERIC_ALL; */
64 return (GENERIC_READ | GENERIC_WRITE);
65 }
66
67 return 0x20197;
68 }
69
70 static inline int cifs_get_disposition(unsigned int flags)
71 {
72 if ((flags & (O_CREAT | O_EXCL)) == (O_CREAT | O_EXCL))
73 return FILE_CREATE;
74 else if ((flags & (O_CREAT | O_TRUNC)) == (O_CREAT | O_TRUNC))
75 return FILE_OVERWRITE_IF;
76 else if ((flags & O_CREAT) == O_CREAT)
77 return FILE_OPEN_IF;
78 else
79 return FILE_OPEN;
80 }
81
82 /* all arguments to this function must be checked for validity in caller */
83 static inline int cifs_open_inode_helper(struct inode *inode, struct file *file,
84 struct cifsInodeInfo *pCifsInode, struct cifsFileInfo *pCifsFile,
85 struct cifsTconInfo *pTcon, int *oplock, FILE_ALL_INFO *buf,
86 char *full_path, int xid)
87 {
88 struct timespec temp;
89 int rc;
90
91 /* want handles we can use to read with first
92 in the list so we do not have to walk the
93 list to search for one in prepare_write */
94 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
95 list_add_tail(&pCifsFile->flist,
96 &pCifsInode->openFileList);
97 } else {
98 list_add(&pCifsFile->flist,
99 &pCifsInode->openFileList);
100 }
101 write_unlock(&GlobalSMBSeslock);
102 write_unlock(&file->f_owner.lock);
103 if (pCifsInode->clientCanCacheRead) {
104 /* we have the inode open somewhere else
105 no need to discard cache data */
106 goto client_can_cache;
107 }
108
109 /* BB need same check in cifs_create too? */
110 /* if not oplocked, invalidate inode pages if mtime or file
111 size changed */
112 temp = cifs_NTtimeToUnix(le64_to_cpu(buf->LastWriteTime));
113 if (timespec_equal(&file->f_dentry->d_inode->i_mtime, &temp) &&
114 (file->f_dentry->d_inode->i_size ==
115 (loff_t)le64_to_cpu(buf->EndOfFile))) {
116 cFYI(1, ("inode unchanged on server"));
117 } else {
118 if (file->f_dentry->d_inode->i_mapping) {
119 /* BB no need to lock inode until after invalidate
120 since namei code should already have it locked? */
121 filemap_fdatawrite(file->f_dentry->d_inode->i_mapping);
122 filemap_fdatawait(file->f_dentry->d_inode->i_mapping);
123 }
124 cFYI(1, ("invalidating remote inode since open detected it "
125 "changed"));
126 invalidate_remote_inode(file->f_dentry->d_inode);
127 }
128
129 client_can_cache:
130 if (pTcon->ses->capabilities & CAP_UNIX)
131 rc = cifs_get_inode_info_unix(&file->f_dentry->d_inode,
132 full_path, inode->i_sb, xid);
133 else
134 rc = cifs_get_inode_info(&file->f_dentry->d_inode,
135 full_path, buf, inode->i_sb, xid);
136
137 if ((*oplock & 0xF) == OPLOCK_EXCLUSIVE) {
138 pCifsInode->clientCanCacheAll = TRUE;
139 pCifsInode->clientCanCacheRead = TRUE;
140 cFYI(1, ("Exclusive Oplock granted on inode %p",
141 file->f_dentry->d_inode));
142 } else if ((*oplock & 0xF) == OPLOCK_READ)
143 pCifsInode->clientCanCacheRead = TRUE;
144
145 return rc;
146 }
147
148 int cifs_open(struct inode *inode, struct file *file)
149 {
150 int rc = -EACCES;
151 int xid, oplock;
152 struct cifs_sb_info *cifs_sb;
153 struct cifsTconInfo *pTcon;
154 struct cifsFileInfo *pCifsFile;
155 struct cifsInodeInfo *pCifsInode;
156 struct list_head *tmp;
157 char *full_path = NULL;
158 int desiredAccess;
159 int disposition;
160 __u16 netfid;
161 FILE_ALL_INFO *buf = NULL;
162
163 xid = GetXid();
164
165 cifs_sb = CIFS_SB(inode->i_sb);
166 pTcon = cifs_sb->tcon;
167
168 if (file->f_flags & O_CREAT) {
169 /* search inode for this file and fill in file->private_data */
170 pCifsInode = CIFS_I(file->f_dentry->d_inode);
171 read_lock(&GlobalSMBSeslock);
172 list_for_each(tmp, &pCifsInode->openFileList) {
173 pCifsFile = list_entry(tmp, struct cifsFileInfo,
174 flist);
175 if ((pCifsFile->pfile == NULL) &&
176 (pCifsFile->pid == current->tgid)) {
177 /* mode set in cifs_create */
178
179 /* needed for writepage */
180 pCifsFile->pfile = file;
181
182 file->private_data = pCifsFile;
183 break;
184 }
185 }
186 read_unlock(&GlobalSMBSeslock);
187 if (file->private_data != NULL) {
188 rc = 0;
189 FreeXid(xid);
190 return rc;
191 } else {
192 if (file->f_flags & O_EXCL)
193 cERROR(1, ("could not find file instance for "
194 "new file %p ", file));
195 }
196 }
197
198 down(&inode->i_sb->s_vfs_rename_sem);
199 full_path = build_path_from_dentry(file->f_dentry);
200 up(&inode->i_sb->s_vfs_rename_sem);
201 if (full_path == NULL) {
202 FreeXid(xid);
203 return -ENOMEM;
204 }
205
206 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
207 inode, file->f_flags, full_path));
208 desiredAccess = cifs_convert_flags(file->f_flags);
209
210 /*********************************************************************
211 * open flag mapping table:
212 *
213 * POSIX Flag CIFS Disposition
214 * ---------- ----------------
215 * O_CREAT FILE_OPEN_IF
216 * O_CREAT | O_EXCL FILE_CREATE
217 * O_CREAT | O_TRUNC FILE_OVERWRITE_IF
218 * O_TRUNC FILE_OVERWRITE
219 * none of the above FILE_OPEN
220 *
221 * Note that there is not a direct match between disposition
222 * FILE_SUPERSEDE (ie create whether or not file exists although
223 * O_CREAT | O_TRUNC is similar but truncates the existing
224 * file rather than creating a new file as FILE_SUPERSEDE does
225 * (which uses the attributes / metadata passed in on open call)
226 *?
227 *? O_SYNC is a reasonable match to CIFS writethrough flag
228 *? and the read write flags match reasonably. O_LARGEFILE
229 *? is irrelevant because largefile support is always used
230 *? by this client. Flags O_APPEND, O_DIRECT, O_DIRECTORY,
231 * O_FASYNC, O_NOFOLLOW, O_NONBLOCK need further investigation
232 *********************************************************************/
233
234 disposition = cifs_get_disposition(file->f_flags);
235
236 if (oplockEnabled)
237 oplock = REQ_OPLOCK;
238 else
239 oplock = FALSE;
240
241 /* BB pass O_SYNC flag through on file attributes .. BB */
242
243 /* Also refresh inode by passing in file_info buf returned by SMBOpen
244 and calling get_inode_info with returned buf (at least helps
245 non-Unix server case) */
246
247 /* BB we can not do this if this is the second open of a file
248 and the first handle has writebehind data, we might be
249 able to simply do a filemap_fdatawrite/filemap_fdatawait first */
250 buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
251 if (!buf) {
252 rc = -ENOMEM;
253 goto out;
254 }
255 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
256 CREATE_NOT_DIR, &netfid, &oplock, buf,
257 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags
258 & CIFS_MOUNT_MAP_SPECIAL_CHR);
259 if (rc) {
260 cFYI(1, ("cifs_open returned 0x%x ", rc));
261 goto out;
262 }
263 file->private_data =
264 kmalloc(sizeof(struct cifsFileInfo), GFP_KERNEL);
265 if (file->private_data == NULL) {
266 rc = -ENOMEM;
267 goto out;
268 }
269 pCifsFile = cifs_init_private(file->private_data, inode, file, netfid);
270 write_lock(&file->f_owner.lock);
271 write_lock(&GlobalSMBSeslock);
272 list_add(&pCifsFile->tlist, &pTcon->openFileList);
273
274 pCifsInode = CIFS_I(file->f_dentry->d_inode);
275 if (pCifsInode) {
276 rc = cifs_open_inode_helper(inode, file, pCifsInode,
277 pCifsFile, pTcon,
278 &oplock, buf, full_path, xid);
279 } else {
280 write_unlock(&GlobalSMBSeslock);
281 write_unlock(&file->f_owner.lock);
282 }
283
284 if (oplock & CIFS_CREATE_ACTION) {
285 /* time to set mode which we can not set earlier due to
286 problems creating new read-only files */
287 if (cifs_sb->tcon->ses->capabilities & CAP_UNIX) {
288 CIFSSMBUnixSetPerms(xid, pTcon, full_path,
289 inode->i_mode,
290 (__u64)-1, (__u64)-1, 0 /* dev */,
291 cifs_sb->local_nls,
292 cifs_sb->mnt_cifs_flags &
293 CIFS_MOUNT_MAP_SPECIAL_CHR);
294 } else {
295 /* BB implement via Windows security descriptors eg
296 CIFSSMBWinSetPerms(xid, pTcon, full_path, mode,
297 -1, -1, local_nls);
298 in the meantime could set r/o dos attribute when
299 perms are eg: mode & 0222 == 0 */
300 }
301 }
302
303 out:
304 kfree(buf);
305 kfree(full_path);
306 FreeXid(xid);
307 return rc;
308 }
309
310 /* Try to reaquire byte range locks that were released when session */
311 /* to server was lost */
312 static int cifs_relock_file(struct cifsFileInfo *cifsFile)
313 {
314 int rc = 0;
315
316 /* BB list all locks open on this file and relock */
317
318 return rc;
319 }
320
321 static int cifs_reopen_file(struct inode *inode, struct file *file,
322 int can_flush)
323 {
324 int rc = -EACCES;
325 int xid, oplock;
326 struct cifs_sb_info *cifs_sb;
327 struct cifsTconInfo *pTcon;
328 struct cifsFileInfo *pCifsFile;
329 struct cifsInodeInfo *pCifsInode;
330 char *full_path = NULL;
331 int desiredAccess;
332 int disposition = FILE_OPEN;
333 __u16 netfid;
334
335 if (inode == NULL)
336 return -EBADF;
337 if (file->private_data) {
338 pCifsFile = (struct cifsFileInfo *)file->private_data;
339 } else
340 return -EBADF;
341
342 xid = GetXid();
343 down(&pCifsFile->fh_sem);
344 if (pCifsFile->invalidHandle == FALSE) {
345 up(&pCifsFile->fh_sem);
346 FreeXid(xid);
347 return 0;
348 }
349
350 if (file->f_dentry == NULL) {
351 up(&pCifsFile->fh_sem);
352 cFYI(1, ("failed file reopen, no valid name if dentry freed"));
353 FreeXid(xid);
354 return -EBADF;
355 }
356 cifs_sb = CIFS_SB(inode->i_sb);
357 pTcon = cifs_sb->tcon;
358 /* can not grab rename sem here because various ops, including
359 those that already have the rename sem can end up causing writepage
360 to get called and if the server was down that means we end up here,
361 and we can never tell if the caller already has the rename_sem */
362 full_path = build_path_from_dentry(file->f_dentry);
363 if (full_path == NULL) {
364 up(&pCifsFile->fh_sem);
365 FreeXid(xid);
366 return -ENOMEM;
367 }
368
369 cFYI(1, (" inode = 0x%p file flags are 0x%x for %s",
370 inode, file->f_flags,full_path));
371 desiredAccess = cifs_convert_flags(file->f_flags);
372
373 if (oplockEnabled)
374 oplock = REQ_OPLOCK;
375 else
376 oplock = FALSE;
377
378 /* Can not refresh inode by passing in file_info buf to be returned
379 by SMBOpen and then calling get_inode_info with returned buf
380 since file might have write behind data that needs to be flushed
381 and server version of file size can be stale. If we knew for sure
382 that inode was not dirty locally we could do this */
383
384 /* buf = kmalloc(sizeof(FILE_ALL_INFO), GFP_KERNEL);
385 if (buf == 0) {
386 up(&pCifsFile->fh_sem);
387 kfree(full_path);
388 FreeXid(xid);
389 return -ENOMEM;
390 } */
391 rc = CIFSSMBOpen(xid, pTcon, full_path, disposition, desiredAccess,
392 CREATE_NOT_DIR, &netfid, &oplock, NULL,
393 cifs_sb->local_nls, cifs_sb->mnt_cifs_flags &
394 CIFS_MOUNT_MAP_SPECIAL_CHR);
395 if (rc) {
396 up(&pCifsFile->fh_sem);
397 cFYI(1, ("cifs_open returned 0x%x ", rc));
398 cFYI(1, ("oplock: %d ", oplock));
399 } else {
400 pCifsFile->netfid = netfid;
401 pCifsFile->invalidHandle = FALSE;
402 up(&pCifsFile->fh_sem);
403 pCifsInode = CIFS_I(inode);
404 if (pCifsInode) {
405 if (can_flush) {
406 filemap_fdatawrite(inode->i_mapping);
407 filemap_fdatawait(inode->i_mapping);
408 /* temporarily disable caching while we
409 go to server to get inode info */
410 pCifsInode->clientCanCacheAll = FALSE;
411 pCifsInode->clientCanCacheRead = FALSE;
412 if (pTcon->ses->capabilities & CAP_UNIX)
413 rc = cifs_get_inode_info_unix(&inode,
414 full_path, inode->i_sb, xid);
415 else
416 rc = cifs_get_inode_info(&inode,
417 full_path, NULL, inode->i_sb,
418 xid);
419 } /* else we are writing out data to server already
420 and could deadlock if we tried to flush data, and
421 since we do not know if we have data that would
422 invalidate the current end of file on the server
423 we can not go to the server to get the new inod
424 info */
425 if ((oplock & 0xF) == OPLOCK_EXCLUSIVE) {
426 pCifsInode->clientCanCacheAll = TRUE;
427 pCifsInode->clientCanCacheRead = TRUE;
428 cFYI(1, ("Exclusive Oplock granted on inode %p",
429 file->f_dentry->d_inode));
430 } else if ((oplock & 0xF) == OPLOCK_READ) {
431 pCifsInode->clientCanCacheRead = TRUE;
432 pCifsInode->clientCanCacheAll = FALSE;
433 } else {
434 pCifsInode->clientCanCacheRead = FALSE;
435 pCifsInode->clientCanCacheAll = FALSE;
436 }
437 cifs_relock_file(pCifsFile);
438 }
439 }
440
441 kfree(full_path);
442 FreeXid(xid);
443 return rc;
444 }
445
446 int cifs_close(struct inode *inode, struct file *file)
447 {
448 int rc = 0;
449 int xid;
450 struct cifs_sb_info *cifs_sb;
451 struct cifsTconInfo *pTcon;
452 struct cifsFileInfo *pSMBFile =
453 (struct cifsFileInfo *)file->private_data;
454
455 xid = GetXid();
456
457 cifs_sb = CIFS_SB(inode->i_sb);
458 pTcon = cifs_sb->tcon;
459 if (pSMBFile) {
460 pSMBFile->closePend = TRUE;
461 write_lock(&file->f_owner.lock);
462 if (pTcon) {
463 /* no sense reconnecting to close a file that is
464 already closed */
465 if (pTcon->tidStatus != CifsNeedReconnect) {
466 write_unlock(&file->f_owner.lock);
467 rc = CIFSSMBClose(xid, pTcon,
468 pSMBFile->netfid);
469 write_lock(&file->f_owner.lock);
470 }
471 }
472 write_lock(&GlobalSMBSeslock);
473 list_del(&pSMBFile->flist);
474 list_del(&pSMBFile->tlist);
475 write_unlock(&GlobalSMBSeslock);
476 write_unlock(&file->f_owner.lock);
477 kfree(pSMBFile->search_resume_name);
478 kfree(file->private_data);
479 file->private_data = NULL;
480 } else
481 rc = -EBADF;
482
483 if (list_empty(&(CIFS_I(inode)->openFileList))) {
484 cFYI(1, ("closing last open instance for inode %p", inode));
485 /* if the file is not open we do not know if we can cache info
486 on this inode, much less write behind and read ahead */
487 CIFS_I(inode)->clientCanCacheRead = FALSE;
488 CIFS_I(inode)->clientCanCacheAll = FALSE;
489 }
490 if ((rc ==0) && CIFS_I(inode)->write_behind_rc)
491 rc = CIFS_I(inode)->write_behind_rc;
492 FreeXid(xid);
493 return rc;
494 }
495
496 int cifs_closedir(struct inode *inode, struct file *file)
497 {
498 int rc = 0;
499 int xid;
500 struct cifsFileInfo *pCFileStruct =
501 (struct cifsFileInfo *)file->private_data;
502 char *ptmp;
503
504 cFYI(1, ("Closedir inode = 0x%p with ", inode));
505
506 xid = GetXid();
507
508 if (pCFileStruct) {
509 struct cifsTconInfo *pTcon;
510 struct cifs_sb_info *cifs_sb = CIFS_SB(file->f_dentry->d_sb);
511
512 pTcon = cifs_sb->tcon;
513
514 cFYI(1, ("Freeing private data in close dir"));
515 if ((pCFileStruct->srch_inf.endOfSearch == FALSE) &&
516 (pCFileStruct->invalidHandle == FALSE)) {
517 pCFileStruct->invalidHandle = TRUE;
518 rc = CIFSFindClose(xid, pTcon, pCFileStruct->netfid);
519 cFYI(1, ("Closing uncompleted readdir with rc %d",
520 rc));
521 /* not much we can do if it fails anyway, ignore rc */
522 rc = 0;
523 }
524 ptmp = pCFileStruct->srch_inf.ntwrk_buf_start;
525 if (ptmp) {
526 /* BB removeme BB */ cFYI(1, ("freeing smb buf in srch struct in closedir"));
527 pCFileStruct->srch_inf.ntwrk_buf_start = NULL;
528 cifs_buf_release(ptmp);
529 }
530 ptmp = pCFileStruct->search_resume_name;
531 if (ptmp) {
532 /* BB removeme BB */ cFYI(1, ("freeing resume name in closedir"));
533 pCFileStruct->search_resume_name = NULL;
534 kfree(ptmp);
535 }
536 kfree(file->private_data);
537 file->private_data = NULL;
538 }
539 /* BB can we lock the filestruct while this is going on? */
540 FreeXid(xid);
541 return rc;
542 }
543
544 int cifs_lock(struct file *file, int cmd, struct file_lock *pfLock)
545 {
546 int rc, xid;
547 __u32 lockType = LOCKING_ANDX_LARGE_FILES;
548 __u32 numLock = 0;
549 __u32 numUnlock = 0;
550 __u64 length;
551 int wait_flag = FALSE;
552 struct cifs_sb_info *cifs_sb;
553 struct cifsTconInfo *pTcon;
554
555 length = 1 + pfLock->fl_end - pfLock->fl_start;
556 rc = -EACCES;
557 xid = GetXid();
558
559 cFYI(1, ("Lock parm: 0x%x flockflags: "
560 "0x%x flocktype: 0x%x start: %lld end: %lld",
561 cmd, pfLock->fl_flags, pfLock->fl_type, pfLock->fl_start,
562 pfLock->fl_end));
563
564 if (pfLock->fl_flags & FL_POSIX)
565 cFYI(1, ("Posix "));
566 if (pfLock->fl_flags & FL_FLOCK)
567 cFYI(1, ("Flock "));
568 if (pfLock->fl_flags & FL_SLEEP) {
569 cFYI(1, ("Blocking lock "));
570 wait_flag = TRUE;
571 }
572 if (pfLock->fl_flags & FL_ACCESS)
573 cFYI(1, ("Process suspended by mandatory locking - "
574 "not implemented yet "));
575 if (pfLock->fl_flags & FL_LEASE)
576 cFYI(1, ("Lease on file - not implemented yet"));
577 if (pfLock->fl_flags &
578 (~(FL_POSIX | FL_FLOCK | FL_SLEEP | FL_ACCESS | FL_LEASE)))
579 cFYI(1, ("Unknown lock flags 0x%x", pfLock->fl_flags));
580
581 if (pfLock->fl_type == F_WRLCK) {
582 cFYI(1, ("F_WRLCK "));
583 numLock = 1;
584 } else if (pfLock->fl_type == F_UNLCK) {
585 cFYI(1, ("F_UNLCK "));
586 numUnlock = 1;
587 } else if (pfLock->fl_type == F_RDLCK) {
588 cFYI(1, ("F_RDLCK "));
589 lockType |= LOCKING_ANDX_SHARED_LOCK;
590 numLock = 1;
591 } else if (pfLock->fl_type == F_EXLCK) {
592 cFYI(1, ("F_EXLCK "));
593 numLock = 1;
594 } else if (pfLock->fl_type == F_SHLCK) {
595 cFYI(1, ("F_SHLCK "));
596 lockType |= LOCKING_ANDX_SHARED_LOCK;
597 numLock = 1;
598 } else
599 cFYI(1, ("Unknown type of lock "));
600
601 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
602 pTcon = cifs_sb->tcon;
603
604 if (file->private_data == NULL) {
605 FreeXid(xid);
606 return -EBADF;
607 }
608
609 if (IS_GETLK(cmd)) {
610 rc = CIFSSMBLock(xid, pTcon,
611 ((struct cifsFileInfo *)file->
612 private_data)->netfid,
613 length,
614 pfLock->fl_start, 0, 1, lockType,
615 0 /* wait flag */ );
616 if (rc == 0) {
617 rc = CIFSSMBLock(xid, pTcon,
618 ((struct cifsFileInfo *) file->
619 private_data)->netfid,
620 length,
621 pfLock->fl_start, 1 /* numUnlock */ ,
622 0 /* numLock */ , lockType,
623 0 /* wait flag */ );
624 pfLock->fl_type = F_UNLCK;
625 if (rc != 0)
626 cERROR(1, ("Error unlocking previously locked "
627 "range %d during test of lock ",
628 rc));
629 rc = 0;
630
631 } else {
632 /* if rc == ERR_SHARING_VIOLATION ? */
633 rc = 0; /* do not change lock type to unlock
634 since range in use */
635 }
636
637 FreeXid(xid);
638 return rc;
639 }
640
641 rc = CIFSSMBLock(xid, pTcon,
642 ((struct cifsFileInfo *) file->private_data)->
643 netfid, length,
644 pfLock->fl_start, numUnlock, numLock, lockType,
645 wait_flag);
646 if (rc == 0 && (pfLock->fl_flags & FL_POSIX))
647 posix_lock_file_wait(file, pfLock);
648 FreeXid(xid);
649 return rc;
650 }
651
652 ssize_t cifs_user_write(struct file *file, const char __user *write_data,
653 size_t write_size, loff_t *poffset)
654 {
655 int rc = 0;
656 unsigned int bytes_written = 0;
657 unsigned int total_written;
658 struct cifs_sb_info *cifs_sb;
659 struct cifsTconInfo *pTcon;
660 int xid, long_op;
661 struct cifsFileInfo *open_file;
662
663 if (file->f_dentry == NULL)
664 return -EBADF;
665
666 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
667 if (cifs_sb == NULL)
668 return -EBADF;
669
670 pTcon = cifs_sb->tcon;
671
672 /* cFYI(1,
673 (" write %d bytes to offset %lld of %s", write_size,
674 *poffset, file->f_dentry->d_name.name)); */
675
676 if (file->private_data == NULL)
677 return -EBADF;
678 else
679 open_file = (struct cifsFileInfo *) file->private_data;
680
681 xid = GetXid();
682 if (file->f_dentry->d_inode == NULL) {
683 FreeXid(xid);
684 return -EBADF;
685 }
686
687 if (*poffset > file->f_dentry->d_inode->i_size)
688 long_op = 2; /* writes past end of file can take a long time */
689 else
690 long_op = 1;
691
692 for (total_written = 0; write_size > total_written;
693 total_written += bytes_written) {
694 rc = -EAGAIN;
695 while (rc == -EAGAIN) {
696 if (file->private_data == NULL) {
697 /* file has been closed on us */
698 FreeXid(xid);
699 /* if we have gotten here we have written some data
700 and blocked, and the file has been freed on us while
701 we blocked so return what we managed to write */
702 return total_written;
703 }
704 if (open_file->closePend) {
705 FreeXid(xid);
706 if (total_written)
707 return total_written;
708 else
709 return -EBADF;
710 }
711 if (open_file->invalidHandle) {
712 if ((file->f_dentry == NULL) ||
713 (file->f_dentry->d_inode == NULL)) {
714 FreeXid(xid);
715 return total_written;
716 }
717 /* we could deadlock if we called
718 filemap_fdatawait from here so tell
719 reopen_file not to flush data to server
720 now */
721 rc = cifs_reopen_file(file->f_dentry->d_inode,
722 file, FALSE);
723 if (rc != 0)
724 break;
725 }
726
727 rc = CIFSSMBWrite(xid, pTcon,
728 open_file->netfid,
729 min_t(const int, cifs_sb->wsize,
730 write_size - total_written),
731 *poffset, &bytes_written,
732 NULL, write_data + total_written, long_op);
733 }
734 if (rc || (bytes_written == 0)) {
735 if (total_written)
736 break;
737 else {
738 FreeXid(xid);
739 return rc;
740 }
741 } else
742 *poffset += bytes_written;
743 long_op = FALSE; /* subsequent writes fast -
744 15 seconds is plenty */
745 }
746
747 #ifdef CONFIG_CIFS_STATS
748 if (total_written > 0) {
749 atomic_inc(&pTcon->num_writes);
750 spin_lock(&pTcon->stat_lock);
751 pTcon->bytes_written += total_written;
752 spin_unlock(&pTcon->stat_lock);
753 }
754 #endif
755
756 /* since the write may have blocked check these pointers again */
757 if (file->f_dentry) {
758 if (file->f_dentry->d_inode) {
759 struct inode *inode = file->f_dentry->d_inode;
760 inode->i_ctime = inode->i_mtime =
761 current_fs_time(inode->i_sb);
762 if (total_written > 0) {
763 if (*poffset > file->f_dentry->d_inode->i_size)
764 i_size_write(file->f_dentry->d_inode,
765 *poffset);
766 }
767 mark_inode_dirty_sync(file->f_dentry->d_inode);
768 }
769 }
770 FreeXid(xid);
771 return total_written;
772 }
773
774 static ssize_t cifs_write(struct file *file, const char *write_data,
775 size_t write_size, loff_t *poffset)
776 {
777 int rc = 0;
778 unsigned int bytes_written = 0;
779 unsigned int total_written;
780 struct cifs_sb_info *cifs_sb;
781 struct cifsTconInfo *pTcon;
782 int xid, long_op;
783 struct cifsFileInfo *open_file;
784
785 if (file->f_dentry == NULL)
786 return -EBADF;
787
788 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
789 if (cifs_sb == NULL)
790 return -EBADF;
791
792 pTcon = cifs_sb->tcon;
793
794 /* cFYI(1,
795 (" write %d bytes to offset %lld of %s", write_size,
796 *poffset, file->f_dentry->d_name.name)); */
797
798 if (file->private_data == NULL)
799 return -EBADF;
800 else
801 open_file = (struct cifsFileInfo *)file->private_data;
802
803 xid = GetXid();
804 if (file->f_dentry->d_inode == NULL) {
805 FreeXid(xid);
806 return -EBADF;
807 }
808
809 if (*poffset > file->f_dentry->d_inode->i_size)
810 long_op = 2; /* writes past end of file can take a long time */
811 else
812 long_op = 1;
813
814 for (total_written = 0; write_size > total_written;
815 total_written += bytes_written) {
816 rc = -EAGAIN;
817 while (rc == -EAGAIN) {
818 if (file->private_data == NULL) {
819 /* file has been closed on us */
820 FreeXid(xid);
821 /* if we have gotten here we have written some data
822 and blocked, and the file has been freed on us
823 while we blocked so return what we managed to
824 write */
825 return total_written;
826 }
827 if (open_file->closePend) {
828 FreeXid(xid);
829 if (total_written)
830 return total_written;
831 else
832 return -EBADF;
833 }
834 if (open_file->invalidHandle) {
835 if ((file->f_dentry == NULL) ||
836 (file->f_dentry->d_inode == NULL)) {
837 FreeXid(xid);
838 return total_written;
839 }
840 /* we could deadlock if we called
841 filemap_fdatawait from here so tell
842 reopen_file not to flush data to
843 server now */
844 rc = cifs_reopen_file(file->f_dentry->d_inode,
845 file, FALSE);
846 if (rc != 0)
847 break;
848 }
849
850 rc = CIFSSMBWrite(xid, pTcon,
851 open_file->netfid,
852 min_t(const int, cifs_sb->wsize,
853 write_size - total_written),
854 *poffset, &bytes_written,
855 write_data + total_written, NULL, long_op);
856 }
857 if (rc || (bytes_written == 0)) {
858 if (total_written)
859 break;
860 else {
861 FreeXid(xid);
862 return rc;
863 }
864 } else
865 *poffset += bytes_written;
866 long_op = FALSE; /* subsequent writes fast -
867 15 seconds is plenty */
868 }
869
870 #ifdef CONFIG_CIFS_STATS
871 if (total_written > 0) {
872 atomic_inc(&pTcon->num_writes);
873 spin_lock(&pTcon->stat_lock);
874 pTcon->bytes_written += total_written;
875 spin_unlock(&pTcon->stat_lock);
876 }
877 #endif
878
879 /* since the write may have blocked check these pointers again */
880 if (file->f_dentry) {
881 if (file->f_dentry->d_inode) {
882 file->f_dentry->d_inode->i_ctime =
883 file->f_dentry->d_inode->i_mtime = CURRENT_TIME;
884 if (total_written > 0) {
885 if (*poffset > file->f_dentry->d_inode->i_size)
886 i_size_write(file->f_dentry->d_inode,
887 *poffset);
888 }
889 mark_inode_dirty_sync(file->f_dentry->d_inode);
890 }
891 }
892 FreeXid(xid);
893 return total_written;
894 }
895
896 static int cifs_partialpagewrite(struct page *page, unsigned from, unsigned to)
897 {
898 struct address_space *mapping = page->mapping;
899 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
900 char *write_data;
901 int rc = -EFAULT;
902 int bytes_written = 0;
903 struct cifs_sb_info *cifs_sb;
904 struct cifsTconInfo *pTcon;
905 struct inode *inode;
906 struct cifsInodeInfo *cifsInode;
907 struct cifsFileInfo *open_file = NULL;
908 struct list_head *tmp;
909 struct list_head *tmp1;
910
911 if (!mapping || !mapping->host)
912 return -EFAULT;
913
914 inode = page->mapping->host;
915 cifs_sb = CIFS_SB(inode->i_sb);
916 pTcon = cifs_sb->tcon;
917
918 offset += (loff_t)from;
919 write_data = kmap(page);
920 write_data += from;
921
922 if ((to > PAGE_CACHE_SIZE) || (from > to)) {
923 kunmap(page);
924 return -EIO;
925 }
926
927 /* racing with truncate? */
928 if (offset > mapping->host->i_size) {
929 kunmap(page);
930 return 0; /* don't care */
931 }
932
933 /* check to make sure that we are not extending the file */
934 if (mapping->host->i_size - offset < (loff_t)to)
935 to = (unsigned)(mapping->host->i_size - offset);
936
937 cifsInode = CIFS_I(mapping->host);
938 read_lock(&GlobalSMBSeslock);
939 /* BB we should start at the end */
940 list_for_each_safe(tmp, tmp1, &cifsInode->openFileList) {
941 open_file = list_entry(tmp, struct cifsFileInfo, flist);
942 if (open_file->closePend)
943 continue;
944 /* We check if file is open for writing first */
945 if ((open_file->pfile) &&
946 ((open_file->pfile->f_flags & O_RDWR) ||
947 (open_file->pfile->f_flags & O_WRONLY))) {
948 read_unlock(&GlobalSMBSeslock);
949 bytes_written = cifs_write(open_file->pfile,
950 write_data, to-from,
951 &offset);
952 read_lock(&GlobalSMBSeslock);
953 /* Does mm or vfs already set times? */
954 inode->i_atime =
955 inode->i_mtime = current_fs_time(inode->i_sb);
956 if ((bytes_written > 0) && (offset)) {
957 rc = 0;
958 } else if (bytes_written < 0) {
959 if (rc == -EBADF) {
960 /* have seen a case in which kernel seemed to
961 have closed/freed a file even with writes
962 active so we might as well see if there are
963 other file structs to try for the same
964 inode before giving up */
965 continue;
966 } else
967 rc = bytes_written;
968 }
969 break; /* now that we found a valid file handle and
970 tried to write to it we are done, no sense
971 continuing to loop looking for another */
972 }
973 if (tmp->next == NULL) {
974 cFYI(1, ("File instance %p removed", tmp));
975 break;
976 }
977 }
978 read_unlock(&GlobalSMBSeslock);
979 if (open_file == NULL) {
980 cFYI(1, ("No writeable filehandles for inode"));
981 rc = -EIO;
982 }
983
984 kunmap(page);
985 return rc;
986 }
987
988 #if 0
989 static int cifs_writepages(struct address_space *mapping,
990 struct writeback_control *wbc)
991 {
992 int rc = -EFAULT;
993 int xid;
994
995 xid = GetXid();
996
997 /* Find contiguous pages then iterate through repeating
998 call 16K write then Setpageuptodate or if LARGE_WRITE_X
999 support then send larger writes via kevec so as to eliminate
1000 a memcpy */
1001 FreeXid(xid);
1002 return rc;
1003 }
1004 #endif
1005
1006 static int cifs_writepage(struct page* page, struct writeback_control *wbc)
1007 {
1008 int rc = -EFAULT;
1009 int xid;
1010
1011 xid = GetXid();
1012 /* BB add check for wbc flags */
1013 page_cache_get(page);
1014 if (!PageUptodate(page)) {
1015 cFYI(1, ("ppw - page not up to date"));
1016 }
1017
1018 rc = cifs_partialpagewrite(page, 0, PAGE_CACHE_SIZE);
1019 SetPageUptodate(page); /* BB add check for error and Clearuptodate? */
1020 unlock_page(page);
1021 page_cache_release(page);
1022 FreeXid(xid);
1023 return rc;
1024 }
1025
1026 static int cifs_commit_write(struct file *file, struct page *page,
1027 unsigned offset, unsigned to)
1028 {
1029 int xid;
1030 int rc = 0;
1031 struct inode *inode = page->mapping->host;
1032 loff_t position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + to;
1033 char *page_data;
1034
1035 xid = GetXid();
1036 cFYI(1, ("commit write for page %p up to position %lld for %d",
1037 page, position, to));
1038 if (position > inode->i_size) {
1039 i_size_write(inode, position);
1040 /* if (file->private_data == NULL) {
1041 rc = -EBADF;
1042 } else {
1043 open_file = (struct cifsFileInfo *)file->private_data;
1044 cifs_sb = CIFS_SB(inode->i_sb);
1045 rc = -EAGAIN;
1046 while (rc == -EAGAIN) {
1047 if ((open_file->invalidHandle) &&
1048 (!open_file->closePend)) {
1049 rc = cifs_reopen_file(
1050 file->f_dentry->d_inode, file);
1051 if (rc != 0)
1052 break;
1053 }
1054 if (!open_file->closePend) {
1055 rc = CIFSSMBSetFileSize(xid,
1056 cifs_sb->tcon, position,
1057 open_file->netfid,
1058 open_file->pid, FALSE);
1059 } else {
1060 rc = -EBADF;
1061 break;
1062 }
1063 }
1064 cFYI(1, (" SetEOF (commit write) rc = %d", rc));
1065 } */
1066 }
1067 if (!PageUptodate(page)) {
1068 position = ((loff_t)page->index << PAGE_CACHE_SHIFT) + offset;
1069 /* can not rely on (or let) writepage write this data */
1070 if (to < offset) {
1071 cFYI(1, ("Illegal offsets, can not copy from %d to %d",
1072 offset, to));
1073 FreeXid(xid);
1074 return rc;
1075 }
1076 /* this is probably better than directly calling
1077 partialpage_write since in this function the file handle is
1078 known which we might as well leverage */
1079 /* BB check if anything else missing out of ppw
1080 such as updating last write time */
1081 page_data = kmap(page);
1082 rc = cifs_write(file, page_data + offset, to-offset,
1083 &position);
1084 if (rc > 0)
1085 rc = 0;
1086 /* else if (rc < 0) should we set writebehind rc? */
1087 kunmap(page);
1088 } else {
1089 set_page_dirty(page);
1090 }
1091
1092 FreeXid(xid);
1093 return rc;
1094 }
1095
1096 int cifs_fsync(struct file *file, struct dentry *dentry, int datasync)
1097 {
1098 int xid;
1099 int rc = 0;
1100 struct inode *inode = file->f_dentry->d_inode;
1101
1102 xid = GetXid();
1103
1104 cFYI(1, ("Sync file - name: %s datasync: 0x%x ",
1105 dentry->d_name.name, datasync));
1106
1107 rc = filemap_fdatawrite(inode->i_mapping);
1108 if (rc == 0)
1109 CIFS_I(inode)->write_behind_rc = 0;
1110 FreeXid(xid);
1111 return rc;
1112 }
1113
1114 /* static int cifs_sync_page(struct page *page)
1115 {
1116 struct address_space *mapping;
1117 struct inode *inode;
1118 unsigned long index = page->index;
1119 unsigned int rpages = 0;
1120 int rc = 0;
1121
1122 cFYI(1, ("sync page %p",page));
1123 mapping = page->mapping;
1124 if (!mapping)
1125 return 0;
1126 inode = mapping->host;
1127 if (!inode)
1128 return 0; */
1129
1130 /* fill in rpages then
1131 result = cifs_pagein_inode(inode, index, rpages); */ /* BB finish */
1132
1133 /* cFYI(1, ("rpages is %d for sync page of Index %ld ", rpages, index));
1134
1135 if (rc < 0)
1136 return rc;
1137 return 0;
1138 } */
1139
1140 /*
1141 * As file closes, flush all cached write data for this inode checking
1142 * for write behind errors.
1143 */
1144 int cifs_flush(struct file *file)
1145 {
1146 struct inode * inode = file->f_dentry->d_inode;
1147 int rc = 0;
1148
1149 /* Rather than do the steps manually:
1150 lock the inode for writing
1151 loop through pages looking for write behind data (dirty pages)
1152 coalesce into contiguous 16K (or smaller) chunks to write to server
1153 send to server (prefer in parallel)
1154 deal with writebehind errors
1155 unlock inode for writing
1156 filemapfdatawrite appears easier for the time being */
1157
1158 rc = filemap_fdatawrite(inode->i_mapping);
1159 if (!rc) /* reset wb rc if we were able to write out dirty pages */
1160 CIFS_I(inode)->write_behind_rc = 0;
1161
1162 cFYI(1, ("Flush inode %p file %p rc %d",inode,file,rc));
1163
1164 return rc;
1165 }
1166
1167 ssize_t cifs_user_read(struct file *file, char __user *read_data,
1168 size_t read_size, loff_t *poffset)
1169 {
1170 int rc = -EACCES;
1171 unsigned int bytes_read = 0;
1172 unsigned int total_read = 0;
1173 unsigned int current_read_size;
1174 struct cifs_sb_info *cifs_sb;
1175 struct cifsTconInfo *pTcon;
1176 int xid;
1177 struct cifsFileInfo *open_file;
1178 char *smb_read_data;
1179 char __user *current_offset;
1180 struct smb_com_read_rsp *pSMBr;
1181
1182 xid = GetXid();
1183 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1184 pTcon = cifs_sb->tcon;
1185
1186 if (file->private_data == NULL) {
1187 FreeXid(xid);
1188 return -EBADF;
1189 }
1190 open_file = (struct cifsFileInfo *)file->private_data;
1191
1192 if ((file->f_flags & O_ACCMODE) == O_WRONLY) {
1193 cFYI(1, ("attempting read on write only file instance"));
1194 }
1195 for (total_read = 0, current_offset = read_data;
1196 read_size > total_read;
1197 total_read += bytes_read, current_offset += bytes_read) {
1198 current_read_size = min_t(const int, read_size - total_read,
1199 cifs_sb->rsize);
1200 rc = -EAGAIN;
1201 smb_read_data = NULL;
1202 while (rc == -EAGAIN) {
1203 if ((open_file->invalidHandle) &&
1204 (!open_file->closePend)) {
1205 rc = cifs_reopen_file(file->f_dentry->d_inode,
1206 file, TRUE);
1207 if (rc != 0)
1208 break;
1209 }
1210
1211 rc = CIFSSMBRead(xid, pTcon,
1212 open_file->netfid,
1213 current_read_size, *poffset,
1214 &bytes_read, &smb_read_data);
1215
1216 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1217 if (copy_to_user(current_offset,
1218 smb_read_data + 4 /* RFC1001 hdr */
1219 + le16_to_cpu(pSMBr->DataOffset),
1220 bytes_read)) {
1221 rc = -EFAULT;
1222 FreeXid(xid);
1223 return rc;
1224 }
1225 if (smb_read_data) {
1226 cifs_buf_release(smb_read_data);
1227 smb_read_data = NULL;
1228 }
1229 }
1230 if (rc || (bytes_read == 0)) {
1231 if (total_read) {
1232 break;
1233 } else {
1234 FreeXid(xid);
1235 return rc;
1236 }
1237 } else {
1238 #ifdef CONFIG_CIFS_STATS
1239 atomic_inc(&pTcon->num_reads);
1240 spin_lock(&pTcon->stat_lock);
1241 pTcon->bytes_read += total_read;
1242 spin_unlock(&pTcon->stat_lock);
1243 #endif
1244 *poffset += bytes_read;
1245 }
1246 }
1247 FreeXid(xid);
1248 return total_read;
1249 }
1250
1251
1252 static ssize_t cifs_read(struct file *file, char *read_data, size_t read_size,
1253 loff_t *poffset)
1254 {
1255 int rc = -EACCES;
1256 unsigned int bytes_read = 0;
1257 unsigned int total_read;
1258 unsigned int current_read_size;
1259 struct cifs_sb_info *cifs_sb;
1260 struct cifsTconInfo *pTcon;
1261 int xid;
1262 char *current_offset;
1263 struct cifsFileInfo *open_file;
1264
1265 xid = GetXid();
1266 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1267 pTcon = cifs_sb->tcon;
1268
1269 if (file->private_data == NULL) {
1270 FreeXid(xid);
1271 return -EBADF;
1272 }
1273 open_file = (struct cifsFileInfo *)file->private_data;
1274
1275 if ((file->f_flags & O_ACCMODE) == O_WRONLY)
1276 cFYI(1, ("attempting read on write only file instance"));
1277
1278 for (total_read = 0, current_offset = read_data;
1279 read_size > total_read;
1280 total_read += bytes_read, current_offset += bytes_read) {
1281 current_read_size = min_t(const int, read_size - total_read,
1282 cifs_sb->rsize);
1283 rc = -EAGAIN;
1284 while (rc == -EAGAIN) {
1285 if ((open_file->invalidHandle) &&
1286 (!open_file->closePend)) {
1287 rc = cifs_reopen_file(file->f_dentry->d_inode,
1288 file, TRUE);
1289 if (rc != 0)
1290 break;
1291 }
1292
1293 rc = CIFSSMBRead(xid, pTcon,
1294 open_file->netfid,
1295 current_read_size, *poffset,
1296 &bytes_read, &current_offset);
1297 }
1298 if (rc || (bytes_read == 0)) {
1299 if (total_read) {
1300 break;
1301 } else {
1302 FreeXid(xid);
1303 return rc;
1304 }
1305 } else {
1306 #ifdef CONFIG_CIFS_STATS
1307 atomic_inc(&pTcon->num_reads);
1308 spin_lock(&pTcon->stat_lock);
1309 pTcon->bytes_read += total_read;
1310 spin_unlock(&pTcon->stat_lock);
1311 #endif
1312 *poffset += bytes_read;
1313 }
1314 }
1315 FreeXid(xid);
1316 return total_read;
1317 }
1318
1319 int cifs_file_mmap(struct file *file, struct vm_area_struct *vma)
1320 {
1321 struct dentry *dentry = file->f_dentry;
1322 int rc, xid;
1323
1324 xid = GetXid();
1325 rc = cifs_revalidate(dentry);
1326 if (rc) {
1327 cFYI(1, ("Validation prior to mmap failed, error=%d", rc));
1328 FreeXid(xid);
1329 return rc;
1330 }
1331 rc = generic_file_mmap(file, vma);
1332 FreeXid(xid);
1333 return rc;
1334 }
1335
1336
1337 static void cifs_copy_cache_pages(struct address_space *mapping,
1338 struct list_head *pages, int bytes_read, char *data,
1339 struct pagevec *plru_pvec)
1340 {
1341 struct page *page;
1342 char *target;
1343
1344 while (bytes_read > 0) {
1345 if (list_empty(pages))
1346 break;
1347
1348 page = list_entry(pages->prev, struct page, lru);
1349 list_del(&page->lru);
1350
1351 if (add_to_page_cache(page, mapping, page->index,
1352 GFP_KERNEL)) {
1353 page_cache_release(page);
1354 cFYI(1, ("Add page cache failed"));
1355 continue;
1356 }
1357
1358 target = kmap_atomic(page,KM_USER0);
1359
1360 if (PAGE_CACHE_SIZE > bytes_read) {
1361 memcpy(target, data, bytes_read);
1362 /* zero the tail end of this partial page */
1363 memset(target + bytes_read, 0,
1364 PAGE_CACHE_SIZE - bytes_read);
1365 bytes_read = 0;
1366 } else {
1367 memcpy(target, data, PAGE_CACHE_SIZE);
1368 bytes_read -= PAGE_CACHE_SIZE;
1369 }
1370 kunmap_atomic(target, KM_USER0);
1371
1372 flush_dcache_page(page);
1373 SetPageUptodate(page);
1374 unlock_page(page);
1375 if (!pagevec_add(plru_pvec, page))
1376 __pagevec_lru_add(plru_pvec);
1377 data += PAGE_CACHE_SIZE;
1378 }
1379 return;
1380 }
1381
1382 static int cifs_readpages(struct file *file, struct address_space *mapping,
1383 struct list_head *page_list, unsigned num_pages)
1384 {
1385 int rc = -EACCES;
1386 int xid;
1387 loff_t offset;
1388 struct page *page;
1389 struct cifs_sb_info *cifs_sb;
1390 struct cifsTconInfo *pTcon;
1391 int bytes_read = 0;
1392 unsigned int read_size,i;
1393 char *smb_read_data = NULL;
1394 struct smb_com_read_rsp *pSMBr;
1395 struct pagevec lru_pvec;
1396 struct cifsFileInfo *open_file;
1397
1398 xid = GetXid();
1399 if (file->private_data == NULL) {
1400 FreeXid(xid);
1401 return -EBADF;
1402 }
1403 open_file = (struct cifsFileInfo *)file->private_data;
1404 cifs_sb = CIFS_SB(file->f_dentry->d_sb);
1405 pTcon = cifs_sb->tcon;
1406
1407 pagevec_init(&lru_pvec, 0);
1408
1409 for (i = 0; i < num_pages; ) {
1410 unsigned contig_pages;
1411 struct page *tmp_page;
1412 unsigned long expected_index;
1413
1414 if (list_empty(page_list))
1415 break;
1416
1417 page = list_entry(page_list->prev, struct page, lru);
1418 offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1419
1420 /* count adjacent pages that we will read into */
1421 contig_pages = 0;
1422 expected_index =
1423 list_entry(page_list->prev, struct page, lru)->index;
1424 list_for_each_entry_reverse(tmp_page,page_list,lru) {
1425 if (tmp_page->index == expected_index) {
1426 contig_pages++;
1427 expected_index++;
1428 } else
1429 break;
1430 }
1431 if (contig_pages + i > num_pages)
1432 contig_pages = num_pages - i;
1433
1434 /* for reads over a certain size could initiate async
1435 read ahead */
1436
1437 read_size = contig_pages * PAGE_CACHE_SIZE;
1438 /* Read size needs to be in multiples of one page */
1439 read_size = min_t(const unsigned int, read_size,
1440 cifs_sb->rsize & PAGE_CACHE_MASK);
1441
1442 rc = -EAGAIN;
1443 while (rc == -EAGAIN) {
1444 if ((open_file->invalidHandle) &&
1445 (!open_file->closePend)) {
1446 rc = cifs_reopen_file(file->f_dentry->d_inode,
1447 file, TRUE);
1448 if (rc != 0)
1449 break;
1450 }
1451
1452 rc = CIFSSMBRead(xid, pTcon,
1453 open_file->netfid,
1454 read_size, offset,
1455 &bytes_read, &smb_read_data);
1456 /* BB need to check return code here */
1457 if (rc== -EAGAIN) {
1458 if (smb_read_data) {
1459 cifs_buf_release(smb_read_data);
1460 smb_read_data = NULL;
1461 }
1462 }
1463 }
1464 if ((rc < 0) || (smb_read_data == NULL)) {
1465 cFYI(1, ("Read error in readpages: %d", rc));
1466 /* clean up remaing pages off list */
1467 while (!list_empty(page_list) && (i < num_pages)) {
1468 page = list_entry(page_list->prev, struct page,
1469 lru);
1470 list_del(&page->lru);
1471 page_cache_release(page);
1472 }
1473 break;
1474 } else if (bytes_read > 0) {
1475 pSMBr = (struct smb_com_read_rsp *)smb_read_data;
1476 cifs_copy_cache_pages(mapping, page_list, bytes_read,
1477 smb_read_data + 4 /* RFC1001 hdr */ +
1478 le16_to_cpu(pSMBr->DataOffset), &lru_pvec);
1479
1480 i += bytes_read >> PAGE_CACHE_SHIFT;
1481 #ifdef CONFIG_CIFS_STATS
1482 atomic_inc(&pTcon->num_reads);
1483 spin_lock(&pTcon->stat_lock);
1484 pTcon->bytes_read += bytes_read;
1485 spin_unlock(&pTcon->stat_lock);
1486 #endif
1487 if ((int)(bytes_read & PAGE_CACHE_MASK) != bytes_read) {
1488 i++; /* account for partial page */
1489
1490 /* server copy of file can have smaller size
1491 than client */
1492 /* BB do we need to verify this common case ?
1493 this case is ok - if we are at server EOF
1494 we will hit it on next read */
1495
1496 /* while (!list_empty(page_list) && (i < num_pages)) {
1497 page = list_entry(page_list->prev,
1498 struct page, list);
1499 list_del(&page->list);
1500 page_cache_release(page);
1501 }
1502 break; */
1503 }
1504 } else {
1505 cFYI(1, ("No bytes read (%d) at offset %lld . "
1506 "Cleaning remaining pages from readahead list",
1507 bytes_read, offset));
1508 /* BB turn off caching and do new lookup on
1509 file size at server? */
1510 while (!list_empty(page_list) && (i < num_pages)) {
1511 page = list_entry(page_list->prev, struct page,
1512 lru);
1513 list_del(&page->lru);
1514
1515 /* BB removeme - replace with zero of page? */
1516 page_cache_release(page);
1517 }
1518 break;
1519 }
1520 if (smb_read_data) {
1521 cifs_buf_release(smb_read_data);
1522 smb_read_data = NULL;
1523 }
1524 bytes_read = 0;
1525 }
1526
1527 pagevec_lru_add(&lru_pvec);
1528
1529 /* need to free smb_read_data buf before exit */
1530 if (smb_read_data) {
1531 cifs_buf_release(smb_read_data);
1532 smb_read_data = NULL;
1533 }
1534
1535 FreeXid(xid);
1536 return rc;
1537 }
1538
1539 static int cifs_readpage_worker(struct file *file, struct page *page,
1540 loff_t *poffset)
1541 {
1542 char *read_data;
1543 int rc;
1544
1545 page_cache_get(page);
1546 read_data = kmap(page);
1547 /* for reads over a certain size could initiate async read ahead */
1548
1549 rc = cifs_read(file, read_data, PAGE_CACHE_SIZE, poffset);
1550
1551 if (rc < 0)
1552 goto io_error;
1553 else
1554 cFYI(1, ("Bytes read %d ",rc));
1555
1556 file->f_dentry->d_inode->i_atime =
1557 current_fs_time(file->f_dentry->d_inode->i_sb);
1558
1559 if (PAGE_CACHE_SIZE > rc)
1560 memset(read_data + rc, 0, PAGE_CACHE_SIZE - rc);
1561
1562 flush_dcache_page(page);
1563 SetPageUptodate(page);
1564 rc = 0;
1565
1566 io_error:
1567 kunmap(page);
1568 page_cache_release(page);
1569 return rc;
1570 }
1571
1572 static int cifs_readpage(struct file *file, struct page *page)
1573 {
1574 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1575 int rc = -EACCES;
1576 int xid;
1577
1578 xid = GetXid();
1579
1580 if (file->private_data == NULL) {
1581 FreeXid(xid);
1582 return -EBADF;
1583 }
1584
1585 cFYI(1, ("readpage %p at offset %d 0x%x\n",
1586 page, (int)offset, (int)offset));
1587
1588 rc = cifs_readpage_worker(file, page, &offset);
1589
1590 unlock_page(page);
1591
1592 FreeXid(xid);
1593 return rc;
1594 }
1595
1596 /* We do not want to update the file size from server for inodes
1597 open for write - to avoid races with writepage extending
1598 the file - in the future we could consider allowing
1599 refreshing the inode only on increases in the file size
1600 but this is tricky to do without racing with writebehind
1601 page caching in the current Linux kernel design */
1602 int is_size_safe_to_change(struct cifsInodeInfo *cifsInode)
1603 {
1604 struct list_head *tmp;
1605 struct list_head *tmp1;
1606 struct cifsFileInfo *open_file = NULL;
1607 int rc = TRUE;
1608
1609 if (cifsInode == NULL)
1610 return rc;
1611
1612 read_lock(&GlobalSMBSeslock);
1613 list_for_each_safe(tmp, tmp1, &cifsInode->openFileList) {
1614 open_file = list_entry(tmp, struct cifsFileInfo, flist);
1615 if (open_file == NULL)
1616 break;
1617 if (open_file->closePend)
1618 continue;
1619 /* We check if file is open for writing,
1620 BB we could supplement this with a check to see if file size
1621 changes have been flushed to server - ie inode metadata dirty */
1622 if ((open_file->pfile) &&
1623 ((open_file->pfile->f_flags & O_RDWR) ||
1624 (open_file->pfile->f_flags & O_WRONLY))) {
1625 rc = FALSE;
1626 break;
1627 }
1628 if (tmp->next == NULL) {
1629 cFYI(1, ("File instance %p removed", tmp));
1630 break;
1631 }
1632 }
1633 read_unlock(&GlobalSMBSeslock);
1634 return rc;
1635 }
1636
1637
1638 static int cifs_prepare_write(struct file *file, struct page *page,
1639 unsigned from, unsigned to)
1640 {
1641 int rc = 0;
1642 loff_t offset = (loff_t)page->index << PAGE_CACHE_SHIFT;
1643 cFYI(1, ("prepare write for page %p from %d to %d",page,from,to));
1644 if (!PageUptodate(page)) {
1645 /* if (to - from != PAGE_CACHE_SIZE) {
1646 void *kaddr = kmap_atomic(page, KM_USER0);
1647 memset(kaddr, 0, from);
1648 memset(kaddr + to, 0, PAGE_CACHE_SIZE - to);
1649 flush_dcache_page(page);
1650 kunmap_atomic(kaddr, KM_USER0);
1651 } */
1652 /* If we are writing a full page it will be up to date,
1653 no need to read from the server */
1654 if ((to == PAGE_CACHE_SIZE) && (from == 0))
1655 SetPageUptodate(page);
1656
1657 /* might as well read a page, it is fast enough */
1658 if ((file->f_flags & O_ACCMODE) != O_WRONLY) {
1659 rc = cifs_readpage_worker(file, page, &offset);
1660 } else {
1661 /* should we try using another file handle if there is one -
1662 how would we lock it to prevent close of that handle
1663 racing with this read?
1664 In any case this will be written out by commit_write */
1665 }
1666 }
1667
1668 /* BB should we pass any errors back?
1669 e.g. if we do not have read access to the file */
1670 return 0;
1671 }
1672
1673 struct address_space_operations cifs_addr_ops = {
1674 .readpage = cifs_readpage,
1675 .readpages = cifs_readpages,
1676 .writepage = cifs_writepage,
1677 .prepare_write = cifs_prepare_write,
1678 .commit_write = cifs_commit_write,
1679 .set_page_dirty = __set_page_dirty_nobuffers,
1680 /* .sync_page = cifs_sync_page, */
1681 /* .direct_IO = */
1682 };
Verdex Pro support