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